@langchain/anthropic 0.1.9 → 0.1.11

package/dist/chat_models.js

@@ -1,8 +1,12 @@
 import { Anthropic } from "@anthropic-ai/sdk";
 import { AIMessage, AIMessageChunk, } from "@langchain/core/messages";
-import { ChatGenerationChunk } from "@langchain/core/outputs";
+import { ChatGenerationChunk, } from "@langchain/core/outputs";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
+import { isZodSchema } from "@langchain/core/utils/types";
+import { AnthropicToolsOutputParser } from "./output_parsers.js";
 function _formatImage(imageUrl) {
     const regex = /^data:(image\/.+);base64,(.+)$/;
     const match = imageUrl.match(regex);
@@ -19,6 +23,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 AIMessage(messages[0].text, additionalKwargs),
+            },
+        ];
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const castMessage = messages;
+        const generations = [
+            {
+                text: "",
+                message: new 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.
  *
@@ -162,6 +194,32 @@ export class ChatAnthropicMessages extends 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: zodToJsonSchema(tool.schema),
+        }));
+    }
     /**
      * Get the parameters used to invoke the model
      */
@@ -177,6 +235,27 @@ export class ChatAnthropicMessages extends 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 {
@@ -195,69 +274,91 @@ export class ChatAnthropicMessages extends 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 ChatGenerationChunk({
+                message: new 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 ChatGenerationChunk({
-                    message: new AIMessageChunk({
-                        content: "",
-                        additional_kwargs: filteredAdditionalKwargs,
-                    }),
-                    text: "",
-                });
-            }
-            else if (data.type === "message_delta") {
-                yield new ChatGenerationChunk({
-                    message: new 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 ChatGenerationChunk({
+                        message: new 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 ChatGenerationChunk({
                         message: new 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 ChatGenerationChunk({
+                            message: new AIMessageChunk({
+                                content,
+                                additional_kwargs: {},
+                            }),
+                            text: content,
+                        });
+                        await runManager?.handleLLMNewToken(content);
+                    }
                 }
             }
+            yield new ChatGenerationChunk({
+                message: new AIMessageChunk({
+                    content: "",
+                    additional_kwargs: { usage: usageData },
+                }),
+                text: "",
+            });
         }
-        yield new ChatGenerationChunk({
-            message: new AIMessageChunk({
-                content: "",
-                additional_kwargs: { usage: usageData },
-            }),
-            text: "",
-        });
     }
     /**
      * Formats messages as a prompt for the model.
@@ -281,6 +382,9 @@ export class ChatAnthropicMessages extends 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.");
             }
@@ -294,26 +398,44 @@ export class ChatAnthropicMessages extends BaseChatModel {
                 };
             }
             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,
-                            };
+                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 if (contentPart.type === "tool_use") {
+                        // TODO: Fix when SDK types are fixed
+                        return {
+                            type: "tool_use",
+                            id: contentPart.id,
+                            name: contentPart.name,
+                            input: contentPart.input,
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        };
+                    }
+                    else {
+                        throw new Error("Unsupported message content format");
+                    }
+                });
+                return {
+                    role,
+                    content: contentBlocks,
                 };
             }
         });
@@ -323,6 +445,17 @@ export class ChatAnthropicMessages extends 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`);
@@ -330,7 +463,7 @@ export class ChatAnthropicMessages extends 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;
@@ -352,26 +485,14 @@ export class ChatAnthropicMessages extends 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 AIMessage({
-                            content: content[0].text,
-                            additional_kwargs: additionalKwargs,
-                        }),
-                    },
-                ],
+                generations,
             };
         }
     }
@@ -380,12 +501,12 @@ export class ChatAnthropicMessages extends 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 Anthropic({
                 ...this.clientOptions,
-                ...options,
+                ...options_,
                 apiKey: this.anthropicApiKey,
                 // Prefer LangChain built-in retries
                 maxRetries: 0,
@@ -395,7 +516,7 @@ export class ChatAnthropicMessages extends BaseChatModel {
             ...request,
             ...this.invocationKwargs,
             stream: true,
-        });
+        }, options);
         return this.caller.call(makeCompletionRequest);
     }
     /** @ignore */
@@ -415,12 +536,88 @@ export class ChatAnthropicMessages extends 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 (isZodSchema(schema)) {
+            const jsonSchema = zodToJsonSchema(schema);
+            tools = [
+                {
+                    name: functionName,
+                    description: jsonSchema.description ?? "A function available to call.",
+                    input_schema: jsonSchema,
+                },
+            ];
+            outputParser = new 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 AnthropicToolsOutputParser({
+                returnSingle: true,
+                keyName: functionName,
+            });
+        }
+        const llm = this.bind({
+            tools,
+        });
+        if (!includeRaw) {
+            return llm.pipe(outputParser).withConfig({
+                runName: "ChatAnthropicStructuredOutput",
+            });
+        }
+        const parserAssign = RunnablePassthrough.assign({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            parsed: (input, config) => outputParser.invoke(input.raw, config),
+        });
+        const parserNone = RunnablePassthrough.assign({
+            parsed: () => null,
+        });
+        const parsedWithFallback = parserAssign.withFallbacks({
+            fallbacks: [parserNone],
+        });
+        return RunnableSequence.from([
+            {
+                raw: llm,
+            },
+            parsedWithFallback,
+        ]).withConfig({
+            runName: "StructuredOutputRunnable",
+        });
+    }
 }
 export class ChatAnthropic extends ChatAnthropicMessages {
 }

package/dist/experimental/tests/tool_calling.int.test.js

@@ -6,7 +6,7 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 import { HumanMessage } from "@langchain/core/messages";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { ChatAnthropicTools } from "../tool_calling.js";
-test("Test ChatAnthropicTools", async () => {
+test.skip("Test ChatAnthropicTools", async () => {
     const chat = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -15,7 +15,7 @@ test("Test ChatAnthropicTools", async () => {
     const res = await chat.invoke([message]);
     console.log(JSON.stringify(res));
 });
-test("Test ChatAnthropicTools streaming", async () => {
+test.skip("Test ChatAnthropicTools streaming", async () => {
     const chat = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -29,7 +29,7 @@ test("Test ChatAnthropicTools streaming", async () => {
     }
     expect(chunks.length).toBeGreaterThan(1);
 });
-test("Test ChatAnthropicTools with tools", async () => {
+test.skip("Test ChatAnthropicTools with tools", async () => {
     const chat = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         temperature: 0.1,
@@ -65,7 +65,7 @@ test("Test ChatAnthropicTools with tools", async () => {
     expect(res.additional_kwargs.tool_calls).toBeDefined();
     expect(res.additional_kwargs.tool_calls?.[0].function.name).toEqual("get_current_weather");
 });
-test("Test ChatAnthropicTools with a forced function call", async () => {
+test.skip("Test ChatAnthropicTools with a forced function call", async () => {
     const chat = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         temperature: 0.1,
@@ -106,7 +106,7 @@ test("Test ChatAnthropicTools with a forced function call", async () => {
     expect(res.additional_kwargs.tool_calls).toBeDefined();
     expect(res.additional_kwargs.tool_calls?.[0]?.function.name).toEqual("extract_data");
 });
-test("ChatAnthropicTools with Zod schema", async () => {
+test.skip("ChatAnthropicTools with Zod schema", async () => {
     const schema = z.object({
         people: z.array(z.object({
             name: z.string().describe("The name of a person"),
@@ -148,7 +148,7 @@ test("ChatAnthropicTools with Zod schema", async () => {
         ]),
     });
 });
-test("ChatAnthropicTools with parallel tool calling", async () => {
+test.skip("ChatAnthropicTools with parallel tool calling", async () => {
     const schema = z.object({
         name: z.string().describe("The name of a person"),
         height: z.number().describe("The person's height"),
@@ -186,7 +186,7 @@ test("ChatAnthropicTools with parallel tool calling", async () => {
         { name: "Claudia", height: 6, hairColor: "brunette" },
     ]));
 });
-test("Test ChatAnthropic withStructuredOutput", async () => {
+test.skip("Test ChatAnthropic withStructuredOutput", async () => {
     const runnable = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -202,7 +202,7 @@ test("Test ChatAnthropic withStructuredOutput", async () => {
     console.log(JSON.stringify(res, null, 2));
     expect(res).toEqual({ name: "Alex", height: 5, hairColor: "blonde" });
 });
-test("Test ChatAnthropic withStructuredOutput on a single array item", async () => {
+test.skip("Test ChatAnthropic withStructuredOutput on a single array item", async () => {
     const runnable = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -220,7 +220,7 @@ test("Test ChatAnthropic withStructuredOutput on a single array item", async ()
         people: [{ hairColor: "blonde", height: 5, name: "Alex" }],
     });
 });
-test("Test ChatAnthropic withStructuredOutput on a single array item", async () => {
+test.skip("Test ChatAnthropic withStructuredOutput on a single array item", async () => {
     const runnable = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -262,7 +262,7 @@ test("Test ChatAnthropic withStructuredOutput on a single array item", async ()
         tone: "positive",
     });
 });
-test("Test ChatAnthropicTools", async () => {
+test.skip("Test ChatAnthropicTools", async () => {
     const chat = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,

package/dist/experimental/tool_calling.cjs

@@ -12,6 +12,7 @@ const tool_calling_js_1 = require("./utils/tool_calling.cjs");
 /**
  * Experimental wrapper over Anthropic chat models that adds support for
  * a function calling interface.
+ * @deprecated Prefer traditional tool use through ChatAnthropic.
  */
 class ChatAnthropicTools extends chat_models_1.BaseChatModel {
     static lc_name() {

package/dist/experimental/tool_calling.d.ts

@@ -23,6 +23,7 @@ export type ChatAnthropicToolsInput = Partial<AnthropicInput> & BaseChatModelPar
 /**
  * Experimental wrapper over Anthropic chat models that adds support for
  * a function calling interface.
+ * @deprecated Prefer traditional tool use through ChatAnthropic.
  */
 export declare class ChatAnthropicTools extends BaseChatModel<ChatAnthropicToolsCallOptions> {
     llm: BaseChatModel;

package/dist/experimental/tool_calling.js

@@ -9,6 +9,7 @@ import { DEFAULT_TOOL_SYSTEM_PROMPT, formatAsXMLRepresentation, fixArrayXMLParam
 /**
  * Experimental wrapper over Anthropic chat models that adds support for
  * a function calling interface.
+ * @deprecated Prefer traditional tool use through ChatAnthropic.
  */
 export class ChatAnthropicTools extends BaseChatModel {
     static lc_name() {