@langchain/anthropic 0.1.1 → 0.1.2

package/dist/chat_models.cjs

@@ -6,6 +6,22 @@ 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");
+function _formatImage(imageUrl) {
+    const regex = /^data:(image\/.+);base64,(.+)$/;
+    const match = imageUrl.match(regex);
+    if (match === null) {
+        throw new Error([
+            "Anthropic only supports base64-encoded images currently.",
+            "Example: data:image/png;base64,/9j/4AAQSk...",
+        ].join("\n\n"));
+    }
+    return {
+        type: "base64",
+        media_type: match[1] ?? "",
+        data: match[2] ?? "",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    };
+}
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -243,16 +259,13 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         let system;
         if (messages.length > 0 && messages[0]._getType() === "system") {
             if (typeof messages[0].content !== "string") {
-                throw new Error("Currently only string content messages are supported.");
+                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 (typeof message.content !== "string") {
-                throw new Error("Currently only string content messages are supported.");
-            }
             if (message._getType() === "human") {
                 role = "user";
             }
@@ -265,10 +278,35 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             else {
                 throw new Error(`Message type "${message._getType()}" is not supported.`);
             }
-            return {
-                role,
-                content: message.content,
-            };
+            if (typeof message.content === "string") {
+                return {
+                    role,
+                    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 {
+                            return contentPart;
+                        }
+                    }),
+                };
+            }
         });
         return {
             messages: formattedMessages,
@@ -374,10 +412,6 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
     _llmType() {
         return "anthropic";
     }
-    /** @ignore */
-    _combineLLMOutput() {
-        return [];
-    }
 }
 exports.ChatAnthropicMessages = ChatAnthropicMessages;
 class ChatAnthropic extends ChatAnthropicMessages {

package/dist/chat_models.d.ts

@@ -165,8 +165,6 @@ export declare class ChatAnthropicMessages<CallOptions extends BaseLanguageModel
         signal?: AbortSignal;
     }): Promise<Anthropic.Message>;
     _llmType(): string;
-    /** @ignore */
-    _combineLLMOutput(): never[];
 }
 export declare class ChatAnthropic extends ChatAnthropicMessages {
 }

package/dist/chat_models.js

@@ -3,6 +3,22 @@ import { AIMessage, AIMessageChunk, } 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";
+function _formatImage(imageUrl) {
+    const regex = /^data:(image\/.+);base64,(.+)$/;
+    const match = imageUrl.match(regex);
+    if (match === null) {
+        throw new Error([
+            "Anthropic only supports base64-encoded images currently.",
+            "Example: data:image/png;base64,/9j/4AAQSk...",
+        ].join("\n\n"));
+    }
+    return {
+        type: "base64",
+        media_type: match[1] ?? "",
+        data: match[2] ?? "",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    };
+}
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -240,16 +256,13 @@ export class ChatAnthropicMessages extends BaseChatModel {
         let system;
         if (messages.length > 0 && messages[0]._getType() === "system") {
             if (typeof messages[0].content !== "string") {
-                throw new Error("Currently only string content messages are supported.");
+                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 (typeof message.content !== "string") {
-                throw new Error("Currently only string content messages are supported.");
-            }
             if (message._getType() === "human") {
                 role = "user";
             }
@@ -262,10 +275,35 @@ export class ChatAnthropicMessages extends BaseChatModel {
             else {
                 throw new Error(`Message type "${message._getType()}" is not supported.`);
             }
-            return {
-                role,
-                content: message.content,
-            };
+            if (typeof message.content === "string") {
+                return {
+                    role,
+                    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 {
+                            return contentPart;
+                        }
+                    }),
+                };
+            }
         });
         return {
             messages: formattedMessages,
@@ -371,10 +409,6 @@ export class ChatAnthropicMessages extends BaseChatModel {
     _llmType() {
         return "anthropic";
     }
-    /** @ignore */
-    _combineLLMOutput() {
-        return [];
-    }
 }
 export class ChatAnthropic extends ChatAnthropicMessages {
 }

package/dist/experimental/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tool_calling.cjs"), exports);

package/dist/experimental/index.d.ts

@@ -0,0 +1 @@
+export * from "./tool_calling.js";

package/dist/experimental/index.js

@@ -0,0 +1 @@
+export * from "./tool_calling.js";

package/dist/experimental/tests/tool_calling.int.test.d.ts

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

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

@@ -0,0 +1,204 @@
+/* eslint-disable no-process-env */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { test } from "@jest/globals";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { HumanMessage } from "@langchain/core/messages";
+import { ChatAnthropicTools } from "../tool_calling.js";
+test("Test ChatAnthropicTools", async () => {
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        maxRetries: 0,
+    });
+    const message = new HumanMessage("Hello!");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+});
+test("Test ChatAnthropicTools streaming", async () => {
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        maxRetries: 0,
+    });
+    const message = new HumanMessage("Hello!");
+    const stream = await chat.stream([message]);
+    const chunks = [];
+    for await (const chunk of stream) {
+        console.log(chunk);
+        chunks.push(chunk);
+    }
+    expect(chunks.length).toBeGreaterThan(1);
+});
+test("Test ChatAnthropicTools with tools", async () => {
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        temperature: 0.1,
+        maxRetries: 0,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "get_current_weather",
+                    description: "Get the current weather in a given location",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            location: {
+                                type: "string",
+                                description: "The city and state, e.g. San Francisco, CA",
+                            },
+                            unit: {
+                                type: "string",
+                                enum: ["celsius", "fahrenheit"],
+                            },
+                        },
+                        required: ["location"],
+                    },
+                },
+            },
+        ],
+    });
+    const message = new HumanMessage("What is the weather in San Francisco?");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+    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 () => {
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        temperature: 0.1,
+        maxRetries: 0,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "extract_data",
+                    description: "Return information about the input",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            sentiment: {
+                                type: "string",
+                                description: "The city and state, e.g. San Francisco, CA",
+                            },
+                            aggressiveness: {
+                                type: "integer",
+                                description: "How aggressive the input is from 1 to 10",
+                            },
+                            language: {
+                                type: "string",
+                                description: "The language the input is in",
+                            },
+                        },
+                        required: ["sentiment", "aggressiveness"],
+                    },
+                },
+            },
+        ],
+        tool_choice: { type: "function", function: { name: "extract_data" } },
+    });
+    const message = new HumanMessage("Extract the desired information from the following passage:\n\nthis is really cool");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+    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 () => {
+    const schema = z.object({
+        people: z.array(z.object({
+            name: z.string().describe("The name of a person"),
+            height: z.number().describe("The person's height"),
+            hairColor: z.optional(z.string()).describe("The person's hair color"),
+        })),
+    });
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        temperature: 0.1,
+        maxRetries: 0,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "information_extraction",
+                    description: "Extracts the relevant information from the passage.",
+                    parameters: zodToJsonSchema(schema),
+                },
+            },
+        ],
+        tool_choice: {
+            type: "function",
+            function: {
+                name: "information_extraction",
+            },
+        },
+    });
+    const message = new HumanMessage("Alex is 5 feet tall. Claudia is 1 foot taller than Alex and jumps higher than him. Claudia is a brunette and Alex is blonde.");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+    expect(res.additional_kwargs.tool_calls).toBeDefined();
+    expect(res.additional_kwargs.tool_calls?.[0]?.function.name).toEqual("information_extraction");
+    expect(JSON.parse(res.additional_kwargs.tool_calls?.[0]?.function.arguments ?? "")).toEqual({
+        people: expect.arrayContaining([
+            { name: "Alex", height: 5, hairColor: "blonde" },
+            { name: "Claudia", height: 6, hairColor: "brunette" },
+        ]),
+    });
+});
+test("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"),
+        hairColor: z.optional(z.string()).describe("The person's hair color"),
+    });
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        temperature: 0.1,
+        maxRetries: 0,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "person",
+                    description: "A person mentioned in the passage.",
+                    parameters: zodToJsonSchema(schema),
+                },
+            },
+        ],
+        tool_choice: {
+            type: "function",
+            function: {
+                name: "person",
+            },
+        },
+    });
+    console.log(zodToJsonSchema(schema));
+    const message = new HumanMessage("Alex is 5 feet tall. Claudia is 1 foot taller than Alex and jumps higher than him. Claudia is a brunette and Alex is blonde.");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+    expect(res.additional_kwargs.tool_calls).toBeDefined();
+    expect(res.additional_kwargs.tool_calls?.map((toolCall) => JSON.parse(toolCall.function.arguments ?? ""))).toEqual(expect.arrayContaining([
+        { name: "Alex", height: 5, hairColor: "blonde" },
+        { name: "Claudia", height: 6, hairColor: "brunette" },
+    ]));
+});
+test("Test ChatAnthropic withStructuredOutput", async () => {
+    const runnable = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        maxRetries: 0,
+    }).withStructuredOutput({
+        schema: z.object({
+            name: z.string().describe("The name of a person"),
+            height: z.number().describe("The person's height"),
+            hairColor: z.optional(z.string()).describe("The person's hair color"),
+        }),
+        name: "person",
+    });
+    const message = new HumanMessage("Alex is 5 feet tall. Alex is blonde.");
+    const res = await runnable.invoke([message]);
+    console.log(JSON.stringify(res, null, 2));
+    expect(res).toEqual({ name: "Alex", height: 5, hairColor: "blonde" });
+});

package/dist/experimental/tool_calling.cjs

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatAnthropicTools = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const messages_1 = require("@langchain/core/messages");
+const chat_models_1 = require("@langchain/core/language_models/chat_models");
+const runnables_1 = require("@langchain/core/runnables");
+const openai_tools_1 = require("@langchain/core/output_parsers/openai_tools");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const chat_models_js_1 = require("../chat_models.cjs");
+const tool_calling_js_1 = require("./utils/tool_calling.cjs");
+/**
+ * Experimental wrapper over Anthropic chat models that adds support for
+ * a function calling interface.
+ */
+class ChatAnthropicTools extends chat_models_1.BaseChatModel {
+    static lc_name() {
+        return "ChatAnthropicTools";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "llm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "systemPromptTemplate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "experimental", "chat_models"]
+        });
+        this.llm = fields?.llm ?? new chat_models_js_1.ChatAnthropic(fields);
+        this.systemPromptTemplate =
+            fields?.systemPromptTemplate ?? tool_calling_js_1.DEFAULT_TOOL_SYSTEM_PROMPT;
+        this.stopSequences =
+            fields?.stopSequences ?? this.llm.stopSequences;
+    }
+    invocationParams() {
+        return this.llm.invocationParams();
+    }
+    /** @ignore */
+    _identifyingParams() {
+        return this.llm._identifyingParams();
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        yield* this.llm._streamResponseChunks(messages, options, runManager);
+    }
+    async _prepareAndParseToolCall({ messages, options, runManager, systemPromptTemplate = tool_calling_js_1.DEFAULT_TOOL_SYSTEM_PROMPT, stopSequences, }) {
+        let promptMessages = messages;
+        let forced = false;
+        let toolCall;
+        if (options.tools !== undefined && options.tools.length > 0) {
+            const content = await systemPromptTemplate.format({
+                tools: `<tools>\n${options.tools
+                    .map(tool_calling_js_1.formatAsXMLRepresentation)
+                    .join("\n\n")}</tools>`,
+            });
+            if (promptMessages.length && promptMessages[0]._getType() !== "system") {
+                const systemMessage = new messages_1.SystemMessage({ content });
+                promptMessages = [systemMessage].concat(promptMessages);
+            }
+            else {
+                const systemMessage = new messages_1.SystemMessage({
+                    content: `${content}\n\n${promptMessages[0].content}`,
+                });
+                promptMessages = [systemMessage].concat(promptMessages.slice(1));
+            }
+            // eslint-disable-next-line no-param-reassign
+            options.stop = stopSequences.concat(["</function_calls>"]);
+            if (options.tool_choice && options.tool_choice !== "auto") {
+                toolCall = options.tool_choice.function.name;
+                forced = true;
+                const matchingFunction = options.tools.find(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (tool) => tool.function.name === toolCall);
+                if (!matchingFunction) {
+                    throw new Error(`No matching function found for passed "tool_choice"`);
+                }
+                promptMessages = promptMessages.concat([
+                    new messages_1.AIMessage({
+                        content: `<function_calls>\n<invoke><tool_name>${toolCall}</tool_name>`,
+                    }),
+                ]);
+                // eslint-disable-next-line no-param-reassign
+                delete options.tool_choice;
+            }
+            // eslint-disable-next-line no-param-reassign
+            delete options.tools;
+        }
+        else if (options.tool_choice !== undefined) {
+            throw new Error(`If "tool_choice" is provided, "tools" must also be.`);
+        }
+        const chatResult = await this.llm._generate(promptMessages, options, runManager);
+        const chatGenerationContent = chatResult.generations[0].message.content;
+        if (typeof chatGenerationContent !== "string") {
+            throw new Error("AnthropicFunctions does not support non-string output.");
+        }
+        if (forced) {
+            const parser = new fast_xml_parser_1.XMLParser();
+            const result = parser.parse(`<function_calls>\n<invoke><tool_name>${toolCall}</tool_name>${chatGenerationContent}</function_calls>`);
+            if (toolCall === undefined) {
+                throw new Error(`Could not parse called function from model output.`);
+            }
+            const invocations = Array.isArray(result.function_calls?.invoke ?? [])
+                ? result.function_calls.invoke
+                : [result.function_calls.invoke];
+            const responseMessageWithFunctions = new messages_1.AIMessage({
+                content: "",
+                additional_kwargs: {
+                    tool_calls: invocations.map((toolInvocation, i) => ({
+                        id: i.toString(),
+                        type: "function",
+                        function: {
+                            name: toolInvocation.tool_name,
+                            arguments: JSON.stringify(toolInvocation.parameters),
+                        },
+                    })),
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        else if (chatGenerationContent.includes("<function_calls>")) {
+            const parser = new fast_xml_parser_1.XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</function_calls>`);
+            const invocations = Array.isArray(result.function_calls?.invoke ?? [])
+                ? result.function_calls.invoke
+                : [result.function_calls.invoke];
+            const responseMessageWithFunctions = new messages_1.AIMessage({
+                content: chatGenerationContent.split("<function_calls>")[0],
+                additional_kwargs: {
+                    tool_calls: invocations.map((toolInvocation, i) => ({
+                        id: i.toString(),
+                        type: "function",
+                        function: {
+                            name: toolInvocation.tool_name,
+                            arguments: JSON.stringify(toolInvocation.parameters),
+                        },
+                    })),
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        return chatResult;
+    }
+    async _generate(messages, options, _runManager) {
+        return this._prepareAndParseToolCall({
+            messages,
+            options,
+            systemPromptTemplate: this.systemPromptTemplate,
+            stopSequences: this.stopSequences ?? [],
+        });
+    }
+    _llmType() {
+        return "anthropic_tool_calling";
+    }
+    withStructuredOutput({ schema, name, method, includeRaw, }) {
+        if (method === "jsonMode") {
+            throw new Error(`Anthropic only supports "functionCalling" as a method.`);
+        }
+        const functionName = name ?? "extract";
+        const outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
+            returnSingle: true,
+            keyName: functionName,
+        });
+        let tools;
+        if (isZodSchema(schema)) {
+            const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+            tools = [
+                {
+                    type: "function",
+                    function: {
+                        name: functionName,
+                        description: jsonSchema.description,
+                        parameters: jsonSchema,
+                    },
+                },
+            ];
+        }
+        else {
+            tools = [
+                {
+                    type: "function",
+                    function: {
+                        name: functionName,
+                        description: schema.description,
+                        parameters: schema,
+                    },
+                },
+            ];
+        }
+        const llm = this.bind({
+            tools,
+            tool_choice: {
+                type: "function",
+                function: {
+                    name: functionName,
+                },
+            },
+        });
+        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.ChatAnthropicTools = ChatAnthropicTools;
+function isZodSchema(input) {
+    // Check for a characteristic method of Zod schemas
+    return typeof input?.parse === "function";
+}

package/dist/experimental/tool_calling.d.ts

@@ -0,0 +1,51 @@
+import { BaseMessage } from "@langchain/core/messages";
+import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
+import { BaseChatModel, BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import { BaseLanguageModelCallOptions, BaseLanguageModelInput, StructuredOutputMethodParams, ToolDefinition } from "@langchain/core/language_models/base";
+import { Runnable } from "@langchain/core/runnables";
+import { type AnthropicInput } from "../chat_models.js";
+export interface ChatAnthropicToolsCallOptions extends BaseLanguageModelCallOptions {
+    tools?: ToolDefinition[];
+    tool_choice?: "auto" | {
+        function: {
+            name: string;
+        };
+        type: "function";
+    };
+}
+export type ChatAnthropicToolsInput = Partial<AnthropicInput> & BaseChatModelParams & {
+    llm?: BaseChatModel;
+    systemPromptTemplate?: BasePromptTemplate;
+};
+/**
+ * Experimental wrapper over Anthropic chat models that adds support for
+ * a function calling interface.
+ */
+export declare class ChatAnthropicTools extends BaseChatModel<ChatAnthropicToolsCallOptions> {
+    llm: BaseChatModel;
+    stopSequences?: string[];
+    systemPromptTemplate: BasePromptTemplate;
+    lc_namespace: string[];
+    static lc_name(): string;
+    constructor(fields?: ChatAnthropicToolsInput);
+    invocationParams(): any;
+    /** @ignore */
+    _identifyingParams(): Record<string, any>;
+    _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _prepareAndParseToolCall({ messages, options, runManager, systemPromptTemplate, stopSequences, }: {
+        messages: BaseMessage[];
+        options: ChatAnthropicToolsCallOptions;
+        runManager?: CallbackManagerForLLMRun;
+        systemPromptTemplate?: BasePromptTemplate;
+        stopSequences: string[];
+    }): Promise<ChatResult>;
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
+    _llmType(): string;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>({ schema, name, method, includeRaw, }: StructuredOutputMethodParams<RunOutput, false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>({ schema, name, method, includeRaw, }: StructuredOutputMethodParams<RunOutput, true>): Runnable<BaseLanguageModelInput, {
+        raw: BaseMessage;
+        parsed: RunOutput;
+    }>;
+}

package/dist/experimental/tool_calling.js

@@ -0,0 +1,243 @@
+import { XMLParser } from "fast-xml-parser";
+import { AIMessage, SystemMessage, } from "@langchain/core/messages";
+import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
+import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
+import { JsonOutputKeyToolsParser } from "@langchain/core/output_parsers/openai_tools";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { ChatAnthropic } from "../chat_models.js";
+import { DEFAULT_TOOL_SYSTEM_PROMPT, formatAsXMLRepresentation, } from "./utils/tool_calling.js";
+/**
+ * Experimental wrapper over Anthropic chat models that adds support for
+ * a function calling interface.
+ */
+export class ChatAnthropicTools extends BaseChatModel {
+    static lc_name() {
+        return "ChatAnthropicTools";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "llm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stopSequences", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "systemPromptTemplate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "experimental", "chat_models"]
+        });
+        this.llm = fields?.llm ?? new ChatAnthropic(fields);
+        this.systemPromptTemplate =
+            fields?.systemPromptTemplate ?? DEFAULT_TOOL_SYSTEM_PROMPT;
+        this.stopSequences =
+            fields?.stopSequences ?? this.llm.stopSequences;
+    }
+    invocationParams() {
+        return this.llm.invocationParams();
+    }
+    /** @ignore */
+    _identifyingParams() {
+        return this.llm._identifyingParams();
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        yield* this.llm._streamResponseChunks(messages, options, runManager);
+    }
+    async _prepareAndParseToolCall({ messages, options, runManager, systemPromptTemplate = DEFAULT_TOOL_SYSTEM_PROMPT, stopSequences, }) {
+        let promptMessages = messages;
+        let forced = false;
+        let toolCall;
+        if (options.tools !== undefined && options.tools.length > 0) {
+            const content = await systemPromptTemplate.format({
+                tools: `<tools>\n${options.tools
+                    .map(formatAsXMLRepresentation)
+                    .join("\n\n")}</tools>`,
+            });
+            if (promptMessages.length && promptMessages[0]._getType() !== "system") {
+                const systemMessage = new SystemMessage({ content });
+                promptMessages = [systemMessage].concat(promptMessages);
+            }
+            else {
+                const systemMessage = new SystemMessage({
+                    content: `${content}\n\n${promptMessages[0].content}`,
+                });
+                promptMessages = [systemMessage].concat(promptMessages.slice(1));
+            }
+            // eslint-disable-next-line no-param-reassign
+            options.stop = stopSequences.concat(["</function_calls>"]);
+            if (options.tool_choice && options.tool_choice !== "auto") {
+                toolCall = options.tool_choice.function.name;
+                forced = true;
+                const matchingFunction = options.tools.find(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (tool) => tool.function.name === toolCall);
+                if (!matchingFunction) {
+                    throw new Error(`No matching function found for passed "tool_choice"`);
+                }
+                promptMessages = promptMessages.concat([
+                    new AIMessage({
+                        content: `<function_calls>\n<invoke><tool_name>${toolCall}</tool_name>`,
+                    }),
+                ]);
+                // eslint-disable-next-line no-param-reassign
+                delete options.tool_choice;
+            }
+            // eslint-disable-next-line no-param-reassign
+            delete options.tools;
+        }
+        else if (options.tool_choice !== undefined) {
+            throw new Error(`If "tool_choice" is provided, "tools" must also be.`);
+        }
+        const chatResult = await this.llm._generate(promptMessages, options, runManager);
+        const chatGenerationContent = chatResult.generations[0].message.content;
+        if (typeof chatGenerationContent !== "string") {
+            throw new Error("AnthropicFunctions does not support non-string output.");
+        }
+        if (forced) {
+            const parser = new XMLParser();
+            const result = parser.parse(`<function_calls>\n<invoke><tool_name>${toolCall}</tool_name>${chatGenerationContent}</function_calls>`);
+            if (toolCall === undefined) {
+                throw new Error(`Could not parse called function from model output.`);
+            }
+            const invocations = Array.isArray(result.function_calls?.invoke ?? [])
+                ? result.function_calls.invoke
+                : [result.function_calls.invoke];
+            const responseMessageWithFunctions = new AIMessage({
+                content: "",
+                additional_kwargs: {
+                    tool_calls: invocations.map((toolInvocation, i) => ({
+                        id: i.toString(),
+                        type: "function",
+                        function: {
+                            name: toolInvocation.tool_name,
+                            arguments: JSON.stringify(toolInvocation.parameters),
+                        },
+                    })),
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        else if (chatGenerationContent.includes("<function_calls>")) {
+            const parser = new XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</function_calls>`);
+            const invocations = Array.isArray(result.function_calls?.invoke ?? [])
+                ? result.function_calls.invoke
+                : [result.function_calls.invoke];
+            const responseMessageWithFunctions = new AIMessage({
+                content: chatGenerationContent.split("<function_calls>")[0],
+                additional_kwargs: {
+                    tool_calls: invocations.map((toolInvocation, i) => ({
+                        id: i.toString(),
+                        type: "function",
+                        function: {
+                            name: toolInvocation.tool_name,
+                            arguments: JSON.stringify(toolInvocation.parameters),
+                        },
+                    })),
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        return chatResult;
+    }
+    async _generate(messages, options, _runManager) {
+        return this._prepareAndParseToolCall({
+            messages,
+            options,
+            systemPromptTemplate: this.systemPromptTemplate,
+            stopSequences: this.stopSequences ?? [],
+        });
+    }
+    _llmType() {
+        return "anthropic_tool_calling";
+    }
+    withStructuredOutput({ schema, name, method, includeRaw, }) {
+        if (method === "jsonMode") {
+            throw new Error(`Anthropic only supports "functionCalling" as a method.`);
+        }
+        const functionName = name ?? "extract";
+        const outputParser = new JsonOutputKeyToolsParser({
+            returnSingle: true,
+            keyName: functionName,
+        });
+        let tools;
+        if (isZodSchema(schema)) {
+            const jsonSchema = zodToJsonSchema(schema);
+            tools = [
+                {
+                    type: "function",
+                    function: {
+                        name: functionName,
+                        description: jsonSchema.description,
+                        parameters: jsonSchema,
+                    },
+                },
+            ];
+        }
+        else {
+            tools = [
+                {
+                    type: "function",
+                    function: {
+                        name: functionName,
+                        description: schema.description,
+                        parameters: schema,
+                    },
+                },
+            ];
+        }
+        const llm = this.bind({
+            tools,
+            tool_choice: {
+                type: "function",
+                function: {
+                    name: functionName,
+                },
+            },
+        });
+        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",
+        });
+    }
+}
+function isZodSchema(input) {
+    // Check for a characteristic method of Zod schemas
+    return typeof input?.parse === "function";
+}

package/dist/experimental/utils/tool_calling.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAsXMLRepresentation = exports.DEFAULT_TOOL_SYSTEM_PROMPT = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const prompts_1 = require("@langchain/core/prompts");
+exports.DEFAULT_TOOL_SYSTEM_PROMPT = 
+/* #__PURE__ */ prompts_1.PromptTemplate.fromTemplate(`In this environment you have access to a set of tools you can use to answer the user's question.
+
+You may call them like this:
+<function_calls>
+<invoke>
+<tool_name>$TOOL_NAME</tool_name>
+<parameters>
+<$PARAMETER_NAME>$PARAMETER_VALUE</$PARAMETER_NAME>
+...
+</parameters>
+</invoke>
+</function_calls>
+
+Here are the tools available:
+{tools}`);
+function formatAsXMLRepresentation(tool) {
+    const builder = new fast_xml_parser_1.XMLBuilder();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const toolParamProps = tool.function.parameters?.properties;
+    const parameterXml = Object.keys(toolParamProps)
+        .map((key) => {
+        const parameterData = toolParamProps[key];
+        let xml = `<parameter>
+<name>${key}</name>
+<type>${parameterData.type}</type>`;
+        if (parameterData.description) {
+            xml += `\n<description>${parameterData.description}</description>`;
+        }
+        if (parameterData.type === "array" && parameterData.items) {
+            xml += `\n<items>${builder.build(parameterData.items.properties)}</items>`;
+        }
+        if (parameterData.properties) {
+            xml += `\n<properties>\n${builder.build(parameterData.properties)}\n</properties>`;
+        }
+        return `${xml}\n</parameter>`;
+    })
+        .join("\n");
+    return `<tool_description>
+<tool_name>${tool.function.name}</tool_name>
+<description>${tool.function.description}</description>
+<parameters>
+${parameterXml}
+</parameters>
+</tool_description>`;
+}
+exports.formatAsXMLRepresentation = formatAsXMLRepresentation;

package/dist/experimental/utils/tool_calling.d.ts

@@ -0,0 +1,8 @@
+import { PromptTemplate } from "@langchain/core/prompts";
+import { ToolDefinition } from "@langchain/core/language_models/base";
+export declare const DEFAULT_TOOL_SYSTEM_PROMPT: PromptTemplate<import("@langchain/core/prompts").ParamsFromFString<"In this environment you have access to a set of tools you can use to answer the user's question.\n\nYou may call them like this:\n<function_calls>\n<invoke>\n<tool_name>$TOOL_NAME</tool_name>\n<parameters>\n<$PARAMETER_NAME>$PARAMETER_VALUE</$PARAMETER_NAME>\n...\n</parameters>\n</invoke>\n</function_calls>\n\nHere are the tools available:\n{tools}">, any>;
+export type ToolInvocation = {
+    tool_name: string;
+    parameters: Record<string, unknown>;
+};
+export declare function formatAsXMLRepresentation(tool: ToolDefinition): string;

package/dist/experimental/utils/tool_calling.js

@@ -0,0 +1,48 @@
+import { XMLBuilder } from "fast-xml-parser";
+import { PromptTemplate } from "@langchain/core/prompts";
+export const DEFAULT_TOOL_SYSTEM_PROMPT = 
+/* #__PURE__ */ PromptTemplate.fromTemplate(`In this environment you have access to a set of tools you can use to answer the user's question.
+
+You may call them like this:
+<function_calls>
+<invoke>
+<tool_name>$TOOL_NAME</tool_name>
+<parameters>
+<$PARAMETER_NAME>$PARAMETER_VALUE</$PARAMETER_NAME>
+...
+</parameters>
+</invoke>
+</function_calls>
+
+Here are the tools available:
+{tools}`);
+export function formatAsXMLRepresentation(tool) {
+    const builder = new XMLBuilder();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const toolParamProps = tool.function.parameters?.properties;
+    const parameterXml = Object.keys(toolParamProps)
+        .map((key) => {
+        const parameterData = toolParamProps[key];
+        let xml = `<parameter>
+<name>${key}</name>
+<type>${parameterData.type}</type>`;
+        if (parameterData.description) {
+            xml += `\n<description>${parameterData.description}</description>`;
+        }
+        if (parameterData.type === "array" && parameterData.items) {
+            xml += `\n<items>${builder.build(parameterData.items.properties)}</items>`;
+        }
+        if (parameterData.properties) {
+            xml += `\n<properties>\n${builder.build(parameterData.properties)}\n</properties>`;
+        }
+        return `${xml}\n</parameter>`;
+    })
+        .join("\n");
+    return `<tool_description>
+<tool_name>${tool.function.name}</tool_name>
+<description>${tool.function.description}</description>
+<parameters>
+${parameterXml}
+</parameters>
+</tool_description>`;
+}

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

@@ -30,7 +30,7 @@ test("Test ChatAnthropic Generate", async () => {
     }
     console.log({ res });
 });
-test("Test ChatAnthropic Generate w/ ClientOptions", async () => {
+test.skip("Test ChatAnthropic Generate w/ ClientOptions", async () => {
     const chat = new ChatAnthropic({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -127,7 +127,7 @@ test("Test ChatAnthropic in streaming mode with a signal", async () => {
     }).rejects.toThrow();
     console.log({ nrNewTokens, streamedCompletion });
 }, 5000);
-test("Test ChatAnthropic prompt value", async () => {
+test.skip("Test ChatAnthropic prompt value", async () => {
     const chat = new ChatAnthropic({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -142,7 +142,7 @@ test("Test ChatAnthropic prompt value", async () => {
     }
     console.log({ res });
 });
-test("ChatAnthropic, docs, prompt templates", async () => {
+test.skip("ChatAnthropic, docs, prompt templates", async () => {
     const chat = new ChatAnthropic({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -162,7 +162,7 @@ test("ChatAnthropic, docs, prompt templates", async () => {
     ]);
     console.log(responseA.generations);
 });
-test("ChatAnthropic, longer chain of messages", async () => {
+test.skip("ChatAnthropic, longer chain of messages", async () => {
     const chat = new ChatAnthropic({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -180,7 +180,7 @@ test("ChatAnthropic, longer chain of messages", async () => {
     ]);
     console.log(responseA.generations);
 });
-test("ChatAnthropic, Anthropic apiUrl set manually via constructor", async () => {
+test.skip("ChatAnthropic, Anthropic apiUrl set manually via constructor", async () => {
     // Pass the default URL through (should use this, and work as normal)
     const anthropicApiUrl = "https://api.anthropic.com";
     const chat = new ChatAnthropic({
@@ -249,6 +249,26 @@ test("Test ChatAnthropic headers passed through", async () => {
         },
     });
     const message = new HumanMessage("Hello!");
-    const res = await chat.call([message]);
+    const res = await chat.invoke([message]);
     console.log({ res });
 });
+test("Test ChatAnthropic multimodal", async () => {
+    const chat = new ChatAnthropic({
+        modelName: "claude-3-sonnet-20240229",
+        maxRetries: 0,
+    });
+    const res = await chat.invoke([
+        new HumanMessage({
+            content: [
+                {
+                    type: "image_url",
+                    image_url: {
+                        url: "data:image/jpeg;base64,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",
+                    },
+                },
+                { type: "text", text: "What is this a logo for?" },
+            ],
+        }),
+    ]);
+    console.log(res);
+});

package/experimental.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/experimental/index.cjs');

package/experimental.d.cts

@@ -0,0 +1 @@
+export * from './dist/experimental/index.js'

package/experimental.d.ts

@@ -0,0 +1 @@
+export * from './dist/experimental/index.js'

package/experimental.js

@@ -0,0 +1 @@
+export * from './dist/experimental/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/anthropic",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Anthropic integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -39,10 +39,14 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.15.0",
-    "@langchain/core": "~0.1"
+    "@langchain/core": "~0.1",
+    "fast-xml-parser": "^4.3.5",
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.22.4"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
+    "@langchain/community": "workspace:^",
     "@langchain/scripts": "~0.0",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
@@ -88,6 +92,15 @@
       "import": "./index.js",
       "require": "./index.cjs"
     },
+    "./experimental": {
+      "types": {
+        "import": "./experimental.d.ts",
+        "require": "./experimental.d.cts",
+        "default": "./experimental.d.ts"
+      },
+      "import": "./experimental.js",
+      "require": "./experimental.cjs"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -95,6 +108,10 @@
     "index.cjs",
     "index.js",
     "index.d.ts",
-    "index.d.cts"
+    "index.d.cts",
+    "experimental.cjs",
+    "experimental.js",
+    "experimental.d.ts",
+    "experimental.d.cts"
   ]
 }