@openclaw/ai 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{openai-reasoning-compat-YgeLncHw.mjs → openai-stop-reason-BkFkqqK0.mjs}

@@ -1,7 +1,13 @@
-import { g as isRecord, i as transformMessages, p as normalizeLowercaseStringOrEmpty } from "./host-Dog2WQiR.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { a as isImageWithMediaPayload, d as stripSystemPromptCacheBoundary, r as extractToolResultText, t as describeToolResultMediaPlaceholder } from "./tool-result-text-CTpIRbYd.mjs";
-import { c as resolveProviderRequestCapabilities } from "./openai-tool-projection-OhX64DoP.mjs";
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-BYqrYtC_.mjs";
+import { a as describeToolResultMediaPlaceholder, l as isImageWithMediaPayload, s as extractToolResultText } from "./host-DTqNc7ad.mjs";
+import { a as isRecord, r as asOptionalObjectRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
+import { l as stripSystemPromptCacheBoundary } from "./simple-options-D58D5Kvw.mjs";
+import { o as resolveProviderRequestCapabilities } from "./tool-schema-json-projection-q5d7QX5c.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-ePx-Bbfr.mjs";
+import { l as measureUtf8AppendBytes } from "./openai-tool-projection-CY04OcvQ.mjs";
+import { randomUUID } from "node:crypto";
 //#region packages/ai/src/utils/assistant-text-phase.ts
 function isAssistantTextPhaseBlock(block) {
 	if (!block || typeof block !== "object") return false;
@@ -174,7 +180,161 @@ function resolveOpenAICompletionsCompat(model, resolveCapabilities = resolveProv
 		requiresNonEmptyUserOrAssistantMessage: defaults.requiresNonEmptyUserOrAssistantMessage
 	};
 }
-if (process.env.VITEST || false) globalThis[Symbol.for("openclaw.openAICompletionsCompatTestApi")] = { resolveOpenAICompletionsCompatDefaults };
+//#endregion
+//#region packages/ai/src/providers/openai-completions-tool-calls.ts
+const MAX_BUFFERED_TOOL_CALL_ARGUMENT_BYTES = 256e3;
+const MAX_BUFFERED_LEGACY_FOLLOWING_DELTA_BYTES = 256e3;
+const MAX_BUFFERED_LEGACY_FOLLOWING_DELTAS = 1024;
+/** Normalize the SDK's legacy single-function lane into its modern tool-call shape. */
+function createOpenAICompletionsToolCallDeltaNormalizer() {
+	let sawModernToolCall = false;
+	let pendingLegacyArgumentBytes = 0;
+	let pendingFollowingDeltaBytes = 0;
+	let pendingLegacyToolCall;
+	const modernArguments = /* @__PURE__ */ new Map();
+	const pendingFollowingDeltas = [];
+	const takePendingFollowingDeltas = () => {
+		pendingFollowingDeltaBytes = 0;
+		return pendingFollowingDeltas.splice(0).map((delta) => ({
+			delta,
+			toolCalls: []
+		}));
+	};
+	const bufferFollowingDelta = (delta) => {
+		const nextDeltaBytes = Buffer.byteLength(JSON.stringify(delta), "utf8");
+		if (pendingFollowingDeltaBytes + nextDeltaBytes > MAX_BUFFERED_LEGACY_FOLLOWING_DELTA_BYTES || pendingFollowingDeltas.length >= MAX_BUFFERED_LEGACY_FOLLOWING_DELTAS) throw new Error("Exceeded legacy tool-call content buffer limit");
+		pendingFollowingDeltaBytes += nextDeltaBytes;
+		pendingFollowingDeltas.push(delta);
+	};
+	const withoutToolCalls = (delta) => {
+		const ordinaryDelta = { ...delta };
+		delete ordinaryDelta.function_call;
+		delete ordinaryDelta.tool_calls;
+		return ordinaryDelta;
+	};
+	const hasObservableContent = (value) => {
+		if (typeof value === "string") return value.length > 0;
+		if (Array.isArray(value)) return value.some(hasObservableContent);
+		if (isRecord(value)) return Object.entries(value).some(([field, nestedValue]) => field !== "type" && field !== "id" && field !== "index" && hasObservableContent(nestedValue));
+		return false;
+	};
+	const hasOrdinaryContent = (delta) => Object.entries(delta).some(([field, value]) => field !== "role" && hasObservableContent(value));
+	return (delta, finishReason) => {
+		const ordinaryDelta = withoutToolCalls(delta);
+		if (delta.tool_calls && delta.tool_calls.length > 0) {
+			for (const toolCall of delta.tool_calls) {
+				const index = typeof toolCall.index === "number" ? toolCall.index : void 0;
+				const state = (index === void 0 ? void 0 : modernArguments.get(index)) ?? (toolCall.id ? modernArguments.get(toolCall.id) : void 0) ?? {
+					bytes: 0,
+					pendingHighSurrogate: false
+				};
+				if (index !== void 0) modernArguments.set(index, state);
+				if (toolCall.id) modernArguments.set(toolCall.id, state);
+				const argumentDelta = toolCall.function?.arguments ?? "";
+				const append = measureUtf8AppendBytes(state.pendingHighSurrogate, argumentDelta);
+				state.bytes += append.bytes;
+				if (state.bytes > MAX_BUFFERED_TOOL_CALL_ARGUMENT_BYTES) throw new Error("Exceeded tool-call argument buffer limit");
+				state.pendingHighSurrogate = append.endsWithHighSurrogate;
+			}
+			const precedingDeltas = takePendingFollowingDeltas();
+			sawModernToolCall = true;
+			pendingLegacyArgumentBytes = 0;
+			pendingLegacyToolCall = void 0;
+			return [...precedingDeltas, {
+				delta: ordinaryDelta,
+				toolCalls: delta.tool_calls
+			}];
+		}
+		const functionCall = delta.function_call;
+		if (sawModernToolCall) return [{
+			delta: ordinaryDelta,
+			toolCalls: []
+		}];
+		const hadPendingLegacyCall = pendingLegacyToolCall !== void 0;
+		const leadingDeltas = [];
+		if (hasOrdinaryContent(ordinaryDelta)) if (hadPendingLegacyCall) bufferFollowingDelta(ordinaryDelta);
+		else leadingDeltas.push({
+			delta: ordinaryDelta,
+			toolCalls: []
+		});
+		if (functionCall && (functionCall.name || functionCall.arguments)) {
+			const nextFunctionName = pendingLegacyToolCall?.function?.name ? void 0 : functionCall.name;
+			const nextArgumentBytes = Buffer.byteLength(functionCall.arguments ?? "", "utf8") + Buffer.byteLength(nextFunctionName ?? "", "utf8");
+			if (pendingLegacyArgumentBytes + nextArgumentBytes > MAX_BUFFERED_TOOL_CALL_ARGUMENT_BYTES) throw new Error("Exceeded tool-call argument buffer limit");
+			pendingLegacyArgumentBytes += nextArgumentBytes;
+			pendingLegacyToolCall ??= {
+				index: 0,
+				id: `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`,
+				type: "function",
+				function: {}
+			};
+			const pendingFunction = pendingLegacyToolCall.function ??= {};
+			if (nextFunctionName) pendingFunction.name = nextFunctionName;
+			if (functionCall.arguments) pendingFunction.arguments = (pendingFunction.arguments ?? "") + functionCall.arguments;
+		}
+		if (!pendingLegacyToolCall) return leadingDeltas.length > 0 ? leadingDeltas : [{
+			delta: ordinaryDelta,
+			toolCalls: []
+		}];
+		if (finishReason === "function_call") {
+			const confirmedLegacyToolCall = pendingLegacyToolCall;
+			pendingLegacyToolCall = void 0;
+			pendingLegacyArgumentBytes = 0;
+			return [
+				...leadingDeltas,
+				{
+					delta: {},
+					toolCalls: [confirmedLegacyToolCall]
+				},
+				...takePendingFollowingDeltas()
+			];
+		}
+		if (finishReason) {
+			pendingLegacyArgumentBytes = 0;
+			pendingLegacyToolCall = void 0;
+			return [...leadingDeltas, ...takePendingFollowingDeltas()];
+		}
+		return leadingDeltas;
+	};
+}
+/** Publish only executable calls; streaming scratch state never belongs in replay. */
+function finalizeOpenAICompletionsToolCalls(output, options = {}) {
+	const isToolCall = (block) => block.type === "toolCall";
+	const hasToolCalls = output.content.some(isToolCall);
+	if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
+	if (output.stopReason === "stop" && hasToolCalls && options.allowSilentToolCallPromotion !== false && !output.content.some((block) => {
+		const candidate = block;
+		return candidate.type === "text" && typeof candidate.text === "string" && candidate.text.trim().length > 0;
+	})) output.stopReason = "toolUse";
+	if (output.stopReason !== "toolUse") {
+		if (hasToolCalls) output.content = output.content.filter((block) => !isToolCall(block));
+		return;
+	}
+	for (const block of output.content) {
+		if (!isToolCall(block)) continue;
+		const toolCall = block;
+		let completeArguments;
+		try {
+			completeArguments = typeof toolCall.partialArgs === "string" && toolCall.partialArgs.trim().length > 0 ? JSON.parse(toolCall.partialArgs) : void 0;
+		} catch {
+			completeArguments = void 0;
+		}
+		if (typeof toolCall.name !== "string" || toolCall.name.trim().length === 0 || !isRecord(completeArguments)) {
+			output.stopReason = "error";
+			output.errorMessage = "Provider returned an incomplete or malformed tool call";
+			output.content = output.content.filter((candidate) => !isToolCall(candidate));
+			return;
+		}
+		toolCall.arguments = completeArguments;
+	}
+	for (let contentIndex = 0; contentIndex < output.content.length; contentIndex += 1) {
+		const block = output.content[contentIndex];
+		if (!block || !isToolCall(block)) continue;
+		delete block.partialArgs;
+		delete block.streamIndex;
+		options.onConfirmedToolCall?.(block, contentIndex);
+	}
+}
 //#endregion
 //#region packages/ai/src/openai-completions-messages.ts
 const EMPTY_TOOL_RESULT_TEXT = "(no output)";
@@ -191,15 +351,19 @@ function sanitizeToolResultText(text, fallback) {
 	const sanitized = sanitizeSurrogates(text);
 	return sanitized.trim().length > 0 ? sanitized : fallback;
 }
+/** Whether replayed messages require a tools marker for proxy compatibility. */
+function hasToolCallHistory(messages) {
+	return messages.some((message) => message.role === "toolResult" || message.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "toolCall"));
+}
 /** Convert a normalized transcript to OpenAI Chat Completions messages. */
 function convertMessages(model, context, compat, options = {}) {
 	const params = [];
 	const normalizeToolCallId = (id) => {
 		if (id.includes("|")) return id.slice(0, id.indexOf("|")).replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
-		if (model.provider === "openai") return id.length > 40 ? id.slice(0, 40) : id;
+		if (model.provider === "openai") return id.length > 40 ? truncateUtf16Safe(id, 40) : id;
 		return id;
 	};
-	const transformedMessages = transformMessages(context.messages, model, (id) => normalizeToolCallId(id));
+	const transformedMessages = transformProviderMessages(context.messages, model, (id) => normalizeToolCallId(id));
 	if (context.systemPrompt) {
 		const role = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
 		const systemPrompt = options.preserveSystemPromptCacheBoundary ? context.systemPrompt : stripSystemPromptCacheBoundary(context.systemPrompt);
@@ -231,6 +395,10 @@ function convertMessages(model, context, compat, options = {}) {
 						type: "text",
 						text: sanitizeSurrogates(item.text)
 					};
+					if (item.type === "video") return {
+						type: "video_url",
+						video_url: { url: `data:${item.mimeType};base64,${item.data}` }
+					};
 					return {
 						type: "image_url",
 						image_url: { url: `data:${item.mimeType};base64,${item.data}` }
@@ -253,7 +421,7 @@ function convertMessages(model, context, compat, options = {}) {
 				type: "text",
 				text: sanitizeSurrogates(block.text)
 			}));
-			const assistantText = assistantTextParts.map((part) => part.text).join("");
+			const assistantText = assistantTextParts.map((part) => part.text).join("\n");
 			const nonEmptyThinkingBlocks = msg.content.filter(isThinkingContentBlock).filter((block) => block.thinking.trim().length > 0);
 			if (nonEmptyThinkingBlocks.length > 0) if (compat.requiresThinkingAsText) assistantMsg.content = [{
 				type: "text",
@@ -338,6 +506,33 @@ function convertMessages(model, context, compat, options = {}) {
 	return params;
 }
 //#endregion
+//#region packages/ai/src/transports/openai-reasoning-compat.ts
+/**
+* OpenAI reasoning-effort compatibility helpers.
+*
+* Keeps provider metadata and built-in model exceptions on one path before request payloads are built.
+*/
+const OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS = /* @__PURE__ */ new Set(["gpt-5.1-codex-mini"]);
+function readCompatReasoningEffortMap(compat) {
+	const rawMap = asOptionalObjectRecord(asOptionalObjectRecord(compat)?.reasoningEffortMap);
+	if (!rawMap) return {};
+	return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string"));
+}
+/** Resolves the reasoning effort remap for an OpenAI-compatible model. */
+function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
+	const provider = normalizeLowercaseStringOrEmpty(model.provider ?? "");
+	const id = normalizeLowercaseStringOrEmpty(model.id ?? "");
+	const builtinMap = provider === "openai" && OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS.has(id) ? {
+		minimal: "medium",
+		low: "medium"
+	} : {};
+	return {
+		...fallbackMap,
+		...builtinMap,
+		...readCompatReasoningEffortMap(model.compat)
+	};
+}
+//#endregion
 //#region packages/ai/src/providers/openai-stop-reason.ts
 function mapOpenAIStopReason(reason, options) {
 	if (reason === null) return { stopReason: "stop" };
@@ -365,32 +560,4 @@ function mapOpenAIStopReason(reason, options) {
 	};
 }
 //#endregion
-//#region packages/ai/src/transports/openai-reasoning-compat.ts
-/**
-* OpenAI reasoning-effort compatibility helpers.
-*
-* Keeps provider metadata and built-in model exceptions on one path before request payloads are built.
-*/
-const OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS = /* @__PURE__ */ new Set(["gpt-5.1-codex-mini"]);
-function readCompatReasoningEffortMap(compat) {
-	if (!compat || typeof compat !== "object") return {};
-	const rawMap = compat.reasoningEffortMap;
-	if (!rawMap || typeof rawMap !== "object") return {};
-	return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string"));
-}
-/** Resolves the reasoning effort remap for an OpenAI-compatible model. */
-function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
-	const provider = normalizeLowercaseStringOrEmpty(model.provider ?? "");
-	const id = normalizeLowercaseStringOrEmpty(model.id ?? "");
-	const builtinMap = provider === "openai" && OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS.has(id) ? {
-		minimal: "medium",
-		low: "medium"
-	} : {};
-	return {
-		...fallbackMap,
-		...builtinMap,
-		...readCompatReasoningEffortMap(model.compat)
-	};
-}
-//#endregion
-export { resolveOpenAICompletionsCompat as a, clearPendingCommentaryText as c, detectOpenAICompletionsCompat as i, rememberPendingCommentaryTags as l, mapOpenAIStopReason as n, resolveOpenAICompletionsResponseFormat as o, convertMessages as r, shouldOmitOllamaCompatResponseFormat as s, resolveOpenAIReasoningEffortMap as t, tagPendingCommentaryText as u };
+export { createOpenAICompletionsToolCallDeltaNormalizer as a, resolveOpenAICompletionsCompat as c, clearPendingCommentaryText as d, rememberPendingCommentaryTags as f, hasToolCallHistory as i, resolveOpenAICompletionsResponseFormat as l, resolveOpenAIReasoningEffortMap as n, finalizeOpenAICompletionsToolCalls as o, tagPendingCommentaryText as p, convertMessages as r, detectOpenAICompletionsCompat as s, mapOpenAIStopReason as t, shouldOmitOllamaCompatResponseFormat as u };

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

@@ -0,0 +1,338 @@
+import { n as applyProviderReportedUsageCost, r as calculateCost } from "./sanitize-unicode-BYqrYtC_.mjs";
+import { n as getAiTransportHost } from "./host-DTqNc7ad.mjs";
+import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
+import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-q5d7QX5c.mjs";
+import { t as headersToRecord } from "./headers-DdOQtGuU.mjs";
+import { f as transportAbortError } from "./provider-transcript-transform-ePx-Bbfr.mjs";
+//#region packages/ai/src/transports/openai-transport-shared.ts
+/** Shared options, usage shape, cache identity, ordering, and stream scheduling for OpenAI APIs. */
+const MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS = 12;
+const MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS = 64;
+const GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP = "skip_thought_signature_validator";
+const log = {
+	debug(message, data) {
+		getAiTransportHost().logDebug("openai-transport", () => ({
+			message,
+			data
+		}));
+	},
+	info(message, data) {
+		getAiTransportHost().logInfo("openai-transport", message, data);
+	},
+	warn(message, data) {
+		getAiTransportHost().logWarn("openai-transport", message, data);
+	}
+};
+function parseOpenAICompletionsUsage(rawUsage, model, options) {
+	const cacheRead = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
+	const cacheWrite = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
+	const input = Math.max(0, (rawUsage.prompt_tokens || 0) - cacheRead - cacheWrite);
+	const output = rawUsage.completion_tokens || 0;
+	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
+	const usage = {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		...options?.includeReasoningTokens !== false && typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? { reasoningTokens } : {},
+		totalTokens: input + output + cacheRead + cacheWrite,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+	calculateCost(model, usage);
+	applyProviderReportedUsageCost(usage, rawUsage.cost);
+	return usage;
+}
+function createOpenAIResponseHook(onResponse, response, model) {
+	return onResponse ? () => onResponse({
+		status: response.status,
+		headers: headersToRecord(response.headers)
+	}, model) : void 0;
+}
+function throwIfModelStreamAborted(signal) {
+	if (signal?.aborted) throw transportAbortError(signal);
+}
+/** Measure one UTF-8 append without double-counting a surrogate pair split across chunks. */
+function measureUtf8AppendBytes(bufferEndsWithHighSurrogate, chunk) {
+	let bytes = Buffer.byteLength(chunk, "utf8");
+	if (!chunk) return {
+		bytes,
+		endsWithHighSurrogate: bufferEndsWithHighSurrogate
+	};
+	const nextCodeUnit = chunk.charCodeAt(0);
+	if (bufferEndsWithHighSurrogate && nextCodeUnit >= 56320 && nextCodeUnit <= 57343) bytes -= 2;
+	const finalCodeUnit = chunk.charCodeAt(chunk.length - 1);
+	return {
+		bytes,
+		endsWithHighSurrogate: finalCodeUnit >= 55296 && finalCodeUnit <= 56319
+	};
+}
+function createModelStreamCooperativeScheduler(signal) {
+	let lastYieldedAt = Date.now();
+	let eventsSinceYield = 0;
+	return { async afterEvent() {
+		throwIfModelStreamAborted(signal);
+		eventsSinceYield += 1;
+		const now = Date.now();
+		if (eventsSinceYield < MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS && now - lastYieldedAt < MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS) return;
+		eventsSinceYield = 0;
+		lastYieldedAt = now;
+		await new Promise((resolve) => {
+			setTimeout(resolve, 0);
+		});
+		throwIfModelStreamAborted(signal);
+	} };
+}
+function resolvePromptCacheKey(options, cacheRetention) {
+	if (cacheRetention === "none") return;
+	return clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId);
+}
+function isOpenAICompletionsThinkingEnabled(effort) {
+	const normalized = effort.trim().toLowerCase();
+	return normalized !== "off" && normalized !== "none";
+}
+function readOpenAICompletionsContentDeltas(content, topLevelRefusal, mirroredThinking = []) {
+	let deltas = readOpenAICompletionsContentPartDeltas(content);
+	if (mirroredThinking.length > 0) {
+		const structuredThinking = deltas.filter((delta) => delta.kind === "thinking").map((delta) => delta.text);
+		const mirrorsCombinedThinking = structuredThinking.length > 1 && mirroredThinking.includes(structuredThinking.join(""));
+		deltas = deltas.filter((delta) => delta.kind !== "thinking" || !mirrorsCombinedThinking && !mirroredThinking.includes(delta.text));
+	}
+	if (typeof topLevelRefusal !== "string" || !topLevelRefusal) return deltas;
+	const structuredRefusals = deltas.filter((delta) => delta.kind === "text" && delta.source === "refusal").map((delta) => delta.text);
+	if (structuredRefusals.some((refusal) => refusal === topLevelRefusal) || structuredRefusals.length > 1 && structuredRefusals.join("") === topLevelRefusal) return deltas;
+	return [...deltas, {
+		kind: "text",
+		text: topLevelRefusal,
+		source: "refusal"
+	}];
+}
+function readOpenAICompletionsContentPartDeltas(content) {
+	if (typeof content === "string") return content ? [{
+		kind: "text",
+		text: content
+	}] : [];
+	if (Array.isArray(content)) return content.flatMap(readOpenAICompletionsContentPartDeltas);
+	if (!content || typeof content !== "object") return [];
+	const record = content;
+	const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+	const extractText = (value) => {
+		if (typeof value === "string") return value;
+		if (Array.isArray(value)) return value.map(extractText).join("");
+		if (value && typeof value === "object") {
+			const nested = value;
+			return extractText(nested.text ?? nested.content ?? nested.thinking ?? nested.refusal);
+		}
+		return "";
+	};
+	const text = extractText(record.text ?? record.content ?? record.thinking ?? record.refusal);
+	if (!text) return [];
+	if (type.includes("thinking") || type.includes("reasoning")) return [{
+		kind: "thinking",
+		text
+	}];
+	if (type === "refusal") return [{
+		kind: "text",
+		text,
+		source: "refusal"
+	}];
+	if (["text", "output_text"].includes(type) || type.endsWith(".output_text")) return [{
+		kind: "text",
+		text
+	}];
+	return [];
+}
+//#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 { createModelStreamCooperativeScheduler as a, log as c, readOpenAICompletionsContentDeltas as d, resolvePromptCacheKey as f, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as i, measureUtf8AppendBytes as l, reconcileOpenAICompletionsToolChoice as n, createOpenAIResponseHook as o, throwIfModelStreamAborted as p, reconcileOpenAIResponsesToolChoice as r, isOpenAICompletionsThinkingEnabled as s, projectOpenAITools as t, parseOpenAICompletionsUsage as u };