@openclaw/codex 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/{app-server-policy-DUMF2Xyr.js → app-server-policy-BmDgseo_.js}

@@ -1,4 +1,4 @@
-import { p as canUseCodexModelBackedApprovalsReviewerForModel } from "./session-binding-Bmt20HfB.js";
+import { b as canUseCodexModelBackedApprovalsReviewerForModel } from "./session-binding-DlVQ-Pxs.js";
 //#region extensions/codex/src/app-server/app-server-policy.ts
 /**
 * Policy promotion for Codex app-server runs that can safely use OpenClaw tool

package/dist/attempt-client-cleanup-Ia52yRWc.js

@@ -0,0 +1,127 @@
+import { f as retireSharedCodexAppServerClientIfCurrent, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, t as clearSharedCodexAppServerClientIfCurrent } from "./shared-client-BVKE40c-.js";
+import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/attempt-client-cleanup.ts
+/**
+* Best-effort cleanup helpers for Codex app-server startup attempts and turns.
+*/
+/** Timeout for best-effort app-server turn interruption during cleanup. */
+const CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS = 5e3;
+/** Timeout for best-effort thread unsubscribe during cleanup. */
+const CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS = 5e3;
+/** Raised when a thread subscription may be live on a client OpenClaw no longer controls. */
+var CodexAppServerUnsafeSubscriptionError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "CodexAppServerUnsafeSubscriptionError";
+	}
+};
+function isCodexAppServerUnsafeSubscriptionError(error) {
+	return error instanceof CodexAppServerUnsafeSubscriptionError;
+}
+/** Asserts Codex resumed the exact thread this attempt subscribed to. */
+function assertCodexThreadResumeSubscription(requestedThreadId, returnedThreadId) {
+	if (returnedThreadId !== requestedThreadId) throw new CodexAppServerUnsafeSubscriptionError(`Codex thread/resume returned ${returnedThreadId} for ${requestedThreadId}`);
+}
+async function closeClientAndWaitIfAvailable(client) {
+	const closeable = client;
+	if (typeof closeable.closeAndWait === "function") {
+		await closeable.closeAndWait();
+		return;
+	}
+	closeable.close?.();
+}
+async function closeCodexStartupClientBestEffort(client) {
+	if (!client) return;
+	const unclaimedSharedClient = clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client);
+	if (unclaimedSharedClient.closed) {
+		await closeClientAndWaitIfAvailable(client);
+		return;
+	}
+	if (unclaimedSharedClient.found) {
+		if (retireSharedCodexAppServerClientIfCurrent(client)?.closed) await closeClientAndWaitIfAvailable(client);
+		return;
+	}
+	const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client);
+	if (retiredSharedClient) {
+		if (retiredSharedClient.closed) await closeClientAndWaitIfAvailable(client);
+		return;
+	}
+	if (clearSharedCodexAppServerClientIfCurrent(client)) {
+		await closeClientAndWaitIfAvailable(client);
+		return;
+	}
+	await closeClientAndWaitIfAvailable(client);
+}
+/** Sends a turn interrupt without blocking abort cleanup on app-server errors. */
+function interruptCodexTurnBestEffort(client, params) {
+	interruptCodexTurnAndWaitBestEffort(client, params);
+}
+/** Sends a bounded turn interrupt and waits for Codex to confirm terminal abort handling. */
+async function interruptCodexTurnAndWaitBestEffort(client, params) {
+	const requestOptions = params.timeoutMs && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? { timeoutMs: params.timeoutMs } : void 0;
+	const requestParams = {
+		threadId: params.threadId,
+		turnId: params.turnId
+	};
+	try {
+		await (requestOptions ? client.request("turn/interrupt", requestParams, requestOptions) : client.request("turn/interrupt", requestParams));
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server turn interrupt failed during abort", { error });
+	}
+}
+/** Unsubscribes from a thread while swallowing cleanup-only failures. */
+async function unsubscribeCodexThreadBestEffort(client, params) {
+	try {
+		await client.request("thread/unsubscribe", { threadId: params.threadId }, { timeoutMs: params.timeoutMs });
+		return true;
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server thread unsubscribe cleanup failed", {
+			threadId: params.threadId,
+			error
+		});
+		return false;
+	}
+}
+/**
+* Retires the shared client after a timed-out turn so later runs do not reuse a
+* potentially wedged app-server connection.
+*/
+async function retireCodexAppServerClientAfterTimedOutTurn(client, params) {
+	const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client, { failActiveLeases: params.suspectPhysicalClient });
+	const detachedSharedClient = Boolean(retiredSharedClient);
+	if (!(params.suspectPhysicalClient && (retiredSharedClient?.closed ?? false))) {
+		interruptCodexTurnBestEffort(client, {
+			threadId: params.threadId,
+			turnId: params.turnId,
+			timeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS
+		});
+		await unsubscribeCodexThreadBestEffort(client, {
+			threadId: params.threadId,
+			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
+		});
+	}
+	let closedClient = retiredSharedClient?.closed ?? false;
+	if (!detachedSharedClient) {
+		const close = client.close;
+		if (typeof close === "function") try {
+			close.call(client);
+			closedClient = true;
+		} catch (error) {
+			embeddedAgentLog.debug("codex app-server client close failed during timeout cleanup", {
+				threadId: params.threadId,
+				turnId: params.turnId,
+				error
+			});
+		}
+	}
+	embeddedAgentLog.warn("codex app-server client retired after timed-out turn", {
+		threadId: params.threadId,
+		turnId: params.turnId,
+		reason: params.reason,
+		detachedSharedClient,
+		closedClient,
+		activeSharedClientLeases: retiredSharedClient?.activeLeases ?? 0
+	});
+}
+//#endregion
+export { closeCodexStartupClientBestEffort as a, isCodexAppServerUnsafeSubscriptionError as c, assertCodexThreadResumeSubscription as i, retireCodexAppServerClientAfterTimedOutTurn as l, CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS as n, interruptCodexTurnAndWaitBestEffort as o, CodexAppServerUnsafeSubscriptionError as r, interruptCodexTurnBestEffort as s, CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS as t, unsubscribeCodexThreadBestEffort as u };

