@openclaw/ai 2026.9.4 → 2026.9.6

package/dist/openai-reasoning-effort-ash8dPrd.mjs

@@ -0,0 +1,243 @@
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import { i as asOptionalRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { n as normalizeUniqueTrimmedStringList } from "./string-normalization-J9ZiLfGO.mjs";
+//#region packages/llm-core/src/model-data.ts
+const MODEL_DATA_APIS = [
+	"openai-completions",
+	"openai-responses",
+	"openai-chatgpt-responses",
+	"anthropic-messages",
+	"google-generative-ai",
+	"google-vertex",
+	"github-copilot",
+	"bedrock-converse-stream",
+	"ollama",
+	"pi-messages",
+	"azure-openai-responses"
+];
+const MODEL_DATA_THINKING_FORMATS = [
+	"openai",
+	"openrouter",
+	"deepseek",
+	"together",
+	"qwen",
+	"qwen-chat-template",
+	"zai"
+];
+const MODEL_DATA_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+[...MODEL_DATA_APIS];
+[...MODEL_DATA_THINKING_FORMATS];
+/** Model-level thinking settings carried by provider catalog metadata. */
+const MODEL_CATALOG_THINKING_LEVELS = [...MODEL_DATA_THINKING_LEVELS];
+const OPENAI_THINKING_APIS = /* @__PURE__ */ new Set([
+	"openai-completions",
+	"openai-responses",
+	"openai-chatgpt-responses",
+	"azure-openai-responses"
+]);
+/** Managed API aliases retain the source adapter's reasoning contract. */
+function resolveOpenAIThinkingApi(api) {
+	if (typeof api !== "string") return;
+	const sourceApi = api.replace(/^openclaw-(.+)-transport$/u, "$1");
+	return OPENAI_THINKING_APIS.has(sourceApi) ? sourceApi : void 0;
+}
+/** Map keys describe logical choices; provider-native values retain their spelling. */
+function listMappedModelThinkingLevels(model) {
+	const compat = asOptionalRecord(model.compat);
+	const efforts = compat?.supportedReasoningEfforts;
+	const api = resolveOpenAIThinkingApi(model.api);
+	const format = compat?.thinkingFormat;
+	if (!api || api === "openai-completions" && (format === "qwen" || format === "qwen-chat-template" || format === "zai") || compat?.supportsReasoningEffort === false || Array.isArray(efforts) && efforts.length === 0) return [];
+	const mapping = asOptionalRecord(compat?.reasoningEffortMap);
+	const mapped = new Set(Object.entries(mapping ?? {}).flatMap(([level, effort]) => typeof effort === "string" && effort.trim() ? [level.trim().toLowerCase()] : []));
+	return MODEL_CATALOG_THINKING_LEVELS.filter((level) => mapped.has(level));
+}
+//#endregion
+//#region packages/ai/src/providers/openai-reasoning-effort.ts
+/**
+* OpenAI-compatible reasoning-effort normalization. Different GPT families
+* expose different accepted effort enums, so callers map requested values here
+* before constructing provider payloads.
+*/
+const ENABLED_REASONING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const GPT_5_REASONING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high"
+];
+const GPT_51_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high"
+];
+const GPT_52_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_56_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const GPT_6_ASTRA_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const GPT_CODEX_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_PRO_REASONING_EFFORTS = [
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_5_PRO_REASONING_EFFORTS = ["high"];
+const GPT_51_CODEX_MAX_REASONING_EFFORTS = [
+	"none",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_51_CODEX_MINI_REASONING_EFFORTS = ["medium"];
+const GENERIC_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high"
+];
+const CANONICAL_REASONING_EFFORTS = /* @__PURE__ */ new Set([
+	"none",
+	...ENABLED_REASONING_EFFORTS,
+	"off"
+]);
+function normalizeModelId(id) {
+	return normalizeLowercaseStringOrEmpty(id ?? "").replace(/-\d{4}-\d{2}-\d{2}$/u, "");
+}
+/** Return whether a model is the GPT-5.4 mini family. */
+function isOpenAIGpt54MiniModel(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return /^gpt-5\.4-mini(?:-|$)/u.test(id);
+}
+/** Return whether a model is the GPT-5.5 family. */
+function isOpenAIGpt55Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.5(?:-|$)/u.test(id) || /^gpt-5\.5(?:\s|\(|-|$)/u.test(name);
+}
+/** Return whether a model is the GPT-5.6 family. */
+function isOpenAIGpt56Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.6(?:-|$)/u.test(id) || /^gpt-5\.6(?:\s|\(|-|$)/u.test(name);
+}
+/** Return whether a model has a known GPT-6 reasoning and sampling contract. */
+function isOpenAIGpt6Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return id === "gpt-6-astra" || id === "gpt-6-sol" || id === "gpt-6-luna";
+}
+/** Normalize user-facing reasoning effort names to API effort names. */
+function normalizeOpenAIReasoningEffort(effort) {
+	const trimmed = effort.trim();
+	const folded = trimmed.toLowerCase();
+	return CANONICAL_REASONING_EFFORTS.has(folded) ? folded : trimmed;
+}
+function readCompatReasoningEfforts(compat) {
+	if (!compat || typeof compat !== "object") return;
+	if (compat.supportsReasoningEffort === false) return [];
+	const raw = compat.supportedReasoningEfforts;
+	if (!Array.isArray(raw)) return;
+	return normalizeUniqueTrimmedStringList(raw);
+}
+function isDisabledReasoningEffort(effort) {
+	return effort === "none" || effort === "off";
+}
+/** Resolve the reasoning efforts accepted by a specific OpenAI-compatible model. */
+function resolveOpenAISupportedReasoningEfforts(model) {
+	return resolveOpenAIModelReasoningEfforts(model) ?? GENERIC_REASONING_EFFORTS;
+}
+/** Read a declared or known model contract, leaving unknown compatible models unspecified. */
+function resolveOpenAIModelReasoningEfforts(model) {
+	const compatEfforts = readCompatReasoningEfforts(model.compat);
+	if (compatEfforts) return compatEfforts;
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const api = resolveOpenAIThinkingApi(model.api);
+	const supportsMax = api !== "openai-completions";
+	if (isOpenAIGpt6Model(model) && api !== "azure-openai-responses") {
+		if (id === "gpt-6-astra") return supportsMax ? GPT_6_ASTRA_REASONING_EFFORTS : GPT_CODEX_REASONING_EFFORTS;
+		return supportsMax ? GPT_56_REASONING_EFFORTS : GPT_52_REASONING_EFFORTS;
+	}
+	if (/^gpt-5\.6(?:-|$)/u.test(id)) return supportsMax ? GPT_56_REASONING_EFFORTS : GPT_52_REASONING_EFFORTS;
+	if (id === "gpt-5.1-codex-mini") return GPT_51_CODEX_MINI_REASONING_EFFORTS;
+	if (id === "gpt-5.1-codex-max") return GPT_51_CODEX_MAX_REASONING_EFFORTS;
+	if (/^gpt-5(?:\.\d+)?-codex(?:-|$)/u.test(id)) return GPT_CODEX_REASONING_EFFORTS;
+	if (id === "gpt-5-pro") return GPT_5_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?-pro(?:-|$)/u.test(id)) return GPT_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?(?:-|$)/u.test(id)) return GPT_52_REASONING_EFFORTS;
+	if (/^gpt-5\.1(?:-|$)/u.test(id)) return GPT_51_REASONING_EFFORTS;
+	if (/^gpt-5(?:-|$)/u.test(id)) return GPT_5_REASONING_EFFORTS;
+}
+/**
+* Return whether a model accepts temperature. GPT-5.6 and known GPT-6 models
+* reject it with a 400; catalog compat can override per model.
+*/
+function supportsOpenAITemperature(model) {
+	const compat = model.compat;
+	if (compat && typeof compat === "object") {
+		const declared = compat.supportsTemperature;
+		if (typeof declared === "boolean") return declared;
+	}
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return (!isOpenAIGpt6Model(model) || resolveOpenAIThinkingApi(model.api) === "azure-openai-responses") && !/^gpt-5\.6(?:-|$)/u.test(id);
+}
+/** Return whether a model accepts a requested reasoning effort. */
+function supportsOpenAIReasoningEffort(model, effort) {
+	return resolveOpenAISupportedReasoningEfforts(model).includes(normalizeOpenAIReasoningEffort(effort));
+}
+/** Read provider mappings without folding provider-native labels. */
+function resolveOpenAIReasoningEffortMapping(effort, mapping) {
+	const requested = normalizeOpenAIReasoningEffort(effort);
+	return mapping?.[requested] ?? (mapping && CANONICAL_REASONING_EFFORTS.has(requested) ? Object.entries(mapping).find(([key]) => normalizeOpenAIReasoningEffort(key) === requested)?.[1] : void 0);
+}
+/** Resolve a requested reasoning effort to the closest value supported by the model. */
+function resolveOpenAIReasoningEffortForModel(params) {
+	const requested = normalizeOpenAIReasoningEffort(params.effort);
+	const mapped = resolveOpenAIReasoningEffortMapping(requested, params.fallbackMap);
+	const normalized = mapped === void 0 ? requested : mapped.trim();
+	const supported = resolveOpenAISupportedReasoningEfforts(params.model);
+	if (supported.includes(normalized)) return normalized;
+	if (requested === "off" && supported.includes("none")) return "none";
+	if (isDisabledReasoningEffort(requested) || isDisabledReasoningEffort(normalized)) return;
+	const requestedRank = ENABLED_REASONING_EFFORTS.findIndex((effort) => effort === normalized);
+	const ranked = ENABLED_REASONING_EFFORTS.filter((effort) => supported.includes(effort));
+	return (requestedRank < 0 ? void 0 : ranked.findLast((effort) => ENABLED_REASONING_EFFORTS.indexOf(effort) <= requestedRank) ?? ranked[0]) ?? supported.find((effort) => !isDisabledReasoningEffort(normalizeOpenAIReasoningEffort(effort)));
+}
+//#endregion
+export { normalizeOpenAIReasoningEffort as a, resolveOpenAIReasoningEffortMapping as c, supportsOpenAITemperature as d, MODEL_CATALOG_THINKING_LEVELS as f, isOpenAIGpt6Model as i, resolveOpenAISupportedReasoningEfforts as l, resolveOpenAIThinkingApi as m, isOpenAIGpt55Model as n, resolveOpenAIModelReasoningEfforts as o, listMappedModelThinkingLevels as p, isOpenAIGpt56Model as r, resolveOpenAIReasoningEffortForModel as s, isOpenAIGpt54MiniModel as t, supportsOpenAIReasoningEffort as u };

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

@@ -1,14 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.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 { n as clampOpenAIPromptCacheKey, r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-CjV_2IRI.mjs";
+import { i as resolveOpenAICompletionsCompat } from "./openai-completions-compat-CUollwl6.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { n as buildBaseOptions } from "./simple-options-BQbb4yQL.mjs";
+import { n as buildBaseOptions } from "./simple-options-np1XPuhm.mjs";
+import { g as resolveOpenAISimpleReasoningEffort } from "./openai-transport-params-DZKOTSfH.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-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 resolveProviderSimpleCompletionHeaders } from "./provider-transport-turn-state-lrXEFkYr.mjs";
+import { a as runResponsesStreamLifecycle, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, r as convertResponsesMessages, t as applyCommonResponsesParams } from "./openai-responses-shared-DvSqtJ6_.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-responses.ts
 var openai_responses_exports = /* @__PURE__ */ __exportAll({
 	streamOpenAIResponses: () => streamOpenAIResponses,
@@ -21,9 +22,6 @@ function getCompat(model) {
 		sendSessionIdHeader: model.compat?.sendSessionIdHeader ?? true
 	};
 }
-/**
-* Generate function for OpenAI Responses API
-*/
 const streamOpenAIResponses = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
 	const output = createResponsesAssistantOutput(model);
@@ -53,7 +51,7 @@ const streamSimpleOpenAIResponses = (model, context, options) => {
 	return streamOpenAIResponses(model, context, {
 		...base,
 		authProfileId: replayOptions?.authProfileId,
-		reasoningEffort: resolveResponsesReasoningEffort(model, options?.reasoning),
+		reasoningEffort: resolveOpenAISimpleReasoningEffort(model, options?.reasoning),
 		replayResponsesItemIds: replayOptions?.replayResponsesItemIds
 	});
 };
@@ -92,8 +90,6 @@ function buildParams(model, context, options, replayMode = "checkpoint") {
 		...resolveOpenAIPromptCacheParams(model, cacheRetention, compat),
 		store: false
 	};
-	if (options?.maxTokens) params.max_output_tokens = options?.maxTokens;
-	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options?.temperature;
 	if (options?.serviceTier !== void 0) params.service_tier = options.serviceTier;
 	applyCommonResponsesParams(params, model, context, options, { setDefaultReasoningOff: model.provider !== "github-copilot" });
 	return params;

package/dist/{openai-responses-compaction-window-CIhBAkkq.mjs → openai-responses-compaction-window-BiNCT0bS.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 { u as supportsOpenAIReasoningEffort } from "./openai-reasoning-effort-ash8dPrd.mjs";
+import { t as canonicalizeBase64 } from "./base64-CPmadnUf.mjs";
+import { t as parsePositiveInteger } from "./positive-integer-BiUxrd71.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-BjBAqAg_.d.mts → openai-responses-contracts-B1ENJFpI.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-C25RT6bP.mjs";
+import { O as Model, j as ModelThinkingLevel, n as Api } from "./types-qZFbaDbK.mjs";
+import { a as BaseOpenAIStreamOptions, f as OpenAIReasoningEffort } from "./provider-options-DZYq53lj.mjs";
+import "./types-DTvddOfm.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-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-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. */