@openclaw/codex 2026.9.5 → 2026.9.6

package/dist/.setup/{provider-capabilities-B8J4Dy-O.mjs → provider-capabilities-BfE88FZ5.mjs}

@@ -1,5 +1,5 @@
-import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-BpTtuLQ5.mjs";
-import { lt as normalizeCodexDynamicToolName } from "./thread-lifecycle-Cik28qWn.mjs";
+import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-DA4VR4Eb.mjs";
+import { ut as normalizeCodexDynamicToolName } from "./thread-requests-BLvGkP2R.mjs";
 import { pinExecToolTarget } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { loadNodeExecAvailability } from "openclaw/plugin-sdk/node-selection-runtime";
 //#region extensions/codex/src/app-server/shell-dynamic-tools.ts
@@ -51,6 +51,27 @@ function createGatewayProcessProjection(createProjection, processTool) {
 		description: "Manage background shell sessions in the existing per-session OpenClaw process scope: list, poll, log, write, send-keys, submit, paste, kill, clear, or remove. Use for gateway_exec follow-up; use native Codex shell session handling for ordinary local work."
 	});
 }
+function createSandboxExecProjection(execTool) {
+	return {
+		...execTool,
+		name: "sandbox_exec",
+		description: "Run a shell command through OpenClaw's configured sandbox backend for this session. Use when OpenClaw sandboxing is active or when a command must execute in the sandbox backend, such as an SSH-backed sandbox or Docker container-path bind layout. Use Codex's native shell only when no OpenClaw sandbox is active and native Code Mode is available.",
+		execute: async (toolCallId, args, signal, onUpdate) => {
+			const result = await execTool.execute(toolCallId, args, signal, onUpdate);
+			return {
+				...result,
+				content: result.content.map((item) => item.type === "text" ? Object.assign({}, item, { text: item.text.replace(PROCESS_FOLLOWUP_TEXT, "Use sandbox_process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.") }) : item)
+			};
+		}
+	};
+}
+function createSandboxProcessProjection(processTool) {
+	return {
+		...processTool,
+		name: "sandbox_process",
+		description: "Manage background shell sessions through OpenClaw's configured sandbox backend for this session: list, poll, log, write, send-keys, submit, paste, kill, clear, or remove. Use only for sandbox follow-up; use Codex's native shell session handling only when no OpenClaw sandbox is active and native Code Mode is available."
+	};
+}
 //#endregion
 //#region extensions/codex/src/app-server/provider-capabilities.ts
 function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
@@ -59,6 +80,12 @@ function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
 	return provider === "openai" ? "supported" : "unsupported";
 }
 async function readConfiguredProviderWebSearchSupport(params) {
+	if (params.expectedNativeModelProvider) {
+		if (((await params.client.request("config/read", { includeLayers: false }, {
+			timeoutMs: params.timeoutMs,
+			signal: params.signal
+		})).config.model_provider ?? "openai") !== params.expectedNativeModelProvider) return "unknown";
+	}
 	return (await params.client.request("modelProvider/capabilities/read", {}, {
 		timeoutMs: params.timeoutMs,
 		signal: params.signal
@@ -89,6 +116,7 @@ async function resolveCodexProviderWebSearchSupport(params) {
 			client,
 			timeoutMs: params.appServer.requestTimeoutMs,
 			modelProviderOverride: params.modelProviderOverride,
+			expectedNativeModelProvider: params.expectedNativeModelProvider,
 			signal: params.signal
 		});
 	} catch {
@@ -98,4 +126,4 @@ async function resolveCodexProviderWebSearchSupport(params) {
 	}
 }
 //#endregion
-export { CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME as a, createNodeExecAliasDynamicTool as c, CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME as i, isCodexDynamicToolExcluded as l, resolveCodexProviderWebSearchSupportForClient as n, createGatewayExecProjection as o, CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME as r, createGatewayProcessProjection as s, resolveCodexProviderWebSearchSupport as t };
+export { CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME as a, createNodeExecAliasDynamicTool as c, isCodexDynamicToolExcluded as d, CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME as i, createSandboxExecProjection as l, resolveCodexProviderWebSearchSupportForClient as n, createGatewayExecProjection as o, CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME as r, createGatewayProcessProjection as s, resolveCodexProviderWebSearchSupport as t, createSandboxProcessProjection as u };

package/dist/.setup/{rate-limits-DOEGYRNs.mjs → rate-limits-CMU3DUD0.mjs}

@@ -1,20 +1,76 @@
-import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
 import { normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { z } from "zod";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { PROVIDER_LABELS, clampPercent } from "openclaw/plugin-sdk/provider-usage";
+//#region extensions/codex/src/app-server/rate-limit-time.ts
+/** Human-readable Codex quota reset times; no account or routing decisions. */
+const ONE_SECOND_MS = 1e3;
+const ONE_MINUTE_MS = 6e4;
+const ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
+const ONE_DAY_MS$1 = 24 * ONE_HOUR_MS;
+function formatCalendarResetTime(resetsAtMs, nowMs) {
+	const resetDate = new Date(resetsAtMs);
+	const resetParts = new Intl.DateTimeFormat("en-US", {
+		month: "short",
+		day: "numeric",
+		...resetDate.getFullYear() === new Date(nowMs).getFullYear() ? {} : { year: "numeric" },
+		hour: "numeric",
+		minute: "2-digit",
+		timeZoneName: "short"
+	}).formatToParts(resetDate);
+	const part = (type) => resetParts.find((entry) => entry.type === type)?.value;
+	const dateParts = [
+		part("month"),
+		part("day"),
+		part("year")
+	].filter(Boolean);
+	return [
+		dateParts.length > 1 ? `${dateParts[0]} ${dateParts.slice(1).join(", ")}` : dateParts[0],
+		"at",
+		[
+			[part("hour"), part("minute")].filter(Boolean).join(":"),
+			part("dayPeriod"),
+			part("timeZoneName")
+		].filter(Boolean).join(" ")
+	].filter(Boolean).join(" ");
+}
+function formatRelativeDuration(durationMs) {
+	const safeMs = Math.max(1e3, durationMs);
+	if (safeMs < ONE_MINUTE_MS) return `${Math.ceil(safeMs / 1e3)} seconds`;
+	if (safeMs < ONE_HOUR_MS) {
+		const minutes = Math.ceil(safeMs / ONE_MINUTE_MS);
+		return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+	}
+	if (safeMs < ONE_DAY_MS$1) {
+		const hours = Math.ceil(safeMs / ONE_HOUR_MS);
+		return `${hours} ${hours === 1 ? "hour" : "hours"}`;
+	}
+	const days = Math.ceil(safeMs / ONE_DAY_MS$1);
+	return `${days} ${days === 1 ? "day" : "days"}`;
+}
+function formatResetDuration(resetsAtMs, nowMs) {
+	const durationMs = Math.round(Math.max(ONE_SECOND_MS, resetsAtMs - nowMs) / ONE_SECOND_MS) * ONE_SECOND_MS;
+	const days = Math.floor(durationMs / ONE_DAY_MS$1);
+	const hours = Math.floor(durationMs % ONE_DAY_MS$1 / ONE_HOUR_MS);
+	const minutes = Math.floor(durationMs % ONE_HOUR_MS / ONE_MINUTE_MS);
+	const seconds = Math.floor(durationMs % ONE_MINUTE_MS / ONE_SECOND_MS);
+	if (days > 0) return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+	if (hours > 0) return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+	return `${seconds}s`;
+}
+//#endregion
 //#region extensions/codex/src/app-server/rate-limits.ts
 /**
 * Parses Codex account rate-limit payloads into user-facing usage summaries,
 * reset hints, and enriched usage-limit error messages.
 */
 const CODEX_LIMIT_ID = "codex";
+const CODEX_RESERVE_ROUTE = "gpt-reserve";
+const CODEX_RESERVE_USAGE_NOTICE = "Luna Reserve is a separate, backend-authorized route. Ordinary Luna does not use this reserve, even with Fast off. An unused reserve does not establish eligibility or per-request billing. Ordinary usage may consume credits after included limits are reached.";
 const LIMIT_WINDOW_KEYS = ["primary", "secondary"];
-const ONE_SECOND_MS = 1e3;
-const ONE_MINUTE_MS = 6e4;
-const ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
-const ONE_DAY_MS = 24 * ONE_HOUR_MS;
+const ONE_DAY_MS = 864e5;
 const DAY_WINDOW_MINUTES = 1440;
 const WEEKLY_WINDOW_MINUTES = 7 * DAY_WINDOW_MINUTES;
 const WEEKLY_RESET_GAP_MS = 3 * ONE_DAY_MS;
@@ -24,32 +80,18 @@ const optionalNumber = z.number().optional().catch(void 0);
 const optionalBoolean = z.boolean().optional().catch(void 0);
 const rateLimitWindowSchema = z.object({
 	usedPercent: optionalNumber,
-	used_percent: optionalNumber,
 	resetsAt: optionalNumber,
-	resets_at: optionalNumber,
-	windowDurationMins: optionalNumber,
-	window_duration_mins: optionalNumber,
-	windowMinutes: optionalNumber,
-	window_minutes: optionalNumber
-}).transform((window) => {
-	const resetsAt = window.resetsAt ?? window.resets_at;
-	return {
-		usedPercent: window.usedPercent ?? window.used_percent,
-		resetsAt,
-		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
-		windowDurationMins: window.windowDurationMins ?? window.window_duration_mins ?? window.windowMinutes ?? window.window_minutes
-	};
-}).optional().catch(void 0);
+	windowDurationMins: optionalNumber
+}).transform((window) => ({
+	usedPercent: window.usedPercent,
+	resetsAtMs: resolveExpiresAtMsFromEpochSeconds(window.resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
+	windowDurationMins: window.windowDurationMins
+})).optional().catch(void 0);
 const creditsSchema = z.object({
 	hasCredits: optionalBoolean,
-	has_credits: optionalBoolean,
 	unlimited: optionalBoolean,
 	balance: z.preprocess(parseStrictFiniteNumber, optionalNumber)
-}).transform((credits) => ({
-	hasCredits: credits.hasCredits ?? credits.has_credits,
-	unlimited: credits.unlimited,
-	balance: credits.balance
-})).optional().catch(void 0);
+}).optional().catch(void 0);
 const rateLimitSnapshotSchema = z.looseObject({
 	primary: rateLimitWindowSchema,
 	secondary: rateLimitWindowSchema,
@@ -58,19 +100,23 @@ const rateLimitSnapshotSchema = z.looseObject({
 	primary: snapshot.primary,
 	secondary: snapshot.secondary,
 	credits: snapshot.credits,
-	limitId: normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id),
-	limitName: normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name),
-	planType: normalizeOptionalString(snapshot.planType) ?? normalizeOptionalString(snapshot.plan_type),
-	rateLimitReachedType: normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type)
+	limitId: normalizeOptionalString(snapshot.limitId),
+	limitName: normalizeOptionalString(snapshot.limitName),
+	planType: normalizeOptionalString(snapshot.planType),
+	rateLimitReachedType: normalizeOptionalString(snapshot.rateLimitReachedType)
 }));
 /** Enriches Codex usage-limit failures with reset timing and recovery guidance. */
 function formatCodexUsageLimitErrorMessage(params) {
 	const message = normalizeOptionalString(params.message);
-	if (!isCodexUsageLimitError(params.codexErrorInfo)) return;
+	if (params.codexErrorInfo !== "usageLimitExceeded") 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 ordinaryUsageAllowed = readOrdinaryUsageAllowed(params.rateLimits);
+	const snapshots = collectCodexRateLimitSnapshots(params.rateLimits).filter(snapshotHasDisplayableData);
+	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
+	const blockingSnapshot = selectBlockingRateLimitSnapshot(snapshots, ordinaryUsageAllowed);
+	const usageSummary = usageSnapshot ? summarizeRateLimitUsage(usageSnapshot, blockingSnapshot, nowMs) : void 0;
+	if (params.rateLimitsAuthoritative && (ordinaryUsageAllowed === true && !blockingSnapshot || ordinaryUsageAllowed === void 0 && usageSummary?.blocked === false)) 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 = (blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs) : void 0) ?? (ordinaryUsageAllowed === void 0 && !usageSummary?.blocked ? selectNextRateLimitReset(params.rateLimits, nowMs) : void 0);
 	const parts = [CODEX_USAGE_LIMIT_MESSAGE_PREFIX];
 	let recoveryAction = "Wait until Codex becomes available";
 	if (nextReset) {
@@ -99,7 +145,8 @@ function summarizeCodexRateLimits(value, nowMs = Date.now()) {
 	const snapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasDisplayableData);
 	if (snapshots.length === 0) return;
 	const summaries = snapshots.slice(0, 4).map((snapshot) => summarizeRateLimitSnapshot(snapshot, nowMs)).filter((summary) => summary !== void 0);
-	return summaries.length > 0 ? summaries.join("; ") : void 0;
+	if (summaries.length === 0) return;
+	return [summaries.join("; "), reserveUsageNotice(snapshots)].filter(Boolean).join(". ");
 }
 /** Returns true when a value contains any recognizable Codex rate-limit snapshots. */
 function hasCodexRateLimitSnapshots(value) {
@@ -118,11 +165,17 @@ function resolveCodexUsageLimitResetAtMs(value, nowMs = Date.now()) {
 }
 /** Summarizes account availability, blocking reason, and reset time from rate-limit data. */
 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 blockedSnapshots = snapshots.filter(snapshotHasLimitBlock);
-	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
+	const ordinaryUsageAllowed = readOrdinaryUsageAllowed(value);
+	if (ordinaryUsageAllowed === null) return;
+	const snapshot = collectCodexRateLimitSnapshots(value).find(isCodexLimitSnapshot);
+	if (ordinaryUsageAllowed !== void 0) return {
+		usageLine: snapshot ? formatUsageLine(snapshot) : void 0,
+		blocked: !ordinaryUsageAllowed,
+		...!ordinaryUsageAllowed ? { blockingReason: "Codex usage limit is reached" } : {}
+	};
+	return snapshot && snapshotHasDisplayableData(snapshot) ? summarizeRateLimitUsage(snapshot, snapshotHasLimitBlock(snapshot) ? snapshot : void 0, nowMs) : void 0;
+}
+function summarizeRateLimitUsage(usageSnapshot, blockingSnapshot, nowMs) {
 	const blockingEntries = blockingSnapshot ? readWindowEntries(blockingSnapshot) : [];
 	const blockingWindowEntry = selectBlockingWindowEntry(blockingEntries, nowMs);
 	const blockingWindow = blockingWindowEntry?.window;
@@ -147,7 +200,9 @@ function buildCodexAppServerUsageSnapshot(value, options = {}) {
 	const snapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
 	const entries = snapshot ? readWindowEntries(snapshot) : [];
 	const windows = entries.map((entry) => readProviderUsageWindow(entry, entries)).filter((window) => Boolean(window));
+	const summary = reserveUsageNotice(snapshots);
 	const result = {
+		...summary ? { summary } : {},
 		provider: "openai",
 		displayName: PROVIDER_LABELS.openai,
 		windows,
@@ -176,13 +231,6 @@ function buildCodexAppServerUsageSnapshot(value, options = {}) {
 	}
 	return result;
 }
-function isCodexUsageLimitError(codexErrorInfo) {
-	if (codexErrorInfo === "usageLimitExceeded") return true;
-	if (typeof codexErrorInfo === "string") {
-		if (codexErrorInfo.replace(/[_\s-]/gu, "").toLowerCase() === "usagelimitexceeded") return true;
-	}
-	return false;
-}
 function selectNextRateLimitReset(value, nowMs) {
 	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => snapshot[key] ?? [])).filter((window) => window.resetsAtMs > nowMs);
 	if (futureWindows.length === 0) return;
@@ -190,10 +238,13 @@ function selectNextRateLimitReset(value, nowMs) {
 	return (exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows).toSorted((left, right) => left.resetsAtMs - right.resetsAtMs)[0];
 }
 function selectBlockingRateLimitReset(value, nowMs) {
-	const blockedSnapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasLimitBlock);
-	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
+	const blockingSnapshot = selectBlockingRateLimitSnapshot(collectCodexRateLimitSnapshots(value), readOrdinaryUsageAllowed(value));
 	return blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs) : void 0;
 }
