@openclaw/acpx 2026.7.2-beta.5 → 2026.7.33

package/dist/{process-lease-CU1cFI4I.js → .setup/process-lease-DiKkFj6F.mjs}

@@ -22,7 +22,11 @@ function normalizeAcpxGatewayInstanceRecord(value) {
 * Persistent lease store for ACPX wrapper processes. Leases let OpenClaw attach
 * gateway/session identity to spawned ACP processes and clean them up later.
 */
-/** CLI argument carrying the ACPX process lease id. */
+/** Environment variable carrying the ACPX process lease id. */
+const OPENCLAW_ACPX_LEASE_ID_ENV = "OPENCLAW_ACPX_LEASE_ID";
+/** Environment variable carrying the owning gateway instance id. */
+const OPENCLAW_GATEWAY_INSTANCE_ID_ENV = "OPENCLAW_GATEWAY_INSTANCE_ID";
+/** CLI argument carrying the ACPX process lease id for platforms without env wrapping. */
 const OPENCLAW_ACPX_LEASE_ID_ARG = "--openclaw-acpx-lease-id";
 /** CLI argument carrying the owning gateway instance id. */
 const OPENCLAW_GATEWAY_INSTANCE_ID_ARG = "--openclaw-gateway-instance-id";
@@ -123,9 +127,15 @@ function appendAcpxLeaseArgs(params) {
 		quoteEnvValue(params.gatewayInstanceId)
 	].join(" ");
 }
-/** Add ACPX lease identity to a command through portable wrapper arguments. */
+/** Add ACPX lease identity to a command through env vars and portable args. */
 function withAcpxLeaseEnvironment(params) {
-	return appendAcpxLeaseArgs(params);
+	if ((params.platform ?? process.platform) === "win32") return appendAcpxLeaseArgs(params);
+	return [
+		"env",
+		`${OPENCLAW_ACPX_LEASE_ID_ENV}=${quoteEnvValue(params.leaseId)}`,
+		`${OPENCLAW_GATEWAY_INSTANCE_ID_ENV}=${quoteEnvValue(params.gatewayInstanceId)}`,
+		appendAcpxLeaseArgs(params)
+	].join(" ");
 }
 //#endregion
-export { hashAcpxProcessCommand as a, openAcpxProcessLeaseStateStore as c, ACPX_GATEWAY_INSTANCE_NAMESPACE as d, ACPX_LEGACY_GATEWAY_INSTANCE_FILE as f, createAcpxProcessLeaseStore as i, withAcpxLeaseEnvironment as l, normalizeAcpxGatewayInstanceRecord as m, OPENCLAW_GATEWAY_INSTANCE_ID_ARG as n, normalizeAcpxProcessLease as o, ACPX_LEGACY_PROCESS_LEASE_FILE as p, createAcpxProcessLeaseId as r, normalizeAcpxProcessLeaseFile as s, OPENCLAW_ACPX_LEASE_ID_ARG as t, ACPX_GATEWAY_INSTANCE_KEY as u };
+export { createAcpxProcessLeaseStore as a, normalizeAcpxProcessLeaseFile as c, ACPX_GATEWAY_INSTANCE_KEY as d, ACPX_GATEWAY_INSTANCE_NAMESPACE as f, normalizeAcpxGatewayInstanceRecord as h, createAcpxProcessLeaseId as i, openAcpxProcessLeaseStateStore as l, ACPX_LEGACY_PROCESS_LEASE_FILE as m, OPENCLAW_ACPX_LEASE_ID_ENV as n, hashAcpxProcessCommand as o, ACPX_LEGACY_GATEWAY_INSTANCE_FILE as p, OPENCLAW_GATEWAY_INSTANCE_ID_ARG as r, normalizeAcpxProcessLease as s, OPENCLAW_ACPX_LEASE_ID_ARG as t, withAcpxLeaseEnvironment as u };

