@openclaw/codex 2026.7.2-beta.5 → 2026.7.2-beta.7

package/dist/{dynamic-tools-LIt9ojep.js → dynamic-tools-D2gYkSBO.js}

@@ -1,10 +1,11 @@
-import { V as isJsonObject, l as releaseLeasedSharedCodexAppServerClient, q as resolveCodexGatewayTimeoutWithGraceMs, z as CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE } from "./shared-client-BVKE40c-.js";
-import { T as readCodexPluginConfig } from "./session-binding-DlVQ-Pxs.js";
-import { D as isForcedPrivateQaCodexRuntime, E as filterCodexDynamicToolsWithOpenClawShell, O as isSystemAgentOnlyCodexDynamicToolAllowlist, T as filterCodexDynamicTools, et as readItem, h as resolveCodexWebSearchPlan, i as invalidInlineImageText, k as normalizeCodexDynamicToolName, o as sanitizeInlineImageDataUrl, st as readString$2, tt as readItemString } from "./thread-lifecycle-DRg_FdzC.js";
-import { l as readCodexTurn } from "./protocol-validators-Dm4eXZmt.js";
-import { r as formatCodexDisplayText } from "./command-formatters-ico4ZFnk.js";
-import { a as resolveCodexNodeExecToolOverrides, i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-D1Wky__S.js";
-import { n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-Bj_Ak_jI.js";
+import { H as CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE, W as isJsonObject, X as resolveCodexGatewayTimeoutWithGraceMs, l as releaseLeasedSharedCodexAppServerClient } from "./shared-client-DTbvH-XV.js";
+import { O as readCodexPluginConfig } from "./session-binding-BXpo9ymA.js";
+import { D as isForcedPrivateQaCodexRuntime, E as filterCodexDynamicToolsWithOpenClawShell, O as isSystemAgentOnlyCodexDynamicToolAllowlist, T as filterCodexDynamicTools, ct as readString$2, g as resolveCodexWebSearchPlan, i as invalidInlineImageText, k as normalizeCodexDynamicToolName, nt as readItemString, o as sanitizeInlineImageDataUrl, tt as readItem } from "./thread-lifecycle-DF53ogiA.js";
+import { S as readCodexTurn } from "./transcript-mirror-DzsdNCf5.js";
+import { r as formatCodexDisplayText } from "./command-formatters-C336eRVS.js";
+import { a as resolveCodexNodeExecToolOverrides, i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-NuhpXmPB.js";
+import { n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-CU6_AnOb.js";
+import path from "node:path";
 import { addTimerTimeoutGraceMs, asDateTimestampMs, finiteSecondsToTimerSafeMilliseconds, parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { HEARTBEAT_RESPONSE_TOOL_NAME, buildAgentHookContextChannelFields, buildEmbeddedAttemptToolRunContext, callGatewayTool, consumeAdjustedParamsForToolCall, consumePreExecutionBlockedToolCall, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractMessagingToolSend, extractMessagingToolSendResult, extractToolResultMediaArtifact, filterProviderNormalizableTools, filterToolResultMediaUrls, finalizeToolTerminalPresentation, formatApprovalDisplayPath, formatToolExecutionErrorMessage, getBeforeToolCallFailureDisposition, getChannelAgentToolMeta, getPluginToolMeta, hasNativeHookRelayInvocation, invokeNativeHookRelay, isDeliveredMessageToolOnlySourceReplyResult, isDeliveredMessagingToolResult, isHostScopedAgentToolActive, isMessagingTool, isMessagingToolSendAction, isReplaySafeToolCall, isSubagentSessionKey, isToolResultError, isToolWrappedWithBeforeToolCallHook, normalizeAgentRuntimeTools, normalizeHeartbeatToolResponse, projectRuntimeToolInputSchema, registerNativeHookRelay, resolveAttemptSpawnWorkspaceDir, resolveModelAuthMode, resolveNativeHookRelayDeferredToolApproval, resolveToolExecutionErrorKind, resolveToolResultFailureKind, runAgentHarnessAfterToolCallHook, runBeforeToolCallHook, sanitizeToolResult, setBeforeToolCallDiagnosticsEnabled, supportsModelTools, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash } from "node:crypto";
@@ -14,6 +15,9 @@ import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-util
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { emitTrustedDiagnosticEvent, hasPendingInternalDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { isToolAllowed } from "openclaw/plugin-sdk/sandbox";
+import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
+import { getMediaDir } from "openclaw/plugin-sdk/media-runtime";
 import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeOpenAIToolSchemas } from "openclaw/plugin-sdk/provider-tools";
 //#region extensions/codex/src/app-server/event-projector-items.ts
@@ -108,7 +112,7 @@ function shouldSynthesizeToolProgressForItem(item) {
 	}
 }
 function shouldRecordNativeToolTranscript(item) {
-	return shouldSynthesizeToolProgressForItem(item) && item.type !== "webSearch";
+	return shouldSynthesizeToolProgressForItem(item);
 }
 function isMutatingNativeToolItem(item) {
 	if (item.type === "commandExecution") return true;
@@ -604,6 +608,19 @@ const CODEX_NATIVE_HOOK_RELAY_COMMAND_MAX_PARENT_MARGIN_MS = 1e3;
 const CODEX_NATIVE_HOOK_RELAY_DEFAULT_TIMEOUT_SEC = 10;
 const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS = 1e4;
 const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS = 5e3;
+const CODEX_HOOK_MATCHER_NAMES_BY_TOOL_ID = {
+	exec: [
+		"Bash",
+		"exec",
+		"exec_command"
+	],
+	apply_patch: [
+		"apply_patch",
+		"Write",
+		"Edit"
+	],
+	spawn_agent: ["spawn_agent", "Agent"]
+};
 /** Defers relay unregister so late native hook subprocesses can still resolve. */
 function scheduleCodexNativeHookRelayUnregister(params) {
 	let pending;
@@ -662,6 +679,7 @@ function createCodexNativeHookRelay(params) {
 		runId: params.runId,
 		...params.channelId ? { channelId: params.channelId } : {},
 		...params.requester ? { requester: params.requester } : {},
+		...params.approvalContext ? { approvalContext: params.approvalContext } : {},
 		allowedEvents: params.events,
 		preToolUseLoopDetection: params.loopDetectionPreToolUseRelay,
 		ttlMs: resolveCodexNativeHookRelayTtlMs({
@@ -730,18 +748,23 @@ function buildCodexNativeHookRelayConfig(params) {
 		}
 		const timeout = normalizeHookTimeoutSec(params.hookTimeoutSec);
 		const command = params.relay.commandForEvent(event, { timeoutMs: resolveCodexNativeHookRelayCommandTimeoutMs(timeout) });
-		config[`hooks.${codexEvent}`] = [{ hooks: [{
-			type: "command",
-			command,
-			timeout,
-			async: false,
-			statusMessage: "OpenClaw native hook relay"
-		}] }];
+		const matcher = selectedNoopPreToolUse ? void 0 : buildCodexNativeToolMatcher(params.relay.toolMatcherForEvent(event));
+		config[`hooks.${codexEvent}`] = [{
+			...matcher ? { matcher } : {},
+			hooks: [{
+				type: "command",
+				command,
+				timeout,
+				async: false,
+				statusMessage: "OpenClaw native hook relay"
+			}]
+		}];
 		const state = {
 			enabled: true,
 			trusted_hash: codexCommandHookTrustedHash({
 				event,
 				command,
+				matcher,
 				timeout,
 				statusMessage: "OpenClaw native hook relay"
 			})
@@ -769,9 +792,26 @@ function resolveCodexNativeHookRelayCommandTimeoutMs(hookTimeoutSec) {
 	const parentMarginMs = Math.min(CODEX_NATIVE_HOOK_RELAY_COMMAND_MAX_PARENT_MARGIN_MS, Math.max(CODEX_NATIVE_HOOK_RELAY_COMMAND_MIN_PARENT_MARGIN_MS, Math.floor(parentTimeoutMs / 5)));
 	return Math.max(1, parentTimeoutMs - parentMarginMs);
 }
+function buildCodexNativeToolMatcher(toolNames) {
+	if (toolNames === void 0) return;
+	if (toolNames.length === 0) throw new TypeError("Codex native hook matcher requires at least one tool name");
+	const nativeNames = /* @__PURE__ */ new Set();
+	let hasCustomToolName = false;
+	for (const toolName of toolNames) {
+		const canonicalToolName = toolName.trim();
+		if (!canonicalToolName || canonicalToolName === "*") throw new TypeError("Codex native hook matcher requires canonical OpenClaw tool ids");
+		const nativeAliases = CODEX_HOOK_MATCHER_NAMES_BY_TOOL_ID[canonicalToolName];
+		if (!nativeAliases) hasCustomToolName = true;
+		for (const nativeName of nativeAliases ?? [canonicalToolName]) nativeNames.add(nativeName);
+	}
+	const sortedNames = Array.from(nativeNames).toSorted();
+	if (!hasCustomToolName && sortedNames.every((toolName) => /^[A-Za-z0-9_]+$/.test(toolName))) return sortedNames.join("|");
+	return `(?i)^(?:${sortedNames.map((toolName) => toolName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})$`;
+}
 function codexCommandHookTrustedHash(params) {
 	const identity = {
 		event_name: CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT[params.event],
+		...params.matcher ? { matcher: params.matcher } : {},
 		hooks: [{
 			async: false,
 			command: params.command,
@@ -984,6 +1024,322 @@ var CodexNativeToolLifecycleProjector = class {
 	}
 };
 //#endregion
+//#region extensions/codex/src/app-server/remote-workspace-path.ts
+/** Projects a gateway workspace path into the remote Codex execution workspace. */
+function mapCodexAppServerRemoteWorkspacePath(params) {
+	if (!params.remoteWorkspaceRoot) return params.value;
+	const localRoot = normalizeWorkspaceMatchPath(params.localWorkspaceRoot);
+	const remoteRoot = normalizeWorkspaceMatchPath(params.remoteWorkspaceRoot);
+	const normalizedValue = normalizeWorkspaceMatchPath(params.value);
+	if (!localRoot || !remoteRoot) throw new Error("Codex remoteWorkspaceRoot requires non-empty workspace roots.");
+	if (normalizedValue === localRoot) return remoteRoot;
+	const prefix = `${localRoot}/`;
+	if (!normalizedValue.startsWith(prefix)) throw new Error(`Codex remoteWorkspaceRoot is configured but cwd ${params.value} is outside OpenClaw workspace root ${params.localWorkspaceRoot}; refusing to send a gateway-local cwd to the remote Codex app-server.`);
+	return joinRemoteWorkspacePath(remoteRoot, normalizedValue.slice(prefix.length));
+}
+/** Maps a remote workspace artifact back into the corresponding gateway workspace. */
+function mapCodexAppServerLocalWorkspacePath(params) {
+	if (!params.remoteWorkspaceRoot) return params.value;
+	const localRoot = normalizeWorkspaceMatchPath(params.localWorkspaceRoot);
+	const remoteRoot = normalizeWorkspaceMatchPath(params.remoteWorkspaceRoot);
+	if (!localRoot || !remoteRoot) throw new Error("Codex remoteWorkspaceRoot requires non-empty workspace roots.");
+	const normalizedValue = normalizeWorkspaceMatchPath(params.value);
+	if (!normalizedValue || isCodexPassThroughMediaSource(normalizedValue)) return params.value;
+	const usesWindowsPaths = /^[a-z]:\//iu.test(remoteRoot) || remoteRoot.startsWith("//");
+	const matchValue = usesWindowsPaths ? normalizedValue.toLowerCase() : normalizedValue;
+	const matchRoot = usesWindowsPaths ? remoteRoot.toLowerCase() : remoteRoot;
+	if (matchValue === matchRoot) return params.localWorkspaceRoot;
+	const prefix = matchRoot.endsWith("/") ? matchRoot : `${matchRoot}/`;
+	const isRemoteWorkspacePath = matchValue.startsWith(prefix);
+	if (!isRemoteWorkspacePath && isAbsoluteWorkspacePath(normalizedValue)) throw new Error(`Codex remote workspace artifact ${params.value} is outside ${params.remoteWorkspaceRoot}.`);
+	const suffixSegments = (isRemoteWorkspacePath ? normalizedValue.slice(prefix.length) : normalizedValue).split("/");
+	if (suffixSegments.some((segment) => segment === "..")) throw new Error(`Codex remote workspace artifact ${params.value} must stay inside ${params.remoteWorkspaceRoot}.`);
+	return path.join(params.localWorkspaceRoot, ...suffixSegments.filter((segment) => segment !== "."));
+}
+function normalizeWorkspaceMatchPath(value) {
+	const normalized = value.replace(/\\/gu, "/");
+	if (/^[a-z]:\/$/iu.test(normalized)) return normalized;
+	return normalized.length > 1 ? normalized.replace(/[\\/]+$/u, "") : normalized;
+}
+/** Keeps remote URLs and opaque managed media references out of workspace path mapping. */
+function isCodexPassThroughMediaSource(value) {
+	return /^(?:https?|mxc|buffer|media):\/\//iu.test(value) || /^data:/iu.test(value);
+}
+function isAbsoluteWorkspacePath(value) {
+	return value.startsWith("/") || /^[a-z]:\//iu.test(value) || /^[a-z][a-z0-9+.-]*:/iu.test(value);
+}
+function joinRemoteWorkspacePath(remoteRoot, suffix) {
+	return remoteRoot.endsWith("/") ? `${remoteRoot}${suffix}` : `${remoteRoot}/${suffix}`;
+}
+//#endregion
+//#region extensions/codex/src/app-server/remote-workspace-media.ts
+const REMOTE_WORKSPACE_MEDIA_TIMEOUT_MS = 6e4;
+const REMOTE_WORKSPACE_MEDIA_MAX_BYTES = 64 * 1024 * 1024;
+const REMOTE_WORKSPACE_MEDIA_MAX_ATTACHMENTS = 16;
+const CODEX_REMOTE_MEDIA_CHUNK_BYTES = 512 * 1024;
+const CODEX_REMOTE_COMMAND_DEFAULT_OUTPUT_BYTES = 1024 * 1024;
+const CODEX_BOUNDED_REMOTE_FILE_READER = [
+	"try{",
+	"const fs=require(\"node:fs\");",
+	"const path=require(\"node:path\");",
+	"const file=process.argv[1];",
+	"const max=Number(process.argv[2]);",
+	"const offset=Number(process.argv[3]);",
+	"const chunk=Number(process.argv[4]);",
+	"const workspace=process.argv[5];",
+	"if(!Number.isSafeInteger(max)||max<0)throw Error(\"invalid media byte limit\");",
+	"if(!Number.isSafeInteger(offset)||offset<0||!Number.isSafeInteger(chunk)||chunk<=0)throw Error(\"invalid media chunk\");",
+	"if(fs.lstatSync(file).isSymbolicLink())throw Error(\"symbolic links are not allowed\");",
+	"const noFollow=fs.constants.O_NOFOLLOW??0;",
+	"const fd=fs.openSync(file,fs.constants.O_RDONLY|noFollow);",
+	"try{",
+	"const before=fs.fstatSync(fd);",
+	"if(!before.isFile())throw Error(\"not a regular file\");",
+	"if(workspace){",
+	"const descriptor=process.platform===\"linux\"?fs.realpathSync(`/proc/self/fd/${fd}`):fs.realpathSync(file);",
+	"const relative=path.relative(fs.realpathSync(workspace),descriptor);",
+	"if(!relative||relative===\"..\"||relative.startsWith(`..${path.sep}`)||path.isAbsolute(relative))throw Error(\"file escapes remote workspace\");",
+	"const verified=fs.statSync(descriptor);",
+	"if(verified.dev!==before.dev||verified.ino!==before.ino)throw Error(\"file changed while being opened\");",
+	"}",
+	"if(before.size>max)throw Error(`file exceeds limit of ${max} bytes`);",
+	"if(offset>before.size)throw Error(\"file changed while being read\");",
+	"const expected=Math.min(chunk,before.size-offset);",
+	"const buffer=Buffer.allocUnsafe(expected);",
+	"let total=0;",
+	"while(total<buffer.length){",
+	"const count=fs.readSync(fd,buffer,total,buffer.length-total,offset+total);",
+	"if(count===0)break;total+=count;",
+	"}",
+	"if(total!==expected)throw Error(\"file changed while being read\");",
+	"const after=fs.fstatSync(fd);",
+	"const revision=stat=>[stat.dev,stat.ino,stat.size,stat.mtimeMs,stat.ctimeMs].join(\":\");",
+	"if(!after.isFile()||revision(after)!==revision(before))throw Error(\"file changed while being read\");",
+	"process.stdout.write(JSON.stringify({dataBase64:buffer.toString(\"base64\"),size:before.size,revision:revision(before)}));",
+	"}finally{fs.closeSync(fd)}",
+	"}catch(error){process.stderr.write(error instanceof Error?error.message:String(error));process.exitCode=1}"
+].join("");
+const MESSAGE_MEDIA_KEYS = [
+	"media",
+	"mediaUrl",
+	"media_url",
+	"path",
+	"filePath",
+	"fileUrl",
+	"imageUrl",
+	"image_url"
+];
+const MESSAGE_MEDIA_ARRAY_KEYS = [
+	"mediaUrls",
+	"media_urls",
+	"imageUrls",
+	"image_urls"
+];
+const ATTACHMENT_MEDIA_KEYS = [
+	"media",
+	"mediaUrl",
+	"path",
+	"filePath",
+	"fileUrl",
+	"url"
+];
+/** Reads actual remote bytes with a cap enforced by Codex before transport. */
+async function readBoundedCodexRemoteWorkspaceFile(params) {
+	if (!Number.isSafeInteger(params.maxBytes) || params.maxBytes < 0) throw new Error("Codex remote workspace upload requires a valid media byte limit.");
+	params.signal?.throwIfAborted();
+	const chunks = [];
+	let offset = 0;
+	let expectedSize;
+	let expectedRevision;
+	const startedAt = Date.now();
+	do {
+		params.signal?.throwIfAborted();
+		const timeoutMs = params.timeoutMs === void 0 ? void 0 : params.timeoutMs - (Date.now() - startedAt);
+		if (timeoutMs !== void 0 && timeoutMs <= 0) throw new Error("Codex remote workspace file transfer timed out.");
+		let response;
+		try {
+			response = await params.client.request("command/exec", {
+				command: [
+					"node",
+					"-e",
+					CODEX_BOUNDED_REMOTE_FILE_READER,
+					"--",
+					params.path,
+					String(params.maxBytes),
+					String(offset),
+					String(CODEX_REMOTE_MEDIA_CHUNK_BYTES),
+					...params.workspaceRoot ? [params.workspaceRoot] : []
+				],
+				env: {
+					NODE_OPTIONS: null,
+					NODE_PATH: null
+				},
+				...timeoutMs === void 0 ? {} : { timeoutMs }
+			}, {
+				signal: params.signal,
+				timeoutMs
+			});
+		} catch (error) {
+			if (error instanceof Error && /failed to spawn|executable.*not found|\bENOENT\b/iu.test(error.message)) throw new Error("Codex remote workspace file transfer requires Node.js on the remote app-server host.", { cause: error });
+			throw error;
+		}
+		if (!response || response.exitCode !== 0) {
+			const detail = typeof response?.stderr === "string" ? response.stderr.trim() : "";
+			throw new Error(`Codex remote workspace artifact could not be read: ${params.path}${detail ? `: ${detail}` : ""}`);
+		}
+		if (typeof response.stdout !== "string" || response.stdout.length > CODEX_REMOTE_COMMAND_DEFAULT_OUTPUT_BYTES) throw new Error("Codex remote workspace artifact exceeded the native command output cap.");
+		let payload;
+		try {
+			payload = JSON.parse(response.stdout);
+		} catch {
+			throw new Error("Codex remote workspace artifact returned invalid chunk data.");
+		}
+		if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new Error("Codex remote workspace artifact returned invalid chunk data.");
+		const chunk = payload;
+		if (typeof chunk.dataBase64 !== "string" || !Number.isSafeInteger(chunk.size) || chunk.size < 0 || chunk.size > params.maxBytes || typeof chunk.revision !== "string" || !chunk.revision) throw new Error("Codex remote workspace artifact returned invalid or oversized chunk data.");
+		if (expectedSize === void 0) {
+			expectedSize = chunk.size;
+			expectedRevision = chunk.revision;
+		}
+		if (chunk.size !== expectedSize || chunk.revision !== expectedRevision) throw new Error("Codex remote workspace artifact changed during chunked transfer.");
+		const remainingBytes = expectedSize - offset;
+		const expectedChunkBytes = Math.min(CODEX_REMOTE_MEDIA_CHUNK_BYTES, remainingBytes);
+		if (chunk.dataBase64.length > Math.ceil(expectedChunkBytes / 3) * 4) throw new Error("Codex remote workspace artifact returned oversized chunk data.");
+		const buffer = Buffer.from(chunk.dataBase64, "base64");
+		if (buffer.byteLength !== expectedChunkBytes || buffer.toString("base64") !== chunk.dataBase64) throw new Error("Codex remote workspace artifact returned invalid chunk data.");
+		chunks.push(buffer);
+		offset += buffer.byteLength;
+	} while (offset < (expectedSize ?? 0));
+	return { dataBase64: Buffer.concat(chunks, offset).toString("base64") };
+}
+/** Stages authoritative bounded remote bytes into immutable Gateway-owned media. */
+async function prepareCodexRemoteWorkspaceMessageMedia(params) {
+	const { localWorkspaceRoot, remoteWorkspaceRoot } = params;
+	if (!localWorkspaceRoot || !remoteWorkspaceRoot) return params.args;
+	const remotePathsByLocalPath = /* @__PURE__ */ new Map();
+	const gatewayManagedPaths = /* @__PURE__ */ new Set();
+	const gatewayMediaRoot = getMediaDir();
+	let attachmentEntries = 0;
+	const mapMediaPath = (value) => {
+		if (typeof value !== "string") return value;
+		if (isGatewayManagedMediaPath(value, gatewayMediaRoot)) {
+			attachmentEntries += 1;
+			gatewayManagedPaths.add(value);
+			return value;
+		}
+		const mapped = mapCodexAppServerLocalWorkspacePath({
+			value,
+			localWorkspaceRoot,
+			remoteWorkspaceRoot
+		});
+		if (value.trim() && !isCodexPassThroughMediaSource(value)) {
+			attachmentEntries += 1;
+			remotePathsByLocalPath.set(mapped, mapCodexAppServerRemoteWorkspacePath({
+				value: mapped,
+				localWorkspaceRoot,
+				remoteWorkspaceRoot
+			}));
+		}
+		return mapped;
+	};
+	let mappedArgs = params.args;
+	const setMappedValue = (key, value) => {
+		if (value === params.args[key]) return;
+		if (mappedArgs === params.args) mappedArgs = { ...params.args };
+		mappedArgs[key] = value;
+	};
+	for (const key of MESSAGE_MEDIA_KEYS) setMappedValue(key, mapMediaPath(params.args[key]));
+	for (const key of MESSAGE_MEDIA_ARRAY_KEYS) {
+		const value = params.args[key];
+		if (Array.isArray(value)) {
+			const mapped = value.map(mapMediaPath);
+			if (mapped.some((entry, index) => entry !== value[index])) setMappedValue(key, mapped);
+		}
+	}
+	if (Array.isArray(params.args.attachments)) {
+		const attachments = params.args.attachments;
+		const mapped = attachments.map((attachment) => {
+			if (!attachment || typeof attachment !== "object" || Array.isArray(attachment)) return attachment;
+			const record = attachment;
+			let mappedAttachment = record;
+			for (const key of ATTACHMENT_MEDIA_KEYS) {
+				const value = mapMediaPath(record[key]);
+				if (value !== record[key]) {
+					if (mappedAttachment === record) mappedAttachment = { ...record };
+					mappedAttachment[key] = value;
+				}
+			}
+			return mappedAttachment;
+		});
+		if (mapped.some((attachment, index) => attachment !== attachments[index])) setMappedValue("attachments", mapped);
+	}
+	if (attachmentEntries > REMOTE_WORKSPACE_MEDIA_MAX_ATTACHMENTS) throw new Error(`Codex remote workspace upload exceeds the ${REMOTE_WORKSPACE_MEDIA_MAX_ATTACHMENTS}-attachment limit.`);
+	for (const managedPath of gatewayManagedPaths) await assertGatewayManagedMediaPath(managedPath, gatewayMediaRoot);
+	if (remotePathsByLocalPath.size === 0) return mappedArgs;
+	const readRemoteFile = params.readRemoteFile;
+	if (!readRemoteFile) throw new Error("Codex remote workspace file transfer requires an active app-server client.");
+	const maxBytes = params.maxBytes ?? REMOTE_WORKSPACE_MEDIA_MAX_BYTES;
+	const timeoutMs = params.timeoutMs ?? REMOTE_WORKSPACE_MEDIA_TIMEOUT_MS;
+	const deadline = Date.now() + timeoutMs;
+	const stagedPaths = /* @__PURE__ */ new Map();
+	let totalBytes = 0;
+	for (const [localPath, remotePath] of remotePathsByLocalPath) {
+		params.signal?.throwIfAborted();
+		const remainingBytes = maxBytes - totalBytes;
+		const remainingMs = deadline - Date.now();
+		if (remainingMs <= 0) throw new Error("Codex remote workspace attachment batch timed out.");
+		const response = await readRemoteFile({
+			path: remotePath,
+			maxBytes: remainingBytes,
+			workspaceRoot: remoteWorkspaceRoot,
+			signal: params.signal,
+			timeoutMs: remainingMs
+		});
+		if (!response || typeof response.dataBase64 !== "string") throw new Error(`Codex remote workspace artifact returned no file data: ${remotePath}`);
+		if (response.dataBase64.length > Math.ceil(remainingBytes / 3) * 4) throw new Error(`Codex remote workspace artifact exceeds the limit of ${remainingBytes} bytes.`);
+		const remoteBuffer = Buffer.from(response.dataBase64, "base64");
+		if (remoteBuffer.byteLength > remainingBytes || remoteBuffer.toString("base64") !== response.dataBase64) throw new Error(`Codex remote workspace artifact returned invalid or oversized file data: ${remotePath}`);
+		totalBytes += remoteBuffer.byteLength;
+		const saved = await saveMediaBuffer(remoteBuffer, void 0, "outbound", maxBytes, path.basename(remotePath));
+		stagedPaths.set(localPath, saved.path);
+	}
+	return mapMessageMediaValues(mappedArgs, (value) => stagedPaths.get(value) ?? value);
+}
+function isGatewayManagedMediaPath(value, mediaRoot) {
+	if (!path.isAbsolute(value)) return false;
+	const relativePath = path.relative(mediaRoot, value);
+	return Boolean(relativePath && relativePath !== ".." && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath));
+}
+async function assertGatewayManagedMediaPath(value, mediaRoot) {
+	const opened = await (await root(mediaRoot, { symlinks: "reject" })).open(path.relative(mediaRoot, value), { symlinks: "reject" });
+	try {
+		if (!(await opened.handle.stat()).isFile()) throw new Error(`Codex Gateway-managed media is not a regular file: ${value}`);
+	} finally {
+		await opened[Symbol.asyncDispose]();
+	}
+}
+function mapMessageMediaValues(args, mapValue) {
+	const mapped = { ...args };
+	for (const key of MESSAGE_MEDIA_KEYS) {
+		const value = mapped[key];
+		if (typeof value === "string") mapped[key] = mapValue(value);
+	}
+	for (const key of MESSAGE_MEDIA_ARRAY_KEYS) {
+		const value = mapped[key];
+		if (Array.isArray(value)) mapped[key] = value.map((entry) => typeof entry === "string" ? mapValue(entry) : entry);
+	}
+	if (Array.isArray(mapped.attachments)) mapped.attachments = mapped.attachments.map((attachment) => {
+		if (!attachment || typeof attachment !== "object" || Array.isArray(attachment)) return attachment;
+		const record = { ...attachment };
+		for (const key of ATTACHMENT_MEDIA_KEYS) {
+			const value = record[key];
+			if (typeof value === "string") record[key] = mapValue(value);
+		}
+		return record;
+	});
+	return mapped;
+}
+//#endregion
 //#region extensions/codex/src/app-server/dynamic-tool-build-state.ts
 /** Mutable dependency seam shared by dynamic-tool construction and its behavioral tests. */
 const dynamicToolBuildState = {};
@@ -1193,8 +1549,10 @@ async function buildDynamicTools(input) {
 	const toolBuildStages = createCodexDynamicToolBuildStageTracker({ enabled: input.profilerEnabled });
 	const modelHasVision = params.model.input?.includes("image") ?? false;
 	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, input.sessionAgentId);
-	const { createOpenClawCodingTools: defaultCreateOpenClawCodingTools, resolveWebSearchToolPolicy } = await import("openclaw/plugin-sdk/agent-harness");
-	const createOpenClawCodingTools = dynamicToolBuildState.openClawCodingToolsFactory ?? defaultCreateOpenClawCodingTools;
+	const injectedOpenClawCodingToolsFactory = dynamicToolBuildState.openClawCodingToolsFactory;
+	let agentHarnessModule;
+	const loadAgentHarnessModule = async () => agentHarnessModule ??= await import("openclaw/plugin-sdk/agent-harness");
+	const createOpenClawCodingTools = injectedOpenClawCodingToolsFactory ?? (await loadAgentHarnessModule()).createOpenClawCodingTools;
 	toolBuildStages.mark("load-agent-harness-tools");
 	const sessionKeys = resolveOpenClawCodingToolsSessionKeys(params, input.sandboxSessionKey);
 	const nativeExecutionPolicy = resolveCodexNativeExecutionPolicyForDynamicTools(input);
@@ -1305,7 +1663,8 @@ async function buildDynamicTools(input) {
 	});
 	toolBuildStages.mark("vision-filtering");
 	const webSearchPresent = visionFilteredTools.some((tool) => tool.name === "web_search");
-	const webSearchPolicy = resolveWebSearchToolPolicy({
+	const persistentCodexWebSearchSurface = params.config?.tools?.web?.search?.enabled !== false && !(input.pluginConfig.codexDynamicToolsExclude ?? []).some((name) => normalizeCodexDynamicToolName(name) === "web_search");
+	const webSearchPolicy = webSearchPresent || persistentCodexWebSearchSurface ? (await loadAgentHarnessModule()).resolveWebSearchToolPolicy({
 		config: params.config,
 		modelProvider: params.model.provider,
 		modelId: params.modelId,
@@ -1325,9 +1684,11 @@ async function buildDynamicTools(input) {
 		inputProvenance: params.inputProvenance,
 		trustedInternalHandoff: params.trustedInternalHandoff,
 		scheduledToolPolicy: params.scheduledToolPolicy
-	});
+	}) : {
+		allowed: false,
+		persistentAllowed: false
+	};
 	const transientWebSearchRestriction = !webSearchPolicy.allowed && webSearchPolicy.persistentAllowed || isCodexMemoryFlushRun(params);
-	const persistentCodexWebSearchSurface = params.config?.tools?.web?.search?.enabled !== false && !(input.pluginConfig.codexDynamicToolsExclude ?? []).some((name) => normalizeCodexDynamicToolName(name) === "web_search");
 	input.onPersistentWebSearchPolicyResolved?.(webSearchPresent || persistentCodexWebSearchSurface && transientWebSearchRestriction && webSearchPolicy.persistentAllowed);
 	const filteredTools = filterCodexDynamicToolsForAllowlist(visionFilteredTools, includeForcedCodexDynamicToolAllow(params.toolsAllow, messagePolicyParams));
 	toolBuildStages.mark("allowlist-filter");
@@ -1440,27 +1801,6 @@ function resolveCodexAppServerExecutionCwd(params) {
 		remoteWorkspaceRoot: params.remoteWorkspaceRoot
 	});
 }
-/** Projects a local OpenClaw workspace cwd into the remote Codex app-server workspace root. */
-function mapCodexAppServerRemoteWorkspacePath(params) {
-	if (!params.remoteWorkspaceRoot) return params.value;
-	const localRoot = normalizeRemoteWorkspaceMatchPath(params.localWorkspaceRoot);
-	const remoteRoot = normalizeRemoteWorkspaceMatchPath(params.remoteWorkspaceRoot);
-	const normalizedValue = normalizeRemoteWorkspaceMatchPath(params.value);
-	if (!localRoot || !remoteRoot) throw new Error("Codex remoteWorkspaceRoot requires non-empty workspace roots.");
-	if (normalizedValue === localRoot) return remoteRoot;
-	const prefix = `${localRoot}/`;
-	if (!normalizedValue.startsWith(prefix)) throw new Error(`Codex remoteWorkspaceRoot is configured but cwd ${params.value} is outside OpenClaw workspace root ${params.localWorkspaceRoot}; refusing to send a gateway-local cwd to the remote Codex app-server.`);
-	return joinRemoteWorkspacePath(remoteRoot, normalizedValue.slice(prefix.length));
-}
-function normalizeRemoteWorkspaceMatchPath(value) {
-	return trimTrailingPathSeparator(value.replace(/\\/gu, "/"));
-}
-function trimTrailingPathSeparator(value) {
-	return value.length > 1 ? value.replace(/[\\/]+$/u, "") : value;
-}
-function joinRemoteWorkspacePath(remoteRoot, suffix) {
-	return remoteRoot === "/" ? `/${suffix}` : `${remoteRoot}/${suffix}`;
-}
 /** Converts OpenClaw sandbox networking into Codex's external-sandbox policy shape. */
 function resolveCodexExternalSandboxPolicyForOpenClawSandbox(sandbox) {
 	return {
@@ -1602,6 +1942,20 @@ function settleCodexSourceReplyFinality(owner, turnSucceeded) {
 	return turnSucceeded && intents.some((intent) => intent.record.sourceReplyFinal === true);
 }
 //#endregion
+//#region extensions/codex/src/app-server/hook-requester.ts
+/** Rebuilds the host-proven requester identity shared by native and bridged tool hooks. */
+function buildCodexHookRequester(params) {
+	const channel = params.messageChannel ?? params.messageProvider;
+	const requester = {
+		...channel ? { channel } : {},
+		...params.agentAccountId ? { accountId: params.agentAccountId } : {},
+		...params.senderId ? { senderId: params.senderId } : {},
+		...params.senderIsOwner !== void 0 ? { senderIsOwner: params.senderIsOwner } : {},
+		...params.memberRoleIds?.length ? { roleIds: [...params.memberRoleIds] } : {}
+	};
+	return Object.keys(requester).length > 0 ? requester : void 0;
+}
+//#endregion
 //#region extensions/codex/src/app-server/provider-capabilities.ts
 function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
 	const provider = modelProviderOverride?.trim().toLowerCase();
@@ -2405,6 +2759,7 @@ const PERMISSION_VALUE_MAX_LENGTH = 48;
 const COMMAND_PREVIEW_WITH_DETAILS_MAX_LENGTH = 80;
 const APPROVAL_PREVIEW_SCAN_MAX_LENGTH = 4096;
 const APPROVAL_PREVIEW_OMITTED = "[preview truncated or unsafe content omitted]";
+const CONCRETE_TOOL_AUTO_APPROVAL_METHODS = /* @__PURE__ */ new Set(["item/commandExecution/requestApproval", "item/fileChange/requestApproval"]);
 const ANSI_OSC_SEQUENCE_RE = new RegExp(String.raw`(?:\u001b]|\u009d)[^\u001b\u009c\u0007]*(?:\u0007|\u001b\\|\u009c)`, "g");
 const ANSI_CONTROL_SEQUENCE_RE = new RegExp(String.raw`(?:\u001b\[[0-?]*[ -/]*[@-~]|\u009b[0-?]*[ -/]*[@-~]|\u001b[@-Z\\-_])`, "g");
 const CONTROL_CHARACTER_RE = new RegExp(String.raw`[\u0000-\u001f\u007f-\u009f]+`, "g");
@@ -2417,7 +2772,6 @@ const DANGLING_TERMINAL_SEQUENCE_SUFFIX_RE = new RegExp(String.raw`(?:\u001b\][^
 async function handleCodexAppServerApprovalRequest(params) {
 	const requestParams = isJsonObject(params.requestParams) ? params.requestParams : void 0;
 	if (!matchesCurrentTurn(requestParams, params.threadId, params.turnId)) return;
-	if (!isSupportedAppServerApprovalMethod(params.method)) return unsupportedApprovalResponse();
 	const context = buildApprovalContext({
 		method: params.method,
 		requestParams,
@@ -2458,7 +2812,20 @@ async function handleCodexAppServerApprovalRequest(params) {
 			});
 			return buildApprovalResponse(params.method, context.requestParams, policyOutcome.outcome);
 		}
-		if (params.autoApprove === true) {
+		const canAutoApproveConcreteToolCall = CONCRETE_TOOL_AUTO_APPROVAL_METHODS.has(params.method);
+		if (canAutoApproveConcreteToolCall && params.autoApproveOpenClawToolPolicy === true && policyOutcome?.outcome === "allowed") {
+			emitApprovalEvent(params.paramsForRun, {
+				phase: "resolved",
+				kind: context.kind,
+				status: "approved",
+				title: context.title,
+				...context.eventDetails,
+				...approvalEventScope(params.method, "approved-once"),
+				message: "Codex app-server approval accepted by OpenClaw tool policy."
+			});
+			return buildApprovalResponse(params.method, context.requestParams, "approved-once");
+		}
+		if (canAutoApproveConcreteToolCall && params.autoApprove === true) {
 			emitApprovalEvent(params.paramsForRun, {
 				phase: "resolved",
 				kind: context.kind,
@@ -2620,7 +2987,7 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 		...nativeRelayOutcome.failureDisposition ? { failureDisposition: nativeRelayOutcome.failureDisposition } : {}
 	};
 	if (nativeRelayOutcome?.outcome === "approved-once" || nativeRelayOutcome?.outcome === "approved-session") return { outcome: nativeRelayOutcome.outcome };
-	if (nativeRelayOutcome?.handled) return { outcome: "no-decision" };
+	if (nativeRelayOutcome?.handled) return { outcome: "allowed" };
 	const hookChannelId = buildAgentHookContextChannelFields({
 		sessionKey: params.paramsForRun.sessionKey,
 		messageChannel: params.paramsForRun.messageChannel,
@@ -2628,6 +2995,7 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 		currentChannelId: params.paramsForRun.currentChannelId,
 		messageTo: params.paramsForRun.messageTo
 	}).channelId;
+	const requester = buildCodexHookRequester(params.paramsForRun);
 	const outcome = await runBeforeToolCallHook({
 		toolName: policyRequest.toolName,
 		params: policyRequest.params,
@@ -2642,7 +3010,14 @@ 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 } : {},
-			...hookChannelId ? { channelId: hookChannelId } : {}
+			...hookChannelId ? { channelId: hookChannelId } : {},
+			...requester ? { requester } : {},
+			trigger: params.paramsForRun.trigger,
+			approvalReviewerDeviceId: params.paramsForRun.approvalReviewerDeviceId,
+			turnSourceChannel: params.paramsForRun.messageChannel ?? params.paramsForRun.messageProvider,
+			turnSourceTo: params.paramsForRun.currentMessagingTarget ?? params.paramsForRun.currentChannelId,
+			turnSourceAccountId: params.paramsForRun.agentAccountId,
+			turnSourceThreadId: params.paramsForRun.currentThreadTs
 		}
 	});
 	if (outcome.blocked) return {
@@ -2655,6 +3030,7 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 		reason: "OpenClaw tool policy rewrote Codex app-server approval params; refusing original request."
 	};
 	if (outcome.approvalResolution) return { outcome: "approved-once" };
+	return { outcome: "allowed" };
 }
 async function runNativeRelayToolPolicyForApprovalRequest(params) {
 	if (params.method !== "item/commandExecution/requestApproval" || !params.nativeHookRelay?.allowedEvents.includes("pre_tool_use")) return;
@@ -3068,9 +3444,6 @@ function approvalKindForMethod(method) {
 	if (method.includes("fileChange") || method.includes("Patch") || method.includes("permissions")) return "plugin";
 	return "unknown";
 }
-function isSupportedAppServerApprovalMethod(method) {
-	return method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval" || method === "item/permissions/requestApproval";
-}
 function emitApprovalEvent(params, data) {
 	params.onAgentEvent?.({
 		stream: "approval",
@@ -3386,6 +3759,7 @@ function createCodexDynamicToolBridge(params) {
 	const legacyExtensionRunner = createCodexAppServerToolResultExtensionRunner(toolResultHookContext);
 	const executionSnapshotStates = /* @__PURE__ */ new Map();
 	const directToolNames = /* @__PURE__ */ new Set([...ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES, ...params.directToolNames ?? []]);
+	let readRemoteWorkspaceFile;
 	return {
 		availableSpecs: createCodexDynamicToolSpecs({
 			entries: availableTools,
@@ -3397,7 +3771,11 @@ function createCodexDynamicToolBridge(params) {
 			loading: params.loading ?? "searchable",
 			directToolNames
 		}),
+		resultContentSourceForTool: (toolName) => toolMap.get(toolName)?.tool.resultContentSource,
 		telemetry,
+		setRemoteWorkspaceFileReader: (reader) => {
+			readRemoteWorkspaceFile = reader;
+		},
 		consumeToolExecutionSnapshot: (toolCallId) => {
 			const state = executionSnapshotStates.get(toolCallId);
 			executionSnapshotStates.delete(toolCallId);
@@ -3448,7 +3826,15 @@ function createCodexDynamicToolBridge(params) {
 				};
 			};
 			try {
-				const preparedArgs = tool.prepareArguments ? tool.prepareArguments(args) : args;
+				const toolArgs = tool.prepareArguments ? tool.prepareArguments(args) : args;
+				const preparedArgs = toolName === "message" && isRecord(toolArgs) ? await prepareCodexRemoteWorkspaceMessageMedia({
+					args: toolArgs,
+					localWorkspaceRoot: params.hookContext?.workspaceDir,
+					remoteWorkspaceRoot: params.hookContext?.remoteWorkspaceRoot,
+					readRemoteFile: readRemoteWorkspaceFile,
+					timeoutMs: params.hookContext?.remoteWorkspaceRequestTimeoutMs,
+					signal
+				}) : toolArgs;
 				const telemetryArgs = isRecord(preparedArgs) ? preparedArgs : args;
 				executedArgs = structuredClone(telemetryArgs);
 				const messagingContext = {
@@ -3680,7 +4066,8 @@ function createCodexDynamicToolSpecs(params) {
 	const specs = [];
 	const namespaceTools = [];
 	const directOnlyNamespaceTools = [];
-	for (const entry of params.entries) {
+	const entries = params.loading === "direct" ? params.entries : params.entries.toSorted((left, right) => left.name.localeCompare(right.name));
+	for (const entry of entries) {
 		const functionSpec = createCodexDynamicToolFunctionSpec({ entry });
 		if (entry.name === "openclaw" && params.directToolNames.has(entry.name)) {
 			specs.push(functionSpec);
@@ -4130,4 +4517,4 @@ function isCronAddAction(args) {
 	return typeof action === "string" && action.trim().toLowerCase() === "add";
 }
 //#endregion
-export { shouldSynthesizeToolProgressForItem as $, resolveCodexNativeHookRelayEvents as A, shouldReleaseTurnAfterTerminalDynamicTool as B, CodexNativeToolLifecycleProjector as C, buildCodexNativeHookRelayDisabledConfig as D, buildCodexNativeHookRelayConfig as E, isDynamicToolTerminalDiagnosticEvent as F, isNonSuccessItemStatus as G, toCodexDynamicToolProtocolResponse as H, isMatchingDynamicToolTerminalDiagnostic as I, itemName as J, isSideEffectingNativeToolItem as K, resolveDynamicToolCallTimeoutMs as L, scheduleCodexNativeHookRelayUnregister as M, handleDynamicToolCallWithTimeout as N, createCodexNativeHookRelay as O, hasPendingDynamicToolTerminalDiagnostic as P, shouldRecordNativeToolTranscript as Q, resolveTerminalDynamicToolBatchAction as R, filterToolsForVisionInputs as S, CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS as T, resolveCodexToolAbortTerminalReason as U, toCodexDynamicToolProgressResponse as V, isMutatingNativeToolItem as W, itemTitle as X, itemStatus as Y, shouldClearTerminalPresentationForNativeItem as Z, resolveCodexMessageToolProvider as _, emitDynamicToolStartedDiagnostic as a, shouldRequireCodexSandboxExecServerEnvironment as b, resolveCodexProviderWebSearchSupportForClient as c, createCodexDynamicToolBuildStageTracker as d, unknownItemStatus as et, disableCodexPluginThreadConfig as f, resolveCodexExternalSandboxPolicyForOpenClawSandbox as g, resolveCodexAppServerHookChannelId as h, emitDynamicToolErrorDiagnostic as i, resolveCodexNativeHookRelayTtlMs as j, emitCodexNativePreToolUseFailureDiagnostic as k, settleCodexSourceReplyFinality as l, resolveCodexAppServerExecutionCwd as m, handleCodexAppServerApprovalRequest as n, emitDynamicToolTerminalDiagnostic as o, formatCodexDynamicToolBuildStageSummary as p, itemKind as q, handleCodexAppServerElicitationRequest as r, resolveCodexProviderWebSearchSupport as s, createCodexDynamicToolBridge as t, buildDynamicTools as u, resolveCodexSandboxEnvironmentSelection as v, CODEX_NATIVE_HOOK_RELAY_EVENTS as w, shouldWarnCodexDynamicToolBuildStageSummary as x, shouldEnableCodexAppServerNativeToolSurface as y, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as z };
+export { shouldClearTerminalPresentationForNativeItem as $, createCodexNativeHookRelay as A, resolveTerminalDynamicToolBatchAction as B, filterToolsForVisionInputs as C, CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS as D, CODEX_NATIVE_HOOK_RELAY_EVENTS as E, handleDynamicToolCallWithTimeout as F, resolveCodexToolAbortTerminalReason as G, shouldReleaseTurnAfterTerminalDynamicTool as H, hasPendingDynamicToolTerminalDiagnostic as I, isSideEffectingNativeToolItem as J, isMutatingNativeToolItem as K, isDynamicToolTerminalDiagnosticEvent as L, resolveCodexNativeHookRelayEvents as M, resolveCodexNativeHookRelayTtlMs as N, buildCodexNativeHookRelayConfig as O, scheduleCodexNativeHookRelayUnregister as P, itemTitle as Q, isMatchingDynamicToolTerminalDiagnostic as R, shouldWarnCodexDynamicToolBuildStageSummary as S, CodexNativeToolLifecycleProjector as T, toCodexDynamicToolProgressResponse as U, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as V, toCodexDynamicToolProtocolResponse as W, itemName as X, itemKind as Y, itemStatus as Z, resolveCodexExternalSandboxPolicyForOpenClawSandbox as _, emitDynamicToolStartedDiagnostic as a, shouldEnableCodexAppServerNativeToolSurface as b, resolveCodexProviderWebSearchSupportForClient as c, buildDynamicTools as d, shouldRecordNativeToolTranscript as et, createCodexDynamicToolBuildStageTracker as f, resolveCodexAppServerHookChannelId as g, resolveCodexAppServerExecutionCwd as h, emitDynamicToolErrorDiagnostic as i, emitCodexNativePreToolUseFailureDiagnostic as j, buildCodexNativeHookRelayDisabledConfig as k, buildCodexHookRequester as l, formatCodexDynamicToolBuildStageSummary as m, handleCodexAppServerApprovalRequest as n, unknownItemStatus as nt, emitDynamicToolTerminalDiagnostic as o, disableCodexPluginThreadConfig as p, isNonSuccessItemStatus as q, handleCodexAppServerElicitationRequest as r, resolveCodexProviderWebSearchSupport as s, createCodexDynamicToolBridge as t, shouldSynthesizeToolProgressForItem as tt, settleCodexSourceReplyFinality as u, resolveCodexMessageToolProvider as v, readBoundedCodexRemoteWorkspaceFile as w, shouldRequireCodexSandboxExecServerEnvironment as x, resolveCodexSandboxEnvironmentSelection as y, resolveDynamicToolCallTimeoutMs as z };