@openclaw/codex 2026.6.2-beta.1 → 2026.6.5-beta.2

package/dist/{native-hook-relay-CBp3nIGk.js → native-hook-relay-DZ3Oon0b.js}

@@ -1,20 +1,25 @@
-import { l as isJsonObject } from "./client-BFxKzFnH.js";
-import { S as invalidInlineImageText, w as sanitizeInlineImageDataUrl } from "./thread-lifecycle-BOYYMjx6.js";
-import { s as formatCodexDisplayText } from "./notification-correlation-Bg-AlEEy.js";
+import { l as isJsonObject } from "./client-kMCtlApt.js";
+import { S as invalidInlineImageText, w as sanitizeInlineImageDataUrl } from "./thread-lifecycle-BJsazZ8j.js";
+import { s as formatCodexDisplayText } from "./notification-correlation-o8quHmTK.js";
 import { addTimerTimeoutGraceMs, finiteSecondsToTimerSafeMilliseconds, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { createHash } from "node:crypto";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { asOptionalRecord, isRecord, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { HEARTBEAT_RESPONSE_TOOL_NAME, buildAgentHookContextChannelFields, callGatewayTool, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractToolResultMediaArtifact, filterToolResultMediaUrls, formatApprovalDisplayPath, hasNativeHookRelayInvocation, invokeNativeHookRelay, isMessagingTool, isMessagingToolSendAction, isToolWrappedWithBeforeToolCallHook, normalizeHeartbeatToolResponse, projectRuntimeToolInputSchema, registerNativeHookRelay, resolveNativeHookRelayDeferredToolApproval, runAgentHarnessAfterToolCallHook, runBeforeToolCallHook, setBeforeToolCallDiagnosticsEnabled, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { emitTrustedDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
+/** Default idle timeout while waiting for app-server turn completion. */
 const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
+/** Short guard after apparent assistant completion. */
 const CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 1e4;
 const CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 5 * 6e4;
+/** Guard after reasoning/commentary progress when no tool handoff occurred. */
 const CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS = 5 * 6e4;
+/** Long terminal idle watch for app-server turns that never send completion. */
 const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 30 * 6e4;
 function resolvePositiveIntegerTimeoutMs(value, fallbackMs) {
 	return resolveTimerTimeoutMs(value, resolveTimerTimeoutMs(fallbackMs, 1));
 }
+/** Runs startup work with abort and timeout handling plus optional cleanup. */
 async function withCodexStartupTimeout(params) {
 	if (params.signal.aborted) throw new Error("codex app-server startup aborted");
 	let timeout;
@@ -52,32 +57,43 @@ async function withCodexStartupTimeout(params) {
 		abortCleanup?.();
 	}
 }
+/** Resolves startup timeout while honoring the configured floor. */
 function resolveCodexStartupTimeoutMs(params) {
 	const timeoutFloorMs = resolvePositiveIntegerTimeoutMs(params.timeoutFloorMs, 100);
 	const timeoutMs = resolvePositiveIntegerTimeoutMs(params.timeoutMs, timeoutFloorMs);
 	return Math.max(timeoutFloorMs, timeoutMs);
 }
+/** Resolves the completion-idle timeout for an active turn. */
 function resolveCodexTurnCompletionIdleTimeoutMs(value) {
 	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS);
 }
+/** Resolves the short assistant-completion release timeout. */
 function resolveCodexTurnAssistantCompletionIdleTimeoutMs(value) {
 	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS);
 }
+/** Resolves the conservative post-tool raw assistant guard timeout. */
 function resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(value, fallbackMs) {
 	return resolvePositiveIntegerTimeoutMs(value, Math.max(resolvePositiveIntegerTimeoutMs(void 0, fallbackMs), CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS));
 }
+/** Resolves the long terminal turn idle timeout. */
 function resolveCodexTurnTerminalIdleTimeoutMs(value) {
 	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS);
 }
+/** Adds gateway grace time to a caller timeout without overflowing invalid values. */
 function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
 	const timeout = resolvePositiveIntegerTimeoutMs(timeoutMs, 1);
 	return addTimerTimeoutGraceMs(timeout, resolveTimerTimeoutMs(graceMs, 0, 0)) ?? timeout;
 }
 //#endregion
 //#region extensions/codex/src/app-server/plugin-approval-roundtrip.ts
