@openclaw/codex 2026.5.7-beta.1 → 2026.5.9-beta.1

package/dist/{thread-lifecycle-CzllX4PU.js → thread-lifecycle-unEEsXe-.js}

@@ -1,10 +1,12 @@
-import { n as codexSandboxPolicyForTurn } from "./config-ByrA30No.js";
-import { n as assertCodexThreadStartResponse, t as assertCodexThreadResumeResponse } from "./protocol-validators-Dky2yV4W.js";
+import { l as resolveCodexPluginsPolicy, r as codexSandboxPolicyForTurn } from "./config-BZiM7rhH.js";
+import { n as assertCodexThreadStartResponse, t as assertCodexThreadResumeResponse } from "./protocol-validators-CbqWfY5M.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
 import { CODEX_GPT5_HEARTBEAT_PROMPT_OVERLAY, renderCodexPromptOverlay } from "./prompt-overlay.js";
 import { isModernCodexModel } from "./provider.js";
-import { i as isCodexAppServerConnectionClosedError } from "./client-BGbqC7jk.js";
-import { i as readCodexAppServerBinding, n as isCodexAppServerNativeAuthProfile, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-DuJYTJQy.js";
+import { i as isCodexAppServerConnectionClosedError } from "./client-DYkCXAze.js";
+import { i as readCodexAppServerBinding, n as isCodexAppServerNativeAuthProfile, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-C_HDlZx8.js";
+import { i as defaultCodexAppInventoryCache, n as readCodexPluginInventory, t as ensureCodexPluginActivation } from "./plugin-activation-D0uXssSN.js";
+import crypto from "node:crypto";
 import { HEARTBEAT_RESPONSE_TOOL_NAME, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractToolResultMediaArtifact, filterToolResultMediaUrls, isMessagingTool, isMessagingToolSendAction, isToolWrappedWithBeforeToolCallHook, normalizeHeartbeatToolResponse, runAgentHarnessAfterToolCallHook, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/dynamic-tool-profile.ts
 const CODEX_NATIVE_FIRST_DYNAMIC_TOOL_EXCLUDES = [
@@ -16,17 +18,27 @@ const CODEX_NATIVE_FIRST_DYNAMIC_TOOL_EXCLUDES = [
 	"process",
 	"update_plan"
 ];
+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 applyCodexDynamicToolProfile(tools, config) {
 	const excludes = /* @__PURE__ */ new Set();
 	if ((config.codexDynamicToolsProfile ?? "native-first") === "native-first") for (const name of CODEX_NATIVE_FIRST_DYNAMIC_TOOL_EXCLUDES) excludes.add(name);
 	for (const name of config.codexDynamicToolsExclude ?? []) {
-		const trimmed = name.trim();
+		const trimmed = normalizeCodexDynamicToolName(name);
 		if (trimmed) excludes.add(trimmed);
 	}
-	return excludes.size === 0 ? tools : tools.filter((tool) => !excludes.has(tool.name));
+	return excludes.size === 0 ? tools : tools.filter((tool) => !excludes.has(normalizeCodexDynamicToolName(tool.name)));
 }
 //#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"]);
 function createCodexDynamicToolBridge(params) {
 	const toolResultHookContext = toToolResultHookContext(params.hookContext);
 	const tools = params.tools.map((tool) => isToolWrappedWithBeforeToolCallHook(tool) ? tool : wrapToolWithBeforeToolCallHook(tool, params.hookContext));
@@ -44,11 +56,12 @@ function createCodexDynamicToolBridge(params) {
 		...toolResultHookContext
 	});
 	const legacyExtensionRunner = createCodexAppServerToolResultExtensionRunner(toolResultHookContext);
+	const directToolNames = new Set([...ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES, ...params.directToolNames ?? []]);
 	return {
-		specs: tools.map((tool) => ({
-			name: tool.name,
-			description: tool.description,
-			inputSchema: toJsonValue(tool.parameters)
+		specs: tools.map((tool) => createCodexDynamicToolSpec({
+			tool,
+			loading: params.loading ?? "searchable",
+			directToolNames
 		})),
 		telemetry,
 		handleToolCall: async (call, options) => {
@@ -138,6 +151,19 @@ function createCodexDynamicToolBridge(params) {
 		}
 	};
 }
+function createCodexDynamicToolSpec(params) {
+	const base = {
+		name: params.tool.name,
+		description: params.tool.description,
+		inputSchema: toJsonValue(params.tool.parameters)
+	};
+	if (params.loading === "direct" || params.directToolNames.has(params.tool.name)) return base;
+	return {
+		...base,
+		namespace: CODEX_OPENCLAW_DYNAMIC_TOOL_NAMESPACE,
+		deferLoading: true
+	};
+}
 function toToolResultHookContext(ctx) {
 	const { agentId, sessionId, sessionKey, runId } = ctx ?? {};
 	return {
@@ -271,15 +297,274 @@ function isCronAddAction(args) {
 	return typeof action === "string" && action.trim().toLowerCase() === "add";
 }
 //#endregion
+//#region extensions/codex/src/app-server/plugin-thread-config.ts
+const CODEX_PLUGIN_THREAD_CONFIG_INPUT_FINGERPRINT_VERSION = 1;
+const CODEX_PLUGIN_THREAD_CONFIG_FINGERPRINT_VERSION = 1;
+function shouldBuildCodexPluginThreadConfig(pluginConfig) {
+	return resolveCodexPluginsPolicy(pluginConfig).configured;
+}
+function buildCodexPluginThreadConfigInputFingerprint(params) {
+	return fingerprintJson({
+		version: CODEX_PLUGIN_THREAD_CONFIG_INPUT_FINGERPRINT_VERSION,
+		policy: policyFingerprint(resolveCodexPluginsPolicy(params.pluginConfig)),
+		appCacheKey: params.appCacheKey ?? null
+	});
+}
+async function buildCodexPluginThreadConfig(params) {
+	const appCache = params.appCache ?? defaultCodexAppInventoryCache;
+	let inputFingerprint = buildCodexPluginThreadConfigInputFingerprint({
+		pluginConfig: params.pluginConfig,
+		appCacheKey: params.appCacheKey
+	});
+	const policy = resolveCodexPluginsPolicy(params.pluginConfig);
+	if (!policy.enabled) return emptyPluginThreadConfig({
+		enabled: false,
+		inputFingerprint,
+		configPatch: buildDisabledAppsConfigPatch()
+	});
+	let inventory = await readCodexPluginInventory({
+		pluginConfig: params.pluginConfig,
+		policy,
+		request: params.request,
+		appCache,
+		appCacheKey: params.appCacheKey,
+		nowMs: params.nowMs
+	});
+	if (shouldWaitForInitialAppInventory(params, policy, inventory)) {
+		await refreshAppInventoryNow(params, appCache);
+		inventory = await readCodexPluginInventory({
+			pluginConfig: params.pluginConfig,
+			policy,
+			request: params.request,
+			appCache,
+			appCacheKey: params.appCacheKey,
+			nowMs: params.nowMs
+		});
+		inputFingerprint = buildCodexPluginThreadConfigInputFingerprint({
+			pluginConfig: params.pluginConfig,
+			appCacheKey: params.appCacheKey
+		});
+	}
+	const activationDiagnostics = [];
+	const activationResults = [];
+	for (const record of inventory.records) {
+		if (!record.activationRequired) continue;
+		const activation = await ensureCodexPluginActivation({
+			identity: record.policy,
+			request: params.request,
+			appCache,
+			appCacheKey: params.appCacheKey
+		});
+		activationResults.push(activation);
+		if (!activation.ok) activationDiagnostics.push({
+			code: "plugin_activation_failed",
+			plugin: record.policy,
+			message: activation.diagnostics.map((item) => item.message).join(" ") || activation.reason
+		});
+	}
+	if (activationResults.some((activation) => activation.ok && activation.installAttempted)) {
+		await refreshAppInventoryNow(params, appCache, { forceRefetch: true });
+		inventory = await readCodexPluginInventory({
+			pluginConfig: params.pluginConfig,
+			policy,
+			request: params.request,
+			appCache,
+			appCacheKey: params.appCacheKey,
+			nowMs: params.nowMs
+		});
+		inputFingerprint = buildCodexPluginThreadConfigInputFingerprint({
+			pluginConfig: params.pluginConfig,
+			appCacheKey: params.appCacheKey
+		});
+	}
+	const diagnostics = [...inventory.diagnostics, ...activationDiagnostics];
+	const apps = { _default: {
+		enabled: false,
+		destructive_enabled: false,
+		open_world_enabled: false
+	} };
+	const policyApps = {};
+	const pluginAppIds = {};
+	for (const record of inventory.records) {
+		if (record.activationRequired) {
+			if (!activationResults.find((item) => item.identity.configKey === record.policy.configKey)?.ok) continue;
+		}
+		if (record.appOwnership !== "proven") continue;
+		pluginAppIds[record.policy.configKey] = [...record.ownedAppIds].toSorted();
+		for (const app of record.apps) {
+			if (!app.accessible || !app.enabled) {
+				diagnostics.push({
+					code: "app_not_ready",
+					plugin: record.policy,
+					message: `${app.id} is not accessible or enabled for ${record.policy.pluginName}.`
+				});
+				continue;
+			}
+			const appConfig = {
+				enabled: true,
+				destructive_enabled: record.policy.allowDestructiveActions,
+				open_world_enabled: true,
+				default_tools_approval_mode: "prompt"
+			};
+			apps[app.id] = appConfig;
+			policyApps[app.id] = {
+				configKey: record.policy.configKey,
+				marketplaceName: record.policy.marketplaceName,
+				pluginName: record.policy.pluginName,
+				allowDestructiveActions: record.policy.allowDestructiveActions,
+				mcpServerNames: [...record.detail?.mcpServers ?? []].toSorted()
+			};
+		}
+	}
+	const configPatch = { apps };
+	const policyContext = buildPluginAppPolicyContext(policyApps, pluginAppIds);
+	return {
+		enabled: true,
+		configPatch,
+		fingerprint: fingerprintJson({
+			version: CODEX_PLUGIN_THREAD_CONFIG_FINGERPRINT_VERSION,
+			inputFingerprint,
+			configPatch,
+			policyContext
+		}),
+		inputFingerprint,
+		policyContext,
+		inventory,
+		diagnostics
+	};
+}
+function mergeCodexThreadConfigs(...configs) {
+	let merged;
+	for (const config of configs) {
+		if (!config) continue;
+		merged = mergeJsonObjects(merged ?? {}, config);
+	}
+	return merged && Object.keys(merged).length > 0 ? merged : void 0;
+}
+function isCodexPluginThreadBindingStale(params) {
+	if (!params.codexPluginsEnabled) return Boolean(params.bindingFingerprint || params.bindingInputFingerprint || params.hasBindingPolicyContext);
+	if (!params.bindingFingerprint || !params.bindingInputFingerprint || !params.hasBindingPolicyContext) return true;
+	return params.bindingInputFingerprint !== params.currentInputFingerprint;
+}
+function emptyPluginThreadConfig(params) {
+	const policyContext = buildPluginAppPolicyContext({}, {});
+	return {
+		enabled: params.enabled,
+		fingerprint: fingerprintJson({
+			version: CODEX_PLUGIN_THREAD_CONFIG_FINGERPRINT_VERSION,
+			inputFingerprint: params.inputFingerprint,
+			configPatch: params.configPatch ?? null,
+			policyContext
+		}),
+		inputFingerprint: params.inputFingerprint,
+		...params.configPatch ? { configPatch: params.configPatch } : {},
+		policyContext,
+		diagnostics: []
+	};
+}
+function buildDisabledAppsConfigPatch() {
+	return { apps: { _default: {
+		enabled: false,
+		destructive_enabled: false,
+		open_world_enabled: false
+	} } };
+}
+function buildPluginAppPolicyContext(apps, pluginAppIds) {
+	return {
+		fingerprint: fingerprintJson({
+			version: 1,
+			apps,
+			pluginAppIds
+		}),
+		apps,
+		pluginAppIds
+	};
+}
+function shouldWaitForInitialAppInventory(params, policy, inventory) {
+	return Boolean(params.appCacheKey && policy.pluginPolicies.some((plugin) => plugin.enabled) && inventory.appInventory?.state === "missing");
+}
+async function refreshAppInventoryNow(params, appCache, options = {}) {
+	const appCacheKey = params.appCacheKey;
+	if (!appCacheKey) return;
+	const request = async (method, requestParams) => await params.request(method, requestParams);
+	try {
+		await appCache.refreshNow({
+			key: appCacheKey,
+			request,
+			nowMs: params.nowMs,
+			forceRefetch: options.forceRefetch
+		});
+	} catch {}
+}
+function policyFingerprint(policy) {
+	return {
+		enabled: policy.enabled,
+		allowDestructiveActions: policy.allowDestructiveActions,
+		plugins: policy.pluginPolicies.map((plugin) => ({
+			configKey: plugin.configKey,
+			marketplaceName: plugin.marketplaceName,
+			pluginName: plugin.pluginName,
+			enabled: plugin.enabled,
+			allowDestructiveActions: plugin.allowDestructiveActions
+		}))
+	};
+}
+function mergeJsonObjects(left, right) {
+	const merged = { ...left };
+	for (const [key, value] of Object.entries(right)) {
+		const existing = merged[key];
+		merged[key] = isPlainJsonObject(existing) && isPlainJsonObject(value) ? mergeJsonObjects(existing, value) : value;
+	}
+	return merged;
+}
+function isPlainJsonObject(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function fingerprintJson(value) {
+	return crypto.createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+//#endregion
 //#region extensions/codex/src/app-server/thread-lifecycle.ts
 async function startOrResumeThread(params) {
 	const dynamicToolsFingerprint = fingerprintDynamicTools(params.dynamicTools);
-	const binding = await readCodexAppServerBinding(params.params.sessionFile, {
+	let binding = await readCodexAppServerBinding(params.params.sessionFile, {
 		authProfileStore: params.params.authProfileStore,
 		agentDir: params.params.agentDir,
 		config: params.params.config
 	});
 	let preserveExistingBinding = false;
+	let prebuiltPluginThreadConfig;
+	if (binding?.threadId) {
+		let pluginBindingStale = isCodexPluginThreadBindingStale({
+			codexPluginsEnabled: params.pluginThreadConfig?.enabled ?? false,
+			bindingFingerprint: binding.pluginAppsFingerprint,
+			bindingInputFingerprint: binding.pluginAppsInputFingerprint,
+			currentInputFingerprint: params.pluginThreadConfig?.inputFingerprint,
+			hasBindingPolicyContext: Boolean(binding.pluginAppPolicyContext)
+		});
+		if (!pluginBindingStale && shouldRecheckRecoverablePluginBinding({
+			binding,
+			pluginThreadConfig: params.pluginThreadConfig
+		})) try {
+			prebuiltPluginThreadConfig = await params.pluginThreadConfig?.build();
+			pluginBindingStale = prebuiltPluginThreadConfig?.fingerprint !== binding.pluginAppsFingerprint;
+		} catch (error) {
+			embeddedAgentLog.warn("codex app-server plugin app config recovery check failed", {
+				error,
+				threadId: binding.threadId
+			});
+		}
+		if (pluginBindingStale) {
+			embeddedAgentLog.debug("codex app-server plugin app config changed; starting a new thread", { threadId: binding.threadId });
+			await clearCodexAppServerBinding(params.params.sessionFile);
+			binding = void 0;
+		}
+	}
 	if (binding?.threadId) if (binding.dynamicToolsFingerprint && !areDynamicToolFingerprintsCompatible(binding.dynamicToolsFingerprint, dynamicToolsFingerprint)) {
 		preserveExistingBinding = shouldStartTransientNoToolThread({
 			previous: binding.dynamicToolsFingerprint,
@@ -314,6 +599,9 @@ async function startOrResumeThread(params) {
 			model: params.params.modelId,
 			modelProvider: response.modelProvider ?? fallbackModelProvider,
 			dynamicToolsFingerprint,
+			pluginAppsFingerprint: binding.pluginAppsFingerprint,
+			pluginAppsInputFingerprint: binding.pluginAppsInputFingerprint,
+			pluginAppPolicyContext: binding.pluginAppPolicyContext,
 			createdAt: binding.createdAt
 		}, {
 			authProfileStore: params.params.authProfileStore,
@@ -327,19 +615,24 @@ async function startOrResumeThread(params) {
 			authProfileId: boundAuthProfileId,
 			model: params.params.modelId,
 			modelProvider: response.modelProvider ?? fallbackModelProvider,
-			dynamicToolsFingerprint
+			dynamicToolsFingerprint,
+			pluginAppsFingerprint: binding.pluginAppsFingerprint,
+			pluginAppsInputFingerprint: binding.pluginAppsInputFingerprint,
+			pluginAppPolicyContext: binding.pluginAppPolicyContext
 		};
 	} catch (error) {
 		if (isCodexAppServerConnectionClosedError(error)) throw error;
 		embeddedAgentLog.warn("codex app-server thread resume failed; starting a new thread", { error });
 		await clearCodexAppServerBinding(params.params.sessionFile);
 	}
+	const pluginThreadConfig = params.pluginThreadConfig?.enabled ? prebuiltPluginThreadConfig ?? await params.pluginThreadConfig.build() : void 0;
+	const config = mergeCodexThreadConfigs(params.config, pluginThreadConfig?.configPatch);
 	const response = assertCodexThreadStartResponse(await params.client.request("thread/start", buildThreadStartParams(params.params, {
 		cwd: params.cwd,
 		dynamicTools: params.dynamicTools,
 		appServer: params.appServer,
 		developerInstructions: params.developerInstructions,
-		config: params.config
+		config
 	})));
 	const modelProvider = resolveCodexAppServerModelProvider({
 		provider: params.params.provider,
@@ -356,6 +649,9 @@ async function startOrResumeThread(params) {
 		model: response.model ?? params.params.modelId,
 		modelProvider: response.modelProvider ?? modelProvider,
 		dynamicToolsFingerprint,
+		pluginAppsFingerprint: pluginThreadConfig?.fingerprint,
+		pluginAppsInputFingerprint: pluginThreadConfig?.inputFingerprint,
+		pluginAppPolicyContext: pluginThreadConfig?.policyContext,
 		createdAt
 	}, {
 		authProfileStore: params.params.authProfileStore,
@@ -371,10 +667,21 @@ async function startOrResumeThread(params) {
 		model: response.model ?? params.params.modelId,
 		modelProvider: response.modelProvider ?? modelProvider,
 		dynamicToolsFingerprint,
+		pluginAppsFingerprint: pluginThreadConfig?.fingerprint,
+		pluginAppsInputFingerprint: pluginThreadConfig?.inputFingerprint,
+		pluginAppPolicyContext: pluginThreadConfig?.policyContext,
 		createdAt,
 		updatedAt: createdAt
 	};
 }
+function shouldRecheckRecoverablePluginBinding(params) {
+	if (!params.pluginThreadConfig?.enabled) return false;
+	if (!params.binding.pluginAppsFingerprint || !params.binding.pluginAppsInputFingerprint || params.binding.pluginAppsInputFingerprint !== params.pluginThreadConfig.inputFingerprint) return false;
+	const policyContext = params.binding.pluginAppPolicyContext;
+	if (!policyContext) return false;
+	const expectedPluginConfigKeys = params.pluginThreadConfig.enabledPluginConfigKeys ?? [];
+	return Object.keys(policyContext.apps).length === 0 || expectedPluginConfigKeys.length > 0;
+}
 function buildThreadStartParams(params, options) {
 	const modelProvider = resolveCodexAppServerModelProvider({
 		provider: params.provider,
@@ -445,7 +752,11 @@ function buildTurnCollaborationMode(params) {
 	};
 }
 function buildHeartbeatCollaborationInstructions() {
-	return ["This is an OpenClaw heartbeat turn. Apply these instructions only to this heartbeat wake; ordinary chat turns should stay in Codex Default mode.", CODEX_GPT5_HEARTBEAT_PROMPT_OVERLAY].join("\n\n");
+	return [
+		"This is an OpenClaw heartbeat turn. Apply these instructions only to this heartbeat wake; ordinary chat turns should stay in Codex Default mode.",
+		"When you are ready to end the heartbeat, prefer the structured `heartbeat_respond` tool so OpenClaw can record the wake outcome and notification decision. If `heartbeat_respond` is not already available and `tool_search` is available, search for `heartbeat_respond`, load it, then call it. Use `notify=false` when nothing should visibly interrupt the user.",
+		CODEX_GPT5_HEARTBEAT_PROMPT_OVERLAY
+	].join("\n\n");
 }
 function codexDynamicToolsFingerprint(dynamicTools) {
 	return fingerprintDynamicTools(dynamicTools);
@@ -535,4 +846,4 @@ function resolveReasoningEffort(thinkLevel, modelId) {
 	return null;
 }
 //#endregion
-export { buildTurnStartParams as a, createCodexDynamicToolBridge as c, buildThreadStartParams as i, applyCodexDynamicToolProfile as l, buildDeveloperInstructions as n, codexDynamicToolsFingerprint as o, buildThreadResumeParams as r, startOrResumeThread as s, areCodexDynamicToolFingerprintsCompatible as t };
+export { buildTurnStartParams as a, buildCodexPluginThreadConfig as c, createCodexDynamicToolBridge as d, applyCodexDynamicToolProfile as f, buildThreadStartParams as i, buildCodexPluginThreadConfigInputFingerprint as l, buildDeveloperInstructions as n, codexDynamicToolsFingerprint as o, normalizeCodexDynamicToolName as p, buildThreadResumeParams as r, startOrResumeThread as s, areCodexDynamicToolFingerprintsCompatible as t, shouldBuildCodexPluginThreadConfig as u };

package/openclaw.plugin.json

@@ -15,7 +15,7 @@
       }
     }
   },
-  "providerDiscoveryEntry": "./provider-discovery.ts",
+  "providerCatalogEntry": "./provider-discovery.ts",
   "syntheticAuthRefs": ["codex"],
   "nonSecretAuthMarkers": ["codex-app-server"],
   "activation": {
@@ -38,6 +38,11 @@
         "enum": ["native-first", "openclaw-compat"],
         "default": "native-first"
       },
+      "codexDynamicToolsLoading": {
+        "type": "string",
+        "enum": ["searchable", "direct"],
+        "default": "searchable"
+      },
       "codexDynamicToolsExclude": {
         "type": "array",
         "items": { "type": "string" },
@@ -91,6 +96,42 @@
           }
         }
       },
+      "codexPlugins": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "enabled": {
+            "type": "boolean",
+            "default": false
+          },
+          "allow_destructive_actions": {
+            "type": "boolean",
+            "default": false
+          },
+          "plugins": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "enabled": {
+                  "type": "boolean"
+                },
+                "marketplaceName": {
+                  "type": "string",
+                  "enum": ["openai-curated"]
+                },
+                "pluginName": {
+                  "type": "string"
+                },
+                "allow_destructive_actions": {
+                  "type": "boolean"
+                }
+              }
+            }
+          }
+        }
+      },
       "appServer": {
         "type": "object",
         "additionalProperties": false,
@@ -130,6 +171,11 @@
             "minimum": 1,
             "default": 60000
           },
+          "turnCompletionIdleTimeoutMs": {
+            "type": "number",
+            "minimum": 1,
+            "default": 60000
+          },
           "approvalPolicy": {
             "type": "string",
             "enum": ["never", "on-request", "on-failure", "untrusted"]
@@ -142,7 +188,7 @@
             "type": "string",
             "enum": ["user", "auto_review", "guardian_subagent"]
           },
-          "serviceTier": { "type": ["string", "null"], "enum": ["fast", "flex", null] },
+          "serviceTier": { "type": ["string", "null"] },
           "defaultWorkspaceDir": {
             "type": "string"
           }
@@ -156,6 +202,11 @@
       "help": "Select which OpenClaw dynamic tools are exposed to Codex app-server. native-first omits tools Codex already owns.",
       "advanced": true
     },
+    "codexDynamicToolsLoading": {
+      "label": "Dynamic Tools Loading",
+      "help": "Use searchable to defer OpenClaw dynamic tools behind Codex tool search, or direct to expose them in the initial context.",
+      "advanced": true
+    },
     "codexDynamicToolsExclude": {
       "label": "Dynamic Tool Excludes",
       "help": "Additional OpenClaw dynamic tool names to omit from Codex app-server turns.",
@@ -219,6 +270,26 @@
       "help": "MCP server name exposed by the Computer Use plugin.",
       "advanced": true
     },
+    "codexPlugins": {
+      "label": "Native Codex Plugins",
+      "help": "Controls native Codex plugin availability for Codex harness turns.",
+      "advanced": true
+    },
+    "codexPlugins.enabled": {
+      "label": "Enable Native Plugins",
+      "help": "Expose explicit migrated Codex plugin entries to Codex harness turns.",
+      "advanced": true
+    },
+    "codexPlugins.allow_destructive_actions": {
+      "label": "Allow Destructive Plugin Actions",
+      "help": "Default policy for plugin app write or destructive action elicitations. Defaults to false.",
+      "advanced": true
+    },
+    "codexPlugins.plugins": {
+      "label": "Migrated Plugin Entries",
+      "help": "Explicit migration-authored plugin entries. The wildcard key * is not supported.",
+      "advanced": true
+    },
     "appServer": {
       "label": "App Server",
       "help": "Runtime controls for connecting to Codex app-server.",
@@ -270,6 +341,11 @@
       "help": "Maximum time to wait for Codex app-server control-plane requests.",
       "advanced": true
     },
+    "appServer.turnCompletionIdleTimeoutMs": {
+      "label": "Turn Completion Idle Timeout",
+      "help": "Maximum quiet time after a turn-scoped Codex app-server request before OpenClaw interrupts the turn while waiting for turn/completed.",
+      "advanced": true
+    },
     "appServer.approvalPolicy": {
       "label": "Approval Policy",
       "help": "Codex native approval policy sent to thread start, resume, and turns.",
@@ -287,7 +363,7 @@
     },
     "appServer.serviceTier": {
       "label": "Service Tier",
-      "help": "Optional Codex app-server service tier. Use fast, flex, or null.",
+      "help": "Optional Codex app-server service tier. Use priority, flex, or null. Legacy fast is accepted as priority.",
       "advanced": true
     },
     "appServer.defaultWorkspaceDir": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.5.7-beta.1",
+  "version": "2026.5.9-beta.1",
   "description": "OpenClaw Codex harness and model provider plugin",
   "repository": {
     "type": "git",
@@ -8,11 +8,10 @@
   },
   "type": "module",
   "dependencies": {
-    "@mariozechner/pi-coding-agent": "0.73.0",
-    "@openai/codex": "0.128.0",
+    "@mariozechner/pi-coding-agent": "0.73.1",
+    "@openai/codex": "0.130.0",
     "ajv": "^8.20.0",
-    "ws": "^8.20.0",
-    "zod": "^4.4.3"
+    "ws": "^8.20.0"
   },
   "devDependencies": {
     "@openclaw/plugin-sdk": "workspace:*"
@@ -27,10 +26,10 @@
       "minHostVersion": ">=2026.5.1-beta.1"
     },
     "compat": {
-      "pluginApi": ">=2026.5.7-beta.1"
+      "pluginApi": ">=2026.5.9-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.7-beta.1"
+      "openclawVersion": "2026.5.9-beta.1"
     },
     "release": {
       "publishToClawHub": true,
@@ -45,7 +44,7 @@
     "openclaw.plugin.json"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.5.7-beta.1"
+    "openclaw": ">=2026.5.9-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {