@langchain/anthropic 0.1.6 → 0.1.7

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

@@ -262,3 +262,17 @@ test("Test ChatAnthropic withStructuredOutput on a single array item", async ()
         tone: "positive",
     });
 });
+test("Test ChatAnthropicTools", async () => {
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        maxRetries: 0,
+    });
+    const structured = chat.withStructuredOutput(z.object({
+        nested: z.array(z.number()),
+    }), { force: false });
+    const res = await structured.invoke("What are the first five natural numbers?");
+    console.log(res);
+    expect(res).toEqual({
+        nested: [1, 2, 3, 4, 5],
+    });
+});

package/dist/experimental/tool_calling.cjs

@@ -18,6 +18,9 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
         return "ChatAnthropicTools";
     }
     constructor(fields) {
+        if (fields?.cache !== undefined) {
+            throw new Error("Caching is not supported for this model.");
+        }
         super(fields ?? {});
         Object.defineProperty(this, "llm", {
             enumerable: true,
@@ -59,7 +62,7 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
     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, }) {
+    async _prepareAndParseToolCall({ messages, options, systemPromptTemplate = tool_calling_js_1.DEFAULT_TOOL_SYSTEM_PROMPT, stopSequences, }) {
         let promptMessages = messages;
         let forced = false;
         let toolCall;
@@ -105,8 +108,10 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
         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;
+        const chatResult = await this.llm
+            .withConfig({ runName: "ChatAnthropicTools" })
+            .invoke(promptMessages, options);
+        const chatGenerationContent = chatResult.content;
         if (typeof chatGenerationContent !== "string") {
             throw new Error("AnthropicFunctions does not support non-string output.");
         }
@@ -171,15 +176,25 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
                 generations: [{ message: responseMessageWithFunctions, text: "" }],
             };
         }
-        return chatResult;
+        return { generations: [{ message: chatResult, text: "" }] };
     }
-    async _generate(messages, options, _runManager) {
-        return this._prepareAndParseToolCall({
-            messages,
-            options,
+    async generate(messages, parsedOptions, callbacks) {
+        const baseMessages = messages.map((messageList) => messageList.map(messages_1.coerceMessageLikeToMessage));
+        // generate results
+        const chatResults = await Promise.all(baseMessages.map((messageList) => this._prepareAndParseToolCall({
+            messages: messageList,
+            options: { callbacks, ...parsedOptions },
             systemPromptTemplate: this.systemPromptTemplate,
             stopSequences: this.stopSequences ?? [],
-        });
+        })));
+        // create combined output
+        const output = {
+            generations: chatResults.map((chatResult) => chatResult.generations),
+        };
+        return output;
+    }
+    async _generate(_messages, _options, _runManager) {
+        throw new Error("Unused.");
     }
     _llmType() {
         return "anthropic_tool_calling";
@@ -190,6 +205,7 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
         let name;
         let method;
         let includeRaw;
+        let force;
         if (isStructuredOutputMethodParams(outputSchema)) {
             schema = outputSchema.schema;
             name = outputSchema.name;
@@ -201,6 +217,7 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
             name = config?.name;
             method = config?.method;
             includeRaw = config?.includeRaw;
+            force = config?.force ?? true;
         }
         if (method === "jsonMode") {
             throw new Error(`Anthropic only supports "functionCalling" as a method.`);
@@ -244,12 +261,14 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
         }
         const llm = this.bind({
             tools,
-            tool_choice: {
-                type: "function",
-                function: {
-                    name: functionName,
-                },
-            },
+            tool_choice: force
+                ? {
+                    type: "function",
+                    function: {
+                        name: functionName,
+                    },
+                }
+                : "auto",
         });
         if (!includeRaw) {
             return llm.pipe(outputParser).withConfig({

package/dist/experimental/tool_calling.d.ts

@@ -1,7 +1,7 @@
-import { BaseMessage } from "@langchain/core/messages";
-import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
+import { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
+import type { ChatGenerationChunk, ChatResult, LLMResult } from "@langchain/core/outputs";
 import { BaseChatModel, BaseChatModelParams } from "@langchain/core/language_models/chat_models";
-import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
+import { CallbackManagerForLLMRun, Callbacks } from "@langchain/core/callbacks/manager";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelCallOptions, BaseLanguageModelInput, StructuredOutputMethodParams, StructuredOutputMethodOptions, ToolDefinition } from "@langchain/core/language_models/base";
 import { Runnable } from "@langchain/core/runnables";
@@ -35,17 +35,21 @@ export declare class ChatAnthropicTools extends BaseChatModel<ChatAnthropicTools
     /** @ignore */
     _identifyingParams(): Record<string, any>;
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    _prepareAndParseToolCall({ messages, options, runManager, systemPromptTemplate, stopSequences, }: {
+    _prepareAndParseToolCall({ messages, options, 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>;
+    generate(messages: BaseMessageLike[][], parsedOptions?: ChatAnthropicToolsCallOptions, callbacks?: Callbacks): Promise<LLMResult>;
+    _generate(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
     _llmType(): string;
-    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, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, false> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false> & {
+        force?: boolean;
+    }): 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> & {
+        force?: boolean;
+    }): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;

package/dist/experimental/tool_calling.js

@@ -1,5 +1,5 @@
 import { XMLParser } from "fast-xml-parser";
-import { AIMessage, SystemMessage, } from "@langchain/core/messages";
+import { AIMessage, SystemMessage, coerceMessageLikeToMessage, } 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";
@@ -15,6 +15,9 @@ export class ChatAnthropicTools extends BaseChatModel {
         return "ChatAnthropicTools";
     }
     constructor(fields) {
+        if (fields?.cache !== undefined) {
+            throw new Error("Caching is not supported for this model.");
+        }
         super(fields ?? {});
         Object.defineProperty(this, "llm", {
             enumerable: true,
@@ -56,7 +59,7 @@ export class ChatAnthropicTools extends BaseChatModel {
     async *_streamResponseChunks(messages, options, runManager) {
         yield* this.llm._streamResponseChunks(messages, options, runManager);
     }
-    async _prepareAndParseToolCall({ messages, options, runManager, systemPromptTemplate = DEFAULT_TOOL_SYSTEM_PROMPT, stopSequences, }) {
+    async _prepareAndParseToolCall({ messages, options, systemPromptTemplate = DEFAULT_TOOL_SYSTEM_PROMPT, stopSequences, }) {
         let promptMessages = messages;
         let forced = false;
         let toolCall;
@@ -102,8 +105,10 @@ export class ChatAnthropicTools extends BaseChatModel {
         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;
+        const chatResult = await this.llm
+            .withConfig({ runName: "ChatAnthropicTools" })
+            .invoke(promptMessages, options);
+        const chatGenerationContent = chatResult.content;
         if (typeof chatGenerationContent !== "string") {
             throw new Error("AnthropicFunctions does not support non-string output.");
         }
@@ -168,15 +173,25 @@ export class ChatAnthropicTools extends BaseChatModel {
                 generations: [{ message: responseMessageWithFunctions, text: "" }],
             };
         }
-        return chatResult;
+        return { generations: [{ message: chatResult, text: "" }] };
     }
-    async _generate(messages, options, _runManager) {
-        return this._prepareAndParseToolCall({
-            messages,
-            options,
+    async generate(messages, parsedOptions, callbacks) {
+        const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
+        // generate results
+        const chatResults = await Promise.all(baseMessages.map((messageList) => this._prepareAndParseToolCall({
+            messages: messageList,
+            options: { callbacks, ...parsedOptions },
             systemPromptTemplate: this.systemPromptTemplate,
             stopSequences: this.stopSequences ?? [],
-        });
+        })));
+        // create combined output
+        const output = {
+            generations: chatResults.map((chatResult) => chatResult.generations),
+        };
+        return output;
+    }
+    async _generate(_messages, _options, _runManager) {
+        throw new Error("Unused.");
     }
     _llmType() {
         return "anthropic_tool_calling";
@@ -187,6 +202,7 @@ export class ChatAnthropicTools extends BaseChatModel {
         let name;
         let method;
         let includeRaw;
+        let force;
         if (isStructuredOutputMethodParams(outputSchema)) {
             schema = outputSchema.schema;
             name = outputSchema.name;
@@ -198,6 +214,7 @@ export class ChatAnthropicTools extends BaseChatModel {
             name = config?.name;
             method = config?.method;
             includeRaw = config?.includeRaw;
+            force = config?.force ?? true;
         }
         if (method === "jsonMode") {
             throw new Error(`Anthropic only supports "functionCalling" as a method.`);
@@ -241,12 +258,14 @@ export class ChatAnthropicTools extends BaseChatModel {
         }
         const llm = this.bind({
             tools,
-            tool_choice: {
-                type: "function",
-                function: {
-                    name: functionName,
-                },
-            },
+            tool_choice: force
+                ? {
+                    type: "function",
+                    function: {
+                        name: functionName,
+                    },
+                }
+                : "auto",
         });
         if (!includeRaw) {
             return llm.pipe(outputParser).withConfig({

package/dist/experimental/utils/tool_calling.cjs

@@ -62,9 +62,21 @@ xmlParameters
         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]];
+            const value = xmlParameters[key];
+            if (Array.isArray(value)) {
+                fixedParameters[key] = value;
+            }
+            else if (typeof value === "string") {
+                if (value.startsWith("[") && value.endsWith("]")) {
+                    fixedParameters[key] = JSON.parse(value);
+                }
+                else {
+                    fixedParameters[key] = value.split(",");
+                }
+            }
+            else {
+                fixedParameters[key] = [value];
+            }
             // Crawl for objects like {"item": "my string"} that should really just be "my string"
             if (schemaType !== "object" &&
                 typeof xmlParameters[key] === "object" &&

package/dist/experimental/utils/tool_calling.js

@@ -58,9 +58,21 @@ xmlParameters
         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]];
+            const value = xmlParameters[key];
+            if (Array.isArray(value)) {
+                fixedParameters[key] = value;
+            }
+            else if (typeof value === "string") {
+                if (value.startsWith("[") && value.endsWith("]")) {
+                    fixedParameters[key] = JSON.parse(value);
+                }
+                else {
+                    fixedParameters[key] = value.split(",");
+                }
+            }
+            else {
+                fixedParameters[key] = [value];
+            }
             // Crawl for objects like {"item": "my string"} that should really just be "my string"
             if (schemaType !== "object" &&
                 typeof xmlParameters[key] === "object" &&

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

@@ -95,7 +95,7 @@ test("Test ChatAnthropic in streaming mode", async () => {
         }),
     });
     const message = new HumanMessage("Hello!");
-    const res = await model.call([message]);
+    const res = await model.invoke([message]);
     console.log({ res });
     expect(nrNewTokens > 0).toBe(true);
     expect(res.content).toBe(streamedCompletion);
@@ -117,7 +117,7 @@ test("Test ChatAnthropic in streaming mode with a signal", async () => {
     const controller = new AbortController();
     const message = new HumanMessage("Hello! Give me an extremely verbose response");
     await expect(() => {
-        const res = model.call([message], {
+        const res = model.invoke([message], {
             signal: controller.signal,
         });
         setTimeout(() => {

package/package.json

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