@openclaw/codex 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/binding-connection-I5Bo-AsX.js

@@ -0,0 +1,33 @@
+import { T as readCodexPluginConfig, g as resolveCodexAppServerRuntimeOptions, y as resolveCodexSupervisionAppServerRuntimeOptions } from "./session-binding-DPxIvMgE.js";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-C3H2CVp6.js";
+//#region extensions/codex/src/app-server/binding-connection.ts
+/** Requires the native model pair after a supervised pending branch has materialized. */
+function requireCodexSupervisionModelSelection(binding) {
+	const model = binding.model?.trim();
+	const modelProvider = binding.modelProvider?.trim();
+	if (binding.connectionScope !== "supervision" || !model || !modelProvider) throw new Error("Codex supervised binding is missing its native model and provider; refusing request selection");
+	return {
+		model,
+		modelProvider
+	};
+}
+/** Resolves connection and auth ownership exclusively from the private thread binding. */
+function resolveCodexBindingAppServerConnection(params) {
+	const { binding, authProfileId, ...runtimeParams } = params;
+	const usesSupervisionConnection = binding?.connectionScope === "supervision";
+	if (usesSupervisionConnection && readCodexPluginConfig(runtimeParams.pluginConfig).supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
+	const appServer = (usesSupervisionConnection ? resolveCodexSupervisionAppServerRuntimeOptions : resolveCodexAppServerRuntimeOptions)(runtimeParams);
+	if (usesSupervisionConnection) {
+		const persistedFingerprint = binding.pendingSupervisionBranch?.connectionFingerprint ?? binding.appServerRuntimeFingerprint;
+		const currentFingerprint = buildCodexAppServerConnectionFingerprint(appServer, runtimeParams.agentDir);
+		if (!persistedFingerprint || persistedFingerprint !== currentFingerprint) throw new Error("Codex supervision connection changed; refusing to operate on its bound native thread");
+	}
+	return {
+		appServer,
+		usesSupervisionConnection,
+		requestAuthProfileId: usesSupervisionConnection ? void 0 : authProfileId,
+		clientAuthProfileId: usesSupervisionConnection ? null : authProfileId
+	};
+}
+//#endregion
+export { resolveCodexBindingAppServerConnection as n, requireCodexSupervisionModelSelection as t };

package/dist/{bounded-turn-FEbUXoYT.js → bounded-turn-qgZmzy_4.js}

@@ -1,24 +1,22 @@
-import { V as isJsonObject, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-BVKE40c-.js";
-import { p as resolveCodexAppServerRuntimeOptions } from "./session-binding-DlVQ-Pxs.js";
-import { o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-Ia52yRWc.js";
-import { _ as readCodexNotificationItem, h as isRetryableErrorNotification } from "./attempt-notifications-CMR2_fmR.js";
-import { G as mergeCodexThreadConfigs, d as buildCodexRingZeroThreadConfigPatch, f as buildCodexRuntimeThreadConfig, l as assertCodexRingZeroHasNoManagedHooks, p as readCodexInheritedMcpServerNames, u as attestCodexRingZeroThreadHasNoMcpServers } from "./thread-lifecycle-DRg_FdzC.js";
-import { t as normalizeCodexResponseTokenUsage } from "./event-projector-usage-tvgb1NCX.js";
-import { a as assertCodexTurnStartResponse, i as assertCodexThreadStartResponse, s as readCodexErrorNotification, u as readCodexTurnCompletedNotification } from "./protocol-validators-Dm4eXZmt.js";
-import { r as readModelListResult } from "./models-BA01NEez.js";
+import { g as resolveCodexAppServerRuntimeOptions } from "./session-binding-DPxIvMgE.js";
+import { ct as isJsonObject, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-kIBbGjk4.js";
+import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-DMLXUfa8.js";
+import { b as isTerminalTurnStatus, n as normalizeCodexResponseTokenUsage, x as readCodexNotificationItem, y as isRetryableErrorNotification } from "./event-projector-usage-e5huIQWu.js";
+import { a as assertCodexThreadStartResponse, c as readCodexErrorNotification, o as assertCodexTurnStartResponse, u as readCodexTurnCompletedNotification } from "./protocol-validators-B4F7L8Rf.js";
+import { r as readModelListResult } from "./models-BFlpn1Ex.js";
+import { W as mergeCodexThreadConfigs, c as buildCodexRingZeroThreadConfigPatch, l as buildCodexRuntimeThreadConfig, o as assertCodexRestrictedToolSurfaceHasNoManagedHooks, s as attestCodexRestrictedToolSurfaceMcpServersDisabled, u as readCodexInheritedMcpServerNames } from "./thread-lifecycle-Bu1BTDXr.js";
+import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
 //#region extensions/codex/src/app-server/bounded-turn.ts
-const CODEX_PRIVATE_STDIO_ARGS = [
-	"app-server",
-	"--listen",
-	"stdio://"
-];
 const CODEX_APP_SERVER_ARGS_ENV_KEY = "OPENCLAW_CODEX_APP_SERVER_ARGS";
 const CODEX_BOUNDED_THREAD_CONFIG = {
+	"agents.enabled": false,
 	"features.multi_agent": false,
+	"features.multi_agent_v2": false,
 	"features.apps": false,
 	"features.plugins": false,
 	"features.image_generation": false,
@@ -33,6 +31,13 @@ const CODEX_SETTLED_FINALIZER_THREAD_CONFIG = {
 	"skills.include_instructions": false,
 	include_environment_context: false
 };
+var CodexBoundedTurnTimeoutError = class extends Error {
+	constructor(taskLabel, timeoutMs) {
+		const bound = timeoutMs % 1e3 === 0 ? `${timeoutMs / 1e3}s` : `${timeoutMs}ms`;
+		super(`codex app-server ${taskLabel} turn timed out after ${bound}`);
+		this.name = "TimeoutError";
+	}
+};
 async function runBoundedCodexAppServerTurn(params) {
 	const appServer = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.options.pluginConfig,
@@ -55,23 +60,31 @@ async function runBoundedCodexAppServerTurn(params) {
 }
 async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt = 0, timing) {
 	const totalTimeoutMs = timing?.timeoutMs ?? resolveTimerTimeoutMs(params.timeoutMs, 100, 100);
+	const timeoutError = new CodexBoundedTurnTimeoutError(params.taskLabel, totalTimeoutMs);
 	const deadline = timing?.deadline ?? Date.now() + totalTimeoutMs;
 	const timeoutMs = deadline - Date.now();
-	if (timeoutMs <= 0) throw new Error(`${params.taskLabel} timed out`);
+	if (timeoutMs <= 0) throw timeoutError;
 	const agentDir = params.agentDir?.trim() || void 0;
-	const startOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
+	const isolatedStartOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
+	const startOptions = workspace.codexHome && params.preparedAuth ? {
+		...isolatedStartOptions,
+		homeScope: "agent"
+	} : isolatedStartOptions;
 	const ownsClient = !params.options.clientFactory;
+	const authSelection = params.preparedAuth ? { preparedAuth: params.preparedAuth } : { authProfileId: params.profile };
 	const client = params.options.clientFactory ? await params.options.clientFactory({
 		startOptions,
-		authProfileId: params.profile,
+		...authSelection,
+		authRequirement: params.authRequirement,
 		agentDir,
 		config: params.config,
 		timeoutMs,
 		...params.signal ? { abandonSignal: params.signal } : {}
-	}) : await import("./shared-client-BVKE40c-.js").then((n) => n.p).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+	}) : await import("./shared-client-kIBbGjk4.js").then((n) => n.m).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		startOptions,
 		timeoutMs,
-		authProfileId: params.profile,
+		...authSelection,
+		authRequirement: params.authRequirement,
 		agentDir,
 		authProfileStore: params.authProfileStore,
 		config: params.config,
@@ -97,8 +110,8 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	if (params.signal?.aborted) abortFromCaller();
 	else params.signal?.addEventListener("abort", abortFromCaller, { once: true });
 	const remainingRunMs = deadline - Date.now();
-	if (remainingRunMs <= 0) abortRun("timeout");
-	const timeout = setTimeout(() => abortRun("timeout"), Math.max(1, remainingRunMs));
+	if (remainingRunMs <= 0) abortRun(timeoutError);
+	const timeout = setTimeout(() => abortRun(timeoutError), Math.max(1, remainingRunMs));
 	timeout.unref?.();
 	let retrySelection = false;
 	try {
@@ -110,17 +123,18 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			signal: abortController.signal
 		});
 		const inheritedMcpServerNames = params.requireNoExternalCapabilities ? await readCodexInheritedMcpServerNames(client, workspace.cwd, abortController.signal) : [];
-		if (params.requireNoExternalCapabilities) await assertCodexRingZeroHasNoManagedHooks(client, abortController.signal);
+		if (params.requireNoExternalCapabilities) await assertCodexRestrictedToolSurfaceHasNoManagedHooks(client, abortController.signal);
+		const threadConfig = buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames), { nativeCodeModeEnabled: false });
 		const thread = assertCodexThreadStartResponse(await client.request("thread/start", {
 			model,
-			modelProvider: "openai",
+			...params.modelProvider ? { modelProvider: params.modelProvider } : {},
 			cwd: workspace.cwd,
 			approvalPolicy: "on-request",
 			sandbox: "read-only",
 			serviceName: "OpenClaw",
 			...params.requireNoExternalCapabilities ? { baseInstructions: "" } : {},
 			developerInstructions: params.developerInstructions,
-			config: buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames), { nativeCodeModeEnabled: false }),
+			config: threadConfig,
 			environments: [],
 			dynamicTools: [],
 			experimentalRawEvents: true,
@@ -131,7 +145,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		}));
 		activeThreadId = thread.thread.id;
 		if (abortController.signal.aborted) requestInterrupt();
