@openclaw/ai 2026.9.4 → 2026.9.6

package/dist/{openai-chatgpt-responses-CgO6kZfo.mjs → openai-chatgpt-responses-sTxPl4zM.mjs}

@@ -1,22 +1,86 @@
-import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-CPeq9F7y.mjs";
+import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-DzrF1h4J.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-B8YfDGd4.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-Bds-n_9Q.mjs";
-import { l as extractErrorCodeOrErrno, o as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, u as toErrorObject } from "./diagnostics-QuErwCIl.mjs";
-import { s as resolveTimerTimeoutMs } from "./base64-D-su8YVo.mjs";
-import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-zrYjICLZ.mjs";
+import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { d as supportsOpenAITemperature } from "./openai-reasoning-effort-ash8dPrd.mjs";
+import { A as headersToRecord, n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-yTvBrYM2.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-CjV_2IRI.mjs";
+import { _ as extractErrorCodeOrErrno, o as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, v as toErrorObject } from "./diagnostics-CH8j2wIG.mjs";
+import { s as resolveTimerTimeoutMs } from "./base64-CPmadnUf.mjs";
+import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-03Qi0CN2.mjs";
 import { parseRetryAfterHeadersSeconds } from "./internal/retry-after.mjs";
-import { m as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-BQbb4yQL.mjs";
-import { _ as createOpenAIProviderAcceptanceHook, v as createOpenAIResponseHook } from "./openai-transport-params-9aPuV5YY.mjs";
+import { m as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-np1XPuhm.mjs";
+import { S as createResponseModelTracker, b as createOpenAIProviderAcceptanceHook, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, x as createOpenAIResponseHook } from "./openai-transport-params-DZKOTSfH.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { O as headersToRecord, b as withProviderResponseHook, m as notifyProviderStreamOpened, n as assignTransportErrorDetails, v as transportAbortError } from "./transport-stream-shared-zHll9BxO.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-2hfrquuz.mjs";
-import { C as supportsOpenAITemperature, m as responsesPromptObserver } from "./openai-responses-contracts-DDOHA62Y.mjs";
-import { F as resolveNextResponsesEncryptedContentAttempt, H as buildOpenAIResponsesReasoningReplayMetadata, K as suppressOpenAIResponsesCompaction, N as isInvalidEncryptedContentError, a as resolveResponsesReasoningEffort, h as ResponsesStreamFailure, i as createResponsesAssistantOutput, j as commitResponsesEncryptedContentAttempt, l as convertResponsesToolPayload, n as applyResponsesServiceTierPricing, o as resolveResponsesRequestReasoningEffort, r as convertResponsesMessages, u as processResponsesStream } from "./openai-responses-shared-B8RdBPCv.mjs";
+import { b as withProviderResponseHook, m as notifyProviderStreamOpened, n as assignTransportErrorDetails, v as transportAbortError } from "./transport-stream-shared-B5RioB_Q.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BeptfRL6.mjs";
+import { h as responsesPromptObserver } from "./openai-responses-contracts-DWrfMODE.mjs";
+import { D as ResponsesStreamFailure, E as resolveNextResponsesEncryptedContentAttempt, M as recordResponsesContextUsage, S as commitResponsesEncryptedContentAttempt, Z as suppressOpenAIResponsesCompaction, c as readOpenAIMisalignmentReview, i as createResponsesAssistantOutput, l as processResponsesStream, n as applyResponsesServiceTierPricing, o as convertResponsesToolPayload, q as buildOpenAIResponsesReasoningReplayMetadata, r as convertResponsesMessages, w as isInvalidEncryptedContentError } from "./openai-responses-shared-DvSqtJ6_.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-f8J7wpsk.mjs";
+import { i as resolveOpenAIResponsesTextFormat, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-DPHWgbBH.mjs";
+import { n as withResponsesRequestAcceptance, t as responsesRequestLifecycle } from "./openai-responses-request-lifecycle-DFuyO1pQ.mjs";
 import { n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-KWcgd0d_.mjs";
+//#region packages/ai/src/providers/openai-chatgpt-responses-events.ts
+var CodexApiError = class extends Error {
+	constructor(message, options) {
+		super(message);
+		this.name = "CodexApiError";
+		this.code = options?.code;
+		this.status = options?.status;
+		this.payload = options?.payload;
+		this.cause = options?.cause;
+	}
+};
+function extractCodexEventError(event) {
+	const nested = isRecord(event.error) ? event.error : void 0;
+	return {
+		code: typeof event.code === "string" ? event.code : typeof nested?.code === "string" ? nested.code : void 0,
+		message: typeof event.message === "string" ? event.message : typeof nested?.message === "string" ? nested.message : void 0
+	};
+}
+async function* mapCodexEvents(events, initialResponseHeaders, options) {
+	const responseModelTracker = createResponseModelTracker();
+	responseModelTracker.begin(initialResponseHeaders);
+	for await (const event of withResponsesRequestAcceptance(events, responsesRequestLifecycle.get(options), options?.signal)) {
+		responseModelTracker.observeEvent(event);
+		const type = typeof event.type === "string" ? event.type : void 0;
+		if (!type) continue;
+		if (type === "error") {
+			const { code, message } = extractCodexEventError(event);
+			throw new CodexApiError(`Codex error: ${message || code || JSON.stringify(event)}`, {
+				code,
+				payload: event
+			});
+		}
+		if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
+			const response = isRecord(event.response) ? event.response : void 0;
+			const normalizedResponse = response ? {
+				...response,
+				status: normalizeCodexStatus(response.status),
+				model: responseModelTracker.resolve()
+			} : response;
+			yield {
+				...event,
+				type: type === "response.done" ? "response.completed" : type,
+				response: normalizedResponse
+			};
+			return;
+		}
+		yield event;
+	}
+}
+function normalizeCodexStatus(status) {
+	switch (status) {
+		case "completed":
+		case "incomplete":
+		case "failed":
+		case "cancelled":
+		case "queued":
+		case "in_progress": return status;
+		default: return;
+	}
+}
+//#endregion
 //#region packages/ai/src/providers/openai-chatgpt-responses-protocol.ts
 const OPENAI_CHATGPT_RESPONSES_SUCCESS_BODY_MAX_BYTES = 16777216;
 var CodexProtocolError = class extends Error {
@@ -98,14 +162,6 @@ const RETRYABLE_WEBSOCKET_CLOSE_CODES = /* @__PURE__ */ new Set([
 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;
-const CODEX_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
-	"completed",
-	"incomplete",
-	"failed",
-	"cancelled",
-	"queued",
-	"in_progress"
-]);
 function resolveRequestTimeoutMs(options) {
 	const timeoutMs = options?.timeoutMs;
 	return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? resolveTimerTimeoutMs(timeoutMs, 1) : void 0;
@@ -190,7 +246,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					websocketStarted = false;
 					websocketRequestSent = false;
 					try {
-						await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), activeAttempt.request, websocketHeaders, output, stream, model, () => {
+						const terminal = await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), activeAttempt.request, websocketHeaders, output, stream, model, () => {
 							websocketStarted = true;
 						}, () => {
 							commitSemanticAttempt(activeAttempt);
@@ -199,6 +255,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 						}, options?.signal);
 						if (activeSignal?.aborted) throw transportAbortError(activeSignal);
 						if (output.stopReason === "aborted" || output.stopReason === "error") throw new CodexApiError(output.errorMessage ?? "An unknown error occurred");
+						if (terminal && activeAttempt.kind === "initial") recordResponsesContextUsage(output, model, options, activeAttempt.request, terminal.output, "provider");
 						stream.push({
 							type: "done",
 							reason: output.stopReason,
@@ -249,6 +306,12 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				});
 				let attemptResponse;
 				try {
+					const lifecycle = responsesRequestLifecycle.get(options);
+					if (lifecycle) {
+						await lifecycle.beforeDispatch(activeSignal);
+						activeSignal?.throwIfAborted();
+						lifecycle.assertCurrent();
+					}
 					attemptResponse = await fetch(resolveCodexUrl(model.baseUrl), {
 						method: "POST",
 						headers: sseHeaders,
@@ -291,7 +354,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				semanticAttempt = nextSemanticAttempt;
 			}
 			const hookedResponseStream = withProviderResponseHook({
-				stream: mapCodexEvents(parseOpenAIChatGptResponsesSse(response)),
+				stream: mapCodexEvents(parseOpenAIChatGptResponsesSse(response), response.headers, requestOptions),
 				signal: firstEventAbort.signal,
 				abort: firstEventAbort.abort,
 				hook: createOpenAIProviderAcceptanceHook(options, response, model),
@@ -300,7 +363,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					partial: output
 				})
 			});
-			await processResponsesStream(hookedResponseStream, output, stream, model, {
+			const terminal = await processResponsesStream(hookedResponseStream, output, stream, model, {
 				serviceTier: options?.serviceTier,
 				firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
 				abortFirstEventStream: firstEventAbort.abort,
@@ -315,6 +378,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			});
 			if (activeSignal?.aborted) throw transportAbortError(activeSignal);
 			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+			if (terminal && semanticAttempt.kind === "initial") recordResponsesContextUsage(output, model, options, semanticAttempt.request, terminal.output, "provider");
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -322,9 +386,20 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			});
 			stream.end();
 		} catch (error) {
+			await responsesRequestLifecycle.get(options)?.settle().catch(() => void 0);
 			const requestTimedOut = isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0;
 			const normalizedError = requestTimedOut && requestTimeoutMs !== void 0 ? formatRequestTimeoutError(requestTimeoutMs, error) : error;
 			for (const block of output.content) delete block.partialJson;
+			const providerRefusal = readCodexProviderRefusal(normalizedError);
+			if (providerRefusal) appendAssistantMessageDiagnostic(output, {
+				type: "provider_refusal",
+				timestamp: Date.now(),
+				details: {
+					provider: "openai",
+					category: providerRefusal.category,
+					...providerRefusal.review ? { review: providerRefusal.review } : {}
+				}
+			});
 			const terminal = assignTransportErrorDetails(output, normalizedError, options?.signal);
 			getAiTransportHost().logWarn("openai-transport", "ChatGPT Responses stream terminated", {
 				provider: model.provider,
@@ -353,9 +428,11 @@ const streamSimpleOpenAICodexResponses = (model, context, options) => {
 	const resolvedOptions = {
 		...buildBaseOptions(model, options, apiKey),
 		authProfileId: options?.authProfileId,
-		reasoningEffort: resolveResponsesReasoningEffort(model, options?.reasoning)
+		reasoningEffort: resolveOpenAISimpleReasoningEffort(model, options?.reasoning)
 	};
 	responsesPromptObserver.copy(options, resolvedOptions);
+	const lifecycle = responsesRequestLifecycle.get(options);
+	if (lifecycle) responsesRequestLifecycle.set(resolvedOptions, lifecycle);
 	return streamOpenAICodexResponses(model, context, resolvedOptions);
 };
 function buildRequestBody(model, context, options, replayMode = "checkpoint") {
@@ -376,20 +453,24 @@ function buildRequestBody(model, context, options, replayMode = "checkpoint") {
 		include: ["reasoning.encrypted_content"],
 		prompt_cache_key: options?.cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId)
 	};
+	if (options?.responseFormat !== void 0) body.text = {
+		...body.text,
+		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
+	};
 	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 tools = convertResponsesToolPayload(context.tools, { strict: null });
+		const tools = convertResponsesToolPayload(context.tools, { strict: false });
 		if (tools.length > 0) {
 			body.tools = tools;
 			body.tool_choice = "auto";
 			body.parallel_tool_calls = true;
 		}
 	}
-	const effort = options?.reasoningEffort === void 0 ? void 0 : resolveResponsesRequestReasoningEffort(model, options.reasoningEffort);
+	const effort = options?.reasoningEffort === void 0 ? void 0 : resolveOpenAIRequestReasoning(model, options.reasoningEffort).effort;
 	if (effort !== void 0) body.reasoning = {
 		effort,
-		summary: options?.reasoningSummary ?? "auto"
+		...effort === "none" ? {} : { summary: options?.reasoningSummary ?? "auto" }
 	};
 	return body;
 }
@@ -409,60 +490,39 @@ function resolveCodexWebSocketUrl(baseUrl) {
 	if (url.protocol === "http:") url.protocol = "ws:";
 	return url.toString();
 }
-var CodexApiError = class extends Error {
-	constructor(message, options) {
-		super(message);
-		this.name = "CodexApiError";
-		this.code = options?.code;
-		this.status = options?.status;
-		this.payload = options?.payload;
-		this.cause = options?.cause;
+function isJsonRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Structured refusal code carried by the OpenAI Responses transport. Every
+* terminal Responses path preserves it: a non-OK HTTP body parsed by
+* {@link parseErrorResponse}, an SSE/WebSocket `error` event mapped by
+* {@link mapCodexEvents}, and a `response.failed` event normalized into
+* {@link ResponsesStreamFailure}. Only the app-server surface carries the
+* `codexErrorInfo` discriminator, so both shapes must be read here.
+*/
+function readCodexProviderRefusal(error) {
+	if (!(error instanceof ResponsesStreamFailure || error instanceof CodexApiError)) return;
+	const payload = error instanceof CodexApiError ? error.payload : isJsonRecord(error.response) ? error.response : void 0;
+	const nested = isJsonRecord(payload?.error) ? payload.error : void 0;
+	const codexErrorInfo = payload?.codexErrorInfo ?? nested?.codexErrorInfo;
+	if (error.code === "cyber_policy" || codexErrorInfo === "cyberPolicy") return { category: "cyber" };
+	if (error.code === "misalignment_policy_violation" || codexErrorInfo === "misalignmentPolicyViolation") {
+		const details = nested?.misalignment ?? payload?.misalignment;
+		const review = readOpenAIMisalignmentReview(details, true);
+		return {
+			category: "misalignment",
+			...review ? { review } : {}
+		};
 	}
-};
+	return (typeof payload?.message === "string" ? payload.message : typeof nested?.message === "string" ? nested.message : "").startsWith("This content was flagged for possible biological risk.") ? { category: "bio" } : void 0;
+}
 function isCodexNonTransportError(error) {
 	return error instanceof CodexApiError || error instanceof CodexProtocolError || error instanceof ResponsesStreamFailure;
 }
 function isWebSocketConnectionLimitReachedError(error) {
 	return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
 }
-function extractCodexEventError(event) {
-	const nested = event.error && typeof event.error === "object" ? event.error : void 0;
-	return {
-		code: typeof event.code === "string" ? event.code : typeof nested?.code === "string" ? nested.code : void 0,
-		message: typeof event.message === "string" ? event.message : typeof nested?.message === "string" ? nested.message : void 0
-	};
-}
-async function* mapCodexEvents(events) {
-	for await (const event of events) {
-		const type = typeof event.type === "string" ? event.type : void 0;
-		if (!type) continue;
-		if (type === "error") {
-			const { code, message } = extractCodexEventError(event);
-			throw new CodexApiError(`Codex error: ${message || code || JSON.stringify(event)}`, {
-				code,
-				payload: event
-			});
-		}
-		if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
-			const response = event.response;
-			const normalizedResponse = response ? {
-				...response,
-				status: normalizeCodexStatus(response.status)
-			} : response;
-			yield {
-				...event,
-				type: type === "response.done" ? "response.completed" : type,
-				response: normalizedResponse
-			};
-			return;
-		}
-		yield event;
-	}
-}
-function normalizeCodexStatus(status) {
-	if (typeof status !== "string") return;
-	return CODEX_RESPONSE_STATUSES.has(status) ? status : void 0;
-}
 const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
 const SESSION_WEBSOCKET_CACHE_TTL_MS = 3e5;
 const SESSION_WEBSOCKET_MAX_AGE_MS = 33e5;
@@ -614,11 +674,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		const socket = await connectWebSocket(url, headers, signal);
 		return {
 			socket,
-			release: ({ keep } = {}) => {
-				if (keep === false) {
-					closeWebSocketSilently(socket);
-					return;
-				}
+			release: () => {
 				closeWebSocketSilently(socket);
 			}
 		};
@@ -863,12 +919,18 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 			egress: "native-codex-websocket",
 			payloadVariant
 		});
+		const lifecycle = responsesRequestLifecycle.get(options);
+		if (lifecycle) {
+			await lifecycle.beforeDispatch(options?.signal);
+			options?.signal?.throwIfAborted();
+			lifecycle.assertCurrent();
+		}
 		socket.send(JSON.stringify({
 			type: "response.create",
 			...requestBody
 		}));
 		onRequestSent?.();
-		await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal)), output, stream, onFirstProviderEvent, () => notifyProviderStreamOpened({
+		const terminal = await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal), void 0, options), output, stream, onFirstProviderEvent, () => notifyProviderStreamOpened({
 			options,
 			cancelStream: () => {
 				keepConnection = false;
@@ -901,6 +963,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 				lastResponseItems: responseItems
 			};
 		}
+		return terminal;
 	} catch (error) {
 		if (entry) entry.continuation = void 0;
 		keepConnection = false;
@@ -963,8 +1026,11 @@ function parseErrorResponse(raw, response) {
 	let message = raw || statusText || "Request failed";
 	let friendlyMessage;
 	let code;
+	let payload;
 	try {
-		const err = JSON.parse(raw)?.error;
+		const parsed = JSON.parse(raw);
+		payload = isJsonRecord(parsed) ? parsed : void 0;
+		const err = parsed?.error;
 		if (err) {
 			code = err.code || err.type || void 0;
 			if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code ?? "") || status === 429) {
@@ -979,7 +1045,8 @@ function parseErrorResponse(raw, response) {
 	const retryAfterSuffix = Number.isFinite(retryAfterSeconds) ? `; Retry-After: ${Math.ceil(retryAfterSeconds ?? 0)} seconds` : "";
 	return new CodexApiError(`${friendlyMessage || message}${retryAfterSuffix}`, {
 		code,
-		status
+		status,
+		payload
 	});
 }
 function extractOpenAICodexAccountId(token) {

package/dist/{openai-completions-yJuk7eis.mjs → openai-completions-BO6D_hrB.mjs}

@@ -1,19 +1,19 @@
 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 { N as clampThinkingLevel } from "./host-yTvBrYM2.mjs";
+import { i as resolveOpenAICompletionsCompat } from "./openai-completions-compat-CUollwl6.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 buildBaseOptions, o as reasoningTagTextPolicy } from "./simple-options-np1XPuhm.mjs";
+import { C as isOpenAICompletionsThinkingEnabled, b as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-DZKOTSfH.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 { b as withProviderResponseHook, n as assignTransportErrorDetails, v as transportAbortError } from "./transport-stream-shared-B5RioB_Q.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 { t as createAssistantOutput } from "./assistant-output-DM1JBNs1.mjs";
+import { a as convertMessages, i as buildOpenAICompletionsRequest, s as finalizeOpenAICompletionsToolCalls, t as processCompletionsStream } from "./openai-completions-stream-BpuJ0ZOA.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BeptfRL6.mjs";
+import { n as resolveProviderSimpleCompletionHeaders } from "./provider-transport-turn-state-lrXEFkYr.mjs";
 import { n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-B37TB3rB.mjs";
-import { t as createOpenAIProviderClient } from "./openai-provider-client-S2gCrM2Z.mjs";
+import { t as createOpenAIProviderClient } from "./openai-provider-client-BP8J1aeg.mjs";
 //#region packages/ai/src/providers/openai-completions.ts
 var openai_completions_exports = /* @__PURE__ */ __exportAll({
 	convertMessages: () => convertMessages,
@@ -154,11 +154,10 @@ const streamSimpleOpenAICompletions = (model, context, options) => {
 	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,
+		reasoningEffort: clampedReasoning,
 		toolChoice
 	});
 };

package/dist/{openai-prompt-cache-Bds-n_9Q.mjs → openai-completions-compat-CUollwl6.mjs}

@@ -1,18 +1,5 @@
 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
+import { a as resolveProviderRequestCapabilities } from "./host-policy-DZO3oPPk.mjs";
 //#region packages/ai/src/providers/openai-response-format.ts
 const JSON_SCHEMA_RESPONSE_FORMAT_NAME = "openclaw_response";
 const OLLAMA_CLOUD_ORIGIN = "https://ollama.com";
@@ -127,9 +114,6 @@ function resolveOpenAICompletionsCompatDefaults(input) {
 		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)))({
@@ -143,7 +127,7 @@ function detectOpenAICompletionsCompat(model, resolveCapabilities) {
 	});
 	return {
 		capabilities,
-		defaults: resolveOpenAICompletionsCompatDefaultsFromCapabilities({
+		defaults: resolveOpenAICompletionsCompatDefaults({
 			provider: model.provider,
 			modelId: model.id,
 			baseUrl: model.baseUrl,
@@ -164,6 +148,8 @@ function resolveOpenAICompletionsCompat(model, resolveCapabilities) {
 		supportsStore: configured?.supportsStore ?? defaults.supportsStore,
 		supportsDeveloperRole: configured?.supportsDeveloperRole ?? defaults.supportsDeveloperRole,
 		supportsReasoningEffort: configured?.supportsReasoningEffort ?? defaults.supportsReasoningEffort,
+		supportedReasoningEfforts: configured?.supportedReasoningEfforts,
+		reasoningEffortMap: configured?.reasoningEffortMap,
 		supportsUsageInStreaming: configured?.supportsUsageInStreaming ?? defaults.supportsUsageInStreaming,
 		maxTokensField: configured?.maxTokensField ?? defaults.maxTokensField,
 		requiresToolResultName: configured?.requiresToolResultName ?? false,
@@ -186,35 +172,4 @@ function resolveOpenAICompletionsCompat(model, resolveCapabilities) {
 	};
 }
 //#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 };
+export { resolveOpenAIPromptCacheKeySupport as a, shouldOmitOllamaCompatResponseFormat as c, resolveOpenAICompletionsCompat as i, isNativeOpenAIEndpoint as n, usesNativeOpenAICodexResponsesBackend as o, isOpenAICodexResponsesModel as r, resolveOpenAICompletionsResponseFormat as s, detectOpenAICompletionsCompat as t };

package/dist/{openai-completions-compat-eHgh5UPE.d.mts → openai-completions-compat-DfJG1wSO.d.mts}

@@ -1,6 +1,6 @@
-import "./index-DdD3qerf.mjs";
-import { M as OpenAICompletionsCompat, O as Model } from "./types-Ntv5z2g2.mjs";
-import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-4atIX-2V.mjs";
+import "./index-C25RT6bP.mjs";
+import { M as OpenAICompletionsCompat, O as Model } from "./types-qZFbaDbK.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-DH-Z-LDb.mjs";
 //#region packages/ai/src/transports/openai-completions-compat.d.ts
 type ProviderRequestCapabilities = AiProviderRequestCapabilities;
 type OpenAICompletionsSessionAffinity = "none" | "openai" | "openrouter";
@@ -24,7 +24,7 @@ type DetectedOpenAICompletionsCompat = {
   capabilities: ProviderRequestCapabilities;
   defaults: OpenAICompletionsCompatDefaults;
 };
-type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "cacheControlFormat" | "openRouterRouting" | "sendSessionAffinityHeaders" | "reasoningEffortMap"> & {
+type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "cacheControlFormat" | "openRouterRouting" | "sendSessionAffinityHeaders" | "reasoningEffortMap" | "supportedReasoningEfforts"> & Pick<OpenAICompletionsCompat, "reasoningEffortMap" | "supportedReasoningEfforts"> & {
   cacheControlFormat?: OpenAICompletionsCompat["cacheControlFormat"];
   openRouterRouting?: OpenAICompletionsCompat["openRouterRouting"];
   sessionAffinity: OpenAICompletionsSessionAffinity;