@langchain/anthropic 0.1.9 → 0.1.10

package/dist/chat_models.cjs

@@ -6,6 +6,10 @@ const messages_1 = require("@langchain/core/messages");
 const outputs_1 = require("@langchain/core/outputs");
 const env_1 = require("@langchain/core/utils/env");
 const chat_models_1 = require("@langchain/core/language_models/chat_models");
+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 output_parsers_js_1 = require("./output_parsers.cjs");
 function _formatImage(imageUrl) {
     const regex = /^data:(image\/.+);base64,(.+)$/;
     const match = imageUrl.match(regex);
@@ -22,6 +26,34 @@ function _formatImage(imageUrl) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
 }
+function anthropicResponseToChatMessages(messages, additionalKwargs) {
+    if (messages.length === 1 && messages[0].type === "text") {
+        return [
+            {
+                text: messages[0].text,
+                message: new messages_1.AIMessage(messages[0].text, additionalKwargs),
+            },
+        ];
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const castMessage = messages;
+        const generations = [
+            {
+                text: "",
+                message: new messages_1.AIMessage({
+                    content: castMessage,
+                    additional_kwargs: additionalKwargs,
+                }),
+            },
+        ];
+        return generations;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isAnthropicTool(tool) {
+    return "input_schema" in tool;
+}
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -165,6 +197,32 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         this.streaming = fields?.streaming ?? false;
         this.clientOptions = fields?.clientOptions ?? {};
     }
+    /**
+     * Formats LangChain StructuredTools to AnthropicTools.
+     *
+     * @param {ChatAnthropicCallOptions["tools"]} tools The tools to format
+     * @returns {AnthropicTool[] | undefined} The formatted tools, or undefined if none are passed.
+     * @throws {Error} If a mix of AnthropicTools and StructuredTools are passed.
+     */
+    formatStructuredToolToAnthropic(tools) {
+        if (!tools || !tools.length) {
+            return undefined;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (tools.every((tool) => isAnthropicTool(tool))) {
+            // If the tool is already an anthropic tool, return it
+            return tools;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (tools.some((tool) => isAnthropicTool(tool))) {
+            throw new Error(`Can not pass in a mix of AnthropicTools and StructuredTools`);
+        }
+        return tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            input_schema: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
+        }));
+    }
     /**
      * Get the parameters used to invoke the model
      */
@@ -180,6 +238,27 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             ...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 {
@@ -198,69 +277,91 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
     }
     async *_streamResponseChunks(messages, options, runManager) {
         const params = this.invocationParams(options);
-        const stream = await this.createStreamWithRetry({
+        const requestOptions = this.invocationOptions({
             ...params,
+            stream: false,
             ...this.formatMessagesForAnthropic(messages),
-            stream: true,
-        });
-        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;
-                    }
+        }, options);
+        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);
+            yield new outputs_1.ChatGenerationChunk({
+                message: new messages_1.AIMessageChunk({
+                    content: generations[0].message.content,
+                    additional_kwargs: generations[0].message.additional_kwargs,
+                }),
+                text: generations[0].text,
+            });
+        }
+        else {
+            const stream = await this.createStreamWithRetry({
+                ...params,
+                ...this.formatMessagesForAnthropic(messages),
+                stream: true,
+            }, requestOptions);
+            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.");
                 }