+/**
+* Routes Codex app-server plugin approval prompts through OpenClaw's gateway
+* approval tool and maps gateway decisions back to Codex outcomes.
+*/
 const DEFAULT_CODEX_APPROVAL_TIMEOUT_MS = 12e4;
 const MAX_PLUGIN_APPROVAL_TITLE_LENGTH = 80;
 const MAX_PLUGIN_APPROVAL_DESCRIPTION_LENGTH = 256;
+/** Starts a two-phase plugin approval request through the OpenClaw gateway. */
 async function requestPluginApproval(params) {
 	const timeoutMs = DEFAULT_CODEX_APPROVAL_TIMEOUT_MS;
 	return callGatewayTool("plugin.approval.request", { timeoutMs: resolveCodexGatewayTimeoutWithGraceMs(timeoutMs) }, {
@@ -97,6 +113,7 @@ async function requestPluginApproval(params) {
 		twoPhase: true
 	}, { expectFinal: false });
 }
+/** Detects the gateway's explicit null-decision marker for unavailable approvals. */
 function approvalRequestExplicitlyUnavailable(result) {
 	if (result === null || result === void 0 || typeof result !== "object") return false;
 	let descriptor;
@@ -107,6 +124,7 @@ function approvalRequestExplicitlyUnavailable(result) {
 	}
 	return descriptor !== void 0 && "value" in descriptor && descriptor.value === null;
 }
+/** Waits for the gateway's final approval decision, respecting turn aborts. */
 async function waitForPluginApprovalDecision(params) {
 	const waitPromise = callGatewayTool("plugin.approval.waitDecision", { timeoutMs: resolveCodexGatewayTimeoutWithGraceMs(DEFAULT_CODEX_APPROVAL_TIMEOUT_MS) }, { id: params.approvalId });
 	if (!params.signal) return (await waitPromise)?.decision;
@@ -125,6 +143,7 @@ async function waitForPluginApprovalDecision(params) {
 		if (onAbort) params.signal.removeEventListener("abort", onAbort);
 	}
 }
+/** Converts a gateway exec approval decision into the app-server approval outcome enum. */
 function mapExecDecisionToOutcome(decision) {
 	if (decision === "allow-once") return "approved-once";
 	if (decision === "allow-always") return "approved-session";
@@ -143,6 +162,10 @@ function toLintErrorObject(value, fallbackMessage) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/approval-bridge.ts
+/**
+* Bridges Codex app-server approval requests into OpenClaw policy hooks and
+* plugin approval UX.
+*/
 const PERMISSION_DESCRIPTION_MAX_LENGTH = 700;
 const PERMISSION_SAMPLE_LIMIT = 2;
 const PERMISSION_VALUE_MAX_LENGTH = 48;
@@ -154,6 +177,10 @@ const ANSI_CONTROL_SEQUENCE_RE$1 = new RegExp(String.raw`(?:\u001b\[[0-?]*[ -/]*
 const CONTROL_CHARACTER_RE$1 = new RegExp(String.raw`[\u0000-\u001f\u007f-\u009f]+`, "g");
 const INVISIBLE_FORMATTING_CONTROL_RE$1 = new RegExp(String.raw`[\u00ad\u034f\u061c\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff\ufe00-\ufe0f\u{e0100}-\u{e01ef}]`, "gu");
 const DANGLING_TERMINAL_SEQUENCE_SUFFIX_RE$1 = new RegExp(String.raw`(?:\u001b\][^\u001b\u009c\u0007]*|\u009d[^\u001b\u009c\u0007]*|\u001b\[[0-?]*[ -/]*|\u009b[0-?]*[ -/]*|\u001b)$`);
+/**
+* Handles one app-server approval request for the active thread/turn, returning
+* the app-server response payload when the request belongs to this run.
+*/
 async function handleCodexAppServerApprovalRequest(params) {
 	const requestParams = isJsonObject(params.requestParams) ? params.requestParams : void 0;
 	if (!matchesCurrentTurn(requestParams, params.threadId, params.turnId)) return;
@@ -269,6 +296,7 @@ async function handleCodexAppServerApprovalRequest(params) {
 		return buildApprovalResponse(params.method, context.requestParams, cancelled ? "cancelled" : "denied");
 	}
 }
+/** Converts an OpenClaw approval outcome into the app-server method response. */
 function buildApprovalResponse(method, requestParams, outcome) {
 	if (method === "item/commandExecution/requestApproval") return { decision: commandApprovalDecision(requestParams, outcome) };
 	if (method === "item/fileChange/requestApproval") return { decision: fileChangeApprovalDecision(outcome) };
@@ -881,12 +909,21 @@ function formatErrorMessage$1(error) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/vision-tools.ts
+/**
+* Filters Codex dynamic tools for turns that already contain image inputs so
+* models with native vision do not get redundant image-inspection tools.
+*/
+/** Removes the image tool when the model can directly consume inbound images. */
 function filterToolsForVisionInputs(tools, params) {
 	if (!params.modelHasVision || !params.hasInboundImages) return tools;
 	return tools.filter((tool) => tool.name !== "image");
 }
 //#endregion
 //#region extensions/codex/src/app-server/dynamic-tool-diagnostics.ts
+/**
+* Trusted diagnostics emitted around Codex dynamic tool execution lifecycle.
+*/
+/** Emits a start event for one Codex dynamic tool call. */
 function emitDynamicToolStartedDiagnostic(params) {
 	emitTrustedDiagnosticEvent({
 		type: "tool.execution.started",
@@ -897,6 +934,7 @@ function emitDynamicToolStartedDiagnostic(params) {
 		toolCallId: params.call.callId
 	});
 }
+/** Emits an error event for one Codex dynamic tool call. */
 function emitDynamicToolErrorDiagnostic(params) {
 	emitTrustedDiagnosticEvent({
 		type: "tool.execution.error",
@@ -909,6 +947,7 @@ function emitDynamicToolErrorDiagnostic(params) {
 		errorCategory: "codex_dynamic_tool_error"
 	});
 }
+/** Emits the terminal event matching a dynamic tool response's diagnostic type. */
 function emitDynamicToolTerminalDiagnostic(params) {
 	const terminalType = params.response.diagnosticTerminalType ?? (params.response.success ? "completed" : "error");
 	if (terminalType === "completed") {
@@ -940,9 +979,14 @@ function emitDynamicToolTerminalDiagnostic(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/dynamic-tools.ts
+/** Namespace attached to OpenClaw-owned dynamic tools exposed to Codex. */
 const CODEX_OPENCLAW_DYNAMIC_TOOL_NAMESPACE = "openclaw";
 const ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES = new Set(["sessions_yield"]);
 const DEFAULT_CODEX_DYNAMIC_TOOL_RESULT_MAX_CHARS = 16e3;
+/**
+* Creates dynamic tool specs and a call handler that executes OpenClaw tools,
+* applies hooks/middleware, and records delivery/media telemetry.
+*/
 function createCodexDynamicToolBridge(params) {
 	const toolResultHookContext = toToolResultHookContext(params.hookContext);
 	const toolResultMaxChars = resolveCodexDynamicToolResultMaxChars(params.hookContext);
@@ -1964,6 +2008,11 @@ function readFirstString(record, keys) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/native-hook-relay.ts
+/**
+* Bridges Codex native hook callbacks into OpenClaw's native hook relay so
+* app-server tool events can still run OpenClaw policy and diagnostics.
+*/
+/** Codex hook events that can be registered through OpenClaw's native relay. */
 const CODEX_NATIVE_HOOK_RELAY_EVENTS = [
 	"pre_tool_use",
 	"post_tool_use",
@@ -1972,10 +2021,12 @@ const CODEX_NATIVE_HOOK_RELAY_EVENTS = [
 ];
 const CODEX_NATIVE_HOOK_RELAY_EVENTS_WITH_APP_SERVER_APPROVALS = CODEX_NATIVE_HOOK_RELAY_EVENTS.filter((event) => event !== "permission_request");
 const CODEX_NATIVE_HOOK_RELAY_MIN_TTL_MS = 30 * 6e4;
+/** Extra relay lifetime after the expected turn budget, preventing late hook drops. */
 const CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS = 5 * 6e4;
 const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS = 1e4;
 const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS = 5e3;
 const pendingCodexNativeHookRelayUnregisters = /* @__PURE__ */ new Set();
+/** Defers relay unregister so late native hook subprocesses can still resolve. */
 function scheduleCodexNativeHookRelayUnregister(params) {
 	let pending;
 	const unregister = () => {
@@ -1993,10 +2044,12 @@ function scheduleCodexNativeHookRelayUnregister(params) {
 	pendingCodexNativeHookRelayUnregisters.add(pending);
 	timeout.unref();
 }
+/** Computes the delayed unregister window from Codex's hook timeout. */
 function resolveCodexNativeHookRelayUnregisterGraceMs(hookTimeoutSec) {
 	const hookTimeoutMs = typeof hookTimeoutSec === "number" && Number.isFinite(hookTimeoutSec) && hookTimeoutSec > 0 ? finiteSecondsToTimerSafeMilliseconds(Math.ceil(hookTimeoutSec)) ?? 0 : 0;
 	return Math.max(CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS, addTimerTimeoutGraceMs(hookTimeoutMs, CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS) ?? 0);
 }
+/** Registers an OpenClaw native hook relay for a Codex app-server turn. */
 function createCodexNativeHookRelay(params) {
 	if (params.options?.enabled === false) return;
 	return registerNativeHookRelay({
@@ -2028,15 +2081,18 @@ function createCodexNativeHookRelay(params) {
 		}
 	});
 }
+/** Selects the native hook events Codex should install for the current approval mode. */
 function resolveCodexNativeHookRelayEvents(params) {
 	if (params.configuredEvents?.length) return params.configuredEvents;
 	return params.appServer.approvalPolicy === "never" ? CODEX_NATIVE_HOOK_RELAY_EVENTS : CODEX_NATIVE_HOOK_RELAY_EVENTS_WITH_APP_SERVER_APPROVALS;
 }
+/** Derives the native hook relay TTL from the turn budget unless explicitly configured. */
 function resolveCodexNativeHookRelayTtlMs(params) {
 	if (params.explicitTtlMs !== void 0) return params.explicitTtlMs;
 	const relayBudgetMs = params.attemptTimeoutMs + params.startupTimeoutMs + params.turnStartTimeoutMs + CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS;
 	return Math.max(CODEX_NATIVE_HOOK_RELAY_MIN_TTL_MS, Math.floor(relayBudgetMs));
 }
+/** Builds a stable relay id scoped to the agent and session identity. */
 function buildCodexNativeHookRelayId(params) {
 	const hash = createHash("sha256");
 	hash.update("openclaw:codex:native-hook-relay:v1");
@@ -2059,6 +2115,7 @@ const CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT = {
 	before_agent_finalize: "stop"
 };
 const CODEX_SESSION_FLAGS_HOOK_SOURCE_PATHS = ["/<session-flags>/config.toml", "<session-flags>/config.toml"];
+/** Builds the Codex config overlay that installs trusted command hooks for relay events. */
 function buildCodexNativeHookRelayConfig(params) {
 	const events = params.events?.length ? params.events : CODEX_NATIVE_HOOK_RELAY_EVENTS;
 	const selectedEvents = new Set(events);
@@ -2096,6 +2153,7 @@ function buildCodexNativeHookRelayConfig(params) {
 	config["hooks.state"] = hookState;
 	return config;
 }
+/** Builds a Codex config overlay that disables native hooks and clears hook arrays. */
 function buildCodexNativeHookRelayDisabledConfig() {
 	return {
 		"features.hooks": false,

package/dist/{notification-correlation-Bg-AlEEy.js → notification-correlation-o8quHmTK.js}

@@ -1,13 +1,18 @@
-import { l as isJsonObject } from "./client-BFxKzFnH.js";
+import { l as isJsonObject } from "./client-kMCtlApt.js";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { asFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#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 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;
+/** Enriches Codex usage-limit failures with reset timing and recovery guidance. */
 function formatCodexUsageLimitErrorMessage(params) {
 	const message = normalizeText(params.message);
 	if (!isCodexUsageLimitError(params.codexErrorInfo, message)) return;
@@ -32,28 +37,34 @@ 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 = normalizeText(message);
 	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()) {
 	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;
 }
+/** 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;
 }
+/** 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;
@@ -312,6 +323,7 @@ function normalizeText(value) {
 }
 //#endregion
 //#region extensions/codex/src/command-formatters.ts
+/** Formats the combined `/codex status` probe result. */
 function formatCodexStatus(probes) {
 	const lines = [`Codex app-server: ${probes.models.ok || probes.account.ok || probes.limits.ok || probes.mcps.ok || probes.skills.ok ? "connected" : "unavailable"}`];
 	if (probes.models.ok) lines.push(`Models: ${probes.models.value.models.map((model) => formatCodexDisplayText(model.id)).slice(0, 8).join(", ") || "none"}`);
@@ -322,12 +334,14 @@ function formatCodexStatus(probes) {
 	lines.push(`Skills: ${probes.skills.ok ? summarizeCodexSkills(probes.skills.value) : formatCodexDisplayText(probes.skills.error)}`);
 	return lines.join("\n");
 }
+/** Formats Codex model-list results for `/codex models`. */
 function formatModels(result) {
 	if (result.models.length === 0) return "No Codex app-server models returned.";
 	const lines = ["Codex models:", ...result.models.map((model) => `- ${formatCodexDisplayText(model.id)}${model.isDefault ? " (default)" : ""}`)];
 	if (result.truncated) lines.push("- More models available; output truncated.");
 	return lines.join("\n");
 }
+/** Formats Codex thread-list responses with safe resume hints. */
 function formatThreads(response) {
 	const threads = extractArray(response);
 	if (threads.length === 0) return "No Codex threads returned.";
@@ -343,6 +357,7 @@ function formatThreads(response) {
 		return `- ${formatCodexDisplayText(id)}${title ? ` - ${formatCodexDisplayText(title)}` : ""}${details.length > 0 ? ` (${details.map(formatCodexDisplayText).join(", ")})` : ""}\n  Resume: ${formatCodexResumeHint(id)}`;
 	})].join("\n");
 }
+/** Formats account and rate-limit output for `/codex account`. */
 function formatAccount(account, limits, authOverview) {
 	if (authOverview) return formatAccountAuthOverview(authOverview);
 	const formattedLimits = limits.ok ? formatCodexRateLimitDetails(limits.value) : formatCodexDisplayText(limits.error);
@@ -367,6 +382,7 @@ function formatAccountAuthOverview(overview) {
 function formatAuthRowStatus(row) {
 	return row.billingNote ? `${row.status} · ${row.billingNote}` : row.status;
 }
+/** Formats Codex Computer Use readiness and plugin/MCP availability. */
 function formatComputerUseStatus(status) {
 	const lines = [`Computer Use: ${status.ready ? "ready" : status.enabled ? "not ready" : "disabled"}`];
 	lines.push(`Plugin: ${formatCodexDisplayText(status.pluginName)} (${computerUsePluginState(status)})`);
@@ -380,6 +396,7 @@ function computerUsePluginState(status) {
 	if (!status.installed) return "not installed";
 	return status.pluginEnabled ? "installed" : "installed, disabled";
 }
+/** Formats generic array-like Codex app-server responses. */
 function formatList(response, label) {
 	const entries = extractArray(response);
 	if (entries.length === 0) return `${label}: none returned.`;
@@ -388,6 +405,7 @@ function formatList(response, label) {
 		return `- ${formatCodexDisplayText(readString$1(record, "name") ?? readString$1(record, "id") ?? JSON.stringify(entry))}`;
 	})].join("\n");
 }
+/** Formats Codex skills grouped by scope, omitting disabled entries. */
 function formatSkills(response) {
 	const groups = isJsonObject(response) && Array.isArray(response.data) ? response.data : [];
 	if (groups.length === 0) return "Codex skills: none returned.";
@@ -420,6 +438,7 @@ function formatCodexResumeHint(threadId) {
 	if (!CODEX_RESUME_SAFE_THREAD_ID_PATTERN.test(safe)) return "copy the thread id above and run /codex resume <thread-id>";
 	return `/codex resume ${safe}`;
 }
+/** Escapes Codex-originated text so it is safe to render in chat command output. */
 function formatCodexDisplayText(value) {
 	return escapeCodexChatText(formatCodexTextForDisplay(value));
 }
@@ -466,6 +485,7 @@ function isLikelyEmailAddress(value) {
 function isUnsafeDisplayCodePoint(codePoint) {
 	return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint === 173 || codePoint === 1564 || codePoint === 6158 || codePoint >= 8203 && codePoint <= 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8288 && codePoint <= 8303 || codePoint === 65279 || codePoint >= 65529 && codePoint <= 65531 || codePoint >= 917504 && codePoint <= 917631;
 }
+/** Builds the portable `/codex` command help text. */
 function buildHelp() {
 	return [
 		"Codex commands:",
@@ -568,22 +588,31 @@ function extractArray(value) {
 	}
 	return [];
 }
+/** Reads and trims a non-empty string field from a JSON object. */
 function readString$1(record, key) {
 	const value = record[key];
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 //#endregion
 //#region extensions/codex/src/app-server/notification-correlation.ts
+/**
+* Correlates Codex app-server notifications with the active thread/turn so
+* projectors can ignore global or stale events without losing diagnostics.
+*/
+/** Returns true when a notification payload belongs to the exact active thread and turn. */
 function isCodexNotificationForTurn(value, threadId, turnId) {
 	if (!isJsonObject(value)) return false;
 	return readCodexNotificationThreadId(value) === threadId && readCodexNotificationTurnId(value) === turnId;
 }
+/** Reads a thread id from either top-level notification params or nested turn payloads. */
 function readCodexNotificationThreadId(record) {
 	return readNestedTurnThreadId(record) ?? readString(record, "threadId");
 }
+/** Reads a turn id from either top-level notification params or nested turn payloads. */
 function readCodexNotificationTurnId(record) {
 	return readNestedTurnId(record) ?? readString(record, "turnId");
 }
+/** Builds structured correlation details for logs when notification routing is ambiguous. */
 function describeCodexNotificationCorrelation(notification, active) {
 	const params = isJsonObject(notification.params) ? notification.params : void 0;
 	const turn = params && isJsonObject(params.turn) ? params.turn : void 0;

package/dist/prompt-overlay.js

@@ -1,10 +1,17 @@
 import { GPT5_BEHAVIOR_CONTRACT, GPT5_HEARTBEAT_PROMPT_OVERLAY, renderGpt5PromptOverlay, resolveGpt5SystemPromptContribution } from "openclaw/plugin-sdk/provider-model-shared";
 //#region extensions/codex/prompt-overlay.ts
+/**
+* Codex prompt-overlay facade for GPT-5 behavior and heartbeat guidance.
+*/
+/** GPT-5 behavior contract re-exported under the Codex provider namespace. */
 const CODEX_GPT5_BEHAVIOR_CONTRACT = GPT5_BEHAVIOR_CONTRACT;
+/** Heartbeat prompt overlay re-exported under the Codex provider namespace. */
 const CODEX_GPT5_HEARTBEAT_PROMPT_OVERLAY = GPT5_HEARTBEAT_PROMPT_OVERLAY;
+/** Resolves the Codex system-prompt contribution for GPT-5-family models. */
 function resolveCodexSystemPromptContribution(params) {
 	return resolveGpt5SystemPromptContribution(params);
 }
+/** Renders the Codex prompt overlay text for supported GPT-5-family models. */
 function renderCodexPromptOverlay(params) {
 	return renderGpt5PromptOverlay(params);
 }

package/dist/{protocol-validators-DIt7cXIp.js → protocol-validators-CIpP8IJ2.js}

@@ -5494,6 +5494,10 @@ var TurnStartResponse_default = {
 };
 //#endregion
 //#region extensions/codex/src/app-server/protocol-validators.ts
+/**
+* Runtime validators for Codex app-server protocol payloads, including schema
+* normalization for generated JSON Schema before TypeBox compilation.
+*/
 function compileCodexSchema(schema) {
 	const validator = Compile(normalizeJsonSchemaNode(schema));
 	return {
@@ -5613,30 +5617,39 @@ const validateThreadResumeResponse = compileCodexSchema(ThreadResumeResponse_def
 const validateThreadStartResponse = compileCodexSchema(ThreadStartResponse_default);
 const validateTurnCompletedNotification = compileCodexSchema(TurnCompletedNotification_default);
 const validateTurnStartResponse = compileCodexSchema(TurnStartResponse_default);
+/** Asserts and normalizes a Codex thread/start response. */
 function assertCodexThreadStartResponse(value) {
 	return assertCodexShape(validateThreadStartResponse, normalizeWithDefaults(ThreadStartResponse_default, normalizeThreadResponse(value)), "thread/start response");
 }
+/** Asserts and normalizes a Codex thread/fork response. */
 function assertCodexThreadForkResponse(value) {
 	return assertCodexShape(validateThreadStartResponse, normalizeWithDefaults(ThreadStartResponse_default, normalizeThreadResponse(value)), "thread/fork response");
 }
+/** Asserts and normalizes a Codex thread/resume response. */
 function assertCodexThreadResumeResponse(value) {
 	return assertCodexShape(validateThreadResumeResponse, normalizeWithDefaults(ThreadResumeResponse_default, normalizeThreadResponse(value)), "thread/resume response");
 }
+/** Asserts and normalizes a Codex turn/start response. */
 function assertCodexTurnStartResponse(value) {
 	return assertCodexShape(validateTurnStartResponse, normalizeWithDefaults(TurnStartResponse_default, normalizeTurnStartResponse(value)), "turn/start response");
 }
+/** Reads Codex dynamic-tool call params, returning undefined for invalid payloads. */
 function readCodexDynamicToolCallParams(value) {
 	return readCodexShape(validateDynamicToolCallParams, normalizeWithDefaults(DynamicToolCallParams_default, value));
 }
+/** Reads a Codex error notification payload if it matches the protocol schema. */
 function readCodexErrorNotification(value) {
 	return readCodexShape(validateErrorNotification, normalizeWithDefaults(ErrorNotification_default, value));
 }
+/** Reads a Codex model/list response if it matches the protocol schema. */
 function readCodexModelListResponse(value) {
 	return readCodexShape(validateModelListResponse, normalizeWithDefaults(ModelListResponse_default, value));
 }
+/** Reads and normalizes a Codex turn object. */
 function readCodexTurn(value) {
 	return readCodexShape(validateTurnStartResponse, normalizeWithDefaults(TurnStartResponse_default, { turn: normalizeTurn(value) }))?.turn;
 }
+/** Reads a Codex turn/completed notification payload if it matches the protocol schema. */
 function readCodexTurnCompletedNotification(value) {
 	return readCodexShape(validateTurnCompletedNotification, normalizeWithDefaults(TurnCompletedNotification_default, normalizeTurnCompletedNotification(value)));
 }

package/dist/provider-catalog.js

@@ -1,9 +1,13 @@
 //#region extensions/codex/provider-catalog.ts
+/** Provider id used by Codex model refs. */
 const CODEX_PROVIDER_ID = "codex";
+/** Synthetic base URL used to route Codex app-server model requests. */
 const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+/** Synthetic auth marker understood by Codex app-server runtime paths. */
 const CODEX_APP_SERVER_AUTH_MARKER = "codex-app-server";
 const DEFAULT_CONTEXT_WINDOW = 272e3;
 const DEFAULT_MAX_TOKENS = 128e3;
+/** Offline fallback catalog used when live app-server discovery is unavailable. */
 const FALLBACK_CODEX_MODELS = [{
 	id: "gpt-5.5",
 	model: "gpt-5.5",
@@ -30,6 +34,9 @@ const FALLBACK_CODEX_MODELS = [{
 		"xhigh"
 	]
 }];
+/**
+* Converts a Codex app-server model record into OpenClaw provider model config.
+*/
 function buildCodexModelDefinition(model) {
 	const id = model.id.trim() || model.model.trim();
 	return {
@@ -52,6 +59,7 @@ function buildCodexModelDefinition(model) {
 		}
 	};
 }
+/** Builds the synthetic Codex provider config for a model list. */
 function buildCodexProviderConfig(models) {
 	return {
 		baseUrl: CODEX_BASE_URL,

package/dist/provider-discovery.js

@@ -10,6 +10,7 @@ async function runCodexCatalog(ctx) {
 		pluginConfig: resolveCodexPluginConfig(ctx)
 	});
 }
+/** Provider discovery descriptor with static fallback and synthetic auth. */
 const codexProviderDiscovery = {
 	id: CODEX_PROVIDER_ID,
 	label: "Codex",

package/dist/provider.js

@@ -5,12 +5,19 @@ import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-run
 import { normalizeModelCompat } from "openclaw/plugin-sdk/provider-model-shared";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/core";
 //#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");
+/**
+* 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,
@@ -72,6 +79,10 @@ function buildCodexProvider(options = {}) {
 		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 });
@@ -123,7 +134,7 @@ async function listModelsBestEffort(params) {
 	}
 }
 async function listCodexAppServerModelsLazy(options) {
-	const { listCodexAppServerModels } = await import("./models-D8i1zWEu.js").then((n) => n.r);
+	const { listCodexAppServerModels } = await import("./models-DXorTaja.js").then((n) => n.r);
 	return listCodexAppServerModels(options);
 }
 function normalizeTimeoutMs(value) {
@@ -142,6 +153,10 @@ function isKnownXHighCodexModel(modelId) {
 	const lower = modelId.trim().toLowerCase();
 	return lower.startsWith("gpt-5") || lower.startsWith("o3") || lower.startsWith("o4") || lower.includes("codex");
 }
+/**
+* Returns true for Codex models that use the modern reasoning effort enum and
+* reject the legacy CLI `minimal` default.
+*/
 function isModernCodexModel(modelId) {
 	const lower = modelId.trim().toLowerCase();
 	return lower === "gpt-5.5" || lower === "gpt-5.4" || lower === "gpt-5.4-mini" || lower === "gpt-5.3-codex-spark";

package/dist/{rate-limit-cache-N66I-Rd7.js → rate-limit-cache-C7qmZ0Jh.js}

@@ -6,12 +6,14 @@ function getCodexRateLimitCacheState() {
 	globalState[CODEX_RATE_LIMIT_CACHE_STATE] ??= {};
 	return globalState[CODEX_RATE_LIMIT_CACHE_STATE];
 }
+/** Stores a non-empty Codex rate-limit payload with its observation time. */
 function rememberCodexRateLimits(value, nowMs = Date.now()) {
 	if (value === void 0) return;
 	const state = getCodexRateLimitCacheState();
 	state.value = value;
 	state.updatedAtMs = nowMs;
 }
+/** Reads the cached Codex rate-limit payload when it is still within the max-age window. */
 function readRecentCodexRateLimits(options) {
 	const state = getCodexRateLimitCacheState();
 	if (state.value === void 0 || state.updatedAtMs === void 0) return;

package/dist/{request-nYrsFNU2.js → request-D64BfplD.js}

@@ -1,9 +1,13 @@
-import { n as CodexAppServerRpcError } from "./client-BFxKzFnH.js";
-import { b as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-BOYYMjx6.js";
-import { a as getLeasedSharedCodexAppServerClient, h as resolveCodexAppServerHomeDir, i as createIsolatedCodexAppServerClient, l as withTimeout, o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-B31-oqN-.js";
-import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-DMCJlzmz.js";
+import { n as CodexAppServerRpcError } from "./client-kMCtlApt.js";
+import { b as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-BJsazZ8j.js";
+import { a as getLeasedSharedCodexAppServerClient, h as resolveCodexAppServerHomeDir, i as createIsolatedCodexAppServerClient, l as withTimeout, o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-xytpSKD0.js";
+import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-C-Yv9uwY.js";
 import { createHash } from "node:crypto";
 //#region extensions/codex/src/app-server/capabilities.ts
+/**
+* Capability helpers for optional Codex app-server control-plane methods.
+*/
+/** Known app-server methods used by OpenClaw control surfaces. */
 const CODEX_CONTROL_METHODS = {
 	account: "account/read",
 	compact: "thread/compact/start",
@@ -15,6 +19,7 @@ const CODEX_CONTROL_METHODS = {
 	resumeThread: "thread/resume",
 	review: "review/start"
 };
+/** Formats unsupported control calls differently from ordinary RPC failures. */
 function describeControlFailure(error) {
 	if (isUnsupportedControlError(error)) return "unsupported by this Codex app-server";
 	return error instanceof Error ? error.message : String(error);
@@ -24,6 +29,11 @@ function isUnsupportedControlError(error) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/plugin-app-cache-key.ts
+/**
+* Builds stable Codex plugin/app inventory cache keys from app-server startup,
+* auth, account, and version inputs without storing secret material.
+*/
+/** Builds the full app inventory cache key for Codex plugin/app discovery. */
 function buildCodexPluginAppCacheKey(params) {
 	return buildCodexAppInventoryCacheKey({
 		codexHome: resolveCodexPluginAppCacheCodexHome(params.appServer, params.agentDir),
@@ -34,6 +44,7 @@ function buildCodexPluginAppCacheKey(params) {
 		appServerVersion: params.appServerVersion
 	});
 }
+/** Serializes app-server endpoint identity, including credential fingerprints. */
 function resolveCodexPluginAppCacheEndpoint(appServer) {
 	return JSON.stringify({
 		transport: appServer.start.transport,
@@ -43,6 +54,7 @@ function resolveCodexPluginAppCacheEndpoint(appServer) {
 		credentialFingerprint: fingerprintCodexPluginAppCacheCredentials(appServer.start)
 	});
 }
+/** Resolves the CODEX_HOME value that scopes local app-server inventory. */
 function resolveCodexPluginAppCacheCodexHome(appServer, agentDir) {
 	const configuredCodexHome = appServer.start.env?.CODEX_HOME?.trim();
 	if (configuredCodexHome) return configuredCodexHome;