@langchain/anthropic 0.1.14 → 0.1.16

package/dist/chat_models.cjs

@@ -188,24 +188,28 @@ function _formatMessagesForAnthropic(messages) {
             throw new Error(`Message type "${message._getType()}" is not supported.`);
         }
         if ((0, messages_1.isAIMessage)(message) && !!message.tool_calls?.length) {
-            if (message.content === "") {
-                return {
-                    role,
-                    content: message.tool_calls.map(_convertLangChainToolCallToAnthropic),
-                };
-            }
-            else if (typeof message.content === "string") {
-                console.warn(`The "tool_calls" field on a message is only respected if content is an empty string.`);
-                return {
-                    role,
-                    content: _formatContent(message.content),
-                };
+            if (typeof message.content === "string") {
+                if (message.content === "") {
+                    return {
+                        role,
+                        content: message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+                    };
+                }
+                else {
+                    return {
+                        role,
+                        content: [
+                            { type: "text", text: message.content },
+                            ...message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+                        ],
+                    };
+                }
             }
             else {
                 const { content } = message;
                 const hasMismatchedToolCalls = !message.tool_calls.every((toolCall) => content.find((contentPart) => contentPart.type === "tool_use" && contentPart.id === toolCall.id));
                 if (hasMismatchedToolCalls) {
-                    console.warn(`The "tool_calls" field on a message is only respected if content is an empty string.`);
+                    console.warn(`The "tool_calls" field on a message is only respected if content is a string.`);
                 }
                 return {
                     role,
@@ -455,7 +459,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         const params = this.invocationParams(options);
         const formattedMessages = _formatMessagesForAnthropic(messages);
         if (options.tools !== undefined && options.tools.length > 0) {
-            const generations = await this._generateNonStreaming(messages, params, {
+            const { generations } = await this._generateNonStreaming(messages, params, {
                 signal: options.signal,
             });
             const result = generations[0].message;
@@ -558,7 +562,8 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         }, options);
         const { content, ...additionalKwargs } = response;
         const generations = anthropicResponseToChatMessages(content, additionalKwargs);
-        return generations;
+        const { role: _role, type: _type, ...rest } = additionalKwargs;
+        return { generations, llmOutput: rest };
     }
     /** @ignore */
     async _generate(messages, options, runManager) {
@@ -590,12 +595,9 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             };
         }
         else {
-            const generations = await this._generateNonStreaming(messages, params, {
+            return this._generateNonStreaming(messages, params, {
                 signal: options.signal,
             });
-            return {
-                generations,
-            };
         }
     }
     /**

package/dist/chat_models.d.ts

@@ -176,7 +176,16 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
     };
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     /** @ignore */
-    _generateNonStreaming(messages: BaseMessage[], params: Omit<Anthropic.Messages.MessageCreateParamsNonStreaming | Anthropic.Messages.MessageCreateParamsStreaming, "messages"> & Kwargs, requestOptions: AnthropicRequestOptions): Promise<ChatGeneration[]>;
+    _generateNonStreaming(messages: BaseMessage[], params: Omit<Anthropic.Messages.MessageCreateParamsNonStreaming | Anthropic.Messages.MessageCreateParamsStreaming, "messages"> & Kwargs, requestOptions: AnthropicRequestOptions): Promise<{
+        generations: ChatGeneration[];
+        llmOutput: {
+            id: string;
+            model: string;
+            stop_reason: "max_tokens" | "stop_sequence" | "end_turn" | null;
+            stop_sequence: string | null;
+            usage: Anthropic.Messages.Usage;
+        };
+    }>;
     /** @ignore */
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     /**

package/dist/chat_models.js

@@ -184,24 +184,28 @@ function _formatMessagesForAnthropic(messages) {
             throw new Error(`Message type "${message._getType()}" is not supported.`);
         }
         if (isAIMessage(message) && !!message.tool_calls?.length) {
-            if (message.content === "") {
-                return {
-                    role,
-                    content: message.tool_calls.map(_convertLangChainToolCallToAnthropic),
-                };
-            }
-            else if (typeof message.content === "string") {
-                console.warn(`The "tool_calls" field on a message is only respected if content is an empty string.`);
-                return {
-                    role,
-                    content: _formatContent(message.content),
-                };
+            if (typeof message.content === "string") {
+                if (message.content === "") {
+                    return {
+                        role,
+                        content: message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+                    };
+                }
+                else {
+                    return {
+                        role,
+                        content: [
+                            { type: "text", text: message.content },
+                            ...message.tool_calls.map(_convertLangChainToolCallToAnthropic),
+                        ],
+                    };
+                }
             }
             else {
                 const { content } = message;
                 const hasMismatchedToolCalls = !message.tool_calls.every((toolCall) => content.find((contentPart) => contentPart.type === "tool_use" && contentPart.id === toolCall.id));
                 if (hasMismatchedToolCalls) {
-                    console.warn(`The "tool_calls" field on a message is only respected if content is an empty string.`);
+                    console.warn(`The "tool_calls" field on a message is only respected if content is a string.`);
                 }
                 return {
                     role,
@@ -451,7 +455,7 @@ export class ChatAnthropicMessages extends BaseChatModel {
         const params = this.invocationParams(options);
         const formattedMessages = _formatMessagesForAnthropic(messages);
         if (options.tools !== undefined && options.tools.length > 0) {
-            const generations = await this._generateNonStreaming(messages, params, {
+            const { generations } = await this._generateNonStreaming(messages, params, {
                 signal: options.signal,
             });
             const result = generations[0].message;
@@ -554,7 +558,8 @@ export class ChatAnthropicMessages extends BaseChatModel {
         }, options);
         const { content, ...additionalKwargs } = response;
         const generations = anthropicResponseToChatMessages(content, additionalKwargs);
-        return generations;
+        const { role: _role, type: _type, ...rest } = additionalKwargs;
+        return { generations, llmOutput: rest };
     }
     /** @ignore */
     async _generate(messages, options, runManager) {
@@ -586,12 +591,9 @@ export class ChatAnthropicMessages extends BaseChatModel {
             };
         }
         else {
-            const generations = await this._generateNonStreaming(messages, params, {
+            return this._generateNonStreaming(messages, params, {
                 signal: options.signal,
             });
-            return {
-                generations,
-            };
         }
     }
     /**

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

@@ -62,7 +62,7 @@ test("Few shotting with tool calls", async () => {
     const res = await chat.invoke([
         new HumanMessage("What is the weather in SF?"),
         new AIMessage({
-            content: "",
+            content: "Let me look up the current weather.",
             tool_calls: [
                 {
                     id: "toolu_feiwjf9u98r389u498",

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

@@ -5,7 +5,7 @@ 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 { ChatAnthropic } from "../chat_models.js";
-test.skip("Test ChatAnthropic", async () => {
+test("Test ChatAnthropic", async () => {
     const chat = new ChatAnthropic({
         modelName: "claude-3-sonnet-20240229",
         maxRetries: 0,
@@ -13,6 +13,7 @@ test.skip("Test ChatAnthropic", async () => {
     const message = new HumanMessage("Hello!");
     const res = await chat.invoke([message]);
     console.log({ res });
+    expect(res.response_metadata.usage).toBeDefined();
 });
 test("Test ChatAnthropic Generate", async () => {
     const chat = new ChatAnthropic({

package/package.json

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