@openclaw/ai 2026.7.2-beta.7 → 2026.7.34

package/dist/{anthropic-CH4UUnZr.mjs → anthropic-Bcdbq-l5.mjs}

@@ -1,23 +1,331 @@
-import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
-import { d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, h as supportsClaudeNativeMaxEffort, l as resolveClaudeNativeThinkingLevelMap, p as supportsClaudeAdaptiveThinking, u as resolveClaudeOpus5ModelIdentity } from "./src-QkygScBs.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { a as applyClaudeRequestContract, c as requiresClaudeAdaptiveThinking, d as usesClaudeStreamingRefusalContract, i as transformMessages, n as getAiTransportHost, r as resolveAiTransportHeaderSentinels, s as prepareClaudeNoPrefillRequestContext, u as usesClaudeFable5MessagesContract } from "./host-Dog2WQiR.mjs";
-import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { a as isImageWithMediaPayload, d as stripSystemPromptCacheBoundary, n as extractToolResultBlockText, r as extractToolResultText, t as describeToolResultMediaPlaceholder, u as splitSystemPromptCacheBoundary } from "./tool-result-text-CTpIRbYd.mjs";
-import { _ as omitFoundryBearerCredentialHeaders, a as projectAnthropicTools, b as normalizeAnthropicInlineContent, c as ANTHROPIC_OMITTED_REASONING_TEXT, d as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, g as applyAnthropicRefusal, h as resolveAnthropicFallbackServingModelCost, i as readLastAnthropicIterationUsage, l as findActiveAnthropicToolTurnAssistantIndex, m as readAnthropicFallbackBoundary, n as readAnthropicPromptUsageSnapshot, o as reconcileAnthropicToolChoice, p as applyAnthropicFallbackBoundary, r as readAnthropicUsageTokenCount, s as resolveOriginalAnthropicToolName, t as readAnthropicCacheWriteUsage, u as ANTHROPIC_SERVER_SIDE_FALLBACKS, v as usesFoundryBearerAuth, x as resolveAnthropicImageMediaType, y as createAnthropicInlineImageBudget } from "./anthropic-usage-DWU-x8MI.mjs";
-import { c as calculateCost, l as clampThinkingLevel } from "./number-coercion-DvG7SNMg.mjs";
-import { t as createDeferredEventBuffer } from "./deferred-event-buffer-DAvyP7qA.mjs";
-import { n as parseStreamingJson, t as parseJsonWithRepair } from "./json-parse-BvXNt1-7.mjs";
-import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-D81p90xq.mjs";
+import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-CtMlqaQ4.mjs";
+import { d as resolveClaudeSonnet5ModelIdentity, f as supportsClaudeAdaptiveThinking, l as resolveClaudeNativeThinkingLevelMap, m as supportsClaudeNativeXhighEffort, p as supportsClaudeNativeMaxEffort, u as resolveClaudeOpus5ModelIdentity } from "./src-CjOfhrH3.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-4t713IeR.mjs";
+import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-Cn9KAz3z.mjs";
+import { r as createDeferredEventBuffer, t as notifyLlmRequestActivity } from "./llm-request-activity-CehVkZP-.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { t as formatProviderError } from "./provider-error-CAEvRjry.mjs";
-import { i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-NCJtz9i0.mjs";
-import { n as buildBaseOptions, r as clampMaxTokensToModel, t as adjustMaxTokensForThinking } from "./simple-options-9lhRrN73.mjs";
-import "./transform-messages-C8mBqZxF.mjs";
+import { n as parseStreamingJson, t as parseJsonWithRepair } from "./json-parse-DzNSIQBq.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
+import { a as adjustMaxTokensForThinking, b as stripSystemPromptCacheBoundary, c as isRecord, d as prepareClaudeNoPrefillRequestContext, f as requiresClaudeAdaptiveThinking, h as usesClaudeStreamingRefusalContract, i as extractToolResultText, l as applyClaudeRequestContract, m as usesClaudeFable5MessagesContract, n as describeToolResultMediaPlaceholder, o as buildBaseOptions, r as extractToolResultBlockText, t as transformMessages, y as splitSystemPromptCacheBoundary } from "./transform-messages-DoWx35pj.mjs";
+import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BwNu3nDi.mjs";
+import { a as resolveCacheRetention, i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-BsH5cqGj.mjs";
 import Anthropic from "@anthropic-ai/sdk";
-import { Stream } from "@anthropic-ai/sdk/core/streaming.js";
+//#region packages/ai/src/providers/anthropic-auth-headers.ts
+function usesFoundryBearerAuth(model) {
+	return model.provider === "microsoft-foundry" && (model.authHeader === true || hasBearerAuthorizationHeader(model.headers));
+}
+function hasBearerAuthorizationHeader(headers) {
+	if (!headers) return false;
+	return Object.entries(headers).some(([key, value]) => key.toLowerCase() === "authorization" && /^bearer\s+\S+/i.test(value.trim()));
+}
+function omitFoundryBearerCredentialHeaders(headers) {
+	if (!headers) return;
+	const next = {};
+	for (const [key, value] of Object.entries(headers)) {
+		const lower = key.toLowerCase();
+		if (lower === "authorization" || lower === "x-api-key" || lower === "api-key") continue;
+		next[key] = value;
+	}
+	return Object.keys(next).length > 0 ? next : void 0;
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-refusal.ts
+function readNullableString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readAnthropicRefusalDetails(value) {
+	if (!value || typeof value !== "object") return {
+		category: null,
+		explanation: null
+	};
+	const details = value;
+	return {
+		category: readNullableString(details.category),
+		explanation: readNullableString(details.explanation)
+	};
+}
+function formatAnthropicRefusalMessage(details) {
+	return `Anthropic refusal${details.category ? ` (category: ${details.category})` : ""}${details.explanation ? `: ${details.explanation}` : "."}`;
+}
+function applyAnthropicRefusal(output, stopDetails, provider) {
+	const details = readAnthropicRefusalDetails(stopDetails);
+	output.stopReason = "error";
+	output.errorMessage = formatAnthropicRefusalMessage(details);
+	output.diagnostics = [...output.diagnostics ?? [], {
+		type: "provider_refusal",
+		timestamp: Date.now(),
+		details: {
+			provider,
+			category: details.category,
+			explanation: details.explanation
+		}
+	}];
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-server-fallback.ts
+/** Anthropic beta that re-serves safety refusals on an allowed fallback model. */
+const ANTHROPIC_SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-06-01";
+const CLAUDE_FABLE_5_FALLBACK_MODEL = "claude-opus-4-8";
+const CLAUDE_FABLE_5_FALLBACK_MODEL_COST = {
+	input: 5,
+	output: 25,
+	cacheRead: .5,
+	cacheWrite: 6.25
+};
+function buildAnthropicServerSideFallbacks() {
+	return [{ model: CLAUDE_FABLE_5_FALLBACK_MODEL }];
+}
+function readBoundaryModel(value) {
+	if (!value || typeof value !== "object") return null;
+	const model = value.model;
+	return typeof model === "string" && model.trim() ? model : null;
+}
+/** Reads a `fallback` content block marking where one model's output gives way to the next. */
+function readAnthropicFallbackBoundary(block) {
+	if (!block || typeof block !== "object") return null;
+	const record = block;
+	if (record.type !== "fallback") return null;
+	return {
+		fromModel: readBoundaryModel(record.from),
+		toModel: readBoundaryModel(record.to)
+	};
+}
+/**
+* Drops pre-fallback thinking/tool calls while preserving the text prefix that
+* the serving model continued. Dropped tool calls must never execute or replay.
+*/
+function applyAnthropicFallbackBoundary(params) {
+	const { output, boundary } = params;
+	const survivors = output.content.filter((block) => block.type === "text");
+	for (const survivor of survivors) delete survivor.textSignature;
+	output.content.splice(0, output.content.length, ...survivors);
+	if (boundary.toModel) output.responseModel = boundary.toModel;
+	output.diagnostics = [...output.diagnostics ?? [], {
+		type: "provider_fallback",
+		timestamp: Date.now(),
+		details: {
+			provider: params.provider,
+			fromModel: boundary.fromModel,
+			toModel: boundary.toModel
+		}
+	}];
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-thinking-replay.ts
+const ANTHROPIC_OMITTED_REASONING_TEXT = "[assistant reasoning omitted]";
+function asReplayMessage(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+/**
+* Anthropic tool results continue the preceding assistant turn. Preserve that
+* turn's signed thinking even when the next request disables new thinking.
+*/
+function findActiveAnthropicToolTurnAssistantIndex(messages) {
+	const toolResultIds = /* @__PURE__ */ new Set();
+	let index = messages.length - 1;
+	while (index >= 0) {
+		const message = asReplayMessage(messages[index]);
+		if (message?.role !== "toolResult") break;
+		if (typeof message.toolCallId === "string") toolResultIds.add(message.toolCallId);
+		index -= 1;
+	}
+	if (toolResultIds.size === 0) return -1;
+	const assistant = asReplayMessage(messages[index]);
+	if (assistant?.role !== "assistant" || !Array.isArray(assistant.content)) return -1;
+	const toolCallIds = /* @__PURE__ */ new Set();
+	for (const block of assistant.content) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		if ((record.type === "toolCall" || record.type === "tool_use" || record.type === "function_call") && typeof record.id === "string") toolCallIds.add(record.id);
+	}
+	return [...toolResultIds].every((toolCallId) => toolCallIds.has(toolCallId)) ? index : -1;
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-tool-projection.ts
+function isProviderSupportedViolation(violation) {
+	return violation.endsWith(".$dynamicRef") || violation.endsWith(".$dynamicAnchor");
+}
+const schemaValueKeywords = /* @__PURE__ */ new Set([
+	"additionalProperties",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+const schemaArrayKeywords = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+]);
+const schemaMapKeywords = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependencies",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+function normalizeAnthropicJsonSchema(schema) {
+	if (!isRecord(schema)) return schema;
+	let changed = false;
+	const normalized = { ...schema };
+	for (const [key, value] of Object.entries(schema)) {
+		if (schemaValueKeywords.has(key) && !Array.isArray(value)) {
+			const next = normalizeAnthropicJsonSchema(value);
+			normalized[key] = next;
+			changed ||= next !== value;
+			continue;
+		}
+		if (schemaArrayKeywords.has(key) && Array.isArray(value)) {
+			const next = value.map(normalizeAnthropicJsonSchema);
+			normalized[key] = next;
+			changed ||= next.some((entry, index) => entry !== value[index]);
+			continue;
+		}
+		if (schemaMapKeywords.has(key) && isRecord(value)) {
+			const next = Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, normalizeAnthropicJsonSchema(entryValue)]));
+			normalized[key] = next;
+			changed ||= Object.entries(value).some(([entryKey, entryValue]) => next[entryKey] !== entryValue);
+		}
+	}
+	if (Array.isArray(schema.items)) {
+		normalized.prefixItems = schema.items.map(normalizeAnthropicJsonSchema);
+		const additionalItems = schema.additionalItems;
+		if (typeof additionalItems === "boolean" || isRecord(additionalItems)) normalized.items = normalizeAnthropicJsonSchema(additionalItems);
+		else delete normalized.items;
+		delete normalized.additionalItems;
+		changed = true;
+	}
+	return changed ? normalized : schema;
+}
+/** Snapshots direct/custom tool descriptors before Anthropic payload construction. */
+function projectAnthropicTools(tools, toWireName) {
+	const projectedTools = [];
+	const unavailableOriginalNames = /* @__PURE__ */ new Set();
+	for (const tool of tools) {
+		let projectedTool;
+		let originalName;
+		try {
+			const name = tool.name;
+			originalName = name;
+			if (!name) continue;
+			const schemaProjection = projectRuntimeToolInputSchema(tool.parameters, `${name}.parameters`);
+			if (!isRecord(schemaProjection.schema) || schemaProjection.violations.some((violation) => !isProviderSupportedViolation(violation))) {
+				unavailableOriginalNames.add(name);
+				continue;
+			}
+			const anthropicSchema = normalizeAnthropicJsonSchema(schemaProjection.schema);
+			if (!isRecord(anthropicSchema)) {
+				unavailableOriginalNames.add(name);
+				continue;
+			}
+			const properties = anthropicSchema.properties;
+			const required = anthropicSchema.required;
+			if (properties !== void 0 && properties !== null && !isRecord(properties) || required !== void 0 && required !== null && (!Array.isArray(required) || required.some((entry) => typeof entry !== "string"))) {
+				unavailableOriginalNames.add(name);
+				continue;
+			}
+			let description;
+			try {
+				description = typeof tool.description === "string" ? tool.description : void 0;
+			} catch {}
+			projectedTool = {
+				originalName: name,
+				wireName: toWireName(name),
+				...description ? { description } : {},
+				inputSchema: {
+					type: "object",
+					properties: properties ?? {},
+					required: required ?? []
+				}
+			};
+		} catch {
+			if (originalName) unavailableOriginalNames.add(originalName);
+			continue;
+		}
+		const conflictingTool = projectedTools.find((entry) => entry.wireName === projectedTool.wireName);
+		if (conflictingTool && conflictingTool.originalName !== projectedTool.originalName) throw new Error(`Anthropic tool names "${conflictingTool.originalName}" and "${projectedTool.originalName}" both map to "${projectedTool.wireName}"`);
+		projectedTools.push(projectedTool);
+	}
+	return {
+		inputToolCount: tools.length,
+		unavailableOriginalNames,
+		tools: projectedTools
+	};
+}
+/** Keeps forced Anthropic tool choices aligned with the projected wire names. */
+function reconcileAnthropicToolChoice(choice, projection) {
+	if (projection.inputToolCount === 0) return choice;
+	if (choice.type === "tool") {
+		const requestedName = choice.name;
+		const originalMatch = projection.tools.find((tool) => tool.originalName === requestedName);
+		if (originalMatch) return {
+			...choice,
+			name: originalMatch.wireName
+		};
+		if (projection.unavailableOriginalNames.has(requestedName)) throw new Error(`Anthropic tool_choice requested unavailable tool "${requestedName}" after schema conversion`);
+		const matchedTool = projection.tools.find((tool) => tool.wireName === requestedName);
+		if (!matchedTool) throw new Error(`Anthropic tool_choice requested unavailable tool "${requestedName}" after schema conversion`);
+		return {
+			...choice,
+			name: matchedTool.wireName
+		};
+	}
+	if (projection.tools.length === 0) {
+		if (choice.type === "auto") return;
+		if (choice.type === "any") throw new Error("Anthropic tool_choice requires a tool, but no tools survived schema conversion");
+	}
+	return choice;
+}
+/** Maps Claude Code wire names without trusting every direct/custom descriptor. */
+function resolveOriginalAnthropicToolName(name, projection) {
+	return projection?.tools.find((tool) => tool.wireName === name)?.originalName ?? name;
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-usage.ts
+function readAnthropicUsageTokenCount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function readAnthropicPromptUsageSnapshot(usage) {
+	const input = readAnthropicUsageTokenCount(usage.input_tokens);
+	const cacheRead = usage.cache_read_input_tokens == null ? 0 : readAnthropicUsageTokenCount(usage.cache_read_input_tokens);
+	const cacheWrite = usage.cache_creation_input_tokens == null ? 0 : readAnthropicUsageTokenCount(usage.cache_creation_input_tokens);
+	if (input === void 0 || cacheRead === void 0 || cacheWrite === void 0) return;
+	return {
+		input,
+		cacheRead,
+		cacheWrite
+	};
+}
+function readLastAnthropicIterationUsage(usage) {
+	if (usage.iterations == null) return { state: "absent" };
+	if (!Array.isArray(usage.iterations) || usage.iterations.length === 0) return { state: "invalid" };
+	const iteration = usage.iterations.at(-1);
+	if (!iteration || typeof iteration !== "object" || Array.isArray(iteration)) return { state: "invalid" };
+	const record = iteration;
+	const input = readAnthropicUsageTokenCount(record.input_tokens);
+	const cacheRead = readAnthropicUsageTokenCount(record.cache_read_input_tokens);
+	const cacheWrite = readAnthropicUsageTokenCount(record.cache_creation_input_tokens);
+	const outputTokens = readAnthropicUsageTokenCount(record.output_tokens);
+	if (input === void 0 || cacheRead === void 0 || cacheWrite === void 0 || outputTokens === void 0) return { state: "invalid" };
+	const contextPromptTokens = input + cacheRead + cacheWrite;
+	return {
+		state: "valid",
+		usage: {
+			contextPromptTokens,
+			totalTokens: contextPromptTokens + outputTokens
+		}
+	};
+}
+//#endregion
 //#region packages/ai/src/providers/anthropic.ts
 var anthropic_exports = /* @__PURE__ */ __exportAll({
 	streamAnthropic: () => streamAnthropic,
@@ -62,16 +370,16 @@ const toClaudeCodeName = (name) => ccToolLookup.get(name.toLowerCase()) ?? name;
 /**
 * Convert content blocks to Anthropic API format
 */
-async function convertContentBlocks(content, isError, imageBudget) {
+function convertContentBlocks(content, isError) {
 	const text = extractToolResultText(content);
 	const mediaPlaceholder = describeToolResultMediaPlaceholder(content);
-	if (!content.some(isImageWithMediaPayload)) {
+	if (!(Array.isArray(content) && content.some((item) => item && typeof item === "object" && item.type === "image"))) {
 		const sanitized = sanitizeSurrogates(text);
 		return sanitized.trim().length > 0 ? sanitized : mediaPlaceholder ?? (isError ? EMPTY_ERROR_TOOL_RESULT_TEXT : "");
 	}
 	const blocks = [];
 	let hasTextBlock = false;
-	for (const block of content) {
+	for (const block of Array.isArray(content) ? content : []) {
 		if (!block || typeof block !== "object") continue;
 		const record = block;
 		const blockText = extractToolResultBlockText(block);
@@ -82,19 +390,13 @@ async function convertContentBlocks(content, isError, imageBudget) {
 			});
 			hasTextBlock = true;
 		}
-		if (!isImageWithMediaPayload(record)) continue;
-		const [normalizedImage] = await normalizeAnthropicInlineContent([{
-			type: "image",
-			data: typeof record.data === "string" ? record.data : "",
-			mimeType: typeof record.mimeType === "string" ? record.mimeType : "image/jpeg"
-		}], imageBudget);
-		if (normalizedImage?.type !== "image") continue;
+		if (record.type !== "image") continue;
 		blocks.push({
 			type: "image",
 			source: {
 				type: "base64",
-				media_type: resolveAnthropicImageMediaType(normalizedImage.mimeType),
-				data: normalizedImage.data
+				media_type: typeof record.mimeType === "string" ? record.mimeType : "image/jpeg",
+				data: typeof record.data === "string" ? record.data : ""
 			}
 		});
 	}
@@ -114,8 +416,7 @@ function getAnthropicCompat(model) {
 		supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? !isFireworks,
 		supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? !isFireworks,
 		sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? (isFireworks || isCloudflareAiGatewayAnthropic),
-		supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? !isFireworks,
-		allowEmptySignature: model.compat?.allowEmptySignature ?? false
+		supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? !isFireworks
 	};
 }
 function mergeHeaders(...headerSources) {
@@ -131,11 +432,93 @@ const ANTHROPIC_MESSAGE_EVENTS = /* @__PURE__ */ new Set([
 	"content_block_delta",
 	"content_block_stop"
 ]);
-async function* iterateAnthropicEvents(response, requireMessageStop = false) {
+function flushSseEvent(state) {
+	if (!state.event && state.data.length === 0) return null;
+	const event = {
+		event: state.event,
+		data: state.data.join("\n"),
+		raw: [...state.raw]
+	};
+	state.event = null;
+	state.data = [];
+	state.raw = [];
+	return event;
+}
+function decodeSseLine(line, state) {
+	if (line === "") return flushSseEvent(state);
+	state.raw.push(line);
+	if (line.startsWith(":")) return null;
+	const delimiterIndex = line.indexOf(":");
+	const fieldName = delimiterIndex === -1 ? line : line.slice(0, delimiterIndex);
+	let value = delimiterIndex === -1 ? "" : line.slice(delimiterIndex + 1);
+	if (value.startsWith(" ")) value = value.slice(1);
+	if (fieldName === "event") state.event = value;
+	else if (fieldName === "data") state.data.push(value);
+	return null;
+}
+function nextLineBreakIndex(text) {
+	const carriageReturnIndex = text.indexOf("\r");
+	const newlineIndex = text.indexOf("\n");
+	if (carriageReturnIndex === -1) return newlineIndex;
+	if (newlineIndex === -1) return carriageReturnIndex;
+	return Math.min(carriageReturnIndex, newlineIndex);
+}
+function consumeLine(text) {
+	const lineBreakIndex = nextLineBreakIndex(text);
+	if (lineBreakIndex === -1) return null;
+	let nextIndex = lineBreakIndex + 1;
+	if (text[lineBreakIndex] === "\r" && text[nextIndex] === "\n") nextIndex += 1;
+	return {
+		line: text.slice(0, lineBreakIndex),
+		rest: text.slice(nextIndex)
+	};
+}
+async function* iterateSseMessages(body, signal) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const state = {
+		event: null,
+		data: [],
+		raw: []
+	};
+	let buffer = "";
+	try {
+		while (true) {
+			if (signal?.aborted) throw new Error("Request was aborted");
+			const { value, done } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			let consumed = consumeLine(buffer);
+			while (consumed) {
+				buffer = consumed.rest;
+				const event = decodeSseLine(consumed.line, state);
+				if (event) yield event;
+				consumed = consumeLine(buffer);
+			}
+		}
+		buffer += decoder.decode();
+		let consumed = consumeLine(buffer);
+		while (consumed) {
+			buffer = consumed.rest;
+			const event = decodeSseLine(consumed.line, state);
+			if (event) yield event;
+			consumed = consumeLine(buffer);
+		}
+		if (buffer.length > 0) {
+			const event = decodeSseLine(buffer, state);
+			if (event) yield event;
+		}
+		const trailingEvent = flushSseEvent(state);
+		if (trailingEvent) yield trailingEvent;
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function* iterateAnthropicEvents(response, signal, requireMessageStop = false) {
 	if (!response.body) throw new Error("Attempted to iterate over an Anthropic response with no body");
 	let sawMessageStart = false;
 	let sawMessageEnd = false;
-	for await (const sse of Stream.rawEvents(response)) {
+	for await (const sse of iterateSseMessages(response.body, signal)) {
 		if (sse.event === "error") throw new Error(sse.data);
 		if (!ANTHROPIC_MESSAGE_EVENTS.has(sse.event ?? "")) continue;
 		try {
@@ -205,7 +588,7 @@ const streamAnthropic = (model, context, options) => {
 				isOAuth = created.isOAuthToken;
 				serverSideFallback = created.serverSideFallback;
 			}
-			const builtParams = await buildParams(model, requestContext, isOAuth, requestOptions, serverSideFallback);
+			const builtParams = buildParams(model, requestContext, isOAuth, requestOptions, serverSideFallback);
 			let params = builtParams.params;
 			const toolProjection = builtParams.toolProjection;
 			const nextParams = await requestOptions?.onPayload?.(params, model);
@@ -214,7 +597,7 @@ const streamAnthropic = (model, context, options) => {
 			const sdkRequestOptions = {
 				...requestOptions?.signal ? { signal: requestOptions.signal } : {},
 				...requestOptions?.timeoutMs !== void 0 ? { timeout: requestOptions.timeoutMs } : {},
-				maxRetries: requestOptions?.maxRetries ?? 0
+				...requestOptions?.maxRetries !== void 0 ? { maxRetries: requestOptions.maxRetries } : {}
 			};
 			const response = await client.messages.create({
 				...params,
@@ -226,7 +609,7 @@ const streamAnthropic = (model, context, options) => {
 			}, model);
 			const blocks = output.content;
 			const blockIndexes = /* @__PURE__ */ new Map();
-			for await (const event of iterateAnthropicEvents(response, refusalBuffer !== void 0)) if (event.type === "message_start") {
+			for await (const event of iterateAnthropicEvents(response, requestOptions?.signal, refusalBuffer !== void 0)) if (event.type === "message_start") {
 				output.responseId = event.message.id;
 				output.responseModel = event.message.model;
 				const promptUsage = readAnthropicPromptUsageSnapshot(event.message.usage);
@@ -240,8 +623,6 @@ const streamAnthropic = (model, context, options) => {
 				if (cacheReadTokens !== void 0) output.usage.cacheRead = cacheReadTokens;
 				const cacheWriteTokens = event.message.usage.cache_creation_input_tokens == null ? 0 : readAnthropicUsageTokenCount(event.message.usage.cache_creation_input_tokens);
 				if (cacheWriteTokens !== void 0) output.usage.cacheWrite = cacheWriteTokens;
-				const cacheWriteUsage = readAnthropicCacheWriteUsage(event.message.usage);
-				if (cacheWriteUsage.cacheWrite1h !== void 0) output.usage.cacheWrite1h = cacheWriteUsage.cacheWrite1h;
 				output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
 				if (messageStartPromptUsage && outputTokens !== void 0) output.usage.contextUsage = {
 					state: "available",
@@ -265,18 +646,15 @@ const streamAnthropic = (model, context, options) => {
 					});
 					costModel = {
 						...model,
-						cost: resolveAnthropicFallbackServingModelCost({
-							requestedModelId: model.id,
-							servingModelId: fallbackBoundary.toModel,
-							requestedCost: model.cost
-						})
+						cost: CLAUDE_FABLE_5_FALLBACK_MODEL_COST
 					};
 					calculateCost(costModel, output.usage);
 					eventSink.push({
 						type: "start",
 						partial: output
 					});
-					for (const [i, block] of blocks.entries()) {
+					for (let i = 0; i < blocks.length; i += 1) {
+						const block = blocks[i];
 						if (block.type !== "text") continue;
 						delete block.index;
 						eventSink.push({
@@ -434,37 +812,33 @@ const streamAnthropic = (model, context, options) => {
 			} else if (event.type === "message_delta") {
 				if (event.delta.stop_reason) if (event.delta.stop_reason === "refusal") applyAnthropicRefusal(output, event.delta.stop_details, model.provider);
 				else output.stopReason = mapStopReason(event.delta.stop_reason);
-				if (event.usage) {
-					const inputTokens = readAnthropicUsageTokenCount(event.usage.input_tokens);
-					if (inputTokens !== void 0) output.usage.input = inputTokens;
-					const outputTokens = readAnthropicUsageTokenCount(event.usage.output_tokens);
-					if (outputTokens !== void 0) output.usage.output = outputTokens;
-					const cacheReadTokens = readAnthropicUsageTokenCount(event.usage.cache_read_input_tokens);
-					if (cacheReadTokens !== void 0) output.usage.cacheRead = cacheReadTokens;
-					const cacheWriteTokens = readAnthropicUsageTokenCount(event.usage.cache_creation_input_tokens);
-					if (cacheWriteTokens !== void 0) output.usage.cacheWrite = cacheWriteTokens;
-					const cacheWriteUsage = readAnthropicCacheWriteUsage(event.usage);
-					if (cacheWriteUsage.cacheWrite1h !== void 0) output.usage.cacheWrite1h = cacheWriteUsage.cacheWrite1h;
-					output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-					const iterationUsage = readLastAnthropicIterationUsage(event.usage);
-					if (iterationUsage.state === "valid") output.usage.contextUsage = {
+				const inputTokens = readAnthropicUsageTokenCount(event.usage.input_tokens);
+				if (inputTokens !== void 0) output.usage.input = inputTokens;
+				const outputTokens = readAnthropicUsageTokenCount(event.usage.output_tokens);
+				if (outputTokens !== void 0) output.usage.output = outputTokens;
+				const cacheReadTokens = readAnthropicUsageTokenCount(event.usage.cache_read_input_tokens);
+				if (cacheReadTokens !== void 0) output.usage.cacheRead = cacheReadTokens;
+				const cacheWriteTokens = readAnthropicUsageTokenCount(event.usage.cache_creation_input_tokens);
+				if (cacheWriteTokens !== void 0) output.usage.cacheWrite = cacheWriteTokens;
+				output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+				const iterationUsage = readLastAnthropicIterationUsage(event.usage);
+				if (iterationUsage.state === "valid") output.usage.contextUsage = {
+					state: "available",
+					promptTokens: iterationUsage.usage.contextPromptTokens,
+					totalTokens: iterationUsage.usage.totalTokens
+				};
+				else if (iterationUsage.state === "invalid") output.usage.contextUsage = { state: "unavailable" };
+				else if (outputTokens !== void 0 && (messageStartPromptUsage !== void 0 || inputTokens !== void 0 && cacheReadTokens !== void 0 && cacheWriteTokens !== void 0)) {
+					const promptTokens = output.usage.input + output.usage.cacheRead + output.usage.cacheWrite;
+					output.usage.contextUsage = {
 						state: "available",
-						promptTokens: iterationUsage.usage.contextPromptTokens,
-						totalTokens: iterationUsage.usage.totalTokens
+						promptTokens,
+						totalTokens: promptTokens + output.usage.output
 					};
-					else if (iterationUsage.state === "invalid") output.usage.contextUsage = { state: "unavailable" };
-					else if (outputTokens !== void 0 && (messageStartPromptUsage !== void 0 || inputTokens !== void 0 && cacheReadTokens !== void 0 && cacheWriteTokens !== void 0)) {
-						const promptTokens = output.usage.input + output.usage.cacheRead + output.usage.cacheWrite;
-						output.usage.contextUsage = {
-							state: "available",
-							promptTokens,
-							totalTokens: promptTokens + output.usage.output
-						};
-					} else output.usage.contextUsage = { state: "unavailable" };
-				}
+				} else output.usage.contextUsage = { state: "unavailable" };
 				calculateCost(costModel, output.usage);
 			}
-			if (requestOptions?.signal?.aborted) throw transportAbortError(requestOptions.signal);
+			if (requestOptions?.signal?.aborted) throw new Error("Request was aborted");
 			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
 			refusalBuffer?.flush();
 			stream.push({
@@ -483,7 +857,7 @@ const streamAnthropic = (model, context, options) => {
 				output.content = [];
 			}
 			output.stopReason = requestOptions?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = formatProviderError(error);
+			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
 			stream.push({
 				type: "error",
 				reason: output.stopReason,
@@ -550,7 +924,6 @@ const streamSimpleAnthropic = (model, context, options) => {
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 	const base = {
 		...buildBaseOptions(model, options, apiKey),
-		maxTokens: clampMaxTokensToModel(model, options?.maxTokens ?? model.maxTokens),
 		toolChoice: options?.toolChoice
 	};
 	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
@@ -559,7 +932,7 @@ const streamSimpleAnthropic = (model, context, options) => {
 		thinkingEnabled: false
 	});
 	const reasoning = options?.reasoning === "off" ? mandatoryAdaptiveThinking ? "low" : "high" : options?.reasoning;
-	if (resolveClaudeOpus5ModelIdentity(model) || resolveClaudeSonnet5ModelIdentity(model)) return streamAnthropic(model, context, {
+	if (resolveClaudeSonnet5ModelIdentity(model) || resolveClaudeOpus5ModelIdentity(model)) return streamAnthropic(model, context, {
 		...base,
 		thinkingEnabled: true,
 		effort: mapThinkingLevelToEffort(model, reasoning ?? "high")
@@ -578,11 +951,10 @@ const streamSimpleAnthropic = (model, context, options) => {
 		});
 	}
 	const adjusted = adjustMaxTokensForThinking(base.maxTokens, model.maxTokens, reasoning, options?.thinkingBudgets);
-	const thinkingEnabled = adjusted.thinkingBudget >= ANTHROPIC_MIN_THINKING_BUDGET_TOKENS;
-	const maxTokens = thinkingEnabled ? adjusted.maxTokens : clampMaxTokensToModel(model, options?.maxTokens ?? model.maxTokens);
+	const thinkingEnabled = adjusted.thinkingBudget >= 1024;
 	return streamAnthropic(model, context, {
 		...base,
-		maxTokens,
+		maxTokens: adjusted.maxTokens,
 		thinkingEnabled,
 		thinkingBudgetTokens: thinkingEnabled ? adjusted.thinkingBudget : void 0
 	});
@@ -604,7 +976,7 @@ function isAnthropicPublicEndpoint(baseUrl) {
 * identity) requests are excluded until the beta is verified there.
 */
 function supportsAnthropicServerSideFallback(model) {
-	if (!usesClaudeFable5MessagesContract(model) && resolveClaudeOpus5ModelIdentity(model) === void 0 || model.provider !== "anthropic") return false;
+	if (!usesClaudeFable5MessagesContract(model) || model.provider !== "anthropic") return false;
 	return isAnthropicPublicEndpoint(model.baseUrl);
 }
 function createClient(model, apiKey, thinkingEnabled, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, dynamicHeaders, sessionId) {
@@ -708,13 +1080,13 @@ function createClient(model, apiKey, thinkingEnabled, interleavedThinking, useFi
 		serverSideFallback
 	};
 }
-async function buildParams(model, context, isOAuthTokenResult, options, serverSideFallback = false) {
+function buildParams(model, context, isOAuthTokenResult, options, serverSideFallback = false) {
 	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
 	const replayThinkingEnabled = mandatoryAdaptiveThinking || options?.thinkingEnabled === true;
 	const { cacheControl } = getCacheControl(model, options?.cacheRetention);
 	const system = buildAnthropicSystemBlocks(context.systemPrompt, isOAuthTokenResult, cacheControl);
-	const compat = getAnthropicCompat(model);
-	const convertedTools = context.tools ? convertTools(context.tools, isOAuthTokenResult, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : void 0) : void 0;
+	const compat = context.tools ? getAnthropicCompat(model) : void 0;
+	const convertedTools = context.tools && compat ? convertTools(context.tools, isOAuthTokenResult, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : void 0) : void 0;
 	const tools = convertedTools?.tools;
 	const toolProjection = convertedTools?.projection;
 	const systemCacheControlCount = countNativeCacheControlMarkers(system);
@@ -722,12 +1094,12 @@ async function buildParams(model, context, isOAuthTokenResult, options, serverSi
 	const messageCacheControlLimit = Math.max(0, ANTHROPIC_CACHE_CONTROL_LIMIT - systemCacheControlCount - toolCacheControlCount);
 	const params = {
 		model: model.id,
-		messages: await convertMessages(context.messages, model, isOAuthTokenResult, cacheControl, messageCacheControlLimit, replayThinkingEnabled, compat.allowEmptySignature),
+		messages: convertMessages(context.messages, model, isOAuthTokenResult, cacheControl, messageCacheControlLimit, replayThinkingEnabled),
 		max_tokens: options?.maxTokens ?? model.maxTokens,
 		stream: true
 	};
 	if (system) params.system = system;
-	if (serverSideFallback) params.fallbacks = ANTHROPIC_SERVER_SIDE_FALLBACKS;
+	if (serverSideFallback) params.fallbacks = buildAnthropicServerSideFallbacks();
 	if (options?.temperature !== void 0 && !options?.thinkingEnabled && !supportsNativeXhighEffort(model)) params.temperature = options.temperature;
 	if (options?.stop !== void 0 && options.stop.length > 0) params.stop_sequences = options.stop;
 	if (tools && tools.length > 0) params.tools = tools;
@@ -765,15 +1137,13 @@ async function buildParams(model, context, isOAuthTokenResult, options, serverSi
 function normalizeToolCallId(id) {
 	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-async function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messageCacheControlLimit = 4, replayThinkingEnabled = true, allowEmptySignature = false) {
+function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messageCacheControlLimit = 4, replayThinkingEnabled = true) {
 	const params = [];
-	const imageBudget = createAnthropicInlineImageBudget();
 	const cacheBreakpointOptOutParamIndexes = /* @__PURE__ */ new Set();
 	const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
 	const activeToolTurnAssistantIndex = replayThinkingEnabled ? -1 : findActiveAnthropicToolTurnAssistantIndex(transformedMessages);
 	for (let i = 0; i < transformedMessages.length; i++) {
 		const msg = transformedMessages[i];
-		if (!msg) continue;
 		if (msg.role === "user") {
 			const isRuntimeContextCarrier = msg.runtimeContextCarrier === true;
 			if (typeof msg.content === "string") {
@@ -785,7 +1155,7 @@ async function convertMessages(messages, model, isOAuthTokenValue, cacheControl,
 					});
 				}
 			} else {
-				const filteredBlocks = (await normalizeAnthropicInlineContent(msg.content, imageBudget)).map((item) => {
+				const filteredBlocks = msg.content.map((item) => {
 					if (item.type === "text") return {
 						type: "text",
 						text: sanitizeSurrogates(item.text)
@@ -794,7 +1164,7 @@ async function convertMessages(messages, model, isOAuthTokenValue, cacheControl,
 						type: "image",
 						source: {
 							type: "base64",
-							media_type: resolveAnthropicImageMediaType(item.mimeType),
+							media_type: item.mimeType,
 							data: item.data
 						}
 					};
@@ -824,7 +1194,6 @@ async function convertMessages(messages, model, isOAuthTokenValue, cacheControl,
 					continue;
 				}
 				if (block.redacted) {
-					if (!block.thinkingSignature) throw new Error("redacted thinking block is missing its opaque signature");
 					blocks.push({
 						type: "redacted_thinking",
 						data: block.thinkingSignature
@@ -834,7 +1203,7 @@ async function convertMessages(messages, model, isOAuthTokenValue, cacheControl,
 				const thinkingSignature = block.thinkingSignature?.trim();
 				const hasNativeThinkingSignature = Boolean(thinkingSignature) && thinkingSignature !== "reasoning_content";
 				if (block.thinking.trim().length === 0 && !hasNativeThinkingSignature) continue;
-				if (!thinkingSignature && !allowEmptySignature) blocks.push({
+				if (!thinkingSignature) blocks.push({
 					type: "text",
 					text: sanitizeSurrogates(block.thinking)
 				});
@@ -843,7 +1212,7 @@ async function convertMessages(messages, model, isOAuthTokenValue, cacheControl,
 					blocks.push({
 						type: "thinking",
 						thinking: block.thinking,
-						signature: thinkingSignature ?? ""
+						signature: thinkingSignature
 					});
 				}
 			} else if (block.type === "toolCall") blocks.push({
@@ -866,17 +1235,16 @@ async function convertMessages(messages, model, isOAuthTokenValue, cacheControl,
 			toolResults.push({
 				type: "tool_result",
 				tool_use_id: msg.toolCallId,
-				content: await convertContentBlocks(msg.content, msg.isError, imageBudget),
+				content: convertContentBlocks(msg.content, msg.isError),
 				is_error: msg.isError
 			});
 			let j = i + 1;
-			while (j < transformedMessages.length) {
-				const nextMsg = transformedMessages.at(j);
-				if (nextMsg?.role !== "toolResult") break;
+			while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
+				const nextMsg = transformedMessages[j];
 				toolResults.push({
 					type: "tool_result",
 					tool_use_id: nextMsg.toolCallId,
-					content: await convertContentBlocks(nextMsg.content, nextMsg.isError, imageBudget),
+					content: convertContentBlocks(nextMsg.content, nextMsg.isError),
 					is_error: nextMsg.isError
 				});
 				j++;
@@ -892,11 +1260,10 @@ async function convertMessages(messages, model, isOAuthTokenValue, cacheControl,
 		let fallbackToolResult;
 		for (let i = params.length - 1; i >= 0; i--) {
 			const message = params[i];
-			if (!message || message.role !== "user" || cacheBreakpointOptOutParamIndexes.has(i)) continue;
+			if (message.role !== "user" || cacheBreakpointOptOutParamIndexes.has(i)) continue;
 			if (Array.isArray(message.content)) {
 				for (let j = message.content.length - 1; j >= 0; j--) {
 					const block = message.content[j];
-					if (!block) continue;
 					if (block.type === "text" || block.type === "image") {
 						if (fallbackToolResult && messageCacheControlLimit === 1) {
 							applyContentBlockCacheControl(fallbackToolResult, cacheControl);
@@ -1013,4 +1380,4 @@ function mapStopReason(reason) {
 	}
 }
 //#endregion
-export { streamAnthropic as n, streamSimpleAnthropic as r, anthropic_exports as t };
+export { readAnthropicFallbackBoundary as _, readAnthropicUsageTokenCount as a, usesFoundryBearerAuth as b, reconcileAnthropicToolChoice as c, findActiveAnthropicToolTurnAssistantIndex as d, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA as f, buildAnthropicServerSideFallbacks as g, applyAnthropicFallbackBoundary as h, readAnthropicPromptUsageSnapshot as i, resolveOriginalAnthropicToolName as l, CLAUDE_FABLE_5_FALLBACK_MODEL_COST as m, streamAnthropic as n, readLastAnthropicIterationUsage as o, CLAUDE_FABLE_5_FALLBACK_MODEL as p, streamSimpleAnthropic as r, projectAnthropicTools as s, anthropic_exports as t, ANTHROPIC_OMITTED_REASONING_TEXT as u, applyAnthropicRefusal as v, omitFoundryBearerCredentialHeaders as y };