@langchain/anthropic 0.1.2 → 0.1.4

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

@@ -4,6 +4,7 @@ import { test } from "@jest/globals";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { HumanMessage } from "@langchain/core/messages";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { ChatAnthropicTools } from "../tool_calling.js";
 test("Test ChatAnthropicTools", async () => {
     const chat = new ChatAnthropicTools({
@@ -189,12 +190,11 @@ 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"),
-        }),
+    }).withStructuredOutput(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.");
@@ -202,3 +202,63 @@ test("Test ChatAnthropic withStructuredOutput", async () => {
     console.log(JSON.stringify(res, null, 2));
     expect(res).toEqual({ name: "Alex", height: 5, hairColor: "blonde" });
 });
+test("Test ChatAnthropic withStructuredOutput on a single array item", async () => {
+    const runnable = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        maxRetries: 0,
+    }).withStructuredOutput(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 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({
+        people: [{ hairColor: "blonde", height: 5, name: "Alex" }],
+    });
+});
+test("Test ChatAnthropic withStructuredOutput on a single array item", async () => {
+    const runnable = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        maxRetries: 0,
+    }).withStructuredOutput(z.object({
+        sender: z
+            .optional(z.string())
+            .describe("The sender's name, if available"),
+        sender_phone_number: z
+            .optional(z.string())
+            .describe("The sender's phone number, if available"),
+        sender_address: z
+            .optional(z.string())
+            .describe("The sender's address, if available"),
+        action_items: z
+            .array(z.string())
+            .describe("A list of action items requested by the email"),
+        topic: z
+            .string()
+            .describe("High level description of what the email is about"),
+        tone: z.enum(["positive", "negative"]).describe("The tone of the email."),
+    }), {
+        name: "Email",
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        [
+            "human",
+            "What can you tell me about the following email? Make sure to answer in the correct format: {email}",
+        ],
+    ]);
+    const extractionChain = prompt.pipe(runnable);
+    const response = await extractionChain.invoke({
+        email: "From: Erick. The email is about the new project. The tone is positive. The action items are to send the report and to schedule a meeting.",
+    });
+    console.log(JSON.stringify(response, null, 2));
+    expect(response).toEqual({
+        sender: "Erick",
+        action_items: [expect.any(String), expect.any(String)],
+        topic: expect.any(String),
+        tone: "positive",
+    });
+});

package/dist/experimental/tool_calling.cjs

@@ -63,6 +63,7 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
         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
@@ -121,14 +122,20 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
             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),
-                        },
-                    })),
+                    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 {
@@ -144,14 +151,20 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
             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),
-                        },
-                    })),
+                    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 {
@@ -171,7 +184,24 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
     _llmType() {
         return "anthropic_tool_calling";
     }
-    withStructuredOutput({ schema, name, method, includeRaw, }) {
+    withStructuredOutput(outputSchema, config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let schema;
+        let name;
+        let method;
+        let includeRaw;
+        if (isStructuredOutputMethodParams(outputSchema)) {
+            schema = outputSchema.schema;
+            name = outputSchema.name;
+            method = outputSchema.method;
+            includeRaw = outputSchema.includeRaw;
+        }
+        else {
+            schema = outputSchema;
+            name = config?.name;
+            method = config?.method;
+            includeRaw = config?.includeRaw;
+        }
         if (method === "jsonMode") {
             throw new Error(`Anthropic only supports "functionCalling" as a method.`);
         }
@@ -245,3 +275,11 @@ function isZodSchema(input) {
     // Check for a characteristic method of Zod schemas
     return typeof input?.parse === "function";
 }
+function isStructuredOutputMethodParams(x
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    return (x !== undefined &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        typeof x.schema ===
+            "object");
+}

package/dist/experimental/tool_calling.d.ts

@@ -3,8 +3,9 @@ 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 { BaseLanguageModelCallOptions, BaseLanguageModelInput, StructuredOutputMethodParams, StructuredOutputMethodOptions, ToolDefinition } from "@langchain/core/language_models/base";
 import { Runnable } from "@langchain/core/runnables";
+import { z } from "zod";
 import { type AnthropicInput } from "../chat_models.js";
 export interface ChatAnthropicToolsCallOptions extends BaseLanguageModelCallOptions {
     tools?: ToolDefinition[];
@@ -43,8 +44,8 @@ export declare class ChatAnthropicTools extends BaseChatModel<ChatAnthropicTools
     }): 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, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, false> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, true> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;

package/dist/experimental/tool_calling.js

@@ -5,7 +5,7 @@ import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnable
 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";
+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.
@@ -60,6 +60,7 @@ export class ChatAnthropicTools extends BaseChatModel {
         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
@@ -118,14 +119,20 @@ export class ChatAnthropicTools extends BaseChatModel {
             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),
-                        },
-                    })),
+                    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 {
@@ -141,14 +148,20 @@ export class ChatAnthropicTools extends BaseChatModel {
             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),
-                        },
-                    })),
+                    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 {
@@ -168,7 +181,24 @@ export class ChatAnthropicTools extends BaseChatModel {
     _llmType() {
         return "anthropic_tool_calling";
     }
-    withStructuredOutput({ schema, name, method, includeRaw, }) {
+    withStructuredOutput(outputSchema, config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let schema;
+        let name;
+        let method;
+        let includeRaw;
+        if (isStructuredOutputMethodParams(outputSchema)) {
+            schema = outputSchema.schema;
+            name = outputSchema.name;
+            method = outputSchema.method;
+            includeRaw = outputSchema.includeRaw;
+        }
+        else {
+            schema = outputSchema;
+            name = config?.name;
+            method = config?.method;
+            includeRaw = config?.includeRaw;
+        }
         if (method === "jsonMode") {
             throw new Error(`Anthropic only supports "functionCalling" as a method.`);
         }
@@ -241,3 +271,11 @@ function isZodSchema(input) {
     // Check for a characteristic method of Zod schemas
     return typeof input?.parse === "function";
 }
+function isStructuredOutputMethodParams(x
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    return (x !== undefined &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        typeof x.schema ===
+            "object");
+}

package/dist/experimental/utils/tool_calling.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatAsXMLRepresentation = exports.DEFAULT_TOOL_SYSTEM_PROMPT = void 0;
+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 = 
@@ -50,3 +50,38 @@ ${parameterXml}
 </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

@@ -1,3 +1,4 @@
+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>;
@@ -6,3 +7,4 @@ export type ToolInvocation = {
     parameters: Record<string, unknown>;
 };
 export declare function formatAsXMLRepresentation(tool: ToolDefinition): string;
+export declare function fixArrayXMLParameters(schema: JsonSchema7ObjectType, xmlParameters: Record<string, any>): Record<string, any>;

package/dist/experimental/utils/tool_calling.js

@@ -46,3 +46,37 @@ ${parameterXml}
 </parameters>
 </tool_description>`;
 }
+export 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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/anthropic",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Anthropic integrations for LangChain.js",
   "type": "module",
   "engines": {