@openclaw/acpx 2026.9.5 → 2026.9.6

package/dist/.setup/runtime-Du-YvDnr.mjs

@@ -1,1171 +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.mjs";
-import { AcpRuntimeError } from "../runtime-api.js";
-import { t as resolveAcpxSessionResource } from "./session-resource-Dzl0U7kK.mjs";
-import { a as CODEX_ACP_PACKAGE, i as isOpenClawLeaseAwareAcpxProcessCommand, n as cleanupOpenClawOwnedAcpxPendingLease, o as OPENCLAW_CODEX_CONFIG_ARG, r as cleanupOpenClawOwnedAcpxProcessTree } from "./service-DZYyo6-7.mjs";
-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 { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-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/runtime-generations.ts
-var AcpxGenerationRegistry = class {
-	constructor(sessionStore, delegate, createDelegate) {
-		this.sessionStore = sessionStore;
-		this.delegate = delegate;
-		this.createDelegate = createDelegate;
-		this.generations = /* @__PURE__ */ new Map();
-		this.isolatedSessionResources = /* @__PURE__ */ new Set();
-		this.resetDelegates = /* @__PURE__ */ new Set();
-		this.retiringDelegates = /* @__PURE__ */ new WeakSet();
-		this.nextGenerationId = 0;
-		this.generationOwner = Symbol("acpx-runtime-owner");
-		this.stopping = false;
-	}
-	get isStopping() {
-		return this.stopping;
-	}
-	assertRunning() {
-		if (this.stopping) throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "ACP runtime is shut down.");
-	}
-	fromCaptured(resource, captured) {
-		return captured?.owner === this.generationOwner ? captured : this.currentGeneration(resource);
-	}
-	prepareFresh(resource) {
-		const generation = this.generations.get(resource);
-		if (generation) this.retireGeneration(generation);
-		else this.sessionStore.markFresh(resource);
-	}
-	resolveDelegate(generation) {
-		this.assertRunning();
-		if (!generation.delegate) {
-			generation.delegate = generation.afterReset ? this.createDelegate() : this.delegate;
-			if (generation.delegate !== this.delegate) this.resetDelegates.add(generation.delegate);
-		}
-		return generation.delegate;
-	}
-	currentGeneration(resource) {
-		if (this.stopping) throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "ACP runtime is shut down.");
-		let generation = this.generations.get(resource);
-		if (!generation) {
-			const fresh = this.sessionStore.isFresh(resource);
-			const afterReset = fresh || this.isolatedSessionResources.has(resource);
-			if (afterReset) this.isolatedSessionResources.add(resource);
-			generation = {
-				id: ++this.nextGenerationId,
-				owner: this.generationOwner,
-				resource,
-				ensureQueue: new KeyedAsyncQueue(),
-				retired: false,
-				activeOperations: 0,
-				activeRecordOperations: /* @__PURE__ */ new Map(),
-				closedRecordIds: /* @__PURE__ */ new Set(),
-				records: /* @__PURE__ */ new Map(),
-				closeCompleted: false,
-				afterReset,
-				awaitPriorWrites: fresh
-			};
-			this.generations.set(resource, generation);
-		}
-		return generation;
-	}
-	retireGeneration(generation) {
-		generation.retired = true;
-		if (this.generations.get(generation.resource) === generation) {
-			this.generations.delete(generation.resource);
-			this.sessionStore.markFresh(generation.resource);
-		}
-		this.releaseRetiredDelegate(generation);
-	}
-	releaseRetiredDelegate(generation) {
-		const delegate = generation.delegate;
-		if (!generation.retired || generation.activeOperations !== 0 || !delegate || delegate === this.delegate || this.retiringDelegates.has(delegate)) return;
-		this.retiringDelegates.add(delegate);
-		delegate.shutdown().then(() => this.resetDelegates.delete(delegate), () => {});
-	}
-	retainGenerationOperation(generation, recordId) {
-		generation.activeOperations += 1;
-		generation.activeRecordOperations.set(recordId, (generation.activeRecordOperations.get(recordId) ?? 0) + 1);
-		return () => {
-			const remaining = (generation.activeRecordOperations.get(recordId) ?? 1) - 1;
-			if (remaining === 0) {
-				generation.activeRecordOperations.delete(recordId);
-				generation.closedRecordIds.delete(recordId);
-			} else generation.activeRecordOperations.set(recordId, remaining);
-			generation.activeOperations -= 1;
-			if (!generation.retired && generation.closeCompleted && generation.activeOperations === 0 && generation.records.size === 0 && this.generations.get(generation.resource) === generation) {
-				generation.retired = true;
-				this.generations.delete(generation.resource);
-			}
-			this.releaseRetiredDelegate(generation);
-		};
-	}
-	assertCurrentGeneration(generation) {
-		if (this.stopping || generation.retired) throw new AcpRuntimeError("ACP_TURN_FAILED", "ACP runtime operation was superseded by reset.");
-	}
-	async shutdown() {
-		this.stopping = true;
-		const errors = (await Promise.allSettled([this.delegate, ...this.resetDelegates].map((delegate) => delegate.shutdown()))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-		if (errors.length) throw new AggregateError(errors, "ACP runtime shutdown failed.");
-		this.resetDelegates.clear();
-		this.generations.clear();
-		this.isolatedSessionResources.clear();
-	}
-};
-//#endregion
-//#region extensions/acpx/src/runtime-session-store.ts
-/** Generation-bound persistence and process-lease metadata for ACPX resets. */
-function withOpenClawLeaseSessionMetadata(record, lease) {
-	return {
-		...record,
-		openclawLeaseId: lease.leaseId,
-		openclawGatewayInstanceId: lease.gatewayInstanceId
-	};
-}
-function captureGenerationRecord(generation, record) {
-	if (record.closed || generation.closedRecordIds.has(record.acpxRecordId)) generation.records.delete(record.acpxRecordId);
-	else generation.records.set(record.acpxRecordId, record);
-}
-const acpxGenerationKey = Symbol("openclaw.acpxGeneration");
-const acpxOperationScope = new AsyncLocalStorage();
-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) => (part.split(/[\\/]/).pop() ?? "") === "codex-acp-wrapper.mjs" || (part.split(/[\\/]/).pop() ?? "") === "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();
-	const stateQueue = new KeyedAsyncQueue();
-	const pendingWrites = /* @__PURE__ */ new Map();
-	return {
-		async load(sessionId) {
-			const scope = acpxOperationScope.getStore();
-			if (scope?.closeRecord && (sessionId === scope.generation.resource || sessionId === scope.closeRecord.acpxRecordId)) return scope.closeRecord;
-			const resource = scope?.generation.resource ?? sessionId.trim();
-			const pending = pendingWrites.get(sessionId.trim());
-			if (pending && (scope?.generation.awaitPriorWrites || freshSessionKeys.has(resource))) await Promise.allSettled(pending);
-			const load = async () => {
-				if (scope?.generation.retired) return;
-				const normalized = sessionId.trim();
-				if (normalized && freshSessionKeys.has(normalized)) return;
-				const record = await baseStore.load(sessionId);
-				if (scope?.generation.retired || freshSessionKeys.has(scope?.generation.resource ?? normalized)) return;
-				if (scope && record) captureGenerationRecord(scope.generation, record);
-				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;
-				if (scope?.generation.retired) return;
-				const leasedRecord = withOpenClawLeaseSessionMetadata(record, lease);
-				if (scope) captureGenerationRecord(scope.generation, leasedRecord);
-				return leasedRecord;
-			};
-			return await load();
-		},
-		async save(record) {
-			const scope = acpxOperationScope.getStore();
-			if (scope) captureGenerationRecord(scope.generation, record);
-			const resource = record.acpxRecordId;
-			const retiredCloseRecord = scope?.generation.retired && record.closed && record.acpx?.reset_on_next_ensure === true ? scope.closeRecord : void 0;
-			const writeRecord = async () => {
-				if (scope?.generation.retired) {
-					if (!retiredCloseRecord) return;
-					const persisted = await baseStore.load(record.acpxRecordId);
-					if (!persisted || persisted.acpxRecordId !== retiredCloseRecord.acpxRecordId || persisted.acpSessionId !== retiredCloseRecord.acpSessionId || persisted.createdAt !== retiredCloseRecord.createdAt) return;
-					await baseStore.save(record);
-					return;
-				}
-				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 (scope?.generation.retired) return;
-					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;
-						recordToSave = withOpenClawLeaseSessionMetadata({
-							...adoptingLease ? {
-								...record,
-								pid: void 0,
-								processId: void 0,
-								agentStartedAt: void 0
-							} : record,
-							agentCommand: renderAgentCommand(persistedCommand),
-							agentArgv: Array.isArray(persistedCommand) ? persistedCommand : void 0
-						}, leaseIdentity);
-					}
-				}
-				if (scope?.generation.retired) return;
-				await baseStore.save(recordToSave);
-				if (scope && !scope.generation.retired) scope.generation.awaitPriorWrites = false;
-				if (sessionName && !scope?.generation.retired) freshSessionKeys.delete(sessionName);
-			};
-			const writes = pendingWrites.get(resource) ?? /* @__PURE__ */ new Set();
-			const previous = [...writes];
-			const write = scope?.generation.awaitPriorWrites || retiredCloseRecord ? Promise.allSettled(previous).then(() => stateQueue.enqueue(resource, writeRecord)) : writeRecord();
-			writes.add(write);
-			pendingWrites.set(resource, writes);
-			try {
-				await write;
-			} finally {
-				writes.delete(write);
-				if (writes.size === 0 && pendingWrites.get(resource) === writes) pendingWrites.delete(resource);
-			}
-		},
-		loadForClose: (sessionKey) => baseStore.load(sessionKey),
-		isFresh: (sessionKey) => freshSessionKeys.has(sessionKey),
-		markFresh(sessionKey) {
-			const normalized = sessionKey.trim();
-			if (normalized) freshSessionKeys.add(normalized);
-		}
-	};
-}
-//#endregion
-//#region extensions/acpx/src/runtime-process-cleanup.ts
-/** Capture OpenClaw wrapper cleanup ownership before a backend close can yield. */
-async function prepareAcpxProcessCleanup(params) {
-	const { leaseStore, gatewayInstanceId, wrapperRoot, deps } = params;
-	const rootPid = readRecordAgentPid(params.record);
-	const rootCommand = params.command ? renderAgentCommand(params.command) : void 0;
-	const identity = readAcpxProcessLeaseIdentity(params.command);
-	const leaseId = readOpenClawLeaseIdFromRecord(params.record) ?? identity?.leaseId;
-	const expectedGatewayInstanceId = readOpenClawGatewayInstanceIdFromRecord(params.record) ?? identity?.gatewayInstanceId;
-	const sessionKeys = [params.sessionKey, readSessionRecordName(params.record)];
-	const openLeases = rootPid && gatewayInstanceId && leaseStore ? await leaseStore.listOpen(gatewayInstanceId) : [];
-	const selectedLease = rootPid ? selectCurrentSessionLease({
-		leases: openLeases,
-		sessionKeys,
-		rootPid
-	}) : void 0;
-	const loadedLease = leaseId ? await leaseStore?.load(leaseId) : void 0;
-	const ownedLease = selectedLease ?? (loadedLease && loadedLease.gatewayInstanceId === gatewayInstanceId && (!rootPid || loadedLease.rootPid === rootPid) && sessionKeys.includes(loadedLease.sessionKey) ? loadedLease : void 0);
-	const lease = ownedLease ? { ...ownedLease } : void 0;
-	return async () => {
-		if (lease && lease.gatewayInstanceId === gatewayInstanceId) {
-			await leaseStore?.markState(lease.leaseId, "closing");
-			const result = lease.rootPid > 0 ? await cleanupOpenClawOwnedAcpxProcessTree({
-				rootPid: lease.rootPid,
-				rootCommand,
-				expectedLeaseId: lease.leaseId,
-				expectedGatewayInstanceId: lease.gatewayInstanceId,
-				wrapperRoot: lease.wrapperRoot,
-				deps
-			}) : await cleanupOpenClawOwnedAcpxPendingLease({
-				leaseId: lease.leaseId,
-				gatewayInstanceId: lease.gatewayInstanceId,
-				wrapperRoot: lease.wrapperRoot,
-				wrapperPath: lease.wrapperPath,
-				deps
-			});
-			await leaseStore?.markState(lease.leaseId, result.skippedReason === "process-list-unavailable" || result.skippedReason === "unsupported-platform" || lease.rootPid <= 0 && (result.skippedReason === "ambiguous-root" || result.skippedReason === "unverified-root") ? "open" : result.terminatedPids.length > 0 || result.skippedReason === "missing-root" ? "closed" : "lost");
-			return;
-		}
-		if (!rootPid || !rootCommand) return;
-		await cleanupOpenClawOwnedAcpxProcessTree({
-			rootPid,
-			rootCommand,
-			...leaseId ? { expectedLeaseId: leaseId } : {},
-			...expectedGatewayInstanceId ? { expectedGatewayInstanceId } : {},
-			wrapperRoot,
-			deps
-		});
-	};
-}
-//#endregion
-//#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";
-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 "";
-	}
-}
-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, thinkingExplicit: _thinkingExplicit, ...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 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.sessionScope = new AsyncLocalStorage();
-		this.probeQueue = new KeyedAsyncQueue();
-		this.launchLeaseScope = new AsyncLocalStorage();
-		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()
-		};
-		this.createDelegate = () => new AcpxRuntime$1({
-			...options,
-			sessionStore: this.sessionStore,
-			agentRegistry: this.scopedAgentRegistry,
-			mcpServers: (context) => {
-				const servers = typeof options.mcpServers === "function" ? options.mcpServers(context) : options.mcpServers ?? [];
-				if (isOpenClawBridgeCommand(context.agentArgv ?? context.agentCommand)) return [];
-				const target = this.sessionScope.getStore();
-				if (!this.managedToolsMcpBridgeEnabled) return servers;
-				if (!target) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "ACP tool bridge has no session owner");
-				return withManagedToolsMcpSessionEnv({
-					pluginToolsEnabled: this.pluginToolsMcpBridgeEnabled,
-					openclawToolsEnabled: this.openclawToolsMcpBridgeEnabled,
-					mcpServers: servers,
-					...target
-				});
-			},
-			processLifecycle: {
-				onBeforeSpawn: async (launch) => {
-					await options.processLifecycle?.onBeforeSpawn?.(launch);
-					await this.recordProcessLaunch(launch);
-				},
-				onSpawned: async (process) => {
-					await this.recordProcessLaunch(process);
-					await options.processLifecycle?.onSpawned?.(process);
-				},
-				onSpawnFailed: options.processLifecycle?.onSpawnFailed,
-				onExit: options.processLifecycle?.onExit
-			}
-		}, delegateTestOptions);
-		this.delegate = this.createDelegate();
-		this.generationRegistry = new AcpxGenerationRegistry(this.sessionStore, this.delegate, this.createDelegate);
-		this.probeAgent = normalizeAgentName(options.probeAgent) ?? "codex";
-		const probeCommand = resolveAgentCommand({
-			agentName: this.probeAgent,
-			agentRegistry: this.agentRegistry
-		});
-		this.probeCommand = probeCommand;
-	}
-	async runInGeneration(target, scope, run) {
-		const release = this.generationRegistry.retainGenerationOperation(scope.generation, scope.recordId ?? target.acpxRecordId ?? scope.generation.resource);
-		try {
-			return await this.sessionScope.run(target, () => acpxOperationScope.run(scope, run));
-		} finally {
-			release();
-		}
-	}
-	resolveDelegateForSession(params) {
-		const generation = acpxOperationScope.getStore()?.generation ?? this.generationRegistry.currentGeneration(resolveAcpxSessionResource(params));
-		return this.generationRegistry.resolveDelegate(generation);
-	}
-	generationForHandle(handle) {
-		const resource = assertAcpxSessionOwnerLocator({
-			...handle,
-			persistedHandle: handle
-		}, this.legacyBareSessionKeys);
-		const capturedGeneration = handle[acpxGenerationKey];
-		return this.generationRegistry.fromCaptured(resource, capturedGeneration);
-	}
-	async loadOperationSnapshotForHandle(handle, allowRetired = false, generation = this.generationForHandle(handle)) {
-		const resource = generation.resource;
-		if (!allowRetired) this.generationRegistry.assertCurrentGeneration(generation);
-		const ownedRecord = generation.records.get(handle.acpxRecordId ?? resource);
-		if (ownedRecord && (handle.acpxRecordId && ownedRecord.acpxRecordId !== handle.acpxRecordId || handle.backendSessionId && ownedRecord.acpSessionId && ownedRecord.acpSessionId !== handle.backendSessionId)) throw new AcpRuntimeError("ACP_TURN_FAILED", "ACP handle no longer owns this runtime generation.");
-		let record = allowRetired ? generation.retired ? ownedRecord : await this.sessionStore.loadForClose(handle.acpxRecordId ?? resource) : await acpxOperationScope.run({ generation }, () => this.sessionStore.load(handle.acpxRecordId ?? resource));
-		if (allowRetired && generation.retired && ownedRecord) record = ownedRecord;
-		if (allowRetired && record) captureGenerationRecord(generation, record);
-		if (!allowRetired) this.generationRegistry.assertCurrentGeneration(generation);
-		if (record && (handle.acpxRecordId && handle.acpxRecordId !== record.acpxRecordId || handle.backendSessionId && record.acpSessionId && handle.backendSessionId !== record.acpSessionId)) throw new AcpRuntimeError("ACP_TURN_FAILED", "ACP handle no longer owns this runtime record.");
-		const command = readRecordAgentCommand(record) ?? resolveAgentCommand({
-			agentName: readAgentFromHandle(handle),
-			agentRegistry: this.agentRegistry
-		});
-		const identity = readAcpxProcessLeaseIdentity(command);
-		if (identity && this.processLeaseStore && this.gatewayInstanceId && this.wrapperRoot) {
-			const lease = await this.processLeaseStore.load(identity.leaseId);
-			if (identity.gatewayInstanceId !== this.gatewayInstanceId) throw new AcpRuntimeError("ACP_TURN_FAILED", `ACPX process lease ${identity.leaseId} belongs to another gateway`);
-			if (lease && (lease.gatewayInstanceId !== identity.gatewayInstanceId || lease.sessionKey !== resolveAcpxSessionResource(handle) || lease.wrapperRoot !== this.wrapperRoot)) throw new AcpRuntimeError("ACP_TURN_FAILED", `ACPX process lease ${identity.leaseId} belongs to another session`);
-		}
-		if (!allowRetired) this.generationRegistry.assertCurrentGeneration(generation);
-		return {
-			record,
-			command,
-			generation
-		};
-	}
-	resolveDelegateForOperationSnapshot(handle, snapshot) {
-		return acpxOperationScope.run({
-			generation: snapshot.generation,
-			recordId: snapshot.record?.acpxRecordId
-		}, () => 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 reusableIdentity = readAcpxProcessLeaseIdentity(params.reusableCommand);
-		const leaseId = reusableIdentity?.gatewayInstanceId === this.gatewayInstanceId ? 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
-		};
-		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 cleanupOpenClawOwnedAcpxPendingLease({
-			leaseId,
-			gatewayInstanceId: launch.gatewayInstanceId,
-			wrapperRoot: launch.wrapperRoot,
-			wrapperPath: extractGeneratedWrapperPath(leasedCommand),
-			deps: this.processCleanupDeps
-		});
-		return result;
-	}
-	async recordProcessLaunch(process) {
-		const command = [process.command, ...process.args];
-		const identity = readAcpxProcessLeaseIdentity(command);
-		if (!identity || !this.processLeaseStore || !this.wrapperRoot) return;
-		const sessionKey = process.scope.kind === "runtime-session" ? process.scope.sessionKey : ACPX_PROBE_LEASE_SESSION_KEY;
-		const existing = await this.processLeaseStore.load(identity.leaseId);
-		if (identity.gatewayInstanceId !== this.gatewayInstanceId || existing && (existing.gatewayInstanceId !== identity.gatewayInstanceId || existing.sessionKey !== sessionKey || existing.wrapperRoot !== this.wrapperRoot)) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "ACP process lease belongs to another owner");
-		if (!isOpenClawLeaseAwareAcpxProcessCommand({
-			command,
-			wrapperRoot: this.wrapperRoot
-		})) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "ACP process lease has no owned wrapper");
-		await this.processLeaseStore.save({
-			...identity,
-			sessionKey,
-			wrapperRoot: this.wrapperRoot,
-			wrapperPath: extractGeneratedWrapperPath(command),
-			rootPid: "pid" in process ? process.pid : 0,
-			commandHash: hashAcpxProcessCommand(command),
-			startedAt: "startedAt" in process ? Date.parse(process.startedAt) : Date.now(),
-			state: "open"
-		});
-	}
-	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 shutdown() {
-		await this.generationRegistry.shutdown();
-	}
-	isHealthy() {
-		return this.delegate.isHealthy();
-	}
-	async probeAvailability() {
-		await this.probeQueue.enqueue(this.probeAgent, () => this.runWithLaunchLease({
-			agent: this.probeAgent,
-			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
-			command: this.probeCommand,
-			finalizeCompletedProbe: true,
-			run: () => this.delegate.probeAvailability()
-		}));
-	}
-	async doctor() {
-		return await this.probeQueue.enqueue(this.probeAgent, () => this.runWithLaunchLease({
-			agent: this.probeAgent,
-			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
-			command: this.probeCommand,
-			finalizeCompletedProbe: true,
-			run: () => this.delegate.doctor()
-		}));
-	}
-	async ensureSession(input) {
-		const resource = assertAcpxSessionOwnerLocator(input, this.legacyBareSessionKeys);
-		const generation = this.generationRegistry.currentGeneration(resource);
-		return await generation.ensureQueue.enqueue(resource + "\0" + generation.id, () => this.runInGeneration(input, { generation }, async () => {
-			this.generationRegistry.assertCurrentGeneration(generation);
-			const handle = {
-				...await this.ensureSessionUnlocked(input),
-				[acpxGenerationKey]: generation
-			};
-			if (generation.retired && !this.generationRegistry.isStopping) await this.close({
-				handle,
-				reason: "superseded-initialization",
-				discardPersistentState: true
-			});
-			this.generationRegistry.assertCurrentGeneration(generation);
-			return handle;
-		}));
-	}
-	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 dropInheritedCodexMax = isCodexAcp && input.thinking === "max" && input.thinkingExplicit === false;
-		const effectiveInput = dropInheritedCodexMax ? { ...input } : input;
-		if (dropInheritedCodexMax) delete effectiveInput.thinking;
-		const claudeModelOverride = isClaudeAcpCommand(command) ? normalizeClaudeAcpModelOverride(input.model) : void 0;
-		const codexClassification = isCodexAcp ? classifyCodexAcpModelRequest(effectiveInput.model, effectiveInput.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 = effectiveInput.model?.trim();
-		const appliedModel = isCodexAcp && requestedModel ? codexModelOverride?.model ? {
-			kind: "applied",
-			model: requestedModel
-		} : { kind: "dropped" } : void 0;
-		const ensureInput = isCodexAcp ? withCodexSessionModel(effectiveInput, codexModelOverride) : claudeModelOverride ? {
-			...effectiveInput,
-			model: claudeModelOverride
-		} : effectiveInput;
-		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 } : {},
-			...dropInheritedCodexMax ? { appliedThinking: { kind: "dropped" } } : {}
-		};
-	}
-	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 turnPromise = this.loadOperationSnapshotForHandle(input.handle).then((snapshot) => {
-			const { command, generation } = snapshot;
-			this.generationRegistry.assertCurrentGeneration(generation);
-			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
-			return this.sessionScope.run(input.handle, () => acpxOperationScope.run({ generation }, () => withTurnDiagnostics(command, async () => {
-				const release = this.generationRegistry.retainGenerationOperation(generation, snapshot.record?.acpxRecordId ?? input.handle.acpxRecordId ?? generation.resource);
-				try {
-					const turn = delegate.startTurn({
-						...toAcpxResourceInput(input),
-						timeoutMs: 0
-					});
-					turn.result.then(release, release);
-					return {
-						command,
-						turn
-					};
-				} catch (error) {
-					release();
-					throw error;
-				}
-			})));
-		});
-		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: 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));
-			}
-		};
-	}
-	async getCapabilities(input) {
-		const capabilities = await this.delegate.getCapabilities(input?.handle ? toAcpxResourceInput({ handle: input.handle }) : input);
-		return {
-			...capabilities,
-			controls: capabilities.controls.filter((control) => control !== "session/set_model")
-		};
-	}
-	async getStatus(input) {
-		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		return this.runInGeneration(input.handle, {
-			generation: snapshot.generation,
-			recordId: snapshot.record?.acpxRecordId
-		}, () => this.resolveDelegateForOperationSnapshot(input.handle, snapshot).getStatus(toAcpxResourceInput(input)));
-	}
-	async setMode(input) {
-		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		await this.runInGeneration(input.handle, {
-			generation: snapshot.generation,
-			recordId: snapshot.record?.acpxRecordId
-		}, () => this.resolveDelegateForOperationSnapshot(input.handle, snapshot).setMode(toAcpxResourceInput(input)));
-	}
-	async setConfigOption(input) {
-		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		return await this.runInGeneration(input.handle, {
-			generation: snapshot.generation,
-			recordId: snapshot.record?.acpxRecordId
-		}, () => 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;
-				this.generationRegistry.assertCurrentGeneration(snapshot.generation);
-				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.runInGeneration(input.handle, {
-			generation: snapshot.generation,
-			recordId: snapshot.record?.acpxRecordId
-		}, () => this.resolveDelegateForOperationSnapshot(input.handle, snapshot).cancel(toAcpxResourceInput(input)));
-	}
-	async prepareFreshSession(input) {
-		const resource = assertAcpxSessionOwnerLocator(input, this.legacyBareSessionKeys);
-		this.generationRegistry.prepareFresh(resource);
-		this.legacyBareSessionKeys.delete(resource);
-	}
-	async close(input) {
-		const generation = this.generationForHandle(input.handle);
-		await this.runInGeneration(input.handle, { generation }, async () => {
-			const snapshot = await this.loadOperationSnapshotForHandle(input.handle, true, generation);
-			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
-			await acpxOperationScope.run({
-				generation,
-				closeRecord: snapshot.record
-			}, async () => {
-				if (input.discardPersistentState && decodeAcpxRuntimeHandleState(input.handle.runtimeSessionName)?.mode !== "oneshot") {
-					this.generationRegistry.retireGeneration(generation);
-					this.legacyBareSessionKeys.delete(generation.resource);
-				}
-				const cleanup = await prepareAcpxProcessCleanup({
-					record: snapshot.record,
-					command: snapshot.command,
-					sessionKey: resolveAcpxSessionResource(input.handle),
-					gatewayInstanceId: this.gatewayInstanceId,
-					wrapperRoot: this.wrapperRoot,
-					leaseStore: this.processLeaseStore,
-					deps: this.processCleanupDeps
-				}).catch((error) => async () => {
-					throw error;
-				});
-				try {
-					await delegate.close(toAcpxResourceInput(input));
-				} finally {
-					await cleanup();
-				}
-				const recordId = snapshot.record?.acpxRecordId ?? input.handle.acpxRecordId ?? generation.resource;
-				const currentRecord = generation.records.get(recordId);
-				if (!currentRecord || currentRecord.acpSessionId === snapshot.record?.acpSessionId && currentRecord.createdAt === snapshot.record?.createdAt) {
-					generation.records.delete(recordId);
-					if (generation.activeRecordOperations.has(recordId)) generation.closedRecordIds.add(recordId);
-				}
-				generation.closeCompleted = true;
-			});
-		});
-	}
-};
-/** 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 };