@openclaw/ai 2026.9.1 → 2026.9.3

package/dist/{openai-chatgpt-responses-BAJ4gq3i.mjs → openai-chatgpt-responses-nDZccFW-.mjs}

@@ -1,20 +1,22 @@
 import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-CPeq9F7y.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-BIaiBURL.mjs";
-import { r as toErrorObject } from "./diagnostics-KhXK-QJI.mjs";
-import { u as resolveTimerTimeoutMs } from "./base64-CEFBpSkN.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { d as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-0PLDyJ-d.mjs";
-import { c as parseRetryAfterSeconds, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-CtuS1Upe.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-CWuF-sS3.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-BI0rkM-5.mjs";
+import { l as extractErrorCodeOrErrno, o as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, u as toErrorObject } from "./diagnostics-dV98PqIy.mjs";
+import { s as resolveTimerTimeoutMs } from "./base64-D-su8YVo.mjs";
+import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-CCooe-cr.mjs";
+import { parseRetryAfterHeadersSeconds } from "./internal/retry-after.mjs";
+import { d as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-tcKOqnpF.mjs";
+import { _ as createOpenAIProviderAcceptanceHook, v as createOpenAIResponseHook } from "./openai-transport-params-DNasp2fU.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { C as headersToRecord, _ as transportAbortError, p as notifyProviderStreamOpened, t as assignTransportErrorDetails, y as withProviderResponseHook } from "./transport-stream-shared-CytPVLIg.mjs";
-import { F as commitResponsesEncryptedContentAttempt, L as isInvalidEncryptedContentError, W as buildOpenAIResponsesReasoningReplayMetadata, a as resolveResponsesReasoningEffort, c as processResponsesStream, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, q as suppressOpenAIResponsesCompaction, r as convertResponsesMessages, s as convertResponsesToolPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-DiAdpNAM.mjs";
-import { C as createOpenAIProviderAcceptanceHook, w as createOpenAIResponseHook } from "./openai-tool-schema-BMiHFH36.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DcNjoFQE.mjs";
-import { A as supportsOpenAITemperature, S as responsesPromptObserver } from "./openai-responses-compaction-window-DO7yV7az.mjs";
+import { C as headersToRecord, _ as transportAbortError, p as notifyProviderStreamOpened, t as assignTransportErrorDetails, y as withProviderResponseHook } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-2hfrquuz.mjs";
+import { l as supportsOpenAITemperature } from "./openai-reasoning-effort-BK7FbcLT.mjs";
+import { S as responsesPromptObserver } from "./openai-responses-compaction-window-D5jbzCi3.mjs";
+import { J as buildOpenAIResponsesReasoningReplayMetadata, L as commitResponsesEncryptedContentAttempt, Q as suppressOpenAIResponsesCompaction, V as resolveNextResponsesEncryptedContentAttempt, a as resolveResponsesReasoningEffort, h as ResponsesStreamFailure, i as createResponsesAssistantOutput, l as convertResponsesToolPayload, n as applyResponsesServiceTierPricing, o as resolveResponsesRequestReasoningEffort, r as convertResponsesMessages, u as processResponsesStream, z as isInvalidEncryptedContentError } from "./openai-responses-shared-ZyQEzS5i.mjs";
 import { t as createSseByteGuard } from "./streaming-byte-guard-CC-HMn_u.mjs";
 import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
-import { t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-C7x4IK7r.mjs";
+import { t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-tApyTLVu.mjs";
 import { n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-KWcgd0d_.mjs";
 //#region packages/ai/src/providers/openai-chatgpt-responses-protocol.ts
 const OPENAI_CHATGPT_RESPONSES_SUCCESS_BODY_MAX_BYTES = 16777216;
@@ -83,6 +85,17 @@ const os = loadNodeOs();
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
 const CODEX_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set(["openai", "opencode"]);
+const WEBSOCKET_TRANSPORT_ERROR_CODE = "ERR_WEBSOCKET_TRANSPORT";
+const RETRYABLE_WEBSOCKET_CLOSE_CODES = /* @__PURE__ */ new Set([
+	1001,
+	1005,
+	1006,
+	1011,
+	1012,
+	1013,
+	1014,
+	1015
+]);
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
 const OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES = 16384;
@@ -184,7 +197,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 							commitSemanticAttempt(activeAttempt);
 						}, requestOptions, firstEventAbort.abort, observePromptEgress, activeAttempt.kind, () => {
 							websocketRequestSent = true;
-						});
+						}, options?.signal);
 						if (activeSignal?.aborted) throw transportAbortError(activeSignal);
 						if (output.stopReason === "aborted" || output.stopReason === "error") throw new CodexApiError(output.errorMessage ?? "An unknown error occurred");
 						stream.push({
@@ -272,10 +285,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					onTimeout: getFirstStreamEventTimeoutHandler(options)
 				});
 				const [errorText] = await Promise.all([readChatGptResponsesErrorTextLimited(attemptResponse, activeSignal), hookStream[Symbol.asyncIterator]().next()]);
-				const info = parseErrorResponseText(errorText, attemptResponse.status, attemptResponse.statusText);
-				const retryAfterSeconds = parseRetryAfterSeconds(attemptResponse.headers);
-				const retryAfterSuffix = Number.isFinite(retryAfterSeconds) ? `; Retry-After: ${Math.ceil(retryAfterSeconds ?? 0)} seconds` : "";
-				const terminalResponseError = new CodexApiError(`${info.friendlyMessage || info.message}${retryAfterSuffix}`, { code: info.code });
+				const terminalResponseError = parseErrorResponse(errorText, attemptResponse);
 				if (activeSignal?.aborted) throw transportAbortError(activeSignal);
 				const nextSemanticAttempt = await resolveNextResponsesEncryptedContentAttempt(activeAttempt, terminalResponseError, { buildFullHistoryRequest: () => buildBody("full-history") });
 				if (!nextSemanticAttempt) throw terminalResponseError;
@@ -370,20 +380,18 @@ function buildRequestBody(model, context, options, replayMode = "checkpoint") {
 	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) body.temperature = options.temperature;
 	if (options?.serviceTier !== void 0) body.service_tier = options.serviceTier;
 	if (context.tools) {
-		const converted = convertResponsesToolPayload(context.tools, { strict: null });
-		if (converted.tools.length > 0) {
-			body.tools = converted.tools;
+		const tools = convertResponsesToolPayload(context.tools, { strict: null });
+		if (tools.length > 0) {
+			body.tools = tools;
 			body.tool_choice = "auto";
 			body.parallel_tool_calls = true;
 		}
 	}
-	if (options?.reasoningEffort !== void 0) {
-		const effort = options.reasoningEffort === "none" ? model.thinkingLevelMap?.off ?? "none" : model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
-		if (effort !== null) body.reasoning = {
-			effort,
-			summary: options.reasoningSummary ?? "auto"
-		};
-	}
+	const effort = options?.reasoningEffort === void 0 ? void 0 : resolveResponsesRequestReasoningEffort(model, options.reasoningEffort);
+	if (effort !== void 0) body.reasoning = {
+		effort,
+		summary: options?.reasoningSummary ?? "auto"
+	};
 	return body;
 }
 function resolveCodexServiceTier(responseServiceTier, requestServiceTier) {
@@ -407,6 +415,7 @@ var CodexApiError = class extends Error {
 		super(message);
 		this.name = "CodexApiError";
 		this.code = options?.code;
+		this.status = options?.status;
 		this.payload = options?.payload;
 		this.cause = options?.cause;
 	}
@@ -507,15 +516,9 @@ async function getWebSocketConstructor() {
 	if (typeof ctor !== "function") return null;
 	return ctor;
 }
-var WebSocketCloseError = class extends Error {
-	constructor(message, options) {
-		super(message);
-		this.name = "WebSocketCloseError";
-		this.code = options?.code;
-		this.reason = options?.reason;
-		this.wasClean = options?.wasClean;
-	}
-};
+function createWebSocketTransportError(message, cause) {
+	return Object.assign(new Error(message, cause ? { cause } : void 0), { code: extractErrorCodeOrErrno(cause) ?? WEBSOCKET_TRANSPORT_ERROR_CODE });
+}
 function getWebSocketReadyState(socket) {
 	const readyState = socket.readyState;
 	return typeof readyState === "number" ? readyState : void 0;
@@ -688,15 +691,15 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 function extractWebSocketError(event) {
 	if (event && typeof event === "object") {
 		const message = "message" in event ? event.message : void 0;
-		if (typeof message === "string" && message.length > 0) return new Error(message);
 		const nestedError = "error" in event ? event.error : void 0;
-		if (nestedError instanceof Error && nestedError.message.length > 0) return nestedError;
-		if (nestedError && typeof nestedError === "object" && "message" in nestedError) {
-			const nestedMessage = nestedError.message;
-			if (typeof nestedMessage === "string" && nestedMessage.length > 0) return new Error(nestedMessage);
+		const eventMessage = typeof message === "string" && message.length > 0 ? message : void 0;
+		if (nestedError !== void 0) {
+			const cause = toErrorObject(nestedError, eventMessage ?? "WebSocket error");
+			return createWebSocketTransportError(eventMessage ?? (cause.message || "WebSocket error"), cause);
 		}
+		if (eventMessage) return createWebSocketTransportError(eventMessage);
 	}
-	return /* @__PURE__ */ new Error("WebSocket error");
+	return createWebSocketTransportError("WebSocket error");
 }
 function extractWebSocketCloseError(event) {
 	if (event && typeof event === "object") {
@@ -706,13 +709,16 @@ function extractWebSocketCloseError(event) {
 		const codeText = typeof code === "number" ? ` ${code}` : "";
 		let reasonText = typeof reason === "string" && reason.length > 0 ? ` ${reason}` : "";
 		if (!reasonText && code === WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE) reasonText = " message too big";
-		return new WebSocketCloseError(`WebSocket closed${codeText}${reasonText}`.trim(), {
-			code: typeof code === "number" ? code : void 0,
+		const message = `WebSocket closed${codeText}${reasonText}`;
+		const error = typeof code === "number" && RETRYABLE_WEBSOCKET_CLOSE_CODES.has(code) ? createWebSocketTransportError(message) : Object.assign(new Error(message), { code: WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE });
+		return Object.assign(error, {
+			name: "WebSocketCloseError",
+			closeCode: typeof code === "number" ? code : void 0,
 			reason: typeof reason === "string" && reason.length > 0 ? reason : void 0,
 			wasClean: typeof wasClean === "boolean" ? wasClean : void 0
 		});
 	}
-	return /* @__PURE__ */ new Error("WebSocket closed");
+	return createWebSocketTransportError("WebSocket closed");
 }
 async function* parseWebSocket(socket, signal) {
 	const queue = [];
@@ -846,7 +852,7 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onFirst
 		yield event;
 	}
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onFirstProviderEvent, onStart, options, abortFirstEventStream, observePromptEgress, payloadVariant = "initial", onRequestSent) {
+async function processWebSocketStream(url, body, headers, output, stream, model, onFirstProviderEvent, onStart, options, abortFirstEventStream, observePromptEgress, payloadVariant = "initial", onRequestSent, activitySignal) {
 	const { socket, entry, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
 	let keepConnection = true;
 	const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
@@ -874,7 +880,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 			firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
 			abortFirstEventStream,
 			onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
-			signal: options?.signal,
+			signal: activitySignal ?? options?.signal,
 			reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
 				sessionId: options?.sessionId,
 				authProfileId: options?.authProfileId
@@ -953,7 +959,8 @@ async function readChatGptResponsesErrorTextLimited(response, signal) {
 	}
 	return text;
 }
-function parseErrorResponseText(raw, status, statusText) {
+function parseErrorResponse(raw, response) {
+	const { status, statusText } = response;
 	let message = raw || statusText || "Request failed";
 	let friendlyMessage;
 	let code;
@@ -969,11 +976,12 @@ function parseErrorResponseText(raw, status, statusText) {
 			message = err.message || friendlyMessage || message;
 		}
 	} catch {}
-	return {
-		...code ? { code } : {},
-		message,
-		friendlyMessage
-	};
+	const retryAfterSeconds = parseRetryAfterHeadersSeconds(response.headers);
+	const retryAfterSuffix = Number.isFinite(retryAfterSeconds) ? `; Retry-After: ${Math.ceil(retryAfterSeconds ?? 0)} seconds` : "";
+	return new CodexApiError(`${friendlyMessage || message}${retryAfterSuffix}`, {
+		code,
+		status
+	});
 }
 function extractOpenAICodexAccountId(token) {
 	const accountId = resolveOpenAICodexAccountId(token);

package/dist/openai-completions-KuoZyx0d.mjs

@@ -0,0 +1,187 @@
+import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
+import { i as clampThinkingLevel } from "./sanitize-unicode-Bb-v9meu.mjs";
+import { s as resolveOpenAICompletionsCompat } from "./openai-prompt-cache-BI0rkM-5.mjs";
+import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
+import { n as buildBaseOptions, o as reasoningTagTextPolicy } from "./simple-options-tcKOqnpF.mjs";
+import { _ as createOpenAIProviderAcceptanceHook, y as isOpenAICompletionsThinkingEnabled } from "./openai-transport-params-DNasp2fU.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
+import { _ as transportAbortError, t as assignTransportErrorDetails, y as withProviderResponseHook } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+import { a as tagUnresolvedTextAsCommentary, t as clearPendingCommentaryText } from "./assistant-text-phase-C20rxWwP.mjs";
+import { t as createAssistantOutput } from "./assistant-output-iqnlJCV2.mjs";
+import { t as resolveOpencodeSessionHeaders } from "./session-affinity-CCH7eYdB.mjs";
+import { a as convertMessages, i as buildOpenAICompletionsRequest, s as finalizeOpenAICompletionsToolCalls, t as processCompletionsStream } from "./openai-completions-stream-BQk3SkLD.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-2hfrquuz.mjs";
+import { n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-B37TB3rB.mjs";
+import { t as createOpenAIProviderClient } from "./openai-provider-client-ha_WxTyj.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, resolveOpencodeSessionHeaders(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-completions-compat-4IjSBpr6.d.mts → openai-completions-compat-CXn3T1we.d.mts}

@@ -1,6 +1,6 @@
-import "./index-AfaxKT8w.mjs";
-import { D as Model, j as OpenAICompletionsCompat } from "./types-DbrhszyQ.mjs";
-import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-BztR4tQj.mjs";
+import "./index-CQ6LTHw8.mjs";
+import { D as Model, j as OpenAICompletionsCompat } from "./types-Dy1q0CSu.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-DK3wmS3e.mjs";
 //#region packages/ai/src/transports/openai-completions-compat.d.ts
 type ProviderRequestCapabilities = AiProviderRequestCapabilities;
 type OpenAICompletionsSessionAffinity = "none" | "openai" | "openrouter";
@@ -30,7 +30,29 @@ type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "
   sessionAffinity: OpenAICompletionsSessionAffinity;
   visibleReasoningDetailTypes: string[];
   requiresNonEmptyUserOrAssistantMessage: boolean;
+  configuredSupportsLongCacheRetention?: boolean;
 };
+/** Native OpenAI defaults never apply to a configured proxy endpoint. */
+declare function isNativeOpenAIEndpoint(model: {
+  provider?: string;
+  baseUrl?: string;
+}): boolean;
+declare function isOpenAICodexResponsesModel(model: {
+  provider?: string;
+  api?: string;
+  baseUrl?: string;
+}): boolean;
+declare function usesNativeOpenAICodexResponsesBackend(model: {
+  provider?: string;
+  api?: string;
+  baseUrl?: string;
+}): boolean;
+declare function resolveOpenAIPromptCacheKeySupport(model: {
+  api?: string;
+  provider?: string;
+  baseUrl?: string;
+  compat?: Pick<OpenAICompletionsCompat, "supportsPromptCacheKey" | "supportsLongCacheRetention"> | null;
+}): boolean;
 /** Detects endpoint capabilities and defaults for an OpenAI-completions model. */
 declare function detectOpenAICompletionsCompat(model: Pick<Model<"openai-completions">, "provider" | "baseUrl" | "id"> & {
   compat?: {
@@ -40,4 +62,4 @@ declare function detectOpenAICompletionsCompat(model: Pick<Model<"openai-complet
 /** Applies explicit model overrides once on top of the canonical transport defaults. */
 declare function resolveOpenAICompletionsCompat(model: Pick<Model<"openai-completions">, "id" | "provider" | "baseUrl" | "compat">, resolveCapabilities?: (input: AiProviderRequestPolicyInput) => ProviderRequestCapabilities): ResolvedOpenAICompletionsCompat;
 //#endregion
-export { detectOpenAICompletionsCompat as n, resolveOpenAICompletionsCompat as r, ResolvedOpenAICompletionsCompat as t };
+export { resolveOpenAICompletionsCompat as a, isOpenAICodexResponsesModel as i, detectOpenAICompletionsCompat as n, resolveOpenAIPromptCacheKeySupport as o, isNativeOpenAIEndpoint as r, usesNativeOpenAICodexResponsesBackend as s, ResolvedOpenAICompletionsCompat as t };