all[minor]: Add support for openai tools in all tool calling models

.github/workflows/standard-tests.yml

@@ -13,6 +13,7 @@ jobs:
         package: [anthropic, cohere, google-genai, groq, mistralai]
     steps:
       - uses: actions/checkout@v4
+        if: contains(needs.get-changed-files.outputs.changed_files, 'langchain-core/') || contains(needs.get-changed-files.outputs.changed_files, 'libs/langchain-${{ matrix.package }}/')
       - name: Use Node.js 18.x
         uses: actions/setup-node@v3
         with:

langchain-core/.gitignore

@@ -214,6 +214,10 @@ utils/types.cjs
 utils/types.js
 utils/types.d.ts
 utils/types.d.cts
+utils/is_openai_tool.cjs
+utils/is_openai_tool.js
+utils/is_openai_tool.d.ts
+utils/is_openai_tool.d.cts
 vectorstores.cjs
 vectorstores.js
 vectorstores.d.ts

langchain-core/langchain.config.js

@@ -66,6 +66,7 @@ export const config = {
     "utils/testing": "utils/testing/index",
     "utils/tiktoken": "utils/tiktoken",
     "utils/types": "utils/types/index",
+    "utils/is_openai_tool": "utils/is_openai_tool",
     vectorstores: "vectorstores",
   },
   tsConfigPath: resolve("./tsconfig.json"),

langchain-core/package.json

@@ -581,6 +581,15 @@
       "import": "./utils/types.js",
       "require": "./utils/types.cjs"
     },
