@openclaw/codex 2026.5.20-beta.2 → 2026.5.22

package/dist/dynamic-tools-DA42no4X.js

@@ -0,0 +1,497 @@
+import { C as sanitizeInlineImageDataUrl, x as invalidInlineImageText } from "./thread-lifecycle-4Ul7RoW4.js";
+import { HEARTBEAT_RESPONSE_TOOL_NAME, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, extractToolResultMediaArtifact, filterToolResultMediaUrls, isMessagingTool, isMessagingToolSendAction, isToolWrappedWithBeforeToolCallHook, normalizeHeartbeatToolResponse, runAgentHarnessAfterToolCallHook, setBeforeToolCallDiagnosticsEnabled, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
+//#region extensions/codex/src/app-server/dynamic-tool-profile.ts
+const CODEX_APP_SERVER_OWNED_DYNAMIC_TOOL_EXCLUDES = [
+	"read",
+	"write",
+	"edit",
+	"apply_patch",
+	"exec",
+	"process",
+	"update_plan",
+	"tool_call",
+	"tool_describe",
+	"tool_search",
+	"tool_search_code"
+];
+const DYNAMIC_TOOL_NAME_ALIASES = {
+	bash: "exec",
+	"apply-patch": "apply_patch"
+};
+function normalizeCodexDynamicToolName(name) {
+	const normalized = name.trim().toLowerCase();
+	return DYNAMIC_TOOL_NAME_ALIASES[normalized] ?? normalized;
+}
+function isForcedPrivateQaCodexRuntime(env = process.env) {
+	return env.OPENCLAW_BUILD_PRIVATE_QA === "1" && env.OPENCLAW_QA_FORCE_RUNTIME?.trim().toLowerCase() === "codex";
+}
+function resolveCodexDynamicToolsLoading(config, env = process.env) {
+	return isForcedPrivateQaCodexRuntime(env) ? "direct" : config.codexDynamicToolsLoading ?? "searchable";
+}
+function filterCodexDynamicTools(tools, config, env = process.env) {
+	const excludes = /* @__PURE__ */ new Set();
+	if (!isForcedPrivateQaCodexRuntime(env)) for (const name of CODEX_APP_SERVER_OWNED_DYNAMIC_TOOL_EXCLUDES) excludes.add(name);
+	for (const name of config.codexDynamicToolsExclude ?? []) {
+		const trimmed = normalizeCodexDynamicToolName(name);
+		if (trimmed) excludes.add(trimmed);
+	}
+	return excludes.size === 0 ? tools : tools.filter((tool) => !excludes.has(normalizeCodexDynamicToolName(tool.name)));
+}
+//#endregion
+//#region extensions/codex/src/app-server/dynamic-tools.ts
+const CODEX_OPENCLAW_DYNAMIC_TOOL_NAMESPACE = "openclaw";
+const ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES = new Set(["sessions_yield"]);
+const DEFAULT_CODEX_DYNAMIC_TOOL_RESULT_MAX_CHARS = 16e3;
+function createCodexDynamicToolBridge(params) {
+	const toolResultHookContext = toToolResultHookContext(params.hookContext);
+	const toolResultMaxChars = resolveCodexDynamicToolResultMaxChars(params.hookContext);
+	const tools = params.tools.map((tool) => {
+		if (isToolWrappedWithBeforeToolCallHook(tool)) {
+			setBeforeToolCallDiagnosticsEnabled(tool, false);
+			return tool;
+		}
+		return wrapToolWithBeforeToolCallHook(tool, params.hookContext, { emitDiagnostics: false });
+	});
+	const toolMap = new Map(tools.map((tool) => [tool.name, tool]));
+	const registeredTools = params.registeredTools ?? tools;
+	const registeredToolNames = new Set(registeredTools.map((tool) => tool.name));
+	const telemetry = {
+		didSendViaMessagingTool: false,
+		messagingToolSentTexts: [],
+		messagingToolSentMediaUrls: [],
+		messagingToolSentTargets: [],
+		messagingToolSourceReplyPayloads: [],
+		toolMediaUrls: [],
+		toolAudioAsVoice: false
+	};
+	const middlewareRunner = createAgentToolResultMiddlewareRunner({
+		runtime: "codex",
+		...toolResultHookContext
+	});
+	const legacyExtensionRunner = createCodexAppServerToolResultExtensionRunner(toolResultHookContext);
+	const directToolNames = new Set([...ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES, ...params.directToolNames ?? []]);
+	return {
+		availableSpecs: tools.map((tool) => createCodexDynamicToolSpec({
+			tool,
+			loading: params.loading ?? "searchable",
+			directToolNames
+		})),
+		specs: registeredTools.map((tool) => createCodexDynamicToolSpec({
+			tool,
+			loading: params.loading ?? "searchable",
+			directToolNames
+		})),
+		telemetry,
+		handleToolCall: async (call, options) => {
+			const tool = toolMap.get(call.tool);
+			if (!tool) {
+				if (registeredToolNames.has(call.tool)) return {
+					contentItems: [{
+						type: "inputText",
+						text: `OpenClaw tool is not available for this turn: ${call.tool}`
+					}],
+					success: false
+				};
+				return {
+					contentItems: [{
+						type: "inputText",
+						text: `Unknown OpenClaw tool: ${call.tool}`
+					}],
+					success: false
+				};
+			}
+			const args = jsonObjectToRecord(call.arguments);
+			const startedAt = Date.now();
+			const signal = composeAbortSignals(params.signal, options?.signal);
+			let didStartExecution = false;
+			try {
+				const preparedArgs = tool.prepareArguments ? tool.prepareArguments(args) : args;
+				didStartExecution = true;
+				const rawResult = await tool.execute(call.callId, preparedArgs, signal);
+				const rawIsError = isToolResultError(rawResult);
+				const middlewareResult = await middlewareRunner.applyToolResultMiddleware({
+					threadId: call.threadId,
+					turnId: call.turnId,
+					toolCallId: call.callId,
+					toolName: tool.name,
+					args,
+					isError: rawIsError,
+					result: rawResult
+				});
+				const result = await legacyExtensionRunner.applyToolResultExtensions({
+					threadId: call.threadId,
+					turnId: call.turnId,
+					toolCallId: call.callId,
+					toolName: tool.name,
+					args,
+					result: middlewareResult
+				});
+				const resultIsError = rawIsError || isToolResultError(result);
+				collectToolTelemetry({
+					toolName: tool.name,
+					args,
+					result,
+					mediaTrustResult: rawResult,
+					telemetry,
+					isError: resultIsError
+				});
+				runAgentHarnessAfterToolCallHook({
+					toolName: tool.name,
+					toolCallId: call.callId,
+					runId: toolResultHookContext.runId,
+					agentId: toolResultHookContext.agentId,
+					sessionId: toolResultHookContext.sessionId,
+					sessionKey: toolResultHookContext.sessionKey,
+					channelId: toolResultHookContext.channelId,
+					startArgs: args,
+					result,
+					startedAt
+				});
+				const terminalType = inferToolResultDiagnosticTerminalType(result, resultIsError);
+				const response = withDiagnosticTerminalType({
+					contentItems: convertToolContents(result.content, toolResultMaxChars),
+					success: !resultIsError
+				}, terminalType);
+				withDynamicToolTermination(response, rawResult.terminate === true || result.terminate === true || isToolResultYield(rawResult) || isToolResultYield(result));
+				return withSideEffectEvidence(response, terminalType !== "blocked");
+			} catch (error) {
+				collectToolTelemetry({
+					toolName: tool.name,
+					args,
+					result: void 0,
+					telemetry,
+					isError: true
+				});
+				runAgentHarnessAfterToolCallHook({
+					toolName: tool.name,
+					toolCallId: call.callId,
+					runId: toolResultHookContext.runId,
+					agentId: toolResultHookContext.agentId,
+					sessionId: toolResultHookContext.sessionId,
+					sessionKey: toolResultHookContext.sessionKey,
+					channelId: toolResultHookContext.channelId,
+					startArgs: args,
+					error: error instanceof Error ? error.message : String(error),
+					startedAt
+				});
+				return withSideEffectEvidence(withDiagnosticTerminalType({
+					contentItems: [{
+						type: "inputText",
+						text: error instanceof Error ? error.message : String(error)
+					}],
+					success: false
+				}, "error"), didStartExecution);
+			}
+		}
+	};
+}
+function createCodexDynamicToolSpec(params) {
+	const base = {
+		name: params.tool.name,
+		description: params.tool.description,
+		inputSchema: toJsonValue(params.tool.parameters)
+	};
+	if (params.loading === "direct" || params.directToolNames.has(params.tool.name)) return base;
+	return {
+		...base,
+		namespace: CODEX_OPENCLAW_DYNAMIC_TOOL_NAMESPACE,
+		deferLoading: true
+	};
+}
+function toToolResultHookContext(ctx) {
+	const { agentId, sessionId, sessionKey, runId, channelId } = ctx ?? {};
+	return {
+		...agentId && { agentId },
+		...sessionId && { sessionId },
+		...sessionKey && { sessionKey },
+		...runId && { runId },
+		...channelId && { channelId }
+	};
+}
+function resolveCodexDynamicToolResultMaxChars(ctx) {
+	return resolveAgentContextLimitValue({
+		config: ctx?.config,
+		agentId: ctx?.agentId,
+		key: "toolResultMaxChars"
+	}) ?? DEFAULT_CODEX_DYNAMIC_TOOL_RESULT_MAX_CHARS;
+}
+function resolveAgentContextLimitValue(params) {
+	const agents = readRecord(params.config?.agents);
+	const defaultValue = readPositiveInteger(readRecord(readRecord(agents?.defaults)?.contextLimits)?.[params.key]);
+	if (!params.agentId) return defaultValue;
+	const list = agents?.list;
+	if (!Array.isArray(list)) return defaultValue;
+	const normalizedAgentId = normalizeAgentId(params.agentId);
+	return readPositiveInteger(readRecord(readRecord(list.find((entry) => {
+		const entryId = readRecord(entry)?.id;
+		return typeof entryId === "string" && normalizeAgentId(entryId) === normalizedAgentId;
+	}))?.contextLimits)?.[params.key]) ?? defaultValue;
+}
+function composeAbortSignals(...signals) {
+	const activeSignals = signals.filter((signal) => Boolean(signal));
+	if (activeSignals.length === 0) return new AbortController().signal;
+	if (activeSignals.length === 1) return activeSignals[0];
+	return AbortSignal.any(activeSignals);
+}
+function collectToolTelemetry(params) {
+	if (params.isError) return;
+	if (!params.isError && params.toolName === "cron" && isCronAddAction(params.args)) params.telemetry.successfulCronAdds = (params.telemetry.successfulCronAdds ?? 0) + 1;
+	if (!params.isError && params.toolName === HEARTBEAT_RESPONSE_TOOL_NAME) {
+		const response = normalizeHeartbeatToolResponse(params.result?.details);
+		if (response) params.telemetry.heartbeatToolResponse = response;
+	}
+	if (!params.isError && params.result) {
+		const media = extractToolResultMediaArtifact(params.result);
+		if (media) {
+			const mediaUrls = filterToolResultMediaUrls(params.toolName, media.mediaUrls, params.mediaTrustResult ?? params.result);
+			const seen = new Set(params.telemetry.toolMediaUrls);
+			for (const mediaUrl of mediaUrls) if (!seen.has(mediaUrl)) {
+				seen.add(mediaUrl);
+				params.telemetry.toolMediaUrls.push(mediaUrl);
+			}
+			if (media.audioAsVoice) params.telemetry.toolAudioAsVoice = true;
+		}
+	}
+	if (!isMessagingTool(params.toolName) || !isMessagingToolSendAction(params.toolName, params.args)) return;
+	params.telemetry.didSendViaMessagingTool = true;
+	const sourceReplyPayload = extractInternalSourceReplyPayload(params.result?.details);
+	if (sourceReplyPayload) {
+		params.telemetry.messagingToolSourceReplyPayloads.push(sourceReplyPayload);
+		return;
+	}
+	const text = readFirstString(params.args, [
+		"text",
+		"message",
+		"body",
+		"content"
+	]);
+	if (text) params.telemetry.messagingToolSentTexts.push(text);
+	const mediaUrls = collectMediaUrls(params.args);
+	params.telemetry.messagingToolSentMediaUrls.push(...mediaUrls);
+	params.telemetry.messagingToolSentTargets.push({
+		tool: params.toolName,
+		provider: readFirstString(params.args, ["provider", "channel"]) ?? params.toolName,
+		accountId: readFirstString(params.args, ["accountId", "account_id"]),
+		to: readFirstString(params.args, [
+			"to",
+			"target",
+			"recipient"
+		]),
+		threadId: readFirstString(params.args, [
+			"threadId",
+			"thread_id",
+			"messageThreadId"
+		]),
+		...text ? { text } : {},
+		...mediaUrls.length > 0 ? { mediaUrls } : {}
+	});
+}
+function extractInternalSourceReplyPayload(details) {
+	if (!isRecord(details) || details.sourceReplySink !== "internal-ui") return;
+	const rawPayload = details.sourceReply;
+	if (!isRecord(rawPayload)) return;
+	const text = readFirstString(rawPayload, ["text", "message"]);
+	const mediaUrls = collectMediaUrls(rawPayload);
+	const mediaUrl = typeof rawPayload.mediaUrl === "string" && rawPayload.mediaUrl.trim() ? rawPayload.mediaUrl.trim() : mediaUrls[0];
+	const payload = {
+		...text ? { text } : {},
+		...mediaUrl ? { mediaUrl } : {},
+		...mediaUrls.length > 0 ? { mediaUrls } : {},
+		...rawPayload.audioAsVoice === true ? { audioAsVoice: true } : {},
+		...isRecord(rawPayload.presentation) ? { presentation: rawPayload.presentation } : {},
+		...isRecord(rawPayload.interactive) ? { interactive: rawPayload.interactive } : {},
+		...isRecord(rawPayload.channelData) ? { channelData: rawPayload.channelData } : {},
+		...typeof details.idempotencyKey === "string" && details.idempotencyKey.trim() ? { idempotencyKey: details.idempotencyKey.trim() } : {}
+	};
+	return text || mediaUrls.length > 0 || payload.presentation || payload.interactive ? payload : void 0;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readRecord(value) {
+	return isRecord(value) ? value : void 0;
+}
+function readPositiveInteger(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return;
+	return Math.floor(value);
+}
+function isToolResultError(result) {
+	const details = result.details;
+	if (!isRecord(details)) return false;
+	if (details.timedOut === true) return true;
+	if (typeof details.exitCode === "number" && details.exitCode !== 0) return true;
+	if (typeof details.status !== "string") return false;
+	const status = details.status.trim().toLowerCase();
+	return status !== "" && status !== "0" && status !== "ok" && status !== "success" && status !== "completed" && status !== "recorded" && status !== "pending" && status !== "started" && status !== "running" && status !== "yielded";
+}
+function isToolResultYield(result) {
+	const details = result.details;
+	if (!isRecord(details) || typeof details.status !== "string") return false;
+	return details.status.trim().toLowerCase() === "yielded";
+}
+function inferToolResultDiagnosticTerminalType(result, isError) {
+	const details = result.details;
+	if (isRecord(details) && typeof details.status === "string") {
+		if (details.status.trim().toLowerCase() === "blocked") return "blocked";
+	}
+	return isError ? "error" : "completed";
+}
+function withDiagnosticTerminalType(response, terminalType) {
+	Object.defineProperty(response, "diagnosticTerminalType", {
+		configurable: true,
+		enumerable: false,
+		value: terminalType
+	});
+	return response;
+}
+function withSideEffectEvidence(response, sideEffectEvidence) {
+	if (!sideEffectEvidence) return response;
+	Object.defineProperty(response, "sideEffectEvidence", {
+		configurable: true,
+		enumerable: false,
+		value: true
+	});
+	return response;
+}
+function withDynamicToolTermination(response, terminate) {
+	if (!terminate) return response;
+	Object.defineProperty(response, "terminate", {
+		configurable: true,
+		enumerable: false,
+		value: true
+	});
+	return response;
+}
+function normalizeToolResultMaxChars(maxChars) {
+	return typeof maxChars === "number" && Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : DEFAULT_CODEX_DYNAMIC_TOOL_RESULT_MAX_CHARS;
+}
+function convertToolContents(content, toolResultMaxChars = DEFAULT_CODEX_DYNAMIC_TOOL_RESULT_MAX_CHARS) {
+	const maxChars = normalizeToolResultMaxChars(toolResultMaxChars);
+	const totalTextChars = content.reduce((total, item) => total + (item.type === "text" ? item.text.length : 0), 0);
+	if (totalTextChars <= maxChars) return content.flatMap(convertToolContent);
+	const noticeText = `...(OpenClaw truncated dynamic tool result: original ${totalTextChars} chars, showing ${maxChars}; rerun with narrower args.)`;
+	const notice = `\n${noticeText}`;
+	let remainingTextBudget = Math.max(0, maxChars - notice.length);
+	let appendedNotice = false;
+	const output = [];
+	for (const item of content) {
+		if (item.type !== "text") {
+			output.push(...convertToolContent(item));
+			continue;
+		}
+		if (appendedNotice) continue;
+		if (notice.length >= maxChars) {
+			output.push({
+				type: "inputText",
+				text: noticeText.slice(0, maxChars)
+			});
+			appendedNotice = true;
+			continue;
+		}
+		const sliceLength = Math.min(item.text.length, remainingTextBudget);
+		remainingTextBudget -= sliceLength;
+		const shouldAppendNotice = remainingTextBudget <= 0;
+		const text = item.text.slice(0, sliceLength);
+		if (shouldAppendNotice) {
+			output.push({
+				type: "inputText",
+				text: `${text.trimEnd()}${notice}`.slice(0, maxChars)
+			});
+			appendedNotice = true;
+		} else if (text.length > 0) output.push({
+			type: "inputText",
+			text
+		});
+	}
+	if (!appendedNotice) output.push({
+		type: "inputText",
+		text: noticeText.slice(0, maxChars)
+	});
+	return output;
+}
+function convertToolContent(content) {
+	if (content.type === "text") return [{
+		type: "inputText",
+		text: content.text
+	}];
+	const imageUrl = sanitizeInlineImageDataUrl(`data:${content.mimeType};base64,${content.data}`);
+	if (!imageUrl) return [{
+		type: "inputText",
+		text: invalidInlineImageText("codex dynamic tool")
+	}];
+	return [{
+		type: "inputImage",
+		imageUrl
+	}];
+}
+function toJsonValue(value) {
+	try {
+		const text = JSON.stringify(value);
+		if (!text) return {};
+		return JSON.parse(text);
+	} catch {
+		return {};
+	}
+}
+function jsonObjectToRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return value;
+}
+function readFirstString(record, keys) {
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+		if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	}
+}
+function collectMediaUrls(record) {
+	const urls = [];
+	const pushMediaUrl = (value) => {
+		if (typeof value === "string" && value.trim()) urls.push(value.trim());
+	};
+	const pushAttachment = (value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return;
+		const attachment = value;
+		for (const key of [
+			"media",
+			"mediaUrl",
+			"path",
+			"filePath",
+			"fileUrl",
+			"url"
+		]) pushMediaUrl(attachment[key]);
+	};
+	for (const key of [
+		"media",
+		"mediaUrl",
+		"media_url",
+		"path",
+		"filePath",
+		"fileUrl",
+		"imageUrl",
+		"image_url"
+	]) {
+		const value = record[key];
+		pushMediaUrl(value);
+	}
+	for (const key of [
+		"mediaUrls",
+		"media_urls",
+		"imageUrls",
+		"image_urls"
+	]) {
+		const value = record[key];
+		if (!Array.isArray(value)) continue;
+		for (const entry of value) pushMediaUrl(entry);
+	}
+	const attachments = record.attachments;
+	if (Array.isArray(attachments)) for (const attachment of attachments) pushAttachment(attachment);
+	return urls;
+}
+function isCronAddAction(args) {
+	const action = args.action;
+	return typeof action === "string" && action.trim().toLowerCase() === "add";
+}
+//#endregion
+export { resolveCodexDynamicToolsLoading as a, normalizeCodexDynamicToolName as i, filterCodexDynamicTools as n, isForcedPrivateQaCodexRuntime as r, createCodexDynamicToolBridge as t };