package/dist/{attempt-notifications-Ecjyzufe.js → attempt-notifications-CMR2_fmR.js}

@@ -1,4 +1,4 @@
-import { Z as isJsonObject } from "./shared-client-CSXLtCLE.js";
+import { V as isJsonObject } from "./shared-client-BVKE40c-.js";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/codex/src/app-server/attempt-notifications.ts
 /**

package/dist/{media-understanding-provider-IPNNQre6.js → bounded-turn-FEbUXoYT.js}

@@ -1,10 +1,11 @@
-import { Z as isJsonObject, o as isCodexAppServerStartSelectionChangedError } from "./shared-client-CSXLtCLE.js";
-import { _ as readCodexNotificationItem } from "./attempt-notifications-Ecjyzufe.js";
-import { b as resolveCodexAppServerRuntimeOptions } from "./session-binding-Bmt20HfB.js";
-import { _ as readCodexTurnCompletedNotification, d as assertCodexThreadStartResponse, f as assertCodexTurnStartResponse, m as readCodexErrorNotification } from "./transcript-mirror-D9rTxx2P.js";
-import { r as readModelListResult } from "./models-DD5zBdX5.js";
-import { J as mergeCodexThreadConfigs, l as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-CQ_9mAa1.js";
-import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
+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 fs from "node:fs/promises";
 import path from "node:path";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
@@ -15,7 +16,7 @@ const CODEX_PRIVATE_STDIO_ARGS = [
 	"--listen",
 	"stdio://"
 ];
-const OPENCLAW_CODEX_APP_SERVER_ARGS_ENV_VAR = "OPENCLAW_CODEX_APP_SERVER_ARGS";
+const CODEX_APP_SERVER_ARGS_ENV_KEY = "OPENCLAW_CODEX_APP_SERVER_ARGS";
 const CODEX_BOUNDED_THREAD_CONFIG = {
 	"features.multi_agent": false,
 	"features.apps": false,
@@ -28,6 +29,10 @@ const CODEX_PRIVATE_BOUNDED_THREAD_CONFIG = {
 	"features.hooks": false,
 	notify: []
 };
+const CODEX_SETTLED_FINALIZER_THREAD_CONFIG = {
+	"skills.include_instructions": false,
+	include_environment_context: false
+};
 async function runBoundedCodexAppServerTurn(params) {
 	const appServer = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.options.pluginConfig,
@@ -61,22 +66,39 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		authProfileId: params.profile,
 		agentDir,
 		config: params.config,
-		timeoutMs
-	}) : await import("./shared-client-CSXLtCLE.js").then((n) => n.f).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+		timeoutMs,
+		...params.signal ? { abandonSignal: params.signal } : {}
+	}) : await import("./shared-client-BVKE40c-.js").then((n) => n.p).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		startOptions,
 		timeoutMs,
 		authProfileId: params.profile,
 		agentDir,
 		authProfileStore: params.authProfileStore,
-		config: params.config
+		config: params.config,
+		...params.signal ? { abandonSignal: params.signal } : {}
 	}));
 	const abortController = new AbortController();
-	const abortFromCaller = () => abortController.abort(params.signal?.reason ?? "aborted");
+	let activeThreadId;
+	let activeTurnId = "";
+	let interruptPromise;
+	const requestInterrupt = () => {
+		if (!activeThreadId || interruptPromise) return;
+		interruptPromise = interruptCodexTurnAndWaitBestEffort(client, {
+			threadId: activeThreadId,
+			turnId: activeTurnId,
+			timeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS
+		});
+	};
+	const abortRun = (reason) => {
+		abortController.abort(reason);
+		requestInterrupt();
+	};
+	const abortFromCaller = () => abortRun(params.signal?.reason ?? "aborted");
 	if (params.signal?.aborted) abortFromCaller();
 	else params.signal?.addEventListener("abort", abortFromCaller, { once: true });
 	const remainingRunMs = deadline - Date.now();
-	if (remainingRunMs <= 0) abortController.abort("timeout");
-	const timeout = setTimeout(() => abortController.abort("timeout"), Math.max(1, remainingRunMs));
+	if (remainingRunMs <= 0) abortRun("timeout");
+	const timeout = setTimeout(() => abortRun("timeout"), Math.max(1, remainingRunMs));
 	timeout.unref?.();
 	let retrySelection = false;
 	try {
@@ -87,6 +109,8 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			timeoutMs,
 			signal: abortController.signal
 		});
+		const inheritedMcpServerNames = params.requireNoExternalCapabilities ? await readCodexInheritedMcpServerNames(client, workspace.cwd, abortController.signal) : [];
+		if (params.requireNoExternalCapabilities) await assertCodexRingZeroHasNoManagedHooks(client, abortController.signal);
 		const thread = assertCodexThreadStartResponse(await client.request("thread/start", {
 			model,
 			modelProvider: "openai",
@@ -94,8 +118,9 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			approvalPolicy: "on-request",
 			sandbox: "read-only",
 			serviceName: "OpenClaw",
+			...params.requireNoExternalCapabilities ? { baseInstructions: "" } : {},
 			developerInstructions: params.developerInstructions,
-			config: buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace), { nativeCodeModeEnabled: false }),
+			config: buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames), { nativeCodeModeEnabled: false }),
 			environments: [],
 			dynamicTools: [],
 			experimentalRawEvents: true,
@@ -104,6 +129,16 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			timeoutMs,
 			signal: abortController.signal
 		}));
+		activeThreadId = thread.thread.id;
+		if (abortController.signal.aborted) requestInterrupt();
+		if (params.requireNoExternalCapabilities) await attestCodexRingZeroThreadHasNoMcpServers(client, thread.thread.id, abortController.signal);
+		if (params.historyItems?.length) await client.request("thread/inject_items", {
+			threadId: thread.thread.id,
+			items: params.historyItems
+		}, {
+			timeoutMs,
+			signal: abortController.signal
+		});
 		const collector = createCodexBoundedTurnCollector(thread.thread.id, params.taskLabel);
 		const cleanup = client.addNotificationHandler(collector.handleNotification);
 		const requestCleanup = client.addRequestHandler(createCodexBoundedApprovalHandler(params.taskLabel));
@@ -119,6 +154,8 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 				timeoutMs,
 				signal: abortController.signal
 			}));
+			activeTurnId = turn.turn.id;
+			if (abortController.signal.aborted) requestInterrupt();
 			return {
 				...await collector.collect(turn.turn, {
 					timeoutMs,
@@ -136,6 +173,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	} finally {
 		clearTimeout(timeout);
 		params.signal?.removeEventListener("abort", abortFromCaller);
+		await interruptPromise;
 		if (ownsClient) client.close();
 	}
 	if (retrySelection) return await runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt + 1, {
@@ -144,15 +182,17 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	});
 	throw new Error("Codex bounded turn selection retry exited unexpectedly");
 }
-function resolveBoundedThreadConfig(params, workspace) {
+function resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames) {
 	const boundedConfig = mergeCodexThreadConfigs(CODEX_BOUNDED_THREAD_CONFIG, params.threadConfig) ?? CODEX_BOUNDED_THREAD_CONFIG;
-	return workspace.codexHome ? mergeCodexThreadConfigs(boundedConfig, CODEX_PRIVATE_BOUNDED_THREAD_CONFIG) ?? boundedConfig : boundedConfig;
+	const privateConfig = workspace.codexHome ? mergeCodexThreadConfigs(boundedConfig, CODEX_PRIVATE_BOUNDED_THREAD_CONFIG) ?? boundedConfig : boundedConfig;
+	if (!params.requireNoExternalCapabilities) return privateConfig;
+	return mergeCodexThreadConfigs(privateConfig, CODEX_SETTLED_FINALIZER_THREAD_CONFIG, buildCodexRingZeroThreadConfigPatch({ toolsAllow: ["openclaw"] }, true, inheritedMcpServerNames)) ?? privateConfig;
 }
 function buildPrivateCodexAppServerStartOptions(start, codexHome) {
-	const privateEnv = Object.fromEntries(Object.entries(start.env ?? {}).filter(([name]) => name.trim().toUpperCase() !== OPENCLAW_CODEX_APP_SERVER_ARGS_ENV_VAR));
+	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();
-		return normalized !== "CODEX_HOME" && normalized !== OPENCLAW_CODEX_APP_SERVER_ARGS_ENV_VAR;
+		return normalized !== "CODEX_HOME" && normalized !== CODEX_APP_SERVER_ARGS_ENV_KEY;
 	});
 	return {
 		...start,
@@ -161,7 +201,7 @@ function buildPrivateCodexAppServerStartOptions(start, codexHome) {
 			...privateEnv,
 			CODEX_HOME: codexHome
 		},
-		clearEnv: [...clearEnv, OPENCLAW_CODEX_APP_SERVER_ARGS_ENV_VAR]
+		clearEnv: [...clearEnv, CODEX_APP_SERVER_ARGS_ENV_KEY]
 	};
 }
 function createCodexBoundedApprovalHandler(taskLabel) {
@@ -207,6 +247,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 	let turnId;
 	let completedTurn;
 	let promptError;
+	let responseUsage;
 	const pending = [];
 	const completedItems = /* @__PURE__ */ new Map();
 	const assistantTextByItem = /* @__PURE__ */ new Map();
