@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

package/dist/provider-capabilities-BpG9Ltc5.js

@@ -0,0 +1,101 @@
+import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CKhX2kFt.js";
+import { ut as normalizeCodexDynamicToolName } from "./thread-lifecycle-DPK30jad.js";
+import { pinExecToolTarget } from "openclaw/plugin-sdk/codex-mcp-projection";
+import { loadNodeExecAvailability } from "openclaw/plugin-sdk/node-selection-runtime";
+//#region extensions/codex/src/app-server/shell-dynamic-tools.ts
+const CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME = "node_exec";
+const CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME = "gateway_exec";
+const CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME = "gateway_process";
+const PROCESS_FOLLOWUP_TEXT = "Use process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.";
+/** Returns true when plugin config explicitly removes any named dynamic tool. */
+function isCodexDynamicToolExcluded(config, names) {
+	const normalizedNames = new Set(names.map((name) => normalizeCodexDynamicToolName(name)));
+	return (config.codexDynamicToolsExclude ?? []).some((name) => normalizedNames.has(normalizeCodexDynamicToolName(name)));
+}
+async function createNodeExecAliasDynamicTool(execTool, node, discoverySignal, availabilityRef) {
+	const pinnedNode = node?.trim();
+	const availability = await (availabilityRef ? availabilityRef.current ??= loadNodeExecAvailability(discoverySignal) : loadNodeExecAvailability(discoverySignal));
+	discoverySignal?.throwIfAborted();
+	if (!availability.isAvailable(pinnedNode)) return;
+	const pinnedTool = pinExecToolTarget(execTool, {
+		host: "node",
+		...pinnedNode ? { node: pinnedNode } : {}
+	});
+	const execute = async (toolCallId, args, signal, onUpdate) => {
+		const result = await pinnedTool.execute(toolCallId, args, signal, onUpdate);
+		return {
+			...result,
+			content: result.content.map((item) => item.type === "text" ? Object.assign({}, item, { text: item.text.replace(PROCESS_FOLLOWUP_TEXT, "Remote-node background follow-up is unavailable. Wait for the command to complete.") }) : item)
+		};
+	};
+	return {
+		...pinnedTool,
+		name: CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME,
+		description: pinnedNode ? "Run a shell command to completion on the OpenClaw configured remote node for this session. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Remote-node background follow-up is unavailable. Use Codex's native shell for local app-server work when it is available." : "Run a shell command to completion on an OpenClaw remote node. The sole connected node that can execute commands is selected automatically; select by name or id when several can. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Remote-node background follow-up is unavailable. Use Codex's native shell for local app-server work when it is available.",
+		execute
+	};
+}
+function createGatewayExecProjection(createProjection, execTool, params) {
+	return createProjection(execTool, {
+		kind: "exec",
+		name: CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME,
+		description: "Run a shell command through OpenClaw on the Gateway host for OpenClaw-managed Gateway environment access, including Secret Store agent-readable environment values and protected egress sentinels. Native Codex shell remains preferred for ordinary local work. This tool always uses OpenClaw host=gateway internally and follows Gateway exec approval and allowlist policy.",
+		followupText: params.processAliasAvailable ? "Use gateway_process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up." : "Background session follow-up is unavailable because gateway_process is not exposed. Rerun without background=true and set yieldMs high enough to wait for completion.",
+		...params.ask ? { ask: params.ask } : {}
+	});
+}
+function createGatewayProcessProjection(createProjection, processTool) {
+	return createProjection(processTool, {
+		kind: "process",
+		name: CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME,
+		description: "Manage background shell sessions in the existing per-session OpenClaw process scope: list, poll, log, write, send-keys, submit, paste, kill, clear, or remove. Use for gateway_exec follow-up; use native Codex shell session handling for ordinary local work."
+	});
+}
+//#endregion
+//#region extensions/codex/src/app-server/provider-capabilities.ts
+function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
+	const provider = modelProviderOverride?.trim().toLowerCase();
+	if (!provider) return;
+	return provider === "openai" ? "supported" : "unsupported";
+}
+async function readConfiguredProviderWebSearchSupport(params) {
+	return (await params.client.request("modelProvider/capabilities/read", {}, {
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	})).webSearch ? "supported" : "unsupported";
+}
+async function resolveCodexProviderWebSearchSupportForClient(params) {
+	const overrideSupport = resolveOverriddenProviderWebSearchSupport(params.modelProviderOverride);
+	if (overrideSupport) return overrideSupport;
+	try {
+		return await readConfiguredProviderWebSearchSupport(params);
+	} catch {
+		return "unknown";
+	}
+}
+async function resolveCodexProviderWebSearchSupport(params) {
+	const overrideSupport = resolveOverriddenProviderWebSearchSupport(params.modelProviderOverride);
+	if (overrideSupport) return overrideSupport;
+	let client;
+	try {
+		client = await params.clientFactory({
+			startOptions: params.appServer.start,
+			...params.preparedAuth ? { preparedAuth: params.preparedAuth } : { authProfileId: params.authProfileId },
+			agentDir: params.agentDir,
+			config: params.config,
+			timeoutMs: params.appServer.requestTimeoutMs
+		});
+		return await resolveCodexProviderWebSearchSupportForClient({
+			client,
+			timeoutMs: params.appServer.requestTimeoutMs,
+			modelProviderOverride: params.modelProviderOverride,
+			signal: params.signal
+		});
+	} catch {
+		return "unknown";
+	} finally {
+		if (client) releaseLeasedSharedCodexAppServerClient(client);
+	}
+}
+//#endregion
+export { CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME as a, createNodeExecAliasDynamicTool as c, CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME as i, isCodexDynamicToolExcluded as l, resolveCodexProviderWebSearchSupportForClient as n, createGatewayExecProjection as o, CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME as r, createGatewayProcessProjection as s, resolveCodexProviderWebSearchSupport as t };

package/dist/{rate-limits-C5_D8Gmb.js → rate-limits-Fx_l4eNa.js}

@@ -1,4 +1,4 @@
-import { vt as isJsonObject } from "./shared-client-DKz23hHY.js";
+import { B as isJsonObject } from "./config-CyapYSji.js";
 import { asBoolean, asFiniteNumber, normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
@@ -186,8 +186,9 @@ function isRateLimitSnapshot(value) {
 function readRateLimitWindow(snapshot, key) {
 	const window = snapshot[key];
 	if (!isJsonObject(window)) return;
+	const resetsAt = asFiniteNumber(window.resetsAt) ?? asFiniteNumber(window.resets_at);
 	return {
-		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(asFiniteNumber(window.resetsAt) ?? asFiniteNumber(window.resets_at), { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
+		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
 		...readOptionalNumberField(window, "usedPercent", "used_percent"),
 		...readOptionalNumberField(window, "windowDurationMins", "window_duration_mins", "windowMinutes", "window_minutes")
 	};

package/dist/{sandbox-guard-kuWTn9C5.js → request-C8H22rPi.js}

@@ -1,4 +1,6 @@
-import { p as isCodexRemoteExecPlacementSandbox } from "./config-giW8X0QA.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { E as isCodexRemoteExecPlacementSandbox } from "./config-CyapYSji.js";
+import { Ft as withTimeout, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, s as createIsolatedCodexAppServerClient, u as isCodexAppServerStartSelectionChangedError, y as retireSharedCodexAppServerClientIfCurrent } from "./shared-client-CKhX2kFt.js";
 import { resolveAgentConfig, tryResolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
 import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
@@ -279,4 +281,195 @@ function resolveCodexNativeNodeExecBlock(params) {
 	});
 }
 //#endregion
-export { resolveCodexNodeExecToolOverrides as a, resolveCodexNativeExecutionPolicy as i, resolveCodexNativeExecutionBlock as n, resolveCodexNativeSandboxBlock as r, resolveCodexAppServerDirectSandboxBypassBlock as t };
+//#region extensions/codex/src/app-server/request.ts
+var request_exports = /* @__PURE__ */ __exportAll({
+	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
+	readCodexAppServerUsage: () => readCodexAppServerUsage,
+	requestCodexAppServerClientJson: () => requestCodexAppServerClientJson,
+	requestCodexAppServerJson: () => requestCodexAppServerJson,
+	withCodexAppServerJsonClient: () => withCodexAppServerJsonClient
+});
+/** Sends one guarded request over a client lease owned by the caller. */
+async function requestCodexAppServerClientJson(params) {
+	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+		method: params.method,
+		requestParams: params.requestParams,
+		config: params.config,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId
+	});
+	if (sandboxBlock) throw new Error(sandboxBlock);
+	const timeoutMs = params.timeoutMs ?? 6e4;
+	return await withTimeout(params.client.request(params.method, params.requestParams, {
+		timeoutMs,
+		signal: params.signal,
+		...params.assertCurrent ? { assertCurrent: () => assertRequestOwnerCurrent(params.assertCurrent) } : {}
+	}), timeoutMs, `codex app-server ${params.method} timed out`);
+}
+async function requestCodexAppServerJson(params) {
+	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+		method: params.method,
+		requestParams: params.requestParams,
+		config: params.config,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId
+	});
+	if (sandboxBlock) throw new Error(sandboxBlock);
+	return await withCodexAppServerJsonClient({
+		...params,
+		timeoutMessage: `codex app-server ${params.method} timed out`
+	}, async (request) => await request({
+		method: params.method,
+		requestParams: params.requestParams
+	}));
+}
+/** A scoped guard rejected the request before a physical write. */
+var CodexAppServerScopedRequestRejectedError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "CodexAppServerScopedRequestRejectedError";
+	}
+};
+function assertRequestOwnerCurrent(assertCurrent) {
+	try {
+		assertCurrent?.();
+	} catch (cause) {
+		throw new CodexAppServerScopedRequestRejectedError(cause instanceof Error ? cause.message : String(cause), { cause });
+	}
+}
+const CODEX_USAGE_ISOLATED_SHUTDOWN = {
+	forceKillDelayMs: 200,
+	exitTimeoutMs: 300
+};
+const CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS = 4e3;
+const CODEX_USAGE_DEADLINE_RESERVE_MS = CODEX_USAGE_ISOLATED_SHUTDOWN.forceKillDelayMs + CODEX_USAGE_ISOLATED_SHUTDOWN.exitTimeoutMs + 250;
+/** Reads rate limits and best-effort account identity from one isolated app-server session. */
+async function readCodexAppServerUsage(options) {
+	const deadline = Date.now() + options.timeoutMs;
+	return await withCodexAppServerJsonClient({
+		timeoutMs: options.timeoutMs,
+		timeoutMessage: "codex app-server usage read timed out",
+		agentDir: options.agentDir,
+		...options.authProfileId ? { authProfileId: options.authProfileId } : {},
+		config: options.config,
+		startOptions: options.startOptions,
+		isolated: true,
+		isolatedShutdown: CODEX_USAGE_ISOLATED_SHUTDOWN
+	}, async (request) => {
+		const rateLimits = await request({ method: "account/rateLimits/read" });
+		const accountEmail = await readCodexAccountEmailBestEffort(request, deadline);
+		return {
+			rateLimits,
+			...accountEmail ? { accountEmail } : {}
+		};
+	});
+}
+function extractCodexAccountEmail(value) {
+	if (!value || typeof value !== "object") return;
+	const record = value;
+	const account = record.account && typeof record.account === "object" ? record.account : record;
+	const email = account.email ?? account.accountEmail;
+	return typeof email === "string" && email.trim() ? email.trim() : void 0;
+}
+async function readCodexAccountEmailBestEffort(request, deadline) {
+	const boundMs = Math.min(CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS, deadline - Date.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
+	if (boundMs <= 0) return;
+	const read = request({
+		method: "account/read",
+		requestParams: {}
+	}).then((account) => extractCodexAccountEmail(account), () => void 0);
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => resolve(void 0), boundMs);
+		timer.unref?.();
+	});
+	try {
+		return await Promise.race([read, timeout]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+/**
+* Runs several guarded requests over one acquired client (shared lease or
+* isolated child) so related reads see the same app-server session. The whole
+* callback re-runs once when the client's start selection changed underneath it.
+*/
+async function withCodexAppServerJsonClient(params, run) {
+	const timeoutMs = params.timeoutMs ?? 6e4;
+	const timeoutMessage = params.timeoutMessage ?? "codex app-server request timed out";
+	const timeoutController = new AbortController();
+	const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Date.now() + timeoutMs : void 0;
+	const isPastDeadline = () => deadline !== void 0 && Date.now() >= deadline;
+	const throwIfAbandoned = () => {
+		if (timeoutController.signal.aborted || isPastDeadline()) throw new CodexAppServerScopedRequestRejectedError(timeoutMessage);
+	};
+	const remainingTimeoutMs = () => {
+		throwIfAbandoned();
+		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - Date.now());
+	};
+	try {
+		return await withTimeout((async () => {
+			for (let attempt = 0; attempt < 2; attempt += 1) {
+				throwIfAbandoned();
+				const client = await (params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient)({
+					startOptions: params.startOptions,
+					pluginConfig: params.pluginConfig,
+					timeoutMs: remainingTimeoutMs(),
+					authProfileId: params.authProfileId,
+					authProfileStore: params.authProfileStore,
+					authBindingFingerprint: params.authBindingFingerprint,
+					preparedAuth: params.preparedAuth,
+					authRequirement: params.authRequirement,
+					agentDir: params.agentDir,
+					config: params.config,
+					abandonSignal: timeoutController.signal
+				});
+				let scopeActive = true;
+				const assertCurrent = () => {
+					throwIfAbandoned();
+					if (!scopeActive) throw new CodexAppServerScopedRequestRejectedError("Codex app-server request scope is closed");
+					assertRequestOwnerCurrent(params.assertCurrent);
+				};
+				try {
+					assertCurrent();
+					const scopedRequest = async (request) => {
+						const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+							method: request.method,
+							requestParams: request.requestParams,
+							config: params.config,
+							sessionKey: params.sessionKey,
+							sessionId: params.sessionId
+						});
+						if (sandboxBlock) throw new CodexAppServerScopedRequestRejectedError(sandboxBlock);
+						assertCurrent();
+						return await client.request(request.method, request.requestParams, {
+							timeoutMs: remainingTimeoutMs(),
+							signal: timeoutController.signal,
+							assertCurrent
+						});
+					};
+					return await run(scopedRequest, client, { assertCurrent });
+				} catch (error) {
+					if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
+					if (!params.isolated) retireSharedCodexAppServerClientIfCurrent(client);
+					throwIfAbandoned();
+				} finally {
+					scopeActive = false;
+					if (params.isolated) await client.closeAndWait({
+						exitTimeoutMs: params.isolatedShutdown?.exitTimeoutMs ?? 2e3,
+						forceKillDelayMs: params.isolatedShutdown?.forceKillDelayMs ?? 250
+					});
+					else releaseLeasedSharedCodexAppServerClient(client);
+				}
+			}
+			throw new Error("Codex app-server selection retry loop exited unexpectedly");
+		})(), timeoutMs, timeoutMessage);
+	} catch (error) {
+		if (isPastDeadline()) throw new Error(timeoutMessage, { cause: error });
+		throw error;
+	} finally {
+		timeoutController.abort();
+	}
+}
+//#endregion
+export { request_exports as a, resolveCodexNativeSandboxBlock as c, requestCodexAppServerJson as i, resolveCodexNativeExecutionPolicy as l, readCodexAppServerUsage as n, withCodexAppServerJsonClient as o, requestCodexAppServerClientJson as r, resolveCodexNativeExecutionBlock as s, CodexAppServerScopedRequestRejectedError as t, resolveCodexNodeExecToolOverrides as u };