@openclaw/ai 2026.9.5 → 2026.9.7

package/dist/simple-options-CGAkCwtM.mjs

@@ -0,0 +1,349 @@
+import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
+import { O as hasMediaPayload, n as getAiTransportHost } from "./host-CHi3X87F.mjs";
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import { o as truncateUtf16Safe } from "./provider-error-CwT_j2v0.mjs";
+import { i as copyProviderAcceptanceObserver, j as sanitizeSurrogates } from "./transport-stream-shared-Dh5qKJ8e.mjs";
+//#region packages/ai/src/utils/prompt-cache-stability.ts
+/**
+* Prompt-cache normalization helpers. They keep generated prompt sections
+* deterministic across platform newlines, trailing whitespace, and input
+* ordering.
+*/
+/** Canonicalizes provider tool order without relying on host locale settings. */
+function sortPromptCacheToolsByName(tools) {
+	const compareText = (left, right) => {
+		const leftText = left ?? "";
+		const rightText = right ?? "";
+		return leftText < rightText ? -1 : leftText > rightText ? 1 : 0;
+	};
+	return tools.toSorted((left, right) => compareText(left.wireName ?? left.name, right.wireName ?? right.name) || compareText(left.description, right.description));
+}
+/** Normalize structured prompt text before hashing or snapshot comparison. */
+function normalizeStructuredPromptSection(text) {
+	return sanitizeSurrogates(text).replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "").trim();
+}
+/** Normalize, de-dupe, and sort capability ids for stable prompt payloads. */
+function normalizePromptCapabilityIds(capabilities) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const capability of capabilities) {
+		const value = normalizeLowercaseStringOrEmpty(normalizeStructuredPromptSection(capability));
+		if (value) seen.add(value);
+	}
+	return [...seen].toSorted((left, right) => left.localeCompare(right));
+}
+//#endregion
+//#region packages/ai/src/utils/system-prompt-cache-boundary.ts
+/**
+* System prompt cache-boundary helpers.
+*
+* Keeps stable prompt prefixes separate from dynamic runtime additions for provider prompt caching.
+*/
+const SYSTEM_PROMPT_CACHE_BOUNDARY = "\n<!-- OPENCLAW_CACHE_BOUNDARY -->\n";
+/** Producer-delimited Runtime facts; instructions must remain outside this region. */
+const SYSTEM_PROMPT_RELOCATABLE_BOUNDARY = "\n<!-- OPENCLAW-RELOCATABLE-BOUNDARY -->\n";
+const SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END = "\n<!-- /OPENCLAW-RELOCATABLE-BOUNDARY -->";
+function stripSystemPromptCacheBoundary(text) {
+	return stripSystemPromptRelocatableBoundary(text.replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY, "\n").replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY.trim(), ""));
+}
+/** Reject ambiguous markers from workspace or hook text instead of moving instructions. */
+function splitSystemPromptRelocatableBoundary(text) {
+	const opening = SYSTEM_PROMPT_RELOCATABLE_BOUNDARY.trim();
+	const closing = SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END.trim();
+	const start = text.indexOf(opening);
+	const end = text.indexOf(closing);
+	if (start === -1 || end < start || text.includes(opening, start + 38) || text.includes(closing, end + 39)) return;
+	return {
+		remainingPrompt: [text.slice(0, start).trimEnd(), text.slice(end + 39).trimStart()].filter(Boolean).join("\n"),
+		relocatable: text.slice(start + 38, end).trim()
+	};
+}
+function ensureSystemPromptCacheBoundary(systemPrompt) {
+	if (systemPrompt.trim().length === 0) return systemPrompt;
+	return systemPrompt.includes("\n<!-- OPENCLAW_CACHE_BOUNDARY -->\n") ? systemPrompt : `${systemPrompt}${SYSTEM_PROMPT_CACHE_BOUNDARY}`;
+}
+function splitSystemPromptCacheBoundary(text) {
+	const boundaryIndex = text.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+	if (boundaryIndex === -1) return;
+	return {
+		stablePrefix: text.slice(0, boundaryIndex).trimEnd(),
+		dynamicSuffix: text.slice(boundaryIndex + 34).trimStart()
+	};
+}
+/** Keep explicit cache breakpoints while removing relocation metadata. */
+function stripSystemPromptRelocatableBoundary(text) {
+	return text.replaceAll(SYSTEM_PROMPT_RELOCATABLE_BOUNDARY, "\n").replaceAll(SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END, "").replaceAll(SYSTEM_PROMPT_RELOCATABLE_BOUNDARY.trim(), "").replaceAll(SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END.trim(), "");
+}
+function prependSystemPromptAdditionAfterCacheBoundary(params) {
+	const systemPromptAddition = typeof params.systemPromptAddition === "string" ? normalizeStructuredPromptSection(params.systemPromptAddition) : "";
+	if (!systemPromptAddition) return params.systemPrompt;
+	if (params.systemPrompt.trim().length === 0) return systemPromptAddition;
+	const split = splitSystemPromptCacheBoundary(params.systemPrompt);
+	if (!split) return `${systemPromptAddition}\n\n${params.systemPrompt}`;
+	const dynamicSuffix = split.dynamicSuffix ? normalizeStructuredPromptSection(split.dynamicSuffix) : "";
+	if (!dynamicSuffix) return `${split.stablePrefix}${SYSTEM_PROMPT_CACHE_BOUNDARY}${systemPromptAddition}`;
+	return `${split.stablePrefix}${SYSTEM_PROMPT_CACHE_BOUNDARY}${systemPromptAddition}\n\n${dynamicSuffix}`;
+}
+//#endregion
+//#region packages/ai/src/providers/tool-result-text.ts
+const STRUCTURED_TOOL_RESULT_MAX_CHARS = 8e3;
+const IMAGE_TOOL_RESULT_TYPES = /* @__PURE__ */ new Set([
+	"image",
+	"image_url",
+	"input_image"
+]);
+const AUDIO_TOOL_RESULT_TYPES = /* @__PURE__ */ new Set([
+	"audio",
+	"input_audio",
+	"output_audio"
+]);
+const MEDIA_ONLY_TOOL_RESULT_TYPES = /* @__PURE__ */ new Set([...IMAGE_TOOL_RESULT_TYPES, ...AUDIO_TOOL_RESULT_TYPES]);
+const INLINE_DATA_URI_PATTERN = /(^|[^A-Za-z0-9_])data:([a-z][a-z0-9.+-]*\/[a-z0-9.+-]+(?:;[a-z0-9.+-]+=[^,;"'\s]+|;base64)*,[^\s"'<>)]+)/gi;
+const MIME_KEY_CANDIDATES = [
+	"mimeType",
+	"mime_type",
+	"mediaType",
+	"media_type",
+	"contentType",
+	"content_type"
+];
+const TEXTUAL_MIME_PATTERN = /^(?:text\/|application\/(?:json|ld\+json|x-ndjson|xml|javascript|x-www-form-urlencoded)|[^/]+\/[^+]+\+(?:json|xml)$)/i;
+const OPAQUE_OR_BINARY_FIELD_RE = /^(?:blob|buffer|bytes|encrypted_content|encrypted_stdout)$/i;
+function readMimeType(value) {
+	if (!isRecord(value)) return;
+	for (const key of MIME_KEY_CANDIDATES) {
+		const mimeType = value[key];
+		if (typeof mimeType === "string" && mimeType.trim().length > 0) return mimeType;
+	}
+}
+function isBinaryMimeType(mimeType) {
+	const normalized = mimeType.split(";", 1)[0]?.trim().toLowerCase();
+	return normalized ? !TEXTUAL_MIME_PATTERN.test(normalized) : false;
+}
+function describeOmittedValue(value, label) {
+	const length = typeof value === "string" ? value.length : JSON.stringify(value)?.length;
+	return length ? `[${label} omitted: ${length} chars]` : `[${label} omitted]`;
+}
+function redactInlineDataUris(value) {
+	return value.replace(INLINE_DATA_URI_PATTERN, (_match, prefix, uri) => `${prefix}[inline data URI: ${uri.length} chars]`);
+}
+function stringifyStructuredBlock(block) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		const host = getAiTransportHost();
+		const redactedBlock = host.redactModelVisibleSecrets({ structuredToolResult: block }).structuredToolResult;
+		const serialized = JSON.stringify(redactedBlock, function structuredToolResultReplacer(key, value) {
+			if (OPAQUE_OR_BINARY_FIELD_RE.test(key)) return `[omitted ${key}]`;
+			if (key === "data") {
+				const mimeType = readMimeType(this);
+				if (mimeType && isBinaryMimeType(mimeType)) return describeOmittedValue(value, "binary data");
+			}
+			if (typeof value === "bigint") return value.toString();
+			if (typeof value === "string") return redactInlineDataUris(host.redactModelVisibleSecrets(value));
+			if (typeof value === "function" || typeof value === "symbol" || value === void 0) return;
+			if (!value || typeof value !== "object") return value;
+			if (seen.has(value)) return "[Circular]";
+			seen.add(value);
+			return value;
+		});
+		if (!serialized || serialized === "{}") return;
+		return serialized;
+	} catch {
+		return;
+	}
+}
+function truncateStructuredToolText(text) {
+	if (text.length <= STRUCTURED_TOOL_RESULT_MAX_CHARS) return text;
+	return `${truncateUtf16Safe(text, STRUCTURED_TOOL_RESULT_MAX_CHARS)}\n…(truncated)…`;
+}
+function classifyToolResultMedia(blocks) {
+	let hasImage = false;
+	let hasAudio = false;
+	for (const block of blocks) {
+		if (!hasMediaPayload(block) || block.type === "text") continue;
+		const type = typeof block.type === "string" ? block.type : void 0;
+		const mimeType = readMimeType(block)?.toLowerCase();
+		hasImage ||= Boolean(type && IMAGE_TOOL_RESULT_TYPES.has(type) || mimeType?.startsWith("image/"));
+		hasAudio ||= Boolean(type && AUDIO_TOOL_RESULT_TYPES.has(type) || mimeType?.startsWith("audio/"));
+	}
+	return {
+		hasImage,
+		hasAudio
+	};
+}
+function describeToolResultMediaPlaceholder(blocks) {
+	const { hasImage, hasAudio } = classifyToolResultMedia(blocks);
+	if (hasImage && hasAudio) return "(see attached media)";
+	if (hasAudio) return "(see attached audio)";
+	return hasImage ? "(see attached image)" : void 0;
+}
+function extractToolResultBlockText(block) {
+	if (!block || typeof block !== "object") return;
+	const record = block;
+	if (typeof record.type === "string" && MEDIA_ONLY_TOOL_RESULT_TYPES.has(record.type)) return;
+	if (record.type === "text") {
+		const text = typeof record.text === "string" ? record.text : "";
+		return text ? sanitizeSurrogates(text) : void 0;
+	}
+	const structured = stringifyStructuredBlock(record);
+	return structured ? sanitizeSurrogates(truncateStructuredToolText(structured)) : void 0;
+}
+function extractToolResultText(blocks, options) {
+	const explicitTexts = [];
+	const structuredBlocks = [];
+	for (const block of blocks) {
+		if (!block || typeof block !== "object") continue;
+		if (block.type === "text") {
+			const text = extractToolResultBlockText(block);
+			if (text) explicitTexts.push(text);
+		} else structuredBlocks.push(block);
+	}
+	if (explicitTexts.length > 0 && !options?.includeStructured) return explicitTexts.join("\n");
+	const structuredTexts = [];
+	for (const block of structuredBlocks) {
+		const text = extractToolResultBlockText(block);
+		if (text) structuredTexts.push(text);
+	}
+	if (explicitTexts.length > 0) {
+		if (structuredTexts.length > 0) explicitTexts.push(truncateStructuredToolText(structuredTexts.join("\n")));
+		return explicitTexts.join("\n");
+	}
+	return truncateStructuredToolText(structuredTexts.join("\n"));
+}
+/** Describe media that cannot be represented on the target provider wire. */
+function describeUnsupportedToolResultMedia(blocks, support) {
+	const { hasImage, hasAudio } = classifyToolResultMedia(blocks);
+	const omittedImage = hasImage && !support.images;
+	const omittedAudio = hasAudio && !support.audio;
+	if (omittedImage && omittedAudio) return "[unsupported tool-result media omitted]";
+	if (omittedAudio) return "[unsupported tool-result audio omitted]";
+	return omittedImage ? "[unsupported tool-result image omitted]" : void 0;
+}
+function formatToolResultText(params) {
+	const body = params.text.trim() ? `${params.text}${params.omittedMediaPlaceholder ? `\n${params.omittedMediaPlaceholder}` : ""}` : params.omittedMediaPlaceholder ?? params.mediaPlaceholder ?? "(no tool output)";
+	return `${params.isError ? "[tool error] " : ""}${body}`;
+}
+//#endregion
+//#region packages/ai/src/provider-options.ts
+const CODE_MODE_TOOL_SURFACE_OBSERVER = Symbol("openaiCodeModeToolSurfaceObserver");
+const CODE_MODE_TOOL_SURFACE_COLLECTOR = Symbol("openaiCodeModeToolSurfaceCollector");
+const STRICT_REASONING_TAG_TEXT = Symbol("openaiStrictReasoningTagText");
+function markStrictReasoningTagText(options) {
+	Reflect.set(options, STRICT_REASONING_TAG_TEXT, true);
+}
+function isStrictReasoningTagText(options) {
+	return options ? Reflect.get(options, STRICT_REASONING_TAG_TEXT) === true : false;
+}
+const codeModeToolSurfaceObserver = {
+	set(options, observer, collector) {
+		Reflect.set(options, CODE_MODE_TOOL_SURFACE_OBSERVER, observer);
+		if (collector) Reflect.set(options, CODE_MODE_TOOL_SURFACE_COLLECTOR, collector);
+	},
+	get(options) {
+		if (!options) return;
+		const observer = Reflect.get(options, CODE_MODE_TOOL_SURFACE_OBSERVER);
+		return typeof observer === "function" ? (observation) => observer(observation) : void 0;
+	},
+	getCollector(options) {
+		if (!options) return;
+		const collector = Reflect.get(options, CODE_MODE_TOOL_SURFACE_COLLECTOR);
+		return typeof collector === "function" ? (observation) => collector(observation) : void 0;
+	}
+};
+/** Internal output policy for callers that must not recover ambiguous reasoning as visible text. */
+const reasoningTagTextPolicy = {
+	markStrict: markStrictReasoningTagText,
+	isStrict: isStrictReasoningTagText,
+	copy(source, target) {
+		if (isStrictReasoningTagText(source)) markStrictReasoningTagText(target);
+	}
+};
+//#endregion
+//#region packages/ai/src/transports/model-request-body.ts
+const REQUEST_BODY = Symbol("modelRequestBody");
+/** Call-local state survives option spreads; no payload is cached across requests. */
+function modelRequestBodyState(options, inheritFrom) {
+	let state = Reflect.get(options, REQUEST_BODY) ?? (inheritFrom && Reflect.get(inheritFrom, REQUEST_BODY));
+	if (!state) state = {};
+	Reflect.set(options, REQUEST_BODY, state);
+	return state;
+}
+function serializeModelRequestBody(payload) {
+	const json = JSON.stringify(payload);
+	return {
+		body: new TextEncoder().encode(json),
+		stream: json !== void 0 && JSON.parse(json)?.stream === true
+	};
+}
+const encodedBodyStreams = /* @__PURE__ */ new WeakMap();
+function encodedModelRequestBodyStream(body) {
+	return typeof body === "object" && body !== null ? encodedBodyStreams.get(body) : void 0;
+}
+/** SDK RequestOptions.body overrides encoding while the original params retain stream metadata. */
+function prepareModelRequestBody(options) {
+	const state = options ? modelRequestBodyState(options) : {};
+	state.enabled = true;
+	return async (payload) => {
+		const encoded = state.encode ? await state.encode(payload) : serializeModelRequestBody(payload);
+		state.onBytes?.(encoded.body.byteLength);
+		encodedBodyStreams.set(encoded.body, encoded.stream);
+		return {
+			body: encoded.body,
+			headers: { "content-type": "application/json" }
+		};
+	};
+}
+//#endregion
+//#region packages/ai/src/providers/simple-options.ts
+function buildBaseOptions(model, options, apiKey) {
+	const firstEventOptions = options;
+	const baseOptions = {
+		temperature: options?.temperature,
+		...options?.serviceTier ? { serviceTier: options.serviceTier } : {},
+		maxTokens: options?.maxTokens,
+		responseFormat: options?.responseFormat,
+		stop: options?.stop,
+		signal: options?.signal,
+		apiKey: apiKey || options?.apiKey,
+		transport: options?.transport,
+		cacheRetention: options?.cacheRetention,
+		sessionId: options?.sessionId,
+		promptCacheKey: options?.promptCacheKey,
+		headers: options?.headers,
+		onPayload: options?.onPayload,
+		onResponse: options?.onResponse,
+		timeoutMs: options?.timeoutMs,
+		firstEventTimeoutMs: firstEventOptions?.firstEventTimeoutMs,
+		onFirstEventTimeout: firstEventOptions?.onFirstEventTimeout,
+		maxRetryDelayMs: options?.maxRetryDelayMs,
+		metadata: options?.metadata
+	};
+	reasoningTagTextPolicy.copy(options, baseOptions);
+	modelRequestBodyState(baseOptions, options);
+	return copyProviderAcceptanceObserver(options, baseOptions);
+}
+function clampMaxTokensToModel(model, requestedMaxTokens) {
+	return requestedMaxTokens === void 0 ? void 0 : Math.max(1, Math.min(requestedMaxTokens, model.maxTokens ?? requestedMaxTokens));
+}
+function clampReasoning(effort) {
+	return effort === "xhigh" ? "high" : effort;
+}
+function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+	const budgets = {
+		minimal: 1024,
+		low: 2048,
+		medium: 8192,
+		high: 16384,
+		max: 32768,
+		...customBudgets
+	};
+	const minOutputTokens = 1024;
+	let thinkingBudget = budgets[clampReasoning(reasoningLevel)];
+	const maxTokens = baseMaxTokens === void 0 ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+	if (maxTokens <= thinkingBudget) thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
+	return {
+		maxTokens,
+		thinkingBudget
+	};
+}
+//#endregion
+export { stripSystemPromptCacheBoundary as C, sortPromptCacheToolsByName as D, normalizeStructuredPromptSection as E, splitSystemPromptRelocatableBoundary as S, normalizePromptCapabilityIds as T, SYSTEM_PROMPT_RELOCATABLE_BOUNDARY as _, encodedModelRequestBodyStream as a, prependSystemPromptAdditionAfterCacheBoundary as b, serializeModelRequestBody as c, describeToolResultMediaPlaceholder as d, describeUnsupportedToolResultMedia as f, SYSTEM_PROMPT_CACHE_BOUNDARY as g, formatToolResultText as h, clampReasoning as i, codeModeToolSurfaceObserver as l, extractToolResultText as m, buildBaseOptions as n, modelRequestBodyState as o, extractToolResultBlockText as p, clampMaxTokensToModel as r, prepareModelRequestBody as s, adjustMaxTokensForThinking as t, reasoningTagTextPolicy as u, SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END as v, stripSystemPromptRelocatableBoundary as w, splitSystemPromptCacheBoundary as x, ensureSystemPromptCacheBoundary as y };