-		if (params.requireNoExternalCapabilities) await attestCodexRingZeroThreadHasNoMcpServers(client, thread.thread.id, abortController.signal);
+		if (params.requireNoExternalCapabilities) await attestCodexRestrictedToolSurfaceMcpServersDisabled(client, thread.thread.id, threadConfig, abortController.signal);
 		if (params.historyItems?.length) await client.request("thread/inject_items", {
 			threadId: thread.thread.id,
 			items: params.historyItems
@@ -139,14 +153,13 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			timeoutMs,
 			signal: abortController.signal
 		});
-		const collector = createCodexBoundedTurnCollector(thread.thread.id, params.taskLabel);
+		const collector = createCodexBoundedTurnCollector(thread.thread.id, params.taskLabel, params.allowEmptyText === true);
 		const cleanup = client.addNotificationHandler(collector.handleNotification);
 		const requestCleanup = client.addRequestHandler(createCodexBoundedApprovalHandler(params.taskLabel));
 		try {
 			const turn = assertCodexTurnStartResponse(await client.request("turn/start", {
 				threadId: thread.thread.id,
 				input: params.input,
-				cwd: workspace.cwd,
 				approvalPolicy: "on-request",
 				model,
 				effort: "low"
@@ -158,23 +171,25 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			if (abortController.signal.aborted) requestInterrupt();
 			return {
 				...await collector.collect(turn.turn, {
-					timeoutMs,
-					signal: abortController.signal
+					signal: abortController.signal,
+					timeoutError
 				}),
 				model
 			};
 		} finally {
+			await interruptPromise;
 			requestCleanup();
 			cleanup();
 		}
 	} catch (error) {
+		if (abortController.signal.aborted) throw resolveCodexBoundedTurnAbortError(abortController.signal, params.taskLabel, timeoutError);
 		if (ownsClient && isCodexAppServerStartSelectionChangedError(error) && selectionAttempt === 0) retrySelection = true;
 		else throw error;
 	} finally {
 		clearTimeout(timeout);
 		params.signal?.removeEventListener("abort", abortFromCaller);
 		await interruptPromise;
-		if (ownsClient) client.close();
+		if (ownsClient) await closeCodexStartupClientBestEffort(client);
 	}
 	if (retrySelection) return await runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt + 1, {
 		deadline,
@@ -189,6 +204,10 @@ function resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames)
 	return mergeCodexThreadConfigs(privateConfig, CODEX_SETTLED_FINALIZER_THREAD_CONFIG, buildCodexRingZeroThreadConfigPatch({ toolsAllow: ["openclaw"] }, true, inheritedMcpServerNames)) ?? privateConfig;
 }
 function buildPrivateCodexAppServerStartOptions(start, codexHome) {
+	const providerArgs = start.args.flatMap((arg, index) => {
+		const override = arg === "-c" || arg === "--config" ? start.args[index + 1] : arg.startsWith("--config=") ? arg.slice(9) : void 0;
+		return override && /^\s*(?:openai_base_url|model_catalog_json)\s*=/u.test(override) ? ["-c", override] : [];
+	});
 	const privateEnv = Object.fromEntries(Object.entries(start.env ?? {}).filter(([name]) => name.trim().toUpperCase() !== CODEX_APP_SERVER_ARGS_ENV_KEY));
 	const clearEnv = (start.clearEnv ?? []).filter((name) => {
 		const normalized = name.trim().toUpperCase();
@@ -196,7 +215,12 @@ function buildPrivateCodexAppServerStartOptions(start, codexHome) {
 	});
 	return {
 		...start,
-		args: [...CODEX_PRIVATE_STDIO_ARGS],
+		args: [
+			"app-server",
+			...providerArgs,
+			"--listen",
+			"stdio://"
+		],
 		env: {
 			...privateEnv,
 			CODEX_HOME: codexHome
@@ -243,7 +267,7 @@ async function resolveCodexBoundedTurnModel(params) {
 	if (params.requiredModalities.includes("text") && !match.inputModalities.includes("text")) throw new Error(`Codex app-server model does not support text: ${model}`);
 	return model;
 }
-function createCodexBoundedTurnCollector(threadId, taskLabel) {
+function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
 	let turnId;
 	let completedTurn;
 	let promptError;
@@ -252,10 +276,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 	const completedItems = /* @__PURE__ */ new Map();
 	const assistantTextByItem = /* @__PURE__ */ new Map();
 	const assistantItemOrder = [];
-	let resolveCompletion;
-	const completion = new Promise((resolve) => {
-		resolveCompletion = resolve;
-	});
+	const { promise: completion, resolve: resolveCompletion } = createDeferred();
 	const rememberAssistantText = (itemId, text) => {
 		if (!text) return;
 		if (!assistantTextByItem.has(itemId)) assistantItemOrder.push(itemId);
@@ -263,12 +284,12 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 	};
 	const handleNotification = (notification) => {
 		const params = isJsonObject(notification.params) ? notification.params : void 0;
-		if (!params || readString(params, "threadId") !== threadId) return;
+		if (!params || readStringField(params, "threadId") !== threadId) return;
 		if (!turnId) {
 			pending.push(notification);
 			return;
 		}
-		if (readNotificationTurnId(params) !== turnId) return;
+		if (readCodexNotificationTurnId(params) !== turnId) return;
 		if (notification.method === "item/completed") {
 			const item = readCodexNotificationItem(notification.params);
 			if (item) {
@@ -278,8 +299,8 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 			return;
 		}
 		if (notification.method === "item/agentMessage/delta") {
-			const itemId = readString(params, "itemId") ?? readString(params, "id") ?? "assistant";
-			const delta = readString(params, "delta") ?? "";
+			const itemId = readStringField(params, "itemId") ?? readStringField(params, "id") ?? "assistant";
+			const delta = readStringField(params, "delta") ?? "";
 			rememberAssistantText(itemId, `${assistantTextByItem.get(itemId) ?? ""}${delta}`);
 			return;
 		}
@@ -290,26 +311,26 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 		}
 		if (notification.method === "turn/completed") {
 			completedTurn = readCodexTurnCompletedNotification(notification.params)?.turn ?? completedTurn;
-			resolveCompletion?.();
+			resolveCompletion();
 			return;
 		}
 		if (notification.method === "error") {
 			if (isRetryableErrorNotification(notification.params)) return;
 			promptError = readCodexErrorNotification(notification.params)?.error.message ?? `codex app-server ${taskLabel} turn failed`;
-			resolveCompletion?.();
+			resolveCompletion();
 		}
 	};
 	return {
 		handleNotification,
 		async collect(startedTurn, options) {
 			turnId = startedTurn.id;
-			if (isTerminalTurn(startedTurn)) completedTurn = startedTurn;
+			if (isTerminalTurnStatus(startedTurn.status)) completedTurn = startedTurn;
 			for (const notification of pending.splice(0)) handleNotification(notification);
 			if (!completedTurn && !promptError) await waitForTurnCompletion({
 				completion,
-				timeoutMs: options.timeoutMs,
 				signal: options.signal,
-				taskLabel
+				taskLabel,
+				timeoutError: options.timeoutError
 			});
 			if (promptError) throw new Error(promptError);
 			if (completedTurn?.status === "failed") throw new Error(completedTurn.error?.message ?? `codex app-server ${taskLabel} turn failed`);
@@ -318,7 +339,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 			const itemText = collectAssistantTextFromItems(items);
 			const deltaText = assistantItemOrder.map((itemId) => assistantTextByItem.get(itemId)?.trim()).filter((text) => Boolean(text)).join("\n\n").trim();
 			const text = (itemText || deltaText).trim();
-			if (!text) throw new Error(`Codex app-server ${taskLabel} turn returned no text.`);
+			if (!text && !allowEmptyText) throw new Error(`Codex app-server ${taskLabel} turn returned no text.`);
 			return {
 				text,
 				items,
@@ -333,36 +354,23 @@ function collectCompletedItems(turnItems, notificationItems) {
 	return [...items.values()];
 }
 async function waitForTurnCompletion(params) {
-	if (params.signal.aborted) throw new Error(`codex app-server ${params.taskLabel} turn aborted`);
-	let timeout;
+	if (params.signal.aborted) throw resolveCodexBoundedTurnAbortError(params.signal, params.taskLabel, params.timeoutError);
 	let cleanupAbort;
 	try {
 		await Promise.race([params.completion, new Promise((_, reject) => {
-			timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`codex app-server ${params.taskLabel} turn timed out`)), params.timeoutMs);
-			timeout.unref?.();
-			const abortListener = () => reject(/* @__PURE__ */ new Error(`codex app-server ${params.taskLabel} turn aborted`));
+			const abortListener = () => reject(resolveCodexBoundedTurnAbortError(params.signal, params.taskLabel, params.timeoutError));
 			params.signal.addEventListener("abort", abortListener, { once: true });
 			cleanupAbort = () => params.signal.removeEventListener("abort", abortListener);
 		})]);
 	} finally {
-		if (timeout) clearTimeout(timeout);
 		cleanupAbort?.();
 	}
 }
+function resolveCodexBoundedTurnAbortError(signal, taskLabel, timeoutError) {
+	return signal.reason === timeoutError ? timeoutError : /* @__PURE__ */ new Error(`codex app-server ${taskLabel} turn aborted`);
+}
 function collectAssistantTextFromItems(items) {
 	return (items ?? []).filter((item) => item.type === "agentMessage").map((item) => item.text.trim()).filter(Boolean).join("\n\n").trim();
 }
-function readNotificationTurnId(record) {
-	const direct = readString(record, "turnId");
-	if (direct) return direct;
-	return isJsonObject(record.turn) ? readString(record.turn, "id") : void 0;
-}
-function readString(record, key) {
-	const value = record[key];
-	return typeof value === "string" ? value : void 0;
-}
-function isTerminalTurn(turn) {
-	return turn.status === "completed" || turn.status === "interrupted" || turn.status === "failed";
-}
 //#endregion
 export { runBoundedCodexAppServerTurn as t };

package/dist/{capabilities-BHRSI6Cn.js → capabilities-CybGI1oz.js}

@@ -1,4 +1,4 @@
-import { _ as CodexAppServerRpcError } from "./shared-client-BVKE40c-.js";
+import { z as CodexAppServerRpcError } from "./shared-client-kIBbGjk4.js";
 //#region extensions/codex/src/app-server/capabilities.ts
 /**
 * Capability helpers for optional Codex app-server control-plane methods.
@@ -6,10 +6,14 @@ import { _ as CodexAppServerRpcError } from "./shared-client-BVKE40c-.js";
 /** Known app-server methods used by OpenClaw control surfaces. */
 const CODEX_CONTROL_METHODS = {
 	account: "account/read",
-	compact: "thread/compact/start",
+	installedApps: "app/installed",
+	listApps: "app/list",
+	readApps: "app/read",
 	feedback: "feedback/upload",
 	forkThread: "thread/fork",
+	listHooks: "hooks/list",
 	listMcpServers: "mcpServerStatus/list",
+	listPlugins: "plugin/list",
 	listSkills: "skills/list",
 	listThreads: "thread/list",
 	listThreadTurns: "thread/turns/list",
@@ -19,6 +23,8 @@ const CODEX_CONTROL_METHODS = {
 	renameThread: "thread/name/set",
 	resumeThread: "thread/resume",
 	review: "review/start",
+	installPlugin: "plugin/install",
+	reloadMcpServers: "config/mcpServer/reload",
 	unarchiveThread: "thread/unarchive",
 	getThreadGoal: "thread/goal/get",
 	setThreadGoal: "thread/goal/set",

package/dist/cli-metadata.js

@@ -2,7 +2,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/codex/cli-metadata.ts
 function registerCodexCliMetadata(api) {
 	api.registerCli(async ({ program }) => {
-		const { registerCodexSessionCli } = await import("./session-cli-CqZ0Fp2a.js");
+		const { registerCodexSessionCli } = await import("./session-cli-7hgXZDV7.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

package/dist/{command-formatters-ico4ZFnk.js → command-formatters-B1AEz8ZA.js}

@@ -1,6 +1,11 @@
-import { V as isJsonObject } from "./shared-client-BVKE40c-.js";
-import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-S_PXs0ul.js";
+import { ct as isJsonObject } from "./shared-client-kIBbGjk4.js";
+import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-DZXmOL8-.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/command-formatters.ts
+/**
+* Formats Codex command responses for safe chat display, including status,
+* lists, account summaries, and user-facing help text.
+*/
 /** 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"}`];
@@ -25,12 +30,12 @@ function formatThreads(response) {
 	if (threads.length === 0) return "No Codex threads returned.";
 	return ["Codex threads:", ...threads.slice(0, 10).map((thread) => {
 		const record = isJsonObject(thread) ? thread : {};
-		const id = readString(record, "threadId") ?? readString(record, "id") ?? "<unknown>";
-		const title = readString(record, "title") ?? readString(record, "name") ?? readString(record, "summary");
+		const id = normalizeOptionalString(record.threadId) ?? normalizeOptionalString(record.id) ?? "<unknown>";
+		const title = normalizeOptionalString(record.title) ?? normalizeOptionalString(record.name) ?? normalizeOptionalString(record.summary);
 		const details = [
-			readString(record, "model"),
-			readString(record, "cwd"),
-			readString(record, "updatedAt") ?? readString(record, "lastUpdatedAt")
+			normalizeOptionalString(record.model),
+			normalizeOptionalString(record.cwd),
+			normalizeOptionalString(record.updatedAt) ?? normalizeOptionalString(record.lastUpdatedAt)
 		].filter((value) => Boolean(value));
 		return `- ${formatCodexDisplayText(id)}${title ? ` - ${formatCodexDisplayText(title)}` : ""}${details.length > 0 ? ` (${details.map(formatCodexDisplayText).join(", ")})` : ""}\n  Resume: ${formatCodexResumeHint(id)}`;
 	})].join("\n");
@@ -85,7 +90,7 @@ function formatList(response, label) {
 	if (entries.length === 0) return `${label}: none returned.`;
 	return [`${label}:`, ...entries.slice(0, 25).map((entry) => {
 		const record = isJsonObject(entry) ? entry : {};
-		return `- ${formatCodexDisplayText(readString(record, "name") ?? readString(record, "id") ?? JSON.stringify(entry))}`;
+		return `- ${formatCodexDisplayText(normalizeOptionalString(record.name) ?? normalizeOptionalString(record.id) ?? JSON.stringify(entry))}`;
 	})].join("\n");
 }
 /** Formats Codex skills grouped by scope, omitting disabled entries. */
@@ -113,7 +118,7 @@ function formatSkills(response) {
 	return lines.join("\n");
 }
 function formatCodexSkillEntry(entry) {
-	return `\`${formatCodexDisplayText(readString(isJsonObject(entry) ? entry : {}, "name") ?? "<unknown>")}\``;
+	return `\`${formatCodexDisplayText(normalizeOptionalString((isJsonObject(entry) ? entry : {}).name) ?? "<unknown>")}\``;
 }
 const CODEX_RESUME_SAFE_THREAD_ID_PATTERN = /^[A-Za-z0-9._:-]+$/;
 function formatCodexResumeHint(threadId) {
@@ -200,8 +205,8 @@ function buildHelp() {
 function summarizeAccount(value) {
 	if (!isJsonObject(value)) return "unavailable";
 	const account = isJsonObject(value.account) ? value.account : value;
-	if (readString(account, "type") === "amazonBedrock") return "Amazon Bedrock";
-	return readString(account, "email") ?? readString(account, "accountEmail") ?? readString(account, "planType") ?? readString(account, "id") ?? "available";
+	if (normalizeOptionalString(account.type) === "amazonBedrock") return "Amazon Bedrock";
+	return normalizeOptionalString(account.email) ?? normalizeOptionalString(account.accountEmail) ?? normalizeOptionalString(account.planType) ?? normalizeOptionalString(account.id) ?? "available";
 }
 function summarizeArrayLike(value) {
 	const entries = extractArray(value);
@@ -249,7 +254,7 @@ function summarizeRateLimits(value) {
 }
 function isMeaningfulRateLimitSnapshot(value) {
 	if (!isJsonObject(value)) return false;
-	if (readString(value, "rateLimitReachedType") ?? readString(value, "rate_limit_reached_type")) return true;
+	if (normalizeOptionalString(value.rateLimitReachedType) ?? normalizeOptionalString(value.rate_limit_reached_type)) return true;
 	return ["primary", "secondary"].some((key) => {
 		const window = value[key];
 		return isJsonObject(window) && Object.values(window).some((entry) => entry != null);
@@ -272,10 +277,5 @@ function extractArray(value) {
 	}
 	return [];
 }
-/** Reads and trims a non-empty string field from a JSON object. */
-function readString(record, key) {
-	const value = record[key];
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
 //#endregion
-export { formatComputerUseStatus as a, formatSkills as c, formatCodexStatus as i, formatThreads as l, formatAccount as n, formatList as o, formatCodexDisplayText as r, formatModels as s, buildHelp as t, readString as u };
+export { formatComputerUseStatus as a, formatSkills as c, formatCodexStatus as i, formatThreads as l, formatAccount as n, formatList as o, formatCodexDisplayText as r, formatModels as s, buildHelp as t };