@langchain/anthropic 0.2.3 → 0.2.5

package/dist/chat_models.cjs

@@ -10,7 +10,12 @@ const base_1 = require("@langchain/core/language_models/base");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const runnables_1 = require("@langchain/core/runnables");
 const types_1 = require("@langchain/core/utils/types");
+const stream_1 = require("@langchain/core/utils/stream");
 const output_parsers_js_1 = require("./output_parsers.cjs");
+const utils_js_1 = require("./utils.cjs");
+function _toolsInParams(params) {
+    return !!(params.tools && params.tools.length > 0);
+}
 function _formatImage(imageUrl) {
     const regex = /^data:(image\/.+);base64,(.+)$/;
     const match = imageUrl.match(regex);
@@ -44,6 +49,8 @@ function anthropicResponseToChatMessages(messages, additionalKwargs) {
                     content: messages[0].text,
                     additional_kwargs: additionalKwargs,
                     usage_metadata: usageMetadata,
+                    response_metadata: additionalKwargs,
+                    id: additionalKwargs.id,
                 }),
             },
         ];
@@ -59,6 +66,8 @@ function anthropicResponseToChatMessages(messages, additionalKwargs) {
                     additional_kwargs: additionalKwargs,
                     tool_calls: toolCalls,
                     usage_metadata: usageMetadata,
+                    response_metadata: additionalKwargs,
+                    id: additionalKwargs.id,
                 }),
             },
         ];
