@openclaw/ai 2026.9.1 → 2026.9.3

package/dist/{openai-completions-stream-DZjwK8vp.mjs → openai-completions-stream-BQk3SkLD.mjs}

@@ -1,72 +1,29 @@
-import { c as normalizeLowercaseStringOrEmpty, i as asOptionalObjectRecord, o as isRecord, t as truncateUtf16Safe } from "./utf16-slice-qz3nsy87.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-S6binQG-.mjs";
-import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, n as getAiTransportHost } from "./host-BIaiBURL.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { d as stripSystemPromptCacheBoundary } from "./simple-options-0PLDyJ-d.mjs";
-import { o as resolveProviderRequestCapabilities, r as resolveModelRequestTimeoutMs, s as resolveProviderRequestPolicyConfig } from "./tool-schema-json-projection-BtZiml7r.mjs";
-import { i as isCodeModeModelVisibleToolName, p as sha256Hex } from "./transport-utils-CtuS1Upe.mjs";
-import { s as finalizeTerminalToolCallArguments } from "./transport-stream-shared-CytPVLIg.mjs";
-import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-BuAJEbdW.mjs";
+import { r as appendAssistantThinking } from "./event-stream-D8PARQfL.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-Bb-v9meu.mjs";
+import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload } from "./host-CWuF-sS3.mjs";
+import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
+import { d as shouldOmitOllamaCompatResponseFormat, i as detectOpenAICompletionsCompat, r as resolveOpenAIPromptCacheParams, u as resolveOpenAICompletionsResponseFormat } from "./openai-prompt-cache-BI0rkM-5.mjs";
+import { r as emitModelTransportDebug } from "./diagnostics-dV98PqIy.mjs";
+import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-BQBi4B9d.mjs";
+import { i as asNonNegativeFiniteNumber } from "./base64-D-su8YVo.mjs";
+import { l as supportsModelTools, r as estimateStringChars } from "./transport-utils-CCooe-cr.mjs";
+import { n as uniqueStrings } from "./string-normalization-CmLIasuf.mjs";
+import { i as resolveProviderEndpoint, r as resolveOpenAIStrictToolSetting } from "./host-policy-CAopLRKA.mjs";
+import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
+import { d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, u as splitSystemPromptCacheBoundary } from "./simple-options-tcKOqnpF.mjs";
+import { C as readOpenAICompletionsContentDeltas, D as throwIfModelStreamAborted, E as resolvePromptCacheKey, S as parseOpenAICompletionsUsage, b as log, d as resolveOpenAIReasoningEffortMap, f as projectOpenAITools, g as createModelStreamCooperativeScheduler, h as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, p as reconcileOpenAICompletionsToolChoice, s as getCompat, u as resolveOpenAIStrictToolFlagWithDiagnostics, w as readOpenAICompletionsReasoningBatch, x as measureUtf8AppendBytes, y as isOpenAICompletionsThinkingEnabled } from "./openai-transport-params-DNasp2fU.mjs";
+import { s as finalizeTerminalToolCallArguments } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+import { a as tagUnresolvedTextAsCommentary, i as tagPendingCommentaryText, n as rememberPendingCommentaryTags, r as tagInterruptedTextPhases, t as clearPendingCommentaryText } from "./assistant-text-phase-C20rxWwP.mjs";
+import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-Dw_hnxsA.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { A as readOpenAICompletionsReasoningBatch, D as measureUtf8AppendBytes, N as throwIfModelStreamAborted, O as parseOpenAICompletionsUsage, S as createModelStreamCooperativeScheduler, T as isOpenAICompletionsThinkingEnabled, a as resolveOpenAIProjectedToolsStrictToolFlag, k as readOpenAICompletionsContentDeltas, t as findOpenAIStrictToolProjectionDiagnostics } from "./openai-tool-schema-BMiHFH36.mjs";
-import { a as withFirstStreamEventTimeout } from "./stream-first-event-timeout-DcNjoFQE.mjs";
-import { t as transformProviderMessages } from "./provider-transcript-transform-WvJmFUAf.mjs";
+import { a as withFirstStreamEventTimeout } from "./stream-first-event-timeout-2hfrquuz.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-pPmUIwKt.mjs";
+import { n as isOpenAIGpt55Model, o as resolveOpenAIReasoningEffortForModel, r as isOpenAIGpt56Model, t as isOpenAIGpt54MiniModel } from "./openai-reasoning-effort-BK7FbcLT.mjs";
+import { r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-CzjyYXun.mjs";
+import { isGoogleGemini3FlashModel, isGoogleGemini3ProModel } from "./internal/google-model-family.mjs";
 import { t as mapOpenAIStopReason } from "./openai-stop-reason-Drnn_6Qj.mjs";
-import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-C-4uedDb.mjs";
 import { randomUUID } from "node:crypto";
-//#region packages/ai/src/utils/assistant-text-phase.ts
-const EMPTY_ASSISTANT_TEXT_BLOCK_SET = /* @__PURE__ */ new Set();
-function isAssistantTextPhaseBlock(block) {
-	if (!block || typeof block !== "object") return false;
-	const record = block;
-	return record.type === "text" && typeof record.text === "string";
-}
-function encodeAssistantTextSignatureV1(id, phase) {
-	return JSON.stringify({
-		v: 1,
-		id,
-		...phase ? { phase } : {}
-	});
-}
-function tagUnphasedText(content, phase, idPrefix) {
-	const textBlocks = content.filter(isAssistantTextPhaseBlock);
-	let phaseIndex = textBlocks.filter((block) => block.textSignature !== void 0).length;
-	const tagged = /* @__PURE__ */ new Map();
-	for (const block of textBlocks) {
-		if (block.text.trim().length === 0 || block.textSignature !== void 0) continue;
-		const signature = encodeAssistantTextSignatureV1(`${idPrefix}-${phaseIndex}-${randomUUID().replaceAll("-", "").slice(0, 24)}`, phase);
-		block.textSignature = signature;
-		tagged.set(block, signature);
-		phaseIndex += 1;
-	}
-	return tagged;
-}
-/** Tags unphased narration before a tool-call event becomes consumer-visible. */
-function tagPendingCommentaryText(content) {
-	return tagUnphasedText(content, "commentary", "commentary");
-}
-/** Records the confirmed final-answer boundary after reasoning resumes. */
-function tagInterruptedTextPhases(content, interruptedText, preservedVisibleText = EMPTY_ASSISTANT_TEXT_BLOCK_SET) {
-	const interruptedTextIndex = content.indexOf(interruptedText);
-	if (interruptedTextIndex === -1) return;
-	const finalAnswerIndex = content.findIndex((block, index) => index > interruptedTextIndex && isAssistantTextPhaseBlock(block) && block.text.trim().length > 0);
-	if (finalAnswerIndex === -1) return;
-	tagUnphasedText(content.slice(0, finalAnswerIndex).filter((block) => !preservedVisibleText.has(block)), "commentary", "commentary");
-	tagUnphasedText(content.filter((block, index) => index >= finalAnswerIndex || preservedVisibleText.has(block)), "final_answer", "final-answer");
-}
-/** Prevents unresolved completion text from becoming a fallback answer after stream failure. */
-function tagUnresolvedTextAsCommentary(message) {
-	if (message.openclawDelivery?.textPhaseRequiresTerminal) tagUnphasedText(message.content, "commentary", "commentary");
-}
-/** Rolls back only the exact provisional signatures created by this transport turn. */
-function clearPendingCommentaryText(tags) {
-	for (const [block, signature] of tags) if (block.textSignature === signature) delete block.textSignature;
-	tags.clear();
-}
-function rememberPendingCommentaryTags(target, tagged) {
-	for (const [block, signature] of tagged) target.set(block, signature);
-}
-//#endregion
 //#region packages/ai/src/transports/deepseek-dsml-grammar.ts
 const DEEPSEEK_DSML_MARKERS = [
 	"|",
@@ -162,141 +119,132 @@ function longestDsmlOpenPrefixSuffixLength(text) {
 	return 0;
 }
 //#endregion
-//#region packages/ai/src/providers/openai-response-format.ts
-const JSON_SCHEMA_RESPONSE_FORMAT_NAME = "openclaw_response";
-const OLLAMA_CLOUD_ORIGIN = "https://ollama.com";
-function isKnownOpenAIJsonSchemaModelId(modelId) {
-	if (typeof modelId !== "string") return false;
-	if (/^gpt-5(?:[.-]|$)/i.test(modelId) || /^gpt-4\.1(?:-|$)/i.test(modelId)) return true;
-	const gpt4o = /^gpt-4o(-mini)?(?:-(\d{4}-\d{2}-\d{2}))?$/i.exec(modelId);
-	if (gpt4o) {
-		const snapshot = gpt4o[2];
-		return !snapshot || snapshot >= (gpt4o[1] ? "2024-07-18" : "2024-08-06");
-	}
-	return /^(?:o1|o3(?:-mini|-pro)?|o4-mini)(?:-\d{4}-\d{2}-\d{2})?$/i.test(modelId);
-}
-function shouldOmitOllamaCompatResponseFormat(params) {
-	if (!params.provider.includes("ollama")) return false;
-	if (params.hasTools()) return true;
-	try {
-		return new URL(params.baseUrl).origin === OLLAMA_CLOUD_ORIGIN;
-	} catch {
-		return false;
+//#region packages/ai/src/transports/model-max-tokens-params.ts
+/**
+* Max-token parameter normalization across provider/native naming variants.
+* Callers canonicalize aliases before dispatch so payloads cannot carry
+* conflicting limits.
+*/
+const MAX_TOKENS_PARAM_KEYS = [
+	"maxTokens",
+	"max_completion_tokens",
+	"max_tokens"
+];
+/** Resolve the first supported max-token parameter present in a params object. */
+function resolveMaxTokensParam(params) {
+	if (!params) return;
+	for (const key of MAX_TOKENS_PARAM_KEYS) {
+		const resolved = asNonNegativeFiniteNumber(params[key]);
+		if (resolved !== void 0) return resolved;
 	}
 }
 /**
-* Maps the shared JSON Schema option to Chat Completions while preserving the
-* older provider-shaped json_object/json_schema inputs accepted by model params.
+* Canonicalize merged params to `maxTokens`, preserving source precedence from
+* left to right across the provided source objects.
 */
-function resolveOpenAICompletionsResponseFormat(responseFormat, supportsJsonSchemaResponseFormat) {
-	if (!responseFormat) return;
-	if (responseFormat.type === "json_object") return responseFormat;
-	if (responseFormat.type === "text") return responseFormat;
-	if (responseFormat.type === "json_schema" && isRecord(responseFormat.json_schema)) return responseFormat;
-	if (!supportsJsonSchemaResponseFormat) return;
-	return {
-		type: "json_schema",
-		json_schema: {
-			name: JSON_SCHEMA_RESPONSE_FORMAT_NAME,
-			schema: responseFormat
-		}
-	};
+function canonicalizeMaxTokensParam(params) {
+	let resolved;
+	for (const source of params.sources) {
+		const sourceValue = resolveMaxTokensParam(source);
+		if (sourceValue !== void 0) resolved = sourceValue;
+	}
+	if (resolved === void 0) return;
+	for (const key of MAX_TOKENS_PARAM_KEYS) delete params.merged[key];
+	params.merged.maxTokens = resolved;
 }
 //#endregion
-//#region packages/ai/src/transports/openai-completions-compat.ts
-function isDefaultRouteProvider(provider, ...ids) {
-	return provider !== void 0 && ids.includes(provider);
-}
-/** Resolves default request flags for an OpenAI-compatible completions endpoint. */
-function resolveOpenAICompletionsCompatDefaults(input) {
-	const { provider, modelId, endpointClass, knownProviderFamily, supportsNativeStreamingUsageCompat = false, supportsOpenAICompletionsStreamingUsageCompat = false, usesExplicitProxyLikeEndpoint = false } = input;
-	const isDefaultRoute = endpointClass === "default";
-	const usesConfiguredNonOpenAIEndpoint = endpointClass !== "default" && endpointClass !== "openai-public";
-	const isMoonshot = knownProviderFamily === "moonshot" || endpointClass === "moonshot-native";
-	const isMoonshotLike = isMoonshot || knownProviderFamily === "modelstudio" || endpointClass === "modelstudio-native";
-	const isModelStudioLike = knownProviderFamily === "modelstudio" || endpointClass === "modelstudio-native" || isDefaultRoute && isDefaultRouteProvider(provider, "dashscope", "modelstudio", "qwen");
-	const isZai = endpointClass === "zai-native" || isDefaultRoute && isDefaultRouteProvider(input.provider, "zai");
-	const isDeepSeek = endpointClass === "deepseek-native" || isDefaultRoute && isDefaultRouteProvider(input.provider, "deepseek");
-	const isTogether = knownProviderFamily === "together" || input.baseUrl?.includes("api.together.ai") === true || input.baseUrl?.includes("api.together.xyz") === true || isDefaultRoute && isDefaultRouteProvider(input.provider, "together");
-	const isCloudflareAiGateway = provider === "cloudflare-ai-gateway" || input.baseUrl?.includes("gateway.ai.cloudflare.com") === true;
-	const isXiaomi = endpointClass === "xiaomi-native" || isDefaultRoute && isDefaultRouteProvider(input.provider, "xiaomi");
-	const isNonStandard = endpointClass === "cerebras-native" || endpointClass === "chutes-native" || endpointClass === "deepseek-native" || endpointClass === "mistral-public" || endpointClass === "opencode-native" || endpointClass === "opencode-go-native" || endpointClass === "xai-native" || isXiaomi || isZai || isDefaultRoute && isDefaultRouteProvider(input.provider, "cerebras", "chutes", "deepseek", "opencode", "xai");
-	const isOpenRouterLike = input.provider === "openrouter" || endpointClass === "openrouter";
-	const isLocalEndpoint = endpointClass === "local";
-	const usesMaxTokens = endpointClass === "chutes-native" || endpointClass === "mistral-public" || knownProviderFamily === "mistral" || isMoonshot || isCloudflareAiGateway || isZai || isTogether || isDefaultRoute && isDefaultRouteProvider(provider, "chutes");
+//#region packages/ai/src/transports/openai-completions-cache-control.ts
+const shapedPayloads = /* @__PURE__ */ new WeakSet();
+function resolveCompletionsCacheControl(compat, retention, openRouterRoute) {
+	if (compat.cacheControlFormat !== "anthropic" || retention === "none") return;
 	return {
-		supportsStore: !isNonStandard && knownProviderFamily !== "mistral" && !usesExplicitProxyLikeEndpoint,
-		supportsDeveloperRole: !isNonStandard && !isMoonshotLike && !usesConfiguredNonOpenAIEndpoint,
-		supportsReasoningEffort: !isZai && !isTogether && knownProviderFamily !== "mistral" && endpointClass !== "xai-native" && !usesExplicitProxyLikeEndpoint,
-		supportsUsageInStreaming: supportsOpenAICompletionsStreamingUsageCompat || !isNonStandard && (isLocalEndpoint || !usesConfiguredNonOpenAIEndpoint || supportsNativeStreamingUsageCompat),
-		maxTokensField: usesMaxTokens ? "max_tokens" : "max_completion_tokens",
-		thinkingFormat: isDeepSeek || isXiaomi ? "deepseek" : isZai ? "zai" : isTogether ? "together" : isOpenRouterLike ? "openrouter" : "openai",
-		visibleReasoningDetailTypes: isOpenRouterLike ? ["response.output_text", "response.text"] : [],
-		supportsStrictMode: !isZai && !usesConfiguredNonOpenAIEndpoint,
-		supportsJsonSchemaResponseFormat: (endpointClass === "openai-public" || isDefaultRoute && isDefaultRouteProvider(provider, "openai")) && isKnownOpenAIJsonSchemaModelId(modelId),
-		requiresReasoningContentOnAssistantMessages: isDeepSeek || isXiaomi,
-		requiresNonEmptyUserOrAssistantMessage: isModelStudioLike,
-		cacheControlFormat: isModelStudioLike && endpointClass !== "custom" || provider === "openrouter" && modelId?.startsWith("anthropic/") === true ? "anthropic" : void 0,
-		sessionAffinityFormat: isOpenRouterLike ? "openrouter" : "openai",
-		supportsLongCacheRetention: !isModelStudioLike && provider !== "cloudflare-workers-ai" && provider !== "cloudflare-ai-gateway" && knownProviderFamily !== "together" && !input.baseUrl?.includes("api.cloudflare.com") && !input.baseUrl?.includes("gateway.ai.cloudflare.com") && !input.baseUrl?.includes("api.together.ai") && !input.baseUrl?.includes("api.together.xyz")
+		type: "ephemeral",
+		...retention === "long" && compat.supportsLongCacheRetention && (openRouterRoute || compat.configuredSupportsLongCacheRetention === true) ? { ttl: "1h" } : {}
 	};
 }
-function resolveOpenAICompletionsCompatDefaultsFromCapabilities(input) {
-	return resolveOpenAICompletionsCompatDefaults(input);
-}
-/** Detects endpoint capabilities and defaults for an OpenAI-completions model. */
-function detectOpenAICompletionsCompat(model, resolveCapabilities) {
-	const capabilities = (resolveCapabilities ?? ((input) => resolveProviderRequestCapabilities(input, model)))({
-		provider: model.provider,
-		api: "openai-completions",
-		baseUrl: model.baseUrl,
-		capability: "llm",
-		transport: "stream",
-		modelId: model.id,
-		compat: model.compat && typeof model.compat === "object" ? model.compat : void 0
-	});
-	return {
-		capabilities,
-		defaults: resolveOpenAICompletionsCompatDefaultsFromCapabilities({
-			provider: model.provider,
-			modelId: model.id,
-			baseUrl: model.baseUrl,
-			...capabilities
-		})
+/** Shared Chat Completions policy; repeated wrapper application preserves existing checkpoints. */
+function applyCompletionsAnthropicCacheControl(payload, cacheControl = { type: "ephemeral" }, cacheOptOutIndexes = /* @__PURE__ */ new Set(), markTools = true, markMessages = true) {
+	if (shapedPayloads.has(payload)) return;
+	shapedPayloads.add(payload);
+	const messages = Array.isArray(payload.messages) ? payload.messages : [];
+	const tools = Array.isArray(payload.tools) ? payload.tools.filter(isRecord) : [];
+	const blocks = messages.filter(isRecord).flatMap((message) => Array.isArray(message.content) ? message.content.filter(isRecord) : []);
+	for (const block of [...tools, ...blocks]) delete block.cache_control;
+	if (!cacheControl) return;
+	const markText = (message, splitBoundary) => {
+		if (typeof message.content === "string" && message.content) message.content = [{
+			type: "text",
+			text: message.content
+		}];
+		const content = message.content;
+		if (!Array.isArray(content)) return false;
+		for (let i = content.length - 1; i >= 0; i--) {
+			const block = content[i];
+			if (!isRecord(block) || block.type !== "text" || typeof block.text !== "string" || !block.text) continue;
+			const split = splitBoundary ? splitSystemPromptCacheBoundary(block.text) : void 0;
+			if (split) {
+				content.splice(i, 1, ...split.stablePrefix ? [{
+					type: "text",
+					text: split.stablePrefix,
+					cache_control: cacheControl
+				}] : [], ...split.dynamicSuffix ? [{
+					type: "text",
+					text: split.dynamicSuffix
+				}] : []);
+				if (!split.stablePrefix) return false;
+			} else block.cache_control = cacheControl;
+			return true;
+		}
+		return false;
 	};
+	const lastTool = tools.at(-1);
+	if (markTools && lastTool) lastTool.cache_control = cacheControl;
+	if (!markMessages) return;
+	const system = messages.find((message) => isRecord(message) && (message.role === "system" || message.role === "developer"));
+	if (isRecord(system)) markText(system, true);
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (!cacheOptOutIndexes.has(i) && isRecord(message) && (message.role === "user" || message.role === "tool") && markText(message, false)) return;
+	}
 }
-function resolveSessionAffinity(model, detectedFormat) {
-	if (model.compat?.sendSessionAffinityHeaders !== true) return "none";
-	if (detectedFormat === "openrouter" || model.compat.thinkingFormat === "openrouter" || model.compat.openRouterRouting !== void 0) return "openrouter";
-	return "openai";
+//#endregion
+//#region packages/ai/src/transports/openai-completions-string-content.ts
+/**
+* OpenAI Chat Completions compatibility helpers. Some providers only accept
+* role/content messages with plain string content instead of text block arrays.
+*/
+function flattenStringOnlyCompletionContent(content) {
+	if (!Array.isArray(content)) return content;
+	const textParts = [];
+	for (const item of content) {
+		if (!item || typeof item !== "object" || item.type !== "text" || typeof item.text !== "string") return content;
+		textParts.push(item.text);
+	}
+	return textParts.join("\n");
+}
+/** Flatten string-only text block content arrays into newline-joined strings. */
+function flattenCompletionMessagesToStringContent(messages) {
+	return messages.map((message) => {
+		if (!message || typeof message !== "object") return message;
+		const content = message.content;
+		const flattenedContent = flattenStringOnlyCompletionContent(content);
+		if (flattenedContent === content) return message;
+		return {
+			...message,
+			content: flattenedContent
+		};
+	});
 }
-/** Applies explicit model overrides once on top of the canonical transport defaults. */
-function resolveOpenAICompletionsCompat(model, resolveCapabilities) {
-	const { defaults } = detectOpenAICompletionsCompat(model, resolveCapabilities);
-	const configured = model.compat;
-	return {
-		supportsStore: configured?.supportsStore ?? defaults.supportsStore,
-		supportsDeveloperRole: configured?.supportsDeveloperRole ?? defaults.supportsDeveloperRole,
-		supportsReasoningEffort: configured?.supportsReasoningEffort ?? defaults.supportsReasoningEffort,
-		supportsUsageInStreaming: configured?.supportsUsageInStreaming ?? defaults.supportsUsageInStreaming,
-		maxTokensField: configured?.maxTokensField ?? defaults.maxTokensField,
-		requiresToolResultName: configured?.requiresToolResultName ?? false,
-		requiresAssistantAfterToolResult: configured?.requiresAssistantAfterToolResult ?? false,
-		requiresThinkingAsText: configured?.requiresThinkingAsText ?? false,
-		requiresReasoningContentOnAssistantMessages: configured?.requiresReasoningContentOnAssistantMessages ?? defaults.requiresReasoningContentOnAssistantMessages,
-		thinkingFormat: configured?.thinkingFormat ?? defaults.thinkingFormat,
-		openRouterRouting: configured?.openRouterRouting,
-		vercelGatewayRouting: configured?.vercelGatewayRouting ?? {},
-		zaiToolStream: configured?.zaiToolStream ?? false,
-		supportsStrictMode: configured?.supportsStrictMode ?? defaults.supportsStrictMode,
-		supportsJsonSchemaResponseFormat: configured?.supportsJsonSchemaResponseFormat ?? defaults.supportsJsonSchemaResponseFormat,
-		cacheControlFormat: configured?.cacheControlFormat ?? defaults.cacheControlFormat,
-		sessionAffinity: resolveSessionAffinity(model, defaults.sessionAffinityFormat),
-		supportsPromptCacheKey: configured?.supportsPromptCacheKey ?? false,
-		supportsLongCacheRetention: configured?.supportsLongCacheRetention ?? defaults.supportsLongCacheRetention,
-		visibleReasoningDetailTypes: configured && "visibleReasoningDetailTypes" in configured ? configured.visibleReasoningDetailTypes ?? defaults.visibleReasoningDetailTypes : defaults.visibleReasoningDetailTypes,
-		requiresNonEmptyUserOrAssistantMessage: defaults.requiresNonEmptyUserOrAssistantMessage
-	};
+/** Strip completion messages to role/content fields for strict providers. */
+function stripCompletionMessagesToRoleContent(messages) {
+	return messages.map((message) => {
+		if (!message || typeof message !== "object" || Array.isArray(message)) return message;
+		const record = message;
+		const stripped = {};
+		if (Object.hasOwn(record, "role")) stripped.role = record.role;
+		if (Object.hasOwn(record, "content")) stripped.content = record.content;
+		return stripped;
+	});
 }
 //#endregion
 //#region packages/ai/src/providers/openai-completions-tool-calls.ts
@@ -481,17 +429,18 @@ function finalizeOpenAICompletionsToolCalls(output, options = {}) {
 	}
 }
 //#endregion
+//#region packages/ai/src/transports/openai-completions-host.ts
+/**
+* Chat Completions accepts Azure AI Foundry hosts in addition to traditional
+* Azure OpenAI hosts. Do not replace this with isTraditionalAzureOpenAIHost,
+* which intentionally excludes the .services.ai.azure.com Foundry suffix.
+*/
+function isAzureOpenAICompatibleHost(hostname) {
+	return hostname.endsWith(".openai.azure.com") || hostname.endsWith(".services.ai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com");
+}
+//#endregion
 //#region packages/ai/src/openai-completions-messages.ts
 const EMPTY_TOOL_RESULT_TEXT = "(no output)";
-function isTextContentBlock(block) {
-	return block.type === "text";
-}
-function isThinkingContentBlock(block) {
-	return block.type === "thinking";
-}
-function isToolCallBlock(block) {
-	return block.type === "toolCall";
-}
 function sanitizeToolResultText(text, fallback) {
 	const sanitized = sanitizeSurrogates(text);
 	return sanitized.trim().length > 0 ? sanitized : fallback;
@@ -562,25 +511,30 @@ function convertMessages(model, context, compat, options = {}) {
 				role: "assistant",
 				content: compat.requiresAssistantAfterToolResult ? "" : null
 			};
-			const assistantTextParts = msg.content.filter(isTextContentBlock).filter((block) => block.text.trim().length > 0).map((block) => ({
+			const assistantTexts = [];
+			const nonEmptyThinkingBlocks = [];
+			const toolCalls = [];
+			msg.content.forEach((block) => {
+				if (block.type === "text" && block.text.trim().length > 0) assistantTexts.push(sanitizeSurrogates(block.text));
+				else if (block.type === "thinking" && block.thinking.trim().length > 0) nonEmptyThinkingBlocks.push(block);
+				else if (block.type === "toolCall") toolCalls.push(block);
+			});
+			if (nonEmptyThinkingBlocks.length > 0 && compat.requiresThinkingAsText) assistantMsg.content = [{
 				type: "text",
-				text: sanitizeSurrogates(block.text)
-			}));
-			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",
-					text: nonEmptyThinkingBlocks.map((block) => sanitizeSurrogates(block.thinking)).join("\n\n")
-				}, ...assistantTextParts];
-				else {
-					if (assistantText.length > 0) assistantMsg.content = assistantText;
+				text: nonEmptyThinkingBlocks.map((block) => sanitizeSurrogates(block.thinking)).join("\n\n")
+			}, ...assistantTexts.map((text) => ({
+				type: "text",
+				text
+			}))];
+			else {
+				const assistantText = assistantTexts.join("\n");
+				if (assistantText.length > 0) assistantMsg.content = assistantText;
+				if (nonEmptyThinkingBlocks.length > 0) {
 					let signature = nonEmptyThinkingBlocks.at(0)?.thinkingSignature;
 					if (model.provider === "opencode-go" && signature === "reasoning") signature = "reasoning_content";
 					if (signature && signature.length > 0) assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join("\n");
 				}
-			} else if (assistantText.length > 0) assistantMsg.content = assistantText;
-			const toolCalls = msg.content.filter(isToolCallBlock);
+			}
 			if (toolCalls.length > 0) {
 				assistantMsg.tool_calls = toolCalls.map((toolCall) => ({
 					id: toolCall.id,
@@ -604,17 +558,17 @@ function convertMessages(model, context, compat, options = {}) {
 			}
 			if (compat.requiresReasoningContentOnAssistantMessages && model.reasoning && assistantMsg.reasoning_content === void 0) assistantMsg.reasoning_content = "";
 			const content = assistantMsg.content;
-			if (!(content !== null && content !== void 0 && (typeof content === "string" ? content.length > 0 : content.length > 0)) && !assistantMsg.tool_calls) continue;
+			if (!(content !== null && content !== void 0 && content.length > 0) && !assistantMsg.tool_calls) continue;
 			params.push(assistantMsg);
 		} else if (msg.role === "toolResult") {
-			const imageBlocks = [];
+			const imageContentParts = [];
 			let j = i;
 			while (j < transformedMessages.length) {
 				const toolMsg = transformedMessages.at(j);
 				if (toolMsg?.role !== "toolResult") break;
 				const textResult = extractToolResultText(toolMsg.content);
 				const mediaPlaceholder = describeToolResultMediaPlaceholder(toolMsg.content);
-				const hasImages = toolMsg.content.some(isImageWithMediaPayload);
+				const images = toolMsg.content.filter(isImageWithMediaPayload);
 				const toolResultMsg = {
 					role: "tool",
 					content: sanitizeToolResultText(textResult, mediaPlaceholder ?? EMPTY_TOOL_RESULT_TEXT),
@@ -622,8 +576,13 @@ function convertMessages(model, context, compat, options = {}) {
 				};
 				if (compat.requiresToolResultName && toolMsg.toolName) toolResultMsg.name = toolMsg.toolName;
 				params.push(toolResultMsg);
-				if (hasImages && model.input.includes("image")) {
-					for (const block of toolMsg.content) if (isImageWithMediaPayload(block)) imageBlocks.push({
+				if (images.length > 0 && model.input.includes("image")) {
+					const boundedToolName = sanitizeSurrogates(truncateUtf16Safe(toolMsg.toolName ?? "", 64));
+					imageContentParts.push({
+						type: "text",
+						text: `Image(s) from tool result #${j - i + 1}${boundedToolName ? ` (${boundedToolName})` : ""}:`
+					});
+					for (const block of images) imageContentParts.push({
 						type: "image_url",
 						image_url: { url: `data:${block.mimeType};base64,${block.data}` }
 					});
@@ -631,17 +590,14 @@ function convertMessages(model, context, compat, options = {}) {
 				j += 1;
 			}
 			i = j - 1;
-			if (imageBlocks.length > 0) {
+			if (imageContentParts.length > 0) {
 				if (compat.requiresAssistantAfterToolResult) params.push({
 					role: "assistant",
 					content: "I have processed the tool results."
 				});
 				params.push({
 					role: "user",
-					content: [{
-						type: "text",
-						text: "Attached image(s) from tool result:"
-					}, ...imageBlocks]
+					content: imageContentParts
 				});
 				lastRole = "user";
 			} else lastRole = "toolResult";
@@ -652,258 +608,474 @@ 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)
+//#region packages/ai/src/transports/openai-completions-direct-policy.ts
+function applyDirectCompletionsReasoningAndRouting(params, model, options, compat) {
+	const reasoningEffortMap = resolveOpenAIReasoningEffortMap(model);
+	const thinkingLevelMap = model.thinkingLevelMap;
+	const offReasoningEffort = reasoningEffortMap.off ?? model.thinkingLevelMap?.off;
+	const reasoningEffort = options?.reasoningEffort === void 0 ? offReasoningEffort ?? void 0 : reasoningEffortMap[options.reasoningEffort] ?? thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+	const reasoningEnabled = reasoningEffort !== void 0 && reasoningEffort !== "none";
+	if (compat.thinkingFormat === "zai" && model.reasoning) params.thinking = reasoningEnabled ? {
+		type: "enabled",
+		clear_thinking: false
+	} : { type: "disabled" };
+	else if (compat.thinkingFormat === "qwen" && model.reasoning) params.enable_thinking = reasoningEnabled;
+	else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) params.chat_template_kwargs = {
+		enable_thinking: reasoningEnabled,
+		preserve_thinking: true
 	};
-}
-//#endregion
-//#region packages/ai/src/transports/openai-transport-params.ts
-const MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS = 256;
-const OPENAI_CODEX_RESPONSES_PROVIDERS = /* @__PURE__ */ new Set(["openai"]);
-const loggedOpenAIStrictToolDowngradeDiagnosticKeys = /* @__PURE__ */ new Set();
-function readToolPayloadField(record, field) {
-	try {
-		return Object.hasOwn(record, field) ? record[field] : void 0;
-	} catch {
-		return;
+	else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
+		params.thinking = { type: reasoningEnabled ? "enabled" : "disabled" };
+		if (reasoningEnabled && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
+	} else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
+		if (reasoningEnabled) params.reasoning = { effort: reasoningEffort };
+		else if (offReasoningEffort !== null) params.reasoning = { effort: offReasoningEffort ?? "none" };
+	} else if (compat.thinkingFormat === "together" && model.reasoning) {
+		params.reasoning = { enabled: reasoningEnabled };
+		if (reasoningEnabled && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
+	} else if (reasoningEnabled && model.reasoning && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
+	else if (model.reasoning && compat.supportsReasoningEffort) {
+		if (typeof offReasoningEffort === "string") params.reasoning_effort = offReasoningEffort;
 	}
-}
-function readCodeModePayloadToolName(tool) {
-	if (!isRecord(tool)) return;
-	const name = readToolPayloadField(tool, "name");
-	if (typeof name === "string") return name;
-	const fn = readToolPayloadField(tool, "function");
-	if (!isRecord(fn)) return;
-	const fnName = readToolPayloadField(fn, "name");
-	return typeof fnName === "string" ? fnName : void 0;
-}
-function readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes) {
-	if (!isRecord(tool)) return;
-	const type = readToolPayloadField(tool, "type");
-	if (typeof type === "string" && allowedHostedToolTypes?.has(type)) {
-		try {
-			if (Object.hasOwn(tool, "name") || Object.hasOwn(tool, "function") || Object.hasOwn(tool, "functionDeclarations") || Object.hasOwn(tool, "function_declarations")) return false;
-		} catch {
-			return false;
+	if (compat.openRouterRouting) params.provider = compat.openRouterRouting;
+	if (model.baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
+		const routing = model.compat.vercelGatewayRouting;
+		if (routing.only || routing.order) {
+			const gatewayOptions = {};
+			if (routing.only) gatewayOptions.only = routing.only;
+			if (routing.order) gatewayOptions.order = routing.order;
+			params.providerOptions = { gateway: gatewayOptions };
 		}
-		return `hosted:${type}`;
 	}
-	const name = readCodeModePayloadToolName(tool);
-	return typeof name === "string" && isCodeModeModelVisibleToolName(name, visibleToolNames) ? `client:${name}` : void 0;
 }
-function readCodeModePayloadToolIdentities(payload) {
-	if (!isRecord(payload)) return [];
-	const tools = readToolPayloadField(payload, "tools");
-	if (!Array.isArray(tools)) return [];
-	return tools.flatMap((tool) => {
-		if (!isRecord(tool)) return [];
-		const identities = [];
-		const name = readCodeModePayloadToolName(tool);
-		if (name) identities.push(`client:${name}`);
-		for (const key of ["functionDeclarations", "function_declarations"]) {
-			const declarations = readToolPayloadField(tool, key);
-			if (!Array.isArray(declarations)) continue;
-			for (const declaration of declarations) {
-				const declarationName = readCodeModePayloadToolName(declaration);
-				if (declarationName) identities.push(`client:${declarationName}`);
+//#endregion
+//#region packages/ai/src/transports/openai-completions-replay.ts
+function isGoogleOpenAICompatModel(model) {
+	const endpointClass = detectOpenAICompletionsCompat(model).capabilities.endpointClass;
+	return model.provider === "google" || endpointClass === "google-generative-ai" || endpointClass === "google-vertex";
+}
+function requiresGoogleCompatToolCallThoughtSignature(model) {
+	return isGoogleGemini3ProModel(model.id) || isGoogleGemini3FlashModel(model.id);
+}
+const GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE = /[\u2026]|\.\.\./;
+const GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE = /^[A-Za-z0-9+/=]+$/;
+function hasGoogleCompatThoughtSignatureTruncationFootprint(value) {
+	return GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE.test(value) || GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE.test(value) && value.length % 4 !== 0;
+}
+function injectToolCallThoughtSignatures(outgoingMessages, context, model) {
+	if (!isGoogleOpenAICompatModel(model)) return;
+	const sigById = /* @__PURE__ */ new Map();
+	const fallbackSig = requiresGoogleCompatToolCallThoughtSignature(model) ? GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP : void 0;
+	for (const msg of context.messages ?? []) {
+		if (msg.role !== "assistant") continue;
+		const source = msg;
+		if (!Array.isArray(source.content)) continue;
+		for (const block of source.content) {
+			if (block.type !== "toolCall") continue;
+			const id = block.id;
+			const sig = block.thoughtSignature;
+			if (typeof id === "string" && typeof sig === "string" && sig.length > 0) {
+				const isSameRoute = source.api === model.api && source.provider === model.provider && source.model === model.id;
+				if (!isSameRoute && !fallbackSig) continue;
+				sigById.set(id, isSameRoute ? sig : fallbackSig ?? sig);
 			}
 		}
-		const type = readToolPayloadField(tool, "type");
-		if (typeof type === "string" && type !== "function") identities.push(`hosted:${type}`);
-		return identities;
-	});
-}
-function filterCodeModePayloadTools(payload, visibleToolNames, allowedHostedToolTypes, observer) {
-	if (!isRecord(payload)) return;
-	const tools = readToolPayloadField(payload, "tools");
-	if (!Array.isArray(tools)) return;
-	const beforeToolIdentities = observer ? readCodeModePayloadToolIdentities(payload) : void 0;
-	payload.tools = tools.flatMap((tool) => {
-		const identity = readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes);
-		if (identity) return [tool];
-		if (identity === false) return [];
-		if (!isRecord(tool)) return [];
-		const filteredGroups = {};
-		for (const key of ["functionDeclarations", "function_declarations"]) {
-			const declarations = readToolPayloadField(tool, key);
-			if (!Array.isArray(declarations)) continue;
-			const filtered = declarations.filter((declaration) => {
-				const declarationName = readCodeModePayloadToolName(declaration);
-				return typeof declarationName === "string" && isCodeModeModelVisibleToolName(declarationName, visibleToolNames);
-			});
-			if (filtered.length > 0) filteredGroups[key] = filtered;
+	}
+	if (sigById.size === 0 && !fallbackSig) return;
+	for (const message of outgoingMessages) {
+		const toolCalls = message.tool_calls;
+		if (!Array.isArray(toolCalls)) continue;
+		for (const toolCall of toolCalls) {
+			const id = toolCall.id;
+			if (typeof id !== "string") continue;
+			let sig = sigById.get(id) ?? fallbackSig;
+			if (typeof sig === "string" && sig.length > 0) {
+				if (hasGoogleCompatThoughtSignatureTruncationFootprint(sig.trim())) sig = fallbackSig;
+			}
+			if (typeof sig !== "string" || sig.length === 0) continue;
+			const extra = toolCall.extra_content && typeof toolCall.extra_content === "object" ? toolCall.extra_content : {};
+			toolCall.extra_content = extra;
+			const google = extra.google && typeof extra.google === "object" ? extra.google : {};
+			extra.google = google;
+			google.thought_signature = sig;
 		}
-		return Object.keys(filteredGroups).length > 0 ? [filteredGroups] : [];
-	});
-	if (beforeToolIdentities) observer?.({
-		beforeToolIdentities,
-		afterToolIdentities: readCodeModePayloadToolIdentities(payload)
-	});
-}
-function resolveCodeModeResponsesVisibleToolNames(context) {
-	return new Set((context.tools ?? []).map(readCodeModePayloadToolName).filter((name) => typeof name === "string"));
-}
-function enforceCodeModeResponsesToolSurface(payload, visibleToolNames, allowedHostedToolTypes, observer) {
-	if (!isRecord(payload)) return;
-	const tools = readToolPayloadField(payload, "tools");
-	if (!Array.isArray(tools)) return;
-	const beforeToolIdentities = observer ? readCodeModePayloadToolIdentities(payload) : void 0;
-	payload.tools = tools.filter((tool) => Boolean(readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes)));
-	if (beforeToolIdentities) observer?.({
-		beforeToolIdentities,
-		afterToolIdentities: readCodeModePayloadToolIdentities(payload)
-	});
+	}
 }
-function assertCodeModeResponsesToolSurface(payload, visibleToolNames, allowedHostedToolTypes) {
-	const tools = isRecord(payload) ? readToolPayloadField(payload, "tools") : void 0;
-	if (!Array.isArray(tools)) throw new Error("Code mode payload tool surface violation: expected exec,wait; got no tools");
-	const identities = tools.map((tool) => readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes));
-	const names = identities.flatMap((identity) => typeof identity === "string" && identity.startsWith("client:") ? [identity.slice(7)] : []).toSorted((left, right) => left.localeCompare(right));
-	if (names.length >= 2 && identities.every((identity) => typeof identity === "string") && new Set(identities).size === identities.length && names.includes("exec") && names.includes("wait")) return;
-	throw new Error(`Code mode payload tool surface violation: expected exec,wait plus direct-only tools; got ${names.length > 0 ? names.join(",") : "none"}`);
+const COMPLETIONS_REASONING_REPLAY_FIELDS = [
+	"reasoning_details",
+	"reasoning_content",
+	"reasoning",
+	"reasoning_text"
+];
+function stripCompletionsReasoningReplayFields(record) {
+	for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) if (field in record) delete record[field];
+}
+function sanitizeOpenRouterReasoningReplayFields(record) {
+	const reasoningDetails = record.reasoning_details;
+	if (typeof reasoningDetails === "string") {
+		if (reasoningDetails.length > 0 && typeof record.reasoning !== "string") record.reasoning = reasoningDetails;
+		delete record.reasoning_details;
+	} else if (reasoningDetails !== void 0 && !Array.isArray(reasoningDetails)) delete record.reasoning_details;
+	if ("reasoning" in record && (typeof record.reasoning !== "string" || record.reasoning === "")) delete record.reasoning;
+	if ("reasoning_content" in record && (typeof record.reasoning_content !== "string" || record.reasoning_content === "")) delete record.reasoning_content;
+	const reasoningText = record.reasoning_text;
+	if (typeof reasoningText === "string" && reasoningText.length > 0 && typeof record.reasoning !== "string" && typeof record.reasoning_content !== "string") record.reasoning = reasoningText;
+	if ("reasoning_text" in record) delete record.reasoning_text;
+}
+function sanitizeReasoningContentReplayFields(record) {
+	if ("reasoning_content" in record && typeof record.reasoning_content !== "string") delete record.reasoning_content;
+	delete record.reasoning_details;
+	delete record.reasoning;
+	delete record.reasoning_text;
+}
+const REASONING_CONTENT_REPLAY_MODEL_IDS = /* @__PURE__ */ new Set([
+	"deepseek-v4-flash",
+	"deepseek-v4-pro",
+	"kimi-for-coding",
+	"kimi-k2.5",
+	"kimi-k2.6",
+	"kimi-k2.7-code",
+	"kimi-k2.7-code-highspeed",
+	"kimi-k3",
+	"kimi-k2-thinking",
+	"kimi-k2-thinking-turbo",
+	"mimo-v2-pro",
+	"mimo-v2-omni",
+	"mimo-v2.5",
+	"mimo-v2.5-pro",
+	"mimo-v2.6-pro"
+]);
+const REASONING_CONTENT_REPLAY_TIER_SUFFIXES = [
+	"-free",
+	"-paid",
+	"-trial"
+];
+function stripReasoningContentReplayTierSuffix(modelId) {
+	for (const suffix of REASONING_CONTENT_REPLAY_TIER_SUFFIXES) if (modelId.length > suffix.length && modelId.endsWith(suffix)) return modelId.slice(0, -suffix.length);
+	return modelId;
+}
+function getReasoningContentReplayModelIdCandidates(modelId) {
+	if (typeof modelId !== "string") return [];
+	const normalized = modelId.trim().toLowerCase();
+	if (!normalized) return [];
+	const parts = normalized.split("/").filter(Boolean);
+	const finalPart = parts[parts.length - 1] ?? normalized;
+	const candidates = [finalPart];
+	const colonParts = finalPart.split(":").filter(Boolean);
+	if (colonParts.length > 1) candidates.push(colonParts[0] ?? "", colonParts[colonParts.length - 1] ?? "");
+	const baseCount = candidates.length;
+	for (let index = 0; index < baseCount; index += 1) {
+		const candidate = candidates[index];
+		if (typeof candidate !== "string") continue;
+		const stripped = stripReasoningContentReplayTierSuffix(candidate);
+		if (stripped !== candidate) candidates.push(stripped);
+	}
+	return uniqueStrings(candidates.filter(Boolean));
 }
-function buildOpenAIStrictToolDowngradeDiagnosticKey(diagnostics, context) {
-	return sha256Hex(JSON.stringify({
-		transport: context.transport,
-		provider: context.model.provider ?? null,
-		model: context.model.id ?? null,
-		diagnostics: diagnostics.map((entry) => ({
-			toolIndex: entry.toolIndex,
-			toolName: entry.toolName ?? null,
-			violations: entry.violations
-		}))
-	}));
+function shouldPreserveReasoningContentReplay(model, compat) {
+	if (compat.requiresReasoningContentOnAssistantMessages || compat.thinkingFormat === "deepseek" || compat.thinkingFormat === "zai" || shouldTrustReasoningContentReplayMetadata(model)) return true;
+	return getReasoningContentReplayModelIdCandidates(model.id).some((modelId) => REASONING_CONTENT_REPLAY_MODEL_IDS.has(modelId));
 }
-function shouldLogOpenAIStrictToolDowngradeDiagnostic(diagnostics, context) {
-	const key = buildOpenAIStrictToolDowngradeDiagnosticKey(diagnostics, context);
-	if (loggedOpenAIStrictToolDowngradeDiagnosticKeys.has(key)) return false;
-	if (loggedOpenAIStrictToolDowngradeDiagnosticKeys.size >= MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS) loggedOpenAIStrictToolDowngradeDiagnosticKeys.clear();
-	loggedOpenAIStrictToolDowngradeDiagnosticKeys.add(key);
-	return true;
+function shouldPreserveOpenRouterReasoningReplay(model) {
+	if (model.provider !== "openrouter") return true;
+	const normalizedModelId = model.id.trim().toLowerCase();
+	return !(normalizedModelId.startsWith("anthropic/") || normalizedModelId.startsWith("x-ai/"));
 }
-function resolveOpenAIStrictToolFlagWithDiagnostics(projection, strictSetting, context) {
-	const strict = resolveOpenAIProjectedToolsStrictToolFlag(projection, strictSetting);
-	if (strictSetting === true && strict === false) {
-		const diagnostics = findOpenAIStrictToolProjectionDiagnostics(projection);
-		getAiTransportHost().logDebug("openai-transport", () => {
-			if (!shouldLogOpenAIStrictToolDowngradeDiagnostic(diagnostics, context)) return null;
-			const sample = diagnostics.slice(0, 5).map((entry) => ({
-				tool: entry.toolName ?? `tool[${entry.toolIndex}]`,
-				violations: entry.violations.slice(0, 8)
-			}));
-			return {
-				message: `OpenAI ${context.transport} tool schema strict mode downgraded to strict=false for ${context.model.provider ?? "unknown"}/${context.model.id ?? "unknown"} because ${diagnostics.length} tool schema(s) are not strict-compatible`,
-				data: {
-					transport: context.transport,
-					provider: context.model.provider,
-					model: context.model.id,
-					incompatibleToolCount: diagnostics.length,
-					sample
-				}
-			};
-		});
+function shouldTrustReasoningContentReplayMetadata(model) {
+	if (!model.reasoning) return false;
+	if (model.provider.trim().toLowerCase() === "openai") return false;
+	return shouldPreserveOpenRouterReasoningReplay(model);
+}
+function sanitizeCompletionsReasoningReplayFields(messages, options) {
+	if (!Array.isArray(messages)) return;
+	for (const msg of messages) {
+		if (!msg || typeof msg !== "object") continue;
+		const record = msg;
+		if (record.role !== "assistant") continue;
+		if (options.preserveOpenRouterReasoning) sanitizeOpenRouterReasoningReplayFields(record);
+		else if (options.preserveReasoningContent) sanitizeReasoningContentReplayFields(record);
+		else stripCompletionsReasoningReplayFields(record);
 	}
-	return strict;
 }
-function isOpenAICodexResponsesModel(model) {
-	return OPENAI_CODEX_RESPONSES_PROVIDERS.has(model.provider) && (model.api === "openai-chatgpt-responses" || model.api === "openclaw-openai-chatgpt-responses-transport");
+function applyCompletionsReplay(outgoingMessages, context, model, compat) {
+	injectToolCallThoughtSignatures(outgoingMessages, context, model);
+	sanitizeCompletionsReasoningReplayFields(outgoingMessages, {
+		preserveOpenRouterReasoning: compat.thinkingFormat === "openrouter" && shouldPreserveOpenRouterReasoningReplay(model),
+		preserveReasoningContent: shouldPreserveReasoningContentReplay(model, compat)
+	});
 }
-function isNativeOpenAICodexResponsesBaseUrl(baseUrl) {
-	const trimmed = typeof baseUrl === "string" ? baseUrl.trim() : "";
-	if (!trimmed) return false;
+//#endregion
+//#region packages/ai/src/transports/openai-completions-params.ts
+function isKnownOpenAICompletionsEndpoint(model) {
+	if (!model.baseUrl.trim()) return true;
+	const endpointClass = resolveProviderEndpoint(model).endpointClass;
+	if (endpointClass === "openai-public" || endpointClass === "azure-openai") return true;
 	try {
-		const url = new URL(trimmed);
-		if (url.protocol !== "http:" && url.protocol !== "https:") return false;
-		if (url.hostname.toLowerCase() !== "chatgpt.com") return false;
-		const pathname = url.pathname.replace(/\/+$/u, "").toLowerCase();
-		return [
-			"/backend-api",
-			"/backend-api/v1",
-			"/backend-api/codex",
-			"/backend-api/codex/v1"
-		].includes(pathname);
+		return isAzureOpenAICompatibleHost(new URL(model.baseUrl).hostname.toLowerCase());
 	} catch {
 		return false;
 	}
 }
-function usesNativeOpenAICodexResponsesBackend(model) {
-	return isOpenAICodexResponsesModel(model) && isNativeOpenAICodexResponsesBaseUrl(model.baseUrl);
+function resolveOpenAICompletionsReasoningEffort(options) {
+	return options?.reasoningEffort ?? options?.reasoning ?? "high";
 }
-function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, sessionId) {
-	const providerHeaders = { ...model.headers };
-	if (model.provider === "github-copilot") Object.assign(providerHeaders, getAiTransportHost().buildCopilotDynamicHeaders(context.messages));
-	const callerHeaders = {
-		...optionHeaders,
-		...turnHeaders
+function resolveOpenAICompletionsMaxTokens(model, options) {
+	if (options?.maxTokens) return {
+		maxTokens: options.maxTokens,
+		clampToModelMaxTokens: true
+	};
+	const paramsMaxTokens = resolveMaxTokensParam(model.params);
+	if (paramsMaxTokens) return {
+		maxTokens: paramsMaxTokens,
+		clampToModelMaxTokens: false
 	};
-	const resolvedHeaders = resolveProviderRequestPolicyConfig(model, {
-		provider: model.provider,
-		api: model.api,
-		baseUrl: model.baseUrl,
-		capability: "llm",
-		transport: "stream",
-		providerHeaders,
-		callerHeaders: Object.keys(callerHeaders).length > 0 ? callerHeaders : void 0,
-		precedence: "caller-wins"
-	}).headers ?? {};
-	if (sessionId && !Object.keys(resolvedHeaders).some((key) => normalizeLowercaseStringOrEmpty(key) === "session_id") && usesNativeOpenAICodexResponsesBackend(model)) resolvedHeaders.session_id = clampOpenAIPromptCacheKey(sessionId) ?? sessionId;
-	return resolvedHeaders;
-}
-function resolveOpenAISdkTimeoutMs(model, timeoutMs) {
-	return resolveModelRequestTimeoutMs(model, timeoutMs);
-}
-function buildOpenAISdkClientOptions(model) {
-	const timeout = resolveOpenAISdkTimeoutMs(model);
 	return {
-		...timeout === void 0 ? {} : { timeout },
-		maxRetries: 0
+		maxTokens: model.maxTokens,
+		clampToModelMaxTokens: false
 	};
 }
-function buildOpenAISdkRequestOptions(model, signal, options) {
-	const timeout = resolveOpenAISdkTimeoutMs(model, options?.timeoutMs);
-	const headers = options?.stream === true && usesNativeOpenAICodexResponsesBackend(model) ? { Accept: "text/event-stream" } : void 0;
-	if (timeout === void 0 && !signal && !headers) return;
+function resolveOpenAICompletionsModelMaxTokens(model) {
+	return typeof model.maxTokens === "number" && Number.isFinite(model.maxTokens) && model.maxTokens > 0 ? Math.floor(model.maxTokens) : void 0;
+}
+const OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN = 1.25;
+const OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE = 8e3;
+function estimateOpenAICompletionsInputTokens(payload) {
+	let adjustedChars = 0;
+	adjustedChars += estimateOpenAICompletionsMessagesChars(payload.messages);
+	if (Array.isArray(payload.tools) && payload.tools.length > 0) try {
+		adjustedChars += estimateStringChars(JSON.stringify(payload.tools));
+	} catch {
+		adjustedChars += 1024;
+	}
+	if (payload.response_format !== void 0) try {
+		adjustedChars += estimateStringChars(JSON.stringify(payload.response_format));
+	} catch {
+		adjustedChars += 256;
+	}
+	return Math.ceil(adjustedChars / 4 * OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN);
+}
+function estimateOpenAICompletionsMessagesChars(messages) {
+	if (!Array.isArray(messages)) return 0;
+	let adjustedChars = 0;
+	for (const message of messages) {
+		if (!message || typeof message !== "object") continue;
+		const record = message;
+		adjustedChars += estimateOpenAICompletionsContentChars(record.content);
+		for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) adjustedChars += estimateOpenAICompletionsContentChars(record[field]);
+		if (record.tool_calls !== void 0) try {
+			adjustedChars += estimateStringChars(JSON.stringify(record.tool_calls));
+		} catch {
+			adjustedChars += 256;
+		}
+	}
+	return adjustedChars;
+}
+function estimateOpenAICompletionsContentChars(value) {
+	if (typeof value === "string") return estimateStringChars(value);
+	if (!Array.isArray(value)) return 0;
+	let adjustedChars = 0;
+	for (const block of value) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		if (record.type === "image_url" || record.type === "input_image") {
+			adjustedChars += OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE;
+			continue;
+		}
+		const text = record.text;
+		if (typeof text === "string") {
+			adjustedChars += estimateStringChars(text);
+			continue;
+		}
+		try {
+			adjustedChars += estimateStringChars(JSON.stringify(block));
+		} catch {
+			adjustedChars += 256;
+		}
+	}
+	return adjustedChars;
+}
+function resolveOpenAICompletionsEffectiveContextTokens(model) {
+	const contextTokens = model.contextTokens;
+	if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) return contextTokens;
+	return typeof model.contextWindow === "number" && Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : void 0;
+}
+function isQwenOpenAICompletionsThinkingFormat(format) {
+	return format === "qwen" || format === "qwen-chat-template";
+}
+function setQwenChatTemplateThinking(params, enabled) {
+	const existing = params.chat_template_kwargs;
+	params.chat_template_kwargs = existing && typeof existing === "object" && !Array.isArray(existing) ? {
+		...existing,
+		enable_thinking: enabled
+	} : { enable_thinking: enabled };
+}
+function applyQwenOpenAICompletionsThinkingParams(params) {
+	if (!params.modelReasoning || !isQwenOpenAICompletionsThinkingFormat(params.compatThinkingFormat)) return false;
+	const enabled = isOpenAICompletionsThinkingEnabled(params.requestedEffort);
+	if (params.compatThinkingFormat === "qwen-chat-template") setQwenChatTemplateThinking(params.payload, enabled);
+	else params.payload.enable_thinking = enabled;
+	return true;
+}
+function applyTogetherOpenAICompletionsThinkingParams(params) {
+	if (!params.modelReasoning || params.compatThinkingFormat !== "together") return;
+	params.payload.reasoning = { enabled: isOpenAICompletionsThinkingEnabled(params.requestedEffort) };
+}
+function convertTools(tools, compat, model, mode) {
+	const projection = projectOpenAITools(tools);
+	const strict = mode === "direct" ? compat.supportsStrictMode ? false : void 0 : resolveOpenAIStrictToolFlagWithDiagnostics(projection, resolveOpenAIStrictToolSetting(model, {
+		transport: "stream",
+		supportsStrictMode: compat?.supportsStrictMode
+	}), {
+		transport: "completions",
+		model
+	});
 	return {
-		...headers ? { headers } : {},
-		...signal ? { signal } : {},
-		...timeout !== void 0 ? { timeout } : {},
-		maxRetries: 0
+		projection,
+		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
+			const functionTool = {
+				name: tool.name,
+				description: tool.description,
+				parameters: mode === "direct" ? tool.parameters : normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
+			};
+			if (strict !== void 0) functionTool.strict = strict;
+			return {
+				type: "function",
+				function: functionTool
+			};
+		})
 	};
 }
-function getCompat(model) {
-	const resolved = resolveOpenAICompletionsCompat(model);
-	const compat = model.compat ?? {};
-	return {
-		...resolved,
-		cacheControlFormat: resolved.cacheControlFormat,
-		reasoningEffortMap: resolveOpenAIReasoningEffortMap(model, {}),
-		openRouterRouting: resolved.openRouterRouting ?? {},
-		vercelGatewayRouting: resolved.vercelGatewayRouting,
-		requiresStringContent: compat.requiresStringContent ?? false,
-		strictMessageKeys: compat.strictMessageKeys === true
+function buildOpenAICompletionsParams(model, context, options) {
+	return buildOpenAICompletionsRequest(model, context, options, { mode: "managed" });
+}
+function buildOpenAICompletionsRequest(model, context, options, policy) {
+	const resolvedPolicy = policy.mode === "direct" ? policy : {
+		...policy,
+		compat: getCompat(model)
+	};
+	const compat = resolvedPolicy.compat;
+	const managedCompat = resolvedPolicy.mode === "managed" ? resolvedPolicy.compat : void 0;
+	const endpointDetection = detectOpenAICompletionsCompat(model);
+	const compatDetection = policy.mode === "managed" ? endpointDetection : void 0;
+	const { endpointClass } = endpointDetection.capabilities;
+	const cacheRetention = policy.mode === "direct" ? policy.cacheRetention : resolveCacheRetention(options?.cacheRetention);
+	const cacheControl = resolveCompletionsCacheControl(compat, cacheRetention, endpointClass === "openrouter" || endpointClass === "default" && model.provider === "openrouter");
+	const markTools = endpointClass !== "modelstudio-native" && !(endpointClass === "default" && [
+		"modelstudio",
+		"dashscope",
+		"qwen"
+	].includes(model.provider));
+	const cacheOptOutIndexes = /* @__PURE__ */ new Set();
+	let messages = convertMessages(model, context, compat, {
+		cacheOptOutIndexes,
+		preserveSystemPromptCacheBoundary: cacheControl !== void 0 && !managedCompat?.requiresStringContent
+	});
+	if (managedCompat) {
+		applyCompletionsReplay(messages, context, model, managedCompat);
+		if (managedCompat.strictMessageKeys) messages = stripCompletionMessagesToRoleContent(messages);
+		if (managedCompat.requiresStringContent) messages = flattenCompletionMessagesToStringContent(messages);
+	}
+	const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
+	const params = {
+		model: model.id,
+		messages,
+		stream: true,
+		...resolveOpenAIPromptCacheParams(model, cacheRetention, compat)
 	};
+	if (compat.supportsUsageInStreaming) params.stream_options = { include_usage: true };
+	if (compat.supportsStore) params.store = false;
+	if (policy.mode === "direct" || compat.supportsPromptCacheKey && promptCacheKey) params.prompt_cache_key = compat.supportsPromptCacheKey ? promptCacheKey : void 0;
+	if (options?.temperature !== void 0) params.temperature = options.temperature;
+	if (policy.mode === "managed" && options?.topP !== void 0) params.top_p = options.topP;
+	const requestedResponseFormat = options?.responseFormat;
+	const responseFormat = policy.mode === "direct" && requestedResponseFormat === void 0 ? void 0 : resolveOpenAICompletionsResponseFormat(shouldOmitOllamaCompatResponseFormat({
+		provider: model.provider,
+		baseUrl: model.baseUrl,
+		hasTools: () => Boolean(context.tools?.length)
+	}) ? void 0 : requestedResponseFormat, compat.supportsJsonSchemaResponseFormat);
+	if (responseFormat !== void 0) params.response_format = responseFormat;
+	if (policy.mode === "managed" && options?.frequencyPenalty !== void 0) params.frequency_penalty = options.frequencyPenalty;
+	if (policy.mode === "managed" && options?.presencePenalty !== void 0) params.presence_penalty = options.presencePenalty;
+	if (policy.mode === "managed" && options?.seed !== void 0) params.seed = options.seed;
+	if (options?.stop !== void 0 && options.stop.length > 0) params.stop = options.stop;
+	let directToolProjection;
+	if (policy.mode === "direct" || supportsModelTools(model)) {
+		if (context.tools) {
+			const converted = convertTools(context.tools, compat, model, policy.mode);
+			if (policy.mode === "direct") directToolProjection = converted.projection;
+			if (converted.tools.length > 0 || policy.mode === "managed" && converted.projection.inputToolCount === 0 && converted.projection.diagnostics.length === 0) params.tools = converted.tools;
+			else if (hasToolCallHistory(context.messages)) params.tools = [];
+			if (policy.mode === "direct" && compat.zaiToolStream && converted.tools.length > 0) params.tool_stream = true;
+			if (policy.mode === "managed" && options?.toolChoice) {
+				const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, converted.projection);
+				if (toolChoice !== void 0) params.tool_choice = toolChoice;
+			} else if (compatDetection?.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length > 0) params.tool_choice = "auto";
+		} else if (hasToolCallHistory(context.messages)) params.tools = [];
+		if (compatDetection?.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length === 0) {
+			delete params.tools;
+			delete params.tool_choice;
+		}
+	}
+	if (policy.mode === "direct" && compat.cacheControlFormat === "anthropic") applyCompletionsAnthropicCacheControl(params, cacheControl ?? null, cacheOptOutIndexes, markTools);
+	if (policy.mode === "direct" && options?.toolChoice) {
+		const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, directToolProjection ?? projectOpenAITools([]));
+		if (toolChoice !== void 0) params.tool_choice = toolChoice;
+	}
+	{
+		const maxTokenBudget = policy.mode === "direct" ? {
+			maxTokens: options?.maxTokens,
+			clampToModelMaxTokens: true
+		} : resolveOpenAICompletionsMaxTokens(model, options);
+		const effectiveMaxTokens = maxTokenBudget.maxTokens;
+		const effectiveContextTokens = resolveOpenAICompletionsEffectiveContextTokens(model);
+		let clampedMaxTokens = effectiveMaxTokens;
+		const modelMaxTokens = resolveOpenAICompletionsModelMaxTokens(model);
+		if (maxTokenBudget.clampToModelMaxTokens && clampedMaxTokens !== void 0 && modelMaxTokens !== void 0 && clampedMaxTokens > modelMaxTokens) {
+			clampedMaxTokens = modelMaxTokens;
+			if (policy.mode === "managed") emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} modelMaxTokens=${modelMaxTokens}`);
+		}
+		if (compatDetection?.capabilities.usesExplicitProxyLikeEndpoint && clampedMaxTokens !== void 0 && effectiveContextTokens !== void 0) {
+			const estimatedInputTokens = estimateOpenAICompletionsInputTokens(params);
+			const remainingBudget = Math.max(1, effectiveContextTokens - estimatedInputTokens - 1);
+			if (clampedMaxTokens > remainingBudget) {
+				clampedMaxTokens = remainingBudget;
+				emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} effectiveContext=${effectiveContextTokens} estimatedInput=${estimatedInputTokens}`);
+			}
+		}
+		if (policy.mode === "direct" ? options?.maxTokens : clampedMaxTokens) {
+			if (compat.maxTokensField === "max_tokens") params.max_tokens = clampedMaxTokens;
+			else params.max_completion_tokens = clampedMaxTokens;
+		}
+	}
+	if (policy.mode === "direct") {
+		applyDirectCompletionsReasoningAndRouting(params, model, options, compat);
+		return params;
+	}
+	const completionsReasoningEffort = resolveOpenAICompletionsReasoningEffort(options);
+	const resolvedCompletionsReasoningEffort = completionsReasoningEffort ? resolveOpenAIReasoningEffortForModel({
+		model,
+		effort: completionsReasoningEffort,
+		fallbackMap: managedCompat?.reasoningEffortMap
+	}) : void 0;
+	const omitChatCompletionsToolReasoningEffort = Array.isArray(params.tools) && params.tools.length > 0 && (isOpenAIGpt54MiniModel(model) || isOpenAIGpt55Model(model) && isKnownOpenAICompletionsEndpoint(model));
+	const disableChatCompletionsToolReasoning = Array.isArray(params.tools) && params.tools.length > 0 && isOpenAIGpt56Model(model) && isKnownOpenAICompletionsEndpoint(model);
+	const handledQwenThinkingFormat = applyQwenOpenAICompletionsThinkingParams({
+		compatThinkingFormat: compat.thinkingFormat,
+		modelReasoning: model.reasoning,
+		payload: params,
+		requestedEffort: completionsReasoningEffort
+	});
+	applyTogetherOpenAICompletionsThinkingParams({
+		compatThinkingFormat: compat.thinkingFormat,
+		modelReasoning: model.reasoning,
+		payload: params,
+		requestedEffort: completionsReasoningEffort
+	});
+	if (disableChatCompletionsToolReasoning) params.reasoning_effort = "none";
+	else if (compat.thinkingFormat === "openrouter" && model.reasoning && resolvedCompletionsReasoningEffort) params.reasoning = { effort: resolvedCompletionsReasoningEffort };
+	else if (resolvedCompletionsReasoningEffort && model.reasoning && compat.supportsReasoningEffort && !handledQwenThinkingFormat && !omitChatCompletionsToolReasoningEffort) params.reasoning_effort = resolvedCompletionsReasoningEffort;
+	if (compat.cacheControlFormat === "anthropic") applyCompletionsAnthropicCacheControl(params, cacheControl ?? null, cacheOptOutIndexes, markTools, !managedCompat?.requiresStringContent);
+	return params;
 }
 //#endregion
 //#region packages/ai/src/transports/openai-completions-dsml.ts
@@ -1270,7 +1442,7 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 				partial: output
 			});
 		}
-		currentBlock.thinking += reasoningDelta.text;
+		appendAssistantThinking(currentBlock, reasoningDelta.text);
 		pushStreamEvent({
 			type: "thinking_delta",
 			contentIndex: blockIndex(),
@@ -1588,6 +1760,7 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 		emitReasoningUsageActivity(hasReasoningUsageActivity);
 		if (cooperativeScheduler) await cooperativeScheduler.afterEvent();
 	}
+	throwIfModelStreamAborted(options?.signal);
 	if (!finishReason && (directMode || options?.sawStreamDONE?.() === false)) throw new Error("Stream ended without finish_reason");
 	flushReasoningTagTextPartitioner();
 	flushDeepSeekToolCallRecovererAtEnd();
@@ -1611,12 +1784,9 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 	if (output.stopReason === "error" || output.stopReason === "aborted") tagUnresolvedTextAsCommentary(output);
 	if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
 }
-function resolveOpenAICompletionsReasoningEffort(options) {
-	return options?.reasoningEffort ?? options?.reasoning ?? "high";
-}
 function shouldEmitOpenAICompletionsReasoning(model, options) {
 	if (!model.reasoning) return false;
-	const effort = resolveOpenAICompletionsReasoningEffort(options);
+	const effort = options?.reasoningEffort ?? options?.reasoning ?? "high";
 	if (!effort || !isOpenAICompletionsThinkingEnabled(effort)) return false;
 	return true;
 }
@@ -1625,4 +1795,4 @@ function hasOpenAICompletionsReasoningUsageActivity(rawUsage) {
 	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) && reasoningTokens > 0;
 }
 //#endregion
-export { createDeepSeekTextFilter as C, tagUnresolvedTextAsCommentary as E, shouldOmitOllamaCompatResponseFormat as S, tagPendingCommentaryText as T, hasToolCallHistory as _, buildOpenAISdkClientOptions as a, resolveOpenAICompletionsCompat as b, filterCodeModePayloadTools as c, readCodeModePayloadToolName as d, resolveCodeModeResponsesVisibleToolNames as f, convertMessages as g, resolveOpenAIReasoningEffortMap as h, buildOpenAIClientHeaders as i, getCompat as l, usesNativeOpenAICodexResponsesBackend as m, shouldEmitOpenAICompletionsReasoning as n, buildOpenAISdkRequestOptions as o, resolveOpenAIStrictToolFlagWithDiagnostics as p, assertCodeModeResponsesToolSurface as r, enforceCodeModeResponsesToolSurface as s, processCompletionsStream as t, isOpenAICodexResponsesModel as u, finalizeOpenAICompletionsToolCalls as v, clearPendingCommentaryText as w, resolveOpenAICompletionsResponseFormat as x, detectOpenAICompletionsCompat as y };
+export { convertMessages as a, flattenCompletionMessagesToStringContent as c, canonicalizeMaxTokensParam as d, resolveMaxTokensParam as f, buildOpenAICompletionsRequest as i, stripCompletionMessagesToRoleContent as l, shouldEmitOpenAICompletionsReasoning as n, isAzureOpenAICompatibleHost as o, createDeepSeekTextFilter as p, buildOpenAICompletionsParams as r, finalizeOpenAICompletionsToolCalls as s, processCompletionsStream as t, applyCompletionsAnthropicCacheControl as u };