@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/{bounded-turn-C_Hneydj.js → .setup/bounded-turn-B2HScEgT.mjs}

@@ -1,16 +1,80 @@
-import { r as readCodexAppServerConfigOptions } from "./launch-args-RXQwn8zV.js";
-import { C as readCodexErrorNotification, E as createCodexElicitationResponse, b as assertCodexThreadStartResponse, x as assertCodexTurnStartResponse } from "./client-B57KWPQx.js";
-import "./config-oIORaQ5T.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
-import { u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CscigXXL.js";
-import { a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-DKHzbwt5.js";
-import { t as CodexEphemeralTurn } from "./ephemeral-turn-D78_VmzO.js";
-import { r as readModelListResult } from "./models-PCKOim-h.js";
-import { Et as mergeCodexThreadConfigs, K as attestCodexRestrictedToolSurfaceMcpServersDisabled, _ as assertCodexManagedRequirementsDoNotOverrideToolPolicy, v as buildCodexRingZeroThreadConfigPatch, x as readCodexInheritedMcpServerNames, y as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-DXl1-I6b.js";
+import { a as resolveCodexPrivateLauncher, i as readCodexAppServerConfigOptions } from "./launch-args-DbFCehO7.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { d as readCodexEffectiveConfig } from "./config-options-BvaRs51b.mjs";
+import "./config-BoTP_mrL.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
+import { u as isCodexAppServerStartSelectionChangedError } from "./shared-client-DA4VR4Eb.mjs";
+import { E as createCodexElicitationResponse, S as assertCodexTurnStartResponse, w as readCodexErrorNotification, x as assertCodexThreadStartResponse } from "./client-Cs08OXVQ.mjs";
+import { o as closeCodexStartupClientBestEffort, s as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-CEv1cKwF.mjs";
+import { t as CodexEphemeralTurn } from "./ephemeral-turn-poidXgek.mjs";
+import { r as readModelListResult } from "./models-KnqBv0hE.mjs";
+import { L as attestCodexRestrictedToolSurfaceMcpServersDisabled, l as readCodexInheritedMcpServerNames, n as buildCodexRingZeroThreadConfigPatch, r as buildCodexRuntimeThreadConfig, t as assertCodexManagedRequirementsDoNotOverrideToolPolicy, xt as mergeCodexThreadConfigs } from "./thread-requests-BLvGkP2R.mjs";
+import { M as resolveCodexAppServerReasoningEffort } from "./thread-lifecycle-B3mfz1TG.mjs";
+import { a as resolveCodexPromptError } from "./usage-limit-error-DUMbefVY.mjs";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { parse } from "smol-toml";
 import path from "node:path";
 import fs from "node:fs/promises";
+import { canonicalPathFromExistingAncestor, isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
+//#region extensions/codex/src/app-server/bounded-hook-policy.ts
+function assertNoHookDeclarations(config) {
+	if (config.hooks === void 0) return;
+	if (!isJsonObject(config.hooks) || Object.entries(config.hooks).some(([event, value]) => event === "state" ? !isJsonObject(value) : !Array.isArray(value) || value.length > 0)) throw new Error("Codex private completion received unmanaged hook declarations");
+}
+async function assertPrivateLayerPath(value, root) {
+	if (typeof value !== "string" || !path.isAbsolute(value) || !isPathInside(root, await canonicalPathFromExistingAncestor(value))) throw new Error("Codex private completion inherited an external user or project config layer");
+}
+/** Proves hook discovery is confined to managed policy and this completion's private roots. */
+async function assertCodexPrivateHookIsolation(client, workspace, signal) {
+	signal?.throwIfAborted();
+	const [codexHome, cwd] = await Promise.all([fs.realpath(workspace.codexHome), fs.realpath(workspace.cwd)]);
+	const response = await readCodexEffectiveConfig(client, cwd, { signal });
+	const features = response.config.features;
+	if (!isJsonObject(features) || typeof features.hooks !== "boolean" || features.plugins !== false || !Array.isArray(response.config.project_root_markers) || response.config.project_root_markers.length !== 0) throw new Error("Codex private completion could not verify isolated hook discovery settings");
+	if (!Array.isArray(response.layers)) throw new Error("Codex private completion config/read omitted config layers");
+	let privateUserLayer = false;
+	for (const layer of response.layers) {
+		if (!isJsonObject(layer) || !isJsonObject(layer.name) || !isJsonObject(layer.config)) throw new Error("Codex private completion config/read returned invalid config layers");
+		switch (layer.name.type) {
+			case "user":
+				await assertPrivateLayerPath(layer.name.file, codexHome);
+				privateUserLayer = true;
+				break;
+			case "project":
+				await assertPrivateLayerPath(layer.name.dotCodexFolder, cwd);
+				break;
+			case "packagedDefaults":
+			case "sessionFlags":
+				assertNoHookDeclarations(layer.config);
+				break;
+			case "system":
+			case "mdm":
+			case "enterpriseManaged": break;
+			default: throw new Error("Codex private completion received an unsupported config layer");
+		}
+	}
+	if (!privateUserLayer) throw new Error("Codex private completion could not verify its private Codex home");
+	signal?.throwIfAborted();
+	if (!features.hooks) {
+		const requirementsResponse = await client.request("configRequirements/read", {}, { signal });
+		if (!isJsonObject(requirementsResponse) || !isJsonObject(requirementsResponse.requirements) || !isJsonObject(requirementsResponse.requirements.featureRequirements) || requirementsResponse.requirements.featureRequirements.hooks !== false) throw new Error("Codex private completion cannot disable hooks without a managed requirement");
+		return { activeManagedHooks: false };
+	}
+	const inventory = await client.request("hooks/list", { cwds: [cwd] }, { signal });
+	if (!isJsonObject(inventory) || !Array.isArray(inventory.data) || inventory.data.length !== 1 || inventory.nextCursor !== void 0 && inventory.nextCursor !== null) throw new Error("Codex private completion received an incomplete hook inventory");
+	const entry = inventory.data[0];
+	if (!isJsonObject(entry) || entry.cwd !== cwd || !Array.isArray(entry.hooks) || !Array.isArray(entry.errors) || entry.errors.length !== 0 || !Array.isArray(entry.warnings) || entry.warnings.length !== 0) throw new Error("Codex private completion could not verify its hook inventory");
+	let activeManagedHooks = false;
+	for (const hook of entry.hooks) {
+		if (!isJsonObject(hook) || typeof hook.key !== "string" || !hook.key.trim() || typeof hook.enabled !== "boolean" || typeof hook.isManaged !== "boolean") throw new Error("Codex private completion received invalid hook metadata");
+		if (hook.enabled && !hook.isManaged) throw new Error("Codex private completion cannot run unmanaged hooks");
+		activeManagedHooks ||= hook.enabled && hook.isManaged;
+	}
+	signal?.throwIfAborted();
+	return { activeManagedHooks };
+}
+//#endregion
 //#region extensions/codex/src/app-server/bounded-turn.ts
 const CODEX_APP_SERVER_ARGS_ENV_KEY = "OPENCLAW_CODEX_APP_SERVER_ARGS";
 const CODEX_BOUNDED_THREAD_CONFIG = {
@@ -25,6 +89,7 @@ const CODEX_BOUNDED_THREAD_CONFIG = {
 };
 const CODEX_PRIVATE_BOUNDED_THREAD_CONFIG = {
 	"features.hooks": false,
+	project_root_markers: [],
 	notify: []
 };
 const CODEX_SETTLED_FINALIZER_THREAD_CONFIG = {
@@ -67,7 +132,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	if (timeoutMs <= 0) throw timeoutError;
 	params.assertCurrent?.();
 	const agentDir = params.agentDir?.trim() || void 0;
-	const startOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
+	const startOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome, workspace.cwd, params.requireNoExternalCapabilities === true) : appServer.start;
 	const ownsClient = !params.options.clientFactory;
 	const clientOptions = {
 		startOptions,
@@ -79,7 +144,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		assertCurrent: params.assertCurrent,
 		...params.signal ? { abandonSignal: params.signal } : {}
 	};
-	const client = params.options.clientFactory ? await params.options.clientFactory(clientOptions) : await import("./shared-client-CscigXXL.js").then((n) => n.y).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+	const client = params.options.clientFactory ? await params.options.clientFactory(clientOptions) : await import("./shared-client-DA4VR4Eb.mjs").then((n) => n.y).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		...clientOptions,
 		authProfileStore: params.authProfileStore
 	}));
@@ -121,11 +186,23 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			...requestOptions
 		});
 		const inheritedMcpServerNames = params.requireNoExternalCapabilities ? await readCodexInheritedMcpServerNames(client, workspace.cwd, abortController.signal) : [];
-		if (params.requireNoExternalCapabilities) await assertCodexManagedRequirementsDoNotOverrideToolPolicy(client, { restrictedToolSurface: true }, abortController.signal);
-		const threadConfig = buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames), { nativeCodeModeEnabled: false });
+		let enableManagedHooks = false;
+		if (params.requireNoExternalCapabilities) {
+			let privateManagedHooksPresent = false;
+			if (workspace.codexHome) privateManagedHooksPresent = (await assertCodexPrivateHookIsolation(client, {
+				codexHome: workspace.codexHome,
+				cwd: workspace.cwd
+			}, abortController.signal)).activeManagedHooks;
+			({enableManagedHooks} = await assertCodexManagedRequirementsDoNotOverrideToolPolicy(client, {
+				restrictedToolSurface: true,
+				allowConfiguredManagedHooks: workspace.codexHome !== void 0,
+				privateManagedHooksPresent
+			}, abortController.signal));
+		}
+		const threadConfig = buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames, enableManagedHooks), { nativeCodeModeEnabled: false });
 		params.assertCurrent?.();
 		const thread = assertCodexThreadStartResponse(await client.request("thread/start", {
-			model: modelSelection.runtimeModelId,
+			model: modelSelection.model,
 			...params.modelProvider ? { modelProvider: params.modelProvider } : {},
 			cwd: workspace.cwd,
 			approvalPolicy: "on-request",
@@ -156,7 +233,11 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 				threadId: thread.thread.id,
 				input: params.input,
 				approvalPolicy: "on-request",
-				effort: "low"
+				effort: params.thinkLevel === void 0 ? "low" : resolveCodexAppServerReasoningEffort({
+					thinkLevel: params.thinkLevel,
+					modelId: modelSelection.model,
+					supportedReasoningEfforts: modelSelection.supportedReasoningEfforts
+				})
 			}, requestOptions));
 			activeTurnId = turn.turn.id;
 			if (abortController.signal.aborted) requestInterrupt();
