@openclaw/codex 2026.9.6 → 2026.9.7

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

@@ -62,10 +62,6 @@ function formatResetDuration(resetsAtMs, nowMs) {
 }
 //#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.";
@@ -105,7 +101,6 @@ const rateLimitSnapshotSchema = z.looseObject({
 	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 (params.codexErrorInfo !== "usageLimitExceeded") return;
@@ -135,12 +130,10 @@ function formatCodexUsageLimitErrorMessage(params) {
 	parts.push(`${recoveryAction}, use another Codex account if available, or switch to another configured model/provider.`);
 	return parts.join(" ");
 }
-/** Detects usage-limit messages that need a fresh rate-limit query before display. */
 function shouldRefreshCodexRateLimitsForUsageLimitMessage(message) {
 	const text = normalizeOptionalString(message);
 	return Boolean(text?.startsWith(CODEX_USAGE_LIMIT_MESSAGE_PREFIX) && !text.includes("Next reset "));
 }
-/** Formats compact summaries for raw Codex rate-limit snapshot payloads. */
 function summarizeCodexRateLimits(value, nowMs = Date.now()) {
 	const snapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasDisplayableData);
 	if (snapshots.length === 0) return;
@@ -148,22 +141,19 @@ function summarizeCodexRateLimits(value, nowMs = Date.now()) {
 	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) {
 	return collectCodexRateLimitSnapshots(value).length > 0;
 }
-/** Builds short account availability lines suitable for status surfaces. */
 function summarizeCodexAccountRateLimits(value, nowMs = Date.now()) {
 	const summary = summarizeCodexAccountUsage(value, nowMs);
 	if (!summary) return;
 	if (!summary.blocked) return ["Codex is available."];
 	return [summary.blockedUntilText ? `Codex is paused until ${summary.blockedUntilText}.` : "Codex is paused by a usage limit.", summary.blockingReason ? `Your ${summary.blockingReason}.` : "Your Codex usage limit is reached."];
 }
-/** Returns the reset timestamp for the currently blocking Codex usage limit. */
 function resolveCodexUsageLimitResetAtMs(value, nowMs = Date.now()) {
-	return selectBlockingRateLimitReset(value, nowMs)?.resetsAtMs;
+	const blockingSnapshot = selectBlockingRateLimitSnapshot(collectCodexRateLimitSnapshots(value), readOrdinaryUsageAllowed(value));
+	return blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs)?.resetsAtMs : void 0;
 }
-/** Summarizes account availability, blocking reason, and reset time from rate-limit data. */
 function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
 	const ordinaryUsageAllowed = readOrdinaryUsageAllowed(value);
 	if (ordinaryUsageAllowed === null) return;
@@ -194,7 +184,6 @@ function summarizeRateLimitUsage(usageSnapshot, blockingSnapshot, nowMs) {
 		...blockingReason ? { blockingReason } : {}
 	};
 }
