@openclaw/ai 2026.9.4 → 2026.9.5

package/dist/{openai-responses-compaction-window-CIhBAkkq.mjs → openai-responses-compaction-window-D6P5oZP5.mjs}

@@ -1,8 +1,9 @@
 import { i as normalizeOptionalLowercaseString, n as normalizeLowercaseStringOrEmpty, s as readStringValue } from "./string-coerce-fsri9iCu.mjs";
 import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
-import { t as canonicalizeBase64 } from "./base64-D-su8YVo.mjs";
-import { t as parsePositiveInteger } from "./positive-integer-41zhOdcV.mjs";
-import { S as supportsOpenAIReasoningEffort, i as OPENAI_RESPONSES_APIS } from "./openai-responses-contracts-DDOHA62Y.mjs";
+import { l as supportsOpenAIReasoningEffort } from "./openai-reasoning-effort-NlFZmfEu.mjs";
+import { t as canonicalizeBase64 } from "./base64-BQOzsvUH.mjs";
+import { t as parsePositiveInteger } from "./positive-integer-DtjCkbue.mjs";
+import { i as OPENAI_RESPONSES_APIS } from "./openai-responses-contracts-DWrfMODE.mjs";
 import { t as createSseByteGuard } from "./streaming-byte-guard-CC-HMn_u.mjs";
 //#region packages/model-catalog-core/src/provider-id.ts
 function normalizeProviderId(provider) {
@@ -20,33 +21,6 @@ const OPENAI_RESPONSES_PROVIDERS = /* @__PURE__ */ new Set([
 	"azure-openai",
 	"azure-openai-responses"
 ]);
-const LOCAL_ENDPOINT_HOSTS = /* @__PURE__ */ new Set([
-	"localhost",
-	"127.0.0.1",
-	"::1",
-	"[::1]"
-]);
-const MODELSTUDIO_NATIVE_BASE_URLS = /* @__PURE__ */ new Set([
-	"https://coding-intl.dashscope.aliyuncs.com/v1",
-	"https://coding.dashscope.aliyuncs.com/v1",
-	"https://dashscope.aliyuncs.com/compatible-mode/v1",
-	"https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-]);
-const MOONSHOT_NATIVE_BASE_URLS = /* @__PURE__ */ new Set(["https://api.moonshot.ai/v1", "https://api.moonshot.cn/v1"]);
-function normalizeComparableBaseUrl(value) {
-	const trimmed = readStringValue(value)?.trim();
-	if (!trimmed) return;
-	const parsedValue = /^[a-z0-9.[\]-]+(?::\d+)?(?:[/?#].*)?$/i.test(trimmed) ? `https://${trimmed}` : trimmed;
-	try {
-		const url = new URL(parsedValue);
-		if (url.protocol !== "http:" && url.protocol !== "https:") return;
-		url.hash = "";
-		url.search = "";
-		return url.toString().replace(/\/+$/, "").toLowerCase();
-	} catch {
-		return;
-	}
-}
 function resolveUrlHostname(value) {
 	const trimmed = readStringValue(value)?.trim();
 	if (!trimmed) return;
@@ -60,45 +34,22 @@ function resolveUrlHostname(value) {
 		}
 	}
 }
-function hostMatchesSuffix(host, suffix) {
-	return suffix.startsWith(".") || suffix.startsWith("-") ? host.endsWith(suffix) : host === suffix || host.endsWith(`.${suffix}`);
-}
-function isLocalEndpointHost(host) {
-	return LOCAL_ENDPOINT_HOSTS.has(host) || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal");
-}
-function resolveBundledOpenAIResponsesEndpointClass(baseUrl) {
+function resolveOpenAIResponsesEndpointClass(baseUrl) {
 	const trimmed = readStringValue(baseUrl)?.trim();
 	if (!trimmed) return "default";
 	const host = resolveUrlHostname(trimmed);
-	if (!host) return "invalid";
-	const comparableBaseUrl = normalizeComparableBaseUrl(trimmed);
+	if (!host) return "custom";
 	switch (host) {
-		case "api.anthropic.com": return "anthropic-public";
-		case "api.cerebras.ai": return "cerebras-native";
-		case "llm.chutes.ai": return "chutes-native";
-		case "api.deepseek.com": return "deepseek-native";
-		case "api.groq.com": return "groq-native";
-		case "api.mistral.ai": return "mistral-public";
 		case "api.openai.com": return "openai-public";
 		case "chatgpt.com": return "openai";
-		case "generativelanguage.googleapis.com": return "google-generative-ai";
-		case "aiplatform.googleapis.com": return "google-vertex";
 		case "api.x.ai": return "xai-native";
-		case "api.z.ai": return "zai-native";
 	}
-	if (hostMatchesSuffix(host, ".githubcopilot.com")) return "github-copilot-native";
 	if ([
 		".openai.azure.com",
 		".cognitiveservices.azure.com",
 		".services.ai.azure.com",
 		".api.cognitive.microsoft.com"
-	].some((suffix) => hostMatchesSuffix(host, suffix))) return "azure-openai";
-	if (hostMatchesSuffix(host, "openrouter.ai")) return "openrouter";
-	if (hostMatchesSuffix(host, "opencode.ai")) return "opencode-native";
-	if (hostMatchesSuffix(host, "-aiplatform.googleapis.com")) return "google-vertex";
-	if (comparableBaseUrl && MOONSHOT_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "moonshot-native";
-	if (comparableBaseUrl && MODELSTUDIO_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "modelstudio-native";
-	if (isLocalEndpointHost(host)) return "local";
+	].some((suffix) => host.endsWith(suffix))) return "azure-openai";
 	return "custom";
 }
 function isOpenAIResponsesApi(api) {
@@ -113,7 +64,7 @@ function resolveOpenAIResponsesPayloadCapabilities(model) {
 	const provider = normalizeOptionalLowercaseString(model.provider);
 	const api = normalizeOptionalLowercaseString(model.api);
 	const isOpenAIProvider = provider === "openai";
-	const endpointClass = resolveBundledOpenAIResponsesEndpointClass(model.baseUrl);
+	const endpointClass = resolveOpenAIResponsesEndpointClass(model.baseUrl);
 	const isResponsesApi = isOpenAIResponsesApi(api);
 	const usesConfiguredBaseUrl = endpointClass !== "default";
 	const usesKnownNativeOpenAIEndpoint = endpointClass === "openai-public" || endpointClass === "openai" || endpointClass === "azure-openai";
@@ -123,9 +74,11 @@ function resolveOpenAIResponsesPayloadCapabilities(model) {
 	const promptCacheKeySupport = readCompatPayloadBoolean(model.compat, "supportsPromptCacheKey");
 	const shouldStripResponsesPromptCache = promptCacheKeySupport === true ? false : promptCacheKeySupport === false ? isResponsesApi : isResponsesApi && usesExplicitProxyLikeEndpoint;
 	const supportsResponsesStoreField = readCompatPayloadBoolean(model.compat, "supportsStore") !== false && isResponsesApi;
+	const explicitContinuationOptIn = (api === "openai-responses" || api === "openclaw-openai-responses-transport") && supportsResponsesStoreField && provider !== "azure-openai" && provider !== "azure-openai-responses" && readCompatPayloadBoolean(model.compat, "supportsResponsesContinuation") === true;
 	return {
 		allowsOpenAIServiceTier: provider === "openai" && (api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai-public" || isOpenAIProvider && (api === "openai-chatgpt-responses" || api === "openclaw-openai-chatgpt-responses-transport" || api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai",
 		allowsResponsesStore: supportsResponsesStoreField && api !== "openai-chatgpt-responses" && api !== "openclaw-openai-chatgpt-responses-transport" && provider !== void 0 && OPENAI_RESPONSES_PROVIDERS.has(provider) && usesKnownNativeOpenAIEndpoint,
+		explicitContinuationOptIn,
 		shouldStripResponsesPromptCache,
 		supportsResponsesStoreField,
 		usesKnownNativeOpenAIRoute,
@@ -150,11 +103,14 @@ function resolveOpenAIResponsesServerCompactionPlan(model, extraParams) {
 		threshold: enabled ? parsePositiveInteger(extraParams?.responsesCompactThreshold) ?? resolveOpenAIResponsesCompactThreshold(model) : void 0
 	};
 }
-/** Resolve the manual Responses compact-endpoint gate for one route. */
-function resolveOpenAIResponsesCompactEndpointPlan(model, extraParams) {
+/** Resolve the Responses compact-endpoint gate for one route and compaction purpose. */
+function resolveOpenAIResponsesCompactEndpointPlan(model, extraParams, purpose = "manual") {
 	const configured = extraParams?.responsesCompactEndpoint;
 	const provider = typeof model.provider === "string" ? normalizeProviderId(model.provider) : "";
-	return { enabled: isOpenAIResponsesApi(normalizeOptionalLowercaseString(model.api)) && (configured === true || configured !== false && (provider === "xai" || provider === "x-ai") && resolveBundledOpenAIResponsesEndpointClass(model.baseUrl) === "xai-native") };
+	const api = normalizeOptionalLowercaseString(model.api);
+	const endpointClass = resolveOpenAIResponsesEndpointClass(model.baseUrl);
+	const enabledByDefault = (provider === "xai" || provider === "x-ai") && endpointClass === "xai-native" || purpose === "budget" && provider === "openai" && api === "openai-responses" && endpointClass === "openai-public";
+	return { enabled: isOpenAIResponsesApi(api) && configured !== false && (configured === true || enabledByDefault) };
 }
 function stripDisabledOpenAIReasoningPayload(payloadObj) {
 	const reasoning = payloadObj.reasoning;
@@ -174,15 +130,17 @@ function stripInputItemStatuses(input) {
 function resolveOpenAIResponsesPayloadPolicy(model, options = {}) {
 	const capabilities = resolveOpenAIResponsesPayloadCapabilities(model);
 	const storeMode = options.storeMode ?? "provider-policy";
-	const explicitStore = storeMode === "preserve" ? void 0 : storeMode === "disable" ? capabilities.supportsResponsesStoreField ? false : void 0 : capabilities.allowsResponsesStore ? true : void 0;
+	const explicitStore = storeMode === "preserve" ? void 0 : storeMode === "disable" || storeMode === "transport-default" && !capabilities.explicitContinuationOptIn ? capabilities.supportsResponsesStoreField ? false : void 0 : capabilities.allowsResponsesStore || capabilities.explicitContinuationOptIn ? true : void 0;
 	const isResponsesApi = isOpenAIResponsesApi(normalizeOptionalLowercaseString(model.api));
-	const shouldStripDisabledReasoningPayload = isResponsesApi && (!capabilities.usesKnownNativeOpenAIRoute || !supportsOpenAIReasoningEffort(model, "none"));
+	const shouldStripDisabledReasoningPayload = isResponsesApi && !supportsOpenAIReasoningEffort(capabilities.usesKnownNativeOpenAIRoute ? model : { compat: model.compat }, "none");
 	const shouldStripInputStatus = isResponsesApi && !capabilities.usesKnownNativeOpenAIRoute;
 	const serverCompactionPlan = resolveOpenAIResponsesServerCompactionPlan(model, options.extraParams);
 	const usesInstructionsField = readCompatPayloadBoolean(model.compat, "supportsInstructions") ?? capabilities.usesVerifiedInstructionsEndpoint;
 	return {
 		allowsServiceTier: capabilities.allowsOpenAIServiceTier,
 		compactThreshold: serverCompactionPlan.threshold,
+		defaultManagedReasoningEffort: capabilities.usesKnownNativeOpenAIRoute && !shouldStripDisabledReasoningPayload && model.provider !== "github-copilot" ? "none" : void 0,
+		explicitContinuationOptIn: capabilities.explicitContinuationOptIn,
 		explicitStore,
 		shouldStripDisabledReasoningPayload,
 		shouldStripInputStatus,

package/dist/openai-responses-contracts-DWrfMODE.mjs

@@ -0,0 +1,81 @@
+import { r as PROVIDER_POST_DISPATCH_AMBIGUITY_ERROR_CODE } from "./types-LFWwv0cF.mjs";
+import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+//#region packages/ai/src/transports/openai-responses-contracts.ts
+const DEFAULT_AZURE_OPENAI_API_VERSION = "preview";
+const OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS = "Follow the user request.";
+const AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS = 3e4;
+const RESPONSE_FAILED_NO_DETAILS_MESSAGE = "Unknown error (no error details in response)";
+const OPENAI_RESPONSES_REASONING_REPLAY_META_KEY = "__openclaw_replay";
+const OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY = "openclawReasoningReplay";
+const OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE = "openai-responses-compaction";
+const OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE = "openai-responses-retained-compaction";
+const OPENAI_RESPONSES_APIS = /* @__PURE__ */ new Set([
+	"openai-responses",
+	"azure-openai-responses",
+	"openai-chatgpt-responses",
+	"openclaw-openai-responses-transport",
+	"openclaw-openai-chatgpt-responses-transport",
+	"openclaw-azure-openai-responses-transport"
+]);
+var OpenAIResponsesWebSocketPreDispatchError = class extends Error {
+	constructor(cause) {
+		super("OpenAI Responses WebSocket failed before request dispatch", { cause });
+		this.name = "OpenAIResponsesWebSocketPreDispatchError";
+	}
+};
+var OpenAIResponsesWebSocketPostDispatchError = class extends Error {
+	constructor(cause) {
+		super("OpenAI Responses WebSocket failed after request dispatch; outcome is unknown", { cause });
+		this.code = PROVIDER_POST_DISPATCH_AMBIGUITY_ERROR_CODE;
+		this.name = "OpenAIResponsesWebSocketPostDispatchError";
+	}
+};
+var OpenAIResponsesWebSocketServerError = class extends Error {
+	constructor(code, status, param, message, cause) {
+		super(message, { cause });
+		this.code = code;
+		this.status = status;
+		this.param = param;
+		this.name = "OpenAIResponsesWebSocketServerError";
+	}
+};
+var OpenAIResponsesWebSocketSafeRetryError = class extends OpenAIResponsesWebSocketServerError {};
+function readWebSocketServerError(value) {
+	if (!isRecord(value) || value.type !== "error") return;
+	const details = isRecord(value.error) ? value.error : value;
+	if (typeof details.code !== "string" || typeof details.message !== "string") return;
+	const rawStatus = value.status ?? value.status_code;
+	return {
+		code: details.code,
+		message: details.message,
+		param: typeof details.param === "string" ? details.param : null,
+		status: typeof rawStatus === "number" ? rawStatus : void 0
+	};
+}
+function isPreviousResponseRejection(error) {
+	return error.code === "previous_response_not_found" || error.code === "unsupported_parameter" && error.param === "previous_response_id";
+}
+function parseOpenAIResponsesWebSocketServerError(cause) {
+	if (!isRecord(cause)) return;
+	let details = readWebSocketServerError(cause.error) ?? readWebSocketServerError(cause);
+	if (!details && typeof cause.message === "string") try {
+		details = readWebSocketServerError(JSON.parse(cause.message));
+	} catch {}
+	if (!details) return;
+	return new (isPreviousResponseRejection(details) || details.code === "websocket_connection_limit_reached" || details.code === "invalid_encrypted_content" || details.code === "thinking_signature_invalid" ? OpenAIResponsesWebSocketSafeRetryError : OpenAIResponsesWebSocketServerError)(details.code, details.status, details.param, details.message, cause);
+}
+const PROMPT_OBSERVER = Symbol("openaiResponsesPromptObserver");
+const responsesPromptObserver = {
+	set(options, observer) {
+		Reflect.set(options, PROMPT_OBSERVER, observer);
+	},
+	get(options) {
+		return Reflect.get(options, PROMPT_OBSERVER);
+	},
+	copy(source, target) {
+		const observer = source && responsesPromptObserver.get(source);
+		if (observer) responsesPromptObserver.set(target, observer);
+	}
+};
+//#endregion
+export { OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE as a, OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE as c, OpenAIResponsesWebSocketSafeRetryError as d, RESPONSE_FAILED_NO_DETAILS_MESSAGE as f, responsesPromptObserver as h, OPENAI_RESPONSES_APIS as i, OpenAIResponsesWebSocketPostDispatchError as l, parseOpenAIResponsesWebSocketServerError as m, DEFAULT_AZURE_OPENAI_API_VERSION as n, OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY as o, isPreviousResponseRejection as p, OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS as r, OPENAI_RESPONSES_REASONING_REPLAY_META_KEY as s, AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS as t, OpenAIResponsesWebSocketPreDispatchError as u };

package/dist/{openai-responses-contracts-BjBAqAg_.d.mts → openai-responses-contracts-Dflvrfa8.d.mts}

@@ -1,7 +1,11 @@
-import "./index-DdD3qerf.mjs";
-import { O as Model, n as Api } from "./types-Ntv5z2g2.mjs";
-import { a as BaseOpenAIStreamOptions, f as OpenAIReasoningEffort } from "./provider-options-Ceqv1OKk.mjs";
+import "./index-DaF2QbwS.mjs";
+import { O as Model, j as ModelThinkingLevel, n as Api } from "./types-4_uVs5WH.mjs";
+import { a as BaseOpenAIStreamOptions, f as OpenAIReasoningEffort } from "./provider-options-DprLsWh9.mjs";
+import "./types-DkJfb4W3.mjs";
 import { ResponseCompactionItem, ResponseCreateParamsStreaming, ResponseInputItem } from "openai/resources/responses/responses.js";
+//#region packages/ai/src/providers/openai-request-reasoning.d.ts
+type OpenAIRequestReasoningEffort = ModelThinkingLevel | "none";
+//#endregion
 //#region packages/ai/src/transports/openai-responses-compaction-window.d.ts
 type OpenAIResponsesCompactionOutput = Array<ResponseInputItem.Message | ReplayableResponseCompactionItem>;
 /** Read the saved canonical window only when it still matches its opaque checkpoint. */
@@ -27,7 +31,7 @@ type OpenAIResponsesReasoningReplayMetadata = {
   authProfileHash?: string;
 };
 type OpenAIResponsesOptions = BaseOpenAIStreamOptions & {
-  reasoning?: OpenAIReasoningEffort;
+  reasoning?: OpenAIRequestReasoningEffort;
   reasoningEffort?: OpenAIReasoningEffort;
   reasoningSummary?: "auto" | "detailed" | "concise" | null;
   replayResponsesItemIds?: boolean;
@@ -49,4 +53,4 @@ declare const responsesPromptObserver: {
   copy(source: object | undefined, target: object): void;
 };
 //#endregion
-export { ResponsesPromptObservation as a, readOpenAIResponsesCompactionWindow as c, ReplayableResponseCompactionItem as i, OpenAIResponsesOptions as n, responsesPromptObserver as o, OpenAIResponsesReasoningReplayMetadata as r, OpenAIResponsesCompactionOutput as s, OPENAI_RESPONSES_APIS as t };
+export { ResponsesPromptObservation as a, readOpenAIResponsesCompactionWindow as c, ReplayableResponseCompactionItem as i, OpenAIRequestReasoningEffort as l, OpenAIResponsesOptions as n, responsesPromptObserver as o, OpenAIResponsesReasoningReplayMetadata as r, OpenAIResponsesCompactionOutput as s, OPENAI_RESPONSES_APIS as t };

package/dist/{openai-responses-payload-policy-rLRPsSmB.d.mts → openai-responses-payload-policy-C7GsA1y0.d.mts}

@@ -10,13 +10,15 @@ type OpenAIResponsesPayloadModel = {
 };
 type OpenAIResponsesPayloadPolicyOptions = {
   extraParams?: Record<string, unknown>;
-  storeMode?: "provider-policy" | "disable" | "preserve";
+  storeMode?: "provider-policy" | "transport-default" | "disable" | "preserve";
   enablePromptCacheStripping?: boolean;
   enableServerCompaction?: boolean;
 };
 type OpenAIResponsesPayloadPolicy = {
   allowsServiceTier: boolean;
   compactThreshold: number | undefined;
+  defaultManagedReasoningEffort: "none" | undefined;
+  explicitContinuationOptIn: boolean;
   explicitStore: boolean | undefined;
   shouldStripDisabledReasoningPayload: boolean;
   shouldStripInputStatus: boolean;
@@ -30,8 +32,8 @@ declare function resolveOpenAIResponsesServerCompactionPlan(model: OpenAIRespons
   enabled: boolean;
   threshold: number | undefined;
 };
-/** Resolve the manual Responses compact-endpoint gate for one route. */
-declare function resolveOpenAIResponsesCompactEndpointPlan(model: OpenAIResponsesPayloadModel, extraParams?: Record<string, unknown>): {
+/** Resolve the Responses compact-endpoint gate for one route and compaction purpose. */
+declare function resolveOpenAIResponsesCompactEndpointPlan(model: OpenAIResponsesPayloadModel, extraParams?: Record<string, unknown>, purpose?: "manual" | "budget"): {
   enabled: boolean;
 };
 /** Resolve payload mutation policy for one OpenAI Responses-style model endpoint. */

package/dist/openai-responses-prompt-observer-internal-C15_-OwV.mjs

@@ -0,0 +1,195 @@
+import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { u as supportsOpenAITemperature } from "./openai-reasoning-effort-NlFZmfEu.mjs";
+import { r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-1wfaIszn.mjs";
+import { o as usesNativeOpenAICodexResponsesBackend } from "./openai-completions-compat-CkwdxTZx.mjs";
+import { r as resolveOpenAIStrictToolSetting } from "./host-policy-DUnXSx0I.mjs";
+import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
+import { m as stripSystemPromptCacheBoundary } from "./simple-options-C6cFWj_f.mjs";
+import { A as resolvePromptCacheKey, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, m as reconcileOpenAIResponsesToolChoice, s as getCompat } from "./openai-transport-params-DQeuAvBl.mjs";
+import { _ as sanitizeTransportPayloadText } from "./transport-stream-shared-D-6FQSHm.mjs";
+import { h as responsesPromptObserver, r as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS } from "./openai-responses-contracts-DWrfMODE.mjs";
+import { a as applyOpenAIResponsesPayloadPolicy, s as resolveOpenAIResponsesPayloadPolicy } from "./openai-responses-compaction-window-D6P5oZP5.mjs";
+import { N as buildResponsesInputMessage, P as convertResponsesMessages, s as prepareResponsesTools } from "./openai-responses-shared-CwsziD_m.mjs";
+//#region packages/ai/src/transports/openai-responses-params-internal.ts
+const OPENAI_RESPONSES_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
+	"openai",
+	"opencode",
+	"azure-openai-responses",
+	"github-copilot"
+]);
+function hasResponsesWebSearchTool(tools) {
+	if (!Array.isArray(tools)) return false;
+	return tools.some((tool) => {
+		if (!isRecord(tool)) return false;
+		if (tool.type === "web_search") return true;
+		if (tool.type === "function" && tool.name === "web_search") return true;
+		const fn = tool.function;
+		return isRecord(fn) && fn.name === "web_search";
+	});
+}
+function raiseMinimalReasoningForResponsesWebSearch(params) {
+	if (params.effort !== "minimal" || !hasResponsesWebSearchTool(params.tools)) return params.effort;
+	for (const effort of [
+		"low",
+		"medium",
+		"high"
+	]) {
+		const resolved = resolveOpenAIRequestReasoning(params.model, effort).effort;
+		if (resolved && resolved !== "none" && resolved !== "minimal") return resolved;
+	}
+	return params.effort;
+}
+const OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS = [
+	"max_output_tokens",
+	"metadata",
+	"prompt_cache_retention",
+	"prompt_cache_options",
+	"service_tier",
+	"temperature",
+	"top_p"
+];
+function stripOpenAICodexResponsesUnsupportedTextFields(params) {
+	const text = params.text;
+	if (!text || typeof text !== "object" || Array.isArray(text)) return;
+	const sanitizedText = { ...text };
+	delete sanitizedText.format;
+	if (Object.keys(sanitizedText).length > 0) params.text = sanitizedText;
+	else delete params.text;
+}
+function sanitizeOpenAICodexResponsesParams(model, params) {
+	if (!usesNativeOpenAICodexResponsesBackend(model)) return params;
+	for (const key of OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS) delete params[key];
+	Object.assign(params, { store: false });
+	stripOpenAICodexResponsesUnsupportedTextFields(params);
+	return params;
+}
+function buildOpenAIResponsesInstructionsText(context) {
+	if (!context.systemPrompt) return;
+	return sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt));
+}
+function resolveOpenAIResponsesInstructions(model, context, usesInstructionsField) {
+	if (!usesInstructionsField) return;
+	const instructions = buildOpenAIResponsesInstructionsText(context);
+	if (instructions && instructions.trim().length > 0) return instructions;
+	return usesNativeOpenAICodexResponsesBackend(model) ? OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS : void 0;
+}
+function buildOpenAIResponsesCompactSystemMessage(model, instructions) {
+	const compat = getCompat(model);
+	const supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : void 0;
+	const role = model.reasoning && supportsDeveloperRole !== false ? "developer" : "system";
+	return buildResponsesInputMessage(role, [{
+		type: "input_text",
+		text: instructions
+	}]);
+}
+function ensureOpenAIResponsesNonEmptyInput(messages, context) {
+	if (messages.length > 0 || !context.systemPrompt) return;
+	if (!buildOpenAIResponsesInstructionsText(context)) throw new Error("OpenAI Responses requires non-empty input when only systemPrompt is provided.");
+	messages.push(buildResponsesInputMessage("user", [{
+		type: "input_text",
+		text: " "
+	}]));
+}
+function resolveOpenAIResponsesTextFormat(responseFormat) {
+	if (responseFormat.type === "json_schema" && responseFormat.json_schema && typeof responseFormat.json_schema === "object" && !Array.isArray(responseFormat.json_schema)) return {
+		...responseFormat.json_schema,
+		type: "json_schema"
+	};
+	return responseFormat;
+}
+function buildOpenAIResponsesParams(model, context, options, metadata, replayMode = "checkpoint") {
+	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "transport-default" });
+	const policyAllowsReplayIds = payloadPolicy.explicitStore !== false && !payloadPolicy.shouldStripStore;
+	const replayResponsesItemIds = !usesNativeOpenAICodexResponsesBackend(model) && (options?.replayResponsesItemIds ?? policyAllowsReplayIds);
+	const messages = convertResponsesMessages(model, context, OPENAI_RESPONSES_TOOL_CALL_PROVIDERS, {
+		includeSystemPrompt: !payloadPolicy.usesInstructionsField,
+		replayReasoningItems: true,
+		replayResponsesItemIds,
+		authProfileId: options?.authProfileId,
+		sessionId: options?.sessionId,
+		replayMode
+	});
+	ensureOpenAIResponsesNonEmptyInput(messages, context);
+	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+	const compat = getCompat(model);
+	const promptCacheKey = compat.supportsPromptCacheKey ? resolvePromptCacheKey(options, cacheRetention) : void 0;
+	const instructions = resolveOpenAIResponsesInstructions(model, context, payloadPolicy.usesInstructionsField);
+	const params = {
+		model: model.id,
+		input: messages,
+		stream: true,
+		prompt_cache_key: promptCacheKey,
+		...resolveOpenAIPromptCacheParams(model, cacheRetention, compat),
+		...instructions ? { instructions } : {},
+		...metadata ? { metadata } : {}
+	};
+	const effectiveMaxTokens = options?.maxTokens || model.maxTokens;
+	if (effectiveMaxTokens) params.max_output_tokens = Math.max(effectiveMaxTokens, 16);
+	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
+	if (options?.topP !== void 0 && model.id !== "gpt-6-astra") params.top_p = options.topP;
+	if (options?.responseFormat !== void 0) params.text = {
+		...params.text,
+		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
+	};
+	if (options?.serviceTier !== void 0 && payloadPolicy.allowsServiceTier) params.service_tier = options.serviceTier;
+	if (context.tools) {
+		const tools = context.tools;
+		const strict = resolveOpenAIStrictToolSetting(model, { transport: "stream" });
+		const { projection, tools: converted } = prepareResponsesTools(tools, strict, model);
+		if (converted.length > 0 || projection.inputToolCount === 0 && projection.diagnostics.length === 0) params.tools = converted;
+		if (options?.toolChoice) {
+			const toolChoice = reconcileOpenAIResponsesToolChoice(options.toolChoice, projection);
+			if (toolChoice !== void 0) params.tool_choice = toolChoice;
+		}
+	}
+	if (model.reasoning) {
+		const reasoning = options?.reasoning;
+		const requestedEffort = options?.reasoningEffort ?? (reasoning === "none" ? "none" : resolveOpenAISimpleReasoningEffort(model, reasoning)) ?? (options?.reasoningSummary ? "high" : payloadPolicy.defaultManagedReasoningEffort);
+		const resolvedEffort = requestedEffort === void 0 ? void 0 : resolveOpenAIRequestReasoning(model, requestedEffort).effort;
+		if (resolvedEffort !== void 0) {
+			const effort = raiseMinimalReasoningForResponsesWebSearch({
+				model,
+				effort: resolvedEffort,
+				tools: params.tools
+			});
+			const summary = effort !== "none" && (options?.reasoningEffort || options?.reasoning || options?.reasoningSummary) ? options.reasoningSummary || "auto" : void 0;
+			params.reasoning = {
+				effort,
+				...summary ? { summary } : {}
+			};
+			if (summary) params.include = ["reasoning.encrypted_content"];
+		}
+	}
+	applyOpenAIResponsesPayloadPolicy(params, payloadPolicy);
+	return sanitizeOpenAICodexResponsesParams(model, params);
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-prompt-observer-internal.ts
+function readFinalResponsesPrompt(request) {
+	if (typeof request.instructions === "string") return ["instructions", request.instructions];
+	const message = (Array.isArray(request.input) ? request.input : []).find((item) => {
+		const role = item.role;
+		return role === "developer" || role === "system";
+	});
+	if (!message) return ["missing", ""];
+	const content = message.content;
+	const observedPrompt = typeof content === "string" ? content : Array.isArray(content) ? content.flatMap((part) => part.type === "input_text" ? [part.text] : []).join("") : "";
+	return [message.role === "developer" ? "input.developer" : "input.system", observedPrompt];
+}
+function createResponsesPromptEgressObserver(options, assembledPrompt) {
+	const observer = options ? responsesPromptObserver.get(options) : void 0;
+	if (!observer) return;
+	const expectedPrompt = sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(assembledPrompt ?? ""));
+	return (request, metadata) => {
+		const [promptSource, observedPrompt] = readFinalResponsesPrompt(request);
+		observer({
+			...metadata,
+			promptSource,
+			expectedChars: expectedPrompt.length,
+			observedChars: observedPrompt.length,
+			matchesAssembledPrompt: promptSource !== "missing" && observedPrompt === expectedPrompt
+		});
+	};
+}
+//#endregion
+export { sanitizeOpenAICodexResponsesParams as a, resolveOpenAIResponsesTextFormat as i, buildOpenAIResponsesCompactSystemMessage as n, buildOpenAIResponsesParams as r, createResponsesPromptEgressObserver as t };