@openclaw/codex 2026.7.2-beta.7 → 2026.7.33

package/dist/{rate-limits-CU-gVCCS.js → .setup/provider-DGxDs6g8.mjs}

@@ -1,7 +1,12 @@
-import { W as isJsonObject } from "./shared-client-DTbvH-XV.js";
+import { CODEX_APP_SERVER_AUTH_MARKER, CODEX_BASE_URL, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexModelDefinition, buildCodexProviderConfig } from "../provider-catalog.js";
+import { r as isJsonObject } from "./protocol-2POPqAY4.mjs";
+import { d as resolveCodexAppServerRuntimeOptions, u as readCodexPluginConfig } from "./config-CYEDnLJ2.mjs";
+import { resolveCodexSystemPromptContribution } from "../prompt-overlay.js";
+import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { asFiniteNumber, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { normalizeModelCompat } from "openclaw/plugin-sdk/provider-model-shared";
+import { createSubsystemLogger } from "openclaw/plugin-sdk/core";
 import { PROVIDER_LABELS, clampPercent } from "openclaw/plugin-sdk/provider-usage";
 //#region extensions/codex/src/app-server/rate-limits.ts
 /**
@@ -17,17 +22,14 @@ const ONE_DAY_MS = 24 * ONE_HOUR_MS;
 const DAY_WINDOW_MINUTES = 1440;
 const WEEKLY_WINDOW_MINUTES = 7 * DAY_WINDOW_MINUTES;
 const WEEKLY_RESET_GAP_MS = 3 * ONE_DAY_MS;
-const CODEX_USAGE_LIMIT_MESSAGE_PREFIX = "You've reached your Codex subscription usage limit.";
-const CODEX_USAGE_LIMIT_STATE_MISMATCH_MESSAGE = "Codex rejected the request with a usage-limit error, but its current account usage does not report an exhausted limit.";
 /** Enriches Codex usage-limit failures with reset timing and recovery guidance. */
 function formatCodexUsageLimitErrorMessage(params) {
 	const message = normalizeText(params.message);
-	if (!isCodexUsageLimitError(params.codexErrorInfo)) return;
+	if (!isCodexUsageLimitError(params.codexErrorInfo, message)) return;
 	const nowMs = params.nowMs ?? Date.now();
 	const usageSummary = summarizeCodexAccountUsage(params.rateLimits, nowMs);
-	if (params.rateLimitsAuthoritative && hasCodexRateLimitSnapshots(params.rateLimits) && !usageSummary?.blocked) return [CODEX_USAGE_LIMIT_STATE_MISMATCH_MESSAGE, "Retry the request, use another Codex account if available, or switch to another configured model/provider."].join(" ");
 	const nextReset = selectBlockingRateLimitReset(params.rateLimits, nowMs) ?? (usageSummary?.blocked ? void 0 : selectNextRateLimitReset(params.rateLimits, nowMs));
-	const parts = [CODEX_USAGE_LIMIT_MESSAGE_PREFIX];
+	const parts = ["You've reached your Codex subscription usage limit."];
 	let recoveryAction = "Wait until Codex becomes available";
 	if (nextReset) {
 		parts.push(`Next reset ${formatResetTime(nextReset.resetsAtMs, nowMs)}.`);
@@ -48,7 +50,7 @@ function formatCodexUsageLimitErrorMessage(params) {
 /** Detects usage-limit messages that need a fresh rate-limit query before display. */
 function shouldRefreshCodexRateLimitsForUsageLimitMessage(message) {
 	const text = normalizeText(message);
-	return Boolean(text?.startsWith(CODEX_USAGE_LIMIT_MESSAGE_PREFIX) && !text.includes("Next reset "));
+	return Boolean(text?.includes("You've reached your Codex subscription usage limit.") && !text.includes("Next reset "));
 }
 /** Formats compact summaries for raw Codex rate-limit snapshot payloads. */
 function summarizeCodexRateLimits(value, nowMs = Date.now()) {
@@ -76,7 +78,7 @@ function resolveCodexUsageLimitResetAtMs(value, nowMs = Date.now()) {
 function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
 	const snapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasDisplayableData);
 	if (snapshots.length === 0) return;
-	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? expectDefined(snapshots[0], "displayable Codex rate-limit snapshot");
+	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
 	const blockedSnapshots = snapshots.filter(snapshotHasLimitBlock);
 	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
 	const blockingEntries = blockingSnapshot ? readWindowEntries(blockingSnapshot) : [];
@@ -109,12 +111,12 @@ function buildCodexAppServerUsageSnapshot(value) {
 		...snapshot ? { plan: resolveCodexProviderUsagePlan(snapshot) } : {}
 	};
 }
-function isCodexUsageLimitError(codexErrorInfo) {
+function isCodexUsageLimitError(codexErrorInfo, message) {
 	if (codexErrorInfo === "usageLimitExceeded") return true;
 	if (typeof codexErrorInfo === "string") {
 		if (codexErrorInfo.replace(/[_\s-]/gu, "").toLowerCase() === "usagelimitexceeded") return true;
 	}
-	return false;
+	return Boolean(message?.toLowerCase().includes("usage limit"));
 }
 function selectNextRateLimitReset(value, nowMs) {
 	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => readRateLimitWindow(snapshot, key) ?? [])).filter((window) => window.resetsAtMs > nowMs);
@@ -186,8 +188,9 @@ function isRateLimitSnapshot(value) {
 function readRateLimitWindow(snapshot, key) {
 	const window = snapshot[key];
 	if (!isJsonObject(window)) return;
+	const resetsAt = readNumber(window, "resetsAt") ?? readNumber(window, "resets_at");
 	return {
-		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(readNumber(window, "resetsAt") ?? readNumber(window, "resets_at"), { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
+		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
 		...readOptionalNumberField(window, "usedPercent", "used_percent"),
 		...readOptionalNumberField(window, "windowDurationMins", "window_duration_mins", "windowMinutes", "window_minutes")
 	};
@@ -398,4 +401,257 @@ function normalizeText(value) {
 	return text ? text : void 0;
 }
 //#endregion
-export { shouldRefreshCodexRateLimitsForUsageLimitMessage as a, summarizeCodexRateLimits as c, resolveCodexUsageLimitResetAtMs as i, formatCodexUsageLimitErrorMessage as n, summarizeCodexAccountRateLimits as o, hasCodexRateLimitSnapshots as r, summarizeCodexAccountUsage as s, buildCodexAppServerUsageSnapshot as t };
+//#region extensions/codex/provider.ts
+/**
+* Codex provider plugin and live app-server model catalog discovery.
+*/
+const DEFAULT_DISCOVERY_TIMEOUT_MS = 2500;
+const LIVE_DISCOVERY_ENV = "OPENCLAW_CODEX_DISCOVERY_LIVE";
+const MODEL_DISCOVERY_PAGE_LIMIT = 100;
+const CODEX_APP_SERVER_SETUP_METHOD_ID = "app-server";
+const CODEX_DEFAULT_MODEL_REF = `${CODEX_PROVIDER_ID}/${FALLBACK_CODEX_MODELS[0].id}`;
+const codexCatalogLog = createSubsystemLogger("codex/catalog");
+const CODEX_REASONING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"ultra"
+];
+const GPT_56_MAX_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const GPT_56_ULTRA_REASONING_EFFORTS = [...GPT_56_MAX_REASONING_EFFORTS, "ultra"];
+const GPT_56_ULTRA_MODEL_IDS = /* @__PURE__ */ new Set(["gpt-5.6-sol", "gpt-5.6-terra"]);
+const GPT_56_MAX_MODEL_IDS = /* @__PURE__ */ new Set([...GPT_56_ULTRA_MODEL_IDS, "gpt-5.6-luna"]);
+const GPT_56_DEFAULT_REASONING_EFFORTS = /* @__PURE__ */ new Map([
+	["gpt-5.6-sol", "low"],
+	["gpt-5.6-terra", "medium"],
+	["gpt-5.6-luna", "medium"]
+]);
+const GPT_5_PRO_REASONING_EFFORTS = [
+	"medium",
+	"high",
+	"xhigh"
+];
+/**
+* Builds the Codex provider plugin, including setup metadata, catalog discovery,
+* dynamic model resolution, and prompt/thinking hooks.
+*/
+function buildCodexProvider(options = {}) {
+	return {
+		id: CODEX_PROVIDER_ID,
+		label: "Codex",
+		docsPath: "/providers/models",
+		auth: [{
+			id: CODEX_APP_SERVER_SETUP_METHOD_ID,
+			label: "Codex app-server",
+			hint: "Use the Codex app-server runtime and managed model catalog.",
+			kind: "custom",
+			wizard: {
+				choiceId: CODEX_PROVIDER_ID,
+				choiceLabel: "Codex app-server",
+				choiceHint: "Use the Codex app-server runtime and managed model catalog.",
+				assistantPriority: -40,
+				groupId: CODEX_PROVIDER_ID,
+				groupLabel: "Codex",
+				groupHint: "Codex app-server model provider",
+				onboardingScopes: ["text-inference"]
+			},
+			run: async () => ({
+				profiles: [],
+				defaultModel: CODEX_DEFAULT_MODEL_REF
+			})
+		}],
+		catalog: {
+			order: "late",
+			run: async (ctx) => {
+				const pluginConfig = resolvePluginConfigObject(ctx.config, "codex") ?? (ctx.config ? void 0 : options.pluginConfig);
+				return await buildCodexProviderCatalog({
+					env: ctx.env,
+					pluginConfig,
+					listModels: options.listModels
+				});
+			}
+		},
+		staticCatalog: {
+			order: "late",
+			run: async () => ({ provider: buildCodexProviderConfig(FALLBACK_CODEX_MODELS) })
+		},
+		resolveDynamicModel: (ctx) => resolveCodexDynamicModel(ctx.modelId),
+		resolveSyntheticAuth: () => ({
+			apiKey: CODEX_APP_SERVER_AUTH_MARKER,
+			source: "codex-app-server",
+			mode: "token"
+		}),
+		fetchUsageSnapshot: async (ctx) => {
+			if (ctx.token !== "codex-app-server") return null;
+			const pluginConfig = resolvePluginConfigObject(ctx.config, "codex") ?? (ctx.config ? void 0 : options.pluginConfig);
+			const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig });
+			return buildCodexAppServerUsageSnapshot(await (options.readRateLimits ?? requestCodexAppServerRateLimitsLazy)({
+				timeoutMs: ctx.timeoutMs,
+				agentDir: ctx.agentDir,
+				...ctx.authProfileId ? { authProfileId: ctx.authProfileId } : {},
+				config: ctx.config,
+				startOptions: appServer.start
+			}));
+		},
+		resolveThinkingProfile: ({ modelId, compat }) => {
+			const efforts = resolveCodexThinkingEfforts({
+				modelId,
+				supportedReasoningEfforts: readCodexSupportedReasoningEfforts(compat)
+			});
+			const defaultLevel = GPT_56_DEFAULT_REASONING_EFFORTS.get(modelId.trim().toLowerCase());
+			return {
+				levels: [{ id: "off" }, ...efforts.map((id) => ({ id }))],
+				...defaultLevel && efforts.includes(defaultLevel) ? { defaultLevel } : {}
+			};
+		},
+		resolveSystemPromptContribution: ({ config, modelId }) => resolveCodexSystemPromptContribution({
+			config,
+			modelId
+		}),
+		isModernModelRef: ({ modelId }) => isModernCodexModel(modelId)
+	};
+}
+/**
+* Builds the Codex model catalog from live app-server discovery, falling back
+* to built-in model records when discovery is disabled or unavailable.
+*/
+async function buildCodexProviderCatalog(options = {}) {
+	const config = readCodexPluginConfig(options.pluginConfig);
+	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
+	const timeoutMs = normalizeTimeoutMs(config.discovery?.timeoutMs);
+	let discovered = [];
+	if (config.discovery?.enabled !== false && !shouldSkipLiveDiscovery(options.env)) discovered = await listModelsBestEffort({
+		listModels: options.listModels ?? listCodexAppServerModelsLazy,
+		timeoutMs,
+		startOptions: appServer.start,
+		onDiscoveryFailure: options.onDiscoveryFailure
+	});
+	return { provider: buildCodexProviderConfig(discovered.length > 0 ? discovered : FALLBACK_CODEX_MODELS) };
+}
+function resolveCodexDynamicModel(modelId) {
+	const id = modelId.trim();
+	if (!id) return;
+	const fallbackModel = FALLBACK_CODEX_MODELS.find((model) => model.id === id);
+	return normalizeModelCompat({
+		...buildCodexModelDefinition({
+			id,
+			model: id,
+			inputModalities: fallbackModel?.inputModalities ?? ["text"],
+			supportedReasoningEfforts: fallbackModel?.supportedReasoningEfforts
+		}),
+		provider: CODEX_PROVIDER_ID,
+		baseUrl: CODEX_BASE_URL
+	});
+}
+async function listModelsBestEffort(params) {
+	try {
+		const models = [];
+		let cursor;
+		do {
+			const result = await params.listModels({
+				timeoutMs: params.timeoutMs,
+				limit: MODEL_DISCOVERY_PAGE_LIMIT,
+				cursor,
+				startOptions: params.startOptions,
+				sharedClient: false
+			});
+			models.push(...result.models.filter((model) => !model.hidden));
+			cursor = result.nextCursor;
+		} while (cursor);
+		return models;
+	} catch (error) {
+		params.onDiscoveryFailure?.(error);
+		codexCatalogLog.debug("codex model discovery failed; using fallback catalog", { error: error instanceof Error ? error.message : String(error) });
+		return [];
+	}
+}
+async function listCodexAppServerModelsLazy(options) {
+	const { listCodexAppServerModels } = await import("./models-C_aZk03A.mjs").then((n) => n.r);
+	return listCodexAppServerModels(options);
+}
+async function requestCodexAppServerRateLimitsLazy(options) {
+	const { requestCodexAppServerJson } = await import("./request-DFR0JyoV.mjs").then((n) => n.n);
+	return await requestCodexAppServerJson({
+		method: "account/rateLimits/read",
+		timeoutMs: options.timeoutMs,
+		agentDir: options.agentDir,
+		...options.authProfileId ? { authProfileId: options.authProfileId } : {},
+		config: options.config,
+		startOptions: options.startOptions,
+		isolated: true
+	});
+}
+function normalizeTimeoutMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : DEFAULT_DISCOVERY_TIMEOUT_MS;
+}
+function shouldSkipLiveDiscovery(env = process.env) {
+	const override = env[LIVE_DISCOVERY_ENV]?.trim().toLowerCase();
+	if (override === "0" || override === "false") return true;
+	return Boolean(env.VITEST) && override !== "1";
+}
+function isKnownXHighCodexModel(modelId) {
+	const lower = modelId.trim().toLowerCase();
+	return lower.startsWith("gpt-5") || lower.startsWith("o3") || lower.startsWith("o4") || lower.includes("codex");
+}
+function normalizeCodexReasoningEfforts(efforts) {
+	if (!efforts) return [];
+	const supported = new Set(efforts.map((effort) => effort.trim().toLowerCase()));
+	return CODEX_REASONING_EFFORTS.filter((effort) => supported.has(effort));
+}
+/** Read app-server reasoning metadata from a runtime model compat union. */
+function readCodexSupportedReasoningEfforts(compat) {
+	if (!compat || typeof compat !== "object" || Array.isArray(compat)) return;
+	const efforts = compat.supportedReasoningEfforts;
+	if (!Array.isArray(efforts)) return;
+	const strings = efforts.filter((effort) => typeof effort === "string");
+	return strings.some((effort) => effort.trim().toLowerCase() === "none") ? void 0 : strings;
+}
+function resolveCodexThinkingEfforts(params) {
+	if (params.supportedReasoningEfforts) return normalizeCodexReasoningEfforts(params.supportedReasoningEfforts);
+	const fallbackEfforts = resolveCodexFallbackReasoningEfforts(params.modelId);
+	if (fallbackEfforts) return [...fallbackEfforts];
+	return [
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		...isKnownXHighCodexModel(params.modelId) ? ["xhigh"] : [],
+		...isMaxReasoningCodexModel(params.modelId) ? ["max"] : []
+	];
+}
+/** Map a requested effort onto the authoritative app-server model contract. */
+function resolveCodexSupportedReasoningEffort(params) {
+	const supported = normalizeCodexReasoningEfforts(params.supportedReasoningEfforts);
+	if (supported.includes(params.requested)) return params.requested;
+	const fallbackEfforts = params.requested === "ultra" ? supported : supported.filter((effort) => effort !== "ultra");
+	const requestedRank = CODEX_REASONING_EFFORTS.indexOf(params.requested);
+	return fallbackEfforts.find((effort) => CODEX_REASONING_EFFORTS.indexOf(effort) >= requestedRank) ?? fallbackEfforts.at(-1);
+}
+/** Return the known effort contract when app-server model metadata is unavailable. */
+function resolveCodexFallbackReasoningEfforts(modelId) {
+	const normalized = modelId.trim().toLowerCase();
+	if (GPT_56_ULTRA_MODEL_IDS.has(normalized)) return GPT_56_ULTRA_REASONING_EFFORTS;
+	if (normalized === "gpt-5.6-luna") return GPT_56_MAX_REASONING_EFFORTS;
+	if (normalized === "gpt-5.5-pro" || normalized === "gpt-5.4-pro") return GPT_5_PRO_REASONING_EFFORTS;
+}
+/** Return whether the model uses the modern Codex reasoning profile. */
+function isModernCodexModel(modelId) {
+	const lower = modelId.trim().toLowerCase();
+	return GPT_56_MAX_MODEL_IDS.has(lower) || lower === "gpt-5.5" || lower === "gpt-5.5-pro" || lower === "gpt-5.4" || lower === "gpt-5.4-pro" || lower === "gpt-5.4-mini" || lower === "gpt-5.3-codex-spark";
+}
+/** Return whether Codex accepts the preview GPT-5.6 `max` reasoning effort. */
+function isMaxReasoningCodexModel(modelId) {
+	const lower = modelId.trim().toLowerCase();
+	return GPT_56_MAX_MODEL_IDS.has(lower);
+}
+//#endregion
+export { readCodexSupportedReasoningEfforts as a, formatCodexUsageLimitErrorMessage as c, shouldRefreshCodexRateLimitsForUsageLimitMessage as d, summarizeCodexAccountRateLimits as f, isModernCodexModel as i, hasCodexRateLimitSnapshots as l, summarizeCodexRateLimits as m, buildCodexProviderCatalog as n, resolveCodexFallbackReasoningEfforts as o, summarizeCodexAccountUsage as p, isMaxReasoningCodexModel as r, resolveCodexSupportedReasoningEffort as s, buildCodexProvider as t, resolveCodexUsageLimitResetAtMs as u };