@ai-sdk/anthropic 4.0.92 → 4.0.94

package/dist/internal/index.js

@@ -63,6 +63,330 @@ var AnthropicFiles = class {
 	}
 };
 //#endregion
+//#region src/anthropic-model-catalog.ts
+/**
+* Options accepted under `providerOptions.anthropic`. The `satisfies` check
+* keeps this list in sync with the option schema.
+*/
+const anthropicProviderOptions = { language: {
+	sendReasoning: { description: "Whether to send reasoning to the model." },
+	structuredOutputMode: { description: "How structured outputs are generated." },
+	thinking: { description: "Extended thinking configuration." },
+	disableParallelToolUse: { description: "Use at most one tool per response." },
+	cacheControl: { description: "Prompt cache control settings." },
+	metadata: { description: "Request metadata, such as a user ID." },
+	mcpServers: { description: "MCP servers to use in the request." },
+	container: { description: "Container and Agent Skills configuration." },
+	toolStreaming: { description: "Fine-grained streaming of tool inputs and outputs." },
+	effort: { description: "Effort spent on thinking, text, and tool calls." },
+	taskBudget: { description: "Advisory token budget for an agentic task." },
+	speed: { description: "Fast mode for faster output token speeds." },
+	serviceTier: { description: "Service tier for the request." },
+	inferenceGeo: { description: "Where model inference runs." },
+	fallbacks: { description: "Server-side fallback models." },
+	anthropicBeta: { description: "Additional beta features to enable." },
+	safeguards: { description: "Server-side safeguards to run." },
+	compaction: { description: "On-demand conversation summary." },
+	contextManagement: { description: "Server-side context management." }
+} };
+const legacyClaude = defineRuntime({});
+const currentClaude = defineRuntime({
+	maxOutputTokens: 128e3,
+	nativeStructuredOutput: true,
+	adaptiveThinking: true
+});
+const currentClaudeWithoutSampling = defineRuntime({
+	...currentClaude,
+	samplingParameters: false,
+	xhighEffort: true
+});
+function defineRuntime(overrides) {
+	return {
+		maxOutputTokens: 4096,
+		nativeStructuredOutput: false,
+		adaptiveThinking: false,
+		samplingParameters: true,
+		xhighEffort: false,
+		thinkingCanBeDisabledAboveHighEffort: true,
+		thinkingCanBeDisabled: true,
+		budgetThinking: true,
+		forcedToolUse: true,
+		betweenToolsThinking: false,
+		knownModel: true,
+		...overrides
+	};
+}
+const runtimeRules = [
+	{
+		matches: (modelId) => modelId.includes("claude-sonnet-5-5"),
+		definition: defineRuntime({
+			...currentClaudeWithoutSampling,
+			thinkingCanBeDisabledAboveHighEffort: false,
+			thinkingCanBeDisabled: false,
+			budgetThinking: false,
+			forcedToolUse: false,
+			betweenToolsThinking: true
+		})
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-opus-5-5"),
+		definition: defineRuntime({
+			...currentClaudeWithoutSampling,
+			thinkingCanBeDisabledAboveHighEffort: false,
+			thinkingCanBeDisabled: false,
+			budgetThinking: false,
+			forcedToolUse: false
+		})
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-haiku-5-5"),
+		definition: defineRuntime({
+			...currentClaudeWithoutSampling,
+			thinkingCanBeDisabledAboveHighEffort: false,
+			budgetThinking: false
+		})
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-opus-5"),
+		definition: defineRuntime({
+			...currentClaudeWithoutSampling,
+			thinkingCanBeDisabledAboveHighEffort: false
+		})
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-fable-5-1"),
+		definition: defineRuntime({
+			...currentClaudeWithoutSampling,
+			thinkingCanBeDisabled: false,
+			budgetThinking: false,
+			forcedToolUse: false
+		})
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-fable-5"),
+		definition: defineRuntime({
+			...currentClaudeWithoutSampling,
+			thinkingCanBeDisabled: false,
+			budgetThinking: false
+		})
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-opus-4-8") || modelId.includes("claude-opus-4-7") || modelId.includes("claude-sonnet-5"),
+		definition: currentClaudeWithoutSampling
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-sonnet-4-6") || modelId.includes("claude-opus-4-6"),
+		definition: currentClaude
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-sonnet-4-5") || modelId.includes("claude-opus-4-5") || modelId.includes("claude-haiku-4-5"),
+		definition: defineRuntime({
+			maxOutputTokens: 64e3,
+			nativeStructuredOutput: true
+		})
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-opus-4-1"),
+		definition: defineRuntime({
+			maxOutputTokens: 32e3,
+			nativeStructuredOutput: true
+		})
+	},
+	{
+		matches: (modelId) => /claude-sonnet-4(?:-|@)/.test(modelId),
+		definition: defineRuntime({ maxOutputTokens: 64e3 })
+	},
+	{
+		matches: (modelId) => /claude-opus-4(?:-|@)/.test(modelId),
+		definition: defineRuntime({ maxOutputTokens: 32e3 })
+	},
+	{
+		matches: (modelId) => modelId.includes("claude-3-haiku"),
+		definition: legacyClaude
+	},
+	{
+		matches: (modelId) => /claude-(?:instant(?:-|$)|v?2(?=$|[-.:])|3(?=$|[-.]))/.test(modelId),
+		definition: defineRuntime({ knownModel: false })
+	}
+];
+const anthropicModelCatalog = Object.fromEntries(Object.entries({
+	"claude-opus-5-5": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-opus-5": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-sonnet-5-5": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-sonnet-5": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-haiku-5-5": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-fable-5-1": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-fable-5": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-opus-4-8": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-opus-4-7": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-opus-4-6": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-sonnet-4-6": {
+		toolSearch: true,
+		compaction: true,
+		effort: true
+	},
+	"claude-opus-4-5": {
+		toolSearch: true,
+		compaction: false,
+		effort: true
+	},
+	"claude-haiku-4-5": {
+		toolSearch: true,
+		compaction: false,
+		effort: false
+	},
+	"claude-sonnet-4-5": {
+		toolSearch: true,
+		compaction: false,
+		effort: false
+	},
+	"claude-opus-4-1": {
+		toolSearch: false,
+		compaction: false,
+		effort: false
+	},
+	"claude-opus-4-0": {
+		toolSearch: false,
+		compaction: false,
+		effort: false
+	},
+	"claude-sonnet-4-0": {
+		toolSearch: false,
+		compaction: false,
+		effort: false
+	}
+}).map(([modelId, capabilities]) => [modelId, createAnthropicLanguageModelEntry(modelId, capabilities)]));
+function getAnthropicLanguageModelEntry(modelId) {
+	return Object.prototype.hasOwnProperty.call(anthropicModelCatalog, modelId) ? anthropicModelCatalog[modelId] : createAnthropicLanguageModelEntry(modelId);
+}
+function createAnthropicLanguageModelEntry(modelId, documented) {
+	const runtime = resolveRuntimeDefinition(modelId);
+	const declared = documented != null;
+	const samplingSupport = runtime.samplingParameters ? true : { condition: "Only supported when thinking is disabled." };
+	const reasoningSupport = runtime.adaptiveThinking || runtime.budgetThinking;
+	return {
+		capabilities: { language: {
+			inputs: {
+				image: declared ? true : "unknown",
+				audio: declared ? false : "unknown"
+			},
+			objectGeneration: declared ? true : "unknown",
+			tools: {
+				usage: declared ? true : "unknown",
+				streaming: declared ? true : "unknown",
+				forcedChoice: runtime.forcedToolUse,
+				computerUse: declared ? true : "unknown",
+				webSearch: declared ? true : "unknown",
+				toolSearch: documented?.toolSearch ?? "unknown"
+			},
+			reasoning: {
+				support: reasoningSupport,
+				efforts: runtime.xhighEffort ? [
+					"low",
+					"medium",
+					"high",
+					"xhigh",
+					"max"
+				] : void 0,
+				adaptive: runtime.adaptiveThinking,
+				budget: runtime.budgetThinking,
+				canDisable: runtime.thinkingCanBeDisabled,
+				canDisableAboveHighEffort: runtime.thinkingCanBeDisabledAboveHighEffort,
+				supportsXhighEffort: runtime.xhighEffort,
+				betweenTools: runtime.betweenToolsThinking
+			},
+			sampling: {
+				temperature: samplingSupport,
+				topP: samplingSupport,
+				topK: samplingSupport,
+				logprobs: false
+			},
+			structuredOutput: { native: runtime.nativeStructuredOutput },
+			compaction: documented?.compaction ?? "unknown"
+		} },
+		providerOptions: { language: declareProviderOptions(anthropicProviderOptions.language, declared ? true : "unknown", {
+			thinking: reasoningSupport,
+			effort: documented?.effort ?? "unknown",
+			speed: declared ? modelId === "claude-opus-4-6" : "unknown",
+			taskBudget: modelId === "claude-opus-4-7" ? true : "unknown"
+		}) },
+		requestConfig: { language: {
+			maxOutputTokens: runtime.maxOutputTokens,
+			knownModel: runtime.knownModel
+		} }
+	};
+}
+/** Applies one default support value to every option, except the listed ones. */
+function declareProviderOptions(definitions, support, exceptions) {
+	return Object.fromEntries(Object.keys(definitions).map((option) => [option, exceptions[option] ?? support]));
+}
+function resolveRuntimeDefinition(modelId) {
+	const rule = runtimeRules.find((rule) => rule.matches(modelId));
+	if (rule != null) return rule.definition;
+	return modelId.includes("claude-") ? defineRuntime({
+		...currentClaudeWithoutSampling,
+		thinkingCanBeDisabledAboveHighEffort: false,
+		knownModel: false
+	}) : defineRuntime({ knownModel: false });
+}
+/** Compatibility projection for the provider's existing request preparation. */
+function getAnthropicModelCapabilities(modelId) {
+	const { capabilities: { language }, requestConfig: { language: requestConfig } } = getAnthropicLanguageModelEntry(modelId);
+	return {
+		maxOutputTokens: requestConfig.maxOutputTokens,
+		supportsStructuredOutput: language.structuredOutput.native,
+		supportsAdaptiveThinking: language.reasoning.adaptive,
+		rejectsSamplingParameters: language.sampling.temperature !== true,
+		supportsXhighEffort: language.reasoning.supportsXhighEffort,
+		rejectsThinkingDisabledAboveHighEffort: !language.reasoning.canDisableAboveHighEffort,
+		rejectsThinkingDisabled: !language.reasoning.canDisable,
+		rejectsBudgetThinking: !language.reasoning.budget,
+		rejectsForcedToolUse: !language.tools.forcedChoice,
+		supportsBetweenToolsThinking: language.reasoning.betweenTools,
+		isKnownModel: requestConfig.knownModel
+	};
+}
+//#endregion
 //#region src/map-anthropic-citation.ts
 function mapAnthropicCitation(citation, documents) {
 	if (citation.type === "web_search_result_location" || citation.type === "search_result_location") {
@@ -3375,8 +3699,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;
@@ -3388,11 +3714,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;
@@ -3404,6 +3726,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];
@@ -3421,6 +3751,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);
@@ -3539,6 +4018,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({
@@ -3615,7 +4116,7 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 		}) : null;
 		const usedCustomProviderKey = customProviderOptions != null;
 		const anthropicOptions = Object.assign({}, canonicalOptions ?? {}, customProviderOptions ?? {});
