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

package/dist/{thread-lifecycle-D2sxRPdz.js → thread-lifecycle-BbriKhTq.js}

@@ -1,13 +1,14 @@
-import { r as codexSandboxPolicyForTurn, u as resolveCodexPluginsPolicy } from "./config-3ATInASk.js";
+import { r as codexSandboxPolicyForTurn, u as resolveCodexPluginsPolicy } from "./config-B5pq6hEz.js";
 import { n as assertCodexThreadResumeResponse, r as assertCodexThreadStartResponse } from "./protocol-validators-BGBspNmF.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
 import { CODEX_GPT5_HEARTBEAT_PROMPT_OVERLAY, renderCodexPromptOverlay } from "./prompt-overlay.js";
 import { isModernCodexModel } from "./provider.js";
-import { i as isCodexAppServerConnectionClosedError } from "./client-CA7amCZ8.js";
-import { i as readCodexAppServerBinding, n as isCodexAppServerNativeAuthProfile, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-DbdVqMzW.js";
-import { a as defaultCodexAppInventoryCache, r as readCodexPluginInventory, t as ensureCodexPluginActivation } from "./plugin-activation-BDU4e-NA.js";
+import { i as isCodexAppServerConnectionClosedError } from "./client-6FkrXfaz.js";
+import { i as readCodexAppServerBinding, n as isCodexAppServerNativeAuthProfile, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-DqApZIgD.js";
+import { a as defaultCodexAppInventoryCache, r as readCodexPluginInventory, t as ensureCodexPluginActivation } from "./plugin-activation-B49xb7pI.js";
 import crypto from "node:crypto";
 import { HEARTBEAT_RESPONSE_TOOL_NAME, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractToolResultMediaArtifact, filterToolResultMediaUrls, isActiveHarnessContextEngine, isMessagingTool, isMessagingToolSendAction, isToolWrappedWithBeforeToolCallHook, normalizeHeartbeatToolResponse, runAgentHarnessAfterToolCallHook, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { buildCodexUserMcpServersThreadConfigPatch } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { redactSensitiveFieldValue, redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 //#region extensions/codex/src/app-server/dynamic-tool-profile.ts
@@ -32,9 +33,15 @@ function normalizeCodexDynamicToolName(name) {
 	const normalized = name.trim().toLowerCase();
 	return DYNAMIC_TOOL_NAME_ALIASES[normalized] ?? normalized;
 }
-function filterCodexDynamicTools(tools, config) {
+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();
-	for (const name of CODEX_APP_SERVER_OWNED_DYNAMIC_TOOL_EXCLUDES) excludes.add(name);
+	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);
@@ -42,11 +49,113 @@ function filterCodexDynamicTools(tools, config) {
 	return excludes.size === 0 ? tools : tools.filter((tool) => !excludes.has(normalizeCodexDynamicToolName(tool.name)));
 }
 //#endregion
+//#region extensions/codex/src/app-server/image-payload-sanitizer.ts
+const DATA_URL_PREFIX = "data:";
+const IMAGE_OMITTED_TEXT = "omitted image payload: invalid inline image data";
+function startsWithDataUrl(value) {
+	return value.slice(0, 5).toLowerCase() === DATA_URL_PREFIX;
+}
+function canonicalizeBase64(base64) {
+	let cleaned = "";
+	let padding = 0;
+	let sawPadding = false;
+	for (let i = 0; i < base64.length; i += 1) {
+		const code = base64.charCodeAt(i);
+		if (code <= 32) continue;
+		if (code === 61) {
+			padding += 1;
+			if (padding > 2) return;
+			sawPadding = true;
+			cleaned += "=";
+			continue;
+		}
+		if (sawPadding || !(code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 43 || code === 47)) return;
+		cleaned += base64[i];
+	}
+	if (!cleaned || cleaned.length % 4 !== 0) return;
+	return cleaned;
+}
+function sniffImageMime(buffer) {
+	if (buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10) return "image/png";
+	if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) return "image/jpeg";
+	if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") return "image/webp";
+	if (buffer.length >= 6 && (buffer.subarray(0, 6).toString("ascii") === "GIF87a" || buffer.subarray(0, 6).toString("ascii") === "GIF89a")) return "image/gif";
+}
+function sanitizeInlineImageDataUrl(imageUrl) {
+	if (!startsWithDataUrl(imageUrl)) return imageUrl;
+	const commaIndex = imageUrl.indexOf(",");
+	if (commaIndex < 0) return;
+	const metadata = imageUrl.slice(5, commaIndex);
+	const payload = imageUrl.slice(commaIndex + 1);
+	const metadataParts = metadata.split(";").map((part) => part.trim());
+	if (!(metadataParts[0]?.toLowerCase())?.startsWith("image/")) return;
+	if (!metadataParts.slice(1).some((part) => part.toLowerCase() === "base64")) return;
+	const canonicalPayload = canonicalizeBase64(payload);
+	if (!canonicalPayload) return;
+	const sniffedMimeType = sniffImageMime(Buffer.from(canonicalPayload, "base64"));
+	if (!sniffedMimeType) return;
+	return `data:${sniffedMimeType};base64,${canonicalPayload}`;
+}
+function invalidInlineImageText(label) {
+	return `[${label}] ${IMAGE_OMITTED_TEXT}`;
+}
+function isRecord$1(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function sanitizeImageContentRecord(record, label) {
+	if (record.type === "image" && typeof record.data === "string") {
+		const mimeType = typeof record.mimeType === "string" ? record.mimeType : "image/png";
+		const imageUrl = sanitizeInlineImageDataUrl(`data:${mimeType};base64,${record.data}`);
+		if (!imageUrl) return {
+			type: "text",
+			text: invalidInlineImageText(label)
+		};
+		const commaIndex = imageUrl.indexOf(",");
+		const mime = imageUrl.slice(5, commaIndex).split(";")[0] ?? mimeType;
+		return {
+			...record,
+			mimeType: mime,
+			data: imageUrl.slice(commaIndex + 1)
+		};
+	}
+	if (record.type === "inputImage" && typeof record.imageUrl === "string") {
+		const imageUrl = sanitizeInlineImageDataUrl(record.imageUrl);
+		return imageUrl ? {
+			...record,
+			imageUrl
+		} : {
+			type: "inputText",
+			text: invalidInlineImageText(label)
+		};
+	}
+	if (record.type === "input_image" && typeof record.image_url === "string") {
+		const imageUrl = sanitizeInlineImageDataUrl(record.image_url);
+		return imageUrl ? {
+			...record,
+			image_url: imageUrl
+		} : {
+			type: "input_text",
+			text: invalidInlineImageText(label)
+		};
+	}
+}
+function sanitizeCodexHistoryImagePayloads(value, label) {
+	if (Array.isArray(value)) return value.map((entry) => sanitizeCodexHistoryImagePayloads(entry, label));
+	if (!isRecord$1(value)) return value;
+	const imageRecord = sanitizeImageContentRecord(value, label);
+	if (imageRecord) return imageRecord;
+	const next = {};
+	for (const [key, child] of Object.entries(value)) next[key] = sanitizeCodexHistoryImagePayloads(child, label);
+	return next;
+}
+//#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) => isToolWrappedWithBeforeToolCallHook(tool) ? tool : wrapToolWithBeforeToolCallHook(tool, params.hookContext));
 	const toolMap = new Map(tools.map((tool) => [tool.name, tool]));
 	const telemetry = {
@@ -120,12 +229,13 @@ function createCodexDynamicToolBridge(params) {
 					agentId: toolResultHookContext.agentId,
 					sessionId: toolResultHookContext.sessionId,
 					sessionKey: toolResultHookContext.sessionKey,
+					channelId: toolResultHookContext.channelId,
 					startArgs: args,
 					result,
 					startedAt
 				});
 				return {
-					contentItems: result.content.flatMap(convertToolContent),
+					contentItems: convertToolContents(result.content, toolResultMaxChars),
 					success: !resultIsError
 				};
 			} catch (error) {
@@ -143,6 +253,7 @@ function createCodexDynamicToolBridge(params) {
 					agentId: toolResultHookContext.agentId,
 					sessionId: toolResultHookContext.sessionId,
 					sessionKey: toolResultHookContext.sessionKey,
+					channelId: toolResultHookContext.channelId,
 					startArgs: args,
 					error: error instanceof Error ? error.message : String(error),
 					startedAt
@@ -172,14 +283,34 @@ function createCodexDynamicToolSpec(params) {
 	};
 }
 function toToolResultHookContext(ctx) {
-	const { agentId, sessionId, sessionKey, runId } = ctx ?? {};
+	const { agentId, sessionId, sessionKey, runId, channelId } = ctx ?? {};
 	return {
 		...agentId && { agentId },
 		...sessionId && { sessionId },
 		...sessionKey && { sessionKey },
-		...runId && { runId }
+		...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;
@@ -261,6 +392,13 @@ function extractInternalSourceReplyPayload(details) {
 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;
@@ -270,14 +408,66 @@ function isToolResultError(result) {
 	const status = details.status.trim().toLowerCase();
 	return status !== "" && status !== "0" && status !== "ok" && status !== "success" && status !== "completed" && status !== "recorded" && status !== "running";
 }
+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: `data:${content.mimeType};base64,${content.data}`
+		imageUrl
 	}];
 }
 function toJsonValue(value) {
@@ -872,7 +1062,7 @@ async function startOrResumeThread(params) {
 		}
 	} else try {
 		const authProfileId = params.params.authProfileId ?? binding.authProfileId;
-		const resumeConfig = mergeCodexThreadConfigs(params.config, userMcpServersConfigPatch);
+		const resumeConfig = mergeCodexThreadConfigs(params.config, userMcpServersConfigPatch, params.finalConfigPatch);
 		const response = assertCodexThreadResumeResponse(await params.client.request("thread/resume", buildThreadResumeParams(params.params, {
 			threadId: binding.threadId,
 			authProfileId,
@@ -939,7 +1129,7 @@ async function startOrResumeThread(params) {
 		await clearCodexAppServerBinding(params.params.sessionFile);
 	}
 	const pluginThreadConfig = params.pluginThreadConfig?.enabled ? prebuiltPluginThreadConfig ?? await params.pluginThreadConfig.build() : void 0;
-	const config = mergeCodexThreadConfigs(params.config, userMcpServersConfigPatch, pluginThreadConfig?.configPatch);
+	const config = mergeCodexThreadConfigs(params.config, userMcpServersConfigPatch, pluginThreadConfig?.configPatch, params.finalConfigPatch);
 	const response = assertCodexThreadStartResponse(await params.client.request("thread/start", buildThreadStartParams(params.params, {
 		cwd: params.cwd,
 		dynamicTools: params.dynamicTools,
@@ -1238,14 +1428,22 @@ function renderCodexRuntimePromptOverlay(params) {
 	].filter((section) => typeof section === "string" && section.trim().length > 0).join("\n\n");
 }
 function buildUserInput(params, promptText = params.prompt) {
+	const imageInputs = (params.images ?? []).map((image) => {
+		const imageUrl = sanitizeInlineImageDataUrl(`data:${image.mimeType};base64,${image.data}`);
+		return imageUrl ? {
+			type: "image",
+			url: imageUrl
+		} : {
+			type: "text",
+			text: invalidInlineImageText("codex user input"),
+			text_elements: []
+		};
+	});
 	return [{
 		type: "text",
 		text: promptText,
 		text_elements: []
-	}, ...(params.images ?? []).map((image) => ({
-		type: "image",
-		url: `data:${image.mimeType};base64,${image.data}`
-	}))];
+	}, ...imageInputs];
 }
 function resolveCodexAppServerModelProvider(params) {
 	const normalized = params.provider.trim();
@@ -1260,4 +1458,4 @@ function resolveReasoningEffort(thinkLevel, modelId) {
 	return null;
 }
 //#endregion
-export { normalizeCodexDynamicToolName as S, projectContextEngineAssemblyForCodex as _, buildThreadResumeParams as a, createCodexDynamicToolBridge as b, codexDynamicToolsFingerprint as c, resolveReasoningEffort as d, startOrResumeThread as f, shouldBuildCodexPluginThreadConfig as g, mergeCodexThreadConfigs as h, buildDeveloperInstructions as i, isContextEngineBindingCompatible as l, buildCodexPluginThreadConfigInputFingerprint as m, buildCodexRuntimeThreadConfig as n, buildThreadStartParams as o, buildCodexPluginThreadConfig as p, buildContextEngineBinding as r, buildTurnStartParams as s, areCodexDynamicToolFingerprintsCompatible as t, resolveCodexAppServerModelProvider as u, resolveCodexContextEngineProjectionMaxChars as v, filterCodexDynamicTools as x, resolveCodexContextEngineProjectionReserveTokens as y };
+export { isForcedPrivateQaCodexRuntime as C, filterCodexDynamicTools as S, resolveCodexDynamicToolsLoading as T, projectContextEngineAssemblyForCodex as _, buildThreadResumeParams as a, createCodexDynamicToolBridge as b, codexDynamicToolsFingerprint as c, resolveReasoningEffort as d, startOrResumeThread as f, shouldBuildCodexPluginThreadConfig as g, mergeCodexThreadConfigs as h, buildDeveloperInstructions as i, isContextEngineBindingCompatible as l, buildCodexPluginThreadConfigInputFingerprint as m, buildCodexRuntimeThreadConfig as n, buildThreadStartParams as o, buildCodexPluginThreadConfig as p, buildContextEngineBinding as r, buildTurnStartParams as s, areCodexDynamicToolFingerprintsCompatible as t, resolveCodexAppServerModelProvider as u, resolveCodexContextEngineProjectionMaxChars as v, normalizeCodexDynamicToolName as w, sanitizeCodexHistoryImagePayloads as x, resolveCodexContextEngineProjectionReserveTokens as y };

package/dist/{vision-tools-Cm_YicZb.js → vision-tools-BX9YuTEK.js}

@@ -1,6 +1,7 @@
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
 import { r as formatCodexDisplayText } from "./command-formatters-BRW7_Nu7.js";
-import { callGatewayTool, embeddedAgentLog, formatApprovalDisplayPath, runBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { createHash } from "node:crypto";
+import { buildAgentHookContextChannelFields, callGatewayTool, embeddedAgentLog, formatApprovalDisplayPath, hasNativeHookRelayInvocation, invokeNativeHookRelay, runBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/plugin-approval-roundtrip.ts
 const DEFAULT_CODEX_APPROVAL_TIMEOUT_MS = 12e4;
 const MAX_PLUGIN_APPROVAL_TITLE_LENGTH = 80;
@@ -89,9 +90,10 @@ async function handleCodexAppServerApprovalRequest(params) {
 			requestParams,
 			paramsForRun: params.paramsForRun,
 			context,
+			nativeHookRelay: params.nativeHookRelay,
 			signal: params.signal
 		});
-		if (policyOutcome?.blocked) {
+		if (policyOutcome?.outcome === "denied") {
 			emitApprovalEvent(params.paramsForRun, {
 				phase: "resolved",
 				kind: context.kind,
@@ -221,6 +223,26 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 	const policyRequest = buildOpenClawToolPolicyRequest(params.method, params.requestParams);
 	if (!policyRequest) return;
 	const cwd = readString$1(params.requestParams, "cwd") ?? params.paramsForRun.workspaceDir;
+	const nativeRelayOutcome = await runNativeRelayToolPolicyForApprovalRequest({
+		method: params.method,
+		requestParams: params.requestParams,
+		context: params.context,
+		policyRequest,
+		nativeHookRelay: params.nativeHookRelay,
+		cwd
+	});
+	if (nativeRelayOutcome?.blocked) return {
+		outcome: "denied",
+		reason: nativeRelayOutcome.reason
+	};
+	if (nativeRelayOutcome?.handled) return { outcome: "no-decision" };
+	const hookChannelId = buildAgentHookContextChannelFields({
+		sessionKey: params.paramsForRun.sessionKey,
+		messageChannel: params.paramsForRun.messageChannel,
+		messageProvider: params.paramsForRun.messageProvider,
+		currentChannelId: params.paramsForRun.currentChannelId,
+		messageTo: params.paramsForRun.messageTo
+	}).channelId;
 	const outcome = await runBeforeToolCallHook({
 		toolName: policyRequest.toolName,
 		params: policyRequest.params,
@@ -234,23 +256,108 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 			...params.paramsForRun.sessionKey ? { sessionKey: params.paramsForRun.sessionKey } : {},
 			...params.paramsForRun.sessionId ? { sessionId: params.paramsForRun.sessionId } : {},
 			...params.paramsForRun.runId ? { runId: params.paramsForRun.runId } : {},
-			...params.paramsForRun.messageChannel || params.paramsForRun.messageProvider ? { channelId: params.paramsForRun.messageChannel ?? params.paramsForRun.messageProvider } : {}
+			...hookChannelId ? { channelId: hookChannelId } : {}
 		}
 	});
 	if (outcome.blocked) return {
-		blocked: true,
+		outcome: "denied",
 		reason: outcome.reason
 	};
 	if ("params" in outcome && toolPolicyParamsWereRewritten(policyRequest.params, outcome.params)) return {
-		blocked: true,
+		outcome: "denied",
 		reason: "OpenClaw tool policy rewrote Codex app-server approval params; refusing original request."
 	};
 }
+async function runNativeRelayToolPolicyForApprovalRequest(params) {
+	if (params.method !== "item/commandExecution/requestApproval" || !params.nativeHookRelay?.allowedEvents.includes("pre_tool_use")) return;
+	const payload = buildNativeRelayPreToolUsePayload({
+		requestParams: params.requestParams,
+		policyRequest: params.policyRequest,
+		context: params.context,
+		cwd: params.cwd
+	});
+	if (!payload) return;
+	if (hasNativeHookRelayInvocation({
+		relayId: params.nativeHookRelay.relayId,
+		event: "pre_tool_use",
+		toolUseId: params.context.itemId
+	})) return { handled: true };
+	try {
+		const decision = readNativeRelayPreToolUseDecision(await invokeNativeHookRelay({
+			provider: "codex",
+			relayId: params.nativeHookRelay.relayId,
+			event: "pre_tool_use",
+			rawPayload: payload
+		}));
+		if (decision.blocked) return {
+			handled: true,
+			blocked: true,
+			reason: decision.reason
+		};
+		return { handled: true };
+	} catch (error) {
+		return {
+			handled: true,
+			blocked: true,
+			reason: `OpenClaw native hook relay unavailable for Codex app-server approval: ${formatCodexDisplayText(formatErrorMessage$1(error))}`
+		};
+	}
+}
+function buildNativeRelayPreToolUsePayload(params) {
+	const command = readString$1(params.policyRequest.params, "command");
+	if (!command) return;
+	const turnId = readString$1(params.requestParams, "turnId");
+	return {
+		hook_event_name: "PreToolUse",
+		openclaw_approval_mode: "report",
+		tool_name: "exec_command",
+		...params.context.itemId ? { tool_use_id: params.context.itemId } : {},
+		...params.cwd ? { cwd: params.cwd } : {},
+		...turnId ? { turn_id: turnId } : {},
+		tool_input: {
+			...params.policyRequest.params,
+			command,
+			cmd: command
+		}
+	};
+}
+function readNativeRelayPreToolUseDecision(response) {
+	if (!response || response.exitCode !== 0) return {
+		blocked: true,
+		reason: sanitizeRelayDecisionReason(response?.stderr) || sanitizeRelayDecisionReason(response?.stdout) || "OpenClaw native hook relay failed for Codex app-server approval."
+	};
+	const stdout = response.stdout?.trim();
+	if (!stdout) return { blocked: false };
+	const parsed = parseRelayJsonResponse(stdout);
+	const output = isJsonObject(parsed?.hookSpecificOutput) ? parsed.hookSpecificOutput : void 0;
+	if (output?.permissionDecision === "deny") return {
+		blocked: true,
+		reason: readString$1(output, "permissionDecisionReason") || "OpenClaw native hook policy denied Codex app-server approval."
+	};
+	return {
+		blocked: true,
+		reason: output ? "OpenClaw native hook relay returned a non-deny Codex app-server approval decision." : "OpenClaw native hook relay returned an unreadable Codex app-server approval result."
+	};
+}
+function parseRelayJsonResponse(text) {
+	try {
+		const parsed = JSON.parse(text);
+		return isJsonObject(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function sanitizeRelayDecisionReason(value) {
+	return sanitizeApprovalPreview(value ? {
+		value,
+		clipped: false
+	} : void 0, 240).text;
+}
 function buildOpenClawToolPolicyRequest(method, requestParams) {
 	if (method === "item/commandExecution/requestApproval") {
 		const command = readPolicyCommand(requestParams);
 		return {
-			toolName: "bash",
+			toolName: "exec",
 			params: {
 				...command ? { command } : {},
 				...readString$1(requestParams, "cwd") ? { cwd: readString$1(requestParams, "cwd") } : {},
@@ -1120,10 +1227,99 @@ function readFirstString(record, keys) {
 	}
 }
 //#endregion
+//#region extensions/codex/src/app-server/native-hook-relay.ts
+const CODEX_NATIVE_HOOK_RELAY_EVENTS = [
+	"pre_tool_use",
+	"post_tool_use",
+	"permission_request",
+	"before_agent_finalize"
+];
+const CODEX_HOOK_EVENT_BY_NATIVE_EVENT = {
+	pre_tool_use: "PreToolUse",
+	post_tool_use: "PostToolUse",
+	permission_request: "PermissionRequest",
+	before_agent_finalize: "Stop"
+};
+const CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT = {
+	pre_tool_use: "pre_tool_use",
+	post_tool_use: "post_tool_use",
+	permission_request: "permission_request",
+	before_agent_finalize: "stop"
+};
+const CODEX_SESSION_FLAGS_HOOK_SOURCE_PATHS = ["/<session-flags>/config.toml", "<session-flags>/config.toml"];
+function buildCodexNativeHookRelayConfig(params) {
+	const events = params.events?.length ? params.events : CODEX_NATIVE_HOOK_RELAY_EVENTS;
+	const selectedEvents = new Set(events);
+	const config = { "features.hooks": true };
+	const hookState = {};
+	for (const event of CODEX_NATIVE_HOOK_RELAY_EVENTS) {
+		const codexEvent = CODEX_HOOK_EVENT_BY_NATIVE_EVENT[event];
+		const selected = selectedEvents.has(event);
+		if (!selected || !params.relay.shouldRelayEvent(event)) {
+			if (selected || params.clearOmittedEvents) config[`hooks.${codexEvent}`] = [];
+			if (params.clearOmittedEvents) for (const sourcePath of CODEX_SESSION_FLAGS_HOOK_SOURCE_PATHS) hookState[`${sourcePath}:${CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT[event]}:0:0`] = { enabled: false };
+			continue;
+		}
+		const command = params.relay.commandForEvent(event);
+		const timeout = normalizeHookTimeoutSec(params.hookTimeoutSec);
+		config[`hooks.${codexEvent}`] = [{ hooks: [{
+			type: "command",
+			command,
+			timeout,
+			async: false,
+			statusMessage: "OpenClaw native hook relay"
+		}] }];
+		const state = {
+			enabled: true,
+			trusted_hash: codexCommandHookTrustedHash({
+				event,
+				command,
+				timeout,
+				statusMessage: "OpenClaw native hook relay"
+			})
+		};
+		for (const sourcePath of CODEX_SESSION_FLAGS_HOOK_SOURCE_PATHS) hookState[`${sourcePath}:${CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT[event]}:0:0`] = state;
+	}
+	config["hooks.state"] = hookState;
+	return config;
+}
+function buildCodexNativeHookRelayDisabledConfig() {
+	return {
+		"features.hooks": false,
+		"hooks.PreToolUse": [],
+		"hooks.PostToolUse": [],
+		"hooks.PermissionRequest": [],
+		"hooks.Stop": []
+	};
+}
+function normalizeHookTimeoutSec(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.ceil(value) : 5;
+}
+function codexCommandHookTrustedHash(params) {
+	const identity = {
+		event_name: CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT[params.event],
+		hooks: [{
+			async: false,
+			command: params.command,
+			statusMessage: params.statusMessage,
+			timeout: params.timeout,
+			type: "command"
+		}]
+	};
+	return `sha256:${createHash("sha256").update(JSON.stringify(sortJsonValue(identity))).digest("hex")}`;
+}
+function sortJsonValue(value) {
+	if (!value || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map(sortJsonValue);
+	const sorted = {};
+	for (const key of Object.keys(value).toSorted()) sorted[key] = sortJsonValue(value[key]);
+	return sorted;
+}
+//#endregion
 //#region extensions/codex/src/app-server/vision-tools.ts
 function filterToolsForVisionInputs(tools, params) {
 	if (!params.modelHasVision || !params.hasInboundImages) return tools;
 	return tools.filter((tool) => tool.name !== "image");
 }
 //#endregion
-export { handleCodexAppServerElicitationRequest as n, handleCodexAppServerApprovalRequest as r, filterToolsForVisionInputs as t };
+export { handleCodexAppServerElicitationRequest as a, buildCodexNativeHookRelayDisabledConfig as i, CODEX_NATIVE_HOOK_RELAY_EVENTS as n, handleCodexAppServerApprovalRequest as o, buildCodexNativeHookRelayConfig as r, filterToolsForVisionInputs as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.5.16-beta.3",
+  "version": "2026.5.16-beta.5",
   "description": "OpenClaw Codex harness and model provider plugin",
   "repository": {
     "type": "git",
@@ -8,7 +8,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "0.74.0",
+    "@earendil-works/pi-coding-agent": "0.74.1",
     "@openai/codex": "0.130.0",
     "ajv": "8.20.0",
     "ws": "8.20.1",
@@ -27,10 +27,10 @@
       "minHostVersion": ">=2026.5.1-beta.1"
     },
     "compat": {
-      "pluginApi": ">=2026.5.16-beta.3"
+      "pluginApi": ">=2026.5.16-beta.5"
     },
     "build": {
-      "openclawVersion": "2026.5.16-beta.3"
+      "openclawVersion": "2026.5.16-beta.5"
     },
     "release": {
       "publishToClawHub": true,
@@ -45,7 +45,7 @@
     "openclaw.plugin.json"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.5.16-beta.3"
+    "openclaw": ">=2026.5.16-beta.5"
   },
   "peerDependenciesMeta": {
     "openclaw": {