+function selectBlockingRateLimitSnapshot(snapshots, ordinaryUsageAllowed) {
+	const blockedSnapshots = snapshots.filter((snapshot) => snapshotHasLimitBlock(snapshot) && (ordinaryUsageAllowed !== true && ordinaryUsageAllowed !== null || !isCodexLimitSnapshot(snapshot)));
+	return blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0];
+}
 function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	const label = formatLimitLabel(snapshot);
 	const windows = LIMIT_WINDOW_KEYS.flatMap((key) => {
@@ -206,28 +257,14 @@ function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	if (reachedType) return `${label}: ${formatReachedType(reachedType)}`;
 }
 function collectCodexRateLimitSnapshots(value) {
-	const snapshots = [];
-	collectRateLimitSnapshots(value, snapshots, /* @__PURE__ */ new Set());
-	return snapshots;
-}
-function collectRateLimitSnapshots(value, snapshots, seen) {
-	if (Array.isArray(value)) {
-		for (const entry of value) collectRateLimitSnapshots(entry, snapshots, seen);
-		return;
-	}
-	if (!isJsonObject(value)) return;
-	if (isRateLimitSnapshot(value)) {
-		addRateLimitSnapshot(rateLimitSnapshotSchema.parse(value), snapshots, seen);
-		return;
-	}
+	if (!isJsonObject(value)) return [];
+	if (isRateLimitSnapshot(value)) return [rateLimitSnapshotSchema.parse(value)];
 	const byLimitId = value.rateLimitsByLimitId;
-	if (isJsonObject(byLimitId)) for (const key of sortedRateLimitKeys(Object.keys(byLimitId))) collectRateLimitSnapshots(byLimitId[key], snapshots, seen);
-	const snakeByLimitId = value.rate_limits_by_limit_id;
-	if (isJsonObject(snakeByLimitId)) for (const key of sortedRateLimitKeys(Object.keys(snakeByLimitId))) collectRateLimitSnapshots(snakeByLimitId[key], snapshots, seen);
-	collectRateLimitSnapshots(value.rateLimits, snapshots, seen);
-	collectRateLimitSnapshots(value.rate_limits, snapshots, seen);
-	collectRateLimitSnapshots(value.data, snapshots, seen);
-	collectRateLimitSnapshots(value.items, snapshots, seen);
+	return (isJsonObject(byLimitId) ? sortedRateLimitKeys(Object.keys(byLimitId)).map((key) => byLimitId[key]) : [value.rateLimits]).filter(isJsonObject).filter(isRateLimitSnapshot).map((snapshot) => rateLimitSnapshotSchema.parse(snapshot));
+}
+function readOrdinaryUsageAllowed(value) {
+	const allowed = isJsonObject(value) ? value.ordinaryUsageAllowed : void 0;
+	return allowed === null || typeof allowed === "boolean" ? allowed : void 0;
 }
 function sortedRateLimitKeys(keys) {
 	return keys.toSorted((left, right) => {
@@ -236,19 +273,8 @@ function sortedRateLimitKeys(keys) {
 		return left.localeCompare(right);
 	});
 }
-function addRateLimitSnapshot(snapshot, snapshots, seen) {
-	const signature = [
-		snapshot.limitId ?? "",
-		snapshot.limitName ?? "",
-		formatWindowSignature(snapshot.primary),
-		formatWindowSignature(snapshot.secondary)
-	].join("|");
-	if (seen.has(signature)) return;
-	seen.add(signature);
-	snapshots.push(snapshot);
-}
 function isRateLimitSnapshot(value) {
-	return isJsonObject(value.primary) || isJsonObject(value.secondary) || value.rateLimitReachedType !== void 0 || value.rate_limit_reached_type !== void 0 || value.limitId !== void 0 || value.limit_id !== void 0 || value.limitName !== void 0 || value.limit_name !== void 0;
+	return isJsonObject(value.primary) || isJsonObject(value.secondary) || value.rateLimitReachedType !== void 0 || value.limitId !== void 0 || value.limitName !== void 0;
 }
 function snapshotHasDisplayableData(snapshot) {
 	return Boolean(snapshot.rateLimitReachedType) || readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 || entry.window.resetsAtMs > 0);
@@ -259,7 +285,14 @@ function formatRateLimitWindow(key, window, nowMs) {
 function formatRateLimitWindowDetails(window, nowMs) {
 	return `${window.usedPercent === void 0 ? "usage unknown" : `${Math.max(0, 100 - Math.round(window.usedPercent))}% left`}${window.resetsAtMs > nowMs ? ` ⏱${formatResetDuration(window.resetsAtMs, nowMs)}` : ""}`;
 }
+function reserveUsageNotice(snapshots) {
+	return snapshots.some(isReserveSnapshot) ? CODEX_RESERVE_USAGE_NOTICE : void 0;
+}
+function isReserveSnapshot(snapshot) {
+	return snapshot.limitName === CODEX_RESERVE_ROUTE || snapshot.limitId === CODEX_RESERVE_ROUTE;
+}
 function formatLimitLabel(snapshot) {
+	if (isReserveSnapshot(snapshot)) return "Luna Reserve (separate route)";
 	const label = snapshot.limitName ?? snapshot.limitId;
 	if (!label || label === CODEX_LIMIT_ID) return "Codex";
 	return label.replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").trim();
@@ -364,60 +397,6 @@ function hasWeeklySecondaryResetCadence(entry, entries) {
 	const primaryResetMs = entries.find((candidate) => candidate.key === "primary")?.window.resetsAtMs;
 	return typeof primaryResetMs === "number" && primaryResetMs > 0 && entry.window.resetsAtMs > 0 && entry.window.resetsAtMs - primaryResetMs >= WEEKLY_RESET_GAP_MS;
 }
-function formatCalendarResetTime(resetsAtMs, nowMs) {
-	const resetDate = new Date(resetsAtMs);
-	const resetParts = new Intl.DateTimeFormat("en-US", {
-		month: "short",
-		day: "numeric",
-		...resetDate.getFullYear() === new Date(nowMs).getFullYear() ? {} : { year: "numeric" },
-		hour: "numeric",
-		minute: "2-digit",
-		timeZoneName: "short"
-	}).formatToParts(resetDate);
-	const part = (type) => resetParts.find((entry) => entry.type === type)?.value;
-	const dateParts = [
-		part("month"),
-		part("day"),
-		part("year")
-	].filter(Boolean);
-	return [
-		dateParts.length > 1 ? `${dateParts[0]} ${dateParts.slice(1).join(", ")}` : dateParts[0],
-		"at",
-		[
-			[part("hour"), part("minute")].filter(Boolean).join(":"),
-			part("dayPeriod"),
-			part("timeZoneName")
-		].filter(Boolean).join(" ")
-	].filter(Boolean).join(" ");
-}
-function formatRelativeDuration(durationMs) {
-	const safeMs = Math.max(1e3, durationMs);
-	if (safeMs < ONE_MINUTE_MS) return `${Math.ceil(safeMs / 1e3)} seconds`;
-	if (safeMs < ONE_HOUR_MS) {
-		const minutes = Math.ceil(safeMs / ONE_MINUTE_MS);
-		return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
-	}
-	if (safeMs < ONE_DAY_MS) {
-		const hours = Math.ceil(safeMs / ONE_HOUR_MS);
-		return `${hours} ${hours === 1 ? "hour" : "hours"}`;
-	}
-	const days = Math.ceil(safeMs / ONE_DAY_MS);
-	return `${days} ${days === 1 ? "day" : "days"}`;
-}
-function formatResetDuration(resetsAtMs, nowMs) {
-	const durationMs = Math.round(Math.max(ONE_SECOND_MS, resetsAtMs - nowMs) / ONE_SECOND_MS) * ONE_SECOND_MS;
-	const days = Math.floor(durationMs / ONE_DAY_MS);
-	const hours = Math.floor(durationMs % ONE_DAY_MS / ONE_HOUR_MS);
-	const minutes = Math.floor(durationMs % ONE_HOUR_MS / ONE_MINUTE_MS);
-	const seconds = Math.floor(durationMs % ONE_MINUTE_MS / ONE_SECOND_MS);
-	if (days > 0) return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
-	if (hours > 0) return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
-	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
-	return `${seconds}s`;
-}
-function formatWindowSignature(window) {
-	return window ? `${window.usedPercent ?? ""}:${window.resetsAt ?? ""}` : "";
-}
 function extractCodexRetryHint(message) {
 	if (!message) return;
 	const tryAgainAt = /\btry again\s+(at\s+[^.!?\n]+)(?:[.!?]|$)/iu.exec(message);

package/dist/.setup/{request-BioXJLYa.mjs → request-D2L0zMrq.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { i as CodexAppServerRpcError, n as withTimeout, t as withAbortableTimeout } from "./timeout-DZF05XrR.mjs";
+import { i as withTimeout, o as CodexAppServerRpcError, r as withAbortableTimeout } from "./timeout-C910MdAB.mjs";
 //#region extensions/codex/src/app-server/request.ts
 var request_exports = /* @__PURE__ */ __exportAll({
 	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
@@ -28,7 +28,7 @@ async function requestCodexAppServerClientJson(params) {
 	let phase = "prepare";
 	observeControlPhase(params.controlObservation, phase);
 	try {
-		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
+		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-C2sRMOEY.mjs").then((n) => n.r);
 		const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 			method: params.method,
 			requestParams: params.requestParams,
@@ -57,7 +57,7 @@ async function requestCodexAppServerClientJson(params) {
 }
 async function requestCodexAppServerJson(params) {
 	observeControlPhase(params.controlObservation, "prepare");
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
+	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-C2sRMOEY.mjs").then((n) => n.r);
 	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 		method: params.method,
 		requestParams: params.requestParams,
@@ -81,6 +81,15 @@ var CodexAppServerScopedRequestRejectedError = class extends Error {
 		this.name = "CodexAppServerScopedRequestRejectedError";
 	}
 };
+function createScopeCleanupError(message) {
+	const stackTraceLimit = Error.stackTraceLimit;
+	try {
+		Error.stackTraceLimit = 0;
+		return new CodexAppServerScopedRequestRejectedError(message);
+	} finally {
+		Error.stackTraceLimit = stackTraceLimit;
+	}
+}
 function assertRequestOwnerCurrent(assertCurrent) {
 	try {
 		assertCurrent?.();
@@ -99,6 +108,7 @@ async function readCodexAppServerUsage(options) {
 	const deadline = performance.now() + options.timeoutMs;
 	return await withCodexAppServerJsonClient({
 		timeoutMs: options.timeoutMs,
+		signal: options.signal,
 		timeoutMessage: "codex app-server usage read timed out",
 		agentDir: options.agentDir,
 		...options.authProfileId ? { authProfileId: options.authProfileId } : {},
@@ -118,20 +128,13 @@ async function readCodexAppServerUsage(options) {
 		};
 	});
 }
-function extractCodexAccountEmail(value) {
-	if (!value || typeof value !== "object") return;
-	const record = value;
-	const account = record.account && typeof record.account === "object" ? record.account : record;
-	const email = account.email ?? account.accountEmail;
-	return typeof email === "string" && email.trim() ? email.trim() : void 0;
-}
 async function readCodexAccountEmailBestEffort(request, deadline) {
 	const boundMs = Math.min(CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS, deadline - performance.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
 	if (boundMs <= 0) return;
 	const read = request({
 		method: "account/read",
 		requestParams: {}
-	}).then((account) => extractCodexAccountEmail(account), () => void 0);
+	}).then(({ account }) => account?.type === "chatgpt" ? account.email?.trim() || void 0 : void 0, () => void 0);
 	let timer;
 	const timeout = new Promise((resolve) => {
 		timer = setTimeout(() => resolve(void 0), boundMs);
@@ -155,6 +158,9 @@ async function withCodexAppServerJsonClient(params, run) {
 	let errorPhase;
 	observeControlPhase(params.controlObservation, activePhase);
 	const timeoutController = new AbortController();
+	const abort = () => timeoutController.abort(params.signal?.reason);
+	params.signal?.addEventListener("abort", abort, { once: true });
+	if (params.signal?.aborted) abort();
 	const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? performance.now() + timeoutMs : void 0;
 	const isPastDeadline = () => deadline !== void 0 && performance.now() >= deadline;
 	const throwIfAbandoned = () => {
@@ -166,13 +172,14 @@ async function withCodexAppServerJsonClient(params, run) {
 		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - performance.now());
 	};
 	try {
+		throwIfAbandoned();
 		return await withAbortableTimeout({
 			signal: timeoutController.signal,
 			timeoutMs,
 			timeoutMessage,
 			promise: (async () => {
-				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
-				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-BpTtuLQ5.mjs").then((n) => n.y);
+				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-C2sRMOEY.mjs").then((n) => n.r);
+				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-DA4VR4Eb.mjs").then((n) => n.y);
 				for (let attempt = 0; attempt < 2; attempt += 1) {
 					errorPhase = void 0;
 					activePhase = "prepare";
@@ -225,7 +232,7 @@ async function withCodexAppServerJsonClient(params, run) {
 								timeoutMs: remainingTimeoutMs(),
 								signal: timeoutController.signal,
 								...attemptWaiterFinished ? { attemptWaiterFinished } : {},
-								...params.catalogPreview && method === "thread/list" ? {
+								...params.catalogPreview ? {
 									catalogPreview: true,
 									catalogPreviewCache: params.catalogPreviewCache,
 									catalogRows: params.catalogRows
@@ -285,7 +292,8 @@ async function withCodexAppServerJsonClient(params, run) {
 		if (deadlineObserved) throw new Error(timeoutMessage, { cause: error });
 		throw error;
 	} finally {
-		timeoutController.abort(new CodexAppServerScopedRequestRejectedError(timeoutMessage));
+		params.signal?.removeEventListener("abort", abort);
+		timeoutController.abort(createScopeCleanupError(timeoutMessage));
 	}
 }
 //#endregion