@openclaw/ai 2026.7.2-beta.6 → 2026.7.33

package/dist/{openai-tool-projection-OhX64DoP.mjs → openai-tool-projection-BPlyXt8H.mjs}

@@ -1,29 +1,14 @@
-import { g as isRecord, n as getAiTransportHost } from "./host-Dog2WQiR.mjs";
+import { c as isRecord } from "./transform-messages-BhGF_fF4.mjs";
 import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BwNu3nDi.mjs";
-//#region packages/ai/src/transports/host-policy.ts
-function buildGuardedModelFetch(model, timeoutMs, options) {
-	const host = getAiTransportHost();
-	if (options !== void 0) return host.buildModelFetch(model, timeoutMs, options) ?? globalThis.fetch;
-	if (timeoutMs !== void 0) return host.buildModelFetch(model, timeoutMs) ?? globalThis.fetch;
-	return host.buildModelFetch(model) ?? globalThis.fetch;
-}
-function resolveProviderEndpoint(baseUrl) {
-	return { endpointClass: getAiTransportHost().resolveProviderEndpointClass(baseUrl) };
-}
-function resolveProviderRequestCapabilities(input) {
-	return getAiTransportHost().resolveProviderRequestCapabilities(input);
-}
-function resolveProviderRequestPolicyConfig(input) {
-	return { headers: getAiTransportHost().resolveProviderRequestHeaders(input) };
-}
-function resolveModelRequestTimeoutMs(model, timeoutMs) {
-	return timeoutMs ?? getAiTransportHost().resolveModelRequestTimeoutMs(model);
-}
-function resolveOpenAIStrictToolSetting(model, options) {
-	return getAiTransportHost().resolveOpenAIStrictToolSetting(model, options);
-}
-function transformTransportMessages(messages, model, normalizeToolCallId, options) {
-	return getAiTransportHost().transformTransportMessages(messages, model, normalizeToolCallId, options);
+//#region packages/ai/src/providers/openai-prompt-cache.ts
+/** Maximum prompt cache key length accepted by OpenAI-compatible request metadata. */
+const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+/** Truncates a prompt cache key by Unicode code point count. */
+function clampOpenAIPromptCacheKey(key) {
+	if (key === void 0) return;
+	const chars = Array.from(key);
+	if (chars.length <= 64) return key;
+	return chars.slice(0, 64).join("");
 }
 //#endregion
 //#region packages/ai/src/providers/openai-tool-projection.ts
@@ -50,12 +35,7 @@ function projectOpenAITools(tools) {
 	for (let toolIndex = 0; toolIndex < inputToolCount; toolIndex += 1) {
 		let tool;
 		try {
-			const candidate = tools[toolIndex];
-			if (!candidate) {
-				diagnostics.push(unreadableToolDiagnostic(toolIndex));
-				continue;
-			}
-			tool = candidate;
+			tool = tools[toolIndex];
 		} catch {
 			diagnostics.push(unreadableToolDiagnostic(toolIndex));
 			continue;
@@ -212,4 +192,4 @@ function reconcileOpenAICompletionsToolChoice(choice, projection) {
 	};
 }
 //#endregion
-export { resolveModelRequestTimeoutMs as a, resolveProviderRequestCapabilities as c, buildGuardedModelFetch as i, resolveProviderRequestPolicyConfig as l, reconcileOpenAICompletionsToolChoice as n, resolveOpenAIStrictToolSetting as o, reconcileOpenAIResponsesToolChoice as r, resolveProviderEndpoint as s, projectOpenAITools as t, transformTransportMessages as u };
+export { clampOpenAIPromptCacheKey as a, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH as i, reconcileOpenAICompletionsToolChoice as n, reconcileOpenAIResponsesToolChoice as r, projectOpenAITools as t };

package/dist/providers.d.mts

@@ -1,5 +1,4 @@
-import { n as ApiRegistry } from "./api-registry-DlMgPR39.mjs";
-import { n as clampOpenAIPromptCacheKey, t as OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH } from "./openai-prompt-cache-2uo_1OR1.mjs";
+import { n as ApiRegistry } from "./api-registry-BXYnCOIR.mjs";
 
 //#region packages/ai/src/providers/register-builtins.d.ts
 /** Source id used for built-in API provider registrations. */
@@ -9,4 +8,4 @@ declare function registerBuiltInApiProviders(registry: ApiRegistry): void;
 /** Restores the built-in provider registry state for tests. */
 declare function resetApiProviders(registry: ApiRegistry): void;
 //#endregion
-export { BUILT_IN_API_PROVIDER_SOURCE_ID, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH, clampOpenAIPromptCacheKey, registerBuiltInApiProviders, resetApiProviders };
+export { BUILT_IN_API_PROVIDER_SOURCE_ID, registerBuiltInApiProviders, resetApiProviders };

package/dist/providers.mjs

@@ -1,5 +1,4 @@
-import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as clampOpenAIPromptCacheKey, t as OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH } from "./openai-prompt-cache-mZTCdRPo.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
 //#region packages/ai/src/providers/register-builtins.ts
 /** Source id used for built-in API provider registrations. */
 const BUILT_IN_API_PROVIDER_SOURCE_ID = "core:built-in";
@@ -64,35 +63,35 @@ function createLazyRegistration(api, importModule, select) {
 	};
 }
 const registerBuiltIns = [
-	createLazyRegistration("anthropic-messages", () => import("./anthropic-CH4UUnZr.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("anthropic-messages", () => import("./anthropic-BML72tLz.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamAnthropic,
 		streamSimple: module.streamSimpleAnthropic
 	})),
-	createLazyRegistration("openai-completions", () => import("./openai-completions-DsOxhOD1.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("openai-completions", () => import("./openai-completions-9qYFVS7H.mjs").then((n) => n.n), (module) => ({
 		stream: module.streamOpenAICompletions,
 		streamSimple: module.streamSimpleOpenAICompletions
 	})),
-	createLazyRegistration("mistral-conversations", () => import("./mistral-CWmpvWYh.mjs"), (module) => ({
+	createLazyRegistration("mistral-conversations", () => import("./mistral-CePVNdws.mjs"), (module) => ({
 		stream: module.streamMistral,
 		streamSimple: module.streamSimpleMistral
 	})),
-	createLazyRegistration("openai-responses", () => import("./openai-responses-BT7A3sLu.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("openai-responses", () => import("./openai-responses-D6l9URyV.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamOpenAIResponses,
 		streamSimple: module.streamSimpleOpenAIResponses
 	})),
-	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-CImcwB83.mjs"), (module) => ({
+	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-kEN8II8I.mjs"), (module) => ({
 		stream: module.streamAzureOpenAIResponses,
 		streamSimple: module.streamSimpleAzureOpenAIResponses
 	})),
-	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-B84Ibtrd.mjs"), (module) => ({
+	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-BHqbcipc.mjs"), (module) => ({
 		stream: module.streamOpenAICodexResponses,
 		streamSimple: module.streamSimpleOpenAICodexResponses
 	})),
-	createLazyRegistration("google-generative-ai", () => import("./google-CtSg0iTS.mjs"), (module) => ({
+	createLazyRegistration("google-generative-ai", () => import("./google-DTM4O3e9.mjs"), (module) => ({
 		stream: module.streamGoogle,
 		streamSimple: module.streamSimpleGoogle
 	})),
-	createLazyRegistration("google-vertex", () => import("./google-vertex-31f1uS9L.mjs"), (module) => ({
+	createLazyRegistration("google-vertex", () => import("./google-vertex-D58MZHCQ.mjs"), (module) => ({
 		stream: module.streamGoogleVertex,
 		streamSimple: module.streamSimpleGoogleVertex
 	}))
@@ -107,4 +106,4 @@ function resetApiProviders(registry) {
 	registerBuiltInApiProviders(registry);
 }
 //#endregion
-export { BUILT_IN_API_PROVIDER_SOURCE_ID, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH, clampOpenAIPromptCacheKey, registerBuiltInApiProviders, resetApiProviders };
+export { BUILT_IN_API_PROVIDER_SOURCE_ID, registerBuiltInApiProviders, resetApiProviders };

package/dist/reasoning-tag-text-partitioner-axhAdUwg.mjs

@@ -0,0 +1,394 @@
+//#region packages/markdown-core/src/fences.ts
+/** Scans fenced-code spans incrementally so chunking can carry an open fence forward. */
+function scanFenceSpans(buffer, state) {
+	const spans = [];
+	const startsAtLineStart = state?.atLineStart ?? true;
+	let open = state?.open ? {
+		...state.open,
+		start: 0
+	} : void 0;
+	let offset = 0;
+	while (offset <= buffer.length) {
+		const nextNewline = buffer.indexOf("\n", offset);
+		const lineEnd = nextNewline === -1 ? buffer.length : nextNewline;
+		const line = buffer.slice(offset, lineEnd).replace(/\r$/, "");
+		const match = line.match(/^( {0,3})(`{3,}|~{3,})(.*)$/);
+		if (match && (offset > 0 || startsAtLineStart)) {
+			const indent = match[1];
+			const marker = match[2];
+			const markerChar = marker[0];
+			const markerLen = marker.length;
+			if (!open) open = {
+				start: offset,
+				markerChar,
+				markerLen,
+				openLine: line,
+				marker,
+				indent
+			};
+			else if (open.markerChar === markerChar && markerLen >= open.markerLen && /^[ \t]*$/.test(match[3])) {
+				const end = lineEnd;
+				spans.push({
+					start: open.start,
+					end,
+					openLine: open.openLine,
+					marker: open.marker,
+					indent: open.indent
+				});
+				open = void 0;
+			}
+		}
+		if (nextNewline === -1) break;
+		offset = nextNewline + 1;
+	}
+	if (open) spans.push({
+		start: open.start,
+		end: buffer.length,
+		openLine: open.openLine,
+		marker: open.marker,
+		indent: open.indent
+	});
+	return {
+		spans,
+		state: {
+			atLineStart: buffer.length === 0 ? startsAtLineStart : buffer.endsWith("\n"),
+			...open ? { open: {
+				markerChar: open.markerChar,
+				markerLen: open.markerLen,
+				openLine: open.openLine,
+				marker: open.marker,
+				indent: open.indent
+			} } : {}
+		}
+	};
+}
+//#endregion
+//#region packages/markdown-core/src/code-spans.ts
+/** Creates the carry-forward state used when scanning inline code across chunks. */
+function createInlineCodeState() {
+	return {
+		open: false,
+		ticks: 0
+	};
+}
+/** Builds a lookup for fenced and inline code spans while preserving scanner state. */
+function buildCodeSpanIndex(text, inlineState, fenceState) {
+	const { spans: fenceSpans, state: nextFenceState } = scanFenceSpans(text, fenceState);
+	const { spans: inlineSpans, state: nextInlineState } = parseInlineCodeSpans(text, fenceSpans, inlineState ? {
+		open: inlineState.open,
+		ticks: inlineState.ticks
+	} : createInlineCodeState());
+	return {
+		inlineState: nextInlineState,
+		fenceState: nextFenceState,
+		isInside: (index) => isInsideFenceSpan(index, fenceSpans) || isInsideInlineSpan(index, inlineSpans)
+	};
+}
+function parseInlineCodeSpans(text, fenceSpans, initialState) {
+	const spans = [];
+	let open = initialState.open;
+	let ticks = initialState.ticks;
+	let openStart = open ? 0 : -1;
+	let i = 0;
+	while (i < text.length) {
+		const fence = findFenceSpanAtInclusive(fenceSpans, i);
+		if (fence) {
+			i = fence.end;
+			continue;
+		}
+		if (text[i] !== "`") {
+			i += 1;
+			continue;
+		}
+		const runStart = i;
+		let runLength = 0;
+		while (i < text.length && text[i] === "`") {
+			runLength += 1;
+			i += 1;
+		}
+		if (!open) {
+			open = true;
+			ticks = runLength;
+			openStart = runStart;
+			continue;
+		}
+		if (runLength === ticks) {
+			spans.push([openStart, i]);
+			open = false;
+			ticks = 0;
+			openStart = -1;
+		}
+	}
+	if (open) spans.push([openStart, text.length]);
+	return {
+		spans,
+		state: {
+			open,
+			ticks
+		}
+	};
+}
+function findFenceSpanAtInclusive(spans, index) {
+	return spans.find((span) => index >= span.start && index < span.end);
+}
+function isInsideFenceSpan(index, spans) {
+	return spans.some((span) => index >= span.start && index < span.end);
+}
+function isInsideInlineSpan(index, spans) {
+	return spans.some(([start, end]) => index >= start && index < end);
+}
+//#endregion
+//#region packages/ai/src/utils/reasoning-tag-text-partitioner.ts
+const REASONING_TAG_RE = /<\s*(\/?)\s*(?:(?:antml:|mm:)?(?:think(?:ing)?|thought|reasoning)|antthinking)\b[^<>]*>/gi;
+const REASONING_TAG_NAMES = [
+	"think",
+	"thinking",
+	"thought",
+	"reasoning",
+	"antthinking",
+	"antml:think",
+	"antml:thinking",
+	"antml:thought",
+	"antml:reasoning",
+	"mm:think",
+	"mm:thinking",
+	"mm:thought",
+	"mm:reasoning"
+];
+function createReasoningTagTextPartitioner() {
+	let buffer = "";
+	let reasoningDepth = 0;
+	let strictMode = false;
+	let emittedVisibleText = false;
+	let inlineCodeState = createInlineCodeState();
+	let fenceState;
+	let hiddenInlineCodeState = createInlineCodeState();
+	let hiddenFenceState;
+	let recoverableOpenTagText;
+	const consume = (final, recoverFullUnclosed) => {
+		const output = [];
+		const emit = (kind, text) => {
+			if (!text) return;
+			if (kind === "text" && text.trim().length > 0) emittedVisibleText = true;
+			if (kind === "text") {
+				const nextCode = buildCodeSpanIndex(text, inlineCodeState, fenceState);
+				inlineCodeState = nextCode.inlineState;
+				fenceState = nextCode.fenceState;
+			} else {
+				const nextCode = buildCodeSpanIndex(text, hiddenInlineCodeState, hiddenFenceState);
+				hiddenInlineCodeState = nextCode.inlineState;
+				hiddenFenceState = nextCode.fenceState;
+			}
+			const previous = output[output.length - 1];
+			if (previous?.kind === kind) {
+				previous.text += text;
+				return;
+			}
+			output.push({
+				kind,
+				text
+			});
+		};
+		while (buffer) {
+			const activeInlineCodeState = reasoningDepth === 0 ? inlineCodeState : hiddenInlineCodeState;
+			const activeFenceState = reasoningDepth === 0 ? fenceState : hiddenFenceState;
+			const codeSpans = buildCodeSpanIndex(buffer, activeInlineCodeState, activeFenceState);
+			const hasUnclosedCode = reasoningDepth === 0 && Boolean(codeSpans.inlineState.open || codeSpans.fenceState.open);
+			const hasRawReasoning = hasRawReasoningTag(buffer);
+			const tag = findNextReasoningTag(buffer, (index) => final && hasUnclosedCode && hasRawReasoning ? false : codeSpans.isInside(index));
+			if (!tag) {
+				if (final) {
+					const recoverAsText = reasoningDepth > 0 && recoverFullUnclosed && !hasRawReasoningCloseTag(buffer);
+					const recoveredText = recoverAsText && recoverableOpenTagText ? recoverableOpenTagText + buffer : buffer;
+					emit(reasoningDepth > 0 && !recoverAsText ? "thinking" : "text", recoveredText);
+					buffer = "";
+					reasoningDepth = 0;
+					recoverableOpenTagText = void 0;
+					return output;
+				}
+				if (reasoningDepth > 0 && recoverFullUnclosed && (!emittedVisibleText || recoverableOpenTagText)) return output;
+				if (hasUnclosedCode && hasRawReasoning) {
+					const openCodeIndex = inlineCodeState.open || fenceState?.open ? 0 : findOpenCodeContextStart(buffer);
+					if (openCodeIndex !== -1) {
+						emit("text", buffer.slice(0, openCodeIndex));
+						buffer = buffer.slice(openCodeIndex);
+						return output;
+					}
+				}
+				const trailingFenceStart = findTrailingFenceFragmentStart(buffer, activeInlineCodeState, activeFenceState);
+				if (trailingFenceStart !== -1) {
+					emit(reasoningDepth > 0 ? "thinking" : "text", buffer.slice(0, trailingFenceStart));
+					buffer = buffer.slice(trailingFenceStart);
+					return output;
+				}
+				const keepFrom = reasoningTagPrefixSuffixIndex(buffer, (index) => codeSpans.isInside(index));
+				if (keepFrom === -1) {
+					emit(reasoningDepth > 0 ? "thinking" : "text", buffer);
+					buffer = "";
+					return output;
+				}
+				if (reasoningDepth === 0 && keepFrom > 0 && buffer.slice(0, keepFrom).trim().length > 0 && isReasoningCloseTagPrefix(buffer.slice(keepFrom))) return output;
+				if (keepFrom > 0) {
+					emit(reasoningDepth > 0 ? "thinking" : "text", buffer.slice(0, keepFrom));
+					buffer = buffer.slice(keepFrom);
+				}
+				return output;
+			}
+			const beforeTag = buffer.slice(0, tag.index);
+			const afterTag = buffer.slice(tag.index + tag.text.length);
+			if (tag.isClose && reasoningDepth === 0) {
+				if (recoverFullUnclosed && beforeTag.trim().length > 0 && afterTag.trim().length > 0) {
+					emit("text", beforeTag + tag.text);
+					buffer = afterTag;
+					continue;
+				}
+				if (beforeTag.trim().length > 0 && afterTag.trim().length === 0 && !final) return output;
+				if (beforeTag.trim().length === 0 || afterTag.trim().length === 0) emit("text", beforeTag);
+				buffer = afterTag;
+				continue;
+			}
+			emit(reasoningDepth > 0 ? "thinking" : "text", buffer.slice(0, tag.index));
+			buffer = afterTag;
+			if (tag.isClose) {
+				reasoningDepth = Math.max(0, reasoningDepth - 1);
+				if (reasoningDepth === 0) {
+					recoverableOpenTagText = void 0;
+					hiddenInlineCodeState = createInlineCodeState();
+					hiddenFenceState = void 0;
+				}
+			} else {
+				if (reasoningDepth === 0) {
+					recoverableOpenTagText = recoverFullUnclosed && emittedVisibleText ? tag.text : void 0;
+					hiddenInlineCodeState = createInlineCodeState();
+					hiddenFenceState = void 0;
+				}
+				reasoningDepth += 1;
+			}
+		}
+		return output;
+	};
+	return {
+		markStrict() {
+			strictMode = true;
+		},
+		push(chunk) {
+			strictMode = true;
+			buffer += chunk;
+			return consume(false, false);
+		},
+		pushVisible(chunk) {
+			buffer += chunk;
+			return consume(false, true);
+		},
+		flush() {
+			return consume(true, !strictMode);
+		},
+		hasPending() {
+			return buffer.length > 0 || reasoningDepth > 0;
+		},
+		isInsideReasoning() {
+			return reasoningDepth > 0;
+		}
+	};
+}
+function hasRawReasoningTag(text) {
+	REASONING_TAG_RE.lastIndex = 0;
+	return REASONING_TAG_RE.test(text);
+}
+function hasRawReasoningCloseTag(text) {
+	REASONING_TAG_RE.lastIndex = 0;
+	for (;;) {
+		const match = REASONING_TAG_RE.exec(text);
+		if (!match) return false;
+		if (match[1] === "/") return true;
+	}
+}
+function findNextReasoningTag(text, isIndexInsideCode) {
+	REASONING_TAG_RE.lastIndex = 0;
+	for (;;) {
+		const match = REASONING_TAG_RE.exec(text);
+		if (!match) return null;
+		if (!isIndexInsideCode(match.index)) return {
+			index: match.index,
+			text: match[0],
+			isClose: match[1] === "/"
+		};
+	}
+}
+function reasoningTagPrefixSuffixIndex(text, isIndexInsideCode) {
+	for (let index = text.lastIndexOf("<"); index >= 0;) {
+		if (!isIndexInsideCode(index) && isReasoningTagPrefix(text.slice(index))) return index;
+		if (index === 0) break;
+		index = text.lastIndexOf("<", index - 1);
+	}
+	return -1;
+}
+function isReasoningTagPrefix(text) {
+	const name = normalizeReasoningTagPrefixName(text);
+	return REASONING_TAG_NAMES.some((tagName) => {
+		if (tagName.startsWith(name)) return true;
+		if (!name.startsWith(tagName)) return false;
+		const rest = name.slice(tagName.length);
+		return rest.length === 0 || /^[\s/>]/.test(rest);
+	});
+}
+function isReasoningCloseTagPrefix(text) {
+	return text.replace(/^<\s*/, "<").replace(/^<\s*\//, "</").replace(/^<\/\s*/, "</").toLowerCase().startsWith("</") && isReasoningTagPrefix(text);
+}
+function normalizeReasoningTagPrefixName(text) {
+	const normalized = text.replace(/^<\s*/, "<").replace(/^<\s*\//, "</").replace(/^<\/\s*/, "</").toLowerCase();
+	return (normalized.startsWith("</") ? normalized.slice(2) : normalized.slice(1)).trimStart();
+}
+function findOpenCodeContextStart(text) {
+	const fence = findOpenFenceStart(text);
+	const inline = findOpenInlineCodeStart(text);
+	if (fence === -1) return inline;
+	if (inline === -1) return fence;
+	return Math.min(fence, inline);
+}
+function findOpenInlineCodeStart(text) {
+	let openStart = -1;
+	let openTicks = 0;
+	let index = 0;
+	while (index < text.length) {
+		if (text[index] !== "`") {
+			index += 1;
+			continue;
+		}
+		const runStart = index;
+		let runLength = 0;
+		while (index < text.length && text[index] === "`") {
+			runLength += 1;
+			index += 1;
+		}
+		if (openStart === -1) {
+			openStart = runStart;
+			openTicks = runLength;
+		} else if (runLength === openTicks) {
+			openStart = -1;
+			openTicks = 0;
+		}
+	}
+	return openStart;
+}
+function findOpenFenceStart(text) {
+	const fenceRe = /(^|\n)(```|~~~)[^\n]*(?:\n|$)/g;
+	let open = null;
+	for (const match of text.matchAll(fenceRe)) {
+		const index = (match.index ?? 0) + match[1].length;
+		const marker = match[2] ?? "";
+		if (open !== null && open.marker === marker) open = null;
+		else if (!open) open = {
+			marker,
+			index
+		};
+	}
+	return open?.index ?? -1;
+}
+function findTrailingFenceFragmentStart(text, inlineState, fenceState) {
+	if (inlineState.open || fenceState?.open) return -1;
+	const lineStart = Math.max(text.lastIndexOf("\n") + 1, 0);
+	return text.slice(lineStart).match(/^( {0,3})(`{1,2}|~{1,2})$/) ? lineStart : -1;
+}
+//#endregion
+export { createReasoningTagTextPartitioner as t };

package/dist/{src-QkygScBs.mjs → src-CZ503MYJ.mjs}

@@ -1,4 +1,4 @@
-import "./validation-DAa_yFOM.mjs";
+import "./validation-FrchoOlv.mjs";
 //#region packages/llm-core/src/model-contracts/anthropic.ts
 function normalizeClaudeModelId(modelId) {
 	const normalized = modelId?.trim().toLowerCase() ?? "";
@@ -31,7 +31,6 @@ const CLAUDE_SONNET_5_THINKING_PROFILE = {
 	],
 	defaultLevel: "high"
 };
-const CLAUDE_OPUS_5_THINKING_PROFILE = CLAUDE_SONNET_5_THINKING_PROFILE;
 /** 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);
@@ -64,38 +63,20 @@ function resolveClaudeSonnet5ModelIdentity(ref) {
 	if (!match) return;
 	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
 }
-/** Resolve Claude Opus 5 through aliases, direct ids, cloud ids, or deployment metadata. */
-function resolveClaudeOpus5ModelIdentity(ref) {
-	const normalized = resolveClaudeModelIdentity(ref);
-	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 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 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 whether a Claude model supports Anthropic's native fast mode. */
-function supportsClaudeFastMode(ref) {
-	const modelId = resolveClaudeModelIdentity(ref);
-	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-opus-4-8(?=$|[^a-z0-9])/.test(modelId);
+	return /(?:^|-)claude-(?:fable-5|mythos-(?:5|preview)|opus-4-(?:6|7|8)|sonnet-(?:5|4-6))(?=$|[^a-z0-9])/.test(modelId);
 }
 /** 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 /(?:^|-)claude-(?:fable-5|mythos-5|opus-4-(?:6|7|8)|sonnet-(?:5|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 /(?:^|-)claude-(?:fable-5|mythos-5|opus-4-(?:7|8)|sonnet-5)(?=$|[^a-z0-9])/.test(modelId);
 }
 /** Return whether a Claude model rejects caller-selected sampling parameters. */
 function requiresClaudeDefaultSampling(ref) {
@@ -115,4 +96,4 @@ function resolveClaudeNativeThinkingLevelMap(ref) {
 	};
 }
 //#endregion
-export { requiresClaudeMandatoryAdaptiveThinking as a, resolveClaudeMythos5ModelIdentity as c, resolveClaudeSonnet5ModelIdentity as d, supportsClaude1MContext as f, supportsClaudeNativeXhighEffort as g, supportsClaudeNativeMaxEffort as h, requiresClaudeDefaultSampling as i, resolveClaudeNativeThinkingLevelMap as l, supportsClaudeFastMode as m, CLAUDE_OPUS_5_THINKING_PROFILE as n, resolveClaudeFable5ModelIdentity as o, supportsClaudeAdaptiveThinking as p, CLAUDE_SONNET_5_THINKING_PROFILE as r, resolveClaudeModelIdentity as s, CLAUDE_FABLE_5_THINKING_PROFILE as t, resolveClaudeOpus5ModelIdentity as u };
+export { resolveClaudeFable5ModelIdentity as a, resolveClaudeNativeThinkingLevelMap as c, supportsClaudeNativeMaxEffort as d, supportsClaudeNativeXhighEffort as f, requiresClaudeMandatoryAdaptiveThinking as i, resolveClaudeSonnet5ModelIdentity as l, CLAUDE_SONNET_5_THINKING_PROFILE as n, resolveClaudeModelIdentity as o, requiresClaudeDefaultSampling as r, resolveClaudeMythos5ModelIdentity as s, CLAUDE_FABLE_5_THINKING_PROFILE as t, supportsClaudeAdaptiveThinking as u };

package/dist/{stream-first-event-timeout-BBys9hSb.mjs → stream-first-event-timeout-RjWszj8c.mjs}

@@ -1,4 +1,24 @@
-import { n as clampTimerTimeoutMs } from "./number-coercion-DvG7SNMg.mjs";
+//#region packages/normalization-core/src/number-coercion.ts
+/** Returns a number only when the input is already finite. */
+function asFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** Conservative upper bound for Node timer delays. */
+const MAX_TIMER_TIMEOUT_MS = 2147e6;
+/** Clamps finite millisecond values into the Node-safe timer range. */
+function clampTimerTimeoutMs(valueMs, minMs = 1) {
+	const value = asFiniteNumber(valueMs);
+	if (value === void 0) return;
+	return Math.min(Math.max(Math.floor(value), Math.max(1, Math.floor(minMs))), MAX_TIMER_TIMEOUT_MS);
+}
+/** Resolves arbitrary timeout input with fallback and minimum timer bounds. */
+function resolveTimerTimeoutMs(valueMs, fallbackMs, minMs = 1) {
+	const value = asFiniteNumber(valueMs) ?? asFiniteNumber(fallbackMs);
+	const min = Math.max(0, Math.floor(minMs));
+	if (value === void 0) return min;
+	return Math.min(Math.max(Math.floor(value), min), MAX_TIMER_TIMEOUT_MS);
+}
+//#endregion
 //#region packages/ai/src/utils/stream-first-event-timeout.ts
 function getFirstStreamEventTimeoutMs(options) {
 	return options?.firstEventTimeoutMs;
@@ -83,4 +103,4 @@ function withFirstStreamEventTimeout(stream, context) {
 	} };
 }
 //#endregion
-export { withFirstStreamEventTimeout as a, getFirstStreamEventTimeoutMs as i, createFirstStreamEventTimeoutError as n, getFirstStreamEventTimeoutHandler as r, createFirstStreamEventAbortController as t };
+export { withFirstStreamEventTimeout as a, getFirstStreamEventTimeoutMs as i, createFirstStreamEventTimeoutError as n, clampTimerTimeoutMs as o, getFirstStreamEventTimeoutHandler as r, resolveTimerTimeoutMs as s, createFirstStreamEventAbortController as t };