@@ -164,19 +245,26 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 				signal: abortController.signal,
 				abortError: () => resolveCodexBoundedTurnAbortError(abortController.signal, params.taskLabel, timeoutError)
 			});
-			if (result.error || result.turn?.status === "failed") throw new Error((result.error ? readCodexErrorNotification(result.error)?.error.message : result.turn?.error?.message) ?? `codex app-server ${params.taskLabel} turn failed`);
+			if (result.error || result.turn?.status === "failed") {
+				const source = result.error ? readCodexErrorNotification(result.error)?.error : result.turn?.error;
+				const failure = source ? resolveCodexPromptError(source) : void 0;
+				throw failure instanceof Error ? failure : new Error(failure ?? `codex app-server ${params.taskLabel} turn failed`);
+			}
 			if (result.turn?.status !== "completed") throw new Error(`codex app-server ${params.taskLabel} turn ended with status ${result.turn?.status ?? "unknown"}`);
-			if (!result.text && !params.allowEmptyText) throw new Error(`Codex app-server ${params.taskLabel} turn returned no text.`);
+			const lastHookPrompt = enableManagedHooks ? result.items.findLastIndex((item) => item.type === "hookPrompt") : -1;
+			const text = lastHookPrompt < 0 ? result.text : result.items.slice(lastHookPrompt + 1).filter((item) => item.type === "agentMessage").map((item) => item.text?.trim()).filter(Boolean).join("\n\n");
+			if (!text && !params.allowEmptyText) throw new Error(`Codex app-server ${params.taskLabel} turn returned no text.`);
 			params.assertCurrent?.();
 			return {
-				text: result.text,
+				text,
 				items: result.items,
 				usage: result.usage,
-				model: modelSelection.catalogId,
+				model: modelSelection.id,
 				nativeSelection: {
 					model: thread.model,
 					modelProvider: thread.modelProvider
-				}
+				},
+				managedHooksEnabled: enableManagedHooks
 			};
 		} finally {
 			await interruptPromise;
@@ -198,14 +286,20 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	});
 	throw new Error("Codex bounded turn selection retry exited unexpectedly");
 }
-function resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames) {
+function resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames, enableManagedHooks) {
 	const boundedConfig = mergeCodexThreadConfigs(CODEX_BOUNDED_THREAD_CONFIG, params.threadConfig) ?? CODEX_BOUNDED_THREAD_CONFIG;
 	const privateConfig = workspace.codexHome ? mergeCodexThreadConfigs(boundedConfig, CODEX_PRIVATE_BOUNDED_THREAD_CONFIG) ?? boundedConfig : boundedConfig;
 	if (!params.requireNoExternalCapabilities) return privateConfig;
-	return mergeCodexThreadConfigs(privateConfig, CODEX_SETTLED_FINALIZER_THREAD_CONFIG, buildCodexRingZeroThreadConfigPatch({ toolsAllow: ["openclaw"] }, true, inheritedMcpServerNames)) ?? privateConfig;
+	return mergeCodexThreadConfigs(privateConfig, CODEX_SETTLED_FINALIZER_THREAD_CONFIG, buildCodexRingZeroThreadConfigPatch({ toolsAllow: ["openclaw"] }, true, inheritedMcpServerNames), enableManagedHooks ? { "features.hooks": true } : void 0) ?? privateConfig;
 }
-function buildPrivateCodexAppServerStartOptions(start, codexHome) {
-	const providerArgs = readCodexAppServerConfigOptions(start.args).flatMap(({ name, value }) => (name === "-c" || name === "--config") && value && /^\s*(?:openai_base_url|model_catalog_json)\s*=/u.test(value) ? ["-c", value] : []);
+function buildPrivateCodexAppServerStartOptions(start, codexHome, cwd, inspectManagedHooks) {
+	const launchCwd = start.cwd ?? process.cwd();
+	const { launcherArgs, nativeArgs } = resolveCodexPrivateLauncher({
+		command: start.command,
+		args: start.args,
+		cwd: launchCwd
+	});
+	const providerArgs = readCodexAppServerConfigOptions(nativeArgs).flatMap(({ name, value }) => (name === "-c" || name === "--config") && value && /^\s*(?:openai_base_url|model_catalog_json)\s*=/u.test(value) ? ["-c", resolvePrivateProviderOverride(value, launchCwd)] : []);
 	const privateEnv = Object.fromEntries(Object.entries(start.env ?? {}).filter(([name]) => name.trim().toUpperCase() !== CODEX_APP_SERVER_ARGS_ENV_KEY));
 	const clearEnv = (start.clearEnv ?? []).filter((name) => {
 		const normalized = name.trim().toUpperCase();
@@ -213,10 +307,21 @@ function buildPrivateCodexAppServerStartOptions(start, codexHome) {
 	});
 	return {
 		...start,
+		command: !path.isAbsolute(start.command) && /[\\/]/u.test(start.command) ? path.resolve(launchCwd, start.command) : start.command,
 		homeScope: "agent",
+		cwd,
 		args: [
+			...launcherArgs,
 			"app-server",
 			...providerArgs,
+			"-c",
+			"project_root_markers=[]",
+			...inspectManagedHooks ? [
+				"-c",
+				"features.hooks=true",
+				"-c",
+				"features.plugins=false"
+			] : [],
 			"--listen",
 			"stdio://"
 		],
@@ -227,6 +332,18 @@ function buildPrivateCodexAppServerStartOptions(start, codexHome) {
 		clearEnv: [...clearEnv, CODEX_APP_SERVER_ARGS_ENV_KEY]
 	};
 }
+function resolvePrivateProviderOverride(override, launchCwd) {
+	const separator = override.indexOf("=");
+	if (override.slice(0, separator).trim() !== "model_catalog_json") return override;
+	const rawPath = override.slice(separator + 1).trim();
+	let catalogPath;
+	try {
+		catalogPath = parse(`path = ${rawPath}`).path;
+	} catch {
+		catalogPath = rawPath;
+	}
+	return typeof catalogPath === "string" && catalogPath && !path.isAbsolute(catalogPath) ? `model_catalog_json=${JSON.stringify(path.resolve(launchCwd, catalogPath))}` : override;
+}
 function createCodexBoundedApprovalHandler(taskLabel) {
 	return (request) => {
 		if (request.method === "item/commandExecution/requestApproval" || request.method === "item/fileChange/requestApproval") return {
@@ -259,20 +376,14 @@ async function resolveCodexBoundedTurnModel(params) {
 		const supported = listed.filter((entry) => params.requiredModalities.every((modality) => entry.inputModalities.includes(modality)));
 		const selected = supported.find((entry) => entry.isDefault) ?? supported[0];
 		if (!selected) throw new Error(`Codex app-server has no model supporting ${params.requiredModalities.join(" and ")} input.`);
-		return {
-			catalogId: selected.id,
-			runtimeModelId: selected.model
-		};
+		return selected;
 	}
 	const model = params.selection.id;
 	const match = listed.find((entry) => entry.model === model || entry.id === model);
 	if (!match) throw new Error(`Codex app-server model not found: ${model}`);
 	if (params.requiredModalities.includes("image") && !match.inputModalities.includes("image")) throw new Error(`Codex app-server model does not support images: ${model}`);
 	if (params.requiredModalities.includes("text") && !match.inputModalities.includes("text")) throw new Error(`Codex app-server model does not support text: ${model}`);
-	return {
-		catalogId: match.id,
-		runtimeModelId: match.model
-	};
+	return match;
 }
 function resolveCodexBoundedTurnAbortError(signal, taskLabel, timeoutError) {
 	return signal.reason === timeoutError ? timeoutError : /* @__PURE__ */ new Error(`codex app-server ${taskLabel} turn aborted`);

package/dist/{build-state-BCmg9-5p.js → .setup/build-state-C7EnDVgr.mjs}

@@ -1,5 +1,5 @@
 //#region extensions/codex/package.json
-var version = "2026.9.4";
+var version = "2026.9.6";
 //#endregion
 //#region extensions/codex/src/build-state.ts
 /**

package/dist/{capabilities-8vx68WLH.js → .setup/capabilities-CDXOOFdZ.mjs}

@@ -1,4 +1,4 @@
-import { t as CodexAppServerRpcError } from "./rpc-error-ttN_QjEm.js";
+import { o as CodexAppServerRpcError } from "./timeout-C910MdAB.mjs";
 //#region extensions/codex/src/app-server/capabilities.ts
 /**
 * Capability helpers for optional Codex app-server control-plane methods.