@openclaw/acpx 2026.9.4 → 2026.9.6

package/dist/runtime-CSNBTQIs.js

@@ -1,1040 +0,0 @@
-import { _ as splitCommandParts, a as hashAcpxProcessCommand, g as renderAgentCommand, l as readAcpxProcessLeaseIdentity, t as ACPX_PROBE_LEASE_SESSION_KEY, u as withAcpxLeaseArgs } from "./process-lease-B83BGiLj.js";
-import { AcpRuntimeError } from "./runtime-api.js";
-import { t as resolveAcpxSessionResource } from "./session-resource-UWe7qD3m.js";
-import { a as CODEX_ACP_PACKAGE, i as isOpenClawLeaseAwareAcpxProcessCommand, n as cleanupOpenClawOwnedAcpxPendingLease, o as OPENCLAW_CODEX_CONFIG_ARG, r as cleanupOpenClawOwnedAcpxProcessTree } from "./service-BAf6nuci.js";
-import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
-import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import path, { resolve } from "node:path";
-import fs from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { isDeepStrictEqual } from "node:util";
-import { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, decodeAcpxRuntimeHandleState as decodeAcpxRuntimeHandleState$1, encodeAcpxRuntimeHandleState, isRequestedModelUnsupportedError } from "acpx/runtime";
-import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
-//#region extensions/acpx/src/session-owner.ts
-function requireAcpxOwnerMigration(sessionKey) {
-	throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", `ACP session "${sessionKey}" has an unqualified or unverifiable backend locator. Stop the Gateway and run "openclaw doctor --fix" to migrate ownership without losing history, then restart.`, { detailCode: "SESSION_OWNER_MIGRATION_REQUIRED" });
-}
-function assertAcpxSessionOwnerLocator(target, legacyBareSessionKeys) {
-	const resource = resolveAcpxSessionResource(target);
-	const qualified = resource === target.sessionKey.trim().toLowerCase();
-	const persisted = target.persistedHandle;
-	if (!qualified && (legacyBareSessionKeys?.has(target.sessionKey.trim().toLowerCase()) || legacyBareSessionKeys?.has(resource) && !persisted)) requireAcpxOwnerMigration(target.sessionKey);
-	if (persisted) {
-		const decoded = decodeAcpxRuntimeHandleState$1(persisted.runtimeSessionName);
-		if (!qualified && !decoded || decoded && (decoded.name !== resource || persisted.acpxRecordId && decoded.acpxRecordId !== persisted.acpxRecordId)) requireAcpxOwnerMigration(target.sessionKey);
-	}
-	return resource;
-}
-/** Preserve physical oneshot record IDs and the upstream-encoded runtime handle. */
-function toAcpxResourceInput(input) {
-	const sessionKey = assertAcpxSessionOwnerLocator({
-		...input.handle,
-		persistedHandle: input.handle
-	});
-	return {
-		...input,
-		handle: {
-			...input.handle,
-			sessionKey
-		}
-	};
-}
-//#endregion
-//#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 withOpenClawLeaseSessionMetadata(record, lease) {
-	return {
-		...record,
-		openclawLeaseId: lease.leaseId,
-		openclawGatewayInstanceId: lease.gatewayInstanceId
-	};
-}
-const CODEX_WRAPPER_STDERR_LOG_PREFIX = "codex-acp-wrapper.stderr";
-function safeDiagnosticFilePart(value) {
-	return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown";
-}
-function codexWrapperStderrLogFileName(leaseId) {
-	return `${CODEX_WRAPPER_STDERR_LOG_PREFIX}.${safeDiagnosticFilePart(leaseId)}.log`;
-}
-function compactDiagnosticText(value) {
-	return value.replace(/\s+/g, " ").trim();
-}
-function isGenericInternalAcpErrorMessage(message) {
-	return message.trim() === "Internal error";
-}
-function isGenericInternalAcpError(error) {
-	return error instanceof Error && isGenericInternalAcpErrorMessage(error.message);
-}
-async function readCodexWrapperStderrTail(params) {
-	if (!params.wrapperRoot || !params.leaseId) return "";
-	try {
-		const text = await fs.readFile(path.join(params.wrapperRoot, codexWrapperStderrLogFileName(params.leaseId)), "utf8");
-		return compactDiagnosticText(redactSensitiveText(sliceUtf16Safe(text, -6e3)));
-	} catch {
-		return "";
-	}
-}
-function readSessionRecordName(record) {
-	if (typeof record !== "object" || record === null) return "";
-	const { name } = record;
-	return typeof name === "string" ? name.trim() : "";
-}
-function readRecordAgentCommand(record) {
-	return record?.agentArgv ?? record?.agentCommand;
-}
-function readRecordCwd(record) {
-	if (typeof record !== "object" || record === null) return;
-	const { cwd } = record;
-	return typeof cwd === "string" ? cwd.trim() || void 0 : void 0;
-}
-function readRecordResetOnNextEnsure(record) {
-	if (typeof record !== "object" || record === null) return false;
-	const { acpx } = record;
-	if (typeof acpx !== "object" || acpx === null) return false;
-	return acpx.reset_on_next_ensure === true;
-}
-function readRecordAgentPid(record) {
-	if (typeof record !== "object" || record === null) return;
-	const { pid, processId } = record;
-	const rawPid = pid ?? processId;
-	const numericPid = typeof rawPid === "number" ? rawPid : typeof rawPid === "string" ? parseStrictPositiveInteger(rawPid) : void 0;
-	return numericPid && Number.isInteger(numericPid) && numericPid > 0 ? numericPid : void 0;
-}
-function readOpenClawLeaseIdFromRecord(record) {
-	if (typeof record !== "object" || record === null) return;
-	const { openclawLeaseId } = record;
-	return typeof openclawLeaseId === "string" ? openclawLeaseId.trim() || void 0 : void 0;
-}
-function readOpenClawGatewayInstanceIdFromRecord(record) {
-	if (typeof record !== "object" || record === null) return;
-	const { openclawGatewayInstanceId } = record;
-	return typeof openclawGatewayInstanceId === "string" ? openclawGatewayInstanceId.trim() || void 0 : void 0;
-}
-function extractGeneratedWrapperPath(command) {
-	return splitCommandParts(command ?? "").find((part) => basename(part) === "codex-acp-wrapper.mjs" || basename(part) === "claude-agent-acp-wrapper.mjs") ?? "";
-}
-function selectCurrentSessionLease(params) {
-	const sessionKeys = new Set(normalizeStringEntries(params.sessionKeys));
-	const candidates = params.leases.filter((lease) => sessionKeys.has(lease.sessionKey));
-	if (params.rootPid) return candidates.find((lease) => lease.rootPid === params.rootPid);
-	let selected;
-	for (const lease of candidates) if (!selected || lease.startedAt > selected.startedAt) selected = lease;
-	return selected;
-}
-function createResetAwareSessionStore(baseStore, params) {
-	const freshSessionKeys = /* @__PURE__ */ new Set();
-	return {
-		async load(sessionId) {
-			const normalized = sessionId.trim();
-			if (normalized && freshSessionKeys.has(normalized)) return;
-			const record = await baseStore.load(sessionId);
-			if (!record || !params?.leaseStore || !params.gatewayInstanceId) return record;
-			const sessionName = readSessionRecordName(record) || normalized;
-			const lease = selectCurrentSessionLease({
-				leases: await params.leaseStore.listOpen(params.gatewayInstanceId),
-				sessionKeys: [sessionName, normalized],
-				rootPid: readRecordAgentPid(record)
-			});
-			if (!lease) return record;
-			return withOpenClawLeaseSessionMetadata(record, lease);
-		},
-		async save(record) {
-			let recordToSave = record;
-			const launch = params?.launchScope?.getStore();
-			const sessionName = readSessionRecordName(record);
-			const agentCommand = readRecordAgentCommand(record);
-			const leasedCommand = launch?.leasedCommand ?? agentCommand;
-			const leaseIdentity = launch ?? readAcpxProcessLeaseIdentity(leasedCommand);
-			if (params?.leaseStore && params.gatewayInstanceId && params.wrapperRoot && (!launch || sessionName === launch.sessionKey) && leasedCommand && leaseIdentity?.gatewayInstanceId === params.gatewayInstanceId && isOpenClawLeaseAwareAcpxProcessCommand({
-				command: leasedCommand,
-				wrapperRoot: params.wrapperRoot
-			})) {
-				const existing = await params.leaseStore.load(leaseIdentity.leaseId);
-				if (!existing || existing.gatewayInstanceId === leaseIdentity.gatewayInstanceId && existing.sessionKey === sessionName && existing.wrapperRoot === params.wrapperRoot) {
-					const adoptingLease = Boolean(launch && !isDeepStrictEqual(splitCommandParts(launch.resolvedCommand), splitCommandParts(launch.leasedCommand)));
-					const persistedCommand = launch && !adoptingLease ? launch.resolvedCommand : leasedCommand;
-					const lifecycleRecord = adoptingLease ? {
-						...record,
-						pid: void 0,
-						processId: void 0,
-						agentStartedAt: void 0
-					} : record;
-					const rootPid = readRecordAgentPid(lifecycleRecord);
-					if (rootPid) await params.leaseStore.save({
-						leaseId: leaseIdentity.leaseId,
-						gatewayInstanceId: leaseIdentity.gatewayInstanceId,
-						sessionKey: sessionName,
-						wrapperRoot: params.wrapperRoot,
-						wrapperPath: extractGeneratedWrapperPath(leasedCommand),
-						rootPid,
-						...existing?.rootPid === rootPid && existing.processGroupId ? { processGroupId: existing.processGroupId } : {},
-						commandHash: hashAcpxProcessCommand(persistedCommand),
-						startedAt: existing?.rootPid === rootPid ? existing.startedAt : Date.now(),
-						state: "open"
-					});
-					recordToSave = withOpenClawLeaseSessionMetadata({
-						...lifecycleRecord,
-						agentCommand: renderAgentCommand(persistedCommand),
-						agentArgv: Array.isArray(persistedCommand) ? persistedCommand : void 0
-					}, leaseIdentity);
-				}
-			}
-			await baseStore.save(recordToSave);
-			if (sessionName) freshSessionKeys.delete(sessionName);
-		},
-		markFresh(sessionKey) {
-			const normalized = sessionKey.trim();
-			if (normalized) freshSessionKeys.add(normalized);
-		}
-	};
-}
-const OPENCLAW_BRIDGE_EXECUTABLE = "openclaw";
-const OPENCLAW_BRIDGE_SUBCOMMAND = "acp";
-const CODEX_ACP_AGENT_ID = "codex";
-const CODEX_ACP_OPENCLAW_PREFIX = "openai/";
-const CLAUDE_ACP_OPENCLAW_PREFIX = /^(?:anthropic|amazon-bedrock)\//i;
-const CODEX_ACP_THINKING_ALIASES = /* @__PURE__ */ new Map([
-	["off", void 0],
-	["minimal", "low"],
-	["low", "low"],
-	["medium", "medium"],
-	["high", "high"],
-	["x-high", "xhigh"],
-	["x_high", "xhigh"],
-	["extra-high", "xhigh"],
-	["extra_high", "xhigh"],
-	["extra high", "xhigh"],
-	["xhigh", "xhigh"]
-]);
-function normalizeAgentName(value) {
-	const normalized = value?.trim().toLowerCase();
-	return normalized ? normalized : void 0;
-}
-function readAgentFromSessionKey(sessionKey) {
-	const normalized = sessionKey?.trim();
-	if (!normalized) return;
-	return normalizeAgentName(/^agent:(?<agent>[^:]+):/i.exec(normalized)?.groups?.agent);
-}
-function readAgentFromHandle(handle) {
-	return normalizeAgentName(decodeAcpxRuntimeHandleState(handle.runtimeSessionName)?.agent) ?? readAgentFromSessionKey(handle.sessionKey);
-}
-function basename(value) {
-	return value.split(/[\\/]/).pop() ?? value;
-}
-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;
-	let index = 1;
-	while (true) {
-		const part = parts.at(index);
-		if (!part || !isEnvAssignment(part)) break;
-		index += 1;
-	}
-	return parts.slice(index);
-}
-function matchesExecutableName(value, executableName) {
-	const normalized = basename(value).toLowerCase();
-	return normalized === executableName || normalized === `${executableName}.exe`;
-}
-function matchesPackageSpec(value, packageName) {
-	const normalized = value.trim().toLowerCase();
-	return normalized === packageName || normalized.startsWith(`${packageName}@`);
-}
-function stripModuleExtension(value) {
-	return value.replace(/\.[cm]?js$/i, "").toLowerCase();
-}
-function isAcpCommand(command, params) {
-	if (!command) return false;
-	const parts = unwrapEnvCommand(splitCommandParts(command));
-	if (!parts.length) return false;
-	if (parts.some((part) => matchesPackageSpec(part, params.packageName))) return true;
-	const commandName = basename(parts[0] ?? "");
-	if (matchesExecutableName(commandName, params.executableName)) return true;
-	if (!matchesExecutableName(commandName, "node")) return false;
-	const scriptName = stripModuleExtension(basename(parts[1] ?? ""));
-	return scriptName === params.executableName || scriptName === `${params.executableName}-wrapper`;
-}
-function isOpenClawBridgeCommand(command) {
-	if (!command) return false;
-	const parts = unwrapEnvCommand(splitCommandParts(command));
-	if (basename(parts[0] ?? "") === OPENCLAW_BRIDGE_EXECUTABLE) return parts[1] === OPENCLAW_BRIDGE_SUBCOMMAND;
-	if (basename(parts[0] ?? "") !== "node") return false;
-	const scriptName = basename(parts[1] ?? "");
-	return /^openclaw(?:\.[cm]?js)?$/i.test(scriptName) && parts[2] === OPENCLAW_BRIDGE_SUBCOMMAND;
-}
-function isCodexAcpCommand(command) {
-	return isAcpCommand(command, {
-		packageName: CODEX_ACP_PACKAGE,
-		executableName: "codex-acp"
-	});
-}
-function isClaudeAcpCommand(command) {
-	return isAcpCommand(command, {
-		packageName: "@agentclientprotocol/claude-agent-acp",
-		executableName: "claude-agent-acp"
-	});
-}
-function failUnsupportedCodexAcpModel(rawModel) {
-	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", `Codex ACP model "${rawModel}" is not supported. Use openai/<model> or <model>/<reasoning-effort>.`);
-}
-const WIRE_TIMEOUT_CONFIG_KEYS = /* @__PURE__ */ new Set(["timeout", "timeout_seconds"]);
-function assertSupportedRuntimeSessionMode(mode) {
-	if (mode === "persistent" || mode === "oneshot") return;
-	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", `Unsupported ACP runtime session mode ${JSON.stringify(mode)}. Expected one of: persistent, oneshot.`);
-}
-function failUnsupportedCodexAcpThinking(rawThinking) {
-	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", `Codex ACP thinking level "${rawThinking}" is not supported. Use off, minimal, low, medium, high, or xhigh.`);
-}
-function normalizeCodexAcpReasoningEffort(rawThinking) {
-	const normalized = rawThinking?.trim().toLowerCase();
-	if (!normalized) return;
-	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) {
-	const raw = rawModel?.trim();
-	const thinkingReasoningEffort = normalizeCodexAcpReasoningEffort(rawThinking);
-	const thinkingOnlyOverride = thinkingReasoningEffort ? { reasoningEffort: thinkingReasoningEffort } : void 0;
-	if (!raw) return {
-		kind: "override",
-		override: thinkingOnlyOverride ?? {}
-	};
-	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);
-	if (!model || model.includes("/")) return thinkingOnlyOverride ? {
-		kind: "unsupported",
-		thinkingOverride: thinkingOnlyOverride
-	} : { kind: "unsupported" };
-	const reasoningEffort = rawThinking?.trim() ? thinkingReasoningEffort : modelReasoningEffort;
-	return {
-		kind: "override",
-		override: {
-			model,
-			...reasoningEffort ? { reasoningEffort } : {}
-		}
-	};
-}
-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();
-	if (!raw) return;
-	const prefix = raw.match(CLAUDE_ACP_OPENCLAW_PREFIX);
-	if (!prefix) return raw;
-	return raw.slice(prefix[0].length).trim() || void 0;
-}
-function withAcpxSessionOptions(input) {
-	const existingOptions = input.sessionOptions;
-	const model = input.model?.trim() || existingOptions?.model;
-	const sessionOptions = model ? {
-		...existingOptions,
-		model
-	} : existingOptions;
-	const { modelExplicit: _modelExplicit, ...rest } = input;
-	return {
-		...rest,
-		...sessionOptions ? { sessionOptions } : {}
-	};
-}
-function isAcpModelCapabilityMissingError(error) {
-	return isRequestedModelUnsupportedError(error) && error.reason === "missing-capability";
-}
-async function ensureDelegateSessionWithModelFallback(delegate, input) {
-	try {
-		return await delegate.ensureSession(withAcpxSessionOptions(input));
-	} catch (error) {
-		if (input.modelExplicit || !input.model || !isAcpModelCapabilityMissingError(error)) throw error;
-		return {
-			...await delegate.ensureSession(withAcpxSessionOptions({
-				...input,
-				model: void 0
-			})),
-			appliedModel: { kind: "dropped" }
-		};
-	}
-}
-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 [
-		...splitCommandParts(command),
-		OPENCLAW_CODEX_CONFIG_ARG,
-		JSON.stringify(config)
-	];
-}
-function resolveAgentCommand(params) {
-	const normalizedAgentName = normalizeAgentName(params.agentName);
-	if (!normalizedAgentName) return;
-	return splitCommandParts(params.agentRegistry.resolve(normalizedAgentName));
-}
-function shouldUseDistinctBridgeDelegate(options) {
-	const { mcpServers } = options;
-	return Array.isArray(mcpServers) && mcpServers.length > 0;
-}
-function withManagedToolsMcpSessionEnv(params) {
-	const sessionKey = params.sessionKey.trim();
-	if (!params.pluginToolsEnabled && !params.openclawToolsEnabled || !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;
-		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,
-			value: sessionKey
-		}];
-		return {
-			...server,
-			env,
-			args: params.agentId ? [
-				...server.args,
-				"--openclaw-agent-id",
-				params.agentId
-			] : server.args
-		};
-	});
-	return changed ? nextServers : params.mcpServers;
-}
-/** OpenClaw-managed ACP runtime implementation backed by the upstream acpx runtime. */
-var AcpxRuntime = class {
-	constructor(options, testOptions) {
-		this.ownerAwareSessions = 1;
-		this.launchCommandScope = new AsyncLocalStorage();
-		this.managedToolsSessionDelegates = /* @__PURE__ */ new Map();
-		this.launchLeaseScope = new AsyncLocalStorage();
-		this.sessionEnsureQueue = new KeyedAsyncQueue();
-		this.processLeaseTransitionQueue = new KeyedAsyncQueue();
-		this.processLeaseOperationCounts = /* @__PURE__ */ new Map();
-		this.uncertainProcessLeaseIds = /* @__PURE__ */ new Set();
-		this.legacyBareSessionKeys = new Set(options.openclawLegacyBareSessionKeys);
-		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,
-			leaseStore: this.processLeaseStore,
-			launchScope: this.launchLeaseScope,
-			wrapperRoot: this.wrapperRoot
-		});
-		this.agentRegistry = options.agentRegistry;
-		this.scopedAgentRegistry = {
-			resolve: (agentName) => {
-				const launch = this.launchCommandScope.getStore();
-				return launch && launch.agent === normalizeAgentName(agentName) && launch.command ? launch.command : this.agentRegistry.resolve(agentName);
-			},
-			list: () => this.agentRegistry.list()
-		};
-		const sharedOptions = {
-			...options,
-			sessionStore: this.sessionStore,
-			agentRegistry: this.scopedAgentRegistry
-		};
-		this.delegateOptions = sharedOptions;
-		this.delegateTestOptions = delegateTestOptions;
-		this.delegate = new AcpxRuntime$1(sharedOptions, this.delegateTestOptions);
-		this.bridgeSafeDelegate = shouldUseDistinctBridgeDelegate(options) ? new AcpxRuntime$1({
-			...sharedOptions,
-			mcpServers: []
-		}, this.delegateTestOptions) : this.delegate;
-		this.probeAgent = normalizeAgentName(options.probeAgent) ?? "codex";
-		const probeCommand = resolveAgentCommand({
-			agentName: this.probeAgent,
-			agentRegistry: this.agentRegistry
-		});
-		this.probeCommand = probeCommand;
-		const useBridgeSafeProbe = this.managedToolsMcpBridgeEnabled || isOpenClawBridgeCommand(probeCommand);
-		this.probeDelegate = useBridgeSafeProbe ? this.bridgeSafeDelegate : this.delegate;
-	}
-	resolveDelegateForSession(params) {
-		if (isOpenClawBridgeCommand(params.command)) return this.bridgeSafeDelegate;
-		return this.resolveManagedToolsDelegateForSession(params);
-	}
-	resolveManagedToolsDelegateForSession(target) {
-		if (!this.managedToolsMcpBridgeEnabled) return this.delegate;
-		const normalizedSessionKey = resolveAcpxSessionResource(target);
-		const cached = this.managedToolsSessionDelegates.get(normalizedSessionKey);
-		if (cached) return cached;
-		const delegate = new AcpxRuntime$1({
-			...this.delegateOptions,
-			mcpServers: withManagedToolsMcpSessionEnv({
-				pluginToolsEnabled: this.pluginToolsMcpBridgeEnabled,
-				openclawToolsEnabled: this.openclawToolsMcpBridgeEnabled,
-				mcpServers: this.delegateOptions.mcpServers,
-				sessionKey: target.sessionKey,
-				agentId: target.agentId
-			})
-		}, this.delegateTestOptions);
-		this.managedToolsSessionDelegates.set(normalizedSessionKey, delegate);
-		return delegate;
-	}
-	async loadOperationSnapshotForHandle(handle) {
-		assertAcpxSessionOwnerLocator({
-			...handle,
-			persistedHandle: handle
-		}, this.legacyBareSessionKeys);
-		const record = await this.sessionStore.load(handle.acpxRecordId ?? resolveAcpxSessionResource(handle));
-		return {
-			record,
-			command: readRecordAgentCommand(record) ?? resolveAgentCommand({
-				agentName: readAgentFromHandle(handle),
-				agentRegistry: this.agentRegistry
-			})
-		};
-	}
-	resolveDelegateForOperationSnapshot(handle, snapshot) {
-		return this.resolveDelegateForSession({
-			command: snapshot.command,
-			sessionKey: handle.sessionKey,
-			agentId: handle.agentId
-		});
-	}
-	async readReusablePersistentSessionCommand(params) {
-		if (params.mode !== "persistent" || !params.command) return;
-		const existing = await this.sessionStore.load(params.sessionKey);
-		if (!existing || readRecordResetOnNextEnsure(existing)) return;
-		const recordCwd = readRecordCwd(existing);
-		if (!recordCwd || resolve(recordCwd) !== resolve(params.cwd?.trim() || this.cwd)) return;
-		const recordCommand = readRecordAgentCommand(existing);
-		if (!recordCommand) return;
-		const leaseIdentity = readAcpxProcessLeaseIdentity(recordCommand);
-		if (leaseIdentity && leaseIdentity.gatewayInstanceId !== this.gatewayInstanceId) return;
-		const stableRecordCommand = leaseIdentity ? withAcpxLeaseArgs({
-			command: params.command,
-			leaseId: leaseIdentity.leaseId,
-			gatewayInstanceId: leaseIdentity.gatewayInstanceId
-		}) : params.command;
-		if (!isDeepStrictEqual(splitCommandParts(recordCommand), splitCommandParts(stableRecordCommand))) return;
-		return !params.resumeSessionId || existing.acpSessionId === params.resumeSessionId ? recordCommand : void 0;
-	}
-	async runWithLaunchLease(params) {
-		if (!params.command || !this.wrapperRoot || !this.gatewayInstanceId || !this.processLeaseStore || !isOpenClawLeaseAwareAcpxProcessCommand({
-			command: params.command,
-			wrapperRoot: this.wrapperRoot
-		})) return await this.launchCommandScope.run({
-			agent: normalizeAgentName(params.agent) ?? params.agent,
-			command: params.reusableCommand ?? params.command
-		}, params.run);
-		const processLeaseStore = this.processLeaseStore;
-		const reusableIdentity = readAcpxProcessLeaseIdentity(params.reusableCommand);
-		const canReuseLeaseIdentity = reusableIdentity?.gatewayInstanceId === this.gatewayInstanceId;
-		const leaseId = canReuseLeaseIdentity ? reusableIdentity.leaseId : params.finalizeCompletedProbe ? `probe-${hashAcpxProcessCommand(`${this.gatewayInstanceId}\0${extractGeneratedWrapperPath(params.command)}`)}` : randomUUID();
-		const leasedCommand = withAcpxLeaseArgs({
-			command: params.command,
-			leaseId,
-			gatewayInstanceId: this.gatewayInstanceId
-		});
-		const launch = {
-			leaseId,
-			gatewayInstanceId: this.gatewayInstanceId,
-			sessionKey: params.sessionKey,
-			wrapperRoot: this.wrapperRoot,
-			resolvedCommand: params.reusableCommand ?? leasedCommand,
-			leasedCommand
-		};
-		await this.retainProcessLeaseOperation(launch, async () => {
-			const reusableLease = canReuseLeaseIdentity ? await processLeaseStore.load(launch.leaseId) : void 0;
-			if (reusableLease && (reusableLease.gatewayInstanceId !== launch.gatewayInstanceId || reusableLease.sessionKey !== launch.sessionKey || reusableLease.wrapperRoot !== launch.wrapperRoot)) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", `ACPX process lease ${launch.leaseId} belongs to another session`);
-			if (!(!reusableLease && (!params.reusableCommand || isDeepStrictEqual(splitCommandParts(params.reusableCommand), splitCommandParts(leasedCommand))))) return;
-			await processLeaseStore.save({
-				leaseId: launch.leaseId,
-				gatewayInstanceId: launch.gatewayInstanceId,
-				sessionKey: launch.sessionKey,
-				wrapperRoot: launch.wrapperRoot,
-				wrapperPath: extractGeneratedWrapperPath(leasedCommand),
-				rootPid: 0,
-				commandHash: hashAcpxProcessCommand(leasedCommand),
-				startedAt: Date.now(),
-				state: "open"
-			});
-		});
-		try {
-			const result = await this.launchLeaseScope.run(launch, () => this.launchCommandScope.run({
-				agent: normalizeAgentName(params.agent) ?? params.agent,
-				command: launch.resolvedCommand
-			}, params.run));
-			if (params.finalizeCompletedProbe) await this.finalizeCompletedProbeLease(launch);
-			else await this.finalizeProcessLeaseForSession(params.sessionKey, launch);
-			return result;
-		} catch (error) {
-			await this.releaseProcessLeaseAfterUncertainFailure(launch);
-			throw error;
-		}
-	}
-	async prepareProcessLeaseForOperation(handle, record) {
-		if (!this.processLeaseStore || !this.gatewayInstanceId || !this.wrapperRoot) return;
-		const processLeaseStore = this.processLeaseStore;
-		const wrapperRoot = this.wrapperRoot;
-		const recordPid = readRecordAgentPid(record);
-		const command = readRecordAgentCommand(record);
-		const identity = readAcpxProcessLeaseIdentity(command);
-		if (!command || !isOpenClawLeaseAwareAcpxProcessCommand({
-			command,
-			wrapperRoot
-		})) return;
-		if (!identity) return;
-		if (identity.gatewayInstanceId !== this.gatewayInstanceId) throw new AcpRuntimeError("ACP_TURN_FAILED", `ACPX process lease ${identity.leaseId} belongs to another gateway`);
-		await this.retainProcessLeaseOperation(identity, async () => {
-			const existing = await processLeaseStore.load(identity.leaseId);
-			if (!existing) {
-				await processLeaseStore.save({
-					leaseId: identity.leaseId,
-					gatewayInstanceId: identity.gatewayInstanceId,
-					sessionKey: resolveAcpxSessionResource(handle),
-					wrapperRoot,
-					wrapperPath: extractGeneratedWrapperPath(command),
-					rootPid: recordPid ?? 0,
-					commandHash: hashAcpxProcessCommand(command),
-					startedAt: Date.now(),
-					state: "open"
-				});
-				return;
-			}
-			if (existing.gatewayInstanceId !== identity.gatewayInstanceId || existing.sessionKey !== resolveAcpxSessionResource(handle) || existing.wrapperRoot !== wrapperRoot) throw new AcpRuntimeError("ACP_TURN_FAILED", `ACPX process lease ${identity.leaseId} belongs to another session`);
-		});
-		return identity;
-	}
-	async retainProcessLeaseOperation(identity, prepare) {
-		await this.processLeaseTransitionQueue.enqueue(identity.leaseId, async () => {
-			await prepare();
-			this.processLeaseOperationCounts.set(identity.leaseId, (this.processLeaseOperationCounts.get(identity.leaseId) ?? 0) + 1);
-		});
-	}
-	async releaseProcessLeaseOperation(identity, finalize) {
-		if (!identity) return;
-		await this.processLeaseTransitionQueue.enqueue(identity.leaseId, async () => {
-			const count = this.processLeaseOperationCounts.get(identity.leaseId) ?? 0;
-			if (count > 1) {
-				this.processLeaseOperationCounts.set(identity.leaseId, count - 1);
-				return;
-			}
-			if (count === 0) return;
-			this.processLeaseOperationCounts.delete(identity.leaseId);
-			await finalize();
-		});
-	}
-	async finalizeProcessLeaseForOperation(handle, identity) {
-		await this.finalizeProcessLeaseForSession(handle.acpxRecordId ?? resolveAcpxSessionResource(handle), identity);
-	}
-	async finalizeProcessLeaseForSession(sessionId, identity) {
-		if (!identity || !this.processLeaseStore) return;
-		const processLeaseStore = this.processLeaseStore;
-		await this.releaseProcessLeaseOperation(identity, async () => {
-			const lease = await processLeaseStore.load(identity.leaseId);
-			if (!lease || lease.gatewayInstanceId !== identity.gatewayInstanceId) return;
-			if (lease.rootPid <= 0) {
-				if (this.uncertainProcessLeaseIds.has(identity.leaseId)) return;
-				await processLeaseStore.markState(identity.leaseId, "lost");
-				return;
-			}
-			this.uncertainProcessLeaseIds.delete(identity.leaseId);
-			try {
-				const record = await this.sessionStore.load(sessionId);
-				const recordIdentity = readAcpxProcessLeaseIdentity(readRecordAgentCommand(record));
-				if (recordIdentity?.leaseId !== identity.leaseId || recordIdentity.gatewayInstanceId !== identity.gatewayInstanceId) await processLeaseStore.markState(identity.leaseId, "lost");
-			} catch {}
-		});
-	}
-	async finalizeCompletedProbeLease(identity) {
-		if (!this.processLeaseStore) return;
-		const processLeaseStore = this.processLeaseStore;
-		await this.releaseProcessLeaseOperation(identity, async () => {
-			const lease = await processLeaseStore.load(identity.leaseId);
-			if (!lease || lease.gatewayInstanceId !== identity.gatewayInstanceId) return;
-			if (lease.rootPid > 0) return;
-			await cleanupOpenClawOwnedAcpxPendingLease({
-				leaseId: lease.leaseId,
-				gatewayInstanceId: lease.gatewayInstanceId,
-				wrapperRoot: lease.wrapperRoot,
-				wrapperPath: lease.wrapperPath,
-				deps: this.processCleanupDeps
-			});
-		});
-	}
-	async releaseProcessLeaseAfterUncertainFailure(identity) {
-		if (!identity || !this.processLeaseStore) return;
-		this.uncertainProcessLeaseIds.add(identity.leaseId);
-		const processLeaseStore = this.processLeaseStore;
-		await this.releaseProcessLeaseOperation(identity, async () => {
-			const lease = await processLeaseStore.load(identity.leaseId);
-			if (!lease || lease.gatewayInstanceId !== identity.gatewayInstanceId || lease.rootPid > 0) this.uncertainProcessLeaseIds.delete(identity.leaseId);
-		});
-	}
-	async runWithProcessLeaseForHandle(handle, record, run) {
-		const identity = await this.prepareProcessLeaseForOperation(handle, record);
-		try {
-			return await run();
-		} finally {
-			await this.finalizeProcessLeaseForOperation(handle, identity);
-		}
-	}
-	async finalizeProcessLeaseAfter(handle, identityPromise, resultPromise) {
-		try {
-			return await resultPromise;
-		} finally {
-			await this.finalizeProcessLeaseForOperation(handle, await identityPromise);
-		}
-	}
-	async withCodexWrapperDiagnostics(params) {
-		try {
-			return await params.run();
-		} catch (error) {
-			if (!isCodexAcpCommand(params.command) || !isGenericInternalAcpError(error)) throw error;
-			const stderrTail = params.handle ? await this.readCodexTurnFailureStderr({ handle: params.handle }) : await readCodexWrapperStderrTail({
-				wrapperRoot: this.wrapperRoot,
-				leaseId: this.launchLeaseScope.getStore()?.leaseId
-			});
-			if (!stderrTail) throw error;
-			throw new AcpRuntimeError(params.fallbackCode, `Internal error: ${stderrTail}`, { cause: error });
-		}
-	}
-	async readCodexTurnFailureStderr(params) {
-		const record = await this.sessionStore.load(params.handle.acpxRecordId ?? resolveAcpxSessionResource(params.handle));
-		return readCodexWrapperStderrTail({
-			wrapperRoot: this.wrapperRoot,
-			leaseId: readOpenClawLeaseIdFromRecord(record)
-		});
-	}
-	async cleanupProcessTreeForRecord(handle, record) {
-		const leaseId = readOpenClawLeaseIdFromRecord(record);
-		const rootPid = readRecordAgentPid(record);
-		const sessionKeys = [resolveAcpxSessionResource(handle), readSessionRecordName(record)];
-		const selectedLease = selectCurrentSessionLease({
-			leases: this.gatewayInstanceId && this.processLeaseStore ? await this.processLeaseStore.listOpen(this.gatewayInstanceId) : [],
-			sessionKeys,
-			rootPid
-		});
-		const loadedLease = leaseId ? await this.processLeaseStore?.load(leaseId) : void 0;
-		const lease = selectedLease ?? (loadedLease && loadedLease.gatewayInstanceId === this.gatewayInstanceId && (!rootPid || loadedLease.rootPid === rootPid) && sessionKeys.includes(loadedLease.sessionKey) ? loadedLease : void 0);
-		if (lease && lease.gatewayInstanceId === this.gatewayInstanceId && lease.rootPid > 0) {
-			await this.processLeaseStore?.markState(lease.leaseId, "closing");
-			const result = await cleanupOpenClawOwnedAcpxProcessTree({
-				rootPid: lease.rootPid,
-				rootCommand: record?.agentCommand,
-				expectedLeaseId: lease.leaseId,
-				expectedGatewayInstanceId: lease.gatewayInstanceId,
-				wrapperRoot: lease.wrapperRoot,
-				deps: this.processCleanupDeps
-			});
-			await this.processLeaseStore?.markState(lease.leaseId, result.skippedReason === "process-list-unavailable" || result.skippedReason === "unsupported-platform" ? "open" : result.terminatedPids.length > 0 || result.skippedReason === "missing-root" ? "closed" : "lost");
-			return;
-		}
-		const rootCommand = readRecordAgentCommand(record) ?? resolveAgentCommand({
-			agentName: readAgentFromHandle(handle),
-			agentRegistry: this.agentRegistry
-		});
-		if (!rootPid || !rootCommand) return;
-		const expectedGatewayInstanceId = readOpenClawGatewayInstanceIdFromRecord(record);
-		await cleanupOpenClawOwnedAcpxProcessTree({
-			rootPid,
-			rootCommand: renderAgentCommand(rootCommand),
-			...leaseId ? { expectedLeaseId: leaseId } : {},
-			...expectedGatewayInstanceId ? { expectedGatewayInstanceId } : {},
-			wrapperRoot: this.wrapperRoot,
-			deps: this.processCleanupDeps
-		});
-	}
-	isHealthy() {
-		return this.probeDelegate.isHealthy();
-	}
-	async probeAvailability() {
-		await this.runWithLaunchLease({
-			agent: this.probeAgent,
-			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
-			command: this.probeCommand,
-			finalizeCompletedProbe: true,
-			run: () => this.probeDelegate.probeAvailability()
-		});
-	}
-	async doctor() {
-		return await this.runWithLaunchLease({
-			agent: this.probeAgent,
-			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
-			command: this.probeCommand,
-			finalizeCompletedProbe: true,
-			run: () => this.probeDelegate.doctor()
-		});
-	}
-	async ensureSession(input) {
-		const resource = assertAcpxSessionOwnerLocator(input, this.legacyBareSessionKeys);
-		return await this.sessionEnsureQueue.enqueue(resource.trim() || resource, () => this.ensureSessionUnlocked(input));
-	}
-	async ensureSessionUnlocked(logicalInput) {
-		assertSupportedRuntimeSessionMode(logicalInput.mode);
-		const command = resolveAgentCommand({
-			agentName: logicalInput.agent,
-			agentRegistry: this.agentRegistry
-		});
-		const delegate = this.resolveDelegateForSession({
-			command,
-			sessionKey: logicalInput.sessionKey,
-			agentId: logicalInput.agentId
-		});
-		const logicalTarget = {
-			sessionKey: logicalInput.sessionKey,
-			agentId: logicalInput.agentId
-		};
-		const input = {
-			...logicalInput,
-			sessionKey: resolveAcpxSessionResource(logicalInput)
-		};
-		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 ? {
-			...input,
-			model: claudeModelOverride
-		} : input;
-		const stableLaunchCommand = codexModelOverride && command ? appendCodexAcpConfigOverrides(command, codexModelOverride) : command;
-		const reusableCommand = await this.readReusablePersistentSessionCommand({
-			sessionKey: input.sessionKey,
-			mode: input.mode,
-			cwd: input.cwd,
-			command: stableLaunchCommand,
-			resumeSessionId: input.resumeSessionId
-		});
-		return {
-			...await this.runWithLaunchLease({
-				agent: ensureInput.agent,
-				sessionKey: ensureInput.sessionKey,
-				command: stableLaunchCommand,
-				reusableCommand,
-				run: () => this.withCodexWrapperDiagnostics({
-					command: stableLaunchCommand,
-					fallbackCode: "ACP_SESSION_INIT_FAILED",
-					run: () => codexModelOverride ? delegate.ensureSession(withAcpxSessionOptions(ensureInput)) : ensureDelegateSessionWithModelFallback(delegate, ensureInput)
-				})
-			}),
-			...logicalTarget,
-			...appliedModel ? { appliedModel } : {}
-		};
-	}
-	async *runTurn(input) {
-		const turn = this.startTurn(input);
-		turn.result.catch(() => {});
-		let completed = false;
-		try {
-			yield* turn.events;
-			const result = await turn.result;
-			completed = true;
-			yield result.status === "failed" ? {
-				type: "error",
-				...result.error
-			} : {
-				type: "done",
-				...result.stopReason ? { stopReason: result.stopReason } : {}
-			};
-		} finally {
-			if (!completed) {
-				await turn.cancel({ reason: "stream-closed" }).catch(() => {});
-				await turn.closeStream({ reason: "stream-closed" }).catch(() => {});
-				await turn.result.catch(() => {});
-			}
-		}
-	}
-	startTurn(input) {
-		const withTurnDiagnostics = (command, run) => this.withCodexWrapperDiagnostics({
-			command,
-			handle: input.handle,
-			fallbackCode: "ACP_TURN_FAILED",
-			run
-		});
-		const snapshotPromise = this.loadOperationSnapshotForHandle(input.handle);
-		const turnLeasePromise = snapshotPromise.then(({ record }) => this.prepareProcessLeaseForOperation(input.handle, record));
-		const turnPromise = Promise.all([snapshotPromise, turnLeasePromise]).then(([snapshot]) => {
-			const { command } = snapshot;
-			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
-			return withTurnDiagnostics(command, async () => ({
-				command,
-				turn: delegate.startTurn({
-					...toAcpxResourceInput(input),
-					timeoutMs: 0
-				})
-			}));
-		});
-		return {
-			requestId: input.requestId,
-			get promptStarted() {
-				return turnPromise.then(({ turn }) => turn.promptStarted);
-			},
-			events: { async *[Symbol.asyncIterator]() {
-				const { command, turn } = await turnPromise;
-				try {
-					yield* turn.events;
-				} catch (error) {
-					if (!isGenericInternalAcpError(error)) throw error;
-					await withTurnDiagnostics(command, () => Promise.reject(error));
-				}
-			} },
-			result: this.finalizeProcessLeaseAfter(input.handle, turnLeasePromise, turnPromise.then(({ command, turn }) => withTurnDiagnostics(command, async () => {
-				const result = await turn.result;
-				if (result.status !== "failed" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(result.error.message)) return result;
-				const stderrTail = await this.readCodexTurnFailureStderr({ handle: input.handle });
-				if (!stderrTail) return result;
-				return {
-					status: "failed",
-					error: {
-						...result.error,
-						code: "ACP_TURN_FAILED",
-						message: `Internal error: ${stderrTail}`
-					}
-				};
-			}))),
-			cancel(inputArgs) {
-				return turnPromise.then(({ turn }) => turn.cancel(inputArgs));
-			},
-			closeStream(inputArgs) {
-				return turnPromise.then(({ turn }) => turn.closeStream(inputArgs));
-			}
-		};
-	}
-	getCapabilities(input) {
-		return this.delegate.getCapabilities(input?.handle ? toAcpxResourceInput({ handle: input.handle }) : input);
-	}
-	async getStatus(input) {
-		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		return this.resolveDelegateForOperationSnapshot(input.handle, snapshot).getStatus(toAcpxResourceInput(input));
-	}
-	async setMode(input) {
-		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.resolveDelegateForOperationSnapshot(input.handle, snapshot).setMode(toAcpxResourceInput(input)));
-	}
-	async setConfigOption(input) {
-		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		return await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.setConfigOptionUnlocked(input, snapshot));
-	}
-	async setConfigOptionUnlocked(logicalInput, snapshot) {
-		const { command } = snapshot;
-		const delegate = this.resolveDelegateForOperationSnapshot(logicalInput.handle, snapshot);
-		const input = toAcpxResourceInput(logicalInput);
-		const key = input.key.trim().toLowerCase();
-		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;
-				const modelResult = override.model ? await delegate.setConfigOption({
-					...input,
-					key: "model",
-					value: override.model
-				}) : void 0;
-				if (override.reasoningEffort) return await delegate.setConfigOption({
-					...input,
-					key: "reasoning_effort",
-					value: override.reasoningEffort
-				});
-				return modelResult;
-			}
-			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) throw new AcpRuntimeError("ACP_BACKEND_UNSUPPORTED_CONTROL", "Clearing Codex reasoning effort on an existing session is unsupported. Choose a supported explicit effort; the current effort is unchanged.");
-				return await delegate.setConfigOption({
-					...input,
-					key: "reasoning_effort",
-					value: reasoningEffort
-				});
-			}
-		}
-		if (isClaudeAcpCommand(command) && key === "model") return await delegate.setConfigOption({
-			...input,
-			value: normalizeClaudeAcpModelOverride(input.value) ?? input.value
-		});
-		return await delegate.setConfigOption(input);
-	}
-	async cancel(input) {
-		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		await this.resolveDelegateForOperationSnapshot(input.handle, snapshot).cancel(toAcpxResourceInput(input));
-	}
-	async prepareFreshSession(input) {
-		const resource = assertAcpxSessionOwnerLocator(input, this.legacyBareSessionKeys);
-		this.sessionStore.markFresh(resource);
-		this.legacyBareSessionKeys.delete(resource);
-	}
-	async close(input) {
-		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		const closeLease = await this.prepareProcessLeaseForOperation(input.handle, snapshot.record);
-		let cleanupSucceeded = false;
-		try {
-			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
-			const handle = toAcpxResourceInput(input).handle;
-			try {
-				await delegate.close({
-					handle,
-					reason: input.reason,
-					discardPersistentState: input.discardPersistentState
-				});
-				if (this.managedToolsSessionDelegates.get(handle.sessionKey) === delegate) this.managedToolsSessionDelegates.delete(handle.sessionKey);
-			} finally {
-				await this.cleanupProcessTreeForRecord(input.handle, snapshot.record);
-				cleanupSucceeded = true;
-			}
-			if (input.discardPersistentState) await this.prepareFreshSession({
-				...input.handle,
-				persistedHandle: input.handle
-			});
-		} finally {
-			if (cleanupSucceeded) await this.finalizeProcessLeaseForOperation(input.handle, closeLease);
-			else await this.releaseProcessLeaseAfterUncertainFailure(closeLease);
-		}
-	}
-};
-/** Test-only hooks for ACPX runtime behavior that is otherwise private. */
-const testing = {
-	appendCodexAcpConfigOverrides,
-	isClaudeAcpCommand,
-	isCodexAcpCommand
-};
-//#endregion
-export { ACPX_BACKEND_ID, AcpxRuntime, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, testing };