@langchain/anthropic 1.4.0-dev-1775763803878 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @langchain/anthropic
 
+## 1.4.0
+
+### Minor Changes
+
+- [#10777](https://github.com/langchain-ai/langchainjs/pull/10777) [`0cfcfc6`](https://github.com/langchain-ai/langchainjs/commit/0cfcfc66897d8fafeb7e7ed90b7299eace9a7c37) Thanks [@jonaslalin](https://github.com/jonaslalin)! - feat(anthropic): support strict tool calling for custom tools
+
+## 1.3.29
+
+### Patch Changes
+
+- [#10735](https://github.com/langchain-ai/langchainjs/pull/10735) [`1a2a08a`](https://github.com/langchain-ai/langchainjs/commit/1a2a08a33b7d99ec7348678116cc5d074db137bb) Thanks [@chenzimin](https://github.com/chenzimin)! - feat(anthropic): add automatic prompt caching via top-level cache_control
+
+## 1.3.28
+
+### Patch Changes
+
+- [#10776](https://github.com/langchain-ai/langchainjs/pull/10776) [`20a9abe`](https://github.com/langchain-ai/langchainjs/commit/20a9abea23ffacf4ae8dc9a7aeec217143bbdeb6) Thanks [@hntrl](https://github.com/hntrl)! - fix(deps): remediate uuid vulnerability by removing direct uuid usage
+
+- Updated dependencies [[`20a9abe`](https://github.com/langchain-ai/langchainjs/commit/20a9abea23ffacf4ae8dc9a7aeec217143bbdeb6)]:
+  - @langchain/core@1.1.42
+
+## 1.3.27
+
+### Patch Changes
+
+- [#10726](https://github.com/langchain-ai/langchainjs/pull/10726) [`ad153c1`](https://github.com/langchain-ai/langchainjs/commit/ad153c185b6cf813d4b7695740d9a4453d2cb63f) Thanks [@hntrl](https://github.com/hntrl)! - feat(anthropic): add Claude Opus 4.7 compatibility updates
+
+- Updated dependencies [[`589f29c`](https://github.com/langchain-ai/langchainjs/commit/589f29ce844eb252c2d5e6b0f8d26de37763a0d7), [`2e9e696`](https://github.com/langchain-ai/langchainjs/commit/2e9e6969e248a53ede0659a41d0ac8dbaf291ab4)]:
+  - @langchain/core@1.1.41
+
 ## 1.3.26
 
 ### Patch Changes

package/README.md

@@ -75,6 +75,91 @@ const response = await model.stream({
 });
 ```
 
+### Strict Tool Use
+
+Anthropic supports [strict tool use](https://platform.claude.com/docs/en/agents-and-tools/tool-use/strict-tool-use), which uses grammar-constrained sampling to guarantee that Claude's tool inputs match your schema (no missing required fields, no wrong types). Enable it on a per-call, per-binding, or per-tool basis.
+
+**Per-call** with `bindTools` (applies to every tool in the binding):
+
+```typescript
+import { ChatAnthropic } from "@langchain/anthropic";
+import { tool } from "langchain";
+import { z } from "zod";
+
+const getWeather = tool(async ({ location }) => `Weather in ${location}`, {
+  name: "get_weather",
+  description: "Get the current weather in a given location",
+  schema: z.object({ location: z.string() }),
+});
+
+const model = new ChatAnthropic({ model: "claude-opus-4-7" });
+
+const response = await model
+  .bindTools([getWeather], { strict: true })
+  .invoke("What's the weather in San Francisco?");
+```
+
+**Default for a tool-bound model** with `withConfig` (applies to every subsequent call on the bound model):
+
+```typescript
+const strictModelWithTools = model
+  .bindTools([getWeather])
+  .withConfig({ strict: true });
+
+const response = await strictModelWithTools.invoke(
+  "What's the weather in San Francisco?"
+);
+```
+
+**Per-tool** with `extras.strict` for mixed strict/non-strict tool sets:
+
+```typescript
+const lookupCustomer = tool(async ({ id }) => `...`, {
+  name: "lookup_customer",
+  description: "Look up a customer by id",
+  schema: z.object({ id: z.string() }),
+  // Strict on this critical tool only.
+  extras: { strict: true },
+});
+
+const searchDocs = tool(async ({ query }) => `...`, {
+  name: "search_docs",
+  description: "Free-form documentation search",
+  schema: z.object({ query: z.string() }),
+});
+
+const response = await model
+  .bindTools([lookupCustomer, searchDocs])
+  .invoke("Find customer 12345 and any onboarding docs");
+```
+
+**With `withStructuredOutput`** to guarantee schema-conforming output:
+
+```typescript
+const Weather = z.object({
+  location: z.string(),
+  temperature_celsius: z.number(),
+});
+
+const structured = model.withStructuredOutput(Weather, {
+  method: "functionCalling",
+  strict: true,
+});
+
+const result = await structured.invoke("What's the weather in San Francisco?");
+```
+
+Precedence when multiple sources are set:
+
+1. Per-call `strict` (e.g. `bindTools(..., { strict })`, `withConfig({ strict })`, or `withStructuredOutput(..., { strict })`)
+2. Per-tool `strict` (e.g. `extras.strict`, `function.strict` on OpenAI-shaped tools, or `strict` on raw Anthropic-shaped tools)
+
+In other words, per-tool acts as a fallback default for tools that opt in; if the call already specifies `strict`, that value wins for every tool in the request.
+
+> **Note on `withStructuredOutput` methods:** Anthropic's `strict` is a property of a tool definition, so it only applies when `method: "functionCalling"` (the default), where the structured output is produced by a strict tool call.
+>
+> The other method, `"jsonSchema"`, uses Anthropic's [native structured outputs](https://docs.claude.com/en/docs/build-with-claude/structured-outputs) and does not accept `strict`. Passing `strict` together with `"jsonSchema"` or `"jsonMode"` throws, to avoid silently dropping the option. If you want strict-validated output, stick with the default `functionCalling` method.
+
 ## Tools
 
 This package provides LangChain-compatible wrappers for Anthropic's built-in tools. These tools can be bound to `ChatAnthropic` using `bindTools()` or any [`ReactAgent`](https://docs.langchain.com/oss/javascript/langchain/agents).

package/dist/chat_models.cjs

@@ -2,6 +2,7 @@ require("./_virtual/_rolldown/runtime.cjs");
 const require_output_parsers = require("./output_parsers.cjs");
 const require_tools = require("./utils/tools.cjs");
 const require_message_inputs = require("./utils/message_inputs.cjs");
+const require_params = require("./utils/params.cjs");
 const require_message_outputs = require("./utils/message_outputs.cjs");
 const require_errors = require("./utils/errors.cjs");
 const require_profiles = require("./profiles.cjs");
@@ -20,6 +21,7 @@ let _langchain_core_utils_standard_schema = require("@langchain/core/utils/stand
 let _langchain_core_language_models_structured_output = require("@langchain/core/language_models/structured_output");
 //#region src/chat_models.ts
 const MODEL_DEFAULT_MAX_OUTPUT_TOKENS = {
+	"claude-opus-4-7": 16384,
 	"claude-opus-4-6": 16384,
 	"claude-sonnet-4-6": 16384,
 	"claude-opus-4-5": 16384,
@@ -649,7 +651,7 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 			model: modelOrFields
 		} : modelOrFields ?? {};
 		super(fields ?? {});
-		this._addVersion("@langchain/anthropic", "1.4.0-dev-1775763803878");
+		this._addVersion("@langchain/anthropic", "1.4.0");
 		this.anthropicApiKey = fields?.apiKey ?? fields?.anthropicApiKey ?? (0, _langchain_core_utils_env.getEnvironmentVariable)("ANTHROPIC_API_KEY");
 		if (!this.anthropicApiKey && !fields?.createClient) throw new Error("Anthropic API key not found");
 		this.clientOptions = fields?.clientOptions ?? {};
@@ -689,31 +691,48 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 	* Formats LangChain StructuredTools to AnthropicTools.
 	*
 	* @param {ChatAnthropicCallOptions["tools"]} tools The tools to format
+	* @param fields Optional `strict` flag applied to every formatted custom tool.
 	* @returns {AnthropicTool[] | undefined} The formatted tools, or undefined if none are passed.
 	*/
-	formatStructuredToolToAnthropic(tools) {
+	formatStructuredToolToAnthropic(tools, fields) {
 		if (!tools) return;
 		return tools.map((tool) => {
 			if ((0, _langchain_core_utils_function_calling.isLangChainTool)(tool) && tool.extras?.providerToolDefinition) return tool.extras.providerToolDefinition;
 			if (isBuiltinTool(tool)) return tool;
-			if (isAnthropicTool(tool)) return tool;
-			if ((0, _langchain_core_language_models_base.isOpenAITool)(tool)) return {
-				name: tool.function.name,
-				description: tool.function.description,
-				input_schema: tool.function.parameters
-			};
-			if ((0, _langchain_core_utils_function_calling.isLangChainTool)(tool)) return {
-				name: tool.name,
-				description: tool.description,
-				input_schema: (0, _langchain_core_utils_types.isInteropZodSchema)(tool.schema) ? (0, _langchain_core_utils_json_schema.toJsonSchema)(tool.schema) : tool.schema,
-				...tool.extras ? require_tools.AnthropicToolExtrasSchema.parse(tool.extras) : {}
-			};
+			if (isAnthropicTool(tool)) {
+				if (fields?.strict !== void 0) return {
+					...tool,
+					strict: fields.strict
+				};
+				return tool;
+			}
+			if ((0, _langchain_core_language_models_base.isOpenAITool)(tool)) {
+				const functionStrict = "strict" in tool.function && typeof tool.function.strict === "boolean" ? tool.function.strict : void 0;
+				const strict = fields?.strict ?? functionStrict;
+				return {
+					name: tool.function.name,
+					description: tool.function.description,
+					input_schema: tool.function.parameters,
+					...strict !== void 0 ? { strict } : {}
+				};
+			}
+			if ((0, _langchain_core_utils_function_calling.isLangChainTool)(tool)) {
+				const { strict: extrasStrict, ...restExtras } = tool.extras ? require_tools.AnthropicToolExtrasSchema.parse(tool.extras) : {};
+				const strict = fields?.strict ?? extrasStrict;
+				return {
+					name: tool.name,
+					description: tool.description,
+					input_schema: (0, _langchain_core_utils_types.isInteropZodSchema)(tool.schema) ? (0, _langchain_core_utils_json_schema.toJsonSchema)(tool.schema) : tool.schema,
+					...restExtras,
+					...strict !== void 0 ? { strict } : {}
+				};
+			}
 			throw new Error(`Unknown tool type passed to ChatAnthropic: ${JSON.stringify(tool, null, 2)}`);
 		});
 	}
 	bindTools(tools, kwargs) {
 		return this.withConfig({
-			tools: this.formatStructuredToolToAnthropic(tools),
+			tools: this.formatStructuredToolToAnthropic(tools, { strict: kwargs?.strict }),
 			...kwargs
 		});
 	}
@@ -738,31 +757,38 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 			return Object.keys(base).length > 0 ? base : void 0;
 		})();
 		const compactionBetas = this.contextManagement?.edits?.some((e) => e.type === "compact_20260112") ? ["compact-2026-01-12"] : [];
+		const taskBudgetBetas = require_params.getTaskBudgetBetas(this.model, mergedOutputConfig);
 		const output = {
 			model: this.model,
 			stop_sequences: options?.stop ?? this.stopSequences,
 			stream: this.streaming,
 			max_tokens: this.maxTokens,
-			tools: this.formatStructuredToolToAnthropic(options?.tools),
+			tools: this.formatStructuredToolToAnthropic(options?.tools, { strict: options?.strict }),
 			tool_choice,
 			thinking: this.thinking,
 			context_management: this.contextManagement,
 			...this.invocationKwargs,
 			container: options?.container,
-			betas: _combineBetas(this.betas, options?.betas, toolBetas ?? [], compactionBetas),
+			betas: _combineBetas(this.betas, options?.betas, toolBetas ?? [], compactionBetas, taskBudgetBetas),
 			output_config: mergedOutputConfig,
 			inference_geo: options?.inferenceGeo ?? this.inferenceGeo,
-			mcp_servers: options?.mcp_servers
+			mcp_servers: options?.mcp_servers,
+			cache_control: options?.cache_control
 		};
-		if (this.thinking.type === "enabled" || this.thinking.type === "adaptive") {
-			if (this.topK !== void 0) throw new Error("topK is not supported when thinking is enabled");
-			if (this.topP !== void 0) throw new Error("topP is not supported when thinking is enabled");
-			if (this.temperature !== void 0 && this.temperature !== 1) throw new Error("temperature is not supported when thinking is enabled");
-		} else {
-			if (this.temperature !== void 0) output.temperature = this.temperature;
-			if (this.topK !== void 0) output.top_k = this.topK;
-			if (this.topP !== void 0) output.top_p = this.topP;
-		}
+		require_params.validateInvocationParamCompatibility({
+			model: this.model,
+			thinking: this.thinking,
+			topK: this.topK,
+			topP: this.topP,
+			temperature: this.temperature
+		});
+		Object.assign(output, require_params.getSamplingParams({
+			model: this.model,
+			thinking: this.thinking,
+			topK: this.topK,
+			topP: this.topP,
+			temperature: this.temperature
+		}));
 		return output;
 	}
 	/** @ignore */
@@ -783,8 +809,7 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 	}
 	async *_streamResponseChunks(messages, options, runManager) {
 		const params = this.invocationParams(options);
-		let formattedMessages = require_message_inputs._convertMessagesToAnthropicPayload(messages);
-		if (options.cache_control) formattedMessages = require_message_inputs.applyCacheControlToPayload(formattedMessages, options.cache_control);
+		const formattedMessages = require_message_inputs._convertMessagesToAnthropicPayload(messages);
 		const payload = {
 			...params,
 			...formattedMessages,
@@ -837,8 +862,7 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 	*/
 	async *_streamChatModelEvents(messages, options, _runManager) {
 		const params = this.invocationParams(options);
-		let formattedMessages = require_message_inputs._convertMessagesToAnthropicPayload(messages);
-		if (options.cache_control) formattedMessages = require_message_inputs.applyCacheControlToPayload(formattedMessages, options.cache_control);
+		const formattedMessages = require_message_inputs._convertMessagesToAnthropicPayload(messages);
 		const payload = {
 			...params,
 			...formattedMessages,
@@ -861,9 +885,8 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 		yield* require_stream_events.convertAnthropicStream(abortableStream(stream, options.signal), { streamUsage: shouldStreamUsage ?? true });
 	}
 	/** @ignore */
-	async _generateNonStreaming(messages, params, requestOptions, cacheControl) {
-		let formattedMessages = require_message_inputs._convertMessagesToAnthropicPayload(messages);
-		if (cacheControl) formattedMessages = require_message_inputs.applyCacheControlToPayload(formattedMessages, cacheControl);
+	async _generateNonStreaming(messages, params, requestOptions) {
+		const formattedMessages = require_message_inputs._convertMessagesToAnthropicPayload(messages);
 		const { content, ...additionalKwargs } = await this.completionWithRetry({
 			...params,
 			stream: false,
@@ -894,7 +917,7 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 		} else return this._generateNonStreaming(messages, params, {
 			signal: options.signal,
 			headers: options.headers
-		}, options.cache_control);
+		});
 	}
 	/**
 	* Creates a streaming request with retry.
@@ -994,6 +1017,7 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 			schema: outputSchema
 		};
 		let method = config?.method ?? "functionCalling";
+		if (config?.strict !== void 0 && method !== "functionCalling") throw new Error(`Argument \`strict\` is only supported for \`method\` = "functionCalling" on Anthropic models. Got method = "${method}".`);
 		if (method === "jsonMode") {
 			console.warn(`"jsonMode" is not supported for Anthropic models. Falling back to "jsonSchema".`);
 			method = "jsonSchema";
@@ -1040,7 +1064,8 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 					ls_structured_output_format: {
 						kwargs: { method: "functionCalling" },
 						schema: (0, _langchain_core_utils_json_schema.toJsonSchema)(schema)
-					}
+					},
+					...config?.strict !== void 0 ? { strict: config.strict } : {}
 				});
 				const raiseIfNoToolCalls = (message) => {
 					if (!message.tool_calls || message.tool_calls.length === 0) throw new Error(thinkingAdmonition);
@@ -1057,7 +1082,8 @@ var ChatAnthropicMessages = class extends _langchain_core_language_models_chat_m
 				ls_structured_output_format: {
 					kwargs: { method: "functionCalling" },
 					schema: (0, _langchain_core_utils_json_schema.toJsonSchema)(schema)
-				}
+				},
+				...config?.strict !== void 0 ? { strict: config.strict } : {}
 			});
 		} else throw new TypeError(`Unrecognized structured output method '${method}'. Expected 'functionCalling' or 'jsonSchema'`);
 		return (0, _langchain_core_language_models_structured_output.assembleStructuredOutputPipeline)(llm, outputParser, includeRaw, includeRaw ? "StructuredOutputRunnable" : "ChatAnthropicStructuredOutput");