-                usageData = usage;
-                yield new outputs_1.ChatGenerationChunk({
-                    message: new messages_1.AIMessageChunk({
-                        content: "",
-                        additional_kwargs: filteredAdditionalKwargs,
-                    }),
-                    text: "",
-                });
-            }
-            else if (data.type === "message_delta") {
-                yield new outputs_1.ChatGenerationChunk({
-                    message: new messages_1.AIMessageChunk({
-                        content: "",
-                        additional_kwargs: { ...data.delta },
-                    }),
-                    text: "",
-                });
-                if (data?.usage !== undefined) {
-                    usageData.output_tokens += data.usage.output_tokens;
+                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;
+                    yield new outputs_1.ChatGenerationChunk({
+                        message: new messages_1.AIMessageChunk({
+                            content: "",
+                            additional_kwargs: filteredAdditionalKwargs,
+                        }),
+                        text: "",
+                    });
                 }
-            }
-            else if (data.type === "content_block_delta") {
-                const content = data.delta?.text;
-                if (content !== undefined) {
+                else if (data.type === "message_delta") {
                     yield new outputs_1.ChatGenerationChunk({
                         message: new messages_1.AIMessageChunk({
-                            content,
-                            additional_kwargs: {},
+                            content: "",
+                            additional_kwargs: { ...data.delta },
                         }),
-                        text: content,
+                        text: "",
                     });
-                    await runManager?.handleLLMNewToken(content);
+                    if (data?.usage !== undefined) {
+                        usageData.output_tokens += data.usage.output_tokens;
+                    }
+                }
+                else if (data.type === "content_block_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);
+                    }
                 }
             }
+            yield new outputs_1.ChatGenerationChunk({
+                message: new messages_1.AIMessageChunk({
+                    content: "",
+                    additional_kwargs: { usage: usageData },
+                }),
+                text: "",
+            });
         }
-        yield new outputs_1.ChatGenerationChunk({
-            message: new messages_1.AIMessageChunk({
-                content: "",
-                additional_kwargs: { usage: usageData },
-            }),
-            text: "",
-        });
     }
     /**
      * Formats messages as a prompt for the model.
@@ -284,6 +385,9 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             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.");
             }
@@ -296,29 +400,40 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
                     content: message.content,
                 };
             }
-            else {
-                return {
-                    role,
-                    content: 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 ("type" in message.content) {
+                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 {
-                            return contentPart;
+                            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 {
+                        throw new Error("Unsupported message content format");
+                    }
+                });
+                return {
+                    role,
+                    content: contentBlocks,
                 };
             }
+            else {
+                throw new Error("Unsupported message content format");
+            }
         });
         return {
             messages: formattedMessages,
@@ -326,6 +441,17 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         };
     }
     /** @ignore */
+    async _generateNonStreaming(messages, params, requestOptions) {
+        const response = await this.completionWithRetry({
+            ...params,
+            stream: false,
+            ...this.formatMessagesForAnthropic(messages),
+        }, requestOptions);
+        const { content, ...additionalKwargs } = response;
+        const generations = anthropicResponseToChatMessages(content, additionalKwargs);
+        return generations;
+    }
+    /** @ignore */
     async _generate(messages, options, runManager) {
         if (this.stopSequences && options.stop) {
             throw new Error(`"stopSequence" parameter found in input and default params`);
@@ -333,7 +459,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         const params = this.invocationParams(options);
         if (params.stream) {
             let finalChunk;
-            const stream = await this._streamResponseChunks(messages, options, runManager);
+            const stream = this._streamResponseChunks(messages, options, runManager);
             for await (const chunk of stream) {
                 if (finalChunk === undefined) {
                     finalChunk = chunk;
@@ -355,26 +481,14 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             };
         }
         else {
-            const response = await this.completionWithRetry({
+            const requestOptions = this.invocationOptions({
                 ...params,
                 stream: false,
                 ...this.formatMessagesForAnthropic(messages),
-            }, { signal: options.signal });
-            const { content, ...additionalKwargs } = response;
-            if (!Array.isArray(content) || content.length !== 1) {
-                console.log(content);
-                throw new Error("Received multiple content parts in Anthropic response. Only single part messages are currently supported.");
-            }
+            }, options);
+            const generations = await this._generateNonStreaming(messages, params, requestOptions);
             return {
-                generations: [
-                    {
-                        text: content[0].text,
-                        message: new messages_1.AIMessage({
-                            content: content[0].text,
-                            additional_kwargs: additionalKwargs,
-                        }),
-                    },
-                ],
+                generations,
             };
         }
     }
@@ -383,12 +497,12 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
      * @param request The parameters for creating a completion.
      * @returns A streaming request.
      */
-    async createStreamWithRetry(request) {
+    async createStreamWithRetry(request, options) {
         if (!this.streamingClient) {
-            const options = this.apiUrl ? { baseURL: this.apiUrl } : undefined;
+            const options_ = this.apiUrl ? { baseURL: this.apiUrl } : undefined;
             this.streamingClient = new sdk_1.Anthropic({
                 ...this.clientOptions,
-                ...options,
+                ...options_,
                 apiKey: this.anthropicApiKey,
                 // Prefer LangChain built-in retries
                 maxRetries: 0,
@@ -398,7 +512,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             ...request,
             ...this.invocationKwargs,
             stream: true,
-        });
+        }, options);
         return this.caller.call(makeCompletionRequest);
     }
     /** @ignore */
@@ -418,12 +532,88 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         const makeCompletionRequest = async () => this.batchClient.messages.create({
             ...request,
             ...this.invocationKwargs,
-        });
-        return this.caller.callWithOptions({ signal: options.signal }, makeCompletionRequest);
+        }, options);
+        return this.caller.callWithOptions({ signal: options.signal ?? undefined }, makeCompletionRequest);
     }
     _llmType() {
         return "anthropic";
     }
+    withStructuredOutput(outputSchema, config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const schema = outputSchema;
+        const name = config?.name;
+        const method = config?.method;
+        const includeRaw = config?.includeRaw;
+        if (method === "jsonMode") {
+            throw new Error(`Anthropic only supports "functionCalling" as a method.`);
+        }
+        let functionName = name ?? "extract";
+        let outputParser;
+        let tools;
+        if ((0, types_1.isZodSchema)(schema)) {
+            const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+            tools = [
+                {
+                    name: functionName,
+                    description: jsonSchema.description ?? "A function available to call.",
+                    input_schema: jsonSchema,
+                },
+            ];
+            outputParser = new output_parsers_js_1.AnthropicToolsOutputParser({
+                returnSingle: true,
+                keyName: functionName,
+                zodSchema: schema,
+            });
+        }
+        else {
+            let anthropicTools;
+            if (typeof schema.name === "string" &&
+                typeof schema.description === "string" &&
+                typeof schema.input_schema === "object" &&
+                schema.input_schema != null) {
+                anthropicTools = schema;
+                functionName = schema.name;
+            }
+            else {
+                anthropicTools = {
+                    name: functionName,
+                    description: schema.description ?? "",
+                    input_schema: schema,
+                };
+            }
+            tools = [anthropicTools];
+            outputParser = new output_parsers_js_1.AnthropicToolsOutputParser({
+                returnSingle: true,
+                keyName: functionName,
+            });
+        }
+        const llm = this.bind({
+            tools,
+        });
+        if (!includeRaw) {
+            return llm.pipe(outputParser).withConfig({
+                runName: "ChatAnthropicStructuredOutput",
+            });
+        }
+        const parserAssign = runnables_1.RunnablePassthrough.assign({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            parsed: (input, config) => outputParser.invoke(input.raw, config),
+        });
+        const parserNone = runnables_1.RunnablePassthrough.assign({
+            parsed: () => null,
+        });
+        const parsedWithFallback = parserAssign.withFallbacks({
+            fallbacks: [parserNone],
+        });
+        return runnables_1.RunnableSequence.from([
+            {
+                raw: llm,
+            },
+            parsedWithFallback,
+        ]).withConfig({
+            runName: "StructuredOutputRunnable",
+        });
+    }
 }
 exports.ChatAnthropicMessages = ChatAnthropicMessages;
 class ChatAnthropic extends ChatAnthropicMessages {

package/dist/chat_models.d.ts

@@ -2,13 +2,28 @@ 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 { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
+import { ChatGeneration, ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
 import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
-import { type BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+import { StructuredOutputMethodOptions, type BaseLanguageModelCallOptions, BaseLanguageModelInput } from "@langchain/core/language_models/base";
+import { StructuredToolInterface } from "@langchain/core/tools";
+import { Runnable } from "@langchain/core/runnables";
+import { z } from "zod";
+type AnthropicTool = {
+    name: string;
+    description: string;
+    /**
+     * JSON schema.
+     */
+    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[];
+}
 /**
  * Input to AnthropicChat class.
  */
@@ -89,7 +104,7 @@ type Kwargs = Record<string, any>;
  * console.log(res);
  * ```
  */
-export declare class ChatAnthropicMessages<CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends BaseChatModel<CallOptions> implements AnthropicInput {
+export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCallOptions = ChatAnthropicCallOptions> extends BaseChatModel<CallOptions> implements AnthropicInput {
     static lc_name(): string;
     get lc_secrets(): {
         [key: string]: string;
@@ -110,18 +125,27 @@ export declare class ChatAnthropicMessages<CallOptions extends BaseLanguageModel
     protected batchClient: Anthropic;
     protected streamingClient: Anthropic;
     constructor(fields?: Partial<AnthropicInput> & BaseChatModelParams);
+    /**
+     * Formats LangChain StructuredTools to AnthropicTools.
+     *
+     * @param {ChatAnthropicCallOptions["tools"]} tools The tools to format
+     * @returns {AnthropicTool[] | undefined} The formatted tools, or undefined if none are passed.
+     * @throws {Error} If a mix of AnthropicTools and StructuredTools are passed.
+     */
+    formatStructuredToolToAnthropic(tools: ChatAnthropicCallOptions["tools"]): AnthropicTool[] | undefined;
     /**
      * 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;
         metadata?: Anthropic.Messages.MessageCreateParams.Metadata | undefined;
         stream?: boolean | undefined;
         max_tokens: number;
         model: (string & {}) | "claude-3-opus-20240229" | "claude-3-sonnet-20240229" | "claude-2.1'" | "claude-2.0" | "claude-instant-1.2";
         stop_sequences?: string[] | undefined;
-        system?: string | undefined;
         temperature?: number | undefined;
         top_k?: number | undefined;
         top_p?: number | undefined;
@@ -131,12 +155,12 @@ export declare class ChatAnthropicMessages<CallOptions extends BaseLanguageModel
      * Get the identifying parameters for the model
      */
     identifyingParams(): {
+        system?: string | undefined;
         metadata?: Anthropic.Messages.MessageCreateParams.Metadata | undefined;
         stream?: boolean | undefined;
         max_tokens: number;
         model: (string & {}) | "claude-3-opus-20240229" | "claude-3-sonnet-20240229" | "claude-2.1'" | "claude-2.0" | "claude-instant-1.2";
         stop_sequences?: string[] | undefined;
-        system?: string | undefined;
         temperature?: number | undefined;
         top_k?: number | undefined;
         top_p?: number | undefined;
@@ -153,18 +177,23 @@ export declare class ChatAnthropicMessages<CallOptions extends BaseLanguageModel
         messages: AnthropicMessage[];
     };
     /** @ignore */
+    _generateNonStreaming(messages: BaseMessage[], params: Omit<Anthropic.Messages.MessageCreateParamsNonStreaming | Anthropic.Messages.MessageCreateParamsStreaming, "messages"> & Kwargs, requestOptions: AnthropicRequestOptions): Promise<ChatGeneration[]>;
+    /** @ignore */
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     /**
      * Creates a streaming request with retry.
      * @param request The parameters for creating a completion.
      * @returns A streaming request.
      */
-    protected createStreamWithRetry(request: AnthropicStreamingMessageCreateParams & Kwargs): Promise<Stream<AnthropicMessageStreamEvent>>;
+    protected createStreamWithRetry(request: AnthropicStreamingMessageCreateParams & Kwargs, options?: AnthropicRequestOptions): Promise<Stream<AnthropicMessageStreamEvent>>;
     /** @ignore */
-    protected completionWithRetry(request: AnthropicMessageCreateParams & Kwargs, options: {
-        signal?: AbortSignal;
-    }): Promise<Anthropic.Message>;
+    protected completionWithRetry(request: AnthropicMessageCreateParams & Kwargs, options: AnthropicRequestOptions): Promise<Anthropic.Message>;
     _llmType(): string;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+        raw: BaseMessage;
+        parsed: RunOutput;
+    }>;
 }
 export declare class ChatAnthropic extends ChatAnthropicMessages {
 }