@openclaw/acpx 2026.7.1 → 2026.7.2-beta.2

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

@@ -1,13 +1,18 @@
+import { t as AcpxPluginConfigSchema } from "./config-schema-lrk5nlcV.js";
 import "./process-lease-DiKkFj6F.js";
 import { createRequire } from "node:module";
 import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
-import path from "node:path";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import fs from "node:fs";
+import path from "node:path";
+import { runExec } from "openclaw/plugin-sdk/process-runtime";
 import { fileURLToPath } from "node:url";
-import { z } from "zod";
+//#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
@@ -56,42 +61,6 @@ function splitCommandParts(value) {
 	return parts;
 }
 //#endregion
-//#region extensions/acpx/src/config-schema.ts
-/**
-* ACPX plugin configuration schema and public config types. Runtime setup uses
-* this file as the single source of truth for validation and defaulting.
-*/
-const ACPX_PERMISSION_MODES = [
-	"approve-all",
-	"approve-reads",
-	"deny-all"
-];
-const ACPX_NON_INTERACTIVE_POLICIES = ["deny", "fail"];
-const nonEmptyTrimmedString = (message) => z.string({ error: message }).trim().min(1, { error: message });
-const McpServerConfigSchema = z.object({
-	command: nonEmptyTrimmedString("command must be a non-empty string").describe("Command to run the MCP server"),
-	args: z.array(z.string({ error: "args must be an array of strings" }), { error: "args must be an array of strings" }).optional().describe("Arguments to pass to the command"),
-	env: z.record(z.string(), z.string({ error: "env values must be strings" }), { error: "env must be an object of strings" }).optional().describe("Environment variables for the MCP server")
-});
-/** Zod schema for validating raw ACPX plugin config from OpenClaw config. */
-const AcpxPluginConfigSchema = z.strictObject({
-	cwd: nonEmptyTrimmedString("cwd must be a non-empty string").optional(),
-	stateDir: nonEmptyTrimmedString("stateDir must be a non-empty string").optional(),
-	probeAgent: nonEmptyTrimmedString("probeAgent must be a non-empty string").optional(),
-	permissionMode: z.enum(ACPX_PERMISSION_MODES, { error: `permissionMode must be one of: ${ACPX_PERMISSION_MODES.join(", ")}` }).optional(),
-	nonInteractivePermissions: z.enum(ACPX_NON_INTERACTIVE_POLICIES, { error: `nonInteractivePermissions must be one of: ${ACPX_NON_INTERACTIVE_POLICIES.join(", ")}` }).optional(),
-	pluginToolsMcpBridge: z.boolean({ error: "pluginToolsMcpBridge must be a boolean" }).optional(),
-	openClawToolsMcpBridge: z.boolean({ error: "openClawToolsMcpBridge must be a boolean" }).optional(),
-	strictWindowsCmdWrapper: z.boolean({ error: "strictWindowsCmdWrapper must be a boolean" }).optional(),
-	timeoutSeconds: z.number({ error: "timeoutSeconds must be a number >= 0.001" }).min(.001, { error: "timeoutSeconds must be a number >= 0.001" }).default(120),
-	queueOwnerTtlSeconds: z.number({ error: "queueOwnerTtlSeconds must be a number >= 0" }).min(0, { error: "queueOwnerTtlSeconds must be a number >= 0" }).optional(),
-	mcpServers: z.record(z.string(), McpServerConfigSchema).optional(),
-	agents: z.record(z.string(), z.strictObject({
-		command: nonEmptyTrimmedString("agents.<id>.command must be a non-empty string"),
-		args: z.array(z.string({ error: "args must be an array of strings" })).optional()
-	})).optional()
-});
-//#endregion
 //#region extensions/acpx/src/config.ts
 /**
 * Resolves ACPX plugin config from raw user configuration. It locates the
@@ -260,7 +229,7 @@ function resolveAcpxPluginConfig(params) {
 	return {
 		cwd,
 		stateDir,
-		probeAgent: normalizeLowercaseStringOrEmpty(normalized.probeAgent) || void 0,
+		probeAgent: normalized.probeAgent,
 		permissionMode: normalized.permissionMode ?? DEFAULT_PERMISSION_MODE,
 		nonInteractivePermissions: normalized.nonInteractivePermissions ?? DEFAULT_NON_INTERACTIVE_POLICY,
 		pluginToolsMcpBridge,
@@ -282,12 +251,13 @@ function resolveAcpxPluginConfig(params) {
 * ACPX process ownership checks and cleanup. The reaper only terminates
 * OpenClaw-owned wrapper trees after validating paths, packages, and lease ids.
 */
