@openclaw/ai 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/openai-tool-projection-WHf2nuOI.mjs

@@ -1,200 +0,0 @@
-import { f as isRecord } from "./transform-messages-eb6lxDLB.mjs";
-import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BwNu3nDi.mjs";
-//#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
-function unreadableToolDiagnostic(toolIndex) {
-	return {
-		toolIndex,
-		violations: [`tool[${toolIndex}] is unreadable`]
-	};
-}
-/** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
-function projectOpenAITools(tools) {
-	let inputToolCount;
-	try {
-		inputToolCount = tools.length;
-	} catch {
-		return {
-			inputToolCount: 0,
-			tools: [],
-			diagnostics: [unreadableToolDiagnostic(0)]
-		};
-	}
-	const projectedTools = [];
-	const diagnostics = [];
-	for (let toolIndex = 0; toolIndex < inputToolCount; toolIndex += 1) {
-		let tool;
-		try {
-			const candidate = tools[toolIndex];
-			if (!candidate) {
-				diagnostics.push(unreadableToolDiagnostic(toolIndex));
-				continue;
-			}
-			tool = candidate;
-		} catch {
-			diagnostics.push(unreadableToolDiagnostic(toolIndex));
-			continue;
-		}
-		let name;
-		try {
-			name = tool.name;
-		} catch {
-			diagnostics.push({
-				toolIndex,
-				violations: [`tool[${toolIndex}].name is unreadable`]
-			});
-			continue;
-		}
-		if (typeof name !== "string" || !name) {
-			diagnostics.push({
-				toolIndex,
-				violations: [`tool[${toolIndex}].name is empty`]
-			});
-			continue;
-		}
-		let parameters;
-		try {
-			parameters = tool.parameters;
-		} catch {
-			diagnostics.push({
-				toolIndex,
-				toolName: name,
-				violations: [`${name}.parameters is unreadable`]
-			});
-			continue;
-		}
-		const schemaProjection = projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
-		if (!isRecord(schemaProjection.schema) || schemaProjection.violations.length > 0) {
-			diagnostics.push({
-				toolIndex,
-				toolName: name,
-				violations: schemaProjection.violations.length > 0 ? schemaProjection.violations : [`${name}.parameters must be a JSON object schema`]
-			});
-			continue;
-		}
-		let descriptionValue;
-		try {
-			descriptionValue = tool.description;
-		} catch {}
-		const description = typeof descriptionValue === "string" ? descriptionValue : void 0;
-		projectedTools.push({
-			toolIndex,
-			name,
-			...description !== void 0 ? { description } : {},
-			parameters: schemaProjection.schema
-		});
-	}
-	return {
-		inputToolCount,
-		tools: projectedTools,
-		diagnostics
-	};
-}
-function requireProjectedFunction(name, projection, choiceLabel) {
-	if (!projection.tools.some((tool) => tool.name === name)) throw new Error(`${choiceLabel} requested unavailable tool "${name}" after schema conversion`);
-}
-/** Keeps Responses tool choices aligned with surviving function schemas. */
-function reconcileOpenAIResponsesToolChoice(choice, projection) {
-	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
-	if (choice === "required") {
-		if (projection.tools.length === 0) throw new Error("OpenAI Responses tool_choice requires a tool, but no tools survived schema conversion");
-		return choice;
-	}
-	if (choice === "none" || !isRecord(choice)) return choice;
-	const choiceType = choice.type;
-	if (choiceType === "function") {
-		const functionName = choice.name;
-		if (typeof functionName !== "string") return choice;
-		requireProjectedFunction(functionName, projection, "OpenAI Responses tool_choice");
-		return {
-			type: "function",
-			name: functionName
-		};
-	}
-	if (choiceType !== "allowed_tools") return choice;
-	const mode = choice.mode;
-	const tools = choice.tools;
-	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
-	const normalizedAllowedTools = [];
-	for (const tool of tools) {
-		if (!isRecord(tool) || tool.type !== "function") {
-			normalizedAllowedTools.push(tool);
-			continue;
-		}
-		const functionName = tool.name;
-		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
-			type: "function",
-			name: functionName
-		});
-	}
-	if (normalizedAllowedTools.length === 0) {
-		if (mode === "auto") return "none";
-		throw new Error("OpenAI Responses tool_choice requires a tool, but no allowed tools survived schema conversion");
-	}
-	return {
-		type: "allowed_tools",
-		mode,
-		tools: normalizedAllowedTools
-	};
-}
-/** Keeps Chat Completions tool choices aligned with surviving function schemas. */
-function reconcileOpenAICompletionsToolChoice(choice, projection) {
-	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
-	if (choice === "required") {
-		if (projection.tools.length === 0) throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no tools survived schema conversion");
-		return choice;
-	}
-	if (choice === "none" || !isRecord(choice)) return choice;
-	const choiceType = choice.type;
-	if (choiceType === "custom") throw new Error("OpenAI Chat Completions custom tool_choice is unsupported because this adapter emits function tools only");
-	if (choiceType === "function") {
-		const functionChoice = choice.function;
-		if (!isRecord(functionChoice)) return choice;
-		const functionName = functionChoice.name;
-		if (typeof functionName !== "string") return choice;
-		requireProjectedFunction(functionName, projection, "OpenAI Chat Completions tool_choice");
-		return {
-			type: "function",
-			function: { name: functionName }
-		};
-	}
-	if (choiceType !== "allowed_tools") return choice;
-	const allowedConfig = choice.allowed_tools;
-	if (!isRecord(allowedConfig)) return choice;
-	const mode = allowedConfig.mode;
-	const tools = allowedConfig.tools;
-	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
-	const normalizedAllowedTools = [];
-	for (const tool of tools) {
-		if (!isRecord(tool) || tool.type !== "function") continue;
-		const functionChoice = tool.function;
-		const functionName = isRecord(functionChoice) ? functionChoice.name : void 0;
-		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
-			type: "function",
-			function: { name: functionName }
-		});
-	}
-	if (normalizedAllowedTools.length === 0) {
-		if (mode === "auto") return "none";
-		throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no allowed tools survived schema conversion");
-	}
-	return {
-		type: "allowed_tools",
-		allowed_tools: {
-			mode,
-			tools: normalizedAllowedTools
-		}
-	};
-}
-//#endregion
-export { clampOpenAIPromptCacheKey as a, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH as i, reconcileOpenAICompletionsToolChoice as n, reconcileOpenAIResponsesToolChoice as r, projectOpenAITools as t };

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