-/** Converts Codex app-server rate-limit payloads into OpenAI/Codex usage windows. */
 function buildCodexAppServerUsageSnapshot(value, options = {}) {
 	const snapshots = collectCodexRateLimitSnapshots(value);
 	const snapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
@@ -237,10 +226,6 @@ function selectNextRateLimitReset(value, nowMs) {
 	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
 	return (exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows).toSorted((left, right) => left.resetsAtMs - right.resetsAtMs)[0];
 }
-function selectBlockingRateLimitReset(value, nowMs) {
-	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];
@@ -249,7 +234,7 @@ function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	const label = formatLimitLabel(snapshot);
 	const windows = LIMIT_WINDOW_KEYS.flatMap((key) => {
 		const window = snapshot[key];
-		return window ? [formatRateLimitWindow(key, window, nowMs)] : [];
+		return window ? [`${key} ${formatRateLimitWindowDetails(window, nowMs)}`] : [];
 	});
 	const reachedType = snapshot.rateLimitReachedType;
 	const suffix = reachedType ? ` (${formatReachedType(reachedType)})` : "";
@@ -279,9 +264,6 @@ function isRateLimitSnapshot(value) {
 function snapshotHasDisplayableData(snapshot) {
 	return Boolean(snapshot.rateLimitReachedType) || readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 || entry.window.resetsAtMs > 0);
 }
-function formatRateLimitWindow(key, window, nowMs) {
-	return `${key} ${formatRateLimitWindowDetails(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)}` : ""}`;
 }
@@ -295,7 +277,7 @@ 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();
+	return formatReachedType(label);
 }
 function formatReachedType(value) {
 	return value.replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").trim();
@@ -345,11 +327,8 @@ function formatCodexCreditSummary(credits) {
 	return roundedBalance > 0 ? `${roundedBalance} credits` : void 0;
 }
 function selectSnapshotBlockingReset(snapshot, nowMs) {
-	const futureWindows = readWindowEntries(snapshot).map((entry) => entry.window).filter((window) => window.resetsAtMs > nowMs);
-	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
-	const candidates = exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows;
-	const resetSort = exhaustedWindows.length > 0 ? (left, right) => right.resetsAtMs - left.resetsAtMs : (left, right) => left.resetsAtMs - right.resetsAtMs;
-	return candidates.toSorted(resetSort)[0];
+	const window = selectBlockingWindowEntry(readWindowEntries(snapshot), nowMs)?.window;
+	return window && window.resetsAtMs > nowMs ? window : void 0;
 }
 function selectBlockingWindowEntry(entries, nowMs) {
 	const futureEntries = entries.filter((entry) => entry.window.resetsAtMs > nowMs);
@@ -384,10 +363,9 @@ function formatUsageLine(snapshot) {
 	return windows.length > 0 ? windows.join(" · ") : void 0;
 }
 function formatUsageWindowLabel(entry, entries) {
+	const period = formatBlockingLimitPeriod(entry, entries);
+	if (period) return period;
 	const minutes = entry.window.windowDurationMins;
-	if (minutes === WEEKLY_WINDOW_MINUTES || hasWeeklySecondaryResetCadence(entry, entries)) return "weekly";
-	if (minutes === DAY_WINDOW_MINUTES) return "daily";
-	if (minutes !== void 0 && minutes > 0 && minutes < DAY_WINDOW_MINUTES) return "short-term";
 	if (minutes !== void 0 && minutes > 0 && minutes % DAY_WINDOW_MINUTES === 0) return `${minutes / DAY_WINDOW_MINUTES}-day`;
 	if (minutes !== void 0 && minutes > 0 && minutes % 60 === 0) return `${minutes / 60}-hour`;
 	return "usage";
@@ -404,4 +382,4 @@ function extractCodexRetryHint(message) {
 	return /\btry again\s+((?:tomorrow|in\s+[^.!?\n]+)[^.!?\n]*)(?:[.!?]|$)/iu.exec(message)?.[1]?.trim();
 }
 //#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 };
+export { shouldRefreshCodexRateLimitsForUsageLimitMessage as a, summarizeCodexRateLimits as c, resolveCodexUsageLimitResetAtMs as i, formatRelativeDuration as l, formatCodexUsageLimitErrorMessage as n, summarizeCodexAccountRateLimits as o, hasCodexRateLimitSnapshots as r, summarizeCodexAccountUsage as s, buildCodexAppServerUsageSnapshot as t };

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

@@ -1,5 +1,6 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { i as withTimeout, o as CodexAppServerRpcError, r as withAbortableTimeout } from "./timeout-C910MdAB.mjs";
+import { n as CodexAppServerRpcError } from "./rpc-error-BlD2vuzn.mjs";
+import { i as withTimeout, r as withAbortableTimeout } from "./timeout-CXOfNoaX.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
 //#region extensions/codex/src/app-server/request.ts
 var request_exports = /* @__PURE__ */ __exportAll({
 	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
@@ -28,7 +29,7 @@ async function requestCodexAppServerClientJson(params) {
 	let phase = "prepare";
 	observeControlPhase(params.controlObservation, phase);
 	try {
-		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-C2sRMOEY.mjs").then((n) => n.r);
+		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
 		const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 			method: params.method,
 			requestParams: params.requestParams,
@@ -57,7 +58,7 @@ async function requestCodexAppServerClientJson(params) {
 }
 async function requestCodexAppServerJson(params) {
 	observeControlPhase(params.controlObservation, "prepare");
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-C2sRMOEY.mjs").then((n) => n.r);
+	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
 	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 		method: params.method,
 		requestParams: params.requestParams,
@@ -178,8 +179,8 @@ async function withCodexAppServerJsonClient(params, run) {
 			timeoutMs,
 			timeoutMessage,
 			promise: (async () => {
-				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);
+				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
+				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-DqyTMYug.mjs").then((n) => n.v);
 				for (let attempt = 0; attempt < 2; attempt += 1) {
 					errorPhase = void 0;
 					activePhase = "prepare";

package/dist/.setup/responses-oauth-twnuTaAa.mjs

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import { findPersistedAuthProfileCredential, isPendingOAuthRefreshFence, isSameOAuthRefreshGeneration, resolveApiKeyForProfile } from "openclaw/plugin-sdk/agent-runtime";
+import { decodeOpenAICodexJwtPayload } from "openclaw/plugin-sdk/provider-auth";
+//#region extensions/codex/src/app-server/responses-oauth.ts
+const CODEX_RESPONSES_OAUTH_PROVIDER = "openclaw_token_sharing";
+function isCodexResponsesOAuthRun(params) {
+	return params.runtimePlan?.auth.selectedAuthMode === "oauth" && params.runtimePlan.auth.selectedAuthFlow === "chatgpt-token-sharing";
+}
+function isCodexResponsesOAuthCredential(credential) {
+	return credential?.type === "oauth" && credential.provider === "openai" && credential.authFlow === "chatgpt-token-sharing";
+}
+function isCodexResponsesOAuth(prepared) {
+	return prepared?.kind === "profile" && prepared.snapshot?.inferenceAuth === "host-oauth";
+}
+/** The OAuth owner verified this ID token. Decoding here compares identity, never proves it. */
+function fingerprintCodexResponsesOAuth(credential) {
+	if (!isCodexResponsesOAuthCredential(credential) || credential?.type !== "oauth") throw new Error("ChatGPT subscription sharing is unavailable; sign in with OpenClaw again.");
+	const subject = credential.idToken && decodeOpenAICodexJwtPayload(credential.idToken)?.sub;
+	if (!credential.issuer || !credential.clientId || typeof subject !== "string" || !subject) throw new Error("ChatGPT subscription sharing identity is missing; sign in again.");
+	return createHash("sha256").update(JSON.stringify([
+		credential.issuer,
+		credential.clientId,
+		subject,
+		credential.authFlow
+	])).digest("hex");
+}
+async function resolveCodexResponsesOAuthProfileFingerprint(params) {
+	const credential = params.store.profiles[params.profileId];
+	if (credential?.type === "oauth" && isPendingOAuthRefreshFence(credential)) {
+		const resolved = await resolveApiKeyForProfile({
+			cfg: params.config,
+			store: params.store,
+			profileId: params.profileId,
+			agentDir: params.agentDir,
+			allowProfileFallback: false
+		});
+		if (!resolved?.credential || resolved.profileId !== params.profileId) throw new Error("ChatGPT subscription sharing could not settle its refresh; sign in again.");
+		const fingerprint = fingerprintCodexResponsesOAuth(resolved.credential);
+		params.store.profiles[params.profileId] = resolved.credential;
+		return fingerprint;
+	}
+	if (!credential) throw new Error("ChatGPT subscription sharing profile is unavailable; sign in again.");
+	return fingerprintCodexResponsesOAuth(credential);
+}
+/** Keep OAuth refresh and persisted grant ownership in OpenClaw, outside native Codex auth. */
+function createCodexResponsesOAuth(params) {
+	const persisted = Boolean(findPersistedAuthProfileCredential(params)) || params.store.runtimePersistedProfileIds?.includes(params.profileId) === true;
+	const readCredential = () => persisted ? findPersistedAuthProfileCredential(params) : params.store.profiles[params.profileId];
+	const validate = (credential) => {
+		if (fingerprintCodexResponsesOAuth(credential) !== params.fingerprint) throw new Error("ChatGPT subscription sharing identity changed; reconnect before retrying.");
+	};
+	let lastCredential = params.store.profiles[params.profileId];
+	validate(lastCredential);
+	const validateCurrent = (credential, reference) => {
+		if (credential?.type === "oauth" && reference?.type === "oauth" && isPendingOAuthRefreshFence(credential) && credential.authFlow === reference.authFlow && credential.issuer === reference.issuer && credential.clientId === reference.clientId && isSameOAuthRefreshGeneration({
+			profileId: params.profileId,
+			left: credential,
+			right: reference
+		})) return;
+		validate(credential);
+	};
+	return { async resolve(forceRefresh) {
+		const credential = readCredential();
+		validateCurrent(credential, lastCredential);
+		const resolved = await resolveApiKeyForProfile({
+			cfg: params.config,
+			agentDir: params.agentDir,
+			profileId: params.profileId,
+			store: persisted ? {
+				...params.store,
+				profiles: {
+					...params.store.profiles,
+					[params.profileId]: credential
+				}
+			} : params.store,
+			forceRefresh,
+			allowProfileFallback: false,
+			validateOAuthCredential: validate
+		});
+		if (!resolved?.apiKey || resolved.profileId !== params.profileId) throw new Error("ChatGPT subscription sharing could not refresh; sign in again.");
+		const resolvedCredential = resolved.credential;
+		validate(resolvedCredential);
+		lastCredential = resolvedCredential;
+		const assertCurrent = () => validateCurrent(readCredential(), resolvedCredential);
+		assertCurrent();
+		return {
+			token: resolved.apiKey,
+			assertCurrent
+		};
+	} };
+}
+//#endregion
+export { isCodexResponsesOAuthRun as a, isCodexResponsesOAuthCredential as i, createCodexResponsesOAuth as n, resolveCodexResponsesOAuthProfileFingerprint as o, isCodexResponsesOAuth as r, CODEX_RESPONSES_OAUTH_PROVIDER as t };

package/dist/.setup/rpc-error-BlD2vuzn.mjs

@@ -0,0 +1,31 @@
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+//#region extensions/codex/src/app-server/rpc-error.ts
+const CODEX_APP_SERVER_OVERLOADED_ERROR_CODE = -32001;
+/** RPC error wrapper that preserves app-server error code and data. */
+var CodexAppServerRpcError = class extends Error {
+	constructor(error, method) {
+		super(formatCodexAppServerRpcErrorMessage(error, method));
+		this.name = "CodexAppServerRpcError";
+		this.code = error.code;
+		this.data = error.data;
+		this.method = method;
+	}
+};
+function isCodexThreadReadMissingError(error, threadId) {
+	return error instanceof CodexAppServerRpcError && error.method === "thread/read" && error.code === -32600 && error.message === `thread not loaded: ${threadId}`;
+}
+function formatCodexAppServerRpcErrorMessage(error, method) {
+	const message = error.message || `${method} failed`;
+	const detail = readCodexAppServerRpcReloginDetail(error.data);
+	return detail && !message.includes(detail) ? `${message}: ${detail}` : message;
+}
+function readCodexAppServerRpcReloginDetail(data) {
+	const record = isJsonObject(data) ? data : void 0;
+	const nested = isJsonObject(record?.error) ? record.error : record;
+	if (!nested) return;
+	const isRelogin = nested.action === "relogin" || nested.reason === "cloudRequirements" && nested.errorCode === "Auth";
+	const detail = typeof nested.detail === "string" ? nested.detail.trim() : "";
+	return isRelogin && detail ? detail : void 0;
+}
+//#endregion
+export { CodexAppServerRpcError as n, isCodexThreadReadMissingError as r, CODEX_APP_SERVER_OVERLOADED_ERROR_CODE as t };