@langchain/anthropic 0.1.3 → 0.1.5

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

@@ -190,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.");
@@ -207,15 +206,13 @@ test("Test ChatAnthropic withStructuredOutput on a single array item", async ()
     const runnable = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
-    }).withStructuredOutput({
-        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"),
-            })),
-        }),
-    });
+    }).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));
@@ -227,25 +224,24 @@ test("Test ChatAnthropic withStructuredOutput on a single array item", async ()
     const runnable = new ChatAnthropicTools({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
-    }).withStructuredOutput({
-        schema: 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."),
-        }),
+    }).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([

package/dist/experimental/tool_calling.cjs

@@ -184,15 +184,29 @@ 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.`);
         }
         const functionName = name ?? "extract";
-        const outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
-            returnSingle: true,
-            keyName: functionName,
-        });
+        let outputParser;
         let tools;
         if (isZodSchema(schema)) {
             const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
@@ -206,6 +220,11 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
                     },
                 },
             ];
+            outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
+                returnSingle: true,
+                keyName: functionName,
+                zodSchema: schema,
+            });
         }
         else {
             tools = [
@@ -218,6 +237,10 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
                     },
                 },
             ];
+            outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
+                returnSingle: true,
+                keyName: functionName,
+            });
         }
         const llm = this.bind({
             tools,
@@ -254,7 +277,17 @@ class ChatAnthropicTools extends chat_models_1.BaseChatModel {
     }
 }
 exports.ChatAnthropicTools = ChatAnthropicTools;
-function isZodSchema(input) {
+function isZodSchema(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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

@@ -181,15 +181,29 @@ 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.`);
         }
         const functionName = name ?? "extract";
-        const outputParser = new JsonOutputKeyToolsParser({
-            returnSingle: true,
-            keyName: functionName,
-        });
+        let outputParser;
         let tools;
         if (isZodSchema(schema)) {
             const jsonSchema = zodToJsonSchema(schema);
@@ -203,6 +217,11 @@ export class ChatAnthropicTools extends BaseChatModel {
                     },
                 },
             ];
+            outputParser = new JsonOutputKeyToolsParser({
+                returnSingle: true,
+                keyName: functionName,
+                zodSchema: schema,
+            });
         }
         else {
             tools = [
@@ -215,6 +234,10 @@ export class ChatAnthropicTools extends BaseChatModel {
                     },
                 },
             ];
+            outputParser = new JsonOutputKeyToolsParser({
+                returnSingle: true,
+                keyName: functionName,
+            });
         }
         const llm = this.bind({
             tools,
@@ -250,7 +273,17 @@ export class ChatAnthropicTools extends BaseChatModel {
         });
     }
 }
-function isZodSchema(input) {
+function isZodSchema(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/anthropic",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Anthropic integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -39,7 +39,7 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.15.0",
-    "@langchain/core": "~0.1",
+    "@langchain/core": "~0.1.44",
     "fast-xml-parser": "^4.3.5",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.4"