@@ -1,400 +0,0 @@
-//#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, marker, trailing] = match;
-			if (indent === void 0 || marker === void 0 || trailing === void 0) {
-				if (nextNewline === -1) break;
-				offset = nextNewline + 1;
-				continue;
-			}
-			const markerChar = marker.charAt(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(trailing)) {
-				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.charAt(index) !== "`") {
-			index += 1;
-			continue;
-		}
-		const runStart = index;
-		let runLength = 0;
-		while (index < text.length && text.charAt(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 prefix = match.at(1);
-		const marker = match.at(2);
-		if (prefix === void 0 || marker === void 0) continue;
-		const index = (match.index ?? 0) + prefix.length;
-		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/stream-first-event-timeout-RjWszj8c.mjs

@@ -1,106 +0,0 @@
-//#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;
-}
-function getFirstStreamEventTimeoutHandler(options) {
-	return options?.onFirstEventTimeout;
-}
-function formatOptionalField(name, value) {
-	return value ? ` ${name}=${value}` : "";
-}
-function createFirstStreamEventTimeoutError(context) {
-	const stage = context.stage ? `${context.stage} ` : "";
-	const details = [
-		formatOptionalField("provider", context.provider),
-		formatOptionalField("api", context.api),
-		formatOptionalField("model", context.model)
-	].join("");
-	return /* @__PURE__ */ new Error(`${stage}HTTP stream opened but did not deliver a first SSE event within ${context.timeoutMs}ms after streaming headers (first-event timeout).${details}` + (context.hint ? ` ${context.hint}` : ""));
-}
-function createFirstStreamEventAbortController(parentSignal) {
-	const controller = new AbortController();
-	const abortFromParent = () => {
-		if (!controller.signal.aborted) controller.abort(parentSignal?.reason);
-	};
-	if (parentSignal?.aborted) abortFromParent();
-	else parentSignal?.addEventListener("abort", abortFromParent, { once: true });
-	return {
-		signal: controller.signal,
-		abort(reason) {
-			if (!controller.signal.aborted) controller.abort(reason);
-		},
-		dispose() {
-			parentSignal?.removeEventListener("abort", abortFromParent);
-		}
-	};
-}
-function withFirstStreamEventTimeout(stream, context) {
-	const timeoutMs = clampTimerTimeoutMs(context.timeoutMs);
-	if (timeoutMs === void 0 || context.timeoutMs <= 0) return stream;
-	const timeoutContext = {
-		...context,
-		timeoutMs
-	};
-	return { async *[Symbol.asyncIterator]() {
-		const iterator = stream[Symbol.asyncIterator]();
-		let timer;
-		let completed = false;
-		const clear = () => {
-			if (timer) {
-				clearTimeout(timer);
-				timer = void 0;
-			}
-		};
-		try {
-			const first = await new Promise((resolve, reject) => {
-				timer = setTimeout(() => {
-					const timeoutError = createFirstStreamEventTimeoutError(timeoutContext);
-					timeoutContext.onTimeout?.(timeoutError);
-					timeoutContext.abort?.(timeoutError);
-					reject(timeoutError);
-				}, timeoutMs);
-				timer.unref?.();
-				iterator.next().then(resolve, reject);
-			}).finally(clear);
-			if (first.done) {
-				completed = true;
-				return;
-			}
-			yield first.value;
-			for (;;) {
-				const next = await iterator.next();
-				if (next.done) {
-					completed = true;
-					return;
-				}
-				yield next.value;
-			}
-		} finally {
-			clear();
-			if (!completed) iterator.return?.().catch(() => void 0);
-		}
-	} };
-}
-//#endregion
-export { withFirstStreamEventTimeout as a, getFirstStreamEventTimeoutMs as i, createFirstStreamEventTimeoutError as n, clampTimerTimeoutMs as o, getFirstStreamEventTimeoutHandler as r, resolveTimerTimeoutMs as s, createFirstStreamEventAbortController as t };