@openclaw/codex 2026.6.11-beta.2 → 2026.6.33

package/dist/{provider-capabilities-D7hnTO76.js → provider-capabilities-B3pUz-8b.js}

@@ -1,18 +1,17 @@
 import { n as isJsonObject } from "./protocol-dh-ETiNd.js";
-import { C as isForcedPrivateQaCodexRuntime, S as filterCodexDynamicTools, _ as resolveCodexWebSearchPlan, w as normalizeCodexDynamicToolName, x as sanitizeInlineImageDataUrl, y as invalidInlineImageText } from "./thread-lifecycle-DtT3-ehU.js";
-import { c as isTrustedCodexModelBackedOpenAIProvider, u as readCodexPluginConfig } from "./config-CszD0vP3.js";
-import { a as formatCodexDisplayText } from "./app-server-policy-BPTiVNsW.js";
-import { o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-Dtx5i7Ez.js";
+import { C as isForcedPrivateQaCodexRuntime, S as filterCodexDynamicTools, _ as resolveCodexWebSearchPlan, w as normalizeCodexDynamicToolName, x as sanitizeInlineImageDataUrl, y as invalidInlineImageText } from "./thread-lifecycle-DXrm-WWA.js";
+import { l as readCodexPluginConfig } from "./config-DfV7hMHu.js";
+import { a as formatCodexDisplayText } from "./app-server-policy-BaB2492Z.js";
+import { o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-Ll9fWpy9.js";
 import { i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-3tnjhjFb.js";
-import { addTimerTimeoutGraceMs, finiteSecondsToTimerSafeMilliseconds, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { addTimerTimeoutGraceMs, finiteSecondsToTimerSafeMilliseconds, parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { asOptionalRecord, isRecord, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { HEARTBEAT_RESPONSE_TOOL_NAME, buildAgentHookContextChannelFields, buildEmbeddedAttemptToolRunContext, callGatewayTool, consumeAdjustedParamsForToolCall, consumePreExecutionBlockedToolCall, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractMessagingToolSend, extractMessagingToolSendResult, extractToolResultMediaArtifact, filterProviderNormalizableTools, filterToolResultMediaUrls, finalizeToolTerminalPresentation, formatApprovalDisplayPath, getChannelAgentToolMeta, getPluginToolMeta, hasNativeHookRelayInvocation, invokeNativeHookRelay, isMessagingTool, isMessagingToolSendAction, isReplaySafeToolCall, isSubagentSessionKey, isToolResultError, isToolWrappedWithBeforeToolCallHook, normalizeAgentRuntimeTools, normalizeHeartbeatToolResponse, projectRuntimeToolInputSchema, registerNativeHookRelay, resolveAttemptSpawnWorkspaceDir, resolveModelAuthMode, resolveNativeHookRelayDeferredToolApproval, runAgentHarnessAfterToolCallHook, runBeforeToolCallHook, sanitizeToolResult, setBeforeToolCallDiagnosticsEnabled, supportsModelTools, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { emitTrustedDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { emitTrustedDiagnosticEvent, hasPendingInternalDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { isToolAllowed } from "openclaw/plugin-sdk/sandbox";
-import { buildExecAutoReviewInputForShellCommand, reviewExecRequestWithConfiguredModel } from "openclaw/plugin-sdk/agent-harness-exec-review-runtime";
 /** Default idle timeout while waiting for app-server turn completion. */
 const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
 /** Short guard after apparent assistant completion. */
@@ -82,8 +81,9 @@ function resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(value, fallback
 	return resolvePositiveIntegerTimeoutMs(value, Math.max(resolvePositiveIntegerTimeoutMs(void 0, fallbackMs), CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS));
 }
 /** Resolves the long terminal turn idle timeout. */
-function resolveCodexTurnTerminalIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS);
+function resolveCodexTurnTerminalIdleTimeoutMs(value, runTimeoutOverrideMs) {
+	const explicitRunBudgetMs = resolvePositiveIntegerTimeoutMs(runTimeoutOverrideMs, CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS);
+	return resolvePositiveIntegerTimeoutMs(value, Math.max(CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS, explicitRunBudgetMs));
 }
 /** Adds gateway grace time to a caller timeout without overflowing invalid values. */
 function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
@@ -118,7 +118,13 @@ async function requestPluginApproval(params) {
 		timeoutMs,
 		twoPhase: true,
 		...params.allowedDecisions ? { allowedDecisions: params.allowedDecisions } : {}
-	}, { expectFinal: false });
+	}, params.finalResponse ? {
+		expectFinal: true,
+		onAccepted: (payload) => {
+			if (payload && typeof payload === "object" && !Array.isArray(payload)) params.finalResponse?.onAccepted?.(payload);
+		},
+		signal: params.finalResponse.signal
+	} : { expectFinal: false });
 }
 /** Detects the gateway's explicit null-decision marker for unavailable approvals. */
 function approvalRequestExplicitlyUnavailable(result) {
@@ -131,6 +137,19 @@ function approvalRequestExplicitlyUnavailable(result) {
 	}
 	return descriptor !== void 0 && "value" in descriptor && descriptor.value === null;
 }
+/** Reads a decision only from a final response, never from the accepted-phase payload. */
+function readFinalApprovalDecision(result) {
+	if (!result || typeof result !== "object" || Array.isArray(result)) return;
+	try {
+		const status = Object.getOwnPropertyDescriptor(result, "status");
+		if (status && "value" in status && status.value === "accepted") return;
+		const decision = Object.getOwnPropertyDescriptor(result, "decision");
+		if (!decision || !("value" in decision)) return;
+		return decision.value === null || decision.value === "allow-once" || decision.value === "allow-always" || decision.value === "deny" ? decision.value : void 0;
+	} catch {
+		return;
+	}
+}
 /** Waits for the gateway's final approval decision, respecting turn aborts. */
 async function waitForPluginApprovalDecision(params) {
 	const waitPromise = callGatewayTool("plugin.approval.waitDecision", { timeoutMs: resolveCodexGatewayTimeoutWithGraceMs(DEFAULT_CODEX_APPROVAL_TIMEOUT_MS) }, { id: params.approvalId });
@@ -242,34 +261,34 @@ async function handleCodexAppServerApprovalRequest(params) {
 			});
 			return buildApprovalResponse(params.method, context.requestParams, "approved-session");
 		}
-		const autoReviewOutcome = await runInternalExecAutoReviewForApprovalRequest({
-			enabled: params.internalExecAutoReview === true && params.execPolicy?.mode === "auto",
-			method: params.method,
-			requestParams,
-			paramsForRun: params.paramsForRun,
-			context,
-			agentId: params.execReviewerAgentId,
-			signal: params.signal
-		});
-		if (autoReviewOutcome?.outcome === "approved-once") {
+		let emittedApprovalRequestId;
+		const emitRequestedApproval = (approvalId) => {
+			if (emittedApprovalRequestId === approvalId) return;
+			emittedApprovalRequestId = approvalId;
 			emitApprovalEvent(params.paramsForRun, {
-				phase: "resolved",
+				phase: "requested",
 				kind: context.kind,
-				status: "approved",
+				status: "pending",
 				title: context.title,
+				approvalId,
+				approvalSlug: approvalId,
 				...context.eventDetails,
-				...approvalEventScope(params.method, autoReviewOutcome.outcome),
-				message: autoReviewOutcome.reason
+				message: "Codex app-server approval requested."
 			});
-			return buildApprovalResponse(params.method, context.requestParams, autoReviewOutcome.outcome);
-		}
+		};
 		const requestResult = await requestPluginApproval({
 			paramsForRun: params.paramsForRun,
 			title: context.title,
 			description: context.description,
 			severity: context.severity,
 			toolName: context.toolName,
-			toolCallId: context.itemId
+			toolCallId: context.approvalId,
+			finalResponse: {
+				signal: params.signal,
+				onAccepted: (accepted) => {
+					if (accepted.id) emitRequestedApproval(accepted.id);
+				}
+			}
 		});
 		const approvalId = requestResult?.id;
 		if (!approvalId) {
@@ -284,17 +303,9 @@ async function handleCodexAppServerApprovalRequest(params) {
 			});
 			return buildApprovalResponse(params.method, context.requestParams, "denied");
 		}
-		emitApprovalEvent(params.paramsForRun, {
-			phase: "requested",
-			kind: context.kind,
-			status: "pending",
-			title: context.title,
-			approvalId,
-			approvalSlug: approvalId,
-			...context.eventDetails,
-			message: "Codex app-server approval requested."
-		});
-		const outcome = mapExecDecisionToOutcome(approvalRequestExplicitlyUnavailable(requestResult) ? null : await waitForPluginApprovalDecision({
+		emitRequestedApproval(approvalId);
+		const finalDecision = readFinalApprovalDecision(requestResult);
+		const outcome = mapExecDecisionToOutcome(approvalRequestExplicitlyUnavailable(requestResult) ? null : finalDecision ?? await waitForPluginApprovalDecision({
 			approvalId,
 			signal: params.signal
 		}));
@@ -348,6 +359,7 @@ function matchesCurrentTurn(requestParams, threadId, turnId) {
 }
 function buildApprovalContext(params) {
 	const itemId = readString$1(params.requestParams, "itemId") ?? readString$1(params.requestParams, "callId") ?? readString$1(params.requestParams, "approvalId");
+	const approvalId = readString$1(params.requestParams, "approvalId") ?? itemId;
 	const commandDetailLines = params.method === "item/commandExecution/requestApproval" ? describeCommandApprovalDetails(params.requestParams) : [];
 	const commandPreview = sanitizeApprovalPreview(readDisplayCommandPreview(params.requestParams), commandDetailLines.length > 0 ? COMMAND_PREVIEW_WITH_DETAILS_MAX_LENGTH : 180);
 	const reasonPreview = sanitizeApprovalPreview(readStringPreview(params.requestParams, "reason"), 180);
@@ -368,6 +380,7 @@ function buildApprovalContext(params) {
 		severity: kind === "exec" ? "warning" : "info",
 		toolName: kind === "exec" ? "codex_command_approval" : params.method === "item/permissions/requestApproval" ? "codex_permission_approval" : "codex_file_approval",
 		itemId,
+		approvalId,
 		requestParams: params.requestParams,
 		eventDetails: {
 			...itemId ? { itemId } : {},
@@ -378,132 +391,6 @@ function buildApprovalContext(params) {
 		}
 	};
 }
-async function runInternalExecAutoReviewForApprovalRequest(params) {
-	if (!params.enabled || params.method !== "item/commandExecution/requestApproval") return;
-	if (hasCommandApprovalCapabilityAmendments(params.requestParams)) return;
-	const input = await buildAppServerExecAutoReviewInput({
-		requestParams: params.requestParams,
-		paramsForRun: params.paramsForRun
-	});
-	if (!input) return;
-	const reviewerConfig = resolveExecReviewerConfig(params.paramsForRun, params.agentId);
-	if (!canUseInternalExecAutoReviewReviewer(reviewerConfig, params.paramsForRun.config, process.env, params.paramsForRun.agentDir)) return;
-	const decision = await waitForInternalExecAutoReviewDecision({
-		signal: params.signal,
-		promise: reviewExecRequestWithConfiguredModel({
-			cfg: params.paramsForRun.config,
-			agentId: params.agentId ?? params.paramsForRun.agentId,
-			reviewer: reviewerConfig,
-			input
-		})
-	});
-	if (decision.decision !== "allow-once") return;
-	return {
-		outcome: "approved-once",
-		reason: `Codex app-server command approval granted by OpenClaw exec auto-reviewer: ${formatCodexDisplayText(decision.rationale)}`
-	};
-}
-async function waitForInternalExecAutoReviewDecision(params) {
-	if (!params.signal) return params.promise;
-	if (params.signal.aborted) throw toCodexAppServerApprovalCancellationError(params.signal.reason);
-	let onAbort;
-	const abortPromise = new Promise((_, reject) => {
-		onAbort = () => reject(toCodexAppServerApprovalCancellationError(params.signal?.reason));
-		params.signal?.addEventListener("abort", onAbort, { once: true });
-	});
-	try {
-		return await Promise.race([params.promise, abortPromise]);
-	} finally {
-		if (onAbort) params.signal.removeEventListener("abort", onAbort);
-	}
-}
-function toCodexAppServerApprovalCancellationError(reason) {
-	if (reason instanceof Error) return reason;
-	return new Error(typeof reason === "string" && reason.trim() ? reason : "Codex app-server approval cancelled.");
-}
-async function buildAppServerExecAutoReviewInput(params) {
-	const command = readString$1(params.requestParams, "command");
-	if (!command) return;
-	return buildExecAutoReviewInputForShellCommand({
-		command,
-		cwd: readString$1(params.requestParams, "cwd") ?? params.paramsForRun.workspaceDir ?? null,
-		host: "codex-app-server",
-		agent: {
-			id: params.paramsForRun.agentId ?? null,
-			sessionKey: params.paramsForRun.sessionKey ?? null
-		}
-	});
-}
-function hasCommandApprovalCapabilityAmendments(requestParams) {
-	return hasNonEmptyJsonObject(requestParams?.additionalPermissions) || hasNonEmptyJsonObject(requestParams?.networkApprovalContext) || hasNonEmptyJsonObject(requestParams?.proposedExecpolicyAmendment) || hasNonEmptyArray(requestParams?.proposedExecpolicyAmendment) || hasNonEmptyArray(requestParams?.proposedNetworkPolicyAmendments) || findAvailableCommandAmendmentDecision(requestParams) !== void 0 || commandAcceptDecisionUnavailable(requestParams);
-}
-function commandAcceptDecisionUnavailable(requestParams) {
-	const available = requestParams?.availableDecisions;
-	return Array.isArray(available) && !available.includes("accept");
-}
-function hasNonEmptyJsonObject(value) {
-	return isJsonObject(value) && Object.keys(value).length > 0;
-}
-function hasNonEmptyArray(value) {
-	return Array.isArray(value) && value.length > 0;
-}
-function resolveExecReviewerConfig(params, agentId) {
-	const configRoot = readUnknownRecord(params.config);
-	const globalExec = readUnknownRecord(readUnknownRecord(configRoot?.tools)?.exec);
-	return readUnknownRecord(resolveAgentExecConfig(configRoot, agentId ?? params.agentId)?.reviewer) ?? readUnknownRecord(globalExec?.reviewer);
-}
-function canUseInternalExecAutoReviewReviewer(reviewerConfig, config, env, agentDir) {
-	const model = readExecReviewerModelRef(reviewerConfig);
-	const slashIndex = model?.indexOf("/") ?? -1;
-	if (!model || slashIndex <= 0) return false;
-	if (configuredAgentModelAliasMatches(config, model)) return false;
-	if (model.slice(0, slashIndex).trim().toLowerCase() !== "openai") return false;
-	return isTrustedCodexModelBackedOpenAIProvider({
-		config,
-		env,
-		agentDir,
-		model: model.slice(slashIndex + 1).trim()
-	});
-}
-function readExecReviewerModelRef(reviewerConfig) {
-	const model = reviewerConfig?.model;
-	if (typeof model === "string") return model.trim() || void 0;
-	const primary = readUnknownRecord(model)?.primary;
-	return typeof primary === "string" && primary.trim() ? primary.trim() : void 0;
-}
-function configuredAgentModelAliasMatches(config, modelRef) {
-	const normalizedModelRef = normalizeExecReviewerAliasRef(modelRef);
-	return agentModelAliasMatches(readUnknownRecord(readUnknownRecord(readUnknownRecord(config)?.agents)?.defaults), normalizedModelRef);
-}
-function agentModelAliasMatches(agentConfig, normalizedModelRef) {
-	const models = readUnknownRecord(agentConfig?.models);
-	if (!models) return false;
-	for (const entry of Object.values(models)) {
-		const alias = readUnknownRecord(entry)?.alias;
-		if (typeof alias === "string" && normalizeExecReviewerAliasRef(alias) === normalizedModelRef) return true;
-	}
-	return false;
-}
-function normalizeExecReviewerAliasRef(modelRef) {
-	const trimmed = modelRef.trim().toLowerCase();
-	const slashIndex = trimmed.indexOf("/");
-	const authProfileIndex = trimmed.indexOf("@", slashIndex + 1);
-	return authProfileIndex > 0 ? trimmed.slice(0, authProfileIndex) : trimmed;
-}
-function resolveAgentExecConfig(configRoot, agentId) {
-	const normalizedAgentId = agentId ? normalizeAgentId(agentId) : void 0;
-	if (!normalizedAgentId) return;
-	const agentList = readUnknownRecord(configRoot?.agents)?.list;
-	if (!Array.isArray(agentList)) return;
-	for (const entry of agentList) {
-		const record = readUnknownRecord(entry);
-		if (typeof record?.id !== "string" || normalizeAgentId(record.id) !== normalizedAgentId) continue;
-		return readUnknownRecord(readUnknownRecord(record.tools)?.exec);
-	}
-}
-function readUnknownRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
 async function runOpenClawToolPolicyForApprovalRequest(params) {
 	const policyRequest = buildOpenClawToolPolicyRequest(params.method, params.requestParams);
 	if (!policyRequest) return;
@@ -533,7 +420,7 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 	const outcome = await runBeforeToolCallHook({
 		toolName: policyRequest.toolName,
 		params: policyRequest.params,
-		...params.context.itemId ? { toolCallId: params.context.itemId } : {},
+		...params.context.approvalId ? { toolCallId: params.context.approvalId } : {},
 		approvalMode: "request",
 		signal: params.signal,
 		ctx: {
@@ -568,11 +455,11 @@ async function runNativeRelayToolPolicyForApprovalRequest(params) {
 	if (hasNativeHookRelayInvocation({
 		relayId: params.nativeHookRelay.relayId,
 		event: "pre_tool_use",
-		toolUseId: params.context.itemId
+		toolUseId: params.context.approvalId
 	})) {
 		const approvalOutcome = await resolveNativeHookRelayDeferredToolApproval({
 			relayId: params.nativeHookRelay.relayId,
-			toolUseId: params.context.itemId,
+			toolUseId: params.context.approvalId,
 			signal: params.signal
 		});
 		if (approvalOutcome?.outcome === "denied") return {
@@ -602,7 +489,7 @@ async function runNativeRelayToolPolicyForApprovalRequest(params) {
 		};
 		const approvalOutcome = await resolveNativeHookRelayDeferredToolApproval({
 			relayId: params.nativeHookRelay.relayId,
-			toolUseId: params.context.itemId,
+			toolUseId: params.context.approvalId,
 			signal: params.signal
 		});
 		if (approvalOutcome?.outcome === "denied") return {
@@ -631,7 +518,7 @@ function buildNativeRelayPreToolUsePayload(params) {
 		hook_event_name: "PreToolUse",
 		openclaw_approval_mode: "report",
 		tool_name: "exec_command",
-		...params.context.itemId ? { tool_use_id: params.context.itemId } : {},
+		...params.context.approvalId ? { tool_use_id: params.context.approvalId } : {},
 		...params.cwd ? { cwd: params.cwd } : {},
 		...turnId ? { turn_id: turnId } : {},
 		tool_input: {
@@ -1661,6 +1548,272 @@ function emitDynamicToolTerminalDiagnostic(params) {
 	}
 	emitDynamicToolErrorDiagnostic(params);
 }
+/** Hard cap for per-call Codex dynamic tool timeout overrides. */
+const CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS = 6e5;
+const CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS = 3e4;
+const CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS = 12e4;
+/** Timeout for message-delivery dynamic tool calls. */
+const CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS = CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS;
+const LOG_FIELD_MAX_LENGTH = 160;
+function normalizeLogField(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.replaceAll(String.fromCharCode(27), " ").replaceAll("\r", " ").replaceAll("\n", " ").replaceAll("	", " ").trim();
+	if (!normalized) return;
+	return normalized.length > LOG_FIELD_MAX_LENGTH ? `${normalized.slice(0, LOG_FIELD_MAX_LENGTH - 3)}...` : normalized;
+}
+function readNumericTimeoutMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return Math.max(0, Math.floor(value));
+	if (typeof value === "string") {
+		const parsed = parseStrictNonNegativeInteger(value);
+		if (parsed !== void 0) return Math.max(0, Math.floor(parsed));
+	}
+}
+function formatDynamicToolTimeoutDetails(params) {
+	const tool = normalizeLogField(params.call.tool) ?? "unknown";
+	const baseMeta = {
+		tool: params.call.tool,
+		toolCallId: params.call.callId,
+		threadId: params.call.threadId,
+		turnId: params.call.turnId,
+		timeoutMs: params.timeoutMs,
+		timeoutKind: "codex_dynamic_tool_rpc"
+	};
+	if (tool !== "process" || !isJsonObject(params.call.arguments)) return {
+		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms while running tool ${tool}.`,
+		consoleMessage: `codex dynamic tool timeout: tool=${tool} toolTimeoutMs=${params.timeoutMs}; per-tool-call watchdog, not session idle`,
+		meta: baseMeta
+	};
+	const action = normalizeLogField(params.call.arguments.action);
+	const sessionId = normalizeLogField(params.call.arguments.sessionId);
+	const requestedTimeoutMs = readNumericTimeoutMs(params.call.arguments.timeout);
+	const actionPart = action ? ` action=${action}` : "";
+	const sessionPart = sessionId ? ` sessionId=${sessionId}` : "";
+	const requestedPart = requestedTimeoutMs === void 0 ? "" : ` requestedWaitMs=${requestedTimeoutMs}`;
+	const retryHint = action === "poll" ? "; repeated lines usually mean process-poll retry churn, not model progress" : "";
+	const responseTarget = action || sessionId ? ` while waiting for process${actionPart}${sessionPart}` : " while waiting for the process tool";
+	return {
+		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms${responseTarget}. This is a tool RPC timeout, not a session idle timeout.`,
+		consoleMessage: `codex process tool timeout:${actionPart}${sessionPart} toolTimeoutMs=${params.timeoutMs}${requestedPart}; per-tool-call watchdog, not session idle${retryHint}`,
+		meta: {
+			...baseMeta,
+			processAction: action,
+			processSessionId: sessionId,
+			processRequestedTimeoutMs: requestedTimeoutMs
+		}
+	};
+}
+/**
+* Runs a dynamic tool call with run-abort and per-call timeout handling,
+* returning a Codex protocol response instead of throwing.
+*/
+async function handleDynamicToolCallWithTimeout(params) {
+	let didNotifyAgentToolResult = false;
+	const notifyAgentToolResult = (event) => {
+		if (didNotifyAgentToolResult) return;
+		didNotifyAgentToolResult = true;
+		try {
+			params.onAgentToolResult?.(event);
+		} catch (error) {
+			embeddedAgentLog.warn(`onAgentToolResult handler failed: tool=${params.call.tool} error=${String(error)}`);
+		}
+	};
+	const notifyFailedToolResult = (message) => {
+		notifyAgentToolResult({
+			toolName: params.call.tool,
+			result: {
+				content: [{
+					type: "text",
+					text: message
+				}],
+				details: {
+					status: "failed",
+					error: message
+				}
+			},
+			isError: true
+		});
+	};
+	if (params.signal.aborted) {
+		const message = "OpenClaw dynamic tool call aborted before execution.";
+		params.onFallbackSelected?.();
+		notifyFailedToolResult(message);
+		return failedDynamicToolResponse(message);
+	}
+	const controller = new AbortController();
+	let timeout;
+	let timedOut = false;
+	let resolveAbort;
+	const abortFromRun = () => {
+		const message = "OpenClaw dynamic tool call aborted.";
+		params.onFallbackSelected?.();
+		controller.abort(params.signal.reason ?? /* @__PURE__ */ new Error(message));
+		notifyFailedToolResult(message);
+		resolveAbort?.(failedDynamicToolResponse(message, { sideEffectEvidence: true }));
+	};
+	const abortPromise = new Promise((resolve) => {
+		resolveAbort = resolve;
+	});
+	const timeoutPromise = new Promise((resolve) => {
+		const timeoutMs = clampDynamicToolTimeoutMs(params.timeoutMs);
+		timeout = setTimeout(() => {
+			timedOut = true;
+			const timeoutDetails = formatDynamicToolTimeoutDetails({
+				call: params.call,
+				timeoutMs
+			});
+			params.onFallbackSelected?.();
+			controller.abort(new Error(timeoutDetails.responseMessage));
+			params.onTimeout?.();
+			embeddedAgentLog.warn("codex dynamic tool call timed out", {
+				...timeoutDetails.meta,
+				consoleMessage: timeoutDetails.consoleMessage
+			});
+			notifyFailedToolResult(timeoutDetails.responseMessage);
+			resolve(failedDynamicToolResponse(timeoutDetails.responseMessage, { sideEffectEvidence: true }));
+		}, timeoutMs);
+		timeout.unref?.();
+	});
+	try {
+		params.signal.addEventListener("abort", abortFromRun, { once: true });
+		if (params.signal.aborted) abortFromRun();
+		const response = await Promise.race([
+			params.toolBridge.handleToolCall(params.call, {
+				signal: controller.signal,
+				onAgentToolResult: notifyAgentToolResult,
+				toolCallOrdinal: params.toolCallOrdinal
+			}),
+			abortPromise,
+			timeoutPromise
+		]);
+		if (!response.success && !didNotifyAgentToolResult) notifyFailedToolResult(readDynamicToolResponseText(response));
+		return response;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		notifyFailedToolResult(message);
+		return failedDynamicToolResponse(message, { sideEffectEvidence: true });
+	} finally {
+		if (timeout) clearTimeout(timeout);
+		params.signal.removeEventListener("abort", abortFromRun);
+		resolveAbort = void 0;
+		if (!timedOut && !controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("OpenClaw dynamic tool call finished."));
+	}
+}
+function readDynamicToolResponseText(response) {
+	return response.contentItems.flatMap((item) => item.type === "inputText" && typeof item.text === "string" ? [item.text] : []).join("\n").trim() || "OpenClaw dynamic tool call failed.";
+}
+function failedDynamicToolResponse(message, options) {
+	const response = {
+		contentItems: [{
+			type: "inputText",
+			text: message
+		}],
+		success: false
+	};
+	Object.defineProperty(response, "diagnosticTerminalType", {
+		configurable: true,
+		enumerable: false,
+		value: "error"
+	});
+	if (options?.sideEffectEvidence === true) Object.defineProperty(response, "sideEffectEvidence", {
+		configurable: true,
+		enumerable: false,
+		value: true
+	});
+	return response;
+}
+/** Strips OpenClaw-only metadata before sending a dynamic tool response to Codex. */
+function toCodexDynamicToolProtocolResponse(response) {
+	return {
+		contentItems: response.contentItems,
+		success: response.success
+	};
+}
+/** Adds async-started progress details when a tool result continues out of band. */
+function toCodexDynamicToolProgressResponse(response, protocolResponse) {
+	if (response.asyncStarted !== true) return protocolResponse;
+	return {
+		...protocolResponse,
+		details: {
+			async: true,
+			status: "started"
+		}
+	};
+}
+/** Decides whether a terminal dynamic tool response can release the Codex turn. */
+function shouldReleaseTurnAfterTerminalDynamicTool(state) {
+	return !state.completed && !state.aborted && state.responseSuccess && !state.currentTurnHadNonTerminalDynamicToolResult && state.activeAppServerTurnRequests === 0 && state.activeTurnItemIdsCount === 0 && state.pendingOpenClawDynamicToolCompletionIdsCount === 0;
+}
+/** Returns true when a non-async result should block terminal-release shortcuts. */
+function shouldBlockTerminalReleaseForNonTerminalDynamicToolResult(response) {
+	return response.asyncStarted !== true;
+}
+/** Resolves whether terminal diagnostic state should release, wait, or stay idle. */
+function resolveTerminalDynamicToolBatchAction(state) {
+	if (state.activeAppServerTurnRequests > 0 || state.activeTurnItemIdsCount > 0 || state.pendingOpenClawDynamicToolCompletionIdsCount > 0) return "wait";
+	if (state.currentTurnHadNonTerminalDynamicToolResult) return "clear-nonterminal-batch";
+	if (state.hasPendingTerminalDynamicToolRelease) return "release-pending-terminal";
+	return "idle";
+}
+/** Returns true for diagnostic events that terminate a dynamic tool call. */
+function isDynamicToolTerminalDiagnosticEvent(event) {
+	return event.type === "tool.execution.completed" || event.type === "tool.execution.error" || event.type === "tool.execution.blocked";
+}
+/** Matches terminal diagnostics to a specific dynamic tool call id/name. */
+function isMatchingDynamicToolTerminalDiagnostic(params) {
+	if (params.event.toolCallId !== params.call.callId || params.event.toolName !== params.call.tool) return false;
+	if (params.runId !== void 0) return params.event.runId === params.runId;
+	if (params.sessionId !== void 0) return params.event.sessionId === params.sessionId;
+	if (params.sessionKey !== void 0) return params.event.sessionKey === params.sessionKey;
+	return params.event.runId === void 0 && params.event.sessionId === void 0 && params.event.sessionKey === void 0;
+}
+/** Checks pending diagnostics for a terminal event matching a tool call. */
+function hasPendingDynamicToolTerminalDiagnostic(params) {
+	return hasPendingInternalDiagnosticEvent((event) => {
+		if (!isDynamicToolTerminalDiagnosticEvent(event)) return false;
+		return isMatchingDynamicToolTerminalDiagnostic({
+			event,
+			call: params.call,
+			runId: params.runId,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey
+		});
+	});
+}
+/** Resolves per-tool timeout, applying media/message defaults and hard caps. */
+function resolveDynamicToolCallTimeoutMs(params) {
+	if (params.call.tool === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
+	return clampDynamicToolTimeoutMs(readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? 9e4);
+}
+function readDynamicToolCallTimeoutMs(value) {
+	if (!isJsonObject(value)) return;
+	const timeoutMs = readPositiveFiniteTimeoutMs(value.timeoutMs);
+	if (timeoutMs !== void 0) return timeoutMs;
+	const timeoutSecondsMs = readDynamicToolTimeoutSecondsAsMs(value.timeoutSeconds);
+	return timeoutSecondsMs === void 0 ? void 0 : addTimerTimeoutGraceMs(timeoutSecondsMs, CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS);
+}
+function readConfiguredDynamicToolTimeoutMs(toolName, config) {
+	if (toolName === "image_generate") {
+		const imageGenerationModel = config?.agents?.defaults?.imageGenerationModel;
+		if (!imageGenerationModel || typeof imageGenerationModel !== "object") return CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
+		return readPositiveFiniteTimeoutMs(imageGenerationModel.timeoutMs) ?? CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
+	}
+	if (toolName === "image") return readTimeoutSecondsAsMs(config?.tools?.media?.image?.timeoutSeconds) ?? 6e4;
+	if (toolName === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
+}
+function readTimeoutSecondsAsMs(value) {
+	const seconds = readPositiveFiniteTimeoutMs(value);
+	return seconds === void 0 ? void 0 : seconds * 1e3;
+}
+function readDynamicToolTimeoutSecondsAsMs(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) return;
+	return value * 1e3;
+}
+function readPositiveFiniteTimeoutMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+function clampDynamicToolTimeoutMs(timeoutMs) {
+	return Math.max(1, Math.min(CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS, Math.floor(timeoutMs)));
+}
 //#endregion
 //#region extensions/codex/src/app-server/dynamic-tools.ts
 function applyCurrentMessageProvider(toolName, args, currentProvider) {
@@ -2995,6 +3148,7 @@ 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_COMMAND_MIN_PARENT_MARGIN_MS = 250;
 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 pendingCodexNativeHookRelayUnregisters = /* @__PURE__ */ new Set();
@@ -3018,7 +3172,7 @@ function scheduleCodexNativeHookRelayUnregister(params) {
 }
 /** Computes the delayed unregister window from Codex's hook timeout. */
 function resolveCodexNativeHookRelayUnregisterGraceMs(hookTimeoutSec) {
-	const hookTimeoutMs = typeof hookTimeoutSec === "number" && Number.isFinite(hookTimeoutSec) && hookTimeoutSec > 0 ? finiteSecondsToTimerSafeMilliseconds(Math.ceil(hookTimeoutSec)) ?? 0 : 0;
+	const hookTimeoutMs = finiteSecondsToTimerSafeMilliseconds(normalizeHookTimeoutSec(hookTimeoutSec)) ?? 0;
 	return Math.max(CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS, addTimerTimeoutGraceMs(hookTimeoutMs, CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS) ?? 0);
 }
 /** Registers an OpenClaw native hook relay for a Codex app-server turn. */
@@ -3136,7 +3290,7 @@ function buildCodexNativeHookRelayDisabledConfig() {
 	};
 }
 function normalizeHookTimeoutSec(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.ceil(value) : 5;
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.ceil(value) : CODEX_NATIVE_HOOK_RELAY_DEFAULT_TIMEOUT_SEC;
 }
 function resolveCodexNativeHookRelayCommandTimeoutMs(hookTimeoutSec) {
 	const parentTimeoutMs = finiteSecondsToTimerSafeMilliseconds(normalizeHookTimeoutSec(hookTimeoutSec)) ?? 5e3;
@@ -3198,4 +3352,4 @@ async function resolveCodexProviderWebSearchSupport(params) {
 	}
 }
 //#endregion
-export { CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as A, resolveCodexMessageToolProvider as C, shouldWarnCodexDynamicToolBuildStageSummary as D, shouldRequireCodexSandboxExecServerEnvironment as E, resolveCodexTurnTerminalIdleTimeoutMs as F, withCodexStartupTimeout as I, resolveCodexStartupTimeoutMs as M, resolveCodexTurnAssistantCompletionIdleTimeoutMs as N, filterToolsForVisionInputs as O, resolveCodexTurnCompletionIdleTimeoutMs as P, resolveCodexExternalSandboxPolicyForOpenClawSandbox as S, shouldEnableCodexAppServerNativeToolSurface as T, createCodexDynamicToolBuildStageTracker as _, buildCodexNativeHookRelayConfig as a, resolveCodexAppServerExecutionCwd as b, resolveCodexNativeHookRelayEvents as c, handleCodexAppServerElicitationRequest as d, createCodexDynamicToolBridge as f, buildDynamicTools as g, emitDynamicToolTerminalDiagnostic as h, CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS as i, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as j, handleCodexAppServerApprovalRequest as k, resolveCodexNativeHookRelayTtlMs as l, emitDynamicToolStartedDiagnostic as m, resolveCodexProviderWebSearchSupportForClient as n, buildCodexNativeHookRelayDisabledConfig as o, emitDynamicToolErrorDiagnostic as p, CODEX_NATIVE_HOOK_RELAY_EVENTS as r, createCodexNativeHookRelay as s, resolveCodexProviderWebSearchSupport as t, scheduleCodexNativeHookRelayUnregister as u, disableCodexPluginThreadConfig as v, resolveCodexSandboxEnvironmentSelection as w, resolveCodexAppServerHookChannelId as x, formatCodexDynamicToolBuildStageSummary as y };
+export { resolveCodexAppServerExecutionCwd as A, CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as B, emitDynamicToolErrorDiagnostic as C, createCodexDynamicToolBuildStageTracker as D, buildDynamicTools as E, shouldEnableCodexAppServerNativeToolSurface as F, resolveCodexTurnTerminalIdleTimeoutMs as G, resolveCodexStartupTimeoutMs as H, shouldRequireCodexSandboxExecServerEnvironment as I, withCodexStartupTimeout as K, shouldWarnCodexDynamicToolBuildStageSummary as L, resolveCodexExternalSandboxPolicyForOpenClawSandbox as M, resolveCodexMessageToolProvider as N, disableCodexPluginThreadConfig as O, resolveCodexSandboxEnvironmentSelection as P, filterToolsForVisionInputs as R, toCodexDynamicToolProtocolResponse as S, emitDynamicToolTerminalDiagnostic as T, resolveCodexTurnAssistantCompletionIdleTimeoutMs as U, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as V, resolveCodexTurnCompletionIdleTimeoutMs as W, resolveDynamicToolCallTimeoutMs as _, buildCodexNativeHookRelayConfig as a, shouldReleaseTurnAfterTerminalDynamicTool as b, resolveCodexNativeHookRelayEvents as c, handleCodexAppServerElicitationRequest as d, createCodexDynamicToolBridge as f, isMatchingDynamicToolTerminalDiagnostic as g, isDynamicToolTerminalDiagnosticEvent as h, CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS as i, resolveCodexAppServerHookChannelId as j, formatCodexDynamicToolBuildStageSummary as k, resolveCodexNativeHookRelayTtlMs as l, hasPendingDynamicToolTerminalDiagnostic as m, resolveCodexProviderWebSearchSupportForClient as n, buildCodexNativeHookRelayDisabledConfig as o, handleDynamicToolCallWithTimeout as p, CODEX_NATIVE_HOOK_RELAY_EVENTS as r, createCodexNativeHookRelay as s, resolveCodexProviderWebSearchSupport as t, scheduleCodexNativeHookRelayUnregister as u, resolveTerminalDynamicToolBatchAction as v, emitDynamicToolStartedDiagnostic as w, toCodexDynamicToolProgressResponse as x, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as y, handleCodexAppServerApprovalRequest as z };

package/dist/provider.js

@@ -1,2 +1,2 @@
-import { n as buildCodexProviderCatalog, r as isModernCodexModel, t as buildCodexProvider } from "./provider-B-OHpbD3.js";
+import { n as buildCodexProviderCatalog, r as isModernCodexModel, t as buildCodexProvider } from "./provider-J2nTGL8Q.js";
 export { buildCodexProvider, buildCodexProviderCatalog, isModernCodexModel };

package/dist/{request-Dcd452Nk.js → request-RiBbqNPj.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as getLeasedSharedCodexAppServerClient, i as createIsolatedCodexAppServerClient, l as withTimeout, o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-Dtx5i7Ez.js";
+import { a as getLeasedSharedCodexAppServerClient, i as createIsolatedCodexAppServerClient, l as withTimeout, o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-Ll9fWpy9.js";
 import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-3tnjhjFb.js";
 //#region extensions/codex/src/app-server/request.ts
 var request_exports = /* @__PURE__ */ __exportAll({ requestCodexAppServerJson: () => requestCodexAppServerJson });