@langchain/anthropic 0.1.1 → 0.1.3

package/dist/chat_models.cjs

@@ -6,6 +6,22 @@ const messages_1 = require("@langchain/core/messages");
 const outputs_1 = require("@langchain/core/outputs");
 const env_1 = require("@langchain/core/utils/env");
 const chat_models_1 = require("@langchain/core/language_models/chat_models");
+function _formatImage(imageUrl) {
+    const regex = /^data:(image\/.+);base64,(.+)$/;
+    const match = imageUrl.match(regex);
+    if (match === null) {
+        throw new Error([
+            "Anthropic only supports base64-encoded images currently.",
+            "Example: data:image/png;base64,/9j/4AAQSk...",
+        ].join("\n\n"));
+    }
+    return {
+        type: "base64",
+        media_type: match[1] ?? "",
+        data: match[2] ?? "",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    };
+}
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -243,16 +259,13 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         let system;
         if (messages.length > 0 && messages[0]._getType() === "system") {
             if (typeof messages[0].content !== "string") {
-                throw new Error("Currently only string content messages are supported.");
+                throw new Error("System message content must be a string.");
             }
             system = messages[0].content;
         }
         const conversationMessages = system !== undefined ? messages.slice(1) : messages;
         const formattedMessages = conversationMessages.map((message) => {
             let role;
-            if (typeof message.content !== "string") {
-                throw new Error("Currently only string content messages are supported.");
-            }
             if (message._getType() === "human") {
                 role = "user";
             }
@@ -265,10 +278,35 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             else {
                 throw new Error(`Message type "${message._getType()}" is not supported.`);
             }
-            return {
-                role,
-                content: message.content,
-            };
+            if (typeof message.content === "string") {
+                return {
+                    role,
+                    content: message.content,
+                };
+            }
+            else {
+                return {
+                    role,
+                    content: message.content.map((contentPart) => {
+                        if (contentPart.type === "image_url") {
+                            let source;
+                            if (typeof contentPart.image_url === "string") {
+                                source = _formatImage(contentPart.image_url);
+                            }
+                            else {
+                                source = _formatImage(contentPart.image_url.url);
+                            }
+                            return {
+                                type: "image",
+                                source,
+                            };
+                        }
+                        else {
+                            return contentPart;
+                        }
+                    }),
+                };
+            }
         });
         return {
             messages: formattedMessages,
@@ -374,10 +412,6 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
     _llmType() {
         return "anthropic";
     }
-    /** @ignore */
-    _combineLLMOutput() {
-        return [];
-    }
 }
 exports.ChatAnthropicMessages = ChatAnthropicMessages;
 class ChatAnthropic extends ChatAnthropicMessages {

package/dist/chat_models.d.ts

@@ -165,8 +165,6 @@ export declare class ChatAnthropicMessages<CallOptions extends BaseLanguageModel
         signal?: AbortSignal;
     }): Promise<Anthropic.Message>;
     _llmType(): string;
-    /** @ignore */
-    _combineLLMOutput(): never[];
 }
 export declare class ChatAnthropic extends ChatAnthropicMessages {
 }

package/dist/chat_models.js

@@ -3,6 +3,22 @@ import { AIMessage, AIMessageChunk, } from "@langchain/core/messages";
 import { ChatGenerationChunk } from "@langchain/core/outputs";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
+function _formatImage(imageUrl) {
+    const regex = /^data:(image\/.+);base64,(.+)$/;
+    const match = imageUrl.match(regex);
+    if (match === null) {
+        throw new Error([
+            "Anthropic only supports base64-encoded images currently.",
+            "Example: data:image/png;base64,/9j/4AAQSk...",
+        ].join("\n\n"));
+    }
+    return {
+        type: "base64",
+        media_type: match[1] ?? "",
+        data: match[2] ?? "",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    };
+}
 /**
  * Wrapper around Anthropic large language models.
  *
@@ -240,16 +256,13 @@ export class ChatAnthropicMessages extends BaseChatModel {
         let system;
         if (messages.length > 0 && messages[0]._getType() === "system") {
             if (typeof messages[0].content !== "string") {
-                throw new Error("Currently only string content messages are supported.");
+                throw new Error("System message content must be a string.");
             }
             system = messages[0].content;
         }
         const conversationMessages = system !== undefined ? messages.slice(1) : messages;
         const formattedMessages = conversationMessages.map((message) => {
             let role;
-            if (typeof message.content !== "string") {
-                throw new Error("Currently only string content messages are supported.");
-            }
             if (message._getType() === "human") {
                 role = "user";
             }
@@ -262,10 +275,35 @@ export class ChatAnthropicMessages extends BaseChatModel {
             else {
                 throw new Error(`Message type "${message._getType()}" is not supported.`);
             }
-            return {
-                role,
-                content: message.content,
-            };
+            if (typeof message.content === "string") {
+                return {
+                    role,
+                    content: message.content,
+                };
+            }
+            else {
+                return {
+                    role,
+                    content: message.content.map((contentPart) => {
+                        if (contentPart.type === "image_url") {
+                            let source;
+                            if (typeof contentPart.image_url === "string") {
+                                source = _formatImage(contentPart.image_url);
+                            }
+                            else {
+                                source = _formatImage(contentPart.image_url.url);
+                            }
+                            return {
+                                type: "image",
+                                source,
+                            };
+                        }
+                        else {
+                            return contentPart;
+                        }
+                    }),
+                };
+            }
         });
         return {
             messages: formattedMessages,
@@ -371,10 +409,6 @@ export class ChatAnthropicMessages extends BaseChatModel {
     _llmType() {
         return "anthropic";
     }
-    /** @ignore */
-    _combineLLMOutput() {
-        return [];
-    }
 }
 export class ChatAnthropic extends ChatAnthropicMessages {
 }

