@openclaw/codex 2026.5.16-beta.4 → 2026.5.16-beta.6

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.4",
+  "version": "2026.5.16-beta.6",
   "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.4"
+      "pluginApi": ">=2026.5.16-beta.6"
     },
     "build": {
-      "openclawVersion": "2026.5.16-beta.4"
+      "openclawVersion": "2026.5.16-beta.6"
     },
     "release": {
       "publishToClawHub": true,
@@ -45,7 +45,7 @@
     "openclaw.plugin.json"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.5.16-beta.4"
+    "openclaw": ">=2026.5.16-beta.6"
   },
   "peerDependenciesMeta": {
     "openclaw": {