@langchain/anthropic 0.1.1 → 0.1.3

package/dist/experimental/tool_calling.cjs

@@ -0,0 +1,260 @@
+"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;
+        const tools = options.tools === undefined ? [] : [...options.tools];
+        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) => {
+                        const calledTool = tools.find((tool) => tool.function.name === toolCall);
+                        if (calledTool === undefined) {
+                            throw new Error(`Called tool "${toolCall}" did not match an existing tool.`);
+                        }
+                        return {
+                            id: i.toString(),
+                            type: "function",
+                            function: {
+                                name: toolInvocation.tool_name,
+                                arguments: JSON.stringify((0, tool_calling_js_1.fixArrayXMLParameters)(calledTool.function.parameters, 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) => {
+                        const calledTool = tools.find((tool) => tool.function.name === toolInvocation.tool_name);
+                        if (calledTool === undefined) {
+                            throw new Error(`Called tool "${toolCall}" did not match an existing tool.`);
+                        }
+                        return {
+                            id: i.toString(),
+                            type: "function",
+                            function: {
+                                name: toolInvocation.tool_name,
+                                arguments: JSON.stringify((0, tool_calling_js_1.fixArrayXMLParameters)(calledTool.function.parameters, 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,256 @@
+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, fixArrayXMLParameters, } 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;
+        const tools = options.tools === undefined ? [] : [...options.tools];
+        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) => {
+                        const calledTool = tools.find((tool) => tool.function.name === toolCall);
+                        if (calledTool === undefined) {
+                            throw new Error(`Called tool "${toolCall}" did not match an existing tool.`);
+                        }
+                        return {
+                            id: i.toString(),
+                            type: "function",
+                            function: {
+                                name: toolInvocation.tool_name,
+                                arguments: JSON.stringify(fixArrayXMLParameters(calledTool.function.parameters, 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) => {
+                        const calledTool = tools.find((tool) => tool.function.name === toolInvocation.tool_name);
+                        if (calledTool === undefined) {
+                            throw new Error(`Called tool "${toolCall}" did not match an existing tool.`);
+                        }
+                        return {
+                            id: i.toString(),
+                            type: "function",
+                            function: {
+                                name: toolInvocation.tool_name,
+                                arguments: JSON.stringify(fixArrayXMLParameters(calledTool.function.parameters, 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,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixArrayXMLParameters = 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;
+function fixArrayXMLParameters(schema, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+xmlParameters
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const fixedParameters = {};
+    for (const key of Object.keys(xmlParameters)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const schemaType = schema.properties[key].type;
+        // Crawl for lists indistinguishable from single items
+        if (schema.properties && schema.properties[key] && schemaType === "array") {
+            fixedParameters[key] = Array.isArray(xmlParameters[key])
+                ? xmlParameters[key]
+                : [xmlParameters[key]];
+            // Crawl for objects like {"item": "my string"} that should really just be "my string"
+            if (schemaType !== "object" &&
+                typeof xmlParameters[key] === "object" &&
+                !Array.isArray(xmlParameters[key]) &&
+                Object.keys(xmlParameters[key]).length === 1) {
+                // eslint-disable-next-line prefer-destructuring
+                fixedParameters[key] = Object.values(xmlParameters[key])[0];
+            }
+        }
+        else if (typeof xmlParameters[key] === "object" &&
+            xmlParameters[key] !== null) {
+            fixedParameters[key] = fixArrayXMLParameters(schema, xmlParameters[key]);
+        }
+        else {
+            fixedParameters[key] = xmlParameters[key];
+        }
+    }
+    return fixedParameters;
+}
+exports.fixArrayXMLParameters = fixArrayXMLParameters;

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

@@ -0,0 +1,10 @@
+import { JsonSchema7ObjectType } from "zod-to-json-schema";
+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;
+export declare function fixArrayXMLParameters(schema: JsonSchema7ObjectType, xmlParameters: Record<string, any>): Record<string, any>;