@langchain/anthropic 0.1.13 → 0.1.15

package/dist/chat_models.js

@@ -1,12 +1,12 @@
 import { Anthropic } from "@anthropic-ai/sdk";
-import { AIMessage, AIMessageChunk, } from "@langchain/core/messages";
+import { AIMessage, AIMessageChunk, HumanMessage, isAIMessage, } from "@langchain/core/messages";
 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";
+import { AnthropicToolsOutputParser, extractToolCalls, } from "./output_parsers.js";
 function _formatImage(imageUrl) {
     const regex = /^data:(image\/.+);base64,(.+)$/;
     const match = imageUrl.match(regex);
@@ -33,14 +33,15 @@ function anthropicResponseToChatMessages(messages, additionalKwargs) {
         ];
     }
     else {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const castMessage = messages;
+        const toolCalls = extractToolCalls(messages);
         const generations = [
             {
                 text: "",
                 message: new AIMessage({
-                    content: castMessage,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    content: messages,
                     additional_kwargs: additionalKwargs,
+                    tool_calls: toolCalls,
                 }),
             },
         ];
@@ -51,6 +52,179 @@ 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 HumanMessage({
+                    content: [
+                        {
+                            type: "tool_result",
+                            content: message.content,
+                            tool_use_id: message.tool_call_id,
+                        },
+                    ],
+                }));
+            }
+            else {
+                merged.push(new 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;
+}
+export 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,
+    };
+}
+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 (isAIMessage(message) && !!message.tool_calls?.length) {
+            if (typeof message.content === "string") {
+                if (message.content === "") {
+                    return {
+                        role,
+                        content: message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+                    };
+                }
+                else {
+                    return {
+                        role,
+                        content: [
+                            { type: "text", text: message.content },
+                            ...message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+                        ],
+                    };
+                }
+            }
+            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 a string.`);
+                }
+                return {
+                    role,
+                    content: _formatContent(message.content),
+                };
+            }
+        }
+        else {
+            return {
+                role,
+                content: _formatContent(message.content),
+            };
+        }
+    });
+    return {
+        messages: formattedMessages,
+        system,
+    };
+}
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -239,6 +413,12 @@ export class ChatAnthropicMessages extends BaseChatModel {
             input_schema: zodToJsonSchema(tool.schema),
         }));
     }
+    bindTools(tools, kwargs) {
+        return this.bind({
+            tools: this.formatStructuredToolToAnthropic(tools),
+            ...kwargs,
+        });
+    }
     /**
      * Get the parameters used to invoke the model
      */
@@ -251,30 +431,10 @@ export class ChatAnthropicMessages extends BaseChatModel {
             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 {
@@ -293,22 +453,23 @@ export class ChatAnthropicMessages extends BaseChatModel {
     }
     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 ChatGenerationChunk({
                 message: new 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,
             });
@@ -316,9 +477,9 @@ export class ChatAnthropicMessages extends 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) {
@@ -379,95 +540,22 @@ export class ChatAnthropicMessages extends 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;
@@ -502,12 +590,9 @@ export class ChatAnthropicMessages extends 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,
             };

package/dist/output_parsers.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnthropicToolsOutputParser = void 0;
+exports.extractToolCalls = exports.AnthropicToolsOutputParser = void 0;
 const output_parsers_1 = require("@langchain/core/output_parsers");
 class AnthropicToolsOutputParser extends output_parsers_1.BaseLLMOutputParser {
     static lc_name() {
@@ -56,25 +56,32 @@ class AnthropicToolsOutputParser extends output_parsers_1.BaseLLMOutputParser {
             throw new output_parsers_1.OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(result, null, 2));
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async parseResult(generations) {
         const tools = generations.flatMap((generation) => {
             const { message } = generation;
-            if (typeof message === "string") {
-                return [];
-            }
             if (!Array.isArray(message.content)) {
                 return [];
             }
-            const tool = message.content.find((item) => item.type === "tool_use");
+            const tool = extractToolCalls(message.content)[0];
             return tool;
         });
         if (tools[0] === undefined) {
             throw new Error("No parseable tool calls provided to AnthropicToolsOutputParser.");
         }
         const [tool] = tools;
-        const validatedResult = await this._validateResult(tool.input);
+        const validatedResult = await this._validateResult(tool.args);
         return validatedResult;
     }
 }
 exports.AnthropicToolsOutputParser = AnthropicToolsOutputParser;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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 });
+        }
+    }
+    return toolCalls;
+}
+exports.extractToolCalls = extractToolCalls;

package/dist/output_parsers.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { JsonOutputKeyToolsParserParams } from "@langchain/core/output_parsers/openai_tools";
 import { ChatGeneration } from "@langchain/core/outputs";
+import { ToolCall } from "@langchain/core/messages/tool";
 interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParams<T> {
 }
 export declare class AnthropicToolsOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
@@ -17,4 +18,5 @@ export declare class AnthropicToolsOutputParser<T extends Record<string, any> =
     protected _validateResult(result: unknown): Promise<T>;
     parseResult(generations: ChatGeneration[]): Promise<T>;
 }
+export declare function extractToolCalls(content: Record<string, any>[]): ToolCall[];
 export {};

package/dist/output_parsers.js

@@ -53,24 +53,30 @@ export class AnthropicToolsOutputParser extends BaseLLMOutputParser {
             throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(result, null, 2));
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async parseResult(generations) {
         const tools = generations.flatMap((generation) => {
             const { message } = generation;
-            if (typeof message === "string") {
-                return [];
-            }
             if (!Array.isArray(message.content)) {
                 return [];
             }
-            const tool = message.content.find((item) => item.type === "tool_use");
+            const tool = extractToolCalls(message.content)[0];
             return tool;
         });
         if (tools[0] === undefined) {
             throw new Error("No parseable tool calls provided to AnthropicToolsOutputParser.");
         }
         const [tool] = tools;
-        const validatedResult = await this._validateResult(tool.input);
+        const validatedResult = await this._validateResult(tool.args);
         return validatedResult;
     }
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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 });
+        }
+    }
+    return toolCalls;
+}

package/dist/tests/agent.int.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/agent.int.test.js

@@ -0,0 +1,39 @@
+// import { test, expect } from "@jest/globals";
+// import { ChatPromptTemplate } from "@langchain/core/prompts";
+// import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
+// import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
+// import { ChatAnthropic } from "../index.js";
+// const tools = [new TavilySearchResults({ maxResults: 1 })];
+// TODO: This test breaks CI build due to dependencies. Figure out a way around it.
+test("createToolCallingAgent works", async () => {
+    //   const prompt = ChatPromptTemplate.fromMessages([
+    //     ["system", "You are a helpful assistant"],
+    //     ["placeholder", "{chat_history}"],
+    //     ["human", "{input}"],
+    //     ["placeholder", "{agent_scratchpad}"],
+    //   ]);
+    //   const llm = new ChatAnthropic({
+    //     modelName: "claude-3-sonnet-20240229",
+    //     temperature: 0,
+    //   });
+    //   const agent = await createToolCallingAgent({
+    //     llm,
+    //     tools,
+    //     prompt,
+    //   });
+    //   const agentExecutor = new AgentExecutor({
+    //     agent,
+    //     tools,
+    //   });
+    //   const input = "what is the current weather in SF?";
+    //   const result = await agentExecutor.invoke({
+    //     input,
+    //   });
+    //   console.log(result);
+    //   expect(result.input).toBe(input);
+    //   expect(typeof result.output).toBe("string");
+    //   // Length greater than 10 because any less than that would warrant
+    //   // an investigation into why such a short generation was returned.
+    //   expect(result.output.length).toBeGreaterThan(10);
+});
+export {};

package/dist/tests/chat_models-tools.int.test.d.ts

@@ -0,0 +1 @@
+export {};