-const execFileAsync = promisify(execFile);
 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",
@@ -297,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("\\", "/");
 }
@@ -375,11 +358,14 @@ function parseProcessList(stdout) {
 	const processes = [];
 	for (const line of stdout.split(/\r?\n/)) {
 		const match = /^\s*(?<pid>\d+)\s+(?<ppid>\d+)\s+(?<command>.+?)\s*$/.exec(line);
-		if (!match?.groups) continue;
+		const pid = match?.groups?.pid;
+		const ppid = match?.groups?.ppid;
+		const command = match?.groups?.command;
+		if (!pid || !ppid || !command) continue;
 		processes.push({
-			pid: Number.parseInt(match.groups.pid, 10),
-			ppid: Number.parseInt(match.groups.ppid, 10),
-			command: match.groups.command
+			pid: Number.parseInt(pid, 10),
+			ppid: Number.parseInt(ppid, 10),
+			command
 		});
 	}
 	return processes;
@@ -387,7 +373,11 @@ function parseProcessList(stdout) {
 /** List host processes in the compact shape needed by ACPX cleanup. */
 async function listPlatformProcesses() {
 	if (process.platform === "win32") return [];
-	const { stdout } = await execFileAsync("ps", ["-axo", "pid=,ppid=,command="], { maxBuffer: 8 * 1024 * 1024 });
+	const { stdout } = await runExec("ps", ["-axo", "pid=,ppid=,command="], {
+		logOutput: false,
+		maxBuffer: 8 * 1024 * 1024,
+		timeoutMs: ACPX_PROCESS_LIST_TIMEOUT_MS
+	});
 	return parseProcessList(stdout);
 }
 function collectProcessTree(processes, rootPid) {
@@ -520,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-Yz704dK5.js → register.runtime-CysfMsSr.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-CzJr7Koj.js"));
+const loadServiceModule = createLazyRuntimeModule(() => import("./service-DJchyiuU.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-Yz704dK5.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-CysfMsSr.js";
 export { createAcpxRuntimeService };

package/dist/{runtime-WjNm2DKO.js → runtime-BEOGc4Ik.js}

@@ -1,18 +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-cncoDfwV.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 fs from "node:fs/promises";
 import path, { resolve } from "node:path";
-import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, isRequestedModelUnsupportedError } from "acpx/runtime";
-import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-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) {
@@ -48,7 +50,7 @@ function isGenericInternalAcpError(error) {
 async function readCodexWrapperStderrTail(params) {
 	if (!params.wrapperRoot || !params.leaseId) return "";
 	try {
-		return compactDiagnosticText(redactSensitiveText((await fs.readFile(path.join(params.wrapperRoot, codexWrapperStderrLogFileName(params.leaseId)), "utf8")).slice(-6e3)));
+		return compactDiagnosticText(redactSensitiveText(sliceUtf16Safe(await fs.readFile(path.join(params.wrapperRoot, codexWrapperStderrLogFileName(params.leaseId)), "utf8"), -6e3)));
 	} catch {
 		return "";
 	}
@@ -213,9 +215,14 @@ function isEnvAssignment(value) {
 	return /^[A-Za-z_][A-Za-z0-9_]*=/.test(value);
 }
 function unwrapEnvCommand(parts) {
-	if (!parts.length || basename(parts[0]) !== "env") return parts;
+	const command = parts.at(0);
+	if (!command || basename(command) !== "env") return parts;
 	let index = 1;
-	while (index < parts.length && isEnvAssignment(parts[index])) index += 1;
+	while (true) {
+		const part = parts.at(index);
+		if (!part || !isEnvAssignment(part)) break;
+		index += 1;
+	}
 	return parts.slice(index);
 }
 function matchesExecutableName(value, executableName) {
@@ -250,7 +257,7 @@ function isOpenClawBridgeCommand(command) {
 }
 function isCodexAcpCommand(command) {
 	return isAcpCommand(command, {
-		packageName: "@zed-industries/codex-acp",
+		packageName: CODEX_ACP_PACKAGE,
 		executableName: "codex-acp"
 	});
 }
@@ -297,10 +304,6 @@ function normalizeCodexAcpModelOverride(rawModel, rawThinking) {
 		...reasoningEffort ? { reasoningEffort } : {}
 	};
 }
-function codexAcpSessionModelId(override) {
-	if (!override.model) return "";
-	return override.reasoningEffort ? `${override.model}/${override.reasoningEffort}` : override.model;
-}
 function normalizeClaudeAcpModelOverride(rawModel) {
 	const raw = rawModel?.trim();
 	if (!raw) return;
@@ -338,10 +341,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 {
@@ -362,13 +367,6 @@ function resolveAgentCommand(params) {
 	const resolvedCommand = params.agentRegistry.resolve(normalizedAgentName);
 	return typeof resolvedCommand === "string" ? resolvedCommand.trim() || void 0 : void 0;
 }
-function resolveProbeAgentName(options) {
-	const { probeAgent } = options;
-	return normalizeAgentName(typeof probeAgent === "string" ? probeAgent : void 0) ?? "codex";
-}
-function resolveAgentCommandForName(params) {
-	return resolveAgentCommand(params);
-}
 function shouldUseBridgeSafeDelegateForCommand(command) {
 	return isOpenClawBridgeCommand(command);
 }
@@ -376,12 +374,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,
@@ -398,14 +398,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,
@@ -430,44 +432,40 @@ var AcpxRuntime = class {
 			...sharedOptions,
 			mcpServers: []
 		}, this.delegateTestOptions) : this.delegate;
-		this.probeDelegate = this.openclawToolsMcpBridgeEnabled ? this.bridgeSafeDelegate : this.resolveDelegateForAgent(resolveProbeAgentName(options));
-	}
-	resolveDelegateForAgent(agentName) {
-		const command = resolveAgentCommandForName({
-			agentName,
+		const probeCommand = resolveAgentCommand({
+			agentName: normalizeAgentName(options.probeAgent) ?? "codex",
 			agentRegistry: this.agentRegistry
 		});
-		return this.resolveDelegateForCommand(command);
-	}
-	resolveDelegateForCommand(command) {
-		return shouldUseBridgeSafeDelegateForCommand(command) ? this.bridgeSafeDelegate : this.delegate;
+		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);
@@ -479,7 +477,7 @@ var AcpxRuntime = class {
 			command: recordCommand,
 			sessionKey: handle.sessionKey
 		});
-		const command = resolveAgentCommandForName({
+		const command = resolveAgentCommand({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -491,7 +489,7 @@ var AcpxRuntime = class {
 	async resolveCommandForHandle(handle) {
 		const recordCommand = readAgentCommandFromRecord(await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey));
 		if (recordCommand) return recordCommand;
-		return resolveAgentCommandForName({
+		return resolveAgentCommand({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -585,7 +583,7 @@ var AcpxRuntime = class {
 			await this.processLeaseStore?.markState(lease.leaseId, result.terminatedPids.length > 0 || result.skippedReason === "missing-root" ? "closed" : "lost");
 			return;
 		}
-		const rootCommand = readAgentCommandFromRecord(record) ?? resolveAgentCommandForName({
+		const rootCommand = readAgentCommandFromRecord(record) ?? resolveAgentCommand({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -611,7 +609,7 @@ var AcpxRuntime = class {
 	}
 	async ensureSession(input) {
 		assertSupportedRuntimeSessionMode(input.mode);
-		const command = resolveAgentCommandForName({
+		const command = resolveAgentCommand({
 			agentName: input.agent,
 			agentRegistry: this.agentRegistry
 		});
@@ -645,7 +643,7 @@ var AcpxRuntime = class {
 		});
 		const normalizedInput = {
 			...ensureInput,
-			...codexAcpSessionModelId(codexModelOverride) ? { model: codexAcpSessionModelId(codexModelOverride) } : {}
+			...codexModelOverride.model ? { model: codexModelOverride.model } : {}
 		};
 		return await this.runWithLaunchLease({
 			sessionKey: input.sessionKey,
@@ -757,8 +755,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);
@@ -821,7 +819,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);
 	}
 };
@@ -829,7 +827,6 @@ var AcpxRuntime = class {
 const testing = {
 	appendCodexAcpConfigOverrides,
 	assertSupportedRuntimeSessionMode,
-	codexAcpSessionModelId,
 	isClaudeAcpCommand,
 	isCodexAcpCommand,
 	normalizeClaudeAcpModelOverride,