package/dist/{register.runtime-Dajn8myc.js → .setup/register.runtime-DjVBj71-.mjs}

@@ -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-DOsKw_R1.js"));
+const loadServiceModule = createLazyRuntimeModule(() => import("./service-CE4bgxXH.mjs").then((n) => n.t));
 async function startRealService(state) {
 	if (state.realRuntime) return state.realRuntime;
 	if (!state.ctx) throw new Error("ACPX runtime service is not started");

package/dist/{runtime-CN4JQkdV.js → .setup/runtime-FxGnBh3l.mjs}

@@ -1,20 +1,18 @@
-import { a as hashAcpxProcessCommand, l as withAcpxLeaseEnvironment, r as createAcpxProcessLeaseId } from "./process-lease-CU1cFI4I.js";
-import { AcpRuntimeError } from "./runtime-api.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-BIOtp_Ek.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 { i as createAcpxProcessLeaseId, o as hashAcpxProcessCommand, u as withAcpxLeaseEnvironment } from "./process-lease-DiKkFj6F.mjs";
+import { AcpRuntimeError } from "../runtime-api.js";
+import { i as splitCommandParts, n as cleanupOpenClawOwnedAcpxProcessTree, r as isOpenClawLeaseAwareAcpxProcessCommand } from "./service-CE4bgxXH.mjs";
 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";
 //#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) {
@@ -50,7 +48,8 @@ function isGenericInternalAcpError(error) {
 async function readCodexWrapperStderrTail(params) {
 	if (!params.wrapperRoot || !params.leaseId) return "";
 	try {
-		return compactDiagnosticText(redactSensitiveText(sliceUtf16Safe(await fs.readFile(path.join(params.wrapperRoot, codexWrapperStderrLogFileName(params.leaseId)), "utf8"), -6e3)));
+		const text = await fs.readFile(path.join(params.wrapperRoot, codexWrapperStderrLogFileName(params.leaseId)), "utf8");
+		return compactDiagnosticText(redactSensitiveText(text.slice(-6e3)));
 	} catch {
 		return "";
 	}
@@ -166,6 +165,12 @@ 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"],
@@ -209,14 +214,9 @@ function isEnvAssignment(value) {
 	return /^[A-Za-z_][A-Za-z0-9_]*=/.test(value);
 }
 function unwrapEnvCommand(parts) {
-	const command = parts.at(0);
-	if (!command || basename(command) !== "env") return parts;
+	if (!parts.length || basename(parts[0]) !== "env") return parts;
 	let index = 1;
-	while (true) {
-		const part = parts.at(index);
-		if (!part || !isEnvAssignment(part)) break;
-		index += 1;
-	}
+	while (index < parts.length && isEnvAssignment(parts[index])) index += 1;
 	return parts.slice(index);
 }
 function matchesExecutableName(value, executableName) {
@@ -251,7 +251,7 @@ function isOpenClawBridgeCommand(command) {
 }
 function isCodexAcpCommand(command) {
 	return isAcpCommand(command, {
-		packageName: CODEX_ACP_PACKAGE,
+		packageName: "@zed-industries/codex-acp",
 		executableName: "codex-acp"
 	});
 }
@@ -280,50 +280,27 @@ function normalizeCodexAcpReasoningEffort(rawThinking) {
 	if (!CODEX_ACP_THINKING_ALIASES.has(normalized)) failUnsupportedCodexAcpThinking(rawThinking ?? "");
 	return CODEX_ACP_THINKING_ALIASES.get(normalized);
 }
-function isCodexAcpReasoningEffortAlias(value) {
-	const normalized = value?.trim().toLowerCase();
-	return Boolean(normalized && CODEX_ACP_THINKING_ALIASES.has(normalized));
-}
-function classifyCodexAcpModelRequest(rawModel, rawThinking) {
+function normalizeCodexAcpModelOverride(rawModel, rawThinking) {
 	const raw = rawModel?.trim();
 	const thinkingReasoningEffort = normalizeCodexAcpReasoningEffort(rawThinking);
-	const thinkingOnlyOverride = thinkingReasoningEffort ? { reasoningEffort: thinkingReasoningEffort } : void 0;
-	if (!raw) return {
-		kind: "override",
-		override: thinkingOnlyOverride ?? {}
-	};
+	if (!raw) return thinkingReasoningEffort ? { reasoningEffort: thinkingReasoningEffort } : void 0;
 	let value = raw;
-	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" };
+	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>.`);
 	const reasoningEffort = thinkingReasoningEffort ?? modelReasoningEffort;
+	if (reasoningEffort && !CODEX_ACP_REASONING_EFFORTS.has(reasoningEffort)) failUnsupportedCodexAcpThinking(reasoningEffort);
 	return {
-		kind: "override",
-		override: {
-			model,
-			...reasoningEffort ? { reasoningEffort } : {}
-		}
+		model,
+		...reasoningEffort ? { reasoningEffort } : {}
 	};
 }
-function withCodexSessionModel(input, override) {
-	const next = { ...input };
-	if (override?.model) next.model = override.model;
-	else delete next.model;
-	return next;
+function codexAcpSessionModelId(override) {
+	if (!override.model) return "";
+	return override.reasoningEffort ? `${override.model}/${override.reasoningEffort}` : override.model;
 }
 function normalizeClaudeAcpModelOverride(rawModel) {
 	const raw = rawModel?.trim();
@@ -338,9 +315,8 @@ function withAcpxSessionOptions(input) {
 		...existingOptions,
 		model
 	} : existingOptions;
-	const { modelExplicit: _modelExplicit, ...rest } = input;
 	return {
-		...rest,
+		...input,
 		...sessionOptions ? { sessionOptions } : {}
 	};
 }
@@ -363,12 +339,10 @@ function quoteShellArg(value) {
 	return `'${value.replace(/'/g, "'\\''")}'`;
 }
 function appendCodexAcpConfigOverrides(command, override) {
-	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))}`;
+	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(" ")}`;
 }
 function createModelScopedAgentRegistry(params) {
 	return {
@@ -389,6 +363,13 @@ 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);
 }