package/dist/harness.js

@@ -1,10 +1,20 @@
 //#region extensions/codex/harness.ts
 const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = new Set(["codex"]);
+const CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES = [
+	"bootstrap",
+	"assemble-before-prompt",
+	"after-turn",
+	"maintain",
+	"compact",
+	"runtime-llm-complete",
+	"thread-bootstrap-projection"
+];
 function createCodexAppServerAgentHarness(options) {
 	const providerIds = new Set([...options?.providerIds ?? DEFAULT_CODEX_HARNESS_PROVIDER_IDS].map((id) => id.trim().toLowerCase()));
 	return {
 		id: options?.id ?? "codex",
 		label: options?.label ?? "Codex agent harness",
+		contextEngineHostCapabilities: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES,
 		deliveryDefaults: { sourceVisibleReplies: "message_tool" },
 		supports: (ctx) => {
 			const provider = ctx.provider.trim().toLowerCase();
@@ -18,31 +28,31 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-CRHVB240.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-DzlLXP5Y.js");
 			return runCodexAppServerAttempt(params, {
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
 				nativeHookRelay: { enabled: true }
 			});
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-DlJAUYst.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-DzP1wClA.js");
 			return runCodexAppServerSideQuestion(params, {
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
 				nativeHookRelay: { enabled: true }
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-BaSDurdH.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-BwQn7jKq.js");
 			return maybeCompactCodexAppServerSession(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		reset: async (params) => {
 			if (params.sessionFile) {
-				const { clearCodexAppServerBinding } = await import("./session-binding-DEiYHgJ_.js").then((n) => n.a);
+				const { clearCodexAppServerBinding } = await import("./session-binding-Bw_mfIW2.js").then((n) => n.a);
 				await clearCodexAppServerBinding(params.sessionFile);
 			}
 		},
 		dispose: async () => {
-			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-DCxJx5QU.js").then((n) => n.a);
+			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-C_RbGxW8.js").then((n) => n.a);
 			await clearSharedCodexAppServerClientAndWait();
 		}
 	};

package/dist/index.js

@@ -1,12 +1,12 @@
 import { createCodexAppServerAgentHarness } from "./harness.js";
-import { c as resolveCodexAppServerRuntimeOptions, s as readCodexPluginConfig, t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-DqIp6oTk.js";
-import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
+import { c as readCodexPluginConfig, l as resolveCodexAppServerRuntimeOptions, t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-DDMrwfJl.js";
 import { buildCodexProvider } from "./provider.js";
-import { i as describeControlFailure, n as buildCodexPluginAppCacheKey, t as requestCodexAppServerJson } from "./request-BePR77QD.js";
-import { r as formatCodexDisplayText } from "./command-formatters-BVBnEgyA.js";
-import { c as resolveCodexAppServerAuthAccountCacheKey, d as resolveCodexAppServerEnvApiKeyCacheKey, i as getSharedCodexAppServerClient, n as clearSharedCodexAppServerClientIfCurrentAndWait, u as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-DCxJx5QU.js";
-import { a as resolveCodexCliSessionForBindingOnNode, c as handleCodexConversationInboundClaim, i as listCodexCliSessionsOnNode, n as createCodexCliSessionNodeInvokePolicies, o as resumeCodexCliSessionOnNode, s as handleCodexConversationBindingResolved, t as createCodexCliSessionNodeHostCommands } from "./node-cli-sessions-T1olB1SH.js";
-import { a as defaultCodexAppInventoryCache, n as pluginReadParams, t as ensureCodexPluginActivation } from "./plugin-activation-BkQkPLOY.js";
+import { _ as ensureCodexPluginActivation, b as defaultCodexAppInventoryCache, v as pluginReadParams } from "./thread-lifecycle-4Ul7RoW4.js";
+import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
+import { i as describeControlFailure, n as buildCodexPluginAppCacheKey, t as requestCodexAppServerJson } from "./request-NklFaHM4.js";
+import { s as formatCodexDisplayText } from "./notification-correlation-qKY_sgga.js";
+import { c as resolveCodexAppServerAuthAccountCacheKey, d as resolveCodexAppServerEnvApiKeyCacheKey, i as getSharedCodexAppServerClient, n as clearSharedCodexAppServerClientIfCurrentAndWait, u as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-C_RbGxW8.js";
+import { a as resolveCodexCliSessionForBindingOnNode, c as handleCodexConversationInboundClaim, i as listCodexCliSessionsOnNode, n as createCodexCliSessionNodeInvokePolicies, o as resumeCodexCliSessionOnNode, s as handleCodexConversationBindingResolved, t as createCodexCliSessionNodeHostCommands } from "./node-cli-sessions-yVCifOyG.js";
 import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
 import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
@@ -25,7 +25,7 @@ function createCodexCommand(options) {
 		description: "Inspect and control the Codex app-server harness",
 		ownership: "reserved",
 		agentPromptGuidance: [{
-			text: "Native Codex app-server plugin is available (`/codex ...`). For Codex bind/control/thread/resume/steer/stop requests, prefer `/codex bind`, `/codex threads`, `/codex resume`, `/codex steer`, and `/codex stop` over ACP.",
+			text: "Native Codex app-server plugin is available (`/codex ...`). For Codex bind/control/thread/resume/steer/stop requests, prefer `/codex bind`, `/codex threads`, `/codex resume`, `/codex steer`, and `/codex stop` over ACP. When OpenClaw sandboxing is active, native Codex execution modes are unavailable; use normal Codex harness turns.",
 			surfaces: ["pi_main"]
 		}, {
 			text: "Use ACP for Codex only when the user explicitly asks for ACP/acpx or wants to test the ACP path.",
@@ -45,7 +45,7 @@ async function handleCodexCommand(ctx, options = {}) {
 	}
 }
 async function loadDefaultCodexSubcommandHandler() {
-	const { handleCodexSubcommand } = await import("./command-handlers-Gceg_rBZ.js");
+	const { handleCodexSubcommand } = await import("./command-handlers-DsB0GYd2.js");
 	return handleCodexSubcommand;
 }
 //#endregion
@@ -1158,6 +1158,7 @@ var codex_default = definePluginEntry({
 			}
 		}));
 		api.on("inbound_claim", (event, ctx) => handleCodexConversationInboundClaim(event, ctx, {
+			config: api.runtime.config?.current?.(),
 			pluginConfig: resolveCurrentPluginConfig(),
 			resumeCodexCliSessionOnNode: (params) => resumeCodexCliSessionOnNode({
 				runtime: api.runtime,

package/dist/media-understanding-provider.js

@@ -1,8 +1,9 @@
 import { CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS } from "./provider-catalog.js";
-import { c as resolveCodexAppServerRuntimeOptions } from "./config-DqIp6oTk.js";
+import { l as resolveCodexAppServerRuntimeOptions } from "./config-DDMrwfJl.js";
 import { i as assertCodexTurnStartResponse, l as readCodexTurnCompletedNotification, o as readCodexErrorNotification, r as assertCodexThreadStartResponse } from "./protocol-validators-_gKDcd0x.js";
-import { i as readModelListResult } from "./models-C8MdOXGD.js";
+import { i as readModelListResult } from "./models-B_uo1pf5.js";
 import { t as isJsonObject } from "./protocol-oeJQu4rs.js";
+import { n as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-4Ul7RoW4.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;
@@ -62,7 +63,7 @@ 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-DCxJx5QU.js").then((n) => n.a).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+	const client = params.options.clientFactory ? await params.options.clientFactory(appServer.start, params.profile) : await import("./shared-client-C_RbGxW8.js").then((n) => n.a).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		startOptions: appServer.start,
 		timeoutMs,
 		authProfileId: params.profile
@@ -86,6 +87,8 @@ async function runBoundedCodexVisionTurn(params) {
 			sandbox: "read-only",
 			serviceName: "OpenClaw",
 			developerInstructions: params.developerInstructions,
+			config: buildCodexRuntimeThreadConfig(void 0, { nativeCodeModeEnabled: false }),
+			environments: [],
 			dynamicTools: [],
 			experimentalRawEvents: true,
 			persistExtendedHistory: false,

package/dist/{models-C8MdOXGD.js → models-B_uo1pf5.js}

@@ -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-DCxJx5QU.js").then((n) => n.a);
+	const { createIsolatedCodexAppServerClient, getSharedCodexAppServerClient } = await import("./shared-client-C_RbGxW8.js").then((n) => n.a);
 	const client = useSharedClient ? await getSharedCodexAppServerClient({
 		startOptions: options.startOptions,
 		timeoutMs,