@openclaw/codex 2026.7.2-beta.5 → 2026.7.33

package/dist/{conversation-binding-data-BHRpYbX3.js → .setup/conversation-binding-data-CrRxtDBu.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import process from "node:process";

package/dist/{bounded-turn-FEbUXoYT.js → .setup/media-understanding-provider-EbJCyDqe.mjs}

@@ -1,11 +1,11 @@
-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 { CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS } from "../provider-catalog.js";
+import { r as isJsonObject } from "./protocol-2POPqAY4.mjs";
+import { _ as readCodexNotificationItem } from "./attempt-notifications-F8krwWL4.mjs";
+import { d as resolveCodexAppServerRuntimeOptions } from "./config-CYEDnLJ2.mjs";
+import { i as assertCodexTurnStartResponse, l as readCodexTurnCompletedNotification, o as readCodexErrorNotification, r as assertCodexThreadStartResponse } from "./protocol-validators-dZQ-UTOa.mjs";
+import { i as readModelListResult } from "./models-C_aZk03A.mjs";
+import { H as mergeCodexThreadConfigs, r as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-u6CZdOOH.mjs";
+import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
@@ -16,7 +16,7 @@ const CODEX_PRIVATE_STDIO_ARGS = [
 	"--listen",
 	"stdio://"
 ];
-const CODEX_APP_SERVER_ARGS_ENV_KEY = "OPENCLAW_CODEX_APP_SERVER_ARGS";
+const OPENCLAW_CODEX_APP_SERVER_ARGS_ENV_VAR = "OPENCLAW_CODEX_APP_SERVER_ARGS";
 const CODEX_BOUNDED_THREAD_CONFIG = {
 	"features.multi_agent": false,
 	"features.apps": false,
@@ -29,15 +29,8 @@ 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,
-		managedCommandOrder: params.isolation === "private-stdio" ? "package-first" : void 0
-	});
+	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: params.options.pluginConfig });
 	if (params.isolation === "configured-transport") return await runBoundedCodexAppServerTurnInWorkspace(params, appServer, { cwd: params.agentDir?.trim() || process.cwd() });
 	if (appServer.start.transport !== "stdio") throw new Error("Bounded Codex turns require stdio transport so native tools can be isolated.");
 	return await withTempWorkspace({
@@ -53,11 +46,8 @@ async function runBoundedCodexAppServerTurn(params) {
 		});
 	});
 }
-async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt = 0, timing) {
-	const totalTimeoutMs = timing?.timeoutMs ?? resolveTimerTimeoutMs(params.timeoutMs, 100, 100);
-	const deadline = timing?.deadline ?? Date.now() + totalTimeoutMs;
-	const timeoutMs = deadline - Date.now();
-	if (timeoutMs <= 0) throw new Error(`${params.taskLabel} timed out`);
+async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace) {
+	const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 100, 100);
 	const agentDir = params.agentDir?.trim() || void 0;
 	const startOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
 	const ownsClient = !params.options.clientFactory;
@@ -66,41 +56,21 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		authProfileId: params.profile,
 		agentDir,
 		config: params.config,
-		timeoutMs,
-		...params.signal ? { abandonSignal: params.signal } : {}
-	}) : await import("./shared-client-BVKE40c-.js").then((n) => n.p).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+		timeoutMs
+	}) : await import("./shared-client-B2KmLPRw.mjs").then((n) => n.c).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		startOptions,
 		timeoutMs,
 		authProfileId: params.profile,
 		agentDir,
 		authProfileStore: params.authProfileStore,
-		config: params.config,
-		...params.signal ? { abandonSignal: params.signal } : {}
+		config: params.config
 	}));
 	const abortController = new AbortController();
-	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");
+	const abortFromCaller = () => abortController.abort(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) abortRun("timeout");
-	const timeout = setTimeout(() => abortRun("timeout"), Math.max(1, remainingRunMs));
+	const timeout = setTimeout(() => abortController.abort("timeout"), timeoutMs);
 	timeout.unref?.();
-	let retrySelection = false;
 	try {
 		const model = await resolveCodexBoundedTurnModel({
 			client,
@@ -109,8 +79,6 @@ 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",
@@ -118,9 +86,8 @@ 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, inheritedMcpServerNames), { nativeCodeModeEnabled: false }),
+			config: buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace), { nativeCodeModeEnabled: false }),
 			environments: [],
 			dynamicTools: [],
 			experimentalRawEvents: true,
@@ -129,16 +96,6 @@ 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));
@@ -154,8 +111,6 @@ 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,
@@ -167,32 +122,21 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			requestCleanup();
 			cleanup();
 		}
-	} catch (error) {
-		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 (retrySelection) return await runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt + 1, {
-		deadline,
-		timeoutMs: totalTimeoutMs
-	});
-	throw new Error("Codex bounded turn selection retry exited unexpectedly");
 }
-function resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames) {
+function resolveBoundedThreadConfig(params, workspace) {
 	const boundedConfig = mergeCodexThreadConfigs(CODEX_BOUNDED_THREAD_CONFIG, params.threadConfig) ?? CODEX_BOUNDED_THREAD_CONFIG;
-	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;
+	return workspace.codexHome ? mergeCodexThreadConfigs(boundedConfig, CODEX_PRIVATE_BOUNDED_THREAD_CONFIG) ?? boundedConfig : boundedConfig;
 }
 function buildPrivateCodexAppServerStartOptions(start, codexHome) {
-	const privateEnv = Object.fromEntries(Object.entries(start.env ?? {}).filter(([name]) => name.trim().toUpperCase() !== CODEX_APP_SERVER_ARGS_ENV_KEY));
+	const privateEnv = Object.fromEntries(Object.entries(start.env ?? {}).filter(([name]) => name.trim().toUpperCase() !== OPENCLAW_CODEX_APP_SERVER_ARGS_ENV_VAR));
 	const clearEnv = (start.clearEnv ?? []).filter((name) => {
 		const normalized = name.trim().toUpperCase();
-		return normalized !== "CODEX_HOME" && normalized !== CODEX_APP_SERVER_ARGS_ENV_KEY;
+		return normalized !== "CODEX_HOME" && normalized !== OPENCLAW_CODEX_APP_SERVER_ARGS_ENV_VAR;
 	});
 	return {
 		...start,
@@ -201,7 +145,7 @@ function buildPrivateCodexAppServerStartOptions(start, codexHome) {
 			...privateEnv,
 			CODEX_HOME: codexHome
 		},
-		clearEnv: [...clearEnv, CODEX_APP_SERVER_ARGS_ENV_KEY]
+		clearEnv: [...clearEnv, OPENCLAW_CODEX_APP_SERVER_ARGS_ENV_VAR]
 	};
 }
 function createCodexBoundedApprovalHandler(taskLabel) {
@@ -222,14 +166,15 @@ function createCodexBoundedApprovalHandler(taskLabel) {
 	};
 }
 async function resolveCodexBoundedTurnModel(params) {
-	const listed = readModelListResult(await params.client.request("model/list", {
+	const result = await params.client.request("model/list", {
 		limit: null,
 		cursor: null,
 		includeHidden: false
 	}, {
 		timeoutMs: Math.min(params.timeoutMs, 5e3),
 		signal: params.signal
-	})).models;
+	});
+	const listed = readModelListResult(result).models;
 	if (params.selection.mode === "live-default") {
 		const supported = listed.filter((entry) => params.requiredModalities.every((modality) => entry.inputModalities.includes(modality)));
 		const selected = supported.find((entry) => entry.isDefault) ?? supported[0];
@@ -247,7 +192,6 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 	let turnId;
 	let completedTurn;
 	let promptError;
-	let responseUsage;
 	const pending = [];
 	const completedItems = /* @__PURE__ */ new Map();
 	const assistantTextByItem = /* @__PURE__ */ new Map();
@@ -283,18 +227,12 @@ 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?.();
 		}
@@ -313,7 +251,6 @@ 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();
@@ -321,8 +258,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 			if (!text) throw new Error(`Codex app-server ${taskLabel} turn returned no text.`);
 			return {
 				text,
-				items,
-				...responseUsage ? { usage: responseUsage } : {}
+				items
 			};
 		}
 	};
@@ -365,4 +301,169 @@ function isTerminalTurn(turn) {
 	return turn.status === "completed" || turn.status === "interrupted" || turn.status === "failed";
 }
 //#endregion
-export { runBoundedCodexAppServerTurn as t };
+//#region extensions/codex/media-understanding-provider.ts
+/**
+* Codex-backed media understanding provider for bounded image description and
+* structured extraction turns.
+*/
+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.";
+/**
+* Builds the media-understanding provider that delegates image tasks to an
+* isolated Codex app-server session.
+*/
+function buildCodexMediaUnderstandingProvider(options = {}) {
+	return {
+		id: CODEX_PROVIDER_ID,
+		capabilities: ["image"],
+		...DEFAULT_CODEX_IMAGE_MODEL ? { 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 };

package/dist/{models-BA01NEez.js → .setup/models-C_aZk03A.mjs}

@@ -1,10 +1,16 @@
-import { c as readCodexModelListResponse } from "./protocol-validators-Dm4eXZmt.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { s as readCodexModelListResponse } from "./protocol-validators-dZQ-UTOa.mjs";
 import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 /**
 * Lists and normalizes models exposed by the Codex app-server `model/list`
 * endpoint, including pagination and shared-client lease handling.
 */
+var models_exports = /* @__PURE__ */ __exportAll({
+	listAllCodexAppServerModels: () => listAllCodexAppServerModels,
+	listCodexAppServerModels: () => listCodexAppServerModels,
+	readModelListResult: () => readModelListResult
+});
 /** Lists one Codex app-server model page using the configured auth/client options. */
 async function listCodexAppServerModels(options = {}) {
 	return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => requestModelListPage(client, {
@@ -40,19 +46,17 @@ async function listAllCodexAppServerModels(options = {}) {
 async function withCodexAppServerModelClient(options, run) {
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-BVKE40c-.js").then((n) => n.p);
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-B2KmLPRw.mjs").then((n) => n.c);
 	const client = useSharedClient ? await getLeasedSharedCodexAppServerClient({
 		startOptions: options.startOptions,
 		timeoutMs,
 		authProfileId: options.authProfileId,
-		authRequirement: options.authRequirement,
 		agentDir: options.agentDir,
 		config: options.config
 	}) : await createIsolatedCodexAppServerClient({
 		startOptions: options.startOptions,
 		timeoutMs,
 		authProfileId: options.authProfileId,
-		authRequirement: options.authRequirement,
 		agentDir: options.agentDir,
 		config: options.config
 	});
@@ -101,7 +105,8 @@ function readCodexModel(value) {
 	};
 }
 function readReasoningEfforts(value) {
-	return uniqueStrings(value.map((entry) => readNonEmptyString(entry.reasoningEffort)).filter((entry) => entry !== void 0));
+	const efforts = value.map((entry) => readNonEmptyString(entry.reasoningEffort)).filter((entry) => entry !== void 0);
+	return uniqueStrings(efforts);
 }
 function readNonEmptyString(value) {
 	if (typeof value !== "string") return;
@@ -111,4 +116,4 @@ function normalizeMaxPages(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;
 }
 //#endregion
-export { listCodexAppServerModels as n, readModelListResult as r, listAllCodexAppServerModels as t };
+export { readModelListResult as i, listCodexAppServerModels as n, models_exports as r, listAllCodexAppServerModels as t };

package/dist/.setup/notification-correlation-iYs4WieS.mjs

@@ -0,0 +1,35 @@
+import { r as isJsonObject } from "./protocol-2POPqAY4.mjs";
+//#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 canonical top-level or nested thread payloads.
+* The generated v2 schemas require top-level `threadId` on turn/item-scoped
+* notifications and define `Turn` without one, so `turn.threadId` is not a
+* wire shape and is deliberately not read here.
+*/
+function readCodexNotificationThreadId(record) {
+	const thread = isJsonObject(record.thread) ? record.thread : void 0;
+	return readString(record, "threadId") ?? (thread ? readString(thread, "id") : void 0);
+}
+/** Reads a turn id from either top-level notification params or nested turn payloads. */
+function readCodexNotificationTurnId(record) {
+	return readNestedTurnId(record) ?? readString(record, "turnId");
+}
+function readNestedTurnId(record) {
+	const turn = record.turn;
+	return isJsonObject(turn) ? readString(turn, "id") : void 0;
+}
+function readString(record, key) {
+	const value = record[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+//#endregion
+export { readCodexNotificationThreadId as n, readCodexNotificationTurnId as r, isCodexNotificationForTurn as t };

package/dist/.setup/plugin-app-cache-key-DR8jV9oS.mjs

@@ -0,0 +1,99 @@
+import { K as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-u6CZdOOH.mjs";
+import { u as CodexAppServerRpcError, x as resolveCodexAppServerHomeDir } from "./shared-client-B2KmLPRw.mjs";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { OPENCLAW_VERSION } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
+//#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",
+	readThread: "thread/read",
+	rateLimits: "account/rateLimits/read",
+	archiveThread: "thread/archive",
+	renameThread: "thread/name/set",
+	resumeThread: "thread/resume",
+	review: "review/start",
+	unarchiveThread: "thread/unarchive"
+};
+/** 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
+//#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.
+*/
+const require = createRequire(import.meta.url);
+const CODEX_PLUGIN_VERSION = readPluginPackageVersion({ require });
+/** Builds the full app inventory cache key for Codex plugin/app discovery. */
+function buildCodexPluginAppCacheKey(params) {
+	return buildCodexAppInventoryCacheKey({
+		codexHome: params.runtimeIdentity?.codexHome ?? resolveCodexPluginAppCacheCodexHome(params.appServer, params.agentDir),
+		endpoint: resolveCodexPluginAppCacheEndpoint(params.appServer),
+		authProfileId: params.authProfileId,
+		accountId: params.accountId,
+		envApiKeyFingerprint: params.envApiKeyFingerprint,
+		appServerVersion: params.appServerVersion ?? params.runtimeIdentity?.serverVersion,
+		runtimeIdentity: params.runtimeIdentity
+	}, OPENCLAW_VERSION, CODEX_PLUGIN_VERSION);
+}
+/** Builds a durable thread-binding fingerprint for one initialized app-server runtime. */
+function buildCodexAppServerRuntimeFingerprint(params) {
+	return JSON.stringify({
+		endpoint: resolveCodexPluginAppCacheEndpoint(params.appServer),
+		connectionClass: params.appServer.connectionClass,
+		remoteWorkspaceRoot: params.appServer.remoteWorkspaceRoot ?? null,
+		appServerVersion: params.appServerVersion ?? params.runtimeIdentity?.serverVersion ?? null,
+		runtimeIdentity: params.runtimeIdentity ?? null
+	});
+}
+/** Serializes app-server endpoint identity, including credential fingerprints. */
+function resolveCodexPluginAppCacheEndpoint(appServer) {
+	return JSON.stringify({
+		transport: appServer.start.transport,
+		command: appServer.start.command,
+		args: appServer.start.args,
+		url: appServer.start.url ?? null,
+		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;
+	return appServer.start.transport === "stdio" && agentDir ? resolveCodexAppServerHomeDir(agentDir) : void 0;
+}
+function fingerprintCodexPluginAppCacheCredentials(startOptions) {
+	const authToken = startOptions.authToken ?? "";
+	const headers = Object.entries(startOptions.headers).map(([key, value]) => [key.toLowerCase(), value]).toSorted(([left], [right]) => left.localeCompare(right));
+	if (!authToken && headers.length === 0) return null;
+	const hash = createHash("sha256");
+	hash.update("openclaw:codex:plugin-app-cache-credentials:v1");
+	hash.update("\0");
+	hash.update(authToken);
+	for (const [key, value] of headers) {
+		hash.update("\0");
+		hash.update(key);
+		hash.update("\0");
+		hash.update(value);
+	}
+	return `sha256:${hash.digest("hex")}`;
+}
+//#endregion
+export { describeControlFailure as i, buildCodexPluginAppCacheKey as n, CODEX_CONTROL_METHODS as r, buildCodexAppServerRuntimeFingerprint as t };

package/dist/.setup/protocol-2POPqAY4.mjs

@@ -0,0 +1,13 @@
+//#region extensions/codex/src/app-server/protocol.ts
+function flattenCodexDynamicToolFunctions(tools) {
+	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
+}
+const CODEX_INTERACTIVE_THREAD_SOURCE_KINDS = ["cli", "vscode"];
+function isJsonObject(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isRpcResponse(message) {
+	return "id" in message && !("method" in message);
+}
+//#endregion
+export { isRpcResponse as i, flattenCodexDynamicToolFunctions as n, isJsonObject as r, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as t };