-		const { maxOutputTokens: maxOutputTokensForModel, supportsStructuredOutput: modelSupportsStructuredOutput, supportsAdaptiveThinking, rejectsSamplingParameters, supportsXhighEffort, rejectsThinkingDisabledAboveHighEffort, rejectsThinkingDisabled, rejectsBudgetThinking, rejectsForcedToolUse, supportsBetweenToolsThinking, isKnownModel } = getModelCapabilities(modelId);
+		const { maxOutputTokens: maxOutputTokensForModel, supportsStructuredOutput: modelSupportsStructuredOutput, supportsAdaptiveThinking, rejectsSamplingParameters, supportsXhighEffort, rejectsThinkingDisabledAboveHighEffort, rejectsThinkingDisabled, rejectsBudgetThinking, rejectsForcedToolUse, supportsBetweenToolsThinking, isKnownModel } = getAnthropicModelCapabilities(modelId);
 		if (!isKnownModel && maxOutputTokens == null) warnings.push({
 			type: "compatibility",
 			feature: "maxOutputTokens",
@@ -3652,7 +4153,7 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 		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) {
+		if (!useStructuredOutput && rejectsForcedToolUse && modelSupportsStructuredOutput && responseFormat?.type === "json" && responseFormat.schema != null && supportsNativeStructuredOutputSchema(responseFormat.schema)) {
 			warnings.push({
 				type: "unsupported",
 				feature: "providerOptions.anthropic.structuredOutputMode",
@@ -4059,9 +4560,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",
@@ -4499,6 +5001,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;
@@ -4545,9 +5057,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: []
@@ -4933,14 +5455,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({
@@ -5000,7 +5515,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),
@@ -5061,6 +5580,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);
@@ -5086,6 +5606,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;
@@ -5206,6 +5727,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,
@@ -5305,222 +5840,6 @@ var AnthropicLanguageModel = class AnthropicLanguageModel {
 		};
 	}
 };
-/**
-* Returns the capabilities of a Claude model that are used for defaults and feature selection.
-*
-* @see https://docs.claude.com/en/docs/about-claude/models/overview#model-comparison-table
-* @see https://platform.claude.com/docs/en/build-with-claude/structured-outputs
-*/
-function getModelCapabilities(modelId) {
-	if (modelId.includes("claude-sonnet-5-5")) return {
-		maxOutputTokens: 128e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: true,
-		rejectsSamplingParameters: true,
-		supportsXhighEffort: true,
-		rejectsThinkingDisabledAboveHighEffort: true,
-		rejectsThinkingDisabled: true,
-		rejectsBudgetThinking: true,
-		rejectsForcedToolUse: true,
-		supportsBetweenToolsThinking: true,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-opus-5-5")) return {
-		maxOutputTokens: 128e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: true,
-		rejectsSamplingParameters: true,
-		supportsXhighEffort: true,
-		rejectsThinkingDisabledAboveHighEffort: true,
-		rejectsThinkingDisabled: true,
-		rejectsBudgetThinking: true,
-		rejectsForcedToolUse: true,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-haiku-5-5")) return {
-		maxOutputTokens: 128e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: true,
-		rejectsSamplingParameters: true,
-		supportsXhighEffort: true,
-		rejectsThinkingDisabledAboveHighEffort: true,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: true,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-opus-5")) return {
-		maxOutputTokens: 128e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: true,
-		rejectsSamplingParameters: true,
-		supportsXhighEffort: true,
-		rejectsThinkingDisabledAboveHighEffort: true,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-fable-5-1")) return {
-		maxOutputTokens: 128e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: true,
-		rejectsSamplingParameters: true,
-		supportsXhighEffort: true,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: true,
-		rejectsBudgetThinking: true,
-		rejectsForcedToolUse: true,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-fable-5")) return {
-		maxOutputTokens: 128e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: true,
-		rejectsSamplingParameters: true,
-		supportsXhighEffort: true,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: true,
-		rejectsBudgetThinking: true,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-opus-4-8") || modelId.includes("claude-opus-4-7") || modelId.includes("claude-sonnet-5")) return {
-		maxOutputTokens: 128e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: true,
-		rejectsSamplingParameters: true,
-		supportsXhighEffort: true,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-sonnet-4-6") || modelId.includes("claude-opus-4-6")) return {
-		maxOutputTokens: 128e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: true,
-		rejectsSamplingParameters: false,
-		supportsXhighEffort: false,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-sonnet-4-5") || modelId.includes("claude-opus-4-5") || modelId.includes("claude-haiku-4-5")) return {
-		maxOutputTokens: 64e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: false,
-		rejectsSamplingParameters: false,
-		supportsXhighEffort: false,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-opus-4-1")) return {
-		maxOutputTokens: 32e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: false,
-		rejectsSamplingParameters: false,
-		supportsXhighEffort: false,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (/claude-sonnet-4(?:-|@)/.test(modelId)) return {
-		maxOutputTokens: 64e3,
-		supportsStructuredOutput: false,
-		supportsAdaptiveThinking: false,
-		rejectsSamplingParameters: false,
-		supportsXhighEffort: false,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (/claude-opus-4(?:-|@)/.test(modelId)) return {
-		maxOutputTokens: 32e3,
-		supportsStructuredOutput: false,
-		supportsAdaptiveThinking: false,
-		rejectsSamplingParameters: false,
-		supportsXhighEffort: false,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (modelId.includes("claude-3-haiku")) return {
-		maxOutputTokens: 4096,
-		supportsStructuredOutput: false,
-		supportsAdaptiveThinking: false,
-		rejectsSamplingParameters: false,
-		supportsXhighEffort: false,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: true
-	};
-	else if (/claude-(?:instant(?:-|$)|v?2(?=$|[-.:])|3(?=$|[-.]))/.test(modelId)) return {
-		maxOutputTokens: 4096,
-		supportsStructuredOutput: false,
-		supportsAdaptiveThinking: false,
-		rejectsSamplingParameters: false,
-		supportsXhighEffort: false,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: false
-	};
-	else if (modelId.includes("claude-")) return {
-		maxOutputTokens: 128e3,
-		supportsStructuredOutput: true,
-		supportsAdaptiveThinking: true,
-		rejectsSamplingParameters: true,
-		supportsXhighEffort: true,
-		rejectsThinkingDisabledAboveHighEffort: true,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: false
-	};
-	else return {
-		maxOutputTokens: 4096,
-		supportsStructuredOutput: false,
-		supportsAdaptiveThinking: false,
-		rejectsSamplingParameters: false,
-		supportsXhighEffort: false,
-		rejectsThinkingDisabledAboveHighEffort: false,
-		rejectsThinkingDisabled: false,
-		rejectsBudgetThinking: false,
-		rejectsForcedToolUse: false,
-		supportsBetweenToolsThinking: false,
-		isKnownModel: false
-	};
-}
 function hasDynamicFilteringWebToolWithoutCodeExecution(tools) {
 	if (!tools) return false;
 	let hasDynamicFilteringWebTool = false;
@@ -6293,6 +6612,6 @@ var AnthropicSkills = class {
 	}
 };
 //#endregion
-export { AnthropicFiles, AnthropicLanguageModel, AnthropicLanguageModel as AnthropicMessagesLanguageModel, AnthropicSkills, anthropicTools, getModelCapabilities, prepareTools, sanitizeJsonSchema };
+export { AnthropicFiles, AnthropicLanguageModel, AnthropicLanguageModel as AnthropicMessagesLanguageModel, AnthropicSkills, anthropicTools, getAnthropicModelCapabilities as getModelCapabilities, prepareTools, sanitizeJsonSchema };
 
 //# sourceMappingURL=index.js.map