@openclaw/acpx 2026.7.2-beta.1 → 2026.7.2-beta.3

package/dist/index.js

@@ -1,10 +1,11 @@
-import { t as createAcpxRuntimeService } from "./register.runtime-DBqbPx5P.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-BrVpU-xc.js";
 import "./config-schema-lrk5nlcV.js";
 import { tryDispatchAcpReplyHook } from "openclaw/plugin-sdk/acp-runtime-backend";
 import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
 import process$1 from "node:process";
-import { decodeNodePtyResumeParams, resolveExecutableFromPathEnv, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
+import { decodeNodePtyResumeParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createReadStream, readFileSync, statSync } from "node:fs";
 import fs$1 from "node:fs/promises";
 import path from "node:path";
@@ -389,7 +390,7 @@ async function readPiSessionById(threadId, env) {
 const LOCAL_HOST_ID$1 = "gateway";
 const DEFAULT_PAGE_LIMIT = 20;
 const MAX_PAGE_LIMIT$1 = 100;
-const MAX_SEARCH_LENGTH$1 = 500;
+const MAX_SEARCH_LENGTH = 500;
 const MAX_CURSOR_LENGTH$1 = 128;
 const MAX_TRANSCRIPT_ITEM_BYTES = 512 * 1024;
 const MAX_TRANSCRIPT_PAGE_BYTES = 20 * 1024 * 1024;
@@ -483,7 +484,7 @@ function parseListParams(value) {
 		"cursor"
 	].includes(key));
 	if (unknown) throw new Error(`unknown Pi session list parameter: ${unknown}`);
-	const searchTerm = optionalPiString(value.searchTerm, MAX_SEARCH_LENGTH$1);
+	const searchTerm = optionalPiString(value.searchTerm, MAX_SEARCH_LENGTH);
 	if (value.searchTerm !== void 0 && !searchTerm) throw new Error("searchTerm is invalid");
 	const cursor = optionalPiString(value.cursor, MAX_CURSOR_LENGTH$1);
 	if (value.cursor !== void 0 && !cursor) throw new Error("cursor is invalid");
@@ -534,7 +535,7 @@ function isoTimestamp(message, entry) {
 function jsonText(value, maxLength = 2e4) {
 	try {
 		const text = JSON.stringify(value);
-		return text.length > maxLength ? `${text.slice(0, maxLength)}…` : text;
+		return text.length > maxLength ? `${truncateUtf16Safe(text, maxLength)}…` : text;
 	} catch {
 		return;
 	}
@@ -693,7 +694,6 @@ const LOCAL_HOST_ID = "gateway";
 const MAX_PAGE_LIMIT = 100;
 const MAX_HOSTS = 100;
 const MAX_CURSOR_LENGTH = 128;
-const MAX_SEARCH_LENGTH = 500;
 const NODE_TIMEOUT_MS = 2e4;
 const SESSION_ID_PATTERN = /^(?!-)[A-Za-z0-9._:-]{1,256}$/u;
 const TRANSCRIPT_ITEM_TYPES = /* @__PURE__ */ new Set([
@@ -762,15 +762,23 @@ function createPiSessionNodeHostCommands() {
 			isAvailable: ({ config, env }) => storeAvailable({
 				config,
 				env
-			}) && Boolean(resolveExecutableFromPathEnv("pi", env.PATH ?? "")),
+			}) && Boolean(resolveNodeHostExecutable("pi", {
+				env,
+				pathEnv: env.PATH ?? env.Path ?? "",
+				strategy: "direct"
+			})),
 			handle: async (paramsJSON, io) => {
 				if (!io) throw new Error("Pi terminal command requires duplex transport");
 				const params = decodeNodePtyResumeParams(paramsJSON, validatePiThreadId);
 				const record = await requireLocalPiSession(params.threadId);
-				const file = resolveExecutableFromPathEnv("pi", process$1.env.PATH ?? "");
-				if (!file) throw new Error("Pi CLI is unavailable");
+				const resolution = resolveNodeHostExecutable("pi", {
+					env: process$1.env,
+					pathEnv: process$1.env.PATH ?? process$1.env.Path ?? "",
+					strategy: "direct"
+				});
+				if (!resolution) throw new Error("Pi CLI is unavailable");
 				return JSON.stringify(await runNodePtyCommand({
-					file,
+					file: resolution.executable,
 					args: ["--session", params.threadId],
 					cwd: record.cwd,
 					cols: params.cols,
@@ -828,7 +836,7 @@ async function listPiNodeHost(runtime, query, node) {
 			command: PI_SESSIONS_LIST_COMMAND,
 			params: {
 				...query.limitPerHost ? { limit: query.limitPerHost } : {},
-				...query.search?.trim() ? { searchTerm: query.search.trim().slice(0, MAX_SEARCH_LENGTH) } : {},
+				...query.search ? { searchTerm: query.search } : {},
 				...query.cursors?.[hostId] ? { cursor: query.cursors[hostId] } : {}
 			},
 			timeoutMs: NODE_TIMEOUT_MS,
@@ -874,7 +882,6 @@ function parseNodeTranscriptPage(value, threadId) {
 }
 async function listPiHosts(runtime, query) {
 	const requested = query.hostIds ? new Set(query.hostIds) : void 0;
-	const searchTerm = query.search?.trim().slice(0, MAX_SEARCH_LENGTH) || void 0;
 	const hosts = [];
 	if ((!requested || requested.has(LOCAL_HOST_ID)) && piSessionStoreAvailable(process$1.env)) try {
 		hosts.push({
@@ -884,9 +891,13 @@ async function listPiHosts(runtime, query) {
 			connected: true,
 			...await listLocalPiSessionPage({
 				limit: query.limitPerHost,
-				...searchTerm ? { searchTerm } : {},
+				...query.search ? { searchTerm: query.search } : {},
 				cursor: query.cursors?.[LOCAL_HOST_ID]
-			}).then((page) => setTerminalCapability(page, resolveExecutableFromPathEnv("pi", process$1.env.PATH ?? "") !== void 0))
+			}).then((page) => setTerminalCapability(page, resolveNodeHostExecutable("pi", {
+				env: process$1.env,
+				pathEnv: process$1.env.PATH ?? "",
+				strategy: "fallback"
+			}) !== void 0))
 		});
 	} catch {
 		hosts.push({
@@ -937,16 +948,21 @@ async function openPiTerminal(params) {
 	const title = `pi --session ${params.threadId.slice(0, 12)}…`;
 	if (params.hostId === LOCAL_HOST_ID) {
 		const record = await requireLocalPiSession(params.threadId);
-		const executable = resolveExecutableFromPathEnv("pi", process$1.env.PATH ?? "");
-		if (!executable) throw new Error("Pi CLI is unavailable");
+		const resolution = resolveNodeHostExecutable("pi", {
+			env: process$1.env,
+			pathEnv: process$1.env.PATH ?? "",
+			strategy: "fallback"
+		});
+		if (!resolution) throw new Error("Pi CLI is unavailable");
 		return {
 			kind: "local",
 			argv: [
-				executable,
+				resolution.executable,
 				"--session",
 				params.threadId
 			],
 			...record.cwd ? { cwd: record.cwd } : {},
+			...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
 			title
 		};
 	}

package/dist/{process-reaper-B29BzBk4.js → process-reaper-CoGRyMJ_.js}

@@ -7,6 +7,12 @@ import fs from "node:fs";
 import path from "node:path";
 import { runExec } from "openclaw/plugin-sdk/process-runtime";
 import { fileURLToPath } from "node:url";
+//#region extensions/acpx/src/codex-adapter.ts
+const CODEX_ACP_PACKAGE = "@agentclientprotocol/codex-acp";
+const CODEX_ACP_BIN = "codex-acp";
+const LEGACY_CODEX_ACP_PACKAGE = "@zed-industries/codex-acp";
+const OPENCLAW_CODEX_CONFIG_ARG = "--openclaw-codex-config";
+//#endregion
 //#region extensions/acpx/src/command-line.ts
 /**
 * Small shell-command helpers for ACPX-launched processes. Splitting supports
@@ -248,8 +254,10 @@ function resolveAcpxPluginConfig(params) {
 const requireFromHere = createRequire(import.meta.url);
 const GENERATED_WRAPPER_BASENAMES = /* @__PURE__ */ new Set(["codex-acp-wrapper.mjs", "claude-agent-acp-wrapper.mjs"]);
 const OPENCLAW_PLUGIN_DEPS_MARKER = "/plugin-runtime-deps/";
+const ACPX_PROCESS_LIST_TIMEOUT_MS = 2e3;
 const OWNED_ACP_PACKAGE_NAMES = [
-	"@zed-industries/codex-acp",
+	CODEX_ACP_PACKAGE,
+	LEGACY_CODEX_ACP_PACKAGE,
 	"@zed-industries/codex-acp-darwin-arm64",
 	"@zed-industries/codex-acp-darwin-x64",
 	"@zed-industries/codex-acp-linux-arm64",
@@ -259,7 +267,20 @@ const OWNED_ACP_PACKAGE_NAMES = [
 	"@agentclientprotocol/claude-agent-acp",
 	"acpx"
 ];
-const ACP_PACKAGE_MARKERS = [...OWNED_ACP_PACKAGE_NAMES.map((packageName) => `/node_modules/${packageName}/`), "/acpx/dist/"];
+const PLUGIN_DEPS_CODEX_PACKAGE_NAMES = [
+	"@openai/codex",
+	"@openai/codex-darwin-arm64",
+	"@openai/codex-darwin-x64",
+	"@openai/codex-linux-arm64",
+	"@openai/codex-linux-x64",
+	"@openai/codex-win32-arm64",
+	"@openai/codex-win32-x64"
+];
+const ACP_PACKAGE_MARKERS = [
+	...OWNED_ACP_PACKAGE_NAMES.map((packageName) => `/node_modules/${packageName}/`),
+	...PLUGIN_DEPS_CODEX_PACKAGE_NAMES.map((packageName) => `/node_modules/${packageName}/`),
+	"/acpx/dist/"
+];
 function normalizePathLike(value) {
 	return value.replaceAll("\\", "/");
 }
@@ -354,7 +375,8 @@ async function listPlatformProcesses() {
 	if (process.platform === "win32") return [];
 	const { stdout } = await runExec("ps", ["-axo", "pid=,ppid=,command="], {
 		logOutput: false,
-		maxBuffer: 8 * 1024 * 1024
+		maxBuffer: 8 * 1024 * 1024,
+		timeoutMs: ACPX_PROCESS_LIST_TIMEOUT_MS
 	});
 	return parseProcessList(stdout);
 }
@@ -488,4 +510,4 @@ async function reapStaleOpenClawOwnedAcpxOrphans(params) {
 	};
 }
 //#endregion
-export { resolveAcpxPluginRoot as a, splitCommandParts as c, resolveAcpxPluginConfig as i, isOpenClawLeaseAwareAcpxProcessCommand as n, toAcpMcpServers as o, reapStaleOpenClawOwnedAcpxOrphans as r, quoteCommandPart as s, cleanupOpenClawOwnedAcpxProcessTree as t };
+export { resolveAcpxPluginRoot as a, splitCommandParts as c, LEGACY_CODEX_ACP_PACKAGE as d, OPENCLAW_CODEX_CONFIG_ARG as f, resolveAcpxPluginConfig as i, CODEX_ACP_BIN as l, isOpenClawLeaseAwareAcpxProcessCommand as n, toAcpMcpServers as o, reapStaleOpenClawOwnedAcpxOrphans as r, quoteCommandPart as s, cleanupOpenClawOwnedAcpxProcessTree as t, CODEX_ACP_PACKAGE as u };

package/dist/{register.runtime-DBqbPx5P.js → register.runtime-BrVpU-xc.js}

@@ -200,7 +200,7 @@ function createLazyAcpRuntimeProxy(resolveRuntime) {
 * immediately, then imports the heavier service only when a session needs it.
 */
 const ACPX_BACKEND_ID = "acpx";
-const loadServiceModule = createLazyRuntimeModule(() => import("./service-Dm8hpy-C.js"));
+const loadServiceModule = createLazyRuntimeModule(() => import("./service-D6LQXIcJ.js"));
 async function startRealService(state) {
 	if (state.realRuntime) return state.realRuntime;
 	if (!state.ctx) throw new Error("ACPX runtime service is not started");

package/dist/register.runtime.js

@@ -1,2 +1,2 @@
-import { t as createAcpxRuntimeService } from "./register.runtime-DBqbPx5P.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-BrVpU-xc.js";
 export { createAcpxRuntimeService };

package/dist/{runtime-D_fW1HnP.js → runtime-CMARmJuS.js}

@@ -1,19 +1,20 @@
 import { i as createAcpxProcessLeaseId, o as hashAcpxProcessCommand, u as withAcpxLeaseEnvironment } from "./process-lease-DiKkFj6F.js";
 import { AcpRuntimeError } from "./runtime-api.js";
-import { c as splitCommandParts, n as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxProcessTree } from "./process-reaper-B29BzBk4.js";
+import { c as splitCommandParts, f as OPENCLAW_CODEX_CONFIG_ARG, n as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxProcessTree, u as CODEX_ACP_PACKAGE } from "./process-reaper-CoGRyMJ_.js";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import fs from "node:fs/promises";
 import path, { resolve } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, isRequestedModelUnsupportedError } from "acpx/runtime";
 import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
-import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/acpx/src/runtime.ts
 /**
 * OpenClaw ACPX runtime adapter. It wraps the upstream acpx runtime with
 * OpenClaw session metadata, lease tracking, model scoping, and cleanup policy.
 */
+const ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME = "openclaw-plugin-tools";
 const ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME = "openclaw-tools";
 const OPENCLAW_TOOLS_MCP_AGENT_SESSION_KEY_ENV = "OPENCLAW_TOOLS_MCP_AGENT_SESSION_KEY";
 function withOpenClawManagedTurnTimeout(input) {
@@ -165,12 +166,6 @@ const OPENCLAW_BRIDGE_SUBCOMMAND = "acp";
 const CODEX_ACP_AGENT_ID = "codex";
 const CODEX_ACP_OPENCLAW_PREFIX = "openai/";
 const CLAUDE_ACP_OPENCLAW_PREFIX = "anthropic/";
-const CODEX_ACP_REASONING_EFFORTS = /* @__PURE__ */ new Set([
-	"low",
-	"medium",
-	"high",
-	"xhigh"
-]);
 const CODEX_ACP_THINKING_ALIASES = /* @__PURE__ */ new Map([
 	["off", void 0],
 	["minimal", "low"],
@@ -256,7 +251,7 @@ function isOpenClawBridgeCommand(command) {
 }
 function isCodexAcpCommand(command) {
 	return isAcpCommand(command, {
-		packageName: "@zed-industries/codex-acp",
+		packageName: CODEX_ACP_PACKAGE,
 		executableName: "codex-acp"
 	});
 }
@@ -285,27 +280,50 @@ function normalizeCodexAcpReasoningEffort(rawThinking) {
 	if (!CODEX_ACP_THINKING_ALIASES.has(normalized)) failUnsupportedCodexAcpThinking(rawThinking ?? "");
 	return CODEX_ACP_THINKING_ALIASES.get(normalized);
 }
-function normalizeCodexAcpModelOverride(rawModel, rawThinking) {
+function isCodexAcpReasoningEffortAlias(value) {
+	const normalized = value?.trim().toLowerCase();
+	return Boolean(normalized && CODEX_ACP_THINKING_ALIASES.has(normalized));
+}
+function classifyCodexAcpModelRequest(rawModel, rawThinking) {
 	const raw = rawModel?.trim();
 	const thinkingReasoningEffort = normalizeCodexAcpReasoningEffort(rawThinking);
-	if (!raw) return thinkingReasoningEffort ? { reasoningEffort: thinkingReasoningEffort } : void 0;
+	const thinkingOnlyOverride = thinkingReasoningEffort ? { reasoningEffort: thinkingReasoningEffort } : void 0;
+	if (!raw) return {
+		kind: "override",
+		override: thinkingOnlyOverride ?? {}
+	};
 	let value = raw;
-	if (value.toLowerCase().startsWith(CODEX_ACP_OPENCLAW_PREFIX)) value = value.slice(7);
-	const parts = value.split("/");
-	if (parts.length > 2) failUnsupportedCodexAcpModel(raw, `Codex ACP model "${raw}" is not supported. Use openai/<model> or <model>/<reasoning-effort>.`);
-	const model = (parts[0] ?? "").trim();
-	const modelReasoningEffort = normalizeCodexAcpReasoningEffort(parts[1]);
-	if (!model) failUnsupportedCodexAcpModel(raw, `Codex ACP model "${raw}" is not supported. Use openai/<model> or <model>/<reasoning-effort>.`);
+	let hadOpenAiQualifier = false;
+	if (value.toLowerCase().startsWith(CODEX_ACP_OPENCLAW_PREFIX)) {
+		value = value.slice(7);
+		hadOpenAiQualifier = true;
+	}
+	let model = value.trim();
+	let modelReasoningEffort;
+	const slashIndex = value.lastIndexOf("/");
+	if (slashIndex >= 0 && isCodexAcpReasoningEffortAlias(value.slice(slashIndex + 1))) {
+		modelReasoningEffort = normalizeCodexAcpReasoningEffort(value.slice(slashIndex + 1));
+		model = value.slice(0, slashIndex).trim();
+	}
+	if (hadOpenAiQualifier && (!model || model.includes("/"))) failUnsupportedCodexAcpModel(raw, `Codex ACP model "${raw}" is not supported. Use openai/<model> or <model>/<reasoning-effort>.`);
+	if (!model || model.includes("/")) return thinkingOnlyOverride ? {
+		kind: "unsupported",
+		thinkingOverride: thinkingOnlyOverride
+	} : { kind: "unsupported" };
 	const reasoningEffort = thinkingReasoningEffort ?? modelReasoningEffort;
-	if (reasoningEffort && !CODEX_ACP_REASONING_EFFORTS.has(reasoningEffort)) failUnsupportedCodexAcpThinking(reasoningEffort);
 	return {
-		model,
-		...reasoningEffort ? { reasoningEffort } : {}
+		kind: "override",
+		override: {
+			model,
+			...reasoningEffort ? { reasoningEffort } : {}
+		}
 	};
 }
-function codexAcpSessionModelId(override) {
-	if (!override.model) return "";
-	return override.reasoningEffort ? `${override.model}/${override.reasoningEffort}` : override.model;
+function withCodexSessionModel(input, override) {
+	const next = { ...input };
+	if (override?.model) next.model = override.model;
+	else delete next.model;
+	return next;
 }
 function normalizeClaudeAcpModelOverride(rawModel) {
 	const raw = rawModel?.trim();
@@ -320,8 +338,9 @@ function withAcpxSessionOptions(input) {
 		...existingOptions,
 		model
 	} : existingOptions;
+	const { modelExplicit: _modelExplicit, ...rest } = input;
 	return {
-		...input,
+		...rest,
 		...sessionOptions ? { sessionOptions } : {}
 	};
 }
@@ -344,10 +363,12 @@ function quoteShellArg(value) {
 	return `'${value.replace(/'/g, "'\\''")}'`;
 }
 function appendCodexAcpConfigOverrides(command, override) {
-	const configArgs = override.model ? [`model=${override.model}`] : [];
-	if (override.reasoningEffort) configArgs.push(`model_reasoning_effort=${override.reasoningEffort}`);
-	if (configArgs.length === 0) return command;
-	return `${command} ${configArgs.map((arg) => `-c ${quoteShellArg(arg)}`).join(" ")}`;
+	const config = {
+		...override.model ? { model: override.model } : {},
+		...override.reasoningEffort ? { model_reasoning_effort: override.reasoningEffort } : {}
+	};
+	if (Object.keys(config).length === 0) return command;
+	return `${command} ${OPENCLAW_CODEX_CONFIG_ARG} ${quoteShellArg(JSON.stringify(config))}`;
 }
 function createModelScopedAgentRegistry(params) {
 	return {
@@ -375,12 +396,14 @@ function shouldUseDistinctBridgeDelegate(options) {
 	const { mcpServers } = options;
 	return Array.isArray(mcpServers) && mcpServers.length > 0;
 }
-function withOpenClawToolsMcpSessionEnv(params) {
+function withManagedToolsMcpSessionEnv(params) {
 	const sessionKey = params.sessionKey.trim();
-	if (!params.enabled || !sessionKey || !params.mcpServers?.length) return params.mcpServers;
+	if (!params.pluginToolsEnabled && !params.openclawToolsEnabled || !sessionKey || !params.mcpServers?.length) return params.mcpServers;
 	let changed = false;
 	const nextServers = params.mcpServers.map((server) => {
-		if (server.name !== ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME || !("command" in server)) return server;
+		const isManagedPluginTools = params.pluginToolsEnabled && server.name === ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME;
+		const isManagedOpenClawTools = params.openclawToolsEnabled && server.name === ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME;
+		if (!isManagedPluginTools && !isManagedOpenClawTools || !("command" in server)) return server;
 		changed = true;
 		const env = [...server.env.filter((entry) => entry.name !== OPENCLAW_TOOLS_MCP_AGENT_SESSION_KEY_ENV), {
 			name: OPENCLAW_TOOLS_MCP_AGENT_SESSION_KEY_ENV,
@@ -397,14 +420,16 @@ function withOpenClawToolsMcpSessionEnv(params) {
 var AcpxRuntime = class {
 	constructor(options, testOptions) {
 		this.codexAcpModelOverrideScope = new AsyncLocalStorage();
-		this.openclawToolsSessionDelegates = /* @__PURE__ */ new Map();
+		this.managedToolsSessionDelegates = /* @__PURE__ */ new Map();
 		this.launchLeaseScope = new AsyncLocalStorage();
 		const { openclawProcessCleanup, ...delegateTestOptions } = testOptions ?? {};
 		this.processCleanupDeps = openclawProcessCleanup;
 		this.wrapperRoot = options.openclawWrapperRoot;
 		this.gatewayInstanceId = options.openclawGatewayInstanceId;
 		this.processLeaseStore = options.openclawProcessLeaseStore;
+		this.pluginToolsMcpBridgeEnabled = options.pluginToolsMcpBridgeEnabled === true;
 		this.openclawToolsMcpBridgeEnabled = options.openclawToolsMcpBridgeEnabled === true;
+		this.managedToolsMcpBridgeEnabled = this.pluginToolsMcpBridgeEnabled || this.openclawToolsMcpBridgeEnabled;
 		this.cwd = options.cwd;
 		this.sessionStore = createResetAwareSessionStore(options.sessionStore, {
 			gatewayInstanceId: this.gatewayInstanceId,
@@ -433,35 +458,36 @@ var AcpxRuntime = class {
 			agentName: normalizeAgentName(options.probeAgent) ?? "codex",
 			agentRegistry: this.agentRegistry
 		});
-		const useBridgeSafeProbe = this.openclawToolsMcpBridgeEnabled || shouldUseBridgeSafeDelegateForCommand(probeCommand);
+		const useBridgeSafeProbe = this.managedToolsMcpBridgeEnabled || shouldUseBridgeSafeDelegateForCommand(probeCommand);
 		this.probeDelegate = useBridgeSafeProbe ? this.bridgeSafeDelegate : this.delegate;
 	}
 	resolveDelegateForSession(params) {
 		if (shouldUseBridgeSafeDelegateForCommand(params.command)) return this.bridgeSafeDelegate;
-		return this.resolveOpenClawToolsDelegateForSession(params.sessionKey);
+		return this.resolveManagedToolsDelegateForSession(params.sessionKey);
 	}
-	resolveOpenClawToolsDelegateForSession(sessionKey) {
-		if (!this.openclawToolsMcpBridgeEnabled) return this.delegate;
+	resolveManagedToolsDelegateForSession(sessionKey) {
+		if (!this.managedToolsMcpBridgeEnabled) return this.delegate;
 		const normalizedSessionKey = sessionKey.trim();
 		if (!normalizedSessionKey) return this.delegate;
-		const cached = this.openclawToolsSessionDelegates.get(normalizedSessionKey);
+		const cached = this.managedToolsSessionDelegates.get(normalizedSessionKey);
 		if (cached) return cached;
 		const delegate = new AcpxRuntime$1({
 			...this.delegateOptions,
-			mcpServers: withOpenClawToolsMcpSessionEnv({
-				enabled: this.openclawToolsMcpBridgeEnabled,
+			mcpServers: withManagedToolsMcpSessionEnv({
+				pluginToolsEnabled: this.pluginToolsMcpBridgeEnabled,
+				openclawToolsEnabled: this.openclawToolsMcpBridgeEnabled,
 				mcpServers: this.delegateOptions.mcpServers,
 				sessionKey: normalizedSessionKey
 			})
 		}, this.delegateTestOptions);
-		this.openclawToolsSessionDelegates.set(normalizedSessionKey, delegate);
+		this.managedToolsSessionDelegates.set(normalizedSessionKey, delegate);
 		return delegate;
 	}
-	releaseOpenClawToolsDelegateForSession(sessionKey) {
-		if (!this.openclawToolsMcpBridgeEnabled) return;
+	releaseManagedToolsDelegateForSession(sessionKey) {
+		if (!this.managedToolsMcpBridgeEnabled) return;
 		const normalizedSessionKey = sessionKey.trim();
 		if (!normalizedSessionKey) return;
-		this.openclawToolsSessionDelegates.delete(normalizedSessionKey);
+		this.managedToolsSessionDelegates.delete(normalizedSessionKey);
 	}
 	async resolveDelegateForHandle(handle) {
 		const record = await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey);
@@ -613,9 +639,18 @@ var AcpxRuntime = class {
 			command,
 			sessionKey: input.sessionKey
 		});
+		const isCodexAcp = normalizeAgentName(input.agent) === CODEX_ACP_AGENT_ID && isCodexAcpCommand(command);
 		const claudeModelOverride = isClaudeAcpCommand(command) ? normalizeClaudeAcpModelOverride(input.model) : void 0;
-		const codexModelOverride = normalizeAgentName(input.agent) === CODEX_ACP_AGENT_ID && isCodexAcpCommand(command) ? normalizeCodexAcpModelOverride(input.model, input.thinking) : void 0;
-		const ensureInput = claudeModelOverride ? {
+		const codexClassification = isCodexAcp ? classifyCodexAcpModelRequest(input.model, input.thinking) : void 0;
+		if (codexClassification?.kind === "unsupported" && input.modelExplicit) failUnsupportedCodexAcpModel(input.model ?? "");
+		const classifiedCodexOverride = codexClassification?.kind === "override" ? codexClassification.override : codexClassification?.thinkingOverride;
+		const codexModelOverride = classifiedCodexOverride && Object.keys(classifiedCodexOverride).length > 0 ? classifiedCodexOverride : void 0;
+		const requestedModel = input.model?.trim();
+		const appliedModel = isCodexAcp && requestedModel ? codexModelOverride?.model ? {
+			kind: "applied",
+			model: requestedModel
+		} : { kind: "dropped" } : void 0;
+		const ensureInput = isCodexAcp ? withCodexSessionModel(input, codexModelOverride) : claudeModelOverride ? {
 			...input,
 			model: claudeModelOverride
 		} : input;
@@ -627,7 +662,7 @@ var AcpxRuntime = class {
 			command: stableLaunchCommand,
 			resumeSessionId: input.resumeSessionId
 		});
-		if (!codexModelOverride) return await this.runWithLaunchLease({
+		const handle = !codexModelOverride ? await this.runWithLaunchLease({
 			sessionKey: ensureInput.sessionKey,
 			command: stableLaunchCommand,
 			enabled: shouldStartWithLease,
@@ -636,21 +671,20 @@ var AcpxRuntime = class {
 				fallbackCode: "ACP_SESSION_INIT_FAILED",
 				run: () => ensureDelegateSessionWithModelFallback(delegate, ensureInput)
 			})
-		});
-		const normalizedInput = {
-			...ensureInput,
-			...codexAcpSessionModelId(codexModelOverride) ? { model: codexAcpSessionModelId(codexModelOverride) } : {}
-		};
-		return await this.runWithLaunchLease({
+		}) : await this.runWithLaunchLease({
 			sessionKey: input.sessionKey,
 			command: stableLaunchCommand,
 			enabled: shouldStartWithLease,
 			run: () => this.codexAcpModelOverrideScope.run(codexModelOverride, () => this.withCodexWrapperDiagnostics({
 				command: stableLaunchCommand,
 				fallbackCode: "ACP_SESSION_INIT_FAILED",
-				run: () => delegate.ensureSession(withAcpxSessionOptions(normalizedInput))
+				run: () => delegate.ensureSession(withAcpxSessionOptions(ensureInput))
 			}))
 		});
+		return appliedModel ? {
+			...handle,
+			appliedModel
+		} : handle;
 	}
 	async *runTurn(input) {
 		const command = await this.resolveCommandForHandle(input.handle);
@@ -751,8 +785,8 @@ var AcpxRuntime = class {
 			}
 		};
 	}
-	getCapabilities() {
-		return this.delegate.getCapabilities();
+	getCapabilities(input) {
+		return this.delegate.getCapabilities(input);
 	}
 	async getStatus(input) {
 		return (await this.resolveDelegateForHandle(input.handle)).getStatus(input);
@@ -767,22 +801,32 @@ var AcpxRuntime = class {
 		const isCodexAcp = isCodexAcpCommand(command);
 		if (WIRE_TIMEOUT_CONFIG_KEYS.has(key) && (isCodexAcp || isClaudeAcpCommand(command))) return;
 		if (isCodexAcp) {
-			if (key === "model" || key === "thinking" || key === "thought_level" || key === "reasoning_effort") {
-				const override = key === "model" ? normalizeCodexAcpModelOverride(input.value) : normalizeCodexAcpModelOverride(void 0, input.value);
-				if (!override && key !== "model") return;
-				if (override) {
-					if (override.model) await delegate.setConfigOption({
-						...input,
-						key: "model",
-						value: override.model
-					});
-					if (override.reasoningEffort) await delegate.setConfigOption({
-						...input,
-						key: "reasoning_effort",
-						value: override.reasoningEffort
-					});
-					return;
-				}
+			if (key === "model") {
+				const classification = classifyCodexAcpModelRequest(input.value);
+				if (classification.kind === "unsupported") failUnsupportedCodexAcpModel(input.value);
+				const { override } = classification;
+				if (override.model) await delegate.setConfigOption({
+					...input,
+					key: "model",
+					value: override.model
+				});
+				if (override.reasoningEffort) await delegate.setConfigOption({
+					...input,
+					key: "reasoning_effort",
+					value: override.reasoningEffort
+				});
+				return;
+			}
+			if (key === "thinking" || key === "thought_level" || key === "reasoning_effort") {
+				const classification = classifyCodexAcpModelRequest(void 0, input.value);
+				const reasoningEffort = classification.kind === "override" ? classification.override.reasoningEffort : void 0;
+				if (!reasoningEffort) return;
+				await delegate.setConfigOption({
+					...input,
+					key: "reasoning_effort",
+					value: reasoningEffort
+				});
+				return;
 			}
 		}
 		if (isClaudeAcpCommand(command) && key === "model") {
@@ -815,7 +859,7 @@ var AcpxRuntime = class {
 		} finally {
 			await this.cleanupProcessTreeForRecord(input.handle, record);
 		}
-		if (closeSucceeded) this.releaseOpenClawToolsDelegateForSession(input.handle.sessionKey);
+		if (closeSucceeded) this.releaseManagedToolsDelegateForSession(input.handle.sessionKey);
 		if (closeSucceeded && input.discardPersistentState) this.sessionStore.markFresh(input.handle.sessionKey);
 	}
 };
@@ -823,11 +867,10 @@ var AcpxRuntime = class {
 const testing = {
 	appendCodexAcpConfigOverrides,
 	assertSupportedRuntimeSessionMode,
-	codexAcpSessionModelId,
+	classifyCodexAcpModelRequest,
 	isClaudeAcpCommand,
 	isCodexAcpCommand,
-	normalizeClaudeAcpModelOverride,
-	normalizeCodexAcpModelOverride
+	normalizeClaudeAcpModelOverride
 };
 //#endregion
 export { ACPX_BACKEND_ID, AcpxRuntime, testing as __testing, testing, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState };