@ai-sdk/anthropic 4.0.93 → 4.0.95

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @ai-sdk/anthropic
 
+## 4.0.95
+
+### Patch Changes
+
+- 2cd0a97: Enable native structured output and strict tools for supported Claude 5 models on Bedrock. In automatic mode, Bedrock and Anthropic now fall back for schemas that native structured output cannot represent: recursive references, open objects, or more than ten optional properties. Anthropic uses the JSON response tool; Bedrock Converse uses the JSON tool or JSON instructions for models that reject forced tool use. The JSON-tool fallback excludes disabled and unselected application tools. Explicit `outputFormat` selection remains unchanged.
+- 4ae6986: fix(anthropic): parse valid JSON string tool input and safely serialize BigInt and cycles in tool results
+- Updated dependencies [51ca5b7]
+- Updated dependencies [dc6f1c3]
+- Updated dependencies [4ae6986]
+  - @ai-sdk/provider-utils@5.0.73
+
+## 4.0.94
+
+### Patch Changes
+
+- f4c5f1e: fix(anthropic): use native structured outputs for Claude models that reject forced tool use (Sonnet 5.5, Opus 5.5, Fable 5.1) even when the provider disables them by default, as Amazon Bedrock and Google Vertex do. Self-referencing schemas keep the JSON response tool. Also keep `definitions` and `$defs` next to a top-level `$ref` when sanitizing structured output schemas, so the reference still resolves.
+- e10aebb: fix(anthropic): when the JSON response tool is in use but the model answers in text without calling it (for example with manual thinking, where the forced tool choice is downgraded to `auto`), return the final answer text instead of dropping it. Text before a tool call, result, or message continuation is still dropped.
+- b0d51fe: fix(anthropic): keep the JSON response tool for schemas that native structured outputs cannot represent when upgrading models that reject forced tool use. Schemas with open objects (maps, free-form objects) would otherwise come back as `{}`, and schemas with more than 10 optional properties can be rejected as too complex.
+
 ## 4.0.93
 
 ### Patch Changes

package/dist/index.js