@@ -242,12 +283,18 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 			rememberAssistantText(itemId, `${assistantTextByItem.get(itemId) ?? ""}${delta}`);
 			return;
 		}
+		if (notification.method === "rawResponse/completed") {
+			const usage = isJsonObject(params.usage) ? params.usage : void 0;
+			responseUsage = usage ? normalizeCodexResponseTokenUsage(usage) : void 0;
+			return;
+		}
 		if (notification.method === "turn/completed") {
 			completedTurn = readCodexTurnCompletedNotification(notification.params)?.turn ?? completedTurn;
 			resolveCompletion?.();
 			return;
 		}
 		if (notification.method === "error") {
+			if (isRetryableErrorNotification(notification.params)) return;
 			promptError = readCodexErrorNotification(notification.params)?.error.message ?? `codex app-server ${taskLabel} turn failed`;
 			resolveCompletion?.();
 		}
@@ -266,6 +313,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 			});
 			if (promptError) throw new Error(promptError);
 			if (completedTurn?.status === "failed") throw new Error(completedTurn.error?.message ?? `codex app-server ${taskLabel} turn failed`);
+			if (completedTurn?.status !== "completed") throw new Error(`codex app-server ${taskLabel} turn ended with status ${completedTurn?.status ?? "unknown"}`);
 			const items = collectCompletedItems(completedTurn?.items, completedItems);
 			const itemText = collectAssistantTextFromItems(items);
 			const deltaText = assistantItemOrder.map((itemId) => assistantTextByItem.get(itemId)?.trim()).filter((text) => Boolean(text)).join("\n\n").trim();
@@ -273,7 +321,8 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 			if (!text) throw new Error(`Codex app-server ${taskLabel} turn returned no text.`);
 			return {
 				text,
-				items
+				items,
+				...responseUsage ? { usage: responseUsage } : {}
 			};
 		}
 	};
@@ -316,170 +365,4 @@ function isTerminalTurn(turn) {
 	return turn.status === "completed" || turn.status === "interrupted" || turn.status === "failed";
 }
 //#endregion
-//#region extensions/codex/media-understanding-provider.ts
-/**
-* Codex-backed media understanding provider for bounded image description and
-* structured extraction turns.
-*/
-const CODEX_MEDIA_PROVIDER_ID = "codex";
-const DEFAULT_CODEX_IMAGE_MODEL = "gpt-5.6-sol";
-const DEFAULT_CODEX_IMAGE_PROMPT = "Describe the image.";
-/**
-* Builds the media-understanding provider that delegates image tasks to an
-* isolated Codex app-server session.
-*/
-function buildCodexMediaUnderstandingProvider(options = {}) {
-	return {
-		id: CODEX_MEDIA_PROVIDER_ID,
-		capabilities: ["image"],
-		defaultModels: { image: DEFAULT_CODEX_IMAGE_MODEL },
-		describeImage: async (req) => describeCodexImages({
-			images: [{
-				buffer: req.buffer,
-				fileName: req.fileName,
-				mime: req.mime
-			}],
-			provider: req.provider,
-			model: req.model,
-			prompt: req.prompt,
-			maxTokens: req.maxTokens,
-			timeoutMs: req.timeoutMs,
-			profile: req.profile,
-			preferredProfile: req.preferredProfile,
-			authStore: req.authStore,
-			agentDir: req.agentDir,
-			cfg: req.cfg
-		}, options),
-		describeImages: async (req) => describeCodexImages(req, options),
-		extractStructured: async (req) => extractCodexStructured(req, options)
-	};
-}
-async function describeCodexImages(req, options) {
-	const model = req.model.trim();
-	if (!model) throw new Error("Codex image understanding requires model id.");
-	const { text } = await runBoundedCodexAppServerTurn({
-		config: req.cfg,
-		model: {
-			mode: "required",
-			id: model
-		},
-		profile: req.profile,
-		timeoutMs: req.timeoutMs,
-		agentDir: req.agentDir,
-		authProfileStore: req.authStore,
-		options,
-		taskLabel: "image understanding",
-		developerInstructions: "You are OpenClaw's bounded image-understanding worker. Describe only the provided image content. Do not call tools, edit files, or ask follow-up questions.",
-		input: [{
-			type: "text",
-			text: buildCodexImagePrompt(req),
-			text_elements: []
-		}, ...req.images.map((image) => ({
-			type: "image",
-			url: `data:${image.mime ?? "image/png"};base64,${image.buffer.toString("base64")}`
-		}))],
-		requiredModalities: ["text", "image"],
-		isolation: "configured-transport"
-	});
-	return {
-		text,
-		model
-	};
-}
-async function extractCodexStructured(req, options) {
-	const model = req.model.trim();
-	if (!model) throw new Error("Codex structured extraction requires model id.");
-	if (!req.instructions.trim()) throw new Error("Codex structured extraction requires instructions.");
-	if (req.input.length === 0) throw new Error("Codex structured extraction requires at least one input.");
-	if (!req.input.some((entry) => entry.type === "image")) throw new Error("Codex structured extraction requires at least one image input.");
-	const { text } = await runBoundedCodexAppServerTurn({
-		config: req.cfg,
-		model: {
-			mode: "required",
-			id: model
-		},
-		profile: req.profile,
-		timeoutMs: req.timeoutMs,
-		agentDir: req.agentDir,
-		authProfileStore: req.authStore,
-		options,
-		taskLabel: "structured extraction",
-		developerInstructions: "You are OpenClaw's bounded structured-extraction worker. Return only the requested extraction. Do not call tools, edit files, ask follow-up questions, or include secrets.",
-		input: buildCodexStructuredInput(req),
-		requiredModalities: requiredStructuredModalities(),
-		isolation: "configured-transport"
-	});
-	return normalizeStructuredExtractionResult({
-		text,
-		model,
-		provider: req.provider,
-		req
-	});
-}
-function buildCodexImagePrompt(req) {
-	const prompt = req.prompt?.trim() || DEFAULT_CODEX_IMAGE_PROMPT;
-	if (req.images.length <= 1) return prompt;
-	return `${prompt}\n\nAnalyze all ${req.images.length} images together.`;
-}
-function requiredStructuredModalities() {
-	return ["text", "image"];
-}
-function buildCodexStructuredInput(req) {
-	return [{
-		type: "text",
-		text: buildStructuredExtractionPrompt(req),
-		text_elements: []
-	}, ...req.input.map((entry) => {
-		if (entry.type === "text") return {
-			type: "text",
-			text: entry.text,
-			text_elements: []
-		};
-		return {
-			type: "image",
-			url: `data:${entry.mime ?? "image/png"};base64,${entry.buffer.toString("base64")}`
-		};
-	})];
-}
-function buildStructuredExtractionPrompt(req) {
-	return [
-		req.instructions.trim(),
-		req.schemaName ? `Schema name: ${req.schemaName}` : void 0,
-		req.jsonSchema ? `JSON schema:\n${JSON.stringify(req.jsonSchema)}` : void 0,
-		req.jsonMode === false ? "Return the extraction as concise text." : "Return valid JSON only. Do not wrap the JSON in Markdown fences."
-	].filter((part) => Boolean(part)).join("\n\n");
-}
-function isJsonSchemaObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeStructuredExtractionResult(params) {
-	const result = {
-		text: params.text,
-		model: params.model,
-		provider: params.provider,
-		contentType: params.req.jsonMode === false ? "text" : "json"
-	};
-	if (params.req.jsonMode !== false) {
-		try {
-			result.parsed = JSON.parse(params.text);
-		} catch {
-			throw new Error("Codex structured extraction returned invalid JSON.");
-		}
-		if (isJsonSchemaObject(params.req.jsonSchema)) {
-			const validation = validateJsonSchemaValue({
-				schema: params.req.jsonSchema,
-				cacheKey: "codex.media-understanding.extractStructured",
-				value: result.parsed,
-				cache: false
-			});
-			if (!validation.ok) {
-				const message = validation.errors.map((error) => error.text).join("; ") || "invalid";
-				throw new Error(`Codex structured extraction JSON did not match schema: ${message}`);
-			}
-			result.parsed = validation.value;
-		}
-	}
-	return result;
-}
-//#endregion
-export { runBoundedCodexAppServerTurn as n, buildCodexMediaUnderstandingProvider as t };
+export { runBoundedCodexAppServerTurn as t };

