@openclaw/codex 2026.5.10-beta.1 → 2026.5.10-beta.3

package/dist/{client-CTzy3Y6M.js → client-CpksBQ9l.js}

@@ -1,4 +1,4 @@
-import { s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
+import { s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
 import { n as isRpcResponse } from "./protocol-C9UWI98H.js";
 import { createInterface } from "node:readline";
 import { OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";

package/dist/{client-factory-BJL_efz4.js → client-factory-BHbKz0nI.js}

@@ -1,5 +1,5 @@
 //#region extensions/codex/src/app-server/client-factory.ts
-const defaultCodexAppServerClientFactory = (startOptions, authProfileId, agentDir, config) => import("./shared-client-p-TvEiNL.js").then((n) => n.r).then(({ getSharedCodexAppServerClient }) => getSharedCodexAppServerClient({
+const defaultCodexAppServerClientFactory = (startOptions, authProfileId, agentDir, config) => import("./shared-client-BRX9tReb.js").then((n) => n.r).then(({ getSharedCodexAppServerClient }) => getSharedCodexAppServerClient({
 	startOptions,
 	authProfileId,
 	agentDir,

package/dist/{command-handlers-BJ0GpaPa.js → command-handlers-BPaLMsgL.js}

@@ -1,10 +1,10 @@
-import { i as isCodexFastServiceTier, s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
-import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-OtCFiaj_.js";
+import { i as isCodexFastServiceTier, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
+import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-lvthKXfT.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { a as formatCodexStatus, c as formatModels, f as CODEX_CONTROL_METHODS, i as formatCodexDisplayText, l as formatThreads, n as buildHelp, o as formatComputerUseStatus, p as describeControlFailure, r as formatAccount, s as formatList, t as requestCodexAppServerJson, u as readString } from "./request-DC1Dz3iZ.js";
-import { i as readCodexAppServerBinding, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-B44KIZM2.js";
-import { a as parseCodexFastModeArg, c as setCodexConversationFastMode, d as steerCodexConversationTurn, f as stopCodexConversationTurn, i as formatPermissionsMode, l as setCodexConversationModel, m as resolveCodexDefaultWorkspaceDir, o as parseCodexPermissionsModeArg, p as readCodexConversationBindingData, r as startCodexConversationThread, s as readCodexConversationActiveTurn, u as setCodexConversationPermissions } from "./conversation-binding-FqeYliIk.js";
-import { a as readCodexComputerUseStatus, i as installCodexComputerUse, n as rememberCodexRateLimits } from "./rate-limit-cache-DbZvmrAD.js";
+import { a as formatCodexStatus, c as formatModels, i as formatCodexDisplayText, l as formatThreads, m as describeControlFailure, n as buildHelp, o as formatComputerUseStatus, p as CODEX_CONTROL_METHODS, r as formatAccount, s as formatList, t as requestCodexAppServerJson, u as readString } from "./request-Bj4IRDU9.js";
+import { i as readCodexAppServerBinding, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-BAaJ-7s-.js";
+import { a as parseCodexFastModeArg, c as setCodexConversationFastMode, d as steerCodexConversationTurn, f as stopCodexConversationTurn, i as formatPermissionsMode, l as setCodexConversationModel, m as resolveCodexDefaultWorkspaceDir, o as parseCodexPermissionsModeArg, p as readCodexConversationBindingData, r as startCodexConversationThread, s as readCodexConversationActiveTurn, u as setCodexConversationPermissions } from "./conversation-binding-zeuTIuN2.js";
+import { a as readCodexComputerUseStatus, i as installCodexComputerUse, n as rememberCodexRateLimits } from "./rate-limit-cache-BFTJlMhx.js";
 import crypto from "node:crypto";
 //#region extensions/codex/src/command-rpc.ts
 function requestOptions(pluginConfig, limit, config) {
@@ -318,9 +318,9 @@ async function handleCodexDiagnosticsFeedback(deps, ctx, pluginConfig, args, com
 	if (parsed.action === "cancel") return { text: cancelCodexDiagnosticsFeedback(ctx, parsed.token) };
 	if (ctx.diagnosticsUploadApproved === true) return { text: await sendCodexDiagnosticsFeedbackForContext(deps, ctx, pluginConfig, parsed.note) };
 	if (ctx.diagnosticsPreviewOnly === true) return { text: await previewCodexDiagnosticsFeedbackApproval(deps, ctx, parsed.note) };
-	return await requestCodexDiagnosticsFeedbackApproval(deps, ctx, pluginConfig, parsed.note, commandPrefix);
+	return await requestCodexDiagnosticsFeedbackApproval(deps, ctx, parsed.note, commandPrefix);
 }
-async function requestCodexDiagnosticsFeedbackApproval(deps, ctx, pluginConfig, note, commandPrefix) {
+async function requestCodexDiagnosticsFeedbackApproval(deps, ctx, note, commandPrefix) {
 	if (!await hasAnyCodexDiagnosticsSessionFile(ctx)) return { text: "Cannot send Codex diagnostics because this command did not include an OpenClaw session file." };
 	const targets = await resolveCodexDiagnosticsTargets(deps, ctx);
 	if (targets.length === 0) return { text: ["No Codex thread is attached to this OpenClaw session yet.", "Use /codex threads to find a thread, then /codex resume <thread-id> before sending diagnostics."].join("\n") };

package/dist/{compact-4FVe6NwI.js → compact-CMIpm-H_.js}

@@ -1,7 +1,7 @@
-import { s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
+import { s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { i as readCodexAppServerBinding } from "./session-binding-B44KIZM2.js";
-import { n as defaultCodexAppServerClientFactory, t as createCodexAppServerClientFactoryTestHooks } from "./client-factory-BJL_efz4.js";
+import { i as readCodexAppServerBinding } from "./session-binding-BAaJ-7s-.js";
+import { n as defaultCodexAppServerClientFactory, t as createCodexAppServerClientFactoryTestHooks } from "./client-factory-BHbKz0nI.js";
 import { embeddedAgentLog, formatErrorMessage, isActiveHarnessContextEngine, runHarnessContextEngineMaintenance } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/compact.ts
 const DEFAULT_CODEX_COMPACTION_WAIT_TIMEOUT_MS = 300 * 1e3;

package/dist/{config-CT01BBDc.js → config-C7xdbzrp.js}

@@ -1,7 +1,7 @@
 import { createHmac, randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { hostname } from "node:os";
-import { z } from "openclaw/plugin-sdk/zod";
+import { z } from "zod";
 //#region extensions/codex/src/app-server/config.ts
 const START_OPTIONS_KEY_SECRET = randomBytes(32);
 const UNIX_CODEX_REQUIREMENTS_PATH = "/etc/codex/requirements.toml";

package/dist/{conversation-binding-FqeYliIk.js → conversation-binding-zeuTIuN2.js}

@@ -1,8 +1,8 @@
-import { i as isCodexFastServiceTier, r as codexSandboxPolicyForTurn, s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
+import { i as isCodexFastServiceTier, r as codexSandboxPolicyForTurn, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { f as CODEX_CONTROL_METHODS, i as formatCodexDisplayText } from "./request-DC1Dz3iZ.js";
-import { c as resolveCodexAppServerAuthProfileIdForAgent, n as getSharedCodexAppServerClient } from "./shared-client-p-TvEiNL.js";
-import { i as readCodexAppServerBinding, n as isCodexAppServerNativeAuthProfile, o as writeCodexAppServerBinding, r as normalizeCodexAppServerBindingModelProvider, t as clearCodexAppServerBinding } from "./session-binding-B44KIZM2.js";
+import { i as formatCodexDisplayText, p as CODEX_CONTROL_METHODS } from "./request-Bj4IRDU9.js";
+import { c as resolveCodexAppServerAuthProfileIdForAgent, n as getSharedCodexAppServerClient } from "./shared-client-BRX9tReb.js";
+import { i as readCodexAppServerBinding, n as isCodexAppServerNativeAuthProfile, o as writeCodexAppServerBinding, r as normalizeCodexAppServerBindingModelProvider, t as clearCodexAppServerBinding } from "./session-binding-BAaJ-7s-.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
 import path from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/harness.js

@@ -18,21 +18,21 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-DsO-3wqp.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-COMElKgN.js");
 			return runCodexAppServerAttempt(params, { pluginConfig: options?.pluginConfig });
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-4FVe6NwI.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-CMIpm-H_.js");
 			return maybeCompactCodexAppServerSession(params, { pluginConfig: options?.pluginConfig });
 		},
 		reset: async (params) => {
 			if (params.sessionFile) {
-				const { clearCodexAppServerBinding } = await import("./session-binding-B44KIZM2.js").then((n) => n.a);
+				const { clearCodexAppServerBinding } = await import("./session-binding-BAaJ-7s-.js").then((n) => n.a);
 				await clearCodexAppServerBinding(params.sessionFile);
 			}
 		},
 		dispose: async () => {
-			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-p-TvEiNL.js").then((n) => n.r);
+			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-BRX9tReb.js").then((n) => n.r);
 			await clearSharedCodexAppServerClientAndWait();
 		}
 	};

package/dist/index.js

@@ -1,10 +1,10 @@
 import { createCodexAppServerAgentHarness } from "./harness.js";
-import { t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-CT01BBDc.js";
+import { t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-C7xdbzrp.js";
 import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
 import { buildCodexProvider } from "./provider.js";
-import { i as formatCodexDisplayText, p as describeControlFailure, t as requestCodexAppServerJson } from "./request-DC1Dz3iZ.js";
-import { n as handleCodexConversationInboundClaim, t as handleCodexConversationBindingResolved } from "./conversation-binding-FqeYliIk.js";
-import { i as defaultCodexAppInventoryCache, t as ensureCodexPluginActivation } from "./plugin-activation-CweAZa7r.js";
+import { i as formatCodexDisplayText, m as describeControlFailure, t as requestCodexAppServerJson } from "./request-Bj4IRDU9.js";
+import { n as handleCodexConversationInboundClaim, t as handleCodexConversationBindingResolved } from "./conversation-binding-zeuTIuN2.js";
+import { i as defaultCodexAppInventoryCache, t as ensureCodexPluginActivation } from "./plugin-activation-Dn14PX1W.js";
 import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import os from "node:os";
@@ -28,13 +28,17 @@ function createCodexCommand(options) {
 	};
 }
 async function handleCodexCommand(ctx, options = {}) {
-	const { handleCodexSubcommand } = await import("./command-handlers-BJ0GpaPa.js");
+	const { loadSubcommandHandler, ...subcommandOptions } = options;
 	try {
-		return await handleCodexSubcommand(ctx, options);
+		return await (loadSubcommandHandler ? await loadSubcommandHandler() : await loadDefaultCodexSubcommandHandler())(ctx, subcommandOptions);
 	} catch (error) {
 		return { text: `Codex command failed: ${formatCodexDisplayText(describeControlFailure(error))}` };
 	}
 }
+async function loadDefaultCodexSubcommandHandler() {
+	const { handleCodexSubcommand } = await import("./command-handlers-BPaLMsgL.js");
+	return handleCodexSubcommand;
+}
 //#endregion
 //#region extensions/codex/src/migration/helpers.ts
 async function exists(filePath) {

package/dist/media-understanding-provider.js

@@ -1,8 +1,9 @@
 import { CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS } from "./provider-catalog.js";
-import { s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
-import { a as readCodexErrorNotification, c as readCodexTurnCompletedNotification, n as assertCodexThreadStartResponse, r as assertCodexTurnStartResponse } from "./protocol-validators-CbqWfY5M.js";
-import { i as readModelListResult } from "./models-OtCFiaj_.js";
+import { s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
+import { a as readCodexErrorNotification, c as readCodexTurnCompletedNotification, n as assertCodexThreadStartResponse, r as assertCodexTurnStartResponse } from "./protocol-validators-CeCyJaWj.js";
+import { i as readModelListResult } from "./models-lvthKXfT.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
+import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
 //#region extensions/codex/media-understanding-provider.ts
 const DEFAULT_CODEX_IMAGE_MODEL = FALLBACK_CODEX_MODELS.find((model) => model.inputModalities.includes("image"))?.id ?? FALLBACK_CODEX_MODELS[0]?.id;
 const DEFAULT_CODEX_IMAGE_PROMPT = "Describe the image.";
@@ -28,38 +29,63 @@ function buildCodexMediaUnderstandingProvider(options = {}) {
 			agentDir: req.agentDir,
 			cfg: req.cfg
 		}, options),
-		describeImages: async (req) => describeCodexImages(req, 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 appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
-	const timeoutMs = Math.max(100, req.timeoutMs);
-	const ownsClient = !options.clientFactory;
-	const client = options.clientFactory ? await options.clientFactory(appServer.start, req.profile) : await import("./shared-client-p-TvEiNL.js").then((n) => n.r).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+	return {
+		text: await runBoundedCodexVisionTurn({
+			model,
+			profile: req.profile,
+			timeoutMs: req.timeoutMs,
+			agentDir: req.agentDir,
+			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"]
+		}),
+		model
+	};
+}
+async function runBoundedCodexVisionTurn(params) {
+	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: params.options.pluginConfig });
+	const timeoutMs = Math.max(100, params.timeoutMs);
+	const ownsClient = !params.options.clientFactory;
+	const client = params.options.clientFactory ? await params.options.clientFactory(appServer.start, params.profile) : await import("./shared-client-BRX9tReb.js").then((n) => n.r).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		startOptions: appServer.start,
 		timeoutMs,
-		authProfileId: req.profile
+		authProfileId: params.profile
 	}));
 	const abortController = new AbortController();
 	const timeout = setTimeout(() => abortController.abort("timeout"), timeoutMs);
 	timeout.unref?.();
 	try {
-		await assertCodexModelSupportsImage({
+		await assertCodexModelSupportsInput({
 			client,
-			model,
+			model: params.model,
+			requiredModalities: params.requiredModalities,
 			timeoutMs,
 			signal: abortController.signal
 		});
 		const thread = assertCodexThreadStartResponse(await client.request("thread/start", {
-			model,
+			model: params.model,
 			modelProvider: "openai",
-			cwd: req.agentDir || process.cwd(),
+			cwd: params.agentDir || process.cwd(),
 			approvalPolicy: "on-request",
 			sandbox: "read-only",
 			serviceName: "OpenClaw",
-			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.",
+			developerInstructions: params.developerInstructions,
 			dynamicTools: [],
 			experimentalRawEvents: true,
 			persistExtendedHistory: false,
@@ -68,35 +94,25 @@ async function describeCodexImages(req, options) {
 			timeoutMs,
 			signal: abortController.signal
 		}));
-		const collector = createCodexImageTurnCollector(thread.thread.id);
+		const collector = createCodexTurnCollector(thread.thread.id, params.taskLabel);
 		const cleanup = client.addNotificationHandler(collector.handleNotification);
 		const requestCleanup = client.addRequestHandler(denyCodexImageApprovalRequest);
 		try {
 			const turn = assertCodexTurnStartResponse(await client.request("turn/start", {
 				threadId: thread.thread.id,
-				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")}`
-				}))],
-				cwd: req.agentDir || process.cwd(),
+				input: params.input,
+				cwd: params.agentDir || process.cwd(),
 				approvalPolicy: "on-request",
-				model,
+				model: params.model,
 				effort: "low"
 			}, {
 				timeoutMs,
 				signal: abortController.signal
 			}));
-			return {
-				text: await collector.collect(turn.turn, {
-					timeoutMs,
-					signal: abortController.signal
-				}),
-				model
-			};
+			return await collector.collect(turn.turn, {
+				timeoutMs,
+				signal: abortController.signal
+			});
 		} finally {
 			requestCleanup();
 			cleanup();
@@ -106,6 +122,29 @@ async function describeCodexImages(req, options) {
 		if (ownsClient) client.close();
 	}
 }
+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.");
+	return normalizeStructuredExtractionResult({
+		text: await runBoundedCodexVisionTurn({
+			model,
+			profile: req.profile,
+			timeoutMs: req.timeoutMs,
+			agentDir: req.agentDir,
+			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()
+		}),
+		model,
+		provider: req.provider,
+		req
+	});
+}
 function denyCodexImageApprovalRequest(request) {
 	if (request.method === "item/commandExecution/requestApproval" || request.method === "item/fileChange/requestApproval") return {
 		decision: "decline",
@@ -121,7 +160,7 @@ function denyCodexImageApprovalRequest(request) {
 	};
 	if (request.method === "mcpServer/elicitation/request") return { action: "decline" };
 }
-async function assertCodexModelSupportsImage(params) {
+async function assertCodexModelSupportsInput(params) {
 	const match = readModelListResult(await params.client.request("model/list", {
 		limit: 100,
 		cursor: null,
@@ -131,14 +170,75 @@ async function assertCodexModelSupportsImage(params) {
 		signal: params.signal
 	})).models.find((entry) => entry.model === params.model || entry.id === params.model);
 	if (!match) throw new Error(`Codex app-server model not found: ${params.model}`);
-	if (!match.inputModalities.includes("image")) throw new Error(`Codex app-server model does not support images: ${params.model}`);
+	if (params.requiredModalities.includes("image") && !match.inputModalities.includes("image")) throw new Error(`Codex app-server model does not support images: ${params.model}`);
+	if (params.requiredModalities.includes("text") && !match.inputModalities.includes("text")) throw new Error(`Codex app-server model does not support text: ${params.model}`);
 }
 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 createCodexImageTurnCollector(threadId) {
+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;
+}
+function createCodexTurnCollector(threadId, taskLabel) {
 	let turnId;
 	let completedTurn;
 	let promptError;
@@ -174,7 +274,7 @@ function createCodexImageTurnCollector(threadId) {
 			return;
 		}
 		if (notification.method === "error") {
-			promptError = readCodexErrorNotification(notification.params)?.error.message ?? "codex app-server image turn failed";
+			promptError = readCodexErrorNotification(notification.params)?.error.message ?? `codex app-server ${taskLabel} turn failed`;
 			resolveCompletion?.();
 		}
 	};
@@ -187,14 +287,15 @@ function createCodexImageTurnCollector(threadId) {
 			if (!completedTurn && !promptError) await waitForTurnCompletion({
 				completion,
 				timeoutMs: options.timeoutMs,
-				signal: options.signal
+				signal: options.signal,
+				taskLabel
 			});
 			if (promptError) throw new Error(promptError);
-			if (completedTurn?.status === "failed") throw new Error(completedTurn.error?.message ?? "codex app-server image turn failed");
+			if (completedTurn?.status === "failed") throw new Error(completedTurn.error?.message ?? `codex app-server ${taskLabel} turn failed`);
 			const itemText = collectAssistantTextFromItems(completedTurn?.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 image turn returned no text.");
+			if (!text) throw new Error(`Codex app-server ${taskLabel} turn returned no text.`);
 			return text;
 		}
 	};
@@ -204,9 +305,9 @@ async function waitForTurnCompletion(params) {
 	let cleanupAbort;
 	try {
 		await Promise.race([params.completion, new Promise((_, reject) => {
-			timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("codex app-server image turn timed out")), params.timeoutMs);
+			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 image turn aborted"));
+			const abortListener = () => reject(/* @__PURE__ */ new Error(`codex app-server ${params.taskLabel} turn aborted`));
 			params.signal.addEventListener("abort", abortListener, { once: true });
 			cleanupAbort = () => params.signal.removeEventListener("abort", abortListener);
 		})]);

package/dist/{models-OtCFiaj_.js → models-lvthKXfT.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
-import { o as readCodexModelListResponse } from "./protocol-validators-CbqWfY5M.js";
+import { o as readCodexModelListResponse } from "./protocol-validators-CeCyJaWj.js";
 //#region extensions/codex/src/app-server/models.ts
 var models_exports = /* @__PURE__ */ __exportAll({
 	listAllCodexAppServerModels: () => listAllCodexAppServerModels,
@@ -39,7 +39,7 @@ async function listAllCodexAppServerModels(options = {}) {
 async function withCodexAppServerModelClient(options, run) {
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getSharedCodexAppServerClient } = await import("./shared-client-p-TvEiNL.js").then((n) => n.r);
+	const { createIsolatedCodexAppServerClient, getSharedCodexAppServerClient } = await import("./shared-client-BRX9tReb.js").then((n) => n.r);
 	const client = useSharedClient ? await getSharedCodexAppServerClient({
 		startOptions: options.startOptions,
 		timeoutMs,

package/dist/{plugin-activation-CweAZa7r.js → plugin-activation-Dn14PX1W.js}

@@ -1,4 +1,4 @@
-import { l as resolveCodexPluginsPolicy, t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-CT01BBDc.js";
+import { l as resolveCodexPluginsPolicy, t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-C7xdbzrp.js";
 import "node:fs/promises";
 import "node:path";
 var CodexAppInventoryCache = class {

package/dist/{protocol-validators-CbqWfY5M.js → protocol-validators-CeCyJaWj.js}

@@ -5898,10 +5898,10 @@ const validateThreadStartResponse = ajv.compile(ThreadStartResponse_default);
 const validateTurnCompletedNotification = ajv.compile(TurnCompletedNotification_default);
 const validateTurnStartResponse = ajv.compile(TurnStartResponse_default);
 function assertCodexThreadStartResponse(value) {
-	return assertCodexShape(validateThreadStartResponse, value, "thread/start response");
+	return assertCodexShape(validateThreadStartResponse, normalizeThreadResponse(value), "thread/start response");
 }
 function assertCodexThreadResumeResponse(value) {
-	return assertCodexShape(validateThreadResumeResponse, value, "thread/resume response");
+	return assertCodexShape(validateThreadResumeResponse, normalizeThreadResponse(value), "thread/resume response");
 }
 function assertCodexTurnStartResponse(value) {
 	return assertCodexShape(validateTurnStartResponse, normalizeTurnStartResponse(value), "turn/start response");
@@ -5968,6 +5968,28 @@ function normalizeThreadItem(value) {
 		default: return value;
 	}
 }
+function normalizeThreadResponse(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value) || !("thread" in value)) return value;
+	const thread = value.thread;
+	if (thread && typeof thread === "object" && !Array.isArray(thread)) {
+		const t = thread;
+		if (typeof t.id === "string" && typeof t.sessionId !== "string") return {
+			...value,
+			thread: {
+				...thread,
+				sessionId: t.id
+			}
+		};
+		if (typeof t.sessionId === "string" && typeof t.id !== "string") return {
+			...value,
+			thread: {
+				...thread,
+				id: t.sessionId
+			}
+		};
+	}
+	return value;
+}
 function normalizeTurnStartResponse(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value) || !("turn" in value)) return value;
 	return {

package/dist/provider.js

@@ -1,5 +1,5 @@
 import { CODEX_APP_SERVER_AUTH_MARKER, CODEX_BASE_URL, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexModelDefinition, buildCodexProviderConfig } from "./provider-catalog.js";
-import { o as readCodexPluginConfig, s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
+import { o as readCodexPluginConfig, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
 import { resolveCodexSystemPromptContribution } from "./prompt-overlay.js";
 import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/core";
@@ -123,7 +123,7 @@ async function listModelsBestEffort(params) {
 	}
 }
 async function listCodexAppServerModelsLazy(options) {
-	const { listCodexAppServerModels } = await import("./models-OtCFiaj_.js").then((n) => n.r);
+	const { listCodexAppServerModels } = await import("./models-lvthKXfT.js").then((n) => n.r);
 	return listCodexAppServerModels(options);
 }
 function normalizeTimeoutMs(value) {

package/dist/{rate-limit-cache-DbZvmrAD.js → rate-limit-cache-BFTJlMhx.js}

@@ -1,5 +1,5 @@
-import { c as resolveCodexComputerUseConfig, s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
-import { p as describeControlFailure, t as requestCodexAppServerJson } from "./request-DC1Dz3iZ.js";
+import { c as resolveCodexComputerUseConfig, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
+import { m as describeControlFailure, t as requestCodexAppServerJson } from "./request-Bj4IRDU9.js";
 import { existsSync } from "node:fs";
 //#region extensions/codex/src/app-server/computer-use.ts
 var CodexComputerUseSetupError = class extends Error {