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

package/dist/{openai-completions-zLDfebnN.mjs → openai-completions-CiSutyu0.mjs}

@@ -1,17 +1,245 @@
-import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DnhYpc27.mjs";
+import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
-import { n as calculateCost, r as clampThinkingLevel, t as applyProviderReportedUsageCost } from "./model-utils-1GiZ2_rr.mjs";
+import { n as getAiTransportHost } from "./host-XYGZcgO8.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
+import { A as buildBaseOptions, E as isImageWithMediaPayload, O as isRecord, S as describeToolResultMediaPlaceholder, a as splitSystemPromptCacheBoundary, o as stripSystemPromptCacheBoundary, u as transformMessages, w as extractToolResultText, y as normalizeLowercaseStringOrEmpty } from "./shared-CdjNZd35.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
+import { c as calculateCost, l as clampThinkingLevel, s as applyProviderReportedUsageCost } from "./number-coercion-DvG7SNMg.mjs";
+import { d as transportAbortError } from "./transport-stream-shared-BbMELSI4.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
 import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { C as splitSystemPromptCacheBoundary, i as extractToolResultText, l as buildBaseOptions, n as describeToolResultMediaPlaceholder, o as isImageWithMediaPayload, t as transformMessages, w as stripSystemPromptCacheBoundary } from "./transform-messages-eb6lxDLB.mjs";
-import { a as resolveCacheRetention, i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-BsH5cqGj.mjs";
-import { t as formatProviderError } from "./provider-error-LMfTEkfO.mjs";
-import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-BlVe67g6.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-RjWszj8c.mjs";
-import { a as clampOpenAIPromptCacheKey, n as reconcileOpenAICompletionsToolChoice, t as projectOpenAITools } from "./openai-tool-projection-WHf2nuOI.mjs";
+import { t as formatProviderError } from "./provider-error-apVOZI6G.mjs";
+import { a as resolveCacheRetention, i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, o as projectRuntimeToolInputSchema, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-BCoBNmL7.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, o as createReasoningTagTextPartitioner, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-C3OgBjIk.mjs";
 import OpenAI from "openai";
+//#region packages/ai/src/transports/host-policy.ts
+function buildGuardedModelFetch(model, timeoutMs, options) {
+	const host = getAiTransportHost();
+	if (options !== void 0) return host.buildModelFetch(model, timeoutMs, options) ?? globalThis.fetch;
+	if (timeoutMs !== void 0) return host.buildModelFetch(model, timeoutMs) ?? globalThis.fetch;
+	return host.buildModelFetch(model) ?? globalThis.fetch;
+}
+function resolveProviderEndpoint(baseUrl) {
+	return { endpointClass: getAiTransportHost().resolveProviderEndpointClass(baseUrl) };
+}
+function resolveProviderRequestCapabilities(input) {
+	return getAiTransportHost().resolveProviderRequestCapabilities(input);
+}
+function resolveProviderRequestPolicyConfig(input) {
+	return { headers: getAiTransportHost().resolveProviderRequestHeaders(input) };
+}
+function resolveModelRequestTimeoutMs(model, timeoutMs) {
+	return timeoutMs ?? getAiTransportHost().resolveModelRequestTimeoutMs(model);
+}
+function resolveOpenAIStrictToolSetting(model, options) {
+	return getAiTransportHost().resolveOpenAIStrictToolSetting(model, options);
+}
+function transformTransportMessages(messages, model, normalizeToolCallId, options) {
+	return getAiTransportHost().transformTransportMessages(messages, model, normalizeToolCallId, options);
+}
+//#endregion
+//#region packages/ai/src/utils/assistant-text-phase.ts
+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 } : {}
+	});
+}
+/** Tags unphased narration before a tool-call event becomes consumer-visible. */
+function tagPendingCommentaryText(content) {
+	const textBlocks = content.filter(isAssistantTextPhaseBlock);
+	let commentaryIndex = 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(`commentary-${commentaryIndex}`, "commentary");
+		block.textSignature = signature;
+		tagged.set(block, signature);
+		commentaryIndex += 1;
+	}
+	return tagged;
+}
+/** 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/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;
+	}
+}
+/**
+* Maps the shared JSON Schema option to Chat Completions while preserving the
+* older provider-shaped json_object/json_schema inputs accepted by model params.
+*/
+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
+		}
+	};
+}
+//#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 === "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");
+	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: provider === "openrouter" && modelId?.startsWith("anthropic/") === true ? "anthropic" : void 0,
+		sessionAffinityFormat: isOpenRouterLike ? "openrouter" : "openai",
+		supportsLongCacheRetention: 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")
+	};
+}
+function resolveOpenAICompletionsCompatDefaultsFromCapabilities(input) {
+	return resolveOpenAICompletionsCompatDefaults(input);
+}
+/** Detects endpoint capabilities and defaults for an OpenAI-completions model. */
+function detectOpenAICompletionsCompat(model, resolveCapabilities = resolveProviderRequestCapabilities) {
+	const capabilities = resolveCapabilities({
+		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
+		})
+	};
+}
+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";
+}
+/** Applies explicit model overrides once on top of the canonical transport defaults. */
+function resolveOpenAICompletionsCompat(model, resolveCapabilities = resolveProviderRequestCapabilities) {
+	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
+	};
+}
+if (process.env.VITEST || false) globalThis[Symbol.for("openclaw.openAICompletionsCompatTestApi")] = { resolveOpenAICompletionsCompatDefaults };
+//#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
 //#region packages/ai/src/providers/openai-stop-reason.ts
 function mapOpenAIStopReason(reason, options) {
 	if (reason === null) return { stopReason: "stop" };
@@ -39,6 +267,192 @@ function mapOpenAIStopReason(reason, options) {
 	};
 }
 //#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
 //#region packages/ai/src/providers/openai-completions.ts
 var openai_completions_exports = /* @__PURE__ */ __exportAll({
 	convertMessages: () => convertMessages,
@@ -104,10 +518,11 @@ const streamOpenAICompletions = (model, context, options) => {
 			stopReason: "stop",
 			timestamp: Date.now()
 		};
+		const provisionalCommentaryTags = /* @__PURE__ */ new Map();
 		let firstEventAbort;
 		try {
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			const compat = getCompat(model);
+			const compat = resolveOpenAICompletionsCompat(model);
 			const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 			const cacheSessionId = cacheRetention === "none" ? void 0 : options?.sessionId;
 			const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
@@ -328,9 +743,10 @@ const streamOpenAICompletions = (model, context, options) => {
 					if (choiceDelta.content !== null && choiceDelta.content !== void 0 && choiceDelta.content.length > 0) appendPartitionedContent(choiceDelta.content, Boolean(foundReasoningField));
 					const refusalText = typeof choiceDelta.refusal === "string" ? choiceDelta.refusal : "";
 					if (refusalText.length > 0) appendPartitionedContent(refusalText, Boolean(foundReasoningField));
-					if (choiceDelta.tool_calls) {
+					if (choiceDelta.tool_calls && choiceDelta.tool_calls.length > 0) {
 						flushPartitionedContent();
 						sealNativeReasoningBeforeText();
+						rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
 						for (const toolCall of choiceDelta.tool_calls) {
 							const block = ensureToolCallBlock(toolCall);
 							if (!block.id && toolCall.id) {
@@ -366,7 +782,7 @@ const streamOpenAICompletions = (model, context, options) => {
 			}
 			flushPartitionedContent();
 			for (const block of blocks) finishBlock(block);
-			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (options?.signal?.aborted) throw transportAbortError(options.signal);
 			if (output.stopReason === "aborted") throw new Error("Request was aborted");
 			if (output.stopReason === "error") throw new Error(output.errorMessage || "Provider returned an error stop reason");
 			if (!hasFinishReason) throw new Error("Stream ended without finish_reason");
@@ -375,6 +791,8 @@ const streamOpenAICompletions = (model, context, options) => {
 			if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
 			if (output.stopReason === "stop" && hasToolCalls && !hasVisibleText) output.stopReason = "toolUse";
 			if (hasToolCalls && output.stopReason !== "toolUse") output.content = output.content.filter((block) => block.type !== "toolCall");
+			if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
+			if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -416,7 +834,7 @@ const streamSimpleOpenAICompletions = (model, context, options) => {
 		toolChoice
 	});
 };
-function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model)) {
+function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = resolveOpenAICompletionsCompat(model)) {
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 	const headers = { ...model.headers };
 	if (model.provider === "github-copilot") {
@@ -427,7 +845,7 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
 		});
 		Object.assign(headers, copilotHeaders);
 	}
-	if (sessionId && compat.sendSessionAffinityHeaders) if (compat.sessionAffinityFormat === "openrouter") headers["x-session-id"] = sessionId;
+	if (sessionId && compat.sessionAffinity !== "none") if (compat.sessionAffinity === "openrouter") headers["x-session-id"] = sessionId;
 	else {
 		headers.session_id = sessionId;
 		headers["x-client-request-id"] = sessionId;
@@ -447,7 +865,7 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
 		fetch: getAiTransportHost().buildModelFetch(model)
 	});
 }
-function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention)) {
+function buildParams(model, context, options, compat = resolveOpenAICompletionsCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention)) {
 	const cacheControl = getCompatCacheControl(compat, cacheRetention);
 	const cacheOptOutIndexes = /* @__PURE__ */ new Set();
 	const messages = convertMessages(model, context, compat, {
@@ -472,6 +890,13 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
 	}
 	if (options?.temperature !== void 0) params.temperature = options.temperature;
 	if (options?.stop !== void 0 && options.stop.length > 0) params.stop = options.stop;
+	const requestedResponseFormat = options?.responseFormat;
+	const responseFormat = 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;
 	let toolProjection;
 	if (context.tools) {
 		const converted = convertTools(context.tools, compat);
@@ -485,32 +910,35 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
 		const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, toolProjection ?? projectOpenAITools([]));
 		if (toolChoice !== void 0) params.tool_choice = toolChoice;
 	}
-	if (compat.thinkingFormat === "zai" && model.reasoning) params.thinking = options?.reasoningEffort ? {
+	const reasoningEffortMap = resolveOpenAIReasoningEffortMap(model);
+	const reasoningEffort = options?.reasoningEffort === void 0 ? void 0 : reasoningEffortMap[options.reasoningEffort] ?? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+	const reasoningEnabled = reasoningEffort !== void 0;
+	const offReasoningEffort = reasoningEffortMap.off ?? model.thinkingLevelMap?.off;
+	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 = Boolean(options?.reasoningEffort);
+	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: Boolean(options?.reasoningEffort),
+		enable_thinking: reasoningEnabled,
 		preserve_thinking: true
 	};
 	else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
-		params.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
-		if (options?.reasoningEffort && compat.supportsReasoningEffort) params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+		params.thinking = { type: reasoningEnabled ? "enabled" : "disabled" };
+		if (reasoningEnabled && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
 	} else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
 		const openRouterParams = params;
-		if (options?.reasoningEffort) openRouterParams.reasoning = { effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort };
-		else if (model.thinkingLevelMap?.off !== null) openRouterParams.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+		if (reasoningEnabled) openRouterParams.reasoning = { effort: reasoningEffort };
+		else if (offReasoningEffort !== null) openRouterParams.reasoning = { effort: offReasoningEffort ?? "none" };
 	} else if (compat.thinkingFormat === "together" && model.reasoning) {
 		const togetherParams = params;
-		togetherParams.reasoning = { enabled: Boolean(options?.reasoningEffort) };
-		if (options?.reasoningEffort && compat.supportsReasoningEffort) togetherParams.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
-	} else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
-	else if (!options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
-		const offValue = model.thinkingLevelMap?.off;
-		if (typeof offValue === "string") params.reasoning_effort = offValue;
+		togetherParams.reasoning = { enabled: reasoningEnabled };
+		if (reasoningEnabled && compat.supportsReasoningEffort) togetherParams.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;
 	}
-	if (model.compat?.openRouterRouting) params.provider = model.compat.openRouterRouting;
+	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) {
@@ -791,78 +1219,5 @@ function parseChunkUsage(rawUsage, model) {
 	applyProviderReportedUsageCost(usage, rawUsage.cost);
 	return usage;
 }
-/**
-* Detect compatibility settings from provider and baseUrl for known providers.
-* Provider takes precedence over URL-based detection since it's explicitly configured.
-* Returns a fully resolved OpenAICompletionsCompat object with all fields set.
-*/
-function detectCompat(model) {
-	const provider = model.provider;
-	const baseUrl = model.baseUrl;
-	const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
-	const isTogether = provider === "together" || baseUrl.includes("api.together.ai") || baseUrl.includes("api.together.xyz");
-	const isMoonshot = provider === "moonshotai" || provider === "moonshotai-cn" || baseUrl.includes("api.moonshot.");
-	const isCloudflareWorkersAI = provider === "cloudflare-workers-ai" || baseUrl.includes("api.cloudflare.com");
-	const isCloudflareAiGateway = provider === "cloudflare-ai-gateway" || baseUrl.includes("gateway.ai.cloudflare.com");
-	const isOpenRouter = provider === "openrouter" || baseUrl.includes("openrouter.ai");
-	const isNonStandard = provider === "cerebras" || baseUrl.includes("cerebras.ai") || provider === "xai" || baseUrl.includes("api.x.ai") || isTogether || baseUrl.includes("chutes.ai") || baseUrl.includes("deepseek.com") || isZai || isMoonshot || provider === "opencode" || baseUrl.includes("opencode.ai") || isCloudflareWorkersAI || isCloudflareAiGateway;
-	const useMaxTokens = baseUrl.includes("chutes.ai") || isMoonshot || isCloudflareAiGateway || isTogether || isZai;
-	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-	const isDeepSeek = provider === "deepseek" || baseUrl.includes("deepseek.com");
-	const isXiaomi = provider === "xiaomi" || baseUrl.includes("xiaomimimo.com");
-	const supportsOpenRouterDeveloperRole = isOpenRouter && (model.id.startsWith("anthropic/") || model.id.startsWith("openai/"));
-	const usesOpenRouterSessionAffinity = isOpenRouter || model.compat?.thinkingFormat === "openrouter" || model.compat?.openRouterRouting !== void 0;
-	const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : void 0;
-	return {
-		supportsStore: !isNonStandard,
-		supportsDeveloperRole: supportsOpenRouterDeveloperRole || !isNonStandard && !isOpenRouter,
-		supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isTogether && !isCloudflareAiGateway,
-		supportsUsageInStreaming: true,
-		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
-		requiresToolResultName: false,
-		requiresAssistantAfterToolResult: false,
-		requiresThinkingAsText: false,
-		requiresReasoningContentOnAssistantMessages: isDeepSeek || isXiaomi,
-		thinkingFormat: isDeepSeek ? "deepseek" : isXiaomi ? "deepseek" : isZai ? "zai" : isTogether ? "together" : isOpenRouter ? "openrouter" : "openai",
-		openRouterRouting: {},
-		vercelGatewayRouting: {},
-		zaiToolStream: false,
-		supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway,
-		cacheControlFormat,
-		sendSessionAffinityHeaders: false,
-		sessionAffinityFormat: usesOpenRouterSessionAffinity ? "openrouter" : "openai",
-		supportsPromptCacheKey: false,
-		supportsLongCacheRetention: !(isTogether || isCloudflareWorkersAI || isCloudflareAiGateway)
-	};
-}
-/**
-* Get resolved compatibility settings for a model.
-* Uses explicit model.compat if provided, otherwise auto-detects from provider/URL.
-*/
-function getCompat(model) {
-	const detected = detectCompat(model);
-	if (!model.compat) return detected;
-	return {
-		supportsStore: model.compat.supportsStore ?? detected.supportsStore,
-		supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
-		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
-		supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
-		maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
-		requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,
-		requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
-		requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
-		requiresReasoningContentOnAssistantMessages: model.compat.requiresReasoningContentOnAssistantMessages ?? detected.requiresReasoningContentOnAssistantMessages,
-		thinkingFormat: model.compat.thinkingFormat ?? detected.thinkingFormat,
-		openRouterRouting: model.compat.openRouterRouting ?? {},
-		vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
-		zaiToolStream: model.compat.zaiToolStream ?? detected.zaiToolStream,
-		supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
-		cacheControlFormat: model.compat.cacheControlFormat ?? detected.cacheControlFormat,
-		sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders,
-		sessionAffinityFormat: detected.sessionAffinityFormat,
-		supportsPromptCacheKey: model.compat.supportsPromptCacheKey ?? detected.supportsPromptCacheKey,
-		supportsLongCacheRetention: model.compat.supportsLongCacheRetention ?? detected.supportsLongCacheRetention
-	};
-}
 //#endregion
-export { mapOpenAIStopReason as a, streamSimpleOpenAICompletions as i, openai_completions_exports as n, streamOpenAICompletions as r, convertMessages as t };
+export { transformTransportMessages as C, resolveProviderRequestPolicyConfig as S, buildGuardedModelFetch as _, projectOpenAITools as a, resolveProviderEndpoint as b, mapOpenAIStopReason as c, resolveOpenAICompletionsCompat as d, resolveOpenAICompletionsResponseFormat as f, tagPendingCommentaryText as g, rememberPendingCommentaryTags as h, streamSimpleOpenAICompletions as i, resolveOpenAIReasoningEffortMap as l, clearPendingCommentaryText as m, openai_completions_exports as n, reconcileOpenAICompletionsToolChoice as o, shouldOmitOllamaCompatResponseFormat as p, streamOpenAICompletions as r, reconcileOpenAIResponsesToolChoice as s, convertMessages as t, detectOpenAICompletionsCompat as u, resolveModelRequestTimeoutMs as v, resolveProviderRequestCapabilities as x, resolveOpenAIStrictToolSetting as y };