package/dist/{src-DeKjbE8I.mjs → src-H4aXcFuX.mjs}

@@ -1,4 +1,5 @@
-import "./validation-Dw7cb6BV.mjs";
+import "./diagnostics-DzrF1h4J.mjs";
+import "./validation-BFZc40Ig.mjs";
 //#region packages/llm-core/src/model-contracts/anthropic.ts
 function normalizeClaudeModelId(modelId) {
 	const normalized = modelId?.trim().toLowerCase() ?? "";
@@ -29,62 +30,88 @@ const CLAUDE_SONNET_5_THINKING_PROFILE = {
 	defaultLevel: "high"
 };
 const CLAUDE_OPUS_5_THINKING_PROFILE = CLAUDE_SONNET_5_THINKING_PROFILE;
+const CLAUDE_OPUS_55_THINKING_PROFILE = CLAUDE_FABLE_5_THINKING_PROFILE;
+const CLAUDE_SONNET_55_THINKING_PROFILE = {
+	levels: [
+		{ id: "off" },
+		{ id: "low" },
+		{ id: "medium" },
+		{ id: "high" },
+		{ id: "xhigh" },
+		{ id: "max" }
+	],
+	defaultLevel: "high"
+};
 /** Resolve the canonical normalized Claude model id for one runtime model ref. */
 function resolveClaudeModelIdentity(ref) {
 	const normalized = normalizeClaudeModelId((typeof ref.params?.canonicalModelId === "string" ? ref.params.canonicalModelId : void 0) ?? ref.id);
 	return /(?:^|[-/])(claude-[^/]+)$/.exec(normalized)?.[1] ?? normalized;
 }
+function matchClaudeModelIdentity(normalized, pattern) {
+	const match = pattern.exec(normalized);
+	return match ? normalized.slice(match.index + (match[0].startsWith("-") ? 1 : 0)) : void 0;
+}
 /** Resolve Claude Fable 5 through direct ids, cloud ids, or deployment metadata. */
 function resolveClaudeFable5ModelIdentity(ref) {
-	const normalized = resolveClaudeModelIdentity(ref);
-	const match = /(?:^|-)claude-fable-5(?=$|[^a-z0-9])/.exec(normalized);
-	if (!match) return;
-	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
+	return matchClaudeModelIdentity(resolveClaudeModelIdentity(ref), /(?:^|-)claude-fable-5(?=$|[^a-z0-9])/);
 }
 /** Resolve Claude Mythos 5 through direct ids, cloud ids, or deployment metadata. */
 function resolveClaudeMythos5ModelIdentity(ref) {
-	const normalized = resolveClaudeModelIdentity(ref);
-	const match = /(?:^|-)claude-mythos-5(?=$|[^a-z0-9])/.exec(normalized);
-	if (!match) return;
-	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
+	return matchClaudeModelIdentity(resolveClaudeModelIdentity(ref), /(?:^|-)claude-mythos-5(?=$|[^a-z0-9])/);
 }
 /**
-* Anthropic binds thinking to the conversation prefix starting with Fable 5.1 and
-* plans to enforce it on later models. Extend only with live replay proof for the
-* new model (Mythos 5.1 is unregistered here and unproven).
+* Opus 5.5, Sonnet 5.5, and Fable 5.1 require append-only runtime context.
+* Extend only with live replay proof (Mythos 5.1 remains unproven).
 */
 function bindsClaudeThinkingPrefix(ref) {
-	return /^claude-fable-5-1(?=$|[^a-z0-9])/.test(resolveClaudeModelIdentity(ref));
+	return resolveClaudeOpus55ModelIdentity(ref) !== void 0 || resolveClaudeSonnet55ModelIdentity(ref) !== void 0 || /^claude-fable-5-1(?=$|[^a-z0-9])/.test(resolveClaudeModelIdentity(ref));
 }
 /** Return whether a Claude model requires adaptive thinking instead of manual budgets. */
 function requiresClaudeMandatoryAdaptiveThinking(ref) {
 	const modelId = resolveClaudeModelIdentity(ref);
-	return resolveClaudeFable5ModelIdentity(ref) !== void 0 || resolveClaudeMythos5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-mythos-preview(?=$|[^a-z0-9])/.test(modelId);
+	return resolveClaudeOpus55ModelIdentity(ref) !== void 0 || resolveClaudeFable5ModelIdentity(ref) !== void 0 || resolveClaudeMythos5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-mythos-preview(?=$|[^a-z0-9])/.test(modelId);
 }
-/** Resolve Claude Sonnet 5 through direct ids, cloud ids, or deployment metadata. */
+/** Resolve Claude Sonnet 5 through aliases, direct ids, cloud ids, or deployment metadata. */
 function resolveClaudeSonnet5ModelIdentity(ref) {
 	const normalized = resolveClaudeModelIdentity(ref);
-	const match = /(?:^|-)claude-sonnet-5(?=$|[^a-z0-9])/.exec(normalized);
-	if (!match) return;
-	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
+	const sonnet55Identity = resolveClaudeSonnet55ModelIdentity(ref);
+	if (sonnet55Identity) return sonnet55Identity;
+	if (normalized === "sonnet-5") return "claude-sonnet-5";
+	return matchClaudeModelIdentity(normalized, /(?:^|-)claude-sonnet-5(?=$|[^a-z0-9])/);
+}
+/** Resolve the Sonnet 5.5 contract without matching other Sonnet 5 generations. */
+function resolveClaudeSonnet55ModelIdentity(ref) {
+	const normalized = resolveClaudeModelIdentity(ref);
+	if (normalized === "sonnet" || normalized === "sonnet-5-5") return "claude-sonnet-5-5";
+	return /^claude-sonnet-5-5(?=$|[^a-z0-9])/.test(normalized) ? normalized : void 0;
+}
+/** Sonnet 5.5 replaces disabled thinking with between-tool progress updates. */
+function requiresClaudeBetweenToolsThinking(ref) {
+	return resolveClaudeSonnet55ModelIdentity(ref) !== void 0;
 }
 /** Resolve Claude Opus 5 through aliases, direct ids, cloud ids, or deployment metadata. */
 function resolveClaudeOpus5ModelIdentity(ref) {
 	const normalized = resolveClaudeModelIdentity(ref);
+	const opus55Identity = resolveClaudeOpus55ModelIdentity(ref);
+	if (opus55Identity) return opus55Identity;
 	if (normalized === "opus" || normalized === "opus-5") return "claude-opus-5";
-	const match = /(?:^|-)claude-opus-5(?=$|[^a-z0-9])/.exec(normalized);
-	if (!match) return;
-	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
+	return matchClaudeModelIdentity(normalized, /(?:^|-)claude-opus-5(?=$|[^a-z0-9])/);
+}
+/** Resolve the Opus 5.5 contract without matching other Opus 5 generations. */
+function resolveClaudeOpus55ModelIdentity(ref) {
+	const normalized = resolveClaudeModelIdentity(ref);
+	if (normalized === "opus" || normalized === "opus-5-5") return "claude-opus-5-5";
+	return /^claude-opus-5-5(?=$|[^a-z0-9])/.test(normalized) ? normalized : void 0;
 }
 /** Return whether a Claude model supports adaptive thinking. */
 function supportsClaudeAdaptiveThinking(ref) {
 	const modelId = resolveClaudeModelIdentity(ref);
-	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-(?:fable-5|mythos-(?:5|preview)|opus-4-(?:6|7|8)|sonnet-(?:5|4-6))(?=$|[^a-z0-9])/.test(modelId);
+	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || resolveClaudeSonnet5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-(?:fable-5|mythos-(?:5|preview)|opus-4-(?:6|7|8)|sonnet-4-6)(?=$|[^a-z0-9])/.test(modelId);
 }
 /** Return whether a Claude model has a native 1M-token context window. */
 function supportsClaude1MContext(ref) {
 	const modelId = resolveClaudeModelIdentity(ref);
-	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-(?:fable-5|mythos-(?:5|preview)|opus-4-(?:6|7|8)|sonnet-(?:5|4-6))(?=$|[^a-z0-9])/.test(modelId);
+	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || resolveClaudeSonnet5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-(?:fable-5|mythos-(?:5|preview)|opus-4-(?:6|7|8)|sonnet-4-6)(?=$|[^a-z0-9])/.test(modelId);
 }
 /** Return whether a Claude model supports Anthropic's native fast mode. */
 function supportsClaudeFastMode(ref) {
@@ -94,12 +121,12 @@ function supportsClaudeFastMode(ref) {
 /** Return whether a Claude model supports native max effort. */
 function supportsClaudeNativeMaxEffort(ref) {
 	const modelId = resolveClaudeModelIdentity(ref);
-	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-(?:fable-5|mythos-5|opus-4-(?:6|7|8)|sonnet-(?:5|4-6))(?=$|[^a-z0-9])/.test(modelId);
+	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || resolveClaudeSonnet5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-(?:fable-5|mythos-5|opus-4-(?:6|7|8)|sonnet-4-6)(?=$|[^a-z0-9])/.test(modelId);
 }
 /** Return whether a Claude model supports native xhigh effort. */
 function supportsClaudeNativeXhighEffort(ref) {
 	const modelId = resolveClaudeModelIdentity(ref);
-	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-(?:fable-5|mythos-5|opus-4-(?:7|8)|sonnet-5)(?=$|[^a-z0-9])/.test(modelId);
+	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || resolveClaudeSonnet5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-(?:fable-5|mythos-5|opus-4-(?:7|8))(?=$|[^a-z0-9])/.test(modelId);
 }
 /** Return whether a Claude model rejects caller-selected sampling parameters. */
 function requiresClaudeDefaultSampling(ref) {
@@ -192,4 +219,4 @@ function calculateUsageCost(usage, pricing) {
 	return cost;
 }
 //#endregion
-export { supportsClaudeAdaptiveThinking as _, CLAUDE_OPUS_5_THINKING_PROFILE as a, supportsClaudeNativeXhighEffort as b, requiresClaudeDefaultSampling as c, resolveClaudeModelIdentity as d, resolveClaudeMythos5ModelIdentity as f, supportsClaude1MContext as g, resolveClaudeSonnet5ModelIdentity as h, CLAUDE_FABLE_5_THINKING_PROFILE as i, requiresClaudeMandatoryAdaptiveThinking as l, resolveClaudeOpus5ModelIdentity as m, normalizeModelCostConfig as n, CLAUDE_SONNET_5_THINKING_PROFILE as o, resolveClaudeNativeThinkingLevelMap as p, normalizeResolvedPricing as r, bindsClaudeThinkingPrefix as s, calculateUsageCost as t, resolveClaudeFable5ModelIdentity as u, supportsClaudeFastMode as v, supportsClaudeNativeMaxEffort as y };
+export { supportsClaudeFastMode as C, supportsClaudeAdaptiveThinking as S, supportsClaudeNativeXhighEffort as T, resolveClaudeOpus55ModelIdentity as _, CLAUDE_OPUS_55_THINKING_PROFILE as a, resolveClaudeSonnet5ModelIdentity as b, CLAUDE_SONNET_5_THINKING_PROFILE as c, requiresClaudeDefaultSampling as d, requiresClaudeMandatoryAdaptiveThinking as f, resolveClaudeNativeThinkingLevelMap as g, resolveClaudeMythos5ModelIdentity as h, CLAUDE_FABLE_5_THINKING_PROFILE as i, bindsClaudeThinkingPrefix as l, resolveClaudeModelIdentity as m, normalizeModelCostConfig as n, CLAUDE_OPUS_5_THINKING_PROFILE as o, resolveClaudeFable5ModelIdentity as p, normalizeResolvedPricing as r, CLAUDE_SONNET_55_THINKING_PROFILE as s, calculateUsageCost as t, requiresClaudeBetweenToolsThinking as u, resolveClaudeOpus5ModelIdentity as v, supportsClaudeNativeMaxEffort as w, supportsClaude1MContext as x, resolveClaudeSonnet55ModelIdentity as y };

package/dist/{stream-CREqxHgU.mjs → stream-DDsCBgd-.mjs}

@@ -5,12 +5,6 @@ function wrapStream(api, stream) {
 		return stream(model, context, options);
 	};
 }
-function wrapStreamSimple(api, streamSimple) {
-	return (model, context, options) => {
-		if (model.api !== api) throw new Error(`Mismatched api: ${model.api} expected ${api}`);
-		return streamSimple(model, context, options);
-	};
-}
 /** Creates an isolated provider registry for one runtime or tenant. */
 function createApiRegistry() {
 	const providers = /* @__PURE__ */ new Map();
@@ -19,7 +13,7 @@ function createApiRegistry() {
 			provider: {
 				api: provider.api,
 				stream: wrapStream(provider.api, provider.stream),
-				streamSimple: wrapStreamSimple(provider.api, provider.streamSimple)
+				streamSimple: wrapStream(provider.api, provider.streamSimple)
 			},
 			sourceId
 		});

package/dist/{stream-first-event-timeout-C9ZadkJW.mjs → stream-first-event-timeout-B9o0S4SZ.mjs}

@@ -1,4 +1,4 @@
-import { a as clampTimerTimeoutMs } from "./base64-BQOzsvUH.mjs";
+import { a as clampTimerTimeoutMs } from "./base64-C1PsYcRQ.mjs";
 //#region packages/ai/src/utils/stream-first-event-timeout.ts
 function getFirstStreamEventTimeoutMs(options) {
 	return options?.firstEventTimeoutMs;

package/dist/{tool-schema-json-projection-CD9c_fK8.mjs → tool-schema-json-projection-Ct8SeBeJ.mjs}

@@ -1,6 +1,63 @@
-import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
 import { t as expectDefined } from "./expect-lbe3Hgrh.mjs";
 import { types } from "node:util";
+//#region packages/ai/src/providers/schema-walk.ts
+const SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"dependencies",
+	"patternProperties",
+	"properties"
+]);
+/** Containers whose value is a single nested schema. */
+const SCHEMA_OBJECT_KEYS = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+/** Containers whose value is a list of nested schemas. */
+const SCHEMA_ARRAY_KEYS = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"items",
+	"oneOf",
+	"prefixItems"
+]);
+/** Resume child schema walks on a heap stack, never through recursive yield delegation. */
+function evaluateSchemaWalk(walk) {
+	const parents = [];
+	let current = walk;
+	let value;
+	try {
+		while (true) {
+			const step = current.next(value);
+			if (!step.done) {
+				parents.push(current);
+				current = step.value;
+				value = void 0;
+				continue;
+			}
+			value = step.value;
+			const parent = parents.pop();
+			if (!parent) return value;
+			current = parent;
+		}
+	} finally {
+		let parent;
+		while (parent = parents.pop()) parent.return(void 0);
+	}
+}
+//#endregion
 //#region packages/ai/src/providers/tool-schema-json-projection.ts
 function isNonFiniteNumberValue(value) {
 	if (typeof value === "number") return !Number.isFinite(value);
@@ -38,19 +95,10 @@ function serializeToolInputSchema(value, path, captureJson) {
 			isRoot = false;
 			return entry;
 		});
