@openclaw/codex 2026.5.27-beta.1 → 2026.5.28-beta.1

package/dist/{vision-tools-DqpLmF5H.js → native-hook-relay-DYOYE3qb.js}

@@ -1,9 +1,11 @@
-import { l as isJsonObject } from "./client-BVK_jmHW.js";
-import { s as formatCodexDisplayText } from "./notification-correlation-YINts3PA.js";
+import { l as isJsonObject } from "./client-TfDda-h3.js";
+import { S as invalidInlineImageText, w as sanitizeInlineImageDataUrl } from "./thread-lifecycle-1u5ogKG_.js";
+import { s as formatCodexDisplayText } from "./notification-correlation-BVB6XFQM.js";
 import { createHash } from "node:crypto";
-import { normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { buildAgentHookContextChannelFields, callGatewayTool, embeddedAgentLog, formatApprovalDisplayPath, hasNativeHookRelayInvocation, invokeNativeHookRelay, runBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { asOptionalRecord, isRecord, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { HEARTBEAT_RESPONSE_TOOL_NAME, buildAgentHookContextChannelFields, callGatewayTool, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractToolResultMediaArtifact, filterToolResultMediaUrls, formatApprovalDisplayPath, hasNativeHookRelayInvocation, invokeNativeHookRelay, isMessagingTool, isMessagingToolSendAction, isToolWrappedWithBeforeToolCallHook, normalizeHeartbeatToolResponse, projectRuntimeToolInputSchema, registerNativeHookRelay, resolveNativeHookRelayDeferredToolApproval, runAgentHarnessAfterToolCallHook, runBeforeToolCallHook, setBeforeToolCallDiagnosticsEnabled, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { emitTrustedDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 //#region extensions/codex/src/app-server/plugin-approval-roundtrip.ts
 const DEFAULT_CODEX_APPROVAL_TIMEOUT_MS = 12e4;
 const MAX_PLUGIN_APPROVAL_TITLE_LENGTH = 80;
@@ -107,6 +109,18 @@ async function handleCodexAppServerApprovalRequest(params) {
 			});
 			return buildApprovalResponse(params.method, context.requestParams, "denied");
 		}
+		if (policyOutcome?.outcome === "approved-once" || policyOutcome?.outcome === "approved-session") {
+			emitApprovalEvent(params.paramsForRun, {
+				phase: "resolved",
+				kind: context.kind,
+				status: "approved",
+				title: context.title,
+				...context.eventDetails,
+				...approvalEventScope(params.method, policyOutcome.outcome),
+				message: approvalResolutionMessage(policyOutcome.outcome)
+			});
+			return buildApprovalResponse(params.method, context.requestParams, policyOutcome.outcome);
+		}
 		if (params.autoApprove === true) {
 			emitApprovalEvent(params.paramsForRun, {
 				phase: "resolved",
@@ -243,12 +257,14 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 		context: params.context,
 		policyRequest,
 		nativeHookRelay: params.nativeHookRelay,
-		cwd
+		cwd,
+		signal: params.signal
 	});
 	if (nativeRelayOutcome?.blocked) return {
 		outcome: "denied",
 		reason: nativeRelayOutcome.reason
 	};
+	if (nativeRelayOutcome?.outcome === "approved-once" || nativeRelayOutcome?.outcome === "approved-session") return { outcome: nativeRelayOutcome.outcome };
 	if (nativeRelayOutcome?.handled) return { outcome: "no-decision" };
 	const hookChannelId = buildAgentHookContextChannelFields({
 		sessionKey: params.paramsForRun.sessionKey,
@@ -261,7 +277,7 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 		toolName: policyRequest.toolName,
 		params: policyRequest.params,
 		...params.context.itemId ? { toolCallId: params.context.itemId } : {},
-		approvalMode: "report",
+		approvalMode: "request",
 		signal: params.signal,
 		ctx: {
 			...params.paramsForRun.agentId ? { agentId: params.paramsForRun.agentId } : {},
@@ -281,6 +297,7 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 		outcome: "denied",
 		reason: "OpenClaw tool policy rewrote Codex app-server approval params; refusing original request."
 	};
+	if (outcome.approvalResolution) return { outcome: "approved-once" };
 }
 async function runNativeRelayToolPolicyForApprovalRequest(params) {
 	if (params.method !== "item/commandExecution/requestApproval" || !params.nativeHookRelay?.allowedEvents.includes("pre_tool_use")) return;
@@ -295,7 +312,23 @@ async function runNativeRelayToolPolicyForApprovalRequest(params) {
 		relayId: params.nativeHookRelay.relayId,
 		event: "pre_tool_use",
 		toolUseId: params.context.itemId
-	})) return { handled: true };
+	})) {
+		const approvalOutcome = await resolveNativeHookRelayDeferredToolApproval({
+			relayId: params.nativeHookRelay.relayId,
+			toolUseId: params.context.itemId,
+			signal: params.signal
+		});
+		if (approvalOutcome?.outcome === "denied") return {
+			handled: true,
+			blocked: true,
+			reason: approvalOutcome.reason
+		};
+		if (approvalOutcome?.outcome === "approved-once") return {
+			handled: true,
+			outcome: approvalOutcome.outcome
+		};
+		return { handled: true };
+	}
 	try {
 		const decision = readNativeRelayPreToolUseDecision(await invokeNativeHookRelay({
 			provider: "codex",
@@ -310,6 +343,20 @@ async function runNativeRelayToolPolicyForApprovalRequest(params) {
 			blocked: true,
 			reason: decision.reason
 		};
+		const approvalOutcome = await resolveNativeHookRelayDeferredToolApproval({
+			relayId: params.nativeHookRelay.relayId,
+			toolUseId: params.context.itemId,
+			signal: params.signal
+		});
+		if (approvalOutcome?.outcome === "denied") return {
+			handled: true,
+			blocked: true,
+			reason: approvalOutcome.reason
+		};
+		if (approvalOutcome?.outcome === "approved-once") return {
+			handled: true,
+			outcome: approvalOutcome.outcome
+		};
 		return { handled: true };
 	} catch (error) {
 		return {
@@ -758,6 +805,50 @@ function formatErrorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
+//#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/vision-tools.ts
+function filterToolsForVisionInputs(tools, params) {
+	if (!params.modelHasVision || !params.hasInboundImages) return tools;
+	return tools.filter((tool) => tool.name !== "image");
+}
+//#endregion
 //#region extensions/codex/src/app-server/dynamic-tool-diagnostics.ts
 function emitDynamicToolStartedDiagnostic(params) {
 	emitTrustedDiagnosticEvent({
@@ -811,6 +902,522 @@ function emitDynamicToolTerminalDiagnostic(params) {
 	emitDynamicToolErrorDiagnostic(params);
 }
 //#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 availableProjection = projectCodexDynamicTools(params.tools);
+	const registeredProjection = params.registeredTools ? projectCodexDynamicTools(params.registeredTools) : availableProjection;
+	const availableTools = availableProjection.tools.map(({ tool, inputSchema }) => {
+		if (isToolWrappedWithBeforeToolCallHook(tool)) {
+			setBeforeToolCallDiagnosticsEnabled(tool, false);
+			return {
+				tool,
+				inputSchema
+			};
+		}
+		return {
+			tool: wrapToolWithBeforeToolCallHook(tool, params.hookContext, { emitDiagnostics: false }),
+			inputSchema
+		};
+	});
+	const toolMap = new Map(availableTools.map(({ tool }) => [tool.name, tool]));
+	const registeredTools = registeredProjection.tools.map(({ tool }) => tool);
+	const registeredToolNames = new Set(registeredTools.map((tool) => tool.name));
+	const quarantinedTools = dedupeQuarantinedDynamicTools([...availableProjection.quarantinedTools, ...registeredProjection.quarantinedTools]);
+	warnQuarantinedDynamicTools(quarantinedTools);
+	emitQuarantinedDynamicToolDiagnostics(quarantinedTools, params.hookContext);
+	const telemetry = {
+		didSendViaMessagingTool: false,
+		messagingToolSentTexts: [],
+		messagingToolSentMediaUrls: [],
+		messagingToolSentTargets: [],
+		messagingToolSourceReplyPayloads: [],
+		toolMediaUrls: [],
+		toolAudioAsVoice: false,
+		quarantinedTools
+	};
+	const middlewareRunner = createAgentToolResultMiddlewareRunner({
+		runtime: "codex",
+		...toolResultHookContext
+	});
+	const legacyExtensionRunner = createCodexAppServerToolResultExtensionRunner(toolResultHookContext);
+	const directToolNames = new Set([...ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES, ...params.directToolNames ?? []]);
+	return {
+		availableSpecs: availableTools.map(({ tool, inputSchema }) => createCodexDynamicToolSpec({
+			tool,
+			inputSchema,
+			loading: params.loading ?? "searchable",
+			directToolNames
+		})),
+		specs: registeredProjection.tools.map(({ tool, inputSchema }) => createCodexDynamicToolSpec({
+			tool,
+			inputSchema,
+			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));
+				withDynamicToolAsyncStarted(response, isAsyncStartedToolResult(rawResult) || isAsyncStartedToolResult(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: params.inputSchema
+	};
+	if (params.loading === "direct" || params.directToolNames.has(params.tool.name)) return base;
+	return {
+		...base,
+		namespace: CODEX_OPENCLAW_DYNAMIC_TOOL_NAMESPACE,
+		deferLoading: true
+	};
+}
+function projectCodexDynamicTools(tools) {
+	const projectedTools = [];
+	const quarantinedTools = [];
+	for (const tool of tools) {
+		const projection = projectRuntimeToolInputSchema(tool.parameters, `${tool.name}.inputSchema`);
+		if (projection.violations.length > 0) {
+			quarantinedTools.push({
+				tool: tool.name,
+				violations: projection.violations
+			});
+			continue;
+		}
+		projectedTools.push({
+			tool,
+			inputSchema: projection.schema
+		});
+	}
+	return {
+		tools: projectedTools,
+		quarantinedTools
+	};
+}
+function warnQuarantinedDynamicTools(tools) {
+	if (tools.length === 0) return;
+	const unique = /* @__PURE__ */ new Map();
+	for (const tool of tools) unique.set(tool.tool, tool.violations);
+	embeddedAgentLog.warn(`codex app-server quarantined ${unique.size} dynamic ${unique.size === 1 ? "tool" : "tools"} with unsupported input schemas: ${[...unique.keys()].join(", ")}`, { tools: [...unique.entries()].map(([tool, violations]) => ({
+		tool,
+		violations
+	})) });
+}
+function emitQuarantinedDynamicToolDiagnostics(tools, ctx) {
+	for (const tool of tools) emitTrustedDiagnosticEvent({
+		type: "tool.execution.blocked",
+		runId: ctx?.runId,
+		sessionId: ctx?.sessionId,
+		sessionKey: ctx?.sessionKey,
+		toolName: tool.tool,
+		deniedReason: "unsupported_tool_schema",
+		reason: tool.violations.join(", ")
+	});
+}
+function dedupeQuarantinedDynamicTools(tools) {
+	return [...new Map(tools.map((tool) => [tool.tool, {
+		tool: tool.tool,
+		violations: tool.violations
+	}])).values()];
+}
+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 = asOptionalRecord(params.config?.agents);
+	const defaultValue = readPositiveInteger(asOptionalRecord(asOptionalRecord(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(asOptionalRecord(asOptionalRecord(list.find((entry) => {
+		const entryId = asOptionalRecord(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$1(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$1(params.args, ["provider", "channel"]) ?? params.toolName,
+		accountId: readFirstString$1(params.args, ["accountId", "account_id"]),
+		to: readFirstString$1(params.args, [
+			"to",
+			"target",
+			"recipient"
+		]),
+		threadId: readFirstString$1(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$1(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 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 isAsyncStartedToolResult(result) {
+	const details = result.details;
+	return isRecord(details) && details.async === true && details.status === "started";
+}
+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 withDynamicToolAsyncStarted(response, asyncStarted) {
+	if (!asyncStarted) return response;
+	Object.defineProperty(response, "asyncStarted", {
+		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 jsonObjectToRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return value;
+}
+function readFirstString$1(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
 //#region extensions/codex/src/app-server/elicitation-bridge.ts
 const MCP_TOOL_APPROVAL_KIND = "mcp_tool_call";
 const MCP_TOOL_APPROVAL_KIND_KEY = "codex_approval_kind";
@@ -1326,6 +1933,82 @@ const CODEX_NATIVE_HOOK_RELAY_EVENTS = [
 	"permission_request",
 	"before_agent_finalize"
 ];
+const CODEX_NATIVE_HOOK_RELAY_EVENTS_WITH_APP_SERVER_APPROVALS = CODEX_NATIVE_HOOK_RELAY_EVENTS.filter((event) => event !== "permission_request");
+const CODEX_NATIVE_HOOK_RELAY_MIN_TTL_MS = 30 * 6e4;
+const CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS = 5 * 6e4;
+const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS = 1e4;
+const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS = 5e3;
+const pendingCodexNativeHookRelayUnregisters = /* @__PURE__ */ new Set();
+function scheduleCodexNativeHookRelayUnregister(params) {
+	let pending;
+	const unregister = () => {
+		if (!pending) return;
+		const current = pending;
+		pending = void 0;
+		if (!pendingCodexNativeHookRelayUnregisters.delete(current)) return;
+		params.relay.unregister();
+	};
+	const timeout = setTimeout(unregister, resolveCodexNativeHookRelayUnregisterGraceMs(params.hookTimeoutSec));
+	pending = {
+		timeout,
+		unregister
+	};
+	pendingCodexNativeHookRelayUnregisters.add(pending);
+	timeout.unref();
+}
+function resolveCodexNativeHookRelayUnregisterGraceMs(hookTimeoutSec) {
+	const hookTimeoutMs = typeof hookTimeoutSec === "number" && Number.isFinite(hookTimeoutSec) && hookTimeoutSec > 0 ? Math.ceil(hookTimeoutSec) * 1e3 : 0;
+	return Math.max(CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS, hookTimeoutMs + CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS);
+}
+function createCodexNativeHookRelay(params) {
+	if (params.options?.enabled === false) return;
+	return registerNativeHookRelay({
+		provider: "codex",
+		relayId: buildCodexNativeHookRelayId({
+			agentId: params.agentId,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey
+		}),
+		...params.generation ? { generation: params.generation } : {},
+		...params.generationMismatchGraceMs ? { generationMismatchGraceMs: params.generationMismatchGraceMs } : {},
+		...params.agentId ? { agentId: params.agentId } : {},
+		sessionId: params.sessionId,
+		...params.sessionKey ? { sessionKey: params.sessionKey } : {},
+		...params.config ? { config: params.config } : {},
+		runId: params.runId,
+		...params.channelId ? { channelId: params.channelId } : {},
+		allowedEvents: params.events,
+		ttlMs: resolveCodexNativeHookRelayTtlMs({
+			explicitTtlMs: params.options?.ttlMs,
+			attemptTimeoutMs: params.attemptTimeoutMs,
+			startupTimeoutMs: params.startupTimeoutMs,
+			turnStartTimeoutMs: params.turnStartTimeoutMs
+		}),
+		signal: params.signal,
+		command: {
+			nice: 10,
+			timeoutMs: params.options?.gatewayTimeoutMs
+		}
+	});
+}
+function resolveCodexNativeHookRelayEvents(params) {
+	if (params.configuredEvents?.length) return params.configuredEvents;
+	return params.appServer.approvalPolicy === "never" ? CODEX_NATIVE_HOOK_RELAY_EVENTS : CODEX_NATIVE_HOOK_RELAY_EVENTS_WITH_APP_SERVER_APPROVALS;
+}
+function resolveCodexNativeHookRelayTtlMs(params) {
+	if (params.explicitTtlMs !== void 0) return params.explicitTtlMs;
+	const relayBudgetMs = params.attemptTimeoutMs + params.startupTimeoutMs + params.turnStartTimeoutMs + CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS;
+	return Math.max(CODEX_NATIVE_HOOK_RELAY_MIN_TTL_MS, Math.floor(relayBudgetMs));
+}
+function buildCodexNativeHookRelayId(params) {
+	const hash = createHash("sha256");
+	hash.update("openclaw:codex:native-hook-relay:v1");
+	hash.update("\0");
+	hash.update(params.agentId?.trim() || "");
+	hash.update("\0");
+	hash.update(params.sessionKey?.trim() || params.sessionId);
+	return `codex-${hash.digest("hex").slice(0, 40)}`;
+}
 const CODEX_HOOK_EVENT_BY_NATIVE_EVENT = {
 	pre_tool_use: "PreToolUse",
 	post_tool_use: "PostToolUse",
@@ -1408,10 +2091,4 @@ function sortJsonValue(value) {
 	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 a, emitDynamicToolTerminalDiagnostic as c, buildCodexNativeHookRelayDisabledConfig as i, handleCodexAppServerApprovalRequest as l, CODEX_NATIVE_HOOK_RELAY_EVENTS as n, emitDynamicToolErrorDiagnostic as o, buildCodexNativeHookRelayConfig as r, emitDynamicToolStartedDiagnostic as s, filterToolsForVisionInputs as t };
+export { normalizeCodexDynamicToolName as _, createCodexNativeHookRelay as a, scheduleCodexNativeHookRelayUnregister as c, emitDynamicToolErrorDiagnostic as d, emitDynamicToolStartedDiagnostic as f, isForcedPrivateQaCodexRuntime as g, filterCodexDynamicTools as h, buildCodexNativeHookRelayDisabledConfig as i, handleCodexAppServerElicitationRequest as l, filterToolsForVisionInputs as m, CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS as n, resolveCodexNativeHookRelayEvents as o, emitDynamicToolTerminalDiagnostic as p, buildCodexNativeHookRelayConfig as r, resolveCodexNativeHookRelayTtlMs as s, CODEX_NATIVE_HOOK_RELAY_EVENTS as t, createCodexDynamicToolBridge as u, resolveCodexDynamicToolsLoading as v, handleCodexAppServerApprovalRequest as y };