+    "./utils/is_openai_tool": {
+      "types": {
+        "import": "./utils/is_openai_tool.d.ts",
+        "require": "./utils/is_openai_tool.d.cts",
+        "default": "./utils/is_openai_tool.d.ts"
+      },
+      "import": "./utils/is_openai_tool.js",
+      "require": "./utils/is_openai_tool.cjs"
+    },
     "./vectorstores": {
       "types": {
         "import": "./vectorstores.d.ts",
@@ -810,6 +819,10 @@
     "utils/types.js",
     "utils/types.d.ts",
     "utils/types.d.cts",
+    "utils/is_openai_tool.cjs",
+    "utils/is_openai_tool.js",
+    "utils/is_openai_tool.d.ts",
+    "utils/is_openai_tool.d.cts",
     "vectorstores.cjs",
     "vectorstores.js",
     "vectorstores.d.ts",

langchain-core/src/utils/is_openai_tool.ts

@@ -0,0 +1,17 @@
+import { ToolDefinition } from "../language_models/base.js";
+
+export function isOpenAITool(tool: unknown): tool is ToolDefinition {
+  if (typeof tool !== "object" || !tool) return false;
+  if (
+    "type" in tool &&
+    tool.type === "function" &&
+    "function" in tool &&
+    typeof tool.function === "object" &&
+    tool.function &&
+    "name" in tool.function &&
+    "parameters" in tool.function
+  ) {
+    return true;
+  }
+  return false;
+}

libs/langchain-anthropic/package.json

@@ -35,7 +35,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.21.0",
+    "@anthropic-ai/sdk": "^0.22.0",
     "@langchain/core": ">=0.2.5 <0.3.0",
     "fast-xml-parser": "^4.3.5",
     "zod": "^3.22.4",

libs/langchain-anthropic/src/chat_models.ts

@@ -25,9 +25,10 @@ import {
   type BaseChatModelParams,
 } from "@langchain/core/language_models/chat_models";
 import {
-  StructuredOutputMethodOptions,
+  type StructuredOutputMethodOptions,
   type BaseLanguageModelCallOptions,
-  BaseLanguageModelInput,
+  type BaseLanguageModelInput,
+  type ToolDefinition,
 } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { zodToJsonSchema } from "zod-to-json-schema";
@@ -40,21 +41,17 @@ import {
 import { isZodSchema } from "@langchain/core/utils/types";
 import { ToolCall } from "@langchain/core/messages/tool";
 import { z } from "zod";
+import { isOpenAITool } from "@langchain/core/utils/is_openai_tool";
+import type {
+  MessageCreateParams,
+  Tool as AnthropicTool,
+} from "@anthropic-ai/sdk/resources/index.mjs";
 import {
   AnthropicToolsOutputParser,
   extractToolCalls,
 } from "./output_parsers.js";
 import { AnthropicToolResponse } from "./types.js";
 
-type AnthropicTool = {
-  name: string;
-  description: string;
-  /**
-   * JSON schema.
-   */
-  input_schema: Record<string, unknown>;
-};
-
 type AnthropicMessage = Anthropic.MessageParam;
 type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 type AnthropicStreamingMessageCreateParams =
@@ -71,7 +68,12 @@ type AnthropicToolChoice =
 export interface ChatAnthropicCallOptions
   extends BaseLanguageModelCallOptions,
     Pick<AnthropicInput, "streamUsage"> {
-  tools?: (StructuredToolInterface | AnthropicTool)[];
+  tools?: (
+    | StructuredToolInterface
+    | AnthropicTool
+    | Record<string, unknown>
+    | ToolDefinition
+  )[];
   /**
    * Whether or not to specify what tool the model should use
    * @default "auto"
@@ -562,22 +564,35 @@ export class ChatAnthropicMessages<
       return tools as AnthropicTool[];
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if ((tools as any[]).every((tool) => isOpenAITool(tool))) {
+      // Formatted as OpenAI tool, convert to Anthropic tool
+      return (tools as ToolDefinition[]).map((tc) => ({
+        name: tc.function.name,
+        description: tc.function.description,
+        input_schema: tc.function.parameters as AnthropicTool.InputSchema,
+      }));
+    }
+
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     if ((tools as any[]).some((tool) => isAnthropicTool(tool))) {
-      throw new Error(
-        `Can not pass in a mix of AnthropicTools and StructuredTools`
-      );
+      throw new Error(`Can not pass in a mix of tool schemas to ChatAnthropic`);
     }
 
     return (tools as StructuredToolInterface[]).map((tool) => ({
       name: tool.name,
       description: tool.description,
-      input_schema: zodToJsonSchema(tool.schema),
+      input_schema: zodToJsonSchema(tool.schema) as AnthropicTool.InputSchema,
     }));
   }
 
   override bindTools(
-    tools: (AnthropicTool | StructuredToolInterface)[],
+    tools: (
+      | AnthropicTool
+      | Record<string, unknown>
+      | StructuredToolInterface
+      | ToolDefinition
+    )[],
     kwargs?: Partial<CallOptions>
   ): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions> {
     return this.bind({
@@ -597,10 +612,9 @@ export class ChatAnthropicMessages<
   > &
     Kwargs {
     let tool_choice:
-      | {
-          type: string;
-          name?: string;
-        }
+      | MessageCreateParams.ToolChoiceAuto
+      | MessageCreateParams.ToolChoiceAny
+      | MessageCreateParams.ToolChoiceTool
       | undefined;
     if (options?.tool_choice) {
       if (options?.tool_choice === "any") {
@@ -739,7 +753,10 @@ export class ChatAnthropicMessages<
           if (data?.usage !== undefined) {
             usageData.output_tokens += data.usage.output_tokens;
           }
-        } else if (data.type === "content_block_delta") {
+        } else if (
+          data.type === "content_block_delta" &&
+          data.delta.type === "text_delta"
+        ) {
           const content = data.delta?.text;
           if (content !== undefined) {
             yield new ChatGenerationChunk({
@@ -976,7 +993,7 @@ export class ChatAnthropicMessages<
           name: functionName,
           description:
             jsonSchema.description ?? "A function available to call.",
-          input_schema: jsonSchema,
+          input_schema: jsonSchema as AnthropicTool.InputSchema,
         },
       ];
       outputParser = new AnthropicToolsOutputParser({
@@ -998,7 +1015,7 @@ export class ChatAnthropicMessages<
         anthropicTools = {
           name: functionName,
           description: schema.description ?? "",
-          input_schema: schema,
+          input_schema: schema as AnthropicTool.InputSchema,
         };
       }
       tools = [anthropicTools];

libs/langchain-anthropic/src/tests/chat_models-tools.int.test.ts

@@ -340,3 +340,25 @@ test("Can pass tool_choice", async () => {
   expect(input).toBeTruthy();
   expect(input.location).toBeTruthy();
 });
+
+test("bindTools accepts openai formatted tool", async () => {
+  const openaiTool = {
+    type: "function",
+    function: {
+      name: "get_weather",
+      description:
+        "Get the weather of a specific location and return the temperature in Celsius.",
+      parameters: zodToJsonSchema(zodSchema),
+    },
+  };
+  const modelWithTools = model.bindTools([openaiTool]);
+  const response = await modelWithTools.invoke(
+    "Whats the weather like in san francisco?"
+  );
+  expect(response.tool_calls).toHaveLength(1);
+  const { tool_calls } = response;
+  if (!tool_calls) {
+    return;
+  }
+  expect(tool_calls[0].name).toBe("get_weather");
+});