@langchain/openai 0.0.27 → 0.0.28

package/dist/chat_models.cjs

@@ -48,12 +48,30 @@ function messageToOpenAIRole(message) {
 }
 exports.messageToOpenAIRole = messageToOpenAIRole;
 function openAIResponseToChatMessage(message) {
+    const rawToolCalls = message.tool_calls;
     switch (message.role) {
-        case "assistant":
-            return new messages_1.AIMessage(message.content || "", {
-                function_call: message.function_call,
-                tool_calls: message.tool_calls,
+        case "assistant": {
+            const toolCalls = [];
+            const invalidToolCalls = [];
+            for (const rawToolCall of rawToolCalls ?? []) {
+                try {
+                    toolCalls.push((0, openai_tools_1.parseToolCall)(rawToolCall, { returnId: true }));
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (e) {
+                    invalidToolCalls.push((0, openai_tools_1.makeInvalidToolCall)(rawToolCall, e.message));
+                }
+            }
+            return new messages_1.AIMessage({
+                content: message.content || "",
+                tool_calls: toolCalls,
+                invalid_tool_calls: invalidToolCalls,
+                additional_kwargs: {
+                    function_call: message.function_call,
+                    tool_calls: rawToolCalls,
+                },
             });
+        }
         default:
             return new messages_1.ChatMessage(message.content || "", message.role ?? "unknown");
     }
@@ -81,7 +99,22 @@ delta, defaultRole) {
         return new messages_1.HumanMessageChunk({ content });
     }
     else if (role === "assistant") {
-        return new messages_1.AIMessageChunk({ content, additional_kwargs });
+        const toolCallChunks = [];
+        if (Array.isArray(delta.tool_calls)) {
+            for (const rawToolCall of delta.tool_calls) {
+                toolCallChunks.push({
+                    name: rawToolCall.function?.name,
+                    args: rawToolCall.function?.arguments,
+                    id: rawToolCall.id,
+                    index: rawToolCall.index,
+                });
+            }
+        }
+        return new messages_1.AIMessageChunk({
+            content,
+            tool_call_chunks: toolCallChunks,
+            additional_kwargs,
+        });
     }
     else if (role === "system") {
         return new messages_1.SystemMessageChunk({ content });
@@ -118,11 +151,16 @@ function convertMessagesToOpenAIParams(messages) {
         if (message.additional_kwargs.function_call != null) {
             completionParam.function_call = message.additional_kwargs.function_call;
         }
-        if (message.additional_kwargs.tool_calls != null) {
-            completionParam.tool_calls = message.additional_kwargs.tool_calls;
+        if ((0, messages_1.isAIMessage)(message) && !!message.tool_calls?.length) {
+            completionParam.tool_calls = message.tool_calls.map(openai_tools_1.convertLangChainToolCallToOpenAI);
         }
-        if (message.tool_call_id != null) {
-            completionParam.tool_call_id = message.tool_call_id;
+        else {
+            if (message.additional_kwargs.tool_calls != null) {
+                completionParam.tool_calls = message.additional_kwargs.tool_calls;
+            }
+            if (message.tool_call_id != null) {
+                completionParam.tool_call_id = message.tool_call_id;
+            }
         }
         return completionParam;
     });
@@ -437,6 +475,12 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             ...fields?.configuration,
         };
     }
+    bindTools(tools, kwargs) {
+        return this.bind({
+            tools: tools.map(function_calling_1.convertToOpenAITool),
+            ...kwargs,
+        });
+    }
     /**
      * Get the parameters used to invoke the model
      */

package/dist/chat_models.d.ts

@@ -1,12 +1,12 @@
 import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
-import { type BaseMessage } from "@langchain/core/messages";
+import { AIMessageChunk, type BaseMessage } from "@langchain/core/messages";
 import { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
 import { type StructuredToolInterface } from "@langchain/core/tools";
 import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
 import type { BaseFunctionCallOptions, BaseLanguageModelInput, StructuredOutputMethodOptions, StructuredOutputMethodParams } from "@langchain/core/language_models/base";
 import { z } from "zod";
-import { Runnable } from "@langchain/core/runnables";
+import { Runnable, RunnableInterface } from "@langchain/core/runnables";
 import type { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput, OpenAICoreRequestOptions, LegacyOpenAIInput } from "./types.js";
 export type { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput };
 interface TokenUsage {
@@ -62,7 +62,7 @@ export interface ChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCa
  *
  * ```
  */
-export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatModel<CallOptions> implements OpenAIChatInput, AzureOpenAIInput {
+export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatModel<CallOptions, AIMessageChunk> implements OpenAIChatInput, AzureOpenAIInput {
     static lc_name(): string;
     get callKeys(): string[];
     lc_serializable: boolean;
@@ -102,6 +102,7 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
     }, 
     /** @deprecated */
     configuration?: ClientOptions & LegacyOpenAIInput);
+    bindTools(tools: (Record<string, unknown> | StructuredToolInterface)[], kwargs?: Partial<CallOptions>): RunnableInterface<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
     /**
      * Get the parameters used to invoke the model
      */

package/dist/chat_models.js

@@ -1,12 +1,12 @@
 import { OpenAI as OpenAIClient } from "openai";
-import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk, } from "@langchain/core/messages";
+import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk, isAIMessage, } from "@langchain/core/messages";
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
 import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
 import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
 import { JsonOutputParser, StructuredOutputParser, } from "@langchain/core/output_parsers";
-import { JsonOutputKeyToolsParser } from "@langchain/core/output_parsers/openai_tools";
+import { JsonOutputKeyToolsParser, convertLangChainToolCallToOpenAI, makeInvalidToolCall, parseToolCall, } from "@langchain/core/output_parsers/openai_tools";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { getEndpoint } from "./utils/azure.js";
 import { wrapOpenAIClientError } from "./utils/openai.js";
@@ -44,12 +44,30 @@ export function messageToOpenAIRole(message) {
     }
 }
 function openAIResponseToChatMessage(message) {
+    const rawToolCalls = message.tool_calls;
     switch (message.role) {
-        case "assistant":
-            return new AIMessage(message.content || "", {
-                function_call: message.function_call,
-                tool_calls: message.tool_calls,
+        case "assistant": {
+            const toolCalls = [];
+            const invalidToolCalls = [];
+            for (const rawToolCall of rawToolCalls ?? []) {
+                try {
+                    toolCalls.push(parseToolCall(rawToolCall, { returnId: true }));
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (e) {
+                    invalidToolCalls.push(makeInvalidToolCall(rawToolCall, e.message));
+                }
+            }
+            return new AIMessage({
+                content: message.content || "",
+                tool_calls: toolCalls,
+                invalid_tool_calls: invalidToolCalls,
+                additional_kwargs: {
+                    function_call: message.function_call,
+                    tool_calls: rawToolCalls,
+                },
             });
+        }
         default:
             return new ChatMessage(message.content || "", message.role ?? "unknown");
     }
@@ -77,7 +95,22 @@ delta, defaultRole) {
         return new HumanMessageChunk({ content });
     }
     else if (role === "assistant") {
-        return new AIMessageChunk({ content, additional_kwargs });
+        const toolCallChunks = [];
+        if (Array.isArray(delta.tool_calls)) {
+            for (const rawToolCall of delta.tool_calls) {
+                toolCallChunks.push({
+                    name: rawToolCall.function?.name,
+                    args: rawToolCall.function?.arguments,
+                    id: rawToolCall.id,
+                    index: rawToolCall.index,
+                });
+            }
+        }
+        return new AIMessageChunk({
+            content,
+            tool_call_chunks: toolCallChunks,
+            additional_kwargs,
+        });
     }
     else if (role === "system") {
         return new SystemMessageChunk({ content });
@@ -114,11 +147,16 @@ function convertMessagesToOpenAIParams(messages) {
         if (message.additional_kwargs.function_call != null) {
             completionParam.function_call = message.additional_kwargs.function_call;
         }
-        if (message.additional_kwargs.tool_calls != null) {
-            completionParam.tool_calls = message.additional_kwargs.tool_calls;
+        if (isAIMessage(message) && !!message.tool_calls?.length) {
+            completionParam.tool_calls = message.tool_calls.map(convertLangChainToolCallToOpenAI);
         }
-        if (message.tool_call_id != null) {
-            completionParam.tool_call_id = message.tool_call_id;
+        else {
+            if (message.additional_kwargs.tool_calls != null) {
+                completionParam.tool_calls = message.additional_kwargs.tool_calls;
+            }
+            if (message.tool_call_id != null) {
+                completionParam.tool_call_id = message.tool_call_id;
+            }
         }
         return completionParam;
     });
@@ -433,6 +471,12 @@ export class ChatOpenAI extends BaseChatModel {
             ...fields?.configuration,
         };
     }
+    bindTools(tools, kwargs) {
+        return this.bind({
+            tools: tools.map(convertToOpenAITool),
+            ...kwargs,
+        });
+    }
     /**
      * Get the parameters used to invoke the model
      */

package/dist/tests/chat_models-extended.int.test.js

@@ -1,5 +1,5 @@
 import { test, expect, jest } from "@jest/globals";
-import { HumanMessage, ToolMessage } from "@langchain/core/messages";
+import { AIMessage, HumanMessage, ToolMessage } from "@langchain/core/messages";
 import { InMemoryCache } from "@langchain/core/caches";
 import { ChatOpenAI } from "../chat_models.js";
 test("Test ChatOpenAI JSON mode", async () => {
@@ -60,7 +60,10 @@ test("Test ChatOpenAI tool calling", async () => {
         ["human", "What's the weather like in San Francisco, Tokyo, and Paris?"],
     ]);
     console.log(JSON.stringify(res));
-    expect(res.additional_kwargs.tool_calls?.length).toBeGreaterThan(1);
+    expect(res.additional_kwargs.tool_calls?.length).toEqual(3);
+    expect(res.tool_calls?.[0].args).toEqual(JSON.parse(res.additional_kwargs.tool_calls?.[0].function.arguments ?? "{}"));
+    expect(res.tool_calls?.[1].args).toEqual(JSON.parse(res.additional_kwargs.tool_calls?.[1].function.arguments ?? "{}"));
+    expect(res.tool_calls?.[2].args).toEqual(JSON.parse(res.additional_kwargs.tool_calls?.[2].function.arguments ?? "{}"));
 });
 test("Test ChatOpenAI streaming logprobs", async () => {
     const model = new ChatOpenAI({
@@ -203,3 +206,54 @@ test("ChatOpenAI in JSON mode can cache generations", async () => {
     lookupSpy.mockRestore();
     updateSpy.mockRestore();
 });
+test("Few shotting with tool calls", async () => {
+    const chat = new ChatOpenAI({
+        modelName: "gpt-3.5-turbo-1106",
+        temperature: 1,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "get_current_weather",
+                    description: "Get the current weather in a given location",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            location: {
+                                type: "string",
+                                description: "The city and state, e.g. San Francisco, CA",
+                            },
+                            unit: { type: "string", enum: ["celsius", "fahrenheit"] },
+                        },
+                        required: ["location"],
+                    },
+                },
+            },
+        ],
+        tool_choice: "auto",
+    });
+    const res = await chat.invoke([
+        new HumanMessage("What is the weather in SF?"),
+        new AIMessage({
+            content: "",
+            tool_calls: [
+                {
+                    id: "12345",
+                    name: "get_current_weather",
+                    args: {
+                        location: "SF",
+                    },
+                },
+            ],
+        }),
+        new ToolMessage({
+            tool_call_id: "12345",
+            content: "It is currently 24 degrees with hail in SF.",
+        }),
+        new AIMessage("It is currently 24 degrees in SF with hail in SF."),
+        new HumanMessage("What did you say the weather was?"),
+    ]);
+    console.log(res);
+    expect(res.content).toContain("24");
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/openai",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "description": "OpenAI integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -39,7 +39,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": "~0.1.45",
+    "@langchain/core": "~0.1.56",
     "js-tiktoken": "^1.0.7",
     "openai": "^4.32.1",
     "zod": "^3.22.4",