@openclaw/ai 2026.9.2 → 2026.9.4

package/dist/openai-completions-yJuk7eis.mjs

@@ -0,0 +1,187 @@
+import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
+import { M as clampThinkingLevel } from "./host-B8YfDGd4.mjs";
+import { s as resolveOpenAICompletionsCompat } from "./openai-prompt-cache-Bds-n_9Q.mjs";
+import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
+import { n as buildBaseOptions, o as reasoningTagTextPolicy } from "./simple-options-BQbb4yQL.mjs";
+import { _ as createOpenAIProviderAcceptanceHook, y as isOpenAICompletionsThinkingEnabled } from "./openai-transport-params-9aPuV5YY.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
+import { b as withProviderResponseHook, n as assignTransportErrorDetails, v as transportAbortError } from "./transport-stream-shared-zHll9BxO.mjs";
+import { a as tagUnresolvedTextAsCommentary, t as clearPendingCommentaryText } from "./assistant-text-phase-C20rxWwP.mjs";
+import { t as createAssistantOutput } from "./assistant-output-tLt4H-iQ.mjs";
+import { a as convertMessages, i as buildOpenAICompletionsRequest, s as finalizeOpenAICompletionsToolCalls, t as processCompletionsStream } from "./openai-completions-stream-Da2vvl-S.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-2hfrquuz.mjs";
+import { n as resolveProviderSimpleCompletionHeaders } from "./provider-transport-turn-state-D5EXOFL2.mjs";
+import { n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-B37TB3rB.mjs";
+import { t as createOpenAIProviderClient } from "./openai-provider-client-S2gCrM2Z.mjs";
+//#region packages/ai/src/providers/openai-completions.ts
+var openai_completions_exports = /* @__PURE__ */ __exportAll({
+	convertMessages: () => convertMessages,
+	streamOpenAICompletions: () => streamOpenAICompletions,
+	streamSimpleOpenAICompletions: () => streamSimpleOpenAICompletions
+});
+const streamOpenAICompletions = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const output = createAssistantOutput(model);
+		const provisionalCommentaryTags = /* @__PURE__ */ new Map();
+		let firstEventAbort;
+		try {
+			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+			const compat = resolveOpenAICompletionsCompat(model);
+			const shouldEmitReasoning = Boolean(model.reasoning && options?.reasoningEffort && isOpenAICompletionsThinkingEnabled(options.reasoningEffort));
+			const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+			const cacheSessionId = cacheRetention === "none" ? void 0 : options?.sessionId;
+			const client = createClient(model, context, apiKey, resolveProviderSimpleCompletionHeaders(model, options), cacheSessionId, compat);
+			let params = buildOpenAICompletionsRequest(model, context, options, {
+				mode: "direct",
+				compat,
+				cacheRetention
+			});
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== void 0) params = nextParams;
+			firstEventAbort = createFirstStreamEventAbortController(options?.signal);
+			const requestOptions = {
+				signal: firstEventAbort.signal,
+				...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
+				maxRetries: 0
+			};
+			const { data: openaiStream, response } = await client.chat.completions.create(params, requestOptions).withResponse();
+			const hookedOpenAIStream = withProviderResponseHook({
+				stream: openaiStream,
+				signal: firstEventAbort.signal,
+				abort: firstEventAbort.abort,
+				hook: createOpenAIProviderAcceptanceHook(options, response, model),
+				onReady: () => stream.push({
+					type: "start",
+					partial: output
+				})
+			});
+			const finishedBlocks = /* @__PURE__ */ new Set();
+			const contentIndices = /* @__PURE__ */ new WeakMap();
+			let openTextBlock;
+			let openThinkingBlock;
+			const finishBlock = (block) => {
+				const contentIndex = contentIndices.get(block);
+				if (contentIndex === void 0 || finishedBlocks.has(block)) return;
+				finishedBlocks.add(block);
+				if (block.type === "text") {
+					openTextBlock = void 0;
+					stream.push({
+						type: "text_end",
+						contentIndex,
+						content: block.text,
+						partial: output
+					});
+				} else if (block.type === "thinking") {
+					openThinkingBlock = void 0;
+					stream.push({
+						type: "thinking_end",
+						contentIndex,
+						content: block.thinking,
+						partial: output
+					});
+				} else if (block.type === "toolCall") stream.push({
+					type: "toolcall_end",
+					contentIndex,
+					toolCall: block,
+					partial: output
+				});
+			};
+			const directEventStream = { push(event) {
+				if (event.type === "text_start" || event.type === "thinking_start" || event.type === "toolcall_start") {
+					const block = output.content[event.contentIndex];
+					if (block) {
+						contentIndices.set(block, event.contentIndex);
+						if (block.type === "text") openTextBlock = block;
+						else if (block.type === "thinking") openThinkingBlock = block;
+					}
+				}
+				stream.push(event);
+			} };
+			try {
+				await processCompletionsStream(hookedOpenAIStream, output, model, directEventStream, {
+					mode: "direct",
+					beforeContentBlock(nextType) {
+						if (openThinkingBlock) finishBlock(openThinkingBlock);
+						if (openTextBlock && nextType !== "toolCall") finishBlock(openTextBlock);
+					},
+					provisionalCommentaryTags,
+					signal: options?.signal,
+					emitReasoning: shouldEmitReasoning,
+					strictReasoningTags: reasoningTagTextPolicy.isStrict(options),
+					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
+					abortFirstEventStream: firstEventAbort.abort,
+					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options)
+				});
+				if (options?.signal?.aborted) throw transportAbortError(options.signal);
+				if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage || (output.stopReason === "aborted" ? "Request was aborted" : "Provider returned an invalid tool call"));
+			} catch (error) {
+				for (const block of output.content) if (block.type !== "toolCall") finishBlock(block);
+				throw error;
+			}
+			for (const block of output.content) if (block.type !== "toolCall" || output.stopReason === "toolUse") finishBlock(block);
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			const terminal = assignTransportErrorDetails(output, error, options?.signal);
+			finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
+			clearPendingCommentaryText(provisionalCommentaryTags);
+			tagUnresolvedTextAsCommentary(output);
+			for (const block of output.content) {
+				delete block.index;
+				delete block.partialArgs;
+				delete block.streamIndex;
+			}
+			stream.push({
+				type: "error",
+				reason: terminal.stopReason,
+				error: output
+			});
+			stream.end();
+		} finally {
+			firstEventAbort?.dispose();
+		}
+	})();
+	return stream;
+};
+const streamSimpleOpenAICompletions = (model, context, options) => {
+	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const base = buildBaseOptions(model, options, apiKey);
+	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
+	const reasoningEffort = clampedReasoning === "off" ? void 0 : clampedReasoning === "max" ? "xhigh" : clampedReasoning;
+	const toolChoice = options?.toolChoice;
+	return streamOpenAICompletions(model, context, {
+		...base,
+		reasoningEffort,
+		toolChoice
+	});
+};
+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") {
+		const hasImages = hasCopilotVisionInput(context.messages);
+		const copilotHeaders = buildCopilotDynamicHeaders({
+			messages: context.messages,
+			hasImages
+		});
+		Object.assign(headers, copilotHeaders);
+	}
+	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;
+			headers["x-session-affinity"] = sessionId;
+		}
+	}
+	return createOpenAIProviderClient(model, apiKey, headers, optionsHeaders);
+}
+//#endregion
+export { streamOpenAICompletions as n, streamSimpleOpenAICompletions as r, openai_completions_exports as t };