@@ -69,6 +78,117 @@ function anthropicResponseToChatMessages(messages, additionalKwargs) {
 function isAnthropicTool(tool) {
     return "input_schema" in tool;
 }
+function _makeMessageChunkFromAnthropicEvent(data, fields) {
+    let usageDataCopy = { ...fields.usageData };
+    if (data.type === "message_start") {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { content, usage, ...additionalKwargs } = data.message;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const filteredAdditionalKwargs = {};
+        for (const [key, value] of Object.entries(additionalKwargs)) {
+            if (value !== undefined && value !== null) {
+                filteredAdditionalKwargs[key] = value;
+            }
+        }
+        usageDataCopy = usage;
+        let usageMetadata;
+        if (fields.streamUsage) {
+            usageMetadata = {
+                input_tokens: usage.input_tokens,
+                output_tokens: usage.output_tokens,
+                total_tokens: usage.input_tokens + usage.output_tokens,
+            };
+        }
+        console.log("data.message", data.message);
+        return {
+            chunk: new messages_1.AIMessageChunk({
+                content: fields.coerceContentToString ? "" : [],
+                additional_kwargs: filteredAdditionalKwargs,
+                usage_metadata: usageMetadata,
+                id: data.message.id,
+            }),
+            usageData: usageDataCopy,
+        };
+    }
+    else if (data.type === "message_delta") {
+        let usageMetadata;
+        if (fields.streamUsage) {
+            usageMetadata = {
+                input_tokens: data.usage.output_tokens,
+                output_tokens: 0,
+                total_tokens: data.usage.output_tokens,
+            };
+        }
+        if (data?.usage !== undefined) {
+            usageDataCopy.output_tokens += data.usage.output_tokens;
+        }
+        return {
+            chunk: new messages_1.AIMessageChunk({
+                content: fields.coerceContentToString ? "" : [],
+                additional_kwargs: { ...data.delta },
+                usage_metadata: usageMetadata,
+            }),
+            usageData: usageDataCopy,
+        };
+    }
+    else if (data.type === "content_block_start" &&
+        data.content_block.type === "tool_use") {
+        return {
+            chunk: new messages_1.AIMessageChunk({
+                content: fields.coerceContentToString
+                    ? ""
+                    : [
+                        {
+                            index: data.index,
+                            ...data.content_block,
+                            input: "",
+                        },
+                    ],
+                additional_kwargs: {},
+            }),
+            usageData: usageDataCopy,
+        };
+    }
+    else if (data.type === "content_block_delta" &&
+        data.delta.type === "text_delta") {
+        const content = data.delta?.text;
+        if (content !== undefined) {
+            return {
+                chunk: new messages_1.AIMessageChunk({
+                    content: fields.coerceContentToString
+                        ? content
+                        : [
+                            {
+                                index: data.index,
+                                ...data.delta,
+                            },
+                        ],
+                    additional_kwargs: {},
+                }),
+                usageData: usageDataCopy,
+            };
+        }
+    }
+    else if (data.type === "content_block_delta" &&
+        data.delta.type === "input_json_delta") {
+        return {
+            chunk: new messages_1.AIMessageChunk({
+                content: fields.coerceContentToString
+                    ? ""
+                    : [
+                        {
+                            index: data.index,
+                            input: data.delta.partial_json,
+                            type: data.delta.type,
+                        },
+                    ],
+                additional_kwargs: {},
+            }),
+            usageData: usageDataCopy,
+        };
+    }
+    return null;
+}
 function _mergeMessages(messages) {
     // Merge runs of human/tool messages into single human messages with content blocks.
     const merged = [];
@@ -243,6 +363,90 @@ function _formatMessagesForAnthropic(messages) {
         system,
     };
 }
+function extractToolCallChunk(chunk) {
+    let newToolCallChunk;
+    // Initial chunk for tool calls from anthropic contains identifying information like ID and name.
+    // This chunk does not contain any input JSON.
+    const toolUseChunks = Array.isArray(chunk.content)
+        ? chunk.content.find((c) => c.type === "tool_use")
+        : undefined;
+    if (toolUseChunks &&
+        "index" in toolUseChunks &&
+        "name" in toolUseChunks &&
+        "id" in toolUseChunks) {
+        newToolCallChunk = {
+            args: "",
+            id: toolUseChunks.id,
+            name: toolUseChunks.name,
+            index: toolUseChunks.index,
+            type: "tool_call_chunk",
+        };
+    }
+    // Chunks after the initial chunk only contain the index and partial JSON.
+    const inputJsonDeltaChunks = Array.isArray(chunk.content)
+        ? chunk.content.find((c) => c.type === "input_json_delta")
+        : undefined;
+    if (inputJsonDeltaChunks &&
+        "index" in inputJsonDeltaChunks &&
+        "input" in inputJsonDeltaChunks) {
+        if (typeof inputJsonDeltaChunks.input === "string") {
+            newToolCallChunk = {
+                args: inputJsonDeltaChunks.input,
+                index: inputJsonDeltaChunks.index,
+                type: "tool_call_chunk",
+            };
+        }
+        else {
+            newToolCallChunk = {
+                args: JSON.stringify(inputJsonDeltaChunks.input, null, 2),
+                index: inputJsonDeltaChunks.index,
+                type: "tool_call_chunk",
+            };
+        }
+    }
+    return newToolCallChunk;
+}
+function extractToken(chunk) {
+    return typeof chunk.content === "string" && chunk.content !== ""
+        ? chunk.content
+        : undefined;
+}
+function extractToolUseContent(chunk, concatenatedChunks) {
+    let newConcatenatedChunks = concatenatedChunks;
+    // Remove `tool_use` content types until the last chunk.
+    let toolUseContent;
+    if (!newConcatenatedChunks) {
+        newConcatenatedChunks = chunk;
+    }
+    else {
+        newConcatenatedChunks = (0, stream_1.concat)(newConcatenatedChunks, chunk);
+    }
+    if (Array.isArray(newConcatenatedChunks.content) &&
+        newConcatenatedChunks.content.find((c) => c.type === "tool_use")) {
+        try {
+            const toolUseMsg = newConcatenatedChunks.content.find((c) => c.type === "tool_use");
+            if (!toolUseMsg ||
+                !("input" in toolUseMsg || "name" in toolUseMsg || "id" in toolUseMsg))
+                return;
+            const parsedArgs = JSON.parse(toolUseMsg.input);
+            if (parsedArgs) {
+                toolUseContent = {
+                    type: "tool_use",
+                    id: toolUseMsg.id,
+                    name: toolUseMsg.name,
+                    input: parsedArgs,
+                };
+            }
+        }
+        catch (_) {
+            // no-op
+        }
+    }
+    return {
+        toolUseContent,
+        concatenatedChunks: newConcatenatedChunks,
+    };
+}
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -468,22 +672,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
      * Get the parameters used to invoke the model
      */
     invocationParams(options) {
-        let tool_choice;
-        if (options?.tool_choice) {
-            if (options?.tool_choice === "any") {
-                tool_choice = {
-                    type: "any",
-                };
-            }
-            else if (options?.tool_choice === "auto") {
-                tool_choice = {
-                    type: "auto",
-                };
-            }
-            else {
-                tool_choice = options?.tool_choice;
-            }
-        }
+        const tool_choice = (0, utils_js_1.handleToolChoice)(options?.tool_choice);
         return {
             model: this.model,
             temperature: this.temperature,
@@ -516,119 +705,83 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
     async *_streamResponseChunks(messages, options, runManager) {
         const params = this.invocationParams(options);
         const formattedMessages = _formatMessagesForAnthropic(messages);
-        if (options.tools !== undefined && options.tools.length > 0) {
-            const { generations } = await this._generateNonStreaming(messages, params, {
-                signal: options.signal,
-            });
-            const result = generations[0].message;
-            const toolCallChunks = result.tool_calls?.map((toolCall, index) => ({
-                name: toolCall.name,
-                args: JSON.stringify(toolCall.args),
-                id: toolCall.id,
-                index,
-            }));
-            yield new outputs_1.ChatGenerationChunk({
-                message: new messages_1.AIMessageChunk({
-                    content: result.content,
-                    additional_kwargs: result.additional_kwargs,
-                    tool_call_chunks: toolCallChunks,
-                }),
-                text: generations[0].text,
-            });
-        }
-        else {
-            const stream = await this.createStreamWithRetry({
-                ...params,
-                ...formattedMessages,
-                stream: true,
+        const coerceContentToString = !_toolsInParams({
+            ...params,
+            ...formattedMessages,
+            stream: false,
+        });
+        const stream = await this.createStreamWithRetry({
+            ...params,
+            ...formattedMessages,
+            stream: true,
+        });
+        let usageData = { input_tokens: 0, output_tokens: 0 };
+        let concatenatedChunks;
+        for await (const data of stream) {
+            if (options.signal?.aborted) {
+                stream.controller.abort();
+                throw new Error("AbortError: User aborted the request.");
+            }
+            const result = _makeMessageChunkFromAnthropicEvent(data, {
+                streamUsage: !!(this.streamUsage || options.streamUsage),
+                coerceContentToString,
+                usageData,
             });
-            let usageData = { input_tokens: 0, output_tokens: 0 };
-            for await (const data of stream) {
-                if (options.signal?.aborted) {
-                    stream.controller.abort();
-                    throw new Error("AbortError: User aborted the request.");
-                }
-                if (data.type === "message_start") {
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    const { content, usage, ...additionalKwargs } = data.message;
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const filteredAdditionalKwargs = {};
-                    for (const [key, value] of Object.entries(additionalKwargs)) {
-                        if (value !== undefined && value !== null) {
-                            filteredAdditionalKwargs[key] = value;
-                        }
-                    }
-                    usageData = usage;
-                    let usageMetadata;
-                    if (this.streamUsage || options.streamUsage) {
-                        usageMetadata = {
-                            input_tokens: usage.input_tokens,
-                            output_tokens: usage.output_tokens,
-                            total_tokens: usage.input_tokens + usage.output_tokens,
-                        };
-                    }
-                    yield new outputs_1.ChatGenerationChunk({
-                        message: new messages_1.AIMessageChunk({
-                            content: "",
-                            additional_kwargs: filteredAdditionalKwargs,
-                            usage_metadata: usageMetadata,
-                        }),
-                        text: "",
-                    });
-                }
-                else if (data.type === "message_delta") {
-                    let usageMetadata;
-                    if (this.streamUsage || options.streamUsage) {
-                        usageMetadata = {
-                            input_tokens: data.usage.output_tokens,
-                            output_tokens: 0,
-                            total_tokens: data.usage.output_tokens,
-                        };
-                    }
-                    yield new outputs_1.ChatGenerationChunk({
-                        message: new messages_1.AIMessageChunk({
-                            content: "",
-                            additional_kwargs: { ...data.delta },
-                            usage_metadata: usageMetadata,
-                        }),
-                        text: "",
-                    });
-                    if (data?.usage !== undefined) {
-                        usageData.output_tokens += data.usage.output_tokens;
-                    }
-                }
-                else if (data.type === "content_block_delta" &&
-                    data.delta.type === "text_delta") {
-                    const content = data.delta?.text;
-                    if (content !== undefined) {
-                        yield new outputs_1.ChatGenerationChunk({
-                            message: new messages_1.AIMessageChunk({
-                                content,
-                                additional_kwargs: {},
-                            }),
-                            text: content,
-                        });
-                        await runManager?.handleLLMNewToken(content);
-                    }
-                }
+            if (!result)
+                continue;
+            const { chunk, usageData: updatedUsageData } = result;
+            usageData = updatedUsageData;
+            const newToolCallChunk = extractToolCallChunk(chunk);
+            // Maintain concatenatedChunks for accessing the complete `tool_use` content block.
+            concatenatedChunks = concatenatedChunks
+                ? (0, stream_1.concat)(concatenatedChunks, chunk)
+                : chunk;
+            let toolUseContent;
+            const extractedContent = extractToolUseContent(chunk, concatenatedChunks);
+            if (extractedContent) {
+                toolUseContent = extractedContent.toolUseContent;
+                concatenatedChunks = extractedContent.concatenatedChunks;
             }
-            let usageMetadata;
-            if (this.streamUsage || options.streamUsage) {
-                usageMetadata = {
-                    input_tokens: usageData.input_tokens,
-                    output_tokens: usageData.output_tokens,
-                    total_tokens: usageData.input_tokens + usageData.output_tokens,
-                };
+            // Filter partial `tool_use` content, and only add `tool_use` chunks if complete JSON available.
+            const chunkContent = Array.isArray(chunk.content)
+                ? chunk.content.filter((c) => c.type !== "tool_use")
+                : chunk.content;
+            if (Array.isArray(chunkContent) && toolUseContent) {
+                chunkContent.push(toolUseContent);
             }
+            // Extract the text content token for text field and runManager.
+            const token = extractToken(chunk);
             yield new outputs_1.ChatGenerationChunk({
                 message: new messages_1.AIMessageChunk({
-                    content: "",
-                    additional_kwargs: { usage: usageData },
-                    usage_metadata: usageMetadata,
+                    content: chunkContent,
+                    additional_kwargs: chunk.additional_kwargs,
+                    tool_call_chunks: newToolCallChunk ? [newToolCallChunk] : undefined,
+                    usage_metadata: chunk.usage_metadata,
+                    response_metadata: chunk.response_metadata,
+                    id: chunk.id,
                 }),
-                text: "",
+                text: token ?? "",
             });
+            if (token) {
+                await runManager?.handleLLMNewToken(token);
+            }
         }
+        let usageMetadata;
+        if (this.streamUsage || options.streamUsage) {
+            usageMetadata = {
+                input_tokens: usageData.input_tokens,
+                output_tokens: usageData.output_tokens,
+                total_tokens: usageData.input_tokens + usageData.output_tokens,
+            };
+        }
+        yield new outputs_1.ChatGenerationChunk({
+            message: new messages_1.AIMessageChunk({
+                content: coerceContentToString ? "" : [],
+                additional_kwargs: { usage: usageData },
+                usage_metadata: usageMetadata,
+            }),
+            text: "",
+        });
     }
     /** @ignore */
     async _generateNonStreaming(messages, params, requestOptions) {

package/dist/chat_models.d.ts

@@ -3,24 +3,21 @@ import type { Stream } from "@anthropic-ai/sdk/streaming";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 import { AIMessageChunk, type BaseMessage } from "@langchain/core/messages";
 import { ChatGeneration, ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
-import { BaseChatModel, LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
-import { type StructuredOutputMethodOptions, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type ToolDefinition } from "@langchain/core/language_models/base";
+import { BaseChatModel, BaseChatModelCallOptions, LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+import { type StructuredOutputMethodOptions, type BaseLanguageModelInput, type ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
-import { Runnable } from "@langchain/core/runnables";
+import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { ToolCall } from "@langchain/core/messages/tool";
 import { z } from "zod";
 import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/index.mjs";
 import { AnthropicToolResponse } from "./types.js";
+import { AnthropicToolChoice, AnthropicToolTypes } from "./utils.js";
 type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
 type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
 type AnthropicRequestOptions = Anthropic.RequestOptions;
-type AnthropicToolChoice = {
-    type: "tool";
-    name: string;
-} | "any" | "auto";
-export interface ChatAnthropicCallOptions extends BaseLanguageModelCallOptions, Pick<AnthropicInput, "streamUsage"> {
-    tools?: (StructuredToolInterface | AnthropicTool | Record<string, unknown> | ToolDefinition)[];
+export interface ChatAnthropicCallOptions extends BaseChatModelCallOptions, Pick<AnthropicInput, "streamUsage"> {
+    tools?: AnthropicToolTypes[];
     /**
      * Whether or not to specify what tool the model should use
      * @default "auto"
@@ -150,7 +147,7 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
      * @throws {Error} If a mix of AnthropicTools and StructuredTools are passed.
      */
     formatStructuredToolToAnthropic(tools: ChatAnthropicCallOptions["tools"]): AnthropicTool[] | undefined;
-    bindTools(tools: (AnthropicTool | Record<string, unknown> | StructuredToolInterface | ToolDefinition)[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
+    bindTools(tools: (AnthropicTool | Record<string, unknown> | StructuredToolInterface | ToolDefinition | RunnableToolLike)[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
     /**
      * Get the parameters used to invoke the model
      */
@@ -163,8 +160,8 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
         temperature?: number | undefined;
         model: "claude-2.1" | (string & {}) | "claude-3-opus-20240229" | "claude-3-sonnet-20240229" | "claude-3-haiku-20240307" | "claude-2.0" | "claude-instant-1.2";
         system?: string | undefined;
-        stream?: boolean | undefined;
         max_tokens: number;
+        stream?: boolean | undefined;
         stop_sequences?: string[] | undefined;
         top_k?: number | undefined;
         top_p?: number | undefined;
@@ -180,8 +177,8 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
         temperature?: number | undefined;
         model: "claude-2.1" | (string & {}) | "claude-3-opus-20240229" | "claude-3-sonnet-20240229" | "claude-3-haiku-20240307" | "claude-2.0" | "claude-instant-1.2";
         system?: string | undefined;
-        stream?: boolean | undefined;
         max_tokens: number;
+        stream?: boolean | undefined;
         stop_sequences?: string[] | undefined;
         top_k?: number | undefined;
         top_p?: number | undefined;
@@ -194,7 +191,7 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
         llmOutput: {
             id: string;
             model: string;
-            stop_reason: "tool_use" | "max_tokens" | "stop_sequence" | "end_turn" | null;
+            stop_reason: "tool_use" | "stop_sequence" | "end_turn" | "max_tokens" | null;
             stop_sequence: string | null;
             usage: Anthropic.Messages.Usage;
         };

package/dist/chat_models.js

@@ -7,7 +7,12 @@ import { isOpenAITool, } from "@langchain/core/language_models/base";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
 import { isZodSchema } from "@langchain/core/utils/types";
+import { concat } from "@langchain/core/utils/stream";
 import { AnthropicToolsOutputParser, extractToolCalls, } from "./output_parsers.js";
+import { handleToolChoice, } from "./utils.js";
+function _toolsInParams(params) {
+    return !!(params.tools && params.tools.length > 0);
+}
 function _formatImage(imageUrl) {
     const regex = /^data:(image\/.+);base64,(.+)$/;
     const match = imageUrl.match(regex);
@@ -41,6 +46,8 @@ function anthropicResponseToChatMessages(messages, additionalKwargs) {
                     content: messages[0].text,
                     additional_kwargs: additionalKwargs,
                     usage_metadata: usageMetadata,
+                    response_metadata: additionalKwargs,
+                    id: additionalKwargs.id,
                 }),
             },
         ];
@@ -56,6 +63,8 @@ function anthropicResponseToChatMessages(messages, additionalKwargs) {
                     additional_kwargs: additionalKwargs,
                     tool_calls: toolCalls,
                     usage_metadata: usageMetadata,
+                    response_metadata: additionalKwargs,
+                    id: additionalKwargs.id,
                 }),
             },
         ];
@@ -66,6 +75,117 @@ function anthropicResponseToChatMessages(messages, additionalKwargs) {
 function isAnthropicTool(tool) {
     return "input_schema" in tool;
 }
+function _makeMessageChunkFromAnthropicEvent(data, fields) {
+    let usageDataCopy = { ...fields.usageData };
+    if (data.type === "message_start") {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { content, usage, ...additionalKwargs } = data.message;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const filteredAdditionalKwargs = {};
+        for (const [key, value] of Object.entries(additionalKwargs)) {
+            if (value !== undefined && value !== null) {
+                filteredAdditionalKwargs[key] = value;
+            }
+        }
+        usageDataCopy = usage;
+        let usageMetadata;
+        if (fields.streamUsage) {
+            usageMetadata = {
+                input_tokens: usage.input_tokens,
+                output_tokens: usage.output_tokens,
+                total_tokens: usage.input_tokens + usage.output_tokens,
+            };
+        }
+        console.log("data.message", data.message);
+        return {
+            chunk: new AIMessageChunk({
+                content: fields.coerceContentToString ? "" : [],
+                additional_kwargs: filteredAdditionalKwargs,
+                usage_metadata: usageMetadata,
+                id: data.message.id,
+            }),
+            usageData: usageDataCopy,
+        };
+    }
+    else if (data.type === "message_delta") {
+        let usageMetadata;
+        if (fields.streamUsage) {
+            usageMetadata = {
+                input_tokens: data.usage.output_tokens,
+                output_tokens: 0,
+                total_tokens: data.usage.output_tokens,
+            };
+        }
+        if (data?.usage !== undefined) {
+            usageDataCopy.output_tokens += data.usage.output_tokens;
+        }
+        return {
+            chunk: new AIMessageChunk({
+                content: fields.coerceContentToString ? "" : [],
+                additional_kwargs: { ...data.delta },
+                usage_metadata: usageMetadata,
+            }),
+            usageData: usageDataCopy,
+        };
+    }
+    else if (data.type === "content_block_start" &&
+        data.content_block.type === "tool_use") {
+        return {
+            chunk: new AIMessageChunk({
+                content: fields.coerceContentToString
+                    ? ""
+                    : [
+                        {
+                            index: data.index,
+                            ...data.content_block,
+                            input: "",
+                        },
+                    ],
+                additional_kwargs: {},
+            }),
+            usageData: usageDataCopy,
+        };
+    }
+    else if (data.type === "content_block_delta" &&
+        data.delta.type === "text_delta") {
+        const content = data.delta?.text;
+        if (content !== undefined) {
+            return {
+                chunk: new AIMessageChunk({
+                    content: fields.coerceContentToString
+                        ? content
+                        : [
+                            {
+                                index: data.index,
+                                ...data.delta,
+                            },
+                        ],
+                    additional_kwargs: {},
+                }),
+                usageData: usageDataCopy,
+            };
+        }
+    }
+    else if (data.type === "content_block_delta" &&
+        data.delta.type === "input_json_delta") {
+        return {
+            chunk: new AIMessageChunk({
+                content: fields.coerceContentToString
+                    ? ""
+                    : [
+                        {
+                            index: data.index,
+                            input: data.delta.partial_json,
+                            type: data.delta.type,
+                        },
+                    ],
+                additional_kwargs: {},
+            }),
+            usageData: usageDataCopy,
+        };
+    }
+    return null;
+}
 function _mergeMessages(messages) {
     // Merge runs of human/tool messages into single human messages with content blocks.
     const merged = [];
@@ -239,6 +359,90 @@ function _formatMessagesForAnthropic(messages) {
         system,
     };
 }
+function extractToolCallChunk(chunk) {
+    let newToolCallChunk;
+    // Initial chunk for tool calls from anthropic contains identifying information like ID and name.
+    // This chunk does not contain any input JSON.
+    const toolUseChunks = Array.isArray(chunk.content)
+        ? chunk.content.find((c) => c.type === "tool_use")
+        : undefined;
+    if (toolUseChunks &&
+        "index" in toolUseChunks &&
+        "name" in toolUseChunks &&
+        "id" in toolUseChunks) {
+        newToolCallChunk = {
+            args: "",
+            id: toolUseChunks.id,
+            name: toolUseChunks.name,
+            index: toolUseChunks.index,
+            type: "tool_call_chunk",
+        };
+    }
+    // Chunks after the initial chunk only contain the index and partial JSON.
+    const inputJsonDeltaChunks = Array.isArray(chunk.content)
+        ? chunk.content.find((c) => c.type === "input_json_delta")
+        : undefined;
+    if (inputJsonDeltaChunks &&
+        "index" in inputJsonDeltaChunks &&
+        "input" in inputJsonDeltaChunks) {
+        if (typeof inputJsonDeltaChunks.input === "string") {
+            newToolCallChunk = {
+                args: inputJsonDeltaChunks.input,
+                index: inputJsonDeltaChunks.index,
+                type: "tool_call_chunk",
+            };
+        }
+        else {
+            newToolCallChunk = {
+                args: JSON.stringify(inputJsonDeltaChunks.input, null, 2),
+                index: inputJsonDeltaChunks.index,
+                type: "tool_call_chunk",
+            };
+        }
+    }
+    return newToolCallChunk;
+}
+function extractToken(chunk) {
+    return typeof chunk.content === "string" && chunk.content !== ""
+        ? chunk.content
+        : undefined;
+}
+function extractToolUseContent(chunk, concatenatedChunks) {
+    let newConcatenatedChunks = concatenatedChunks;
+    // Remove `tool_use` content types until the last chunk.
+    let toolUseContent;
+    if (!newConcatenatedChunks) {
+        newConcatenatedChunks = chunk;
+    }
+    else {
+        newConcatenatedChunks = concat(newConcatenatedChunks, chunk);
+    }
+    if (Array.isArray(newConcatenatedChunks.content) &&
+        newConcatenatedChunks.content.find((c) => c.type === "tool_use")) {
+        try {
+            const toolUseMsg = newConcatenatedChunks.content.find((c) => c.type === "tool_use");
+            if (!toolUseMsg ||
+                !("input" in toolUseMsg || "name" in toolUseMsg || "id" in toolUseMsg))
+                return;
+            const parsedArgs = JSON.parse(toolUseMsg.input);
+            if (parsedArgs) {
+                toolUseContent = {
+                    type: "tool_use",
+                    id: toolUseMsg.id,
+                    name: toolUseMsg.name,
+                    input: parsedArgs,
+                };
+            }
+        }
+        catch (_) {
+            // no-op
+        }
+    }
+    return {
+        toolUseContent,
+        concatenatedChunks: newConcatenatedChunks,
+    };
+}
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -464,22 +668,7 @@ export class ChatAnthropicMessages extends BaseChatModel {
      * Get the parameters used to invoke the model
      */
     invocationParams(options) {
-        let tool_choice;
-        if (options?.tool_choice) {
-            if (options?.tool_choice === "any") {
-                tool_choice = {
-                    type: "any",
-                };
-            }
-            else if (options?.tool_choice === "auto") {
-                tool_choice = {
-                    type: "auto",
-                };
-            }
-            else {
-                tool_choice = options?.tool_choice;
-            }
-        }
+        const tool_choice = handleToolChoice(options?.tool_choice);
         return {
             model: this.model,
             temperature: this.temperature,
@@ -512,119 +701,83 @@ export class ChatAnthropicMessages extends BaseChatModel {
     async *_streamResponseChunks(messages, options, runManager) {
         const params = this.invocationParams(options);
         const formattedMessages = _formatMessagesForAnthropic(messages);
-        if (options.tools !== undefined && options.tools.length > 0) {
-            const { generations } = await this._generateNonStreaming(messages, params, {
-                signal: options.signal,
-            });
-            const result = generations[0].message;
-            const toolCallChunks = result.tool_calls?.map((toolCall, index) => ({
-                name: toolCall.name,
-                args: JSON.stringify(toolCall.args),
-                id: toolCall.id,
-                index,
-            }));
-            yield new ChatGenerationChunk({
-                message: new AIMessageChunk({
-                    content: result.content,
-                    additional_kwargs: result.additional_kwargs,
-                    tool_call_chunks: toolCallChunks,
-                }),
-                text: generations[0].text,
-            });
-        }
-        else {
-            const stream = await this.createStreamWithRetry({
-                ...params,
-                ...formattedMessages,
-                stream: true,
+        const coerceContentToString = !_toolsInParams({
+            ...params,
+            ...formattedMessages,
+            stream: false,
+        });
+        const stream = await this.createStreamWithRetry({
+            ...params,
+            ...formattedMessages,
+            stream: true,
+        });
+        let usageData = { input_tokens: 0, output_tokens: 0 };
+        let concatenatedChunks;
+        for await (const data of stream) {
+            if (options.signal?.aborted) {
+                stream.controller.abort();
+                throw new Error("AbortError: User aborted the request.");
+            }
+            const result = _makeMessageChunkFromAnthropicEvent(data, {
+                streamUsage: !!(this.streamUsage || options.streamUsage),
+                coerceContentToString,
+                usageData,
             });
-            let usageData = { input_tokens: 0, output_tokens: 0 };
-            for await (const data of stream) {
-                if (options.signal?.aborted) {
-                    stream.controller.abort();
-                    throw new Error("AbortError: User aborted the request.");
-                }
-                if (data.type === "message_start") {
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    const { content, usage, ...additionalKwargs } = data.message;
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const filteredAdditionalKwargs = {};
-                    for (const [key, value] of Object.entries(additionalKwargs)) {
-                        if (value !== undefined && value !== null) {
-                            filteredAdditionalKwargs[key] = value;
-                        }
-                    }
-                    usageData = usage;
-                    let usageMetadata;
-                    if (this.streamUsage || options.streamUsage) {
-                        usageMetadata = {
-                            input_tokens: usage.input_tokens,
-                            output_tokens: usage.output_tokens,
-                            total_tokens: usage.input_tokens + usage.output_tokens,
-                        };
-                    }
-                    yield new ChatGenerationChunk({
-                        message: new AIMessageChunk({
-                            content: "",
-                            additional_kwargs: filteredAdditionalKwargs,
-                            usage_metadata: usageMetadata,
-                        }),
-                        text: "",
-                    });
-                }
-                else if (data.type === "message_delta") {
-                    let usageMetadata;
-                    if (this.streamUsage || options.streamUsage) {
-                        usageMetadata = {
-                            input_tokens: data.usage.output_tokens,
-                            output_tokens: 0,
-                            total_tokens: data.usage.output_tokens,
-                        };
-                    }
-                    yield new ChatGenerationChunk({
-                        message: new AIMessageChunk({
-                            content: "",
-                            additional_kwargs: { ...data.delta },
-                            usage_metadata: usageMetadata,
-                        }),
-                        text: "",
-                    });
-                    if (data?.usage !== undefined) {
-                        usageData.output_tokens += data.usage.output_tokens;
-                    }
-                }
-                else if (data.type === "content_block_delta" &&
-                    data.delta.type === "text_delta") {
-                    const content = data.delta?.text;
-                    if (content !== undefined) {
-                        yield new ChatGenerationChunk({
-                            message: new AIMessageChunk({
-                                content,
-                                additional_kwargs: {},
-                            }),
-                            text: content,
-                        });
-                        await runManager?.handleLLMNewToken(content);
-                    }
-                }
+            if (!result)
+                continue;
+            const { chunk, usageData: updatedUsageData } = result;
+            usageData = updatedUsageData;
+            const newToolCallChunk = extractToolCallChunk(chunk);
+            // Maintain concatenatedChunks for accessing the complete `tool_use` content block.
+            concatenatedChunks = concatenatedChunks
+                ? concat(concatenatedChunks, chunk)
+                : chunk;
+            let toolUseContent;
+            const extractedContent = extractToolUseContent(chunk, concatenatedChunks);
+            if (extractedContent) {
+                toolUseContent = extractedContent.toolUseContent;
+                concatenatedChunks = extractedContent.concatenatedChunks;
             }
-            let usageMetadata;
-            if (this.streamUsage || options.streamUsage) {
-                usageMetadata = {
-                    input_tokens: usageData.input_tokens,
-                    output_tokens: usageData.output_tokens,
-                    total_tokens: usageData.input_tokens + usageData.output_tokens,
-                };
+            // Filter partial `tool_use` content, and only add `tool_use` chunks if complete JSON available.
+            const chunkContent = Array.isArray(chunk.content)
+                ? chunk.content.filter((c) => c.type !== "tool_use")
+                : chunk.content;
+            if (Array.isArray(chunkContent) && toolUseContent) {
+                chunkContent.push(toolUseContent);
             }
+            // Extract the text content token for text field and runManager.
+            const token = extractToken(chunk);
             yield new ChatGenerationChunk({
                 message: new AIMessageChunk({
-                    content: "",
-                    additional_kwargs: { usage: usageData },
-                    usage_metadata: usageMetadata,
+                    content: chunkContent,
+                    additional_kwargs: chunk.additional_kwargs,
+                    tool_call_chunks: newToolCallChunk ? [newToolCallChunk] : undefined,
+                    usage_metadata: chunk.usage_metadata,
+                    response_metadata: chunk.response_metadata,
+                    id: chunk.id,
                 }),
-                text: "",
+                text: token ?? "",
             });
+            if (token) {
+                await runManager?.handleLLMNewToken(token);
+            }
         }
+        let usageMetadata;
+        if (this.streamUsage || options.streamUsage) {
+            usageMetadata = {
+                input_tokens: usageData.input_tokens,
+                output_tokens: usageData.output_tokens,
+                total_tokens: usageData.input_tokens + usageData.output_tokens,
+            };
+        }
+        yield new ChatGenerationChunk({
+            message: new AIMessageChunk({
+                content: coerceContentToString ? "" : [],
+                additional_kwargs: { usage: usageData },
+                usage_metadata: usageMetadata,
+            }),
+            text: "",
+        });
     }
     /** @ignore */
     async _generateNonStreaming(messages, params, requestOptions) {

package/dist/output_parsers.cjs

@@ -79,7 +79,12 @@ function extractToolCalls(content) {
     const toolCalls = [];
     for (const block of content) {
         if (block.type === "tool_use") {
-            toolCalls.push({ name: block.name, args: block.input, id: block.id });
+            toolCalls.push({
+                name: block.name,
+                args: block.input,
+                id: block.id,
+                type: "tool_call",
+            });
         }
     }
     return toolCalls;

package/dist/output_parsers.js

@@ -75,7 +75,12 @@ export function extractToolCalls(content) {
     const toolCalls = [];
     for (const block of content) {
         if (block.type === "tool_use") {
-            toolCalls.push({ name: block.name, args: block.input, id: block.id });
+            toolCalls.push({
+                name: block.name,
+                args: block.input,
+                id: block.id,
+                type: "tool_call",
+            });
         }
     }
     return toolCalls;

package/dist/utils.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleToolChoice = void 0;
+function handleToolChoice(toolChoice) {
+    if (!toolChoice) {
+        return undefined;
+    }
+    else if (toolChoice === "any") {
+        return {
+            type: "any",
+        };
+    }
+    else if (toolChoice === "auto") {
+        return {
+            type: "auto",
+        };
+    }
+    else if (typeof toolChoice === "string") {
+        return {
+            type: "tool",
+            name: toolChoice,
+        };
+    }
+    else {
+        return toolChoice;
+    }
+}
+exports.handleToolChoice = handleToolChoice;

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import type { MessageCreateParams, Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/index.mjs";
+import { ToolDefinition } from "@langchain/core/language_models/base";
+import { RunnableToolLike } from "@langchain/core/runnables";
+import { StructuredToolInterface } from "@langchain/core/tools";
+export type AnthropicToolChoice = {
+    type: "tool";
+    name: string;
+} | "any" | "auto" | "none" | string;
+export type AnthropicToolTypes = StructuredToolInterface | AnthropicTool | Record<string, unknown> | ToolDefinition | RunnableToolLike;
+export declare function handleToolChoice(toolChoice?: AnthropicToolChoice): MessageCreateParams.ToolChoiceAuto | MessageCreateParams.ToolChoiceAny | MessageCreateParams.ToolChoiceTool | undefined;

package/dist/utils.js

@@ -0,0 +1,24 @@
+export function handleToolChoice(toolChoice) {
+    if (!toolChoice) {
+        return undefined;
+    }
+    else if (toolChoice === "any") {
+        return {
+            type: "any",
+        };
+    }
+    else if (toolChoice === "auto") {
+        return {
+            type: "auto",
+        };
+    }
+    else if (typeof toolChoice === "string") {
+        return {
+            type: "tool",
+            name: toolChoice,
+        };
+    }
+    else {
+        return toolChoice;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/anthropic",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Anthropic integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -36,7 +36,7 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.22.0",
-    "@langchain/core": ">=0.2.9 <0.3.0",
+    "@langchain/core": ">=0.2.16 <0.3.0",
     "fast-xml-parser": "^4.3.5",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.4"