@langchain/core 0.1.55 → 0.1.56

package/dist/agents.d.ts

@@ -1,6 +1,6 @@
 export type AgentAction = {
     tool: string;
-    toolInput: string;
+    toolInput: string | Record<string, any>;
     log: string;
 };
 export type AgentFinish = {

package/dist/caches.d.ts

@@ -13,7 +13,7 @@ import { type StoredGeneration } from "./messages/index.js";
 export declare const getCacheKey: (...strings: string[]) => string;
 export declare function deserializeStoredGeneration(storedGeneration: StoredGeneration): {
     text: string;
-    message: import("./messages/index.js").ChatMessage | import("./messages/index.js").HumanMessage | import("./messages/index.js").AIMessage | import("./messages/index.js").SystemMessage | import("./messages/index.js").FunctionMessage | import("./messages/index.js").ToolMessage;
+    message: import("./messages/tool.js").ToolMessage | import("./messages/ai.js").AIMessage | import("./messages/chat.js").ChatMessage | import("./messages/function.js").FunctionMessage | import("./messages/human.js").HumanMessage | import("./messages/system.js").SystemMessage;
 } | {
     text: string;
     message?: undefined;

package/dist/language_models/chat_models.d.ts

@@ -5,6 +5,8 @@ import { BaseLanguageModel, type BaseLanguageModelCallOptions, type BaseLanguage
 import { type CallbackManagerForLLMRun, type Callbacks } from "../callbacks/manager.js";
 import type { RunnableConfig } from "../runnables/config.js";
 import type { BaseCache } from "../caches.js";
+import { StructuredToolInterface } from "../tools.js";
+import { RunnableInterface } from "../runnables/types.js";
 /**
  * Represents a serialized chat model.
  */
@@ -44,21 +46,30 @@ interface ChatModelGenerateCachedParameters<T extends BaseChatModel<CallOptions>
  * Base class for chat models. It extends the BaseLanguageModel class and
  * provides methods for generating chat based on input messages.
  */
-export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseLanguageModel<BaseMessageChunk, CallOptions> {
+export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions, OutputMessageType extends BaseMessageChunk = BaseMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {
     ParsedCallOptions: Omit<CallOptions, keyof RunnableConfig & "timeout">;
     lc_namespace: string[];
     constructor(fields: BaseChatModelParams);
     _combineLLMOutput?(...llmOutputs: LLMResult["llmOutput"][]): LLMResult["llmOutput"];
     protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
+    /**
+     * Bind tool-like objects to this chat model.
+     *
+     * @param tools A list of tool definitions to bind to this chat model.
+     * Can be a structured tool or an object matching the provider's
+     * specific tool schema.
+     * @param kwargs Any additional parameters to bind.
+     */
+    bindTools?(tools: (StructuredToolInterface | Record<string, unknown>)[], kwargs?: Partial<CallOptions>): RunnableInterface<BaseLanguageModelInput, OutputMessageType, CallOptions>;
     /**
      * Invokes the chat model with a single input.
      * @param input The input for the language model.
      * @param options The call options.
      * @returns A Promise that resolves to a BaseMessageChunk.
      */
-    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<BaseMessageChunk>;
+    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;
     _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<BaseMessageChunk>;
+    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;
     /** @ignore */
     _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig): Promise<LLMResult>;
     _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions, }: ChatModelGenerateCachedParameters<typeof this>): Promise<LLMResult & {

package/dist/messages/ai.cjs

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIMessageChunk = exports.isAIMessage = exports.AIMessage = void 0;
+const json_js_1 = require("../utils/json.cjs");
+const base_js_1 = require("./base.cjs");
+const tool_js_1 = require("./tool.cjs");
+/**
+ * Represents an AI message in a conversation.
+ */
+class AIMessage extends base_js_1.BaseMessage {
+    get lc_aliases() {
+        // exclude snake case conversion to pascal case
+        return {
+            ...super.lc_aliases,
+            tool_calls: "tool_calls",
+            invalid_tool_calls: "invalid_tool_calls",
+        };
+    }
+    constructor(fields, 
+    /** @deprecated */
+    kwargs) {
+        let initParams;
+        if (typeof fields === "string") {
+            initParams = {
+                content: fields,
+                tool_calls: [],
+                invalid_tool_calls: [],
+                additional_kwargs: kwargs ?? {},
+            };
+        }
+        else {
+            initParams = fields;
+            const rawToolCalls = initParams.additional_kwargs?.tool_calls;
+            const toolCalls = initParams.tool_calls;
+            if (rawToolCalls !== undefined &&
+                rawToolCalls.length > 0 &&
+                (toolCalls === undefined || toolCalls.length === 0)) {
+                console.warn([
+                    "New LangChain packages are available that more efficiently handle",
+                    "tool calling.\n\nPlease upgrade your packages to versions that set",
+                    "message tool calls. e.g., `yarn add @langchain/anthropic`,",
+                    "yarn add @langchain/openai`, etc.",
+                ].join(" "));
+            }
+            try {
+                if (rawToolCalls !== undefined && toolCalls === undefined) {
+                    const [toolCalls, invalidToolCalls] = (0, tool_js_1.defaultToolCallParser)(rawToolCalls);
+                    initParams.tool_calls = toolCalls ?? [];
+                    initParams.invalid_tool_calls = invalidToolCalls ?? [];
+                }
+                else {
+                    initParams.tool_calls = initParams.tool_calls ?? [];
+                    initParams.invalid_tool_calls = initParams.invalid_tool_calls ?? [];
+                }
+            }
+            catch (e) {
+                // Do nothing if parsing fails
+                initParams.tool_calls = [];
+                initParams.invalid_tool_calls = [];
+            }
+        }
+        // Sadly, TypeScript only allows super() calls at root if the class has
+        // properties with initializers, so we have to check types twice.
+        super(initParams);
+        // These are typed as optional to avoid breaking changes and allow for casting
+        // from BaseMessage.
+        Object.defineProperty(this, "tool_calls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "invalid_tool_calls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        if (typeof initParams !== "string") {
+            this.tool_calls = initParams.tool_calls ?? this.tool_calls;
+            this.invalid_tool_calls =
+                initParams.invalid_tool_calls ?? this.invalid_tool_calls;
+        }
+    }
+    static lc_name() {
+        return "AIMessage";
+    }
+    _getType() {
+        return "ai";
+    }
+}
+exports.AIMessage = AIMessage;
+function isAIMessage(x) {
+    return x._getType() === "ai";
+}
+exports.isAIMessage = isAIMessage;
+/**
+ * Represents a chunk of an AI message, which can be concatenated with
+ * other AI message chunks.
+ */
+class AIMessageChunk extends base_js_1.BaseMessageChunk {
+    constructor(fields) {
+        let initParams;
+        if (typeof fields === "string") {
+            initParams = {
+                content: fields,
+                tool_calls: [],
+                invalid_tool_calls: [],
+                tool_call_chunks: [],
+            };
+        }
+        else if (fields.tool_call_chunks === undefined) {
+            initParams = {
+                ...fields,
+                tool_calls: [],
+                invalid_tool_calls: [],
+                tool_call_chunks: [],
+            };
+        }
+        else {
+            const toolCalls = [];
+            const invalidToolCalls = [];
+            for (const toolCallChunk of fields.tool_call_chunks) {
+                let parsedArgs = {};
+                try {
+                    parsedArgs = (0, json_js_1.parsePartialJson)(toolCallChunk.args ?? "{}") ?? {};
+                    if (typeof parsedArgs !== "object" || Array.isArray(parsedArgs)) {
+                        throw new Error("Malformed tool call chunk args.");
+                    }
+                    toolCalls.push({
+                        name: toolCallChunk.name ?? "",
+                        args: parsedArgs,
+                        id: toolCallChunk.id,
+                    });
+                }
+                catch (e) {
+                    invalidToolCalls.push({
+                        name: toolCallChunk.name,
+                        args: toolCallChunk.args,
+                        id: toolCallChunk.id,
+                        error: "Malformed args.",
+                    });
+                }
+            }
+            initParams = {
+                ...fields,
+                tool_calls: toolCalls,
+                invalid_tool_calls: invalidToolCalls,
+            };
+        }
+        // Sadly, TypeScript only allows super() calls at root if the class has
+        // properties with initializers, so we have to check types twice.
+        super(initParams);
+        // Must redeclare tool call fields since there is no multiple inheritance in JS.
+        // These are typed as optional to avoid breaking changes and allow for casting
+        // from BaseMessage.
+        Object.defineProperty(this, "tool_calls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "invalid_tool_calls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "tool_call_chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.tool_call_chunks =
+            initParams?.tool_call_chunks ?? this.tool_call_chunks;
+        this.tool_calls = initParams?.tool_calls ?? this.tool_calls;
+        this.invalid_tool_calls =
+            initParams?.invalid_tool_calls ?? this.invalid_tool_calls;
+    }
+    get lc_aliases() {
+        // exclude snake case conversion to pascal case
+        return {
+            ...super.lc_aliases,
+            tool_calls: "tool_calls",
+            invalid_tool_calls: "invalid_tool_calls",
+            tool_call_chunks: "tool_call_chunks",
+        };
+    }
+    static lc_name() {
+        return "AIMessageChunk";
+    }
+    _getType() {
+        return "ai";
+    }
+    concat(chunk) {
+        const combinedFields = {
+            content: (0, base_js_1.mergeContent)(this.content, chunk.content),
+            additional_kwargs: (0, base_js_1._mergeDicts)(this.additional_kwargs, chunk.additional_kwargs),
+            response_metadata: (0, base_js_1._mergeDicts)(this.response_metadata, chunk.response_metadata),
+            tool_call_chunks: [],
+        };
+        if (this.tool_call_chunks !== undefined ||
+            chunk.tool_call_chunks !== undefined) {
+            const rawToolCalls = (0, base_js_1._mergeLists)(this.tool_call_chunks, chunk.tool_call_chunks);
+            if (rawToolCalls !== undefined && rawToolCalls.length > 0) {
+                combinedFields.tool_call_chunks = rawToolCalls;
+            }
+        }
+        return new AIMessageChunk(combinedFields);
+    }
+}
+exports.AIMessageChunk = AIMessageChunk;

package/dist/messages/ai.d.ts

@@ -0,0 +1,37 @@
+import { BaseMessage, BaseMessageChunk, type MessageType, BaseMessageFields } from "./base.js";
+import { InvalidToolCall, ToolCall, ToolCallChunk } from "./tool.js";
+export type AIMessageFields = BaseMessageFields & {
+    tool_calls?: ToolCall[];
+    invalid_tool_calls?: InvalidToolCall[];
+};
+/**
+ * Represents an AI message in a conversation.
+ */
+export declare class AIMessage extends BaseMessage {
+    tool_calls?: ToolCall[];
+    invalid_tool_calls?: InvalidToolCall[];
+    get lc_aliases(): Record<string, string>;
+    constructor(fields: string | AIMessageFields, 
+    /** @deprecated */
+    kwargs?: Record<string, unknown>);
+    static lc_name(): string;
+    _getType(): MessageType;
+}
+export declare function isAIMessage(x: BaseMessage): x is AIMessage;
+export type AIMessageChunkFields = AIMessageFields & {
+    tool_call_chunks?: ToolCallChunk[];
+};
+/**
+ * Represents a chunk of an AI message, which can be concatenated with
+ * other AI message chunks.
+ */
+export declare class AIMessageChunk extends BaseMessageChunk {
+    tool_calls?: ToolCall[];
+    invalid_tool_calls?: InvalidToolCall[];
+    tool_call_chunks?: ToolCallChunk[];
+    constructor(fields: string | AIMessageChunkFields);
+    get lc_aliases(): Record<string, string>;
+    static lc_name(): string;
+    _getType(): MessageType;
+    concat(chunk: AIMessageChunk): AIMessageChunk;
+}

package/dist/messages/ai.js

@@ -0,0 +1,207 @@
+import { parsePartialJson } from "../utils/json.js";
+import { BaseMessage, BaseMessageChunk, mergeContent, _mergeDicts, _mergeLists, } from "./base.js";
+import { defaultToolCallParser, } from "./tool.js";
+/**
+ * Represents an AI message in a conversation.
+ */
+export class AIMessage extends BaseMessage {
+    get lc_aliases() {
+        // exclude snake case conversion to pascal case
+        return {
+            ...super.lc_aliases,
+            tool_calls: "tool_calls",
+            invalid_tool_calls: "invalid_tool_calls",
+        };
+    }
+    constructor(fields, 
+    /** @deprecated */
+    kwargs) {
+        let initParams;
+        if (typeof fields === "string") {
+            initParams = {
+                content: fields,
+                tool_calls: [],
+                invalid_tool_calls: [],
+                additional_kwargs: kwargs ?? {},
+            };
+        }
+        else {
+            initParams = fields;
+            const rawToolCalls = initParams.additional_kwargs?.tool_calls;
+            const toolCalls = initParams.tool_calls;
+            if (rawToolCalls !== undefined &&
+                rawToolCalls.length > 0 &&
+                (toolCalls === undefined || toolCalls.length === 0)) {
+                console.warn([
+                    "New LangChain packages are available that more efficiently handle",
+                    "tool calling.\n\nPlease upgrade your packages to versions that set",
+                    "message tool calls. e.g., `yarn add @langchain/anthropic`,",
+                    "yarn add @langchain/openai`, etc.",
+                ].join(" "));
+            }
+            try {
+                if (rawToolCalls !== undefined && toolCalls === undefined) {
+                    const [toolCalls, invalidToolCalls] = defaultToolCallParser(rawToolCalls);
+                    initParams.tool_calls = toolCalls ?? [];
+                    initParams.invalid_tool_calls = invalidToolCalls ?? [];
+                }
+                else {
+                    initParams.tool_calls = initParams.tool_calls ?? [];
+                    initParams.invalid_tool_calls = initParams.invalid_tool_calls ?? [];
+                }
+            }
+            catch (e) {
+                // Do nothing if parsing fails
+                initParams.tool_calls = [];
+                initParams.invalid_tool_calls = [];
+            }
+        }
+        // Sadly, TypeScript only allows super() calls at root if the class has
+        // properties with initializers, so we have to check types twice.
+        super(initParams);
+        // These are typed as optional to avoid breaking changes and allow for casting
+        // from BaseMessage.
+        Object.defineProperty(this, "tool_calls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "invalid_tool_calls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        if (typeof initParams !== "string") {
+            this.tool_calls = initParams.tool_calls ?? this.tool_calls;
+            this.invalid_tool_calls =
+                initParams.invalid_tool_calls ?? this.invalid_tool_calls;
+        }
+    }
+    static lc_name() {
+        return "AIMessage";
+    }
+    _getType() {
+        return "ai";
+    }
+}
+export function isAIMessage(x) {
+    return x._getType() === "ai";
+}
+/**
+ * Represents a chunk of an AI message, which can be concatenated with
+ * other AI message chunks.
+ */
+export class AIMessageChunk extends BaseMessageChunk {
+    constructor(fields) {
+        let initParams;
+        if (typeof fields === "string") {
+            initParams = {
+                content: fields,
+                tool_calls: [],
+                invalid_tool_calls: [],
+                tool_call_chunks: [],
+            };
+        }
+        else if (fields.tool_call_chunks === undefined) {
+            initParams = {
+                ...fields,
+                tool_calls: [],
+                invalid_tool_calls: [],
+                tool_call_chunks: [],
+            };
+        }
+        else {
+            const toolCalls = [];
+            const invalidToolCalls = [];
+            for (const toolCallChunk of fields.tool_call_chunks) {
+                let parsedArgs = {};
+                try {
+                    parsedArgs = parsePartialJson(toolCallChunk.args ?? "{}") ?? {};
+                    if (typeof parsedArgs !== "object" || Array.isArray(parsedArgs)) {
+                        throw new Error("Malformed tool call chunk args.");
+                    }
+                    toolCalls.push({
+                        name: toolCallChunk.name ?? "",
+                        args: parsedArgs,
+                        id: toolCallChunk.id,
+                    });
+                }
+                catch (e) {
+                    invalidToolCalls.push({
+                        name: toolCallChunk.name,
+                        args: toolCallChunk.args,
+                        id: toolCallChunk.id,
+                        error: "Malformed args.",
+                    });
+                }
+            }
+            initParams = {
+                ...fields,
+                tool_calls: toolCalls,
+                invalid_tool_calls: invalidToolCalls,
+            };
+        }
+        // Sadly, TypeScript only allows super() calls at root if the class has
+        // properties with initializers, so we have to check types twice.
+        super(initParams);
+        // Must redeclare tool call fields since there is no multiple inheritance in JS.
+        // These are typed as optional to avoid breaking changes and allow for casting
+        // from BaseMessage.
+        Object.defineProperty(this, "tool_calls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "invalid_tool_calls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "tool_call_chunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.tool_call_chunks =
+            initParams?.tool_call_chunks ?? this.tool_call_chunks;
+        this.tool_calls = initParams?.tool_calls ?? this.tool_calls;
+        this.invalid_tool_calls =
+            initParams?.invalid_tool_calls ?? this.invalid_tool_calls;
+    }
+    get lc_aliases() {
+        // exclude snake case conversion to pascal case
+        return {
+            ...super.lc_aliases,
+            tool_calls: "tool_calls",
+            invalid_tool_calls: "invalid_tool_calls",
+            tool_call_chunks: "tool_call_chunks",
+        };
+    }
+    static lc_name() {
+        return "AIMessageChunk";
+    }
+    _getType() {
+        return "ai";
+    }
+    concat(chunk) {
+        const combinedFields = {
+            content: mergeContent(this.content, chunk.content),
+            additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
+            response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
+            tool_call_chunks: [],
+        };
+        if (this.tool_call_chunks !== undefined ||
+            chunk.tool_call_chunks !== undefined) {
+            const rawToolCalls = _mergeLists(this.tool_call_chunks, chunk.tool_call_chunks);
+            if (rawToolCalls !== undefined && rawToolCalls.length > 0) {
+                combinedFields.tool_call_chunks = rawToolCalls;
+            }
+        }
+        return new AIMessageChunk(combinedFields);
+    }
+}