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

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

@@ -1,17 +1,43 @@
 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-XYGZcgO8.mjs";
-import { C as isImageWithMediaPayload, D as buildBaseOptions, a as stripSystemPromptCacheBoundary, c as transformMessages, g as normalizeLowercaseStringOrEmpty, i as splitSystemPromptCacheBoundary, x as extractToolResultText, y as describeToolResultMediaPlaceholder } from "./system-prompt-cache-boundary-CbHeV4_l.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 { n as calculateCost, r as clampThinkingLevel, t as applyProviderReportedUsageCost } from "./model-utils-1GiZ2_rr.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 { a as resolveCacheRetention, i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-BsH5cqGj.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-DP4xEyBY.mjs";
-import { t as formatProviderError } from "./provider-error-C4VvV_3t.mjs";
-import { a as clampOpenAIPromptCacheKey, n as reconcileOpenAICompletionsToolChoice, t as projectOpenAITools } from "./openai-tool-projection-ITOU9bG1.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;
@@ -48,6 +74,144 @@ 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.
@@ -76,224 +240,6 @@ function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
 	};
 }
 //#endregion
-//#region packages/ai/src/providers/openai-completions-compat.ts
-const DEFAULT_OPENAI_COMPLETIONS_COMPAT = {
-	supportsStore: true,
-	supportsDeveloperRole: true,
-	supportsReasoningEffort: true,
-	supportsUsageInStreaming: true,
-	maxTokensField: "max_completion_tokens",
-	requiresToolResultName: false,
-	requiresAssistantAfterToolResult: false,
-	requiresThinkingAsText: false,
-	requiresReasoningContentOnAssistantMessages: false,
-	thinkingFormat: "openai",
-	vercelGatewayRouting: {},
-	zaiToolStream: false,
-	supportsStrictMode: true,
-	cacheControlFormat: void 0,
-	sessionAffinityFormat: "openai",
-	supportsPromptCacheKey: false,
-	supportsLongCacheRetention: true
-};
-const OPENAI_COMPLETIONS_COMPAT_MATRIX = {
-	openrouter: {
-		priority: 10,
-		providers: ["openrouter"],
-		baseUrlIncludes: ["openrouter.ai"],
-		compat: {
-			supportsDeveloperRole: false,
-			thinkingFormat: "openrouter",
-			sessionAffinityFormat: "openrouter"
-		}
-	},
-	cerebras: {
-		priority: 20,
-		providers: ["cerebras"],
-		baseUrlIncludes: ["cerebras.ai"],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false
-		}
-	},
-	xai: {
-		priority: 20,
-		providers: ["xai"],
-		baseUrlIncludes: ["api.x.ai"],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			supportsReasoningEffort: false
-		}
-	},
-	moonshot: {
-		priority: 20,
-		providers: ["moonshotai", "moonshotai-cn"],
-		baseUrlIncludes: ["api.moonshot."],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			supportsReasoningEffort: false,
-			maxTokensField: "max_tokens",
-			supportsStrictMode: false
-		}
-	},
-	cloudflareWorkersAi: {
-		priority: 20,
-		providers: ["cloudflare-workers-ai"],
-		baseUrlIncludes: ["api.cloudflare.com"],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			supportsLongCacheRetention: false
-		}
-	},
-	cloudflareAiGateway: {
-		priority: 20,
-		providers: ["cloudflare-ai-gateway"],
-		baseUrlIncludes: ["gateway.ai.cloudflare.com"],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			supportsReasoningEffort: false,
-			maxTokensField: "max_tokens",
-			supportsStrictMode: false,
-			supportsLongCacheRetention: false
-		}
-	},
-	opencode: {
-		priority: 20,
-		providers: ["opencode"],
-		baseUrlIncludes: ["opencode.ai"],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false
-		}
-	},
-	chutes: {
-		priority: 20,
-		baseUrlIncludes: ["chutes.ai"],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			maxTokensField: "max_tokens"
-		}
-	},
-	together: {
-		priority: 30,
-		providers: ["together"],
-		baseUrlIncludes: ["api.together.ai", "api.together.xyz"],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			supportsReasoningEffort: false,
-			maxTokensField: "max_tokens",
-			thinkingFormat: "together",
-			supportsStrictMode: false,
-			supportsLongCacheRetention: false
-		}
-	},
-	zai: {
-		priority: 40,
-		providers: ["zai"],
-		baseUrlIncludes: ["api.z.ai"],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			supportsReasoningEffort: false,
-			maxTokensField: "max_tokens",
-			thinkingFormat: "zai"
-		}
-	},
-	xiaomi: {
-		priority: 50,
-		providers: ["xiaomi"],
-		baseUrlIncludes: ["xiaomimimo.com"],
-		compat: {
-			thinkingFormat: "deepseek",
-			requiresReasoningContentOnAssistantMessages: true
-		}
-	},
-	deepseekProvider: {
-		priority: 60,
-		providers: ["deepseek"],
-		compat: {
-			thinkingFormat: "deepseek",
-			requiresReasoningContentOnAssistantMessages: true
-		}
-	},
-	deepseekEndpoint: {
-		priority: 60,
-		baseUrlIncludes: ["deepseek.com"],
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			thinkingFormat: "deepseek",
-			requiresReasoningContentOnAssistantMessages: true
-		}
-	}
-};
-const OPENAI_COMPLETIONS_MODEL_COMPAT_MATRIX = [{
-	profile: "openrouter",
-	modelIdPrefixes: ["anthropic/", "openai/"],
-	compat: { supportsDeveloperRole: true }
-}, {
-	providers: ["openrouter"],
-	modelIdPrefixes: ["anthropic/"],
-	compat: { cacheControlFormat: "anthropic" }
-}];
-const SORTED_OPENAI_COMPLETIONS_COMPAT_RULES = Object.entries(OPENAI_COMPLETIONS_COMPAT_MATRIX).toSorted(([, left], [, right]) => left.priority - right.priority);
-function matchesCompatRule(model, rule) {
-	return rule.providers?.includes(model.provider) === true || rule.baseUrlIncludes?.some((fragment) => model.baseUrl.includes(fragment)) === true;
-}
-function matchesModelCompatRule(model, matchedProfiles, rule) {
-	if (rule.profile !== void 0 && !matchedProfiles.has(rule.profile)) return false;
-	if (rule.providers !== void 0 && !rule.providers.includes(model.provider)) return false;
-	return rule.modelIdPrefixes.some((prefix) => model.id.startsWith(prefix));
-}
-/** Detects request compatibility from the provider, endpoint, and model family matrices. */
-function detectOpenAICompletionsCompat(model) {
-	const compat = { ...DEFAULT_OPENAI_COMPLETIONS_COMPAT };
-	const matchedProfiles = /* @__PURE__ */ new Set();
-	for (const [profile, rule] of SORTED_OPENAI_COMPLETIONS_COMPAT_RULES) {
-		if (!matchesCompatRule(model, rule)) continue;
-		Object.assign(compat, rule.compat);
-		matchedProfiles.add(profile);
-	}
-	for (const rule of OPENAI_COMPLETIONS_MODEL_COMPAT_MATRIX) if (matchesModelCompatRule(model, matchedProfiles, rule)) Object.assign(compat, rule.compat);
-	return compat;
-}
-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 to the detected compatibility defaults. */
-function resolveOpenAICompletionsCompat(model) {
-	const detected = detectOpenAICompletionsCompat(model);
-	const configured = model.compat;
-	return {
-		supportsStore: configured?.supportsStore ?? detected.supportsStore,
-		supportsDeveloperRole: configured?.supportsDeveloperRole ?? detected.supportsDeveloperRole,
-		supportsReasoningEffort: configured?.supportsReasoningEffort ?? detected.supportsReasoningEffort,
-		supportsUsageInStreaming: configured?.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
-		maxTokensField: configured?.maxTokensField ?? detected.maxTokensField,
-		requiresToolResultName: configured?.requiresToolResultName ?? detected.requiresToolResultName,
-		requiresAssistantAfterToolResult: configured?.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
-		requiresThinkingAsText: configured?.requiresThinkingAsText ?? detected.requiresThinkingAsText,
-		requiresReasoningContentOnAssistantMessages: configured?.requiresReasoningContentOnAssistantMessages ?? detected.requiresReasoningContentOnAssistantMessages,
-		thinkingFormat: configured?.thinkingFormat ?? detected.thinkingFormat,
-		openRouterRouting: configured?.openRouterRouting,
-		vercelGatewayRouting: configured?.vercelGatewayRouting ?? detected.vercelGatewayRouting,
-		zaiToolStream: configured?.zaiToolStream ?? detected.zaiToolStream,
-		supportsStrictMode: configured?.supportsStrictMode ?? detected.supportsStrictMode,
-		cacheControlFormat: configured?.cacheControlFormat ?? detected.cacheControlFormat,
-		sessionAffinity: resolveSessionAffinity(model, detected.sessionAffinityFormat),
-		supportsPromptCacheKey: configured?.supportsPromptCacheKey ?? detected.supportsPromptCacheKey,
-		supportsLongCacheRetention: configured?.supportsLongCacheRetention ?? detected.supportsLongCacheRetention
-	};
-}
-//#endregion
 //#region packages/ai/src/providers/openai-stop-reason.ts
 function mapOpenAIStopReason(reason, options) {
 	if (reason === null) return { stopReason: "stop" };
@@ -321,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,
@@ -650,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");
@@ -758,6 +890,13 @@ function buildParams(model, context, options, compat = resolveOpenAICompletionsC
 	}
 	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);
@@ -1081,4 +1220,4 @@ function parseChunkUsage(rawUsage, model) {
 	return usage;
 }
 //#endregion
-export { mapOpenAIStopReason as a, rememberPendingCommentaryTags as c, streamSimpleOpenAICompletions as i, tagPendingCommentaryText as l, openai_completions_exports as n, resolveOpenAIReasoningEffortMap as o, streamOpenAICompletions as r, clearPendingCommentaryText as s, 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 };

package/dist/openai-prompt-cache-2uo_1OR1.d.mts

@@ -0,0 +1,7 @@
+//#region packages/ai/src/providers/openai-prompt-cache.d.ts
+/** Maximum prompt cache key length accepted by OpenAI-compatible request metadata. */
+declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+/** Truncates a prompt cache key by Unicode code point count. */
+declare function clampOpenAIPromptCacheKey(key: string | undefined): string | undefined;
+//#endregion
+export { clampOpenAIPromptCacheKey as n, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH as t };

package/dist/openai-prompt-cache-mZTCdRPo.mjs

@@ -0,0 +1,12 @@
+//#region packages/ai/src/providers/openai-prompt-cache.ts
+/** Maximum prompt cache key length accepted by OpenAI-compatible request metadata. */
+const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+/** Truncates a prompt cache key by Unicode code point count. */
+function clampOpenAIPromptCacheKey(key) {
+	if (key === void 0) return;
+	const chars = Array.from(key);
+	if (chars.length <= 64) return key;
+	return chars.slice(0, 64).join("");
+}
+//#endregion
+export { clampOpenAIPromptCacheKey as n, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH as t };

package/dist/prompt-cache-stability-Cwcjv_fx.d.mts

@@ -0,0 +1,13 @@
+//#region packages/ai/src/utils/prompt-cache-stability.d.ts
+/** Canonicalizes provider tool order without relying on host locale settings. */
+declare function sortPromptCacheToolsByName<T extends {
+  readonly name?: string;
+  readonly wireName?: string;
+  readonly description?: string;
+}>(tools: readonly T[]): T[];
+/** Normalize structured prompt text before hashing or snapshot comparison. */
+declare function normalizeStructuredPromptSection(text: string): string;
+/** Normalize, de-dupe, and sort capability ids for stable prompt payloads. */
+declare function normalizePromptCapabilityIds(capabilities: ReadonlyArray<string>): string[];
+//#endregion
+export { normalizeStructuredPromptSection as n, sortPromptCacheToolsByName as r, normalizePromptCapabilityIds as t };