package/dist/capabilities-BHRSI6Cn.js

@@ -0,0 +1,36 @@
+import { _ as CodexAppServerRpcError } from "./shared-client-BVKE40c-.js";
+//#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",
+	feedback: "feedback/upload",
+	forkThread: "thread/fork",
+	listMcpServers: "mcpServerStatus/list",
+	listSkills: "skills/list",
+	listThreads: "thread/list",
+	listThreadTurns: "thread/turns/list",
+	readThread: "thread/read",
+	rateLimits: "account/rateLimits/read",
+	archiveThread: "thread/archive",
+	renameThread: "thread/name/set",
+	resumeThread: "thread/resume",
+	review: "review/start",
+	unarchiveThread: "thread/unarchive",
+	getThreadGoal: "thread/goal/get",
+	setThreadGoal: "thread/goal/set",
+	clearThreadGoal: "thread/goal/clear"
+};
+/** 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);
+}
+function isUnsupportedControlError(error) {
+	return error instanceof CodexAppServerRpcError && error.code === -32601;
+}
+//#endregion
+export { describeControlFailure as n, CODEX_CONTROL_METHODS as t };

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-Bxk3-Wqz.js");
+		const { registerCodexSessionCli } = await import("./session-cli-CqZ0Fp2a.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

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

@@ -1,39 +1,5 @@
-import { R as CodexAppServerRpcError, Z as isJsonObject } from "./shared-client-CSXLtCLE.js";
-import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-CqhWQ2R9.js";
-//#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",
-	feedback: "feedback/upload",
-	forkThread: "thread/fork",
-	listMcpServers: "mcpServerStatus/list",
-	listSkills: "skills/list",
-	listThreads: "thread/list",
-	listThreadTurns: "thread/turns/list",
-	readThread: "thread/read",
-	rateLimits: "account/rateLimits/read",
-	archiveThread: "thread/archive",
-	renameThread: "thread/name/set",
-	resumeThread: "thread/resume",
-	review: "review/start",
-	unarchiveThread: "thread/unarchive",
-	getThreadGoal: "thread/goal/get",
-	setThreadGoal: "thread/goal/set",
-	clearThreadGoal: "thread/goal/clear"
-};
-/** 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);
-}
-function isUnsupportedControlError(error) {
-	return error instanceof CodexAppServerRpcError && error.code === -32601;
-}
-//#endregion
+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";
 //#region extensions/codex/src/command-formatters.ts
 /** Formats the combined `/codex status` probe result. */
 function formatCodexStatus(probes) {
@@ -312,4 +278,4 @@ function readString(record, key) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 //#endregion
-export { formatComputerUseStatus as a, formatSkills as c, CODEX_CONTROL_METHODS as d, describeControlFailure as f, 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, readString as u };