@openclaw/codex 2026.5.24-beta.2 → 2026.5.26-beta.1

package/dist/{notification-correlation-qKY_sgga.js → notification-correlation-YINts3PA.js}

@@ -1,4 +1,5 @@
-import { t as isJsonObject } from "./protocol-oeJQu4rs.js";
+import { l as isJsonObject } from "./client-BVK_jmHW.js";
+import { asFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/rate-limits.ts
 const CODEX_LIMIT_ID = "codex";
 const LIMIT_WINDOW_KEYS = ["primary", "secondary"];
@@ -10,15 +11,24 @@ function formatCodexUsageLimitErrorMessage(params) {
 	const message = normalizeText(params.message);
 	if (!isCodexUsageLimitError(params.codexErrorInfo, message)) return;
 	const nowMs = params.nowMs ?? Date.now();
-	const nextReset = selectNextRateLimitReset(params.rateLimits, nowMs);
+	const usageSummary = summarizeCodexAccountUsage(params.rateLimits, nowMs);
+	const nextReset = selectBlockingRateLimitReset(params.rateLimits, nowMs) ?? (usageSummary?.blocked ? void 0 : selectNextRateLimitReset(params.rateLimits, nowMs));
 	const parts = ["You've reached your Codex subscription usage limit."];
-	if (nextReset) parts.push(`Next reset ${formatResetTime(nextReset.resetsAtMs, nowMs)}.`);
-	else {
+	let recoveryAction = "Wait until Codex becomes available";
+	if (nextReset) {
+		parts.push(`Next reset ${formatResetTime(nextReset.resetsAtMs, nowMs)}.`);
+		recoveryAction = "Wait until the reset time";
+	} else {
 		const codexRetryHint = extractCodexRetryHint(message);
-		if (codexRetryHint) parts.push(`Codex says to try again ${codexRetryHint}.`);
-		else parts.push("Codex did not return a reset time for this limit.");
+		if (codexRetryHint) {
+			parts.push(`Codex says to try again ${codexRetryHint}.`);
+			recoveryAction = "Wait until the retry time";
+		} else {
+			if (usageSummary?.blockingPeriod && usageSummary.blockingReason) parts.push(`Your ${usageSummary.blockingReason}.`);
+			parts.push("OpenClaw could not determine a reset time from Codex.");
+		}
 	}
-	parts.push("Run /codex account for current usage details.");
+	parts.push(`${recoveryAction}, use another Codex account if available, or switch to another configured model/provider.`);
 	return parts.join(" ");
 }
 function shouldRefreshCodexRateLimitsForUsageLimitMessage(message) {
@@ -49,8 +59,9 @@ function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
 	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
 	const blockedSnapshots = snapshots.filter(snapshotHasLimitBlock);
 	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
-	const blockingReset = blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs) : void 0;
-	const blockingPeriod = formatBlockingLimitPeriod(blockingReset?.windowDurationMins);
+	const blockingWindow = blockingSnapshot ? selectSnapshotBlockingWindow(blockingSnapshot, nowMs) : void 0;
+	const blockingReset = blockingWindow && blockingWindow.resetsAtMs > nowMs ? blockingWindow : void 0;
+	const blockingPeriod = formatBlockingLimitPeriod(blockingWindow?.windowDurationMins);
 	const blockedUntilText = blockingReset ? formatAccountResetTime(blockingReset.resetsAtMs, nowMs) : void 0;
 	const blockedResetRelative = blockingReset ? `in ${formatRelativeDuration(blockingReset.resetsAtMs - nowMs)}` : void 0;
 	const blockingReason = blockingPeriod ? `${blockingPeriod} Codex usage limit is reached` : blockingSnapshot ? "Codex usage limit is reached" : void 0;
@@ -191,6 +202,11 @@ function selectSnapshotBlockingReset(snapshot, nowMs) {
 	const resetSort = exhaustedWindows.length > 0 ? (left, right) => right.resetsAtMs - left.resetsAtMs : (left, right) => left.resetsAtMs - right.resetsAtMs;
 	return candidates.toSorted(resetSort)[0];
 }
+function selectSnapshotBlockingWindow(snapshot, nowMs) {
+	const resetWindow = selectSnapshotBlockingReset(snapshot, nowMs);
+	if (resetWindow) return resetWindow;
+	return readWindowEntries(snapshot).map((entry) => entry.window).filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100).toSorted((left, right) => (right.windowDurationMins ?? 0) - (left.windowDurationMins ?? 0))[0];
+}
 function readWindowEntries(snapshot) {
 	return LIMIT_WINDOW_KEYS.flatMap((key) => {
 		const window = readRateLimitWindow(snapshot, key);
@@ -288,8 +304,7 @@ function readNullableString(record, key) {
 	return readString$2(record, key) ?? void 0;
 }
 function readNumber(record, key) {
-	const value = record[key];
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+	return asFiniteNumber(record[key]);
 }
 function normalizeText(value) {
 	const text = value?.trim();

package/dist/{protocol-validators-_gKDcd0x.js → protocol-validators-CSuFMLvY.js}

@@ -1,4 +1,4 @@
-import AjvPkg from "ajv";
+import { Compile } from "typebox/compile";
 //#region extensions/codex/src/app-server/protocol-generated/json/DynamicToolCallParams.json
 var DynamicToolCallParams_default = {
 	$schema: "http://json-schema.org/draft-07/schema#",
@@ -5856,52 +5856,158 @@ var TurnStartResponse_default = {
 };
 //#endregion
 //#region extensions/codex/src/app-server/protocol-validators.ts
-const ajv = new AjvPkg({
-	allErrors: true,
-	strict: false,
-	useDefaults: true,
-	validateFormats: false
-});
-const validateDynamicToolCallParams = ajv.compile(DynamicToolCallParams_default);
-const validateErrorNotification = ajv.compile(ErrorNotification_default);
-const validateModelListResponse = ajv.compile(ModelListResponse_default);
-const validateThreadResumeResponse = ajv.compile(ThreadResumeResponse_default);
-const validateThreadStartResponse = ajv.compile(ThreadStartResponse_default);
-const validateTurnCompletedNotification = ajv.compile(TurnCompletedNotification_default);
-const validateTurnStartResponse = ajv.compile(TurnStartResponse_default);
+function compileCodexSchema(schema) {
+	const validator = Compile(normalizeJsonSchemaNode(schema));
+	return {
+		check: (value) => validator.Check(value),
+		errors: (value) => [...validator.Errors(value)]
+	};
+}
+function isRecord(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+const schemaMapKeywords = new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+const schemaValueKeywords = new Set([
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+const schemaArrayKeywords = new Set([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+]);
+function schemaTypeIncludes(schema, type) {
+	return schema.type === type || Array.isArray(schema.type) && schema.type.includes(type);
+}
+function normalizeSchemaMap(value) {
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeJsonSchemaNode(entry)]));
+}
+function expandJsonSchemaTypeArray(schema) {
+	const { type, ...rest } = schema;
+	if (!Array.isArray(type)) return schema;
+	return { anyOf: type.map((entry) => Object.assign({}, rest, { type: entry })) };
+}
+function normalizeJsonSchemaNode(schema) {
+	if (Array.isArray(schema)) return schema.map((entry) => normalizeJsonSchemaNode(entry));
+	if (!isRecord(schema)) return schema;
+	const normalizedSchema = expandJsonSchemaTypeArray(schema);
+	return Object.fromEntries(Object.entries(normalizedSchema).map(([key, value]) => {
+		if (schemaMapKeywords.has(key)) return [key, normalizeSchemaMap(value)];
+		if (schemaValueKeywords.has(key) || schemaArrayKeywords.has(key)) return [key, normalizeJsonSchemaNode(value)];
+		return [key, value];
+	}));
+}
+function readDefault(schema) {
+	if (!isRecord(schema) || !Object.prototype.hasOwnProperty.call(schema, "default")) return;
+	return structuredClone(schema.default);
+}
+function decodePointerSegment(segment) {
+	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function resolveLocalRef(root, ref) {
+	if (ref === "#") return root;
+	if (!ref.startsWith("#/")) return;
+	let current = root;
+	for (const segment of ref.slice(2).split("/").map(decodePointerSegment)) {
+		if (!isRecord(current)) return;
+		current = current[segment];
+	}
+	return current;
+}
+function applySchemaDefaults(schema, value, root = schema, resolvingRefs = /* @__PURE__ */ new Set()) {
+	if (value === void 0) {
+		const defaultValue = readDefault(schema);
+		if (defaultValue !== void 0) return defaultValue;
+	}
+	if (!isRecord(schema)) return value;
+	let nextValue = value;
+	if (typeof schema.$ref === "string" && !resolvingRefs.has(schema.$ref)) {
+		const target = resolveLocalRef(root, schema.$ref);
+		if (target !== void 0) {
+			resolvingRefs.add(schema.$ref);
+			nextValue = applySchemaDefaults(target, nextValue, root, resolvingRefs);
+			resolvingRefs.delete(schema.$ref);
+		}
+	}
+	for (const key of ["allOf"]) {
+		const branches = schema[key];
+		if (Array.isArray(branches)) for (const branch of branches) nextValue = applySchemaDefaults(branch, nextValue, root, resolvingRefs);
+	}
+	if (schemaTypeIncludes(schema, "object") && isRecord(nextValue) && isRecord(schema.properties)) {
+		for (const [key, propertySchema] of Object.entries(schema.properties)) {
+			const currentValue = nextValue[key];
+			const defaultedValue = applySchemaDefaults(propertySchema, currentValue, root, resolvingRefs);
+			if (defaultedValue !== void 0 && defaultedValue !== currentValue) nextValue[key] = defaultedValue;
+		}
+		if (isRecord(schema.additionalProperties)) for (const key of Object.keys(nextValue)) {
+			if (Object.prototype.hasOwnProperty.call(schema.properties, key)) continue;
+			nextValue[key] = applySchemaDefaults(schema.additionalProperties, nextValue[key], root, resolvingRefs);
+		}
+	}
+	if (schemaTypeIncludes(schema, "array") && Array.isArray(nextValue) && isRecord(schema.items)) return nextValue.map((entry) => applySchemaDefaults(schema.items, entry, root, resolvingRefs));
+	return nextValue;
+}
+function normalizeWithDefaults(schema, value) {
+	if (value === void 0 || value === null) return value;
+	return applySchemaDefaults(schema, structuredClone(value));
+}
+const validateDynamicToolCallParams = compileCodexSchema(DynamicToolCallParams_default);
+const validateErrorNotification = compileCodexSchema(ErrorNotification_default);
+const validateModelListResponse = compileCodexSchema(ModelListResponse_default);
+const validateThreadResumeResponse = compileCodexSchema(ThreadResumeResponse_default);
+const validateThreadStartResponse = compileCodexSchema(ThreadStartResponse_default);
+const validateTurnCompletedNotification = compileCodexSchema(TurnCompletedNotification_default);
+const validateTurnStartResponse = compileCodexSchema(TurnStartResponse_default);
 function assertCodexThreadStartResponse(value) {
-	return assertCodexShape(validateThreadStartResponse, normalizeThreadResponse(value), "thread/start response");
+	return assertCodexShape(validateThreadStartResponse, normalizeWithDefaults(ThreadStartResponse_default, normalizeThreadResponse(value)), "thread/start response");
 }
 function assertCodexThreadForkResponse(value) {
-	return assertCodexShape(validateThreadStartResponse, normalizeThreadResponse(value), "thread/fork response");
+	return assertCodexShape(validateThreadStartResponse, normalizeWithDefaults(ThreadStartResponse_default, normalizeThreadResponse(value)), "thread/fork response");
 }
 function assertCodexThreadResumeResponse(value) {
-	return assertCodexShape(validateThreadResumeResponse, normalizeThreadResponse(value), "thread/resume response");
+	return assertCodexShape(validateThreadResumeResponse, normalizeWithDefaults(ThreadResumeResponse_default, normalizeThreadResponse(value)), "thread/resume response");
 }
 function assertCodexTurnStartResponse(value) {
-	return assertCodexShape(validateTurnStartResponse, normalizeTurnStartResponse(value), "turn/start response");
+	return assertCodexShape(validateTurnStartResponse, normalizeWithDefaults(TurnStartResponse_default, normalizeTurnStartResponse(value)), "turn/start response");
 }
 function readCodexDynamicToolCallParams(value) {
-	return readCodexShape(validateDynamicToolCallParams, value);
+	return readCodexShape(validateDynamicToolCallParams, normalizeWithDefaults(DynamicToolCallParams_default, value));
 }
 function readCodexErrorNotification(value) {
-	return readCodexShape(validateErrorNotification, value);
+	return readCodexShape(validateErrorNotification, normalizeWithDefaults(ErrorNotification_default, value));
 }
 function readCodexModelListResponse(value) {
-	return readCodexShape(validateModelListResponse, value);
+	return readCodexShape(validateModelListResponse, normalizeWithDefaults(ModelListResponse_default, value));
 }
 function readCodexTurn(value) {
-	return readCodexShape(validateTurnStartResponse, { turn: normalizeTurn(value) })?.turn;
+	return readCodexShape(validateTurnStartResponse, normalizeWithDefaults(TurnStartResponse_default, { turn: normalizeTurn(value) }))?.turn;
 }
 function readCodexTurnCompletedNotification(value) {
-	return readCodexShape(validateTurnCompletedNotification, normalizeTurnCompletedNotification(value));
+	return readCodexShape(validateTurnCompletedNotification, normalizeWithDefaults(TurnCompletedNotification_default, normalizeTurnCompletedNotification(value)));
 }
 function assertCodexShape(validate, value, label) {
-	if (validate(value)) return value;
-	throw new Error(`Invalid Codex app-server ${label}: ${formatAjvErrors(validate)}`);
+	if (validate.check(value)) return value;
+	throw new Error(`Invalid Codex app-server ${label}: ${formatValidationErrors(validate, value)}`);
 }
 function readCodexShape(validate, value) {
-	return validate(value) ? value : void 0;
+	return validate.check(value) ? value : void 0;
 }
 function normalizeTurn(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
@@ -5979,10 +6085,13 @@ function normalizeTurnCompletedNotification(value) {
 		turn: normalizeTurn(value.turn)
 	};
 }
-function formatAjvErrors(validate) {
-	const errors = validate.errors;
+function formatValidationErrors(validate, value) {
+	const errors = validate.errors(value);
 	if (!errors || errors.length === 0) return "schema validation failed";
-	return ajv.errorsText(errors, { separator: "; " });
+	return errors.map((error) => {
+		const message = error.message?.trim() || "schema validation failed";
+		return error.instancePath ? `${error.instancePath} ${message}` : message;
+	}).join("; ");
 }
 //#endregion
 export { readCodexDynamicToolCallParams as a, readCodexTurn as c, assertCodexTurnStartResponse as i, readCodexTurnCompletedNotification as l, assertCodexThreadResumeResponse as n, readCodexErrorNotification as o, assertCodexThreadStartResponse as r, readCodexModelListResponse as s, assertCodexThreadForkResponse as t };

package/dist/provider.js

@@ -1,5 +1,5 @@
 import { CODEX_APP_SERVER_AUTH_MARKER, CODEX_BASE_URL, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexModelDefinition, buildCodexProviderConfig } from "./provider-catalog.js";
-import { c as readCodexPluginConfig, l as resolveCodexAppServerRuntimeOptions } from "./config-DDMrwfJl.js";
+import { c as readCodexPluginConfig, l as resolveCodexAppServerRuntimeOptions } from "./config-0-UN67Qg.js";
 import { resolveCodexSystemPromptContribution } from "./prompt-overlay.js";
 import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { normalizeModelCompat } from "openclaw/plugin-sdk/provider-model-shared";
@@ -123,7 +123,7 @@ async function listModelsBestEffort(params) {
 	}
 }
 async function listCodexAppServerModelsLazy(options) {
-	const { listCodexAppServerModels } = await import("./models-DtGLkqMP.js").then((n) => n.r);
+	const { listCodexAppServerModels } = await import("./models-ASKu9eOY.js").then((n) => n.r);
 	return listCodexAppServerModels(options);
 }
 function normalizeTimeoutMs(value) {
@@ -144,7 +144,7 @@ function isKnownXHighCodexModel(modelId) {
 }
 function isModernCodexModel(modelId) {
 	const lower = modelId.trim().toLowerCase();
-	return lower === "gpt-5.5" || lower === "gpt-5.4" || lower === "gpt-5.4-mini";
+	return lower === "gpt-5.5" || lower === "gpt-5.4" || lower === "gpt-5.4-mini" || lower === "gpt-5.3-codex-spark";
 }
 //#endregion
 export { buildCodexProvider, buildCodexProviderCatalog, isModernCodexModel };

package/dist/{request-D93E78SA.js → request-DmBkYLPy.js}

@@ -1,6 +1,6 @@
-import { n as CodexAppServerRpcError } from "./client-1sSy4p3z.js";
-import { b as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-DGoaguJh.js";
-import { f as resolveCodexAppServerHomeDir, i as getSharedCodexAppServerClient, o as withTimeout, r as createIsolatedCodexAppServerClient } from "./shared-client-CFCUGEVs.js";
+import { n as CodexAppServerRpcError } from "./client-BVK_jmHW.js";
+import { S as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-BapIT9Qs.js";
+import { f as resolveCodexAppServerHomeDir, i as getSharedCodexAppServerClient, o as withTimeout, r as createIsolatedCodexAppServerClient } from "./shared-client-Fou5nAyt.js";
 import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-CTnEWuor.js";
 import { createHash } from "node:crypto";
 //#region extensions/codex/src/app-server/capabilities.ts