package/dist/experimental/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tool_calling.cjs"), exports);

package/dist/experimental/index.d.ts

@@ -0,0 +1 @@
+export * from "./tool_calling.js";

package/dist/experimental/index.js

@@ -0,0 +1 @@
+export * from "./tool_calling.js";

package/dist/experimental/tests/tool_calling.int.test.d.ts

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

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

@@ -0,0 +1,268 @@
+/* eslint-disable no-process-env */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+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({
+        modelName: "claude-3-sonnet-20240229",
+        maxRetries: 0,
+    });
+    const message = new HumanMessage("Hello!");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+});
+test("Test ChatAnthropicTools streaming", async () => {
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        maxRetries: 0,
+    });
+    const message = new HumanMessage("Hello!");
+    const stream = await chat.stream([message]);
+    const chunks = [];
+    for await (const chunk of stream) {
+        console.log(chunk);
+        chunks.push(chunk);
+    }
+    expect(chunks.length).toBeGreaterThan(1);
+});
+test("Test ChatAnthropicTools with tools", async () => {
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        temperature: 0.1,
+        maxRetries: 0,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "get_current_weather",
+                    description: "Get the current weather in a given location",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            location: {
+                                type: "string",
+                                description: "The city and state, e.g. San Francisco, CA",
+                            },
+                            unit: {
+                                type: "string",
+                                enum: ["celsius", "fahrenheit"],
+                            },
+                        },
+                        required: ["location"],
+                    },
+                },
+            },
+        ],
+    });
+    const message = new HumanMessage("What is the weather in San Francisco?");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+    expect(res.additional_kwargs.tool_calls).toBeDefined();
+    expect(res.additional_kwargs.tool_calls?.[0].function.name).toEqual("get_current_weather");
+});
+test("Test ChatAnthropicTools with a forced function call", async () => {
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        temperature: 0.1,
+        maxRetries: 0,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "extract_data",
+                    description: "Return information about the input",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            sentiment: {
+                                type: "string",
+                                description: "The city and state, e.g. San Francisco, CA",
+                            },
+                            aggressiveness: {
+                                type: "integer",
+                                description: "How aggressive the input is from 1 to 10",
+                            },
+                            language: {
+                                type: "string",
+                                description: "The language the input is in",
+                            },
+                        },
+                        required: ["sentiment", "aggressiveness"],
+                    },
+                },
+            },
+        ],
+        tool_choice: { type: "function", function: { name: "extract_data" } },
+    });
+    const message = new HumanMessage("Extract the desired information from the following passage:\n\nthis is really cool");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+    expect(res.additional_kwargs.tool_calls).toBeDefined();
+    expect(res.additional_kwargs.tool_calls?.[0]?.function.name).toEqual("extract_data");
+});
+test("ChatAnthropicTools with Zod schema", async () => {
+    const 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"),
+        })),
+    });
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        temperature: 0.1,
+        maxRetries: 0,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "information_extraction",
+                    description: "Extracts the relevant information from the passage.",
+                    parameters: zodToJsonSchema(schema),
+                },
+            },
+        ],
+        tool_choice: {
+            type: "function",
+            function: {
+                name: "information_extraction",
+            },
+        },
+    });
+    const message = new HumanMessage("Alex is 5 feet tall. Claudia is 1 foot taller than Alex and jumps higher than him. Claudia is a brunette and Alex is blonde.");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+    expect(res.additional_kwargs.tool_calls).toBeDefined();
+    expect(res.additional_kwargs.tool_calls?.[0]?.function.name).toEqual("information_extraction");
+    expect(JSON.parse(res.additional_kwargs.tool_calls?.[0]?.function.arguments ?? "")).toEqual({
+        people: expect.arrayContaining([
+            { name: "Alex", height: 5, hairColor: "blonde" },
+            { name: "Claudia", height: 6, hairColor: "brunette" },
+        ]),
+    });
+});
+test("ChatAnthropicTools with parallel tool calling", async () => {
+    const 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"),
+    });
+    const chat = new ChatAnthropicTools({
+        modelName: "claude-3-sonnet-20240229",
+        temperature: 0.1,
+        maxRetries: 0,
+    }).bind({
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "person",
+                    description: "A person mentioned in the passage.",
+                    parameters: zodToJsonSchema(schema),
+                },
+            },
+        ],
+        tool_choice: {
+            type: "function",
+            function: {
+                name: "person",
+            },
+        },
+    });
+    console.log(zodToJsonSchema(schema));
+    const message = new HumanMessage("Alex is 5 feet tall. Claudia is 1 foot taller than Alex and jumps higher than him. Claudia is a brunette and Alex is blonde.");
+    const res = await chat.invoke([message]);
+    console.log(JSON.stringify(res));
+    expect(res.additional_kwargs.tool_calls).toBeDefined();
+    expect(res.additional_kwargs.tool_calls?.map((toolCall) => JSON.parse(toolCall.function.arguments ?? ""))).toEqual(expect.arrayContaining([
+        { name: "Alex", height: 5, hairColor: "blonde" },
+        { name: "Claudia", height: 6, hairColor: "brunette" },
+    ]));
+});
+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"),
+        }),
+        name: "person",
+    });
+    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({ 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({
+        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"),
+            })),
+        }),
+    });
+    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({
+        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."),
+        }),
+        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",
+    });
+});