@@ -396,14 +377,12 @@ function shouldUseDistinctBridgeDelegate(options) {
 	const { mcpServers } = options;
 	return Array.isArray(mcpServers) && mcpServers.length > 0;
 }
-function withManagedToolsMcpSessionEnv(params) {
+function withOpenClawToolsMcpSessionEnv(params) {
 	const sessionKey = params.sessionKey.trim();
-	if (!params.pluginToolsEnabled && !params.openclawToolsEnabled || !sessionKey || !params.mcpServers?.length) return params.mcpServers;
+	if (!params.enabled || !sessionKey || !params.mcpServers?.length) return params.mcpServers;
 	let changed = false;
 	const nextServers = params.mcpServers.map((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;
+		if (server.name !== ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME || !("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,
@@ -420,16 +399,14 @@ function withManagedToolsMcpSessionEnv(params) {
 var AcpxRuntime = class {
 	constructor(options, testOptions) {
 		this.codexAcpModelOverrideScope = new AsyncLocalStorage();
-		this.managedToolsSessionDelegates = /* @__PURE__ */ new Map();
+		this.openclawToolsSessionDelegates = /* @__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,
@@ -454,40 +431,44 @@ var AcpxRuntime = class {
 			...sharedOptions,
 			mcpServers: []
 		}, this.delegateTestOptions) : this.delegate;
-		const probeCommand = resolveAgentCommand({
-			agentName: normalizeAgentName(options.probeAgent) ?? "codex",
+		this.probeDelegate = this.openclawToolsMcpBridgeEnabled ? this.bridgeSafeDelegate : this.resolveDelegateForAgent(resolveProbeAgentName(options));
+	}
+	resolveDelegateForAgent(agentName) {
+		const command = resolveAgentCommandForName({
+			agentName,
 			agentRegistry: this.agentRegistry
 		});
-		const useBridgeSafeProbe = this.managedToolsMcpBridgeEnabled || shouldUseBridgeSafeDelegateForCommand(probeCommand);
-		this.probeDelegate = useBridgeSafeProbe ? this.bridgeSafeDelegate : this.delegate;
+		return this.resolveDelegateForCommand(command);
+	}
+	resolveDelegateForCommand(command) {
+		return shouldUseBridgeSafeDelegateForCommand(command) ? this.bridgeSafeDelegate : this.delegate;
 	}
 	resolveDelegateForSession(params) {
 		if (shouldUseBridgeSafeDelegateForCommand(params.command)) return this.bridgeSafeDelegate;
-		return this.resolveManagedToolsDelegateForSession(params.sessionKey);
+		return this.resolveOpenClawToolsDelegateForSession(params.sessionKey);
 	}
-	resolveManagedToolsDelegateForSession(sessionKey) {
-		if (!this.managedToolsMcpBridgeEnabled) return this.delegate;
+	resolveOpenClawToolsDelegateForSession(sessionKey) {
+		if (!this.openclawToolsMcpBridgeEnabled) return this.delegate;
 		const normalizedSessionKey = sessionKey.trim();
 		if (!normalizedSessionKey) return this.delegate;
-		const cached = this.managedToolsSessionDelegates.get(normalizedSessionKey);
+		const cached = this.openclawToolsSessionDelegates.get(normalizedSessionKey);
 		if (cached) return cached;
 		const delegate = new AcpxRuntime$1({
 			...this.delegateOptions,
-			mcpServers: withManagedToolsMcpSessionEnv({
-				pluginToolsEnabled: this.pluginToolsMcpBridgeEnabled,
-				openclawToolsEnabled: this.openclawToolsMcpBridgeEnabled,
+			mcpServers: withOpenClawToolsMcpSessionEnv({
+				enabled: this.openclawToolsMcpBridgeEnabled,
 				mcpServers: this.delegateOptions.mcpServers,
 				sessionKey: normalizedSessionKey
 			})
 		}, this.delegateTestOptions);
-		this.managedToolsSessionDelegates.set(normalizedSessionKey, delegate);
+		this.openclawToolsSessionDelegates.set(normalizedSessionKey, delegate);
 		return delegate;
 	}
-	releaseManagedToolsDelegateForSession(sessionKey) {
-		if (!this.managedToolsMcpBridgeEnabled) return;
+	releaseOpenClawToolsDelegateForSession(sessionKey) {
+		if (!this.openclawToolsMcpBridgeEnabled) return;
 		const normalizedSessionKey = sessionKey.trim();
 		if (!normalizedSessionKey) return;
-		this.managedToolsSessionDelegates.delete(normalizedSessionKey);
+		this.openclawToolsSessionDelegates.delete(normalizedSessionKey);
 	}
 	async resolveDelegateForHandle(handle) {
 		const record = await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey);
@@ -499,7 +480,7 @@ var AcpxRuntime = class {
 			command: recordCommand,
 			sessionKey: handle.sessionKey
 		});
-		const command = resolveAgentCommand({
+		const command = resolveAgentCommandForName({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -511,7 +492,7 @@ var AcpxRuntime = class {
 	async resolveCommandForHandle(handle) {
 		const recordCommand = readAgentCommandFromRecord(await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey));
 		if (recordCommand) return recordCommand;
-		return resolveAgentCommand({
+		return resolveAgentCommandForName({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -605,7 +586,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) ?? resolveAgentCommand({
+		const rootCommand = readAgentCommandFromRecord(record) ?? resolveAgentCommandForName({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -631,7 +612,7 @@ var AcpxRuntime = class {
 	}
 	async ensureSession(input) {
 		assertSupportedRuntimeSessionMode(input.mode);
-		const command = resolveAgentCommand({
+		const command = resolveAgentCommandForName({
 			agentName: input.agent,
 			agentRegistry: this.agentRegistry
 		});
@@ -639,18 +620,9 @@ 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 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 ? {
+		const codexModelOverride = normalizeAgentName(input.agent) === CODEX_ACP_AGENT_ID && isCodexAcpCommand(command) ? normalizeCodexAcpModelOverride(input.model, input.thinking) : void 0;
+		const ensureInput = claudeModelOverride ? {
 			...input,
 			model: claudeModelOverride
 		} : input;
@@ -662,7 +634,7 @@ var AcpxRuntime = class {
 			command: stableLaunchCommand,
 			resumeSessionId: input.resumeSessionId
 		});
-		const handle = !codexModelOverride ? await this.runWithLaunchLease({
+		if (!codexModelOverride) return await this.runWithLaunchLease({
 			sessionKey: ensureInput.sessionKey,
 			command: stableLaunchCommand,
 			enabled: shouldStartWithLease,
@@ -671,20 +643,21 @@ var AcpxRuntime = class {
 				fallbackCode: "ACP_SESSION_INIT_FAILED",
 				run: () => ensureDelegateSessionWithModelFallback(delegate, ensureInput)
 			})
-		}) : await this.runWithLaunchLease({
+		});
+		const normalizedInput = {
+			...ensureInput,
+			...codexAcpSessionModelId(codexModelOverride) ? { model: codexAcpSessionModelId(codexModelOverride) } : {}
+		};
+		return 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(ensureInput))
+				run: () => delegate.ensureSession(withAcpxSessionOptions(normalizedInput))
 			}))
 		});
-		return appliedModel ? {
-			...handle,
-			appliedModel
-		} : handle;
 	}
 	async *runTurn(input) {
 		const command = await this.resolveCommandForHandle(input.handle);
@@ -785,8 +758,8 @@ var AcpxRuntime = class {
 			}
 		};
 	}
-	getCapabilities(input) {
-		return this.delegate.getCapabilities(input);
+	getCapabilities() {
+		return this.delegate.getCapabilities();
 	}
 	async getStatus(input) {
 		return (await this.resolveDelegateForHandle(input.handle)).getStatus(input);
@@ -801,32 +774,22 @@ var AcpxRuntime = class {
 		const isCodexAcp = isCodexAcpCommand(command);
 		if (WIRE_TIMEOUT_CONFIG_KEYS.has(key) && (isCodexAcp || isClaudeAcpCommand(command))) return;
 		if (isCodexAcp) {
-			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 (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 (isClaudeAcpCommand(command) && key === "model") {
@@ -859,7 +822,7 @@ var AcpxRuntime = class {
 		} finally {
 			await this.cleanupProcessTreeForRecord(input.handle, record);
 		}
-		if (closeSucceeded) this.releaseManagedToolsDelegateForSession(input.handle.sessionKey);
+		if (closeSucceeded) this.releaseOpenClawToolsDelegateForSession(input.handle.sessionKey);
 		if (closeSucceeded && input.discardPersistentState) this.sessionStore.markFresh(input.handle.sessionKey);
 	}
 };
@@ -867,10 +830,11 @@ var AcpxRuntime = class {
 const testing = {
 	appendCodexAcpConfigOverrides,
 	assertSupportedRuntimeSessionMode,
-	classifyCodexAcpModelRequest,
+	codexAcpSessionModelId,
 	isClaudeAcpCommand,
 	isCodexAcpCommand,
-	normalizeClaudeAcpModelOverride
+	normalizeClaudeAcpModelOverride,
+	normalizeCodexAcpModelOverride
 };
 //#endregion
 export { ACPX_BACKEND_ID, AcpxRuntime, testing as __testing, testing, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState };