@langchain/anthropic 0.1.12 → 0.1.14

package/README.md

@@ -52,7 +52,7 @@ Then initialize
 import { ChatAnthropicMessages } from "@langchain/anthropic";
 
 const model = new ChatAnthropic({
-  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+  apiKey: process.env.ANTHROPIC_API_KEY,
 });
 const response = await model.invoke(new HumanMessage("Hello world!"));
 ```
@@ -63,8 +63,8 @@ const response = await model.invoke(new HumanMessage("Hello world!"));
 import { ChatAnthropicMessages } from "@langchain/anthropic";
 
 const model = new ChatAnthropic({
-  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
-  modelName: "claude-3-sonnet-20240229",
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  model: "claude-3-sonnet-20240229",
 });
 const response = await model.stream(new HumanMessage("Hello world!"));
 ```

package/dist/chat_models.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatAnthropic = exports.ChatAnthropicMessages = void 0;
+exports.ChatAnthropic = exports.ChatAnthropicMessages = exports._convertLangChainToolCallToAnthropic = void 0;
 const sdk_1 = require("@anthropic-ai/sdk");
 const messages_1 = require("@langchain/core/messages");
 const outputs_1 = require("@langchain/core/outputs");
@@ -36,14 +36,15 @@ function anthropicResponseToChatMessages(messages, additionalKwargs) {
         ];
     }
     else {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const castMessage = messages;
+        const toolCalls = (0, output_parsers_js_1.extractToolCalls)(messages);
         const generations = [
             {
                 text: "",
                 message: new messages_1.AIMessage({
-                    content: castMessage,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    content: messages,
                     additional_kwargs: additionalKwargs,
+                    tool_calls: toolCalls,
                 }),
             },
         ];
@@ -54,6 +55,176 @@ function anthropicResponseToChatMessages(messages, additionalKwargs) {
 function isAnthropicTool(tool) {
     return "input_schema" in tool;
 }
+function _mergeMessages(messages) {
+    // Merge runs of human/tool messages into single human messages with content blocks.
+    const merged = [];
+    for (const message of messages) {
+        if (message._getType() === "tool") {
+            if (typeof message.content === "string") {
+                merged.push(new messages_1.HumanMessage({
+                    content: [
+                        {
+                            type: "tool_result",
+                            content: message.content,
+                            tool_use_id: message.tool_call_id,
+                        },
+                    ],
+                }));
+            }
+            else {
+                merged.push(new messages_1.HumanMessage({ content: message.content }));
+            }
+        }
+        else {
+            const previousMessage = merged[merged.length - 1];
+            if (previousMessage?._getType() === "human" &&
+                message._getType() === "human") {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                let combinedContent;
+                if (typeof previousMessage.content === "string") {
+                    combinedContent = [{ type: "text", text: previousMessage.content }];
+                }
+                else {
+                    combinedContent = previousMessage.content;
+                }
+                if (typeof message.content === "string") {
+                    combinedContent.push({ type: "text", text: message.content });
+                }
+                else {
+                    combinedContent = combinedContent.concat(message.content);
+                }
+                previousMessage.content = combinedContent;
+            }
+            else {
+                merged.push(message);
+            }
+        }
+    }
+    return merged;
+}
+function _convertLangChainToolCallToAnthropic(toolCall) {
+    if (toolCall.id === undefined) {
+        throw new Error(`Anthropic requires all tool calls to have an "id".`);
+    }
+    return {
+        type: "tool_use",
+        id: toolCall.id,
+        name: toolCall.name,
+        input: toolCall.args,
+    };
+}
+exports._convertLangChainToolCallToAnthropic = _convertLangChainToolCallToAnthropic;
+function _formatContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    else {
+        const contentBlocks = content.map((contentPart) => {
+            if (contentPart.type === "image_url") {
+                let source;
+                if (typeof contentPart.image_url === "string") {
+                    source = _formatImage(contentPart.image_url);
+                }
+                else {
+                    source = _formatImage(contentPart.image_url.url);
+                }
+                return {
+                    type: "image",
+                    source,
+                };
+            }
+            else if (contentPart.type === "text") {
+                // Assuming contentPart is of type MessageContentText here
+                return {
+                    type: "text",
+                    text: contentPart.text,
+                };
+            }
+            else if (contentPart.type === "tool_use" ||
+                contentPart.type === "tool_result") {
+                // TODO: Fix when SDK types are fixed
+                return {
+                    ...contentPart,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                };
+            }
+            else {
+                throw new Error("Unsupported message content format");
+            }
+        });
+        return contentBlocks;
+    }
+}
+/**
+ * Formats messages as a prompt for the model.
+ * @param messages The base messages to format as a prompt.
+ * @returns The formatted prompt.
+ */
+function _formatMessagesForAnthropic(messages) {
+    const mergedMessages = _mergeMessages(messages);
+    let system;
+    if (mergedMessages.length > 0 && mergedMessages[0]._getType() === "system") {
+        if (typeof messages[0].content !== "string") {
+            throw new Error("System message content must be a string.");
+        }
+        system = messages[0].content;
+    }
+    const conversationMessages = system !== undefined ? mergedMessages.slice(1) : mergedMessages;
+    const formattedMessages = conversationMessages.map((message) => {
+        let role;
+        if (message._getType() === "human") {
+            role = "user";
+        }
+        else if (message._getType() === "ai") {
+            role = "assistant";
+        }
+        else if (message._getType() === "tool") {
+            role = "user";
+        }
+        else if (message._getType() === "system") {
+            throw new Error("System messages are only permitted as the first passed message.");
+        }
+        else {
+            throw new Error(`Message type "${message._getType()}" is not supported.`);
+        }
+        if ((0, messages_1.isAIMessage)(message) && !!message.tool_calls?.length) {
+            if (message.content === "") {
+                return {
+                    role,
+                    content: message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+                };
+            }
+            else if (typeof message.content === "string") {
+                console.warn(`The "tool_calls" field on a message is only respected if content is an empty string.`);
+                return {
+                    role,
+                    content: _formatContent(message.content),
+                };
+            }
+            else {
+                const { content } = message;
+                const hasMismatchedToolCalls = !message.tool_calls.every((toolCall) => content.find((contentPart) => contentPart.type === "tool_use" && contentPart.id === toolCall.id));
+                if (hasMismatchedToolCalls) {
+                    console.warn(`The "tool_calls" field on a message is only respected if content is an empty string.`);
+                }
+                return {
+                    role,
+                    content: _formatContent(message.content),
+                };
+            }
+        }
+        else {
+            return {
+                role,
+                content: _formatContent(message.content),
+            };
+        }
+    });
+    return {
+        messages: formattedMessages,
+        system,
+    };
+}
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -71,7 +242,7 @@ function isAnthropicTool(tool) {
  *
  * const model = new ChatAnthropic({
  *   temperature: 0.9,
- *   anthropicApiKey: 'YOUR-API-KEY',
+ *   apiKey: 'YOUR-API-KEY',
  * });
  * const res = await model.invoke({ input: 'Hello!' });
  * console.log(res);
@@ -84,6 +255,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
     get lc_secrets() {
         return {
             anthropicApiKey: "ANTHROPIC_API_KEY",
+            apiKey: "ANTHROPIC_API_KEY",
         };
     }
     get lc_aliases() {
@@ -105,6 +277,12 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "apiUrl", {
             enumerable: true,
             configurable: true,
@@ -141,6 +319,12 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             writable: true,
             value: "claude-2.1"
         });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "claude-2.1"
+        });
         Object.defineProperty(this, "invocationKwargs", {
             enumerable: true,
             configurable: true,
@@ -180,13 +364,19 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             value: void 0
         });
         this.anthropicApiKey =
-            fields?.anthropicApiKey ?? (0, env_1.getEnvironmentVariable)("ANTHROPIC_API_KEY");
+            fields?.apiKey ??
+                fields?.anthropicApiKey ??
+                (0, env_1.getEnvironmentVariable)("ANTHROPIC_API_KEY");
         if (!this.anthropicApiKey) {
             throw new Error("Anthropic API key not found");
         }
+        /** Keep anthropicApiKey for backwards compatibility */
+        this.apiKey = this.anthropicApiKey;
         // Support overriding the default API URL (i.e., https://api.anthropic.com)
         this.apiUrl = fields?.anthropicApiUrl;
-        this.modelName = fields?.modelName ?? this.modelName;
+        /** Keep modelName for backwards compatibility */
+        this.modelName = fields?.model ?? fields?.modelName ?? this.model;
+        this.model = this.modelName;
         this.invocationKwargs = fields?.invocationKwargs ?? {};
         this.temperature = fields?.temperature ?? this.temperature;
         this.topK = fields?.topK ?? this.topK;
@@ -223,46 +413,32 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             input_schema: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
         }));
     }
+    bindTools(tools, kwargs) {
+        return this.bind({
+            tools: this.formatStructuredToolToAnthropic(tools),
+            ...kwargs,
+        });
+    }
     /**
      * Get the parameters used to invoke the model
      */
     invocationParams(options) {
         return {
-            model: this.modelName,
+            model: this.model,
             temperature: this.temperature,
             top_k: this.topK,
             top_p: this.topP,
             stop_sequences: options?.stop ?? this.stopSequences,
             stream: this.streaming,
             max_tokens: this.maxTokens,
+            tools: this.formatStructuredToolToAnthropic(options?.tools),
             ...this.invocationKwargs,
         };
     }
-    invocationOptions(request, options) {
-        const toolUseBetaHeader = {
-            "anthropic-beta": "tools-2024-04-04",
-        };
-        const tools = this.formatStructuredToolToAnthropic(options?.tools);
-        // If tools are present, populate the body with the message request params.
-        // This is because Anthropic overwrites the message request params if a body
-        // is passed.
-        const body = tools
-            ? {
-                ...request,
-                tools,
-            }
-            : undefined;
-        const headers = tools ? toolUseBetaHeader : undefined;
-        return {
-            signal: options.signal,
-            ...(body ? { body } : {}),
-            ...(headers ? { headers } : {}),
-        };
-    }
     /** @ignore */
     _identifyingParams() {
         return {
-            model_name: this.modelName,
+            model_name: this.model,
             ...this.invocationParams(),
         };
     }
@@ -271,28 +447,29 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
      */
     identifyingParams() {
         return {
-            model_name: this.modelName,
+            model_name: this.model,
             ...this.invocationParams(),
         };
     }
     async *_streamResponseChunks(messages, options, runManager) {
         const params = this.invocationParams(options);
-        const requestOptions = this.invocationOptions({
-            ...params,
-            stream: false,
-            ...this.formatMessagesForAnthropic(messages),
-        }, options);
+        const formattedMessages = _formatMessagesForAnthropic(messages);
         if (options.tools !== undefined && options.tools.length > 0) {
-            const requestOptions = this.invocationOptions({
-                ...params,
-                stream: false,
-                ...this.formatMessagesForAnthropic(messages),
-            }, options);
-            const generations = await this._generateNonStreaming(messages, params, requestOptions);
+            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: generations[0].message.content,
-                    additional_kwargs: generations[0].message.additional_kwargs,
+                    content: result.content,
+                    additional_kwargs: result.additional_kwargs,
+                    tool_call_chunks: toolCallChunks,
                 }),
                 text: generations[0].text,
             });
@@ -300,9 +477,9 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         else {
             const stream = await this.createStreamWithRetry({
                 ...params,
-                ...this.formatMessagesForAnthropic(messages),
+                ...formattedMessages,
                 stream: true,
-            }, requestOptions);
+            });
             let usageData = { input_tokens: 0, output_tokens: 0 };
             for await (const data of stream) {
                 if (options.signal?.aborted) {
@@ -363,95 +540,22 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             });
         }
     }
-    /**
-     * Formats messages as a prompt for the model.
-     * @param messages The base messages to format as a prompt.
-     * @returns The formatted prompt.
-     */
-    formatMessagesForAnthropic(messages) {
-        let system;
-        if (messages.length > 0 && messages[0]._getType() === "system") {
-            if (typeof messages[0].content !== "string") {
-                throw new Error("System message content must be a string.");
-            }
-            system = messages[0].content;
-        }
-        const conversationMessages = system !== undefined ? messages.slice(1) : messages;
-        const formattedMessages = conversationMessages.map((message) => {
-            let role;
-            if (message._getType() === "human") {
-                role = "user";
-            }
-            else if (message._getType() === "ai") {
-                role = "assistant";
-            }
-            else if (message._getType() === "tool") {
-                role = "user";
-            }
-            else if (message._getType() === "system") {
-                throw new Error("System messages are only permitted as the first passed message.");
-            }
-            else {
-                throw new Error(`Message type "${message._getType()}" is not supported.`);
-            }
-            if (typeof message.content === "string") {
-                return {
-                    role,
-                    content: message.content,
-                };
-            }
-            else {
-                const contentBlocks = message.content.map((contentPart) => {
-                    if (contentPart.type === "image_url") {
-                        let source;
-                        if (typeof contentPart.image_url === "string") {
-                            source = _formatImage(contentPart.image_url);
-                        }
-                        else {
-                            source = _formatImage(contentPart.image_url.url);
-                        }
-                        return {
-                            type: "image",
-                            source,
-                        };
-                    }
-                    else if (contentPart.type === "text") {
-                        // Assuming contentPart is of type MessageContentText here
-                        return {
-                            type: "text",
-                            text: contentPart.text,
-                        };
-                    }
-                    else if (contentPart.type === "tool_use" ||
-                        contentPart.type === "tool_result") {
-                        // TODO: Fix when SDK types are fixed
-                        return {
-                            ...contentPart,
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        };
-                    }
-                    else {
-                        throw new Error("Unsupported message content format");
-                    }
-                });
-                return {
-                    role,
-                    content: contentBlocks,
-                };
-            }
-        });
-        return {
-            messages: formattedMessages,
-            system,
-        };
-    }
     /** @ignore */
     async _generateNonStreaming(messages, params, requestOptions) {
+        const options = params.tools !== undefined
+            ? {
+                ...requestOptions,
+                headers: {
+                    ...requestOptions.headers,
+                    "anthropic-beta": "tools-2024-04-04",
+                },
+            }
+            : requestOptions;
         const response = await this.completionWithRetry({
             ...params,
             stream: false,
-            ...this.formatMessagesForAnthropic(messages),
-        }, requestOptions);
+            ..._formatMessagesForAnthropic(messages),
+        }, options);
         const { content, ...additionalKwargs } = response;
         const generations = anthropicResponseToChatMessages(content, additionalKwargs);
         return generations;
@@ -486,12 +590,9 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             };
         }
         else {
-            const requestOptions = this.invocationOptions({
-                ...params,
-                stream: false,
-                ...this.formatMessagesForAnthropic(messages),
-            }, options);
-            const generations = await this._generateNonStreaming(messages, params, requestOptions);
+            const generations = await this._generateNonStreaming(messages, params, {
+                signal: options.signal,
+            });
             return {
                 generations,
             };
@@ -508,7 +609,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             this.streamingClient = new sdk_1.Anthropic({
                 ...this.clientOptions,
                 ...options_,
-                apiKey: this.anthropicApiKey,
+                apiKey: this.apiKey,
                 // Prefer LangChain built-in retries
                 maxRetries: 0,
             });
@@ -522,7 +623,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
     }
     /** @ignore */
     async completionWithRetry(request, options) {
-        if (!this.anthropicApiKey) {
+        if (!this.apiKey) {
             throw new Error("Missing Anthropic API key.");
         }
         if (!this.batchClient) {
@@ -530,7 +631,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             this.batchClient = new sdk_1.Anthropic({
                 ...this.clientOptions,
                 ...options,
-                apiKey: this.anthropicApiKey,
+                apiKey: this.apiKey,
                 maxRetries: 0,
             });
         }

package/dist/chat_models.d.ts

@@ -1,13 +1,15 @@
 import { Anthropic, type ClientOptions } from "@anthropic-ai/sdk";
 import type { Stream } from "@anthropic-ai/sdk/streaming";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
-import { type BaseMessage } from "@langchain/core/messages";
+import { AIMessageChunk, type BaseMessage } from "@langchain/core/messages";
 import { ChatGeneration, ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
 import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
 import { StructuredOutputMethodOptions, type BaseLanguageModelCallOptions, BaseLanguageModelInput } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
-import { Runnable } from "@langchain/core/runnables";
+import { Runnable, RunnableInterface } from "@langchain/core/runnables";
+import { ToolCall } from "@langchain/core/messages/tool";
 import { z } from "zod";
+import { AnthropicToolResponse } from "./types.js";
 type AnthropicTool = {
     name: string;
     description: string;
@@ -16,13 +18,12 @@ type AnthropicTool = {
      */
     input_schema: Record<string, unknown>;
 };
-type AnthropicMessage = Anthropic.MessageParam;
 type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
 type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
 type AnthropicRequestOptions = Anthropic.RequestOptions;
 interface ChatAnthropicCallOptions extends BaseLanguageModelCallOptions {
-    tools?: StructuredToolInterface[] | AnthropicTool[];
+    tools?: (StructuredToolInterface | AnthropicTool)[];
 }
 /**
  * Input to AnthropicChat class.
@@ -64,10 +65,14 @@ export interface AnthropicInput {
     streaming?: boolean;
     /** Anthropic API key */
     anthropicApiKey?: string;
+    /** Anthropic API key */
+    apiKey?: string;
     /** Anthropic API URL */
     anthropicApiUrl?: string;
     /** Model name to use */
     modelName: string;
+    /** Model name to use */
+    model: string;
     /** Overridable Anthropic ClientOptions */
     clientOptions: ClientOptions;
     /** Holds any additional parameters that are valid to pass to {@link
@@ -81,6 +86,7 @@ export interface AnthropicInput {
  * Anthropic API.
  */
 type Kwargs = Record<string, any>;
+export declare function _convertLangChainToolCallToAnthropic(toolCall: ToolCall): AnthropicToolResponse;
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -98,13 +104,13 @@ type Kwargs = Record<string, any>;
  *
  * const model = new ChatAnthropic({
  *   temperature: 0.9,
- *   anthropicApiKey: 'YOUR-API-KEY',
+ *   apiKey: 'YOUR-API-KEY',
  * });
  * const res = await model.invoke({ input: 'Hello!' });
  * console.log(res);
  * ```
  */
-export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCallOptions = ChatAnthropicCallOptions> extends BaseChatModel<CallOptions> implements AnthropicInput {
+export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCallOptions = ChatAnthropicCallOptions> extends BaseChatModel<CallOptions, AIMessageChunk> implements AnthropicInput {
     static lc_name(): string;
     get lc_secrets(): {
         [key: string]: string;
@@ -112,12 +118,14 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
     get lc_aliases(): Record<string, string>;
     lc_serializable: boolean;
     anthropicApiKey?: string;
+    apiKey?: string;
     apiUrl?: string;
     temperature: number;
     topK: number;
     topP: number;
     maxTokens: number;
     modelName: string;
+    model: string;
     invocationKwargs?: Kwargs;
     stopSequences?: string[];
     streaming: boolean;
@@ -133,11 +141,11 @@ 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 | StructuredToolInterface)[], kwargs?: Partial<CallOptions>): RunnableInterface<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
     /**
      * Get the parameters used to invoke the model
      */
     invocationParams(options?: this["ParsedCallOptions"]): Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, "messages"> & Kwargs;
-    invocationOptions(request: Omit<AnthropicMessageCreateParams | AnthropicStreamingMessageCreateParams, "messages"> & Kwargs, options: this["ParsedCallOptions"]): AnthropicRequestOptions;
     /** @ignore */
     _identifyingParams(): {
         system?: string | undefined;
@@ -167,15 +175,6 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
         model_name: string;
     };
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    /**
-     * Formats messages as a prompt for the model.
-     * @param messages The base messages to format as a prompt.
-     * @returns The formatted prompt.
-     */
-    protected formatMessagesForAnthropic(messages: BaseMessage[]): {
-        system?: string;
-        messages: AnthropicMessage[];
-    };
     /** @ignore */
     _generateNonStreaming(messages: BaseMessage[], params: Omit<Anthropic.Messages.MessageCreateParamsNonStreaming | Anthropic.Messages.MessageCreateParamsStreaming, "messages"> & Kwargs, requestOptions: AnthropicRequestOptions): Promise<ChatGeneration[]>;
     /** @ignore */