-	} catch {
-		return {
-			schema: {},
-			violations: [`${path} is not JSON-serializable`]
-		};
-	}
-	if (!text) return {
+	} catch {}
+	if (!text || nonFiniteNumber.path !== null) return {
 		schema: {},
-		violations: [`${path} is not JSON-serializable`]
-	};
-	if (nonFiniteNumber.path !== null) return {
-		schema: {},
-		violations: [`${nonFiniteNumber.path} is not JSON-serializable`]
+		violations: [`${text ? nonFiniteNumber.path : path} is not JSON-serializable`]
 	};
 	const schema = JSON.parse(text);
 	captureJson?.(text);
@@ -59,14 +107,6 @@ function serializeToolInputSchema(value, path, captureJson) {
 		violations: []
 	};
 }
-const schemaMapKeywords = /* @__PURE__ */ new Set([
-	"$defs",
-	"definitions",
-	"dependencies",
-	"dependentSchemas",
-	"patternProperties",
-	"properties"
-]);
 function inspectJsonSchema(schema, path, violations) {
 	if (Array.isArray(schema)) {
 		let index = 0;
@@ -85,7 +125,7 @@ function inspectJsonSchema(schema, path, violations) {
 		if (typeof value === "number" && !Number.isFinite(value)) return false;
 		if (!value || typeof value !== "object") continue;
 		path.push(".", key);
-		if (schemaMapKeywords.has(key) && isRecord(value)) for (const schemaName of Object.keys(value)) {
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) for (const schemaName of Object.keys(value)) {
 			const childSchema = value[schemaName];
 			if (childSchema === void 0) return false;
 			path.push(".", schemaName);
@@ -131,4 +171,4 @@ function projectToolInputSchema(schema, path, captureJson) {
 	};
 }
 //#endregion
-export { projectRuntimeToolInputSchema as n, prepareRuntimeToolInputSchema as t };
+export { SCHEMA_OBJECT_KEYS as a, SCHEMA_MAP_KEYS as i, projectRuntimeToolInputSchema as n, evaluateSchemaWalk as o, SCHEMA_ARRAY_KEYS as r, prepareRuntimeToolInputSchema as t };