@@ -1,5 +1,5 @@
 import { APICallError, InvalidArgumentError, InvalidResponseDataError, NoSuchModelError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
-import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertInlineFileDataToUint8Array, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createProviderDefinedToolFactory, createProviderExecutedToolFactory, createProviderStreamError, createToolNameMapping, encodePathSegment, experimental_toolCaller, generateId, getFromApi, getTopLevelMediaType, isCustomReasoning, isNonNullable, isProviderStreamError, isRecord, lazySchema, loadApiKey, loadOptionalSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, normalizeBatchRequestCounts, normalizeHeaders, parseProviderOptions, postFormDataToApi, postJsonToApi, resolve, resolveFullMediaType, resolveProviderReference, safeValidateTypes, secureJsonParse, serializeModelOptions, validateBaseURL, validateTypes, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertInlineFileDataToUint8Array, convertToBase64, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createProviderDefinedToolFactory, createProviderExecutedToolFactory, createProviderStreamError, createToolNameMapping, encodePathSegment, experimental_toolCaller, generateId, getFromApi, getTopLevelMediaType, isCustomReasoning, isNonNullable, isProviderStreamError, isRecord, lazySchema, loadApiKey, loadOptionalSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, normalizeBatchRequestCounts, normalizeHeaders, parseProviderOptions, postFormDataToApi, postJsonToApi, resolve, resolveFullMediaType, resolveProviderReference, safeValidateTypes, secureJsonParse, serializeModelOptions, stringifyWithBigIntAndCycles, validateBaseURL, validateTypes, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
 import { Experimental_DecisionLanguageModel } from "@ai-sdk/provider-utils/experimental-decision";
 import { z } from "zod/v4";
 //#region src/anthropic-error.ts
@@ -2963,7 +2963,7 @@ async function convertToAnthropicPrompt({ prompt, sendReasoning, warnings, cache
 									case "execution-denied":
 										contentValue = output.reason ?? "Tool call execution denied.";
 										break;
-									default: contentValue = JSON.stringify(output.value);
+									default: contentValue = stringifyWithBigIntAndCycles(output.value);
 								}
 								const toolsetName = getAnthropicToolsetName({
 									toolName: part.toolName,
@@ -3634,6 +3634,10 @@ function getAnthropicCaller(providerOptions) {
 	return caller?.type === "direct" ? { type: "direct" } : void 0;
 }
 function toAnthropicToolInput(input) {
+	if (typeof input === "string") try {
+		const parsed = secureJsonParse(input);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+	} catch {}
 	return typeof input === "object" && input !== null && !Array.isArray(input) ? input : { rawInvalidInput: input };
 }
 //#endregion
@@ -3700,8 +3704,10 @@ function sanitizeDefinition(definition) {
 }
 function sanitizeSchema(schema) {
 	const result = {};
-	const schemaWithDefs = schema;
-	if (schema.$ref != null) return { $ref: schema.$ref };
+	if (schema.$ref != null) return {
+		$ref: schema.$ref,
+		...sanitizeSchemaDefinitions(schema)
+	};
 	if (schema.$schema != null) result.$schema = schema.$schema;
 	if (schema.$id != null) result.$id = schema.$id;
 	if (schema.title != null) result.title = schema.title;
@@ -3713,11 +3719,7 @@ function sanitizeSchema(schema) {
 	if (schema.anyOf != null) result.anyOf = schema.anyOf.map(sanitizeDefinition);
 	else if (schema.oneOf != null) result.anyOf = schema.oneOf.map(sanitizeDefinition);
 	if (schema.allOf != null) result.allOf = schema.allOf.map(sanitizeDefinition);
-	if (schema.definitions != null) result.definitions = Object.fromEntries(Object.entries(schema.definitions).map(([name, definition]) => [name, sanitizeDefinition(definition)]));
-	if (schemaWithDefs.$defs != null) {
-		const resultWithDefs = result;
-		resultWithDefs.$defs = Object.fromEntries(Object.entries(schemaWithDefs.$defs).map(([name, definition]) => [name, sanitizeDefinition(definition)]));
-	}
+	Object.assign(result, sanitizeSchemaDefinitions(schema));
 	if (schema.type === "object" || schema.properties != null) {
 		if (schema.properties != null) result.properties = Object.fromEntries(Object.entries(schema.properties).map(([name, definition]) => [name, sanitizeDefinition(definition)]));
 		result.additionalProperties = false;
@@ -3729,6 +3731,14 @@ function sanitizeSchema(schema) {
 	if (constraintDescription != null) result.description = result.description == null ? constraintDescription : `${result.description}\n${constraintDescription}`;
 	return result;
 }
+function sanitizeSchemaDefinitions(schema) {
+	const { $defs } = schema;
+	const sanitizeAll = (definitions) => Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, sanitizeDefinition(definition)]));
+	return {
+		...schema.definitions != null && { definitions: sanitizeAll(schema.definitions) },
+		...$defs != null && { $defs: sanitizeAll($defs) }
+	};
+}
 function getConstraintDescription(schema) {
 	const descriptions = DESCRIPTION_CONSTRAINT_KEYS.flatMap((key) => {
 		const value = schema[key];
@@ -3746,6 +3756,155 @@ function formatConstraintValue(value) {
 	return JSON.stringify(value);
 }
 //#endregion
+//#region src/has-circular-schema-reference.ts
+const SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+const DATA_KEYWORDS = /* @__PURE__ */ new Set([
+	"const",
+	"default",
+	"enum",
+	"examples"
+]);
+/**
+* Whether a JSON schema contains a cycle of local `$ref`s, e.g. a tree node
+* whose children reference the node itself.
+*
+* Anthropic's native structured outputs reject such schemas, while the JSON
+* response tool accepts them.
+*/
+function hasCircularSchemaReference(schema) {
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (pointer) => {
+		if (visiting.has(pointer)) return true;
+		if (visited.has(pointer)) return false;
+		const target = resolveSchemaPointer(schema, pointer);
+		if (target === void 0) return false;
+		visiting.add(pointer);
+		const isCircular = collectLocalRefs(target).some(visit);
+		visiting.delete(pointer);
+		visited.add(pointer);
+		return isCircular;
+	};
+	return visit("#");
+}
+function collectLocalRefs(node, refs = []) {
+	if (Array.isArray(node)) {
+		for (const item of node) collectLocalRefs(item, refs);
+		return refs;
+	}
+	if (!isRecord(node)) return refs;
+	for (const [key, value] of Object.entries(node)) if (key === "$ref") {
+		if (typeof value === "string" && value.startsWith("#")) refs.push(value);
+	} else if (SCHEMA_MAP_KEYWORDS.has(key) && isRecord(value)) for (const subschema of Object.values(value)) collectLocalRefs(subschema, refs);
+	else if (key !== "$defs" && key !== "definitions" && !DATA_KEYWORDS.has(key)) collectLocalRefs(value, refs);
+	return refs;
+}
+function resolveSchemaPointer(schema, pointer) {
+	if (pointer === "#") return schema;
+	if (!pointer.startsWith("#/")) return;
+	let decodedPointer;
+	try {
+		decodedPointer = decodeURIComponent(pointer.slice(2));
+	} catch {
+		return;
+	}
+	let current = schema;
+	for (const rawSegment of decodedPointer.split("/")) {
+		const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
+		if (Array.isArray(current)) current = current[Number(segment)];
+		else if (isRecord(current)) current = current[segment];
+		else return;
+	}
+	return current;
+}
+//#endregion
+//#region src/supports-native-structured-output-schema.ts
+const MAX_OPTIONAL_PROPERTIES = 10;
+const SUBSCHEMA_KEYWORDS = [
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"then"
+];
+const SUBSCHEMA_LIST_KEYWORDS = [
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+];
+const SUBSCHEMA_MAP_KEYWORDS = [
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+];
+/**
+* Whether Anthropic's native structured outputs (`output_config.format`) can
+* represent a schema without rejecting it or losing data.
+*
+* Rejected: self-referencing schemas, and schemas with too many optional
+* properties. Lossy: open objects (maps, free-form objects), which native
+* structured outputs close with `additionalProperties: false`, so the model
+* can only return `{}` for them.
+*/
+function supportsNativeStructuredOutputSchema(schema) {
+	if (hasCircularSchemaReference(schema)) return false;
+	const { optionalProperties, hasOpenObject } = getSchemaStats(schema, schema, /* @__PURE__ */ new Map());
+	return !hasOpenObject && optionalProperties <= MAX_OPTIONAL_PROPERTIES;
+}
+function getSchemaStats(node, root, refStats) {
+	const stats = {
+		optionalProperties: 0,
+		hasOpenObject: false
+	};
+	if (!isRecord(node)) return stats;
+	const add = (child) => {
+		const childStats = getSchemaStats(child, root, refStats);
+		stats.optionalProperties += childStats.optionalProperties;
+		stats.hasOpenObject ||= childStats.hasOpenObject;
+	};
+	if (typeof node.$ref === "string" && node.$ref.startsWith("#")) {
+		let resolved = refStats.get(node.$ref);
+		if (resolved == null) {
+			resolved = getSchemaStats(resolveSchemaPointer(root, node.$ref), root, refStats);
+			refStats.set(node.$ref, resolved);
+		}
+		stats.optionalProperties += resolved.optionalProperties;
+		stats.hasOpenObject ||= resolved.hasOpenObject;
+	}
+	if (isOpenObject(node)) stats.hasOpenObject = true;
+	if (isRecord(node.properties)) {
+		const required = new Set(Array.isArray(node.required) ? node.required : []);
+		stats.optionalProperties += Object.keys(node.properties).filter((name) => !required.has(name)).length;
+	}
+	for (const keyword of SUBSCHEMA_KEYWORDS) {
+		const value = node[keyword];
+		if (Array.isArray(value)) value.forEach(add);
+		else add(value);
+	}
+	for (const keyword of SUBSCHEMA_LIST_KEYWORDS) {
+		const value = node[keyword];
+		if (Array.isArray(value)) value.forEach(add);
+	}
+	for (const keyword of SUBSCHEMA_MAP_KEYWORDS) {
+		const value = node[keyword];
+		if (isRecord(value)) Object.values(value).forEach(add);
+	}
+	return stats;
+}
+function isOpenObject(node) {
+	const { additionalProperties, patternProperties, properties, type } = node;
+	if (additionalProperties === true || isRecord(additionalProperties)) return true;
+	if (isRecord(patternProperties) && Object.keys(patternProperties).length > 0) return true;
+	return (type === "object" || Array.isArray(type) && type.includes("object")) && properties == null && additionalProperties !== false;
+}
+//#endregion
 //#region src/anthropic-language-model.ts
 function createAnthropicStreamError(error) {
 	const inferredMetadata = getAnthropicStreamErrorMetadata(error.type);
@@ -3864,6 +4023,28 @@ function getProviderOptionsName(provider) {
 	const dotIndex = provider.indexOf(".");
 	return dotIndex === -1 ? provider : provider.substring(0, dotIndex);
 }
+const TEXT_OR_THINKING_BLOCK_TYPES = /* @__PURE__ */ new Set([
+	"redacted_thinking",
+	"text",
+	"thinking"
+]);
+function isContinuationStopReason(stopReason) {
+	return stopReason === "pause_turn" || stopReason === "tool_use";
+}
+/**
+* Text parts to return when the JSON response tool is in use: the text after
+* the last tool call or result, and only if the tool was never called.
+*/
+function getJsonResponseToolFallbackText(content, stopReason) {
+	const text = /* @__PURE__ */ new Set();
+	if (isContinuationStopReason(stopReason)) return text;
+	for (const part of content) {
+		if (part.type === "tool_use" && part.name === "json") return /* @__PURE__ */ new Set();
+		if (part.type === "text") text.add(part);
+		else if (!TEXT_OR_THINKING_BLOCK_TYPES.has(part.type)) text.clear();
+	}
+	return text;
+}
 var AnthropicLanguageModel = class AnthropicLanguageModel {
 	static [WORKFLOW_SERIALIZE](model) {
 		return serializeModelOptions({
@@ -3974,10 +4155,11 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 		}
 		const isAnthropicModel = isKnownModel || modelId.includes("claude-");
 		const supportsStructuredOutput = (config.supportsNativeStructuredOutput ?? true) && modelSupportsStructuredOutput;
+		const supportsResponseSchema = responseFormat?.type !== "json" || responseFormat.schema == null || supportsNativeStructuredOutputSchema(responseFormat.schema);
 		const supportsStrictTools = (config.supportsStrictTools ?? true) && modelSupportsStructuredOutput;
 		const structureOutputMode = anthropicOptions?.structuredOutputMode ?? "auto";
-		let useStructuredOutput = structureOutputMode === "outputFormat" || structureOutputMode === "auto" && supportsStructuredOutput;
-		if (!useStructuredOutput && rejectsForcedToolUse && supportsStructuredOutput && responseFormat?.type === "json" && responseFormat.schema != null) {
+		let useStructuredOutput = structureOutputMode === "outputFormat" || structureOutputMode === "auto" && supportsStructuredOutput && supportsResponseSchema;
+		if (!useStructuredOutput && rejectsForcedToolUse && modelSupportsStructuredOutput && responseFormat?.type === "json" && responseFormat.schema != null && supportsNativeStructuredOutputSchema(responseFormat.schema)) {
 			warnings.push({
 				type: "unsupported",
 				feature: "providerOptions.anthropic.structuredOutputMode",
@@ -4276,7 +4458,7 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 		else if (anthropicOptions?.fallbacks && anthropicOptions.fallbacks.length > 0) betas.add("server-side-fallback-2026-06-01");
 		const defaultEagerInputStreaming = stream && (anthropicOptions?.toolStreaming ?? true);
 		const { tools: anthropicTools, toolChoice: anthropicToolChoice, toolWarnings, betas: toolsBetas } = await prepareTools(jsonResponseTool != null ? {
-			tools: [...tools ?? [], jsonResponseTool],
+			tools: [...(tools ?? []).filter((tool) => toolChoice?.type !== "none" && (toolChoice?.type !== "tool" || tool.name === toolChoice.toolName)), jsonResponseTool],
 			toolChoice: { type: "required" },
 			disableParallelToolUse: true,
 			cacheControlValidator,
@@ -4384,9 +4566,10 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 		const serverToolCalls = {};
 		let isJsonResponseFromTool = false;
 		const hasWebSearchResults = response.content.some((part) => part.type === "web_search_tool_result" && Array.isArray(part.content) && part.content.length > 0);
+		const jsonResponseToolFallbackText = usesJsonResponseTool ? getJsonResponseToolFallbackText(response.content, response.stop_reason) : void 0;
 		for (const part of response.content) switch (part.type) {
 			case "text":
-				if (!usesJsonResponseTool) {
+				if (jsonResponseToolFallbackText == null || jsonResponseToolFallbackText.has(part)) {
 					const citations = part.citations ?? [];
 					content.push({
 						type: "text",
@@ -4824,6 +5007,16 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 		let safeguardResults;
 		let container = null;
 		let isJsonResponseFromTool = false;
+		const heldBackText = [];
+		const heldBackTextByIndex = /* @__PURE__ */ new Map();
+		const createTextEnd = (id, citations) => ({
+			type: "text-end",
+			id,
+			...citations.length > 0 && {
+				citations: citations.map((citation) => mapAnthropicCitation(citation, citationDocuments)),
+				providerMetadata: { anthropic: { citations } }
+			}
+		});
 		let hasWebSearchResults = false;
 		const fallbackWebCitations = [];
 		let isMessageOpen = false;
@@ -4870,9 +5063,19 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 							return;
 						}
 						blockType = contentBlockType;
+						if (!TEXT_OR_THINKING_BLOCK_TYPES.has(contentBlockType)) heldBackText.length = 0;
 						switch (contentBlockType) {
 							case "text":
-								if (usesJsonResponseTool) return;
+								if (usesJsonResponseTool) {
+									const entry = {
+										id: String(value.index),
+										text: "",
+										citations: []
+									};
+									heldBackText.push(entry);
+									heldBackTextByIndex.set(value.index, entry);
+									return;
+								}
 								contentBlocks[value.index] = {
 									type: "text",
 									citations: []
@@ -5258,14 +5461,7 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 							const contentBlock = contentBlocks[value.index];
 							switch (contentBlock.type) {
 								case "text":
-									controller.enqueue({
-										type: "text-end",
-										id: String(value.index),
-										...contentBlock.citations.length > 0 && {
-											citations: contentBlock.citations.map((citation) => mapAnthropicCitation(citation, citationDocuments)),
-											providerMetadata: { anthropic: { citations: contentBlock.citations } }
-										}
-									});
+									controller.enqueue(createTextEnd(String(value.index), contentBlock.citations));
 									break;
 								case "reasoning":
 									controller.enqueue({
@@ -5325,7 +5521,11 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 						const deltaType = value.delta.type;
 						switch (deltaType) {
 							case "text_delta":
-								if (usesJsonResponseTool) return;
+								if (usesJsonResponseTool) {
+									const entry = heldBackTextByIndex.get(value.index);
+									if (entry != null) entry.text += value.delta.text;
+									return;
+								}
 								controller.enqueue({
 									type: "text-delta",
 									id: String(value.index),
@@ -5386,6 +5586,7 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 								const citation = value.delta.citation;
 								const contentBlock = contentBlocks[value.index];
 								if (contentBlock?.type === "text") contentBlock.citations.push(citation);
+								heldBackTextByIndex.get(value.index)?.citations.push(citation);
 								if (citation.type === "web_search_result_location") fallbackWebCitations.push(citation);
 								else {
 									const source = createCitationSource(citation, citationDocuments, generateId);
@@ -5411,6 +5612,7 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 						}
 						isMessageOpen = true;
 						activeMessageId = value.message.id;
+						heldBackTextByIndex.clear();
 						usage.input_tokens = value.message.usage.input_tokens;
 						usage.cache_read_input_tokens = value.message.usage.cache_read_input_tokens ?? 0;
 						usage.cache_creation_input_tokens = value.message.usage.cache_creation_input_tokens ?? 0;
@@ -5531,6 +5733,20 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 							if (source) controller.enqueue(source);
 						}
 						fallbackWebCitations.length = 0;
+						if (!isJsonResponseFromTool && !isContinuationStopReason(finishReason.raw)) for (const { id, text, citations } of heldBackText) {
+							if (text.length === 0) continue;
+							controller.enqueue({
+								type: "text-start",
+								id
+							});
+							controller.enqueue({
+								type: "text-delta",
+								id,
+								delta: text
+							});
+							controller.enqueue(createTextEnd(id, citations));
+						}
+						heldBackText.length = 0;
 						controller.enqueue({
 							type: "finish",
 							finishReason,
@@ -7133,7 +7349,7 @@ var AnthropicSkills = class {
 };
 //#endregion
 //#region src/version.ts
-const VERSION = "4.0.93";
+const VERSION = "4.0.95";
 //#endregion
 //#region src/anthropic-provider.ts
 const ANTHROPIC_API_URL = "https://api.anthropic.com";