package/dist/openai-prompt-cache-B4eYo2-I.d.mts

@@ -0,0 +1,16 @@
+import { M as OpenAICompletionsCompat, O as Model, l as CacheRetention } from "./types-Ntv5z2g2.mjs";
+import "./types-DlfwzH3T.mjs";
+//#region packages/ai/src/providers/openai-prompt-cache.d.ts
+/** Selects documented lifetime fields shared by Responses and Chat Completions. */
+declare function resolveOpenAIPromptCacheParams(model: Pick<Model, "id" | "provider" | "baseUrl">, cacheRetention: CacheRetention, compat: Required<Pick<OpenAICompletionsCompat, "supportsPromptCacheKey" | "supportsLongCacheRetention">>): {
+  prompt_cache_retention?: "24h";
+  prompt_cache_options?: {
+    ttl: "30m";
+  };
+};
+/** 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, resolveOpenAIPromptCacheParams as r, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH as t };

package/dist/openai-prompt-cache-Bds-n_9Q.mjs

@@ -0,0 +1,220 @@
+import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { a as resolveProviderRequestCapabilities } from "./host-policy-Zcg_cNz8.mjs";
+//#region packages/normalization-core/src/code-points.ts
+/** Truncates to a nonnegative code-point budget; grapheme clusters may be split. */
+function truncateCodePoints(text, maxCodePoints) {
+	const limit = Math.max(0, Math.trunc(maxCodePoints) || 0);
+	if (text.length <= limit) return text;
+	const prefix = [];
+	for (const codePoint of text) {
+		if (prefix.length >= limit) break;
+		prefix.push(codePoint);
+	}
+	return prefix.join("");
+}
+//#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);
+}
+/** Native OpenAI defaults never apply to a configured proxy endpoint. */
+function isNativeOpenAIEndpoint(model) {
+	const baseUrl = model.baseUrl?.trim();
+	if (!baseUrl) return model.provider === "openai";
+	const endpoint = URL.parse(baseUrl);
+	return endpoint?.protocol === "https:" && (endpoint.hostname === "api.openai.com" || endpoint.hostname.endsWith(".api.openai.com"));
+}
+function isOpenAICodexResponsesModel(model) {
+	return model.provider === "openai" && (model.api === "openai-chatgpt-responses" || model.api === "openclaw-openai-chatgpt-responses-transport");
+}
+function isNativeOpenAICodexResponsesBaseUrl(baseUrl) {
+	const trimmed = typeof baseUrl === "string" ? baseUrl.trim() : "";
+	if (!trimmed) return false;
+	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",
+			"/backend-api/codex/responses"
+		].includes(pathname);
+	} catch {
+		return false;
+	}
+}
+function usesNativeOpenAICodexResponsesBackend(model) {
+	return isOpenAICodexResponsesModel(model) && isNativeOpenAICodexResponsesBaseUrl(model.baseUrl);
+}
+function resolveOpenAIPromptCacheKeySupport(model) {
+	return model.compat?.supportsPromptCacheKey ?? (isNativeOpenAIEndpoint(model) || usesNativeOpenAICodexResponsesBackend(model));
+}
+/** 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");
+	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" || modelId?.toLowerCase().startsWith("anthropic/") === true && (endpointClass === "openrouter" || isDefaultRoute && provider === "openrouter" || provider === "deepinfra") ? "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")
+	};
+}
+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
+		})
+	};
+}
+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) {
+	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: resolveOpenAIPromptCacheKeySupport(model),
+		supportsLongCacheRetention: configured?.supportsLongCacheRetention ?? (usesNativeOpenAICodexResponsesBackend(model) ? false : defaults.supportsLongCacheRetention),
+		configuredSupportsLongCacheRetention: configured?.supportsLongCacheRetention,
+		visibleReasoningDetailTypes: configured && "visibleReasoningDetailTypes" in configured ? configured.visibleReasoningDetailTypes ?? defaults.visibleReasoningDetailTypes : defaults.visibleReasoningDetailTypes,
+		requiresNonEmptyUserOrAssistantMessage: defaults.requiresNonEmptyUserOrAssistantMessage
+	};
+}
+//#endregion
+//#region packages/ai/src/providers/openai-prompt-cache.ts
+const EXTENDED_RETENTION_MODELS = /* @__PURE__ */ new Set([
+	"gpt-5.5",
+	"gpt-5.5-pro",
+	"gpt-5.4",
+	"gpt-5.2",
+	"gpt-5.1-codex-max",
+	"gpt-5.1",
+	"gpt-5.1-codex",
+	"gpt-5.1-codex-mini",
+	"gpt-5.1-chat-latest",
+	"gpt-5",
+	"gpt-5-codex",
+	"gpt-4.1"
+]);
+/** Selects documented lifetime fields shared by Responses and Chat Completions. */
+function resolveOpenAIPromptCacheParams(model, cacheRetention, compat) {
+	if (cacheRetention !== "long" || !compat.supportsPromptCacheKey || !compat.supportsLongCacheRetention) return {};
+	const version = /^gpt-(\d+)(?:\.(\d+))?(?:-|$)/.exec(model.id);
+	if (version && (Number(version[1]) > 5 || Number(version[1]) === 5 && Number(version[2]) >= 6)) return { prompt_cache_options: { ttl: "30m" } };
+	const modelId = model.id.replace(/-\d{4}-\d{2}-\d{2}$/, "");
+	return !isNativeOpenAIEndpoint(model) || EXTENDED_RETENTION_MODELS.has(modelId) ? { prompt_cache_retention: "24h" } : {};
+}
+/** 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;
+	return truncateCodePoints(key, 64);
+}
+//#endregion
+export { isNativeOpenAIEndpoint as a, resolveOpenAIPromptCacheKeySupport as c, shouldOmitOllamaCompatResponseFormat as d, detectOpenAICompletionsCompat as i, usesNativeOpenAICodexResponsesBackend as l, clampOpenAIPromptCacheKey as n, isOpenAICodexResponsesModel as o, resolveOpenAIPromptCacheParams as r, resolveOpenAICompletionsCompat as s, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH as t, resolveOpenAICompletionsResponseFormat as u };

package/dist/openai-provider-client-S2gCrM2Z.mjs

@@ -0,0 +1,24 @@
+import { n as getAiTransportHost } from "./host-B8YfDGd4.mjs";
+import { T as resolveOpenAIClientBaseUrl } from "./openai-transport-params-9aPuV5YY.mjs";
+import { i as resolveCloudflareBaseUrl, r as isCloudflareProvider } from "./github-copilot-headers-B37TB3rB.mjs";
+import OpenAI from "openai";
+//#region packages/ai/src/providers/openai-provider-client.ts
+function createOpenAIProviderClient(model, apiKey, headers, optionsHeaders) {
+	if (optionsHeaders) Object.assign(headers, optionsHeaders);
+	const defaultHeaders = model.provider === "cloudflare-ai-gateway" ? {
+		...headers,
+		Authorization: headers.Authorization ?? null,
+		"cf-aig-authorization": `Bearer ${apiKey}`
+	} : headers;
+	const baseUrl = isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl;
+	return new OpenAI({
+		apiKey,
+		baseURL: resolveOpenAIClientBaseUrl(model, baseUrl),
+		dangerouslyAllowBrowser: true,
+		defaultHeaders,
+		maxRetries: 0,
+		fetch: getAiTransportHost().buildModelFetch(model)
+	});
+}
+//#endregion
+export { createOpenAIProviderClient as t };

package/dist/{openai-responses-CCL41ALM.mjs → openai-responses-DaYwH05E.mjs}

@@ -1,15 +1,14 @@
 import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-BgDvQeum.mjs";
-import { n as getAiTransportHost } from "./host-CEvLw30U.mjs";
-import { n as clampOpenAIPromptCacheKey, r as resolveOpenAIResponsesCacheParams } from "./openai-prompt-cache-CGnVB74a.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
+import { n as clampOpenAIPromptCacheKey, r as resolveOpenAIPromptCacheParams, s as resolveOpenAICompletionsCompat } from "./openai-prompt-cache-Bds-n_9Q.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { n as buildBaseOptions } from "./simple-options-BjHCCh4v.mjs";
+import { n as buildBaseOptions } from "./simple-options-BQbb4yQL.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, r as convertResponsesMessages, s as runResponsesStreamLifecycle, t as applyCommonResponsesParams } from "./openai-responses-shared-Bmma_3Qc.mjs";
-import { j as resolveOpenAIClientBaseUrl } from "./openai-tool-schema-_pTAJqKF.mjs";
-import { j as supportsOpenAITemperature } from "./openai-responses-compaction-window-BMVHFOtq.mjs";
-import { i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-NCJtz9i0.mjs";
-import OpenAI from "openai";
+import { C as supportsOpenAITemperature } from "./openai-responses-contracts-DDOHA62Y.mjs";
+import { n as resolveProviderSimpleCompletionHeaders } from "./provider-transport-turn-state-D5EXOFL2.mjs";
+import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, r as convertResponsesMessages, s as runResponsesStreamLifecycle, t as applyCommonResponsesParams } from "./openai-responses-shared-B8RdBPCv.mjs";
+import { n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-B37TB3rB.mjs";
+import { t as createOpenAIProviderClient } from "./openai-provider-client-S2gCrM2Z.mjs";
 //#region packages/ai/src/providers/openai-responses.ts
 var openai_responses_exports = /* @__PURE__ */ __exportAll({
 	streamOpenAIResponses: () => streamOpenAIResponses,
@@ -18,8 +17,8 @@ var openai_responses_exports = /* @__PURE__ */ __exportAll({
 const OPENAI_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set(["openai", "opencode"]);
 function getCompat(model) {
 	return {
-		sendSessionIdHeader: model.compat?.sendSessionIdHeader ?? true,
-		supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true
+		...resolveOpenAICompletionsCompat(model),
+		sendSessionIdHeader: model.compat?.sendSessionIdHeader ?? true
 	};
 }
 /**
@@ -36,7 +35,7 @@ const streamOpenAIResponses = (model, context, options) => {
 		createClient: () => {
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
 			const cacheSessionId = resolveCacheRetention(options?.cacheRetention) === "none" ? void 0 : options?.sessionId;
-			return createClient(model, context, apiKey, options?.headers, cacheSessionId);
+			return createClient(model, context, apiKey, resolveProviderSimpleCompletionHeaders(model, options), cacheSessionId);
 		},
 		buildParams: (_requestModel, replayMode) => buildParams(model, context, options, replayMode),
 		processStreamOptions: {
@@ -74,21 +73,7 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId) {
 		if (compat.sendSessionIdHeader) headers.session_id = sessionId;
 		headers["x-client-request-id"] = sessionId;
 	}
-	if (optionsHeaders) Object.assign(headers, optionsHeaders);
-	const defaultHeaders = model.provider === "cloudflare-ai-gateway" ? {
-		...headers,
-		Authorization: headers.Authorization ?? null,
-		"cf-aig-authorization": `Bearer ${apiKey}`
-	} : headers;
-	const baseUrl = isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl;
-	return new OpenAI({
-		apiKey,
-		baseURL: resolveOpenAIClientBaseUrl(model, baseUrl),
-		dangerouslyAllowBrowser: true,
-		defaultHeaders,
-		maxRetries: 0,
-		fetch: getAiTransportHost().buildModelFetch(model)
-	});
+	return createOpenAIProviderClient(model, apiKey, headers, optionsHeaders);
 }
 function buildParams(model, context, options, replayMode = "checkpoint") {
 	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
@@ -103,8 +88,8 @@ function buildParams(model, context, options, replayMode = "checkpoint") {
 		model: model.id,
 		input: messages,
 		stream: true,
-		prompt_cache_key: cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId),
-		...resolveOpenAIResponsesCacheParams(model, cacheRetention, compat.supportsLongCacheRetention),
+		prompt_cache_key: cacheRetention === "none" || !compat.supportsPromptCacheKey ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId),
+		...resolveOpenAIPromptCacheParams(model, cacheRetention, compat),
 		store: false
 	};
 	if (options?.maxTokens) params.max_output_tokens = options?.maxTokens;