@langchain/anthropic 0.3.12 → 0.3.14

package/README.md

@@ -49,24 +49,30 @@ export ANTHROPIC_API_KEY=your-api-key
 Then initialize
 
 ```typescript
-import { ChatAnthropicMessages } from "@langchain/anthropic";
+import { ChatAnthropic } from "@langchain/anthropic";
 
 const model = new ChatAnthropic({
   apiKey: process.env.ANTHROPIC_API_KEY,
 });
-const response = await model.invoke(new HumanMessage("Hello world!"));
+const response = await model.invoke({
+  role: "user",
+  content: "Hello world!",
+});
 ```
 
 ### Streaming
 
 ```typescript
-import { ChatAnthropicMessages } from "@langchain/anthropic";
+import { ChatAnthropic } from "@langchain/anthropic";
 
 const model = new ChatAnthropic({
   apiKey: process.env.ANTHROPIC_API_KEY,
   model: "claude-3-sonnet-20240229",
 });
-const response = await model.stream(new HumanMessage("Hello world!"));
+const response = await model.stream({
+  role: "user",
+  content: "Hello world!",
+});
 ```
 
 ## Development
@@ -119,4 +125,4 @@ After running `yarn build`, publish a new version with:
 
 ```bash
 $ npm publish
-```
+```

package/dist/chat_models.cjs

@@ -19,6 +19,26 @@ const errors_js_1 = require("./utils/errors.cjs");
 function _toolsInParams(params) {
     return !!(params.tools && params.tools.length > 0);
 }
+function _documentsInParams(params) {
+    for (const message of params.messages ?? []) {
+        if (typeof message.content === "string") {
+            continue;
+        }
+        for (const block of message.content ?? []) {
+            if (typeof block === "object" &&
+                block != null &&
+                block.type === "document" &&
+                typeof block.citations === "object" &&
+                block.citations.enabled) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function _thinkingInParams(params) {
+    return !!(params.thinking && params.thinking.type === "enabled");
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isAnthropicTool(tool) {
     return "input_schema" in tool;
@@ -519,6 +539,12 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "thinking", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { type: "disabled" }
+        });
         // Used for non-streaming requests
         Object.defineProperty(this, "batchClient", {
             enumerable: true,
@@ -574,6 +600,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
         this.stopSequences = fields?.stopSequences ?? this.stopSequences;
         this.streaming = fields?.streaming ?? false;
         this.streamUsage = fields?.streamUsage ?? this.streamUsage;
+        this.thinking = fields?.thinking ?? this.thinking;
         this.createClient =
             fields?.createClient ??
                 ((options) => new sdk_1.Anthropic(options));
@@ -607,7 +634,8 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
                 return {
                     name: tool.function.name,
                     description: tool.function.description,
-                    input_schema: tool.function.parameters,
+                    input_schema: tool.function
+                        .parameters,
                 };
             }
             if ((0, function_calling_1.isLangChainTool)(tool)) {
@@ -631,6 +659,27 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
      */
     invocationParams(options) {
         const tool_choice = (0, tools_js_1.handleToolChoice)(options?.tool_choice);
+        if (this.thinking.type === "enabled") {
+            if (this.topK !== -1) {
+                throw new Error("topK is not supported when thinking is enabled");
+            }
+            if (this.topP !== -1) {
+                throw new Error("topP is not supported when thinking is enabled");
+            }
+            if (this.temperature !== 1) {
+                throw new Error("temperature is not supported when thinking is enabled");
+            }
+            return {
+                model: this.model,
+                stop_sequences: options?.stop ?? this.stopSequences,
+                stream: this.streaming,
+                max_tokens: this.maxTokens,
+                tools: this.formatStructuredToolToAnthropic(options?.tools),
+                tool_choice,
+                thinking: this.thinking,
+                ...this.invocationKwargs,
+            };
+        }
         return {
             model: this.model,
             temperature: this.temperature,
@@ -641,6 +690,7 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
             max_tokens: this.maxTokens,
             tools: this.formatStructuredToolToAnthropic(options?.tools),
             tool_choice,
+            thinking: this.thinking,
             ...this.invocationKwargs,
         };
     }
@@ -663,16 +713,15 @@ class ChatAnthropicMessages extends chat_models_1.BaseChatModel {
     async *_streamResponseChunks(messages, options, runManager) {
         const params = this.invocationParams(options);
         const formattedMessages = (0, message_inputs_js_1._convertMessagesToAnthropicPayload)(messages);
-        const coerceContentToString = !_toolsInParams({
-            ...params,
-            ...formattedMessages,
-            stream: false,
-        });
-        const stream = await this.createStreamWithRetry({
+        const payload = {
             ...params,
             ...formattedMessages,
             stream: true,
-        }, {
+        };
+        const coerceContentToString = !_toolsInParams(payload) &&
+            !_documentsInParams(payload) &&
+            !_thinkingInParams(payload);
+        const stream = await this.createStreamWithRetry(payload, {
             headers: options.headers,
         });
         for await (const data of stream) {

package/dist/chat_models.d.ts

@@ -7,8 +7,7 @@ import { BaseChatModel, BaseChatModelCallOptions, LangSmithParams, type BaseChat
 import { type StructuredOutputMethodOptions, type BaseLanguageModelInput } from "@langchain/core/language_models/base";
 import { Runnable } from "@langchain/core/runnables";
 import { z } from "zod";
-import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
-import { AnthropicMessageCreateParams, AnthropicMessageStreamEvent, AnthropicRequestOptions, AnthropicStreamingMessageCreateParams, AnthropicToolChoice, ChatAnthropicToolType } from "./types.js";
+import { AnthropicMessageCreateParams, AnthropicMessageStreamEvent, AnthropicRequestOptions, AnthropicStreamingMessageCreateParams, AnthropicThinkingConfigParam, AnthropicToolChoice, ChatAnthropicToolType } from "./types.js";
 export interface ChatAnthropicCallOptions extends BaseChatModelCallOptions, Pick<AnthropicInput, "streamUsage"> {
     tools?: ChatAnthropicToolType[];
     /**
@@ -88,6 +87,10 @@ export interface AnthropicInput {
      * such as Google Vertex.
      */
     createClient?: (options: ClientOptions) => any;
+    /**
+     * Options for extended thinking.
+     */
+    thinking?: AnthropicThinkingConfigParam;
 }
 /**
  * A type representing additional parameters that can be passed to the
@@ -491,6 +494,7 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
     stopSequences?: string[];
     streaming: boolean;
     clientOptions: ClientOptions;
+    thinking: AnthropicThinkingConfigParam;
     protected batchClient: Anthropic;
     protected streamingClient: Anthropic;
     streamUsage: boolean;
@@ -508,7 +512,7 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
      * @param {ChatAnthropicCallOptions["tools"]} tools The tools to format
      * @returns {AnthropicTool[] | undefined} The formatted tools, or undefined if none are passed.
      */
-    formatStructuredToolToAnthropic(tools: ChatAnthropicCallOptions["tools"]): AnthropicTool[] | undefined;
+    formatStructuredToolToAnthropic(tools: ChatAnthropicCallOptions["tools"]): Anthropic.Messages.Tool[] | undefined;
     bindTools(tools: ChatAnthropicToolType[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
     /**
      * Get the parameters used to invoke the model
@@ -517,9 +521,10 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
     /** @ignore */
     _identifyingParams(): {
         system?: string | Anthropic.Messages.TextBlockParam[] | undefined;
+        thinking?: Anthropic.Messages.ThinkingConfigParam | undefined;
         model: Anthropic.Messages.Model;
         max_tokens: number;
-        tools?: Anthropic.Messages.Tool[] | undefined;
+        tools?: Anthropic.Messages.ToolUnion[] | undefined;
         tool_choice?: Anthropic.Messages.ToolChoice | undefined;
         metadata?: Anthropic.Messages.Metadata | undefined;
         temperature?: number | undefined;
@@ -534,9 +539,10 @@ export declare class ChatAnthropicMessages<CallOptions extends ChatAnthropicCall
      */
     identifyingParams(): {
         system?: string | Anthropic.Messages.TextBlockParam[] | undefined;
+        thinking?: Anthropic.Messages.ThinkingConfigParam | undefined;
         model: Anthropic.Messages.Model;
         max_tokens: number;
-        tools?: Anthropic.Messages.Tool[] | undefined;
+        tools?: Anthropic.Messages.ToolUnion[] | undefined;
         tool_choice?: Anthropic.Messages.ToolChoice | undefined;
         metadata?: Anthropic.Messages.Metadata | undefined;
         temperature?: number | undefined;

package/dist/chat_models.js

@@ -16,6 +16,26 @@ import { wrapAnthropicClientError } from "./utils/errors.js";
 function _toolsInParams(params) {
     return !!(params.tools && params.tools.length > 0);
 }
+function _documentsInParams(params) {
+    for (const message of params.messages ?? []) {
+        if (typeof message.content === "string") {
+            continue;
+        }
+        for (const block of message.content ?? []) {
+            if (typeof block === "object" &&
+                block != null &&
+                block.type === "document" &&
+                typeof block.citations === "object" &&
+                block.citations.enabled) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function _thinkingInParams(params) {
+    return !!(params.thinking && params.thinking.type === "enabled");
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isAnthropicTool(tool) {
     return "input_schema" in tool;
@@ -516,6 +536,12 @@ export class ChatAnthropicMessages extends BaseChatModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "thinking", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { type: "disabled" }
+        });
         // Used for non-streaming requests
         Object.defineProperty(this, "batchClient", {
             enumerable: true,
@@ -571,6 +597,7 @@ export class ChatAnthropicMessages extends BaseChatModel {
         this.stopSequences = fields?.stopSequences ?? this.stopSequences;
         this.streaming = fields?.streaming ?? false;
         this.streamUsage = fields?.streamUsage ?? this.streamUsage;
+        this.thinking = fields?.thinking ?? this.thinking;
         this.createClient =
             fields?.createClient ??
                 ((options) => new Anthropic(options));
@@ -604,7 +631,8 @@ export class ChatAnthropicMessages extends BaseChatModel {
                 return {
                     name: tool.function.name,
                     description: tool.function.description,
-                    input_schema: tool.function.parameters,
+                    input_schema: tool.function
+                        .parameters,
                 };
             }
             if (isLangChainTool(tool)) {
@@ -628,6 +656,27 @@ export class ChatAnthropicMessages extends BaseChatModel {
      */
     invocationParams(options) {
         const tool_choice = handleToolChoice(options?.tool_choice);
+        if (this.thinking.type === "enabled") {
+            if (this.topK !== -1) {
+                throw new Error("topK is not supported when thinking is enabled");
+            }
+            if (this.topP !== -1) {
+                throw new Error("topP is not supported when thinking is enabled");
+            }
+            if (this.temperature !== 1) {
+                throw new Error("temperature is not supported when thinking is enabled");
+            }
+            return {
+                model: this.model,
+                stop_sequences: options?.stop ?? this.stopSequences,
+                stream: this.streaming,
+                max_tokens: this.maxTokens,
+                tools: this.formatStructuredToolToAnthropic(options?.tools),
+                tool_choice,
+                thinking: this.thinking,
+                ...this.invocationKwargs,
+            };
+        }
         return {
             model: this.model,
             temperature: this.temperature,
@@ -638,6 +687,7 @@ export class ChatAnthropicMessages extends BaseChatModel {
             max_tokens: this.maxTokens,
             tools: this.formatStructuredToolToAnthropic(options?.tools),
             tool_choice,
+            thinking: this.thinking,
             ...this.invocationKwargs,
         };
     }
@@ -660,16 +710,15 @@ export class ChatAnthropicMessages extends BaseChatModel {
     async *_streamResponseChunks(messages, options, runManager) {
         const params = this.invocationParams(options);
         const formattedMessages = _convertMessagesToAnthropicPayload(messages);
-        const coerceContentToString = !_toolsInParams({
-            ...params,
-            ...formattedMessages,
-            stream: false,
-        });
-        const stream = await this.createStreamWithRetry({
+        const payload = {
             ...params,
             ...formattedMessages,
             stream: true,
-        }, {
+        };
+        const coerceContentToString = !_toolsInParams(payload) &&
+            !_documentsInParams(payload) &&
+            !_thinkingInParams(payload);
+        const stream = await this.createStreamWithRetry(payload, {
             headers: options.headers,
         });
         for await (const data of stream) {

package/dist/types.d.ts

@@ -1,5 +1,4 @@
 import Anthropic from "@anthropic-ai/sdk";
-import type { Tool as AnthropicTool } from "@anthropic-ai/sdk/resources/messages";
 import { BindToolsInput } from "@langchain/core/language_models/chat_models";
 export type AnthropicToolResponse = {
     type: "tool_use";
@@ -11,14 +10,18 @@ export type AnthropicMessageParam = Anthropic.MessageParam;
 export type AnthropicMessageResponse = Anthropic.ContentBlock | AnthropicToolResponse;
 export type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 export type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
+export type AnthropicThinkingConfigParam = Anthropic.ThinkingConfigParam;
 export type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
 export type AnthropicRequestOptions = Anthropic.RequestOptions;
 export type AnthropicToolChoice = {
     type: "tool";
     name: string;
 } | "any" | "auto" | "none" | string;
-export type ChatAnthropicToolType = AnthropicTool | BindToolsInput;
+export type ChatAnthropicToolType = Anthropic.Messages.Tool | BindToolsInput;
 export type AnthropicTextBlockParam = Anthropic.Messages.TextBlockParam;
 export type AnthropicImageBlockParam = Anthropic.Messages.ImageBlockParam;
 export type AnthropicToolUseBlockParam = Anthropic.Messages.ToolUseBlockParam;
 export type AnthropicToolResultBlockParam = Anthropic.Messages.ToolResultBlockParam;
+export type AnthropicDocumentBlockParam = Anthropic.Messages.DocumentBlockParam;
+export type AnthropicThinkingBlockParam = Anthropic.Messages.ThinkingBlockParam;
+export type AnthropicRedactedThinkingBlockParam = Anthropic.Messages.RedactedThinkingBlockParam;

package/dist/utils/message_inputs.cjs

@@ -108,11 +108,27 @@ function _formatContent(content) {
             else if (contentPart.type === "document") {
                 // PDF
                 return {
-                    type: "document",
-                    source: contentPart.source,
+                    ...contentPart,
                     ...(cacheControl ? { cache_control: cacheControl } : {}),
                 };
             }
+            else if (contentPart.type === "thinking") {
+                const block = {
+                    type: "thinking",
+                    thinking: contentPart.thinking,
+                    signature: contentPart.signature,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                };
+                return block;
+            }
+            else if (contentPart.type === "redacted_thinking") {
+                const block = {
+                    type: "redacted_thinking",
+                    data: contentPart.data,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                };
+                return block;
+            }
             else if (textTypes.find((t) => t === contentPart.type) &&
                 "text" in contentPart) {
                 // Assuming contentPart is of type MessageContentText here

package/dist/utils/message_inputs.js

@@ -104,11 +104,27 @@ function _formatContent(content) {
             else if (contentPart.type === "document") {
                 // PDF
                 return {
-                    type: "document",
-                    source: contentPart.source,
+                    ...contentPart,
                     ...(cacheControl ? { cache_control: cacheControl } : {}),
                 };
             }
+            else if (contentPart.type === "thinking") {
+                const block = {
+                    type: "thinking",
+                    thinking: contentPart.thinking,
+                    signature: contentPart.signature,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                };
+                return block;
+            }
+            else if (contentPart.type === "redacted_thinking") {
+                const block = {
+                    type: "redacted_thinking",
+                    data: contentPart.data,
+                    ...(cacheControl ? { cache_control: cacheControl } : {}),
+                };
+                return block;
+            }
             else if (textTypes.find((t) => t === contentPart.type) &&
                 "text" in contentPart) {
                 // Assuming contentPart is of type MessageContentText here

package/dist/utils/message_outputs.cjs

@@ -60,8 +60,22 @@ function _makeMessageChunkFromAnthropicEvent(data, fields) {
         };
     }
     else if (data.type === "content_block_start" &&
-        data.content_block.type === "tool_use") {
-        const toolCallContentBlock = data.content_block;
+        ["tool_use", "document"].includes(data.content_block.type)) {
+        const contentBlock = data.content_block;
+        let toolCallChunks;
+        if (contentBlock.type === "tool_use") {
+            toolCallChunks = [
+                {
+                    id: contentBlock.id,
+                    index: data.index,
+                    name: contentBlock.name,
+                    args: "",
+                },
+            ];
+        }
+        else {
+            toolCallChunks = [];
+        }
         return {
             chunk: new messages_1.AIMessageChunk({
                 content: fields.coerceContentToString
@@ -74,32 +88,42 @@ function _makeMessageChunkFromAnthropicEvent(data, fields) {
                         },
                     ],
                 additional_kwargs: {},
-                tool_call_chunks: [
-                    {
-                        id: toolCallContentBlock.id,
-                        index: data.index,
-                        name: toolCallContentBlock.name,
-                        args: "",
-                    },
-                ],
+                tool_call_chunks: toolCallChunks,
             }),
         };
     }
     else if (data.type === "content_block_delta" &&
-        data.delta.type === "text_delta") {
-        const content = data.delta?.text;
-        if (content !== undefined) {
+        [
+            "text_delta",
+            "citations_delta",
+            "thinking_delta",
+            "signature_delta",
+        ].includes(data.delta.type)) {
+        if (fields.coerceContentToString && "text" in data.delta) {
             return {
                 chunk: new messages_1.AIMessageChunk({
-                    content: fields.coerceContentToString
-                        ? content
-                        : [
-                            {
-                                index: data.index,
-                                ...data.delta,
-                            },
-                        ],
-                    additional_kwargs: {},
+                    content: data.delta.text,
+                }),
+            };
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const contentBlock = data.delta;
+            if ("citation" in contentBlock) {
+                contentBlock.citations = [contentBlock.citation];
+                delete contentBlock.citation;
+            }
+            if (contentBlock.type === "thinking_delta" ||
+                contentBlock.type === "signature_delta") {
+                return {
+                    chunk: new messages_1.AIMessageChunk({
+                        content: [{ index: data.index, ...contentBlock, type: "thinking" }],
+                    }),
+                };
+            }
+            return {
+                chunk: new messages_1.AIMessageChunk({
+                    content: [{ index: data.index, ...contentBlock, type: "text" }],
                 }),
             };
         }
@@ -146,6 +170,27 @@ function _makeMessageChunkFromAnthropicEvent(data, fields) {
             };
         }
     }
+    else if (data.type === "content_block_start" &&
+        data.content_block.type === "redacted_thinking") {
+        return {
+            chunk: new messages_1.AIMessageChunk({
+                content: fields.coerceContentToString
+                    ? ""
+                    : [{ index: data.index, ...data.content_block }],
+            }),
+        };
+    }
+    else if (data.type === "content_block_start" &&
+        data.content_block.type === "thinking") {
+        const content = data.content_block.thinking;
+        return {
+            chunk: new messages_1.AIMessageChunk({
+                content: fields.coerceContentToString
+                    ? content
+                    : [{ index: data.index, ...data.content_block }],
+            }),
+        };
+    }
     return null;
 }
 exports._makeMessageChunkFromAnthropicEvent = _makeMessageChunkFromAnthropicEvent;

package/dist/utils/message_outputs.js

@@ -57,8 +57,22 @@ export function _makeMessageChunkFromAnthropicEvent(data, fields) {
         };
     }
     else if (data.type === "content_block_start" &&
-        data.content_block.type === "tool_use") {
-        const toolCallContentBlock = data.content_block;
+        ["tool_use", "document"].includes(data.content_block.type)) {
+        const contentBlock = data.content_block;
+        let toolCallChunks;
+        if (contentBlock.type === "tool_use") {
+            toolCallChunks = [
+                {
+                    id: contentBlock.id,
+                    index: data.index,
+                    name: contentBlock.name,
+                    args: "",
+                },
+            ];
+        }
+        else {
+            toolCallChunks = [];
+        }
         return {
             chunk: new AIMessageChunk({
                 content: fields.coerceContentToString
@@ -71,32 +85,42 @@ export function _makeMessageChunkFromAnthropicEvent(data, fields) {
                         },
                     ],
                 additional_kwargs: {},
-                tool_call_chunks: [
-                    {
-                        id: toolCallContentBlock.id,
-                        index: data.index,
-                        name: toolCallContentBlock.name,
-                        args: "",
-                    },
-                ],
+                tool_call_chunks: toolCallChunks,
             }),
         };
     }
     else if (data.type === "content_block_delta" &&
-        data.delta.type === "text_delta") {
-        const content = data.delta?.text;
-        if (content !== undefined) {
+        [
+            "text_delta",
+            "citations_delta",
+            "thinking_delta",
+            "signature_delta",
+        ].includes(data.delta.type)) {
+        if (fields.coerceContentToString && "text" in data.delta) {
             return {
                 chunk: new AIMessageChunk({
-                    content: fields.coerceContentToString
-                        ? content
-                        : [
-                            {
-                                index: data.index,
-                                ...data.delta,
-                            },
-                        ],
-                    additional_kwargs: {},
+                    content: data.delta.text,
+                }),
+            };
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const contentBlock = data.delta;
+            if ("citation" in contentBlock) {
+                contentBlock.citations = [contentBlock.citation];
+                delete contentBlock.citation;
+            }
+            if (contentBlock.type === "thinking_delta" ||
+                contentBlock.type === "signature_delta") {
+                return {
+                    chunk: new AIMessageChunk({
+                        content: [{ index: data.index, ...contentBlock, type: "thinking" }],
+                    }),
+                };
+            }
+            return {
+                chunk: new AIMessageChunk({
+                    content: [{ index: data.index, ...contentBlock, type: "text" }],
                 }),
             };
         }
@@ -143,6 +167,27 @@ export function _makeMessageChunkFromAnthropicEvent(data, fields) {
             };
         }
     }
+    else if (data.type === "content_block_start" &&
+        data.content_block.type === "redacted_thinking") {
+        return {
+            chunk: new AIMessageChunk({
+                content: fields.coerceContentToString
+                    ? ""
+                    : [{ index: data.index, ...data.content_block }],
+            }),
+        };
+    }
+    else if (data.type === "content_block_start" &&
+        data.content_block.type === "thinking") {
+        const content = data.content_block.thinking;
+        return {
+            chunk: new AIMessageChunk({
+                content: fields.coerceContentToString
+                    ? content
+                    : [{ index: data.index, ...data.content_block }],
+            }),
+        };
+    }
     return null;
 }
 export function anthropicResponseToChatMessages(messages, additionalKwargs) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/anthropic",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Anthropic integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -35,7 +35,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.32.1",
+    "@anthropic-ai/sdk": "^0.37.0",
     "fast-xml-parser": "^4.4.1",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.4"