@langchain/anthropic 0.1.9 → 0.1.11

package/dist/output_parsers.cjs

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicToolsOutputParser = void 0;
+const output_parsers_1 = require("@langchain/core/output_parsers");
+class AnthropicToolsOutputParser extends output_parsers_1.BaseLLMOutputParser {
+    static lc_name() {
+        return "AnthropicToolsOutputParser";
+    }
+    constructor(params) {
+        super(params);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "anthropic", "output_parsers"]
+        });
+        Object.defineProperty(this, "returnId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** The type of tool calls to return. */
+        Object.defineProperty(this, "keyName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether to return only the first tool call. */
+        Object.defineProperty(this, "returnSingle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "zodSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keyName = params.keyName;
+        this.returnSingle = params.returnSingle ?? this.returnSingle;
+        this.zodSchema = params.zodSchema;
+    }
+    async _validateResult(result) {
+        if (this.zodSchema === undefined) {
+            return result;
+        }
+        const zodParsedResult = await this.zodSchema.safeParseAsync(result);
+        if (zodParsedResult.success) {
+            return zodParsedResult.data;
+        }
+        else {
+            throw new output_parsers_1.OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(result, null, 2));
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parseResult(generations) {
+        const tools = generations.flatMap((generation) => {
+            const { message } = generation;
+            if (typeof message === "string") {
+                return [];
+            }
+            if (!Array.isArray(message.content)) {
+                return [];
+            }
+            const tool = message.content.find((item) => item.type === "tool_use");
+            return tool;
+        });
+        if (tools[0] === undefined) {
+            throw new Error("No parseable tool calls provided to AnthropicToolsOutputParser.");
+        }
+        const [tool] = tools;
+        const validatedResult = await this._validateResult(tool.input);
+        return validatedResult;
+    }
+}
+exports.AnthropicToolsOutputParser = AnthropicToolsOutputParser;

package/dist/output_parsers.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
+import { JsonOutputKeyToolsParserParams } from "@langchain/core/output_parsers/openai_tools";
+import { ChatGeneration } from "@langchain/core/outputs";
+interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParams<T> {
+}
+export declare class AnthropicToolsOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    returnId: boolean;
+    /** The type of tool calls to return. */
+    keyName: string;
+    /** Whether to return only the first tool call. */
+    returnSingle: boolean;
+    zodSchema?: z.ZodType<T>;
+    constructor(params: AnthropicToolsOutputParserParams<T>);
+    protected _validateResult(result: unknown): Promise<T>;
+    parseResult(generations: ChatGeneration[]): Promise<T>;
+}
+export {};

package/dist/output_parsers.js

@@ -0,0 +1,76 @@
+import { BaseLLMOutputParser, OutputParserException, } from "@langchain/core/output_parsers";
+export class AnthropicToolsOutputParser extends BaseLLMOutputParser {
+    static lc_name() {
+        return "AnthropicToolsOutputParser";
+    }
+    constructor(params) {
+        super(params);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "anthropic", "output_parsers"]
+        });
+        Object.defineProperty(this, "returnId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** The type of tool calls to return. */
+        Object.defineProperty(this, "keyName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether to return only the first tool call. */
+        Object.defineProperty(this, "returnSingle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "zodSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keyName = params.keyName;
+        this.returnSingle = params.returnSingle ?? this.returnSingle;
+        this.zodSchema = params.zodSchema;
+    }
+    async _validateResult(result) {
+        if (this.zodSchema === undefined) {
+            return result;
+        }
+        const zodParsedResult = await this.zodSchema.safeParseAsync(result);
+        if (zodParsedResult.success) {
+            return zodParsedResult.data;
+        }
+        else {
+            throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, JSON.stringify(result, null, 2));
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async parseResult(generations) {
+        const tools = generations.flatMap((generation) => {
+            const { message } = generation;
+            if (typeof message === "string") {
+                return [];
+            }
+            if (!Array.isArray(message.content)) {
+                return [];
+            }
+            const tool = message.content.find((item) => item.type === "tool_use");
+            return tool;
+        });
+        if (tools[0] === undefined) {
+            throw new Error("No parseable tool calls provided to AnthropicToolsOutputParser.");
+        }
+        const [tool] = tools;
+        const validatedResult = await this._validateResult(tool.input);
+        return validatedResult;
+    }
+}

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

@@ -4,6 +4,9 @@ import { HumanMessage } from "@langchain/core/messages";
 import { ChatPromptValue } from "@langchain/core/prompt_values";
 import { PromptTemplate, ChatPromptTemplate, AIMessagePromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate, } from "@langchain/core/prompts";
 import { CallbackManager } from "@langchain/core/callbacks/manager";
+import { StructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
 import { ChatAnthropic } from "../chat_models.js";
 test.skip("Test ChatAnthropic", async () => {
     const chat = new ChatAnthropic({
@@ -272,3 +275,178 @@ test("Test ChatAnthropic multimodal", async () => {
     ]);
     console.log(res);
 });
+describe("Tool calling", () => {
+    const zodSchema = z
+        .object({
+        location: z.string().describe("The name of city to get the weather for."),
+    })
+        .describe("Get the weather of a specific location and return the temperature in Celsius.");
+    class WeatherTool extends StructuredTool {
+        constructor() {
+            super(...arguments);
+            Object.defineProperty(this, "schema", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: z.object({
+                    location: z.string().describe("The name of city to get the weather for."),
+                })
+            });
+            Object.defineProperty(this, "description", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: "Get the weather of a specific location and return the temperature in Celsius."
+            });
+            Object.defineProperty(this, "name", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: "get_weather"
+            });
+        }
+        async _call(input) {
+            console.log(`WeatherTool called with input: ${input}`);
+            return `The weather in ${input.location} is 25°C`;
+        }
+    }
+    const model = new ChatAnthropic({
+        modelName: "claude-3-sonnet-20240229",
+        temperature: 0,
+    });
+    const anthropicTool = {
+        name: "get_weather",
+        description: "Get the weather of a specific location and return the temperature in Celsius.",
+        input_schema: {
+            type: "object",
+            properties: {
+                location: {
+                    type: "string",
+                    description: "The name of city to get the weather for.",
+                },
+            },
+            required: ["location"],
+        },
+    };
+    test("Can bind & invoke StructuredTools", async () => {
+        const tools = [new WeatherTool()];
+        const modelWithTools = model.bind({
+            tools,
+        });
+        const result = await modelWithTools.invoke("What is the weather in London today?");
+        console.log({
+            tool_calls: JSON.stringify(result.content, null, 2),
+        }, "Can bind & invoke StructuredTools");
+        expect(Array.isArray(result.content)).toBeTruthy();
+        if (!Array.isArray(result.content)) {
+            throw new Error("Content is not an array");
+        }
+        let toolCall;
+        result.content.forEach((item) => {
+            if (item.type === "tool_use") {
+                toolCall = item;
+            }
+        });
+        if (!toolCall) {
+            throw new Error("No tool call found");
+        }
+        expect(toolCall).toBeTruthy();
+        const { name, input } = toolCall;
+        expect(name).toBe("get_weather");
+        expect(input).toBeTruthy();
+        expect(input.location).toBeTruthy();
+    });
+    test("Can bind & invoke AnthropicTools", async () => {
+        const modelWithTools = model.bind({
+            tools: [anthropicTool],
+        });
+        const result = await modelWithTools.invoke("What is the weather in London today?");
+        console.log({
+            tool_calls: JSON.stringify(result.content, null, 2),
+        }, "Can bind & invoke StructuredTools");
+        expect(Array.isArray(result.content)).toBeTruthy();
+        if (!Array.isArray(result.content)) {
+            throw new Error("Content is not an array");
+        }
+        let toolCall;
+        result.content.forEach((item) => {
+            if (item.type === "tool_use") {
+                toolCall = item;
+            }
+        });
+        if (!toolCall) {
+            throw new Error("No tool call found");
+        }
+        expect(toolCall).toBeTruthy();
+        const { name, input } = toolCall;
+        expect(name).toBe("get_weather");
+        expect(input).toBeTruthy();
+        expect(input.location).toBeTruthy();
+    });
+    test("Can bind & stream AnthropicTools", async () => {
+        const modelWithTools = model.bind({
+            tools: [anthropicTool],
+        });
+        const result = await modelWithTools.stream("What is the weather in London today?");
+        let finalMessage;
+        for await (const item of result) {
+            console.log("item", JSON.stringify(item, null, 2));
+            finalMessage = item;
+        }
+        if (!finalMessage) {
+            throw new Error("No final message returned");
+        }
+        console.log({
+            tool_calls: JSON.stringify(finalMessage.content, null, 2),
+        }, "Can bind & invoke StructuredTools");
+        expect(Array.isArray(finalMessage.content)).toBeTruthy();
+        if (!Array.isArray(finalMessage.content)) {
+            throw new Error("Content is not an array");
+        }
+        let toolCall;
+        finalMessage.content.forEach((item) => {
+            if (item.type === "tool_use") {
+                toolCall = item;
+            }
+        });
+        if (!toolCall) {
+            throw new Error("No tool call found");
+        }
+        expect(toolCall).toBeTruthy();
+        const { name, input } = toolCall;
+        expect(name).toBe("get_weather");
+        expect(input).toBeTruthy();
+        expect(input.location).toBeTruthy();
+    });
+    test("withStructuredOutput with zod schema", async () => {
+        const modelWithTools = model.withStructuredOutput(zodSchema, {
+            name: "get_weather",
+        });
+        const result = await modelWithTools.invoke("What is the weather in London today?");
+        console.log({
+            result,
+        }, "withStructuredOutput with zod schema");
+        expect(typeof result.location).toBe("string");
+    });
+    test("withStructuredOutput with AnthropicTool", async () => {
+        const modelWithTools = model.withStructuredOutput(anthropicTool, {
+            name: anthropicTool.name,
+        });
+        const result = await modelWithTools.invoke("What is the weather in London today?");
+        console.log({
+            result,
+        }, "withStructuredOutput with AnthropicTool");
+        expect(typeof result.location).toBe("string");
+    });
+    test("withStructuredOutput JSON Schema only", async () => {
+        const jsonSchema = zodToJsonSchema(zodSchema);
+        const modelWithTools = model.withStructuredOutput(jsonSchema, {
+            name: "get_weather",
+        });
+        const result = await modelWithTools.invoke("What is the weather in London today?");
+        console.log({
+            result,
+        }, "withStructuredOutput JSON Schema only");
+        expect(typeof result.location).toBe("string");
+    });
+});

package/dist/tests/chat_models.test.d.ts

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

package/dist/tests/chat_models.test.js

@@ -0,0 +1,88 @@
+import { jest, test } from "@jest/globals";
+import { AIMessage } from "@langchain/core/messages";
+import { z } from "zod";
+import { OutputParserException } from "@langchain/core/output_parsers";
+import { ChatAnthropic } from "../chat_models.js";
+test("withStructuredOutput with output validation", async () => {
+    const model = new ChatAnthropic({
+        modelName: "claude-3-haiku-20240307",
+        temperature: 0,
+        anthropicApiKey: "testing",
+    });
+    jest
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .spyOn(model, "invoke")
+        .mockResolvedValue(new AIMessage({
+        content: [
+            {
+                type: "tool_use",
+                id: "notreal",
+                name: "Extractor",
+                input: "Incorrect string tool call input",
+            },
+        ],
+    }));
+    const schema = z.object({
+        alerts: z
+            .array(z.object({
+            description: z.string().describe("A description of the alert."),
+            severity: z
+                .enum(["HIGH", "MEDIUM", "LOW"])
+                .describe("How severe the alert is."),
+        }))
+            .describe("Important security or infrastructure alerts present in the given text."),
+    });
+    const modelWithStructuredOutput = model.withStructuredOutput(schema, {
+        name: "Extractor",
+    });
+    await expect(async () => {
+        await modelWithStructuredOutput.invoke(`
+      Enumeration of Kernel Modules via Proc
+      Prompt for Credentials with OSASCRIPT
+      User Login
+      Modification of Standard Authentication Module
+      Suspicious Automator Workflows Execution
+    `);
+    }).rejects.toThrowError(OutputParserException);
+});
+test("withStructuredOutput with proper output", async () => {
+    const model = new ChatAnthropic({
+        modelName: "claude-3-haiku-20240307",
+        temperature: 0,
+        anthropicApiKey: "testing",
+    });
+    jest
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .spyOn(model, "invoke")
+        .mockResolvedValue(new AIMessage({
+        content: [
+            {
+                type: "tool_use",
+                id: "notreal",
+                name: "Extractor",
+                input: { alerts: [{ description: "test", severity: "LOW" }] },
+            },
+        ],
+    }));
+    const schema = z.object({
+        alerts: z
+            .array(z.object({
+            description: z.string().describe("A description of the alert."),
+            severity: z
+                .enum(["HIGH", "MEDIUM", "LOW"])
+                .describe("How severe the alert is."),
+        }))
+            .describe("Important security or infrastructure alerts present in the given text."),
+    });
+    const modelWithStructuredOutput = model.withStructuredOutput(schema, {
+        name: "Extractor",
+    });
+    const result = await modelWithStructuredOutput.invoke(`
+    Enumeration of Kernel Modules via Proc
+    Prompt for Credentials with OSASCRIPT
+    User Login
+    Modification of Standard Authentication Module
+    Suspicious Automator Workflows Execution
+  `);
+    console.log(result);
+});

package/dist/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+export type AnthropicToolResponse = {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, any>;
+};

package/dist/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/anthropic",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Anthropic integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -39,8 +39,8 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.17.2",
-    "@langchain/core": "~0.1.44",
+    "@anthropic-ai/sdk": "^0.20.1",
+    "@langchain/core": "~0.1.54",
     "fast-xml-parser": "^4.3.5",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.4"