@openclaw/acpx 2026.5.27 → 2026.5.28-beta.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { createAcpxRuntimeService } from "./register.runtime.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-CIbEVqqU.js";
 import { tryDispatchAcpReplyHook } from "openclaw/plugin-sdk/acp-runtime-backend";
 //#region extensions/acpx/index.ts
 const plugin = {

package/dist/mcp-proxy.mjs

@@ -4,9 +4,15 @@ import { spawn } from "node:child_process";
 import path from "node:path";
 import { createInterface } from "node:readline";
 import { pathToFileURL } from "node:url";
-import { formatErrorMessage } from "./error-format.mjs";
 import { splitCommandLine } from "./mcp-command-line.mjs";
 
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message || error.name || "Error";
+  }
+  return String(error);
+}
+
 function decodePayload(argv) {
   const payloadIndex = argv.indexOf("--payload");
   if (payloadIndex < 0) {

package/dist/register.runtime-CIbEVqqU.js

@@ -0,0 +1,250 @@
+import { getAcpRuntimeBackend, registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "openclaw/plugin-sdk/acp-runtime-backend";
+//#region extensions/acpx/src/runtime-turn.ts
+function createDeferredResult() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((resolvePromise, rejectPromise) => {
+			resolve = resolvePromise;
+			reject = rejectPromise;
+		}),
+		resolve,
+		reject
+	};
+}
+var LegacyRunTurnEventQueue = class {
+	constructor() {
+		this.items = [];
+		this.waits = [];
+		this.closed = false;
+	}
+	push(item) {
+		if (this.closed) return;
+		const waiter = this.waits.shift();
+		if (waiter) {
+			waiter.resolve(item);
+			return;
+		}
+		this.items.push(item);
+	}
+	clear() {
+		this.items.length = 0;
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const waiter of this.waits.splice(0)) waiter.resolve(null);
+	}
+	fail(error) {
+		if (this.closed) return;
+		this.error = error;
+		this.closed = true;
+		for (const waiter of this.waits.splice(0)) waiter.reject(error);
+	}
+	async next() {
+		const item = this.items.shift();
+		if (item) return item;
+		if (this.error) throw this.error;
+		if (this.closed) return null;
+		return await new Promise((resolve, reject) => {
+			this.waits.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	async *iterate() {
+		for (;;) {
+			const item = await this.next();
+			if (!item) return;
+			yield item;
+		}
+	}
+};
+function legacyRunTurnAsStartTurn(runtime, input) {
+	const result = createDeferredResult();
+	result.promise.catch(() => {});
+	const queue = new LegacyRunTurnEventQueue();
+	let resultSettled = false;
+	const settleResult = (next) => {
+		if (resultSettled) return;
+		resultSettled = true;
+		result.resolve(next);
+	};
+	(async () => {
+		try {
+			for await (const event of runtime.runTurn(input)) {
+				if (event.type === "done") {
+					settleResult({
+						status: "completed",
+						...event.stopReason ? { stopReason: event.stopReason } : {}
+					});
+					continue;
+				}
+				if (event.type === "error") {
+					settleResult({
+						status: "failed",
+						error: {
+							message: event.message,
+							...event.code ? { code: event.code } : {},
+							...event.detailCode ? { detailCode: event.detailCode } : {},
+							...event.retryable === void 0 ? {} : { retryable: event.retryable }
+						}
+					});
+					continue;
+				}
+				queue.push(event);
+			}
+			settleResult({
+				status: "failed",
+				error: {
+					code: "ACP_TURN_FAILED",
+					message: "ACP turn ended without a terminal done event."
+				}
+			});
+		} catch (error) {
+			result.reject(error);
+			queue.fail(error);
+			return;
+		}
+		queue.close();
+	})();
+	return {
+		requestId: input.requestId,
+		events: queue.iterate(),
+		result: result.promise,
+		async cancel(inputArgs) {
+			await runtime.cancel({
+				handle: input.handle,
+				reason: inputArgs?.reason
+			});
+		},
+		async closeStream() {
+			queue.clear();
+			queue.close();
+		}
+	};
+}
+function startRuntimeTurn(runtime, input) {
+	return runtime.startTurn?.(input) ?? legacyRunTurnAsStartTurn(runtime, input);
+}
+function lazyStartRuntimeTurn(resolveRuntime, input) {
+	const turnPromise = resolveRuntime().then((runtime) => startRuntimeTurn(runtime, input));
+	return {
+		requestId: input.requestId,
+		events: { async *[Symbol.asyncIterator]() {
+			yield* (await turnPromise).events;
+		} },
+		result: turnPromise.then((turn) => turn.result),
+		cancel(inputArgs) {
+			return turnPromise.then((turn) => turn.cancel(inputArgs));
+		},
+		closeStream(inputArgs) {
+			return turnPromise.then((turn) => turn.closeStream(inputArgs));
+		}
+	};
+}
+//#endregion
+//#region extensions/acpx/register.runtime.ts
+const ACPX_BACKEND_ID = "acpx";
+let serviceModulePromise = null;
+function loadServiceModule() {
+	serviceModulePromise ??= import("./service-Dj4-xaW3.js");
+	return serviceModulePromise;
+}
+async function startRealService(state) {
+	if (state.realRuntime) return state.realRuntime;
+	if (!state.ctx) throw new Error("ACPX runtime service is not started");
+	state.startPromise ??= (async () => {
+		const { createAcpxRuntimeService } = await loadServiceModule();
+		const service = createAcpxRuntimeService(state.params);
+		state.realService = service;
+		await service.start(state.ctx);
+		const backend = getAcpRuntimeBackend(ACPX_BACKEND_ID);
+		if (!backend?.runtime) throw new Error("ACPX runtime service did not register an ACP backend");
+		state.realRuntime = backend.runtime;
+		return state.realRuntime;
+	})();
+	try {
+		return await state.startPromise;
+	} catch (error) {
+		state.startPromise = null;
+		state.realService = null;
+		throw error;
+	}
+}
+function createDeferredRuntime(state) {
+	const resolveRuntime = () => startRealService(state);
+	return {
+		async ensureSession(input) {
+			return await (await resolveRuntime()).ensureSession(input);
+		},
+		startTurn(input) {
+			return lazyStartRuntimeTurn(resolveRuntime, input);
+		},
+		async *runTurn(input) {
+			yield* (await resolveRuntime()).runTurn(input);
+		},
+		async getCapabilities(input) {
+			return await (await resolveRuntime()).getCapabilities?.(input) ?? { controls: [] };
+		},
+		async getStatus(input) {
+			return await (await resolveRuntime()).getStatus?.(input) ?? {};
+		},
+		async setMode(input) {
+			await (await resolveRuntime()).setMode?.(input);
+		},
+		async setConfigOption(input) {
+			await (await resolveRuntime()).setConfigOption?.(input);
+		},
+		async doctor() {
+			return await (await resolveRuntime()).doctor?.() ?? {
+				ok: true,
+				message: "ok"
+			};
+		},
+		async prepareFreshSession(input) {
+			await (await resolveRuntime()).prepareFreshSession?.(input);
+		},
+		async cancel(input) {
+			await (await resolveRuntime()).cancel(input);
+		},
+		async close(input) {
+			await (await resolveRuntime()).close(input);
+		}
+	};
+}
+function createAcpxRuntimeService(params = {}) {
+	const state = {
+		ctx: null,
+		params,
+		realRuntime: null,
+		realService: null,
+		startPromise: null
+	};
+	return {
+		id: "acpx-runtime",
+		async start(ctx) {
+			if (process.env.OPENCLAW_SKIP_ACPX_RUNTIME === "1") {
+				ctx.logger.info("skipping embedded acpx runtime backend (OPENCLAW_SKIP_ACPX_RUNTIME=1)");
+				return;
+			}
+			state.ctx = ctx;
+			registerAcpRuntimeBackend({
+				id: ACPX_BACKEND_ID,
+				runtime: createDeferredRuntime(state)
+			});
+			ctx.logger.info("embedded acpx runtime backend registered lazily");
+		},
+		async stop(ctx) {
+			if (state.realService) await state.realService.stop?.(ctx);
+			else unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
+			state.ctx = null;
+			state.realRuntime = null;
+			state.realService = null;
+			state.startPromise = null;
+		}
+	};
+}
+//#endregion
+export { lazyStartRuntimeTurn as n, createAcpxRuntimeService as t };

package/dist/register.runtime.js

@@ -1,248 +1,2 @@
-import { getAcpRuntimeBackend, registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "openclaw/plugin-sdk/acp-runtime-backend";
-//#region extensions/acpx/register.runtime.ts
-const ACPX_BACKEND_ID = "acpx";
-let serviceModulePromise = null;
-function createDeferredResult() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((resolvePromise, rejectPromise) => {
-			resolve = resolvePromise;
-			reject = rejectPromise;
-		}),
-		resolve,
-		reject
-	};
-}
-var LegacyRunTurnEventQueue = class {
-	constructor() {
-		this.items = [];
-		this.waits = [];
-		this.closed = false;
-	}
-	push(item) {
-		if (this.closed) return;
-		const waiter = this.waits.shift();
-		if (waiter) {
-			waiter.resolve(item);
-			return;
-		}
-		this.items.push(item);
-	}
-	clear() {
-		this.items.length = 0;
-	}
-	close() {
-		if (this.closed) return;
-		this.closed = true;
-		for (const waiter of this.waits.splice(0)) waiter.resolve(null);
-	}
-	fail(error) {
-		if (this.closed) return;
-		this.error = error;
-		this.closed = true;
-		for (const waiter of this.waits.splice(0)) waiter.reject(error);
-	}
-	async next() {
-		const item = this.items.shift();
-		if (item) return item;
-		if (this.error) throw this.error;
-		if (this.closed) return null;
-		return await new Promise((resolve, reject) => {
-			this.waits.push({
-				resolve,
-				reject
-			});
-		});
-	}
-	async *iterate() {
-		for (;;) {
-			const item = await this.next();
-			if (!item) return;
-			yield item;
-		}
-	}
-};
-function loadServiceModule() {
-	serviceModulePromise ??= import("./service-CvQo2rym.js");
-	return serviceModulePromise;
-}
-async function startRealService(state) {
-	if (state.realRuntime) return state.realRuntime;
-	if (!state.ctx) throw new Error("ACPX runtime service is not started");
-	state.startPromise ??= (async () => {
-		const { createAcpxRuntimeService } = await loadServiceModule();
-		const service = createAcpxRuntimeService(state.params);
-		state.realService = service;
-		await service.start(state.ctx);
-		const backend = getAcpRuntimeBackend(ACPX_BACKEND_ID);
-		if (!backend?.runtime) throw new Error("ACPX runtime service did not register an ACP backend");
-		state.realRuntime = backend.runtime;
-		return state.realRuntime;
-	})();
-	try {
-		return await state.startPromise;
-	} catch (error) {
-		state.startPromise = null;
-		state.realService = null;
-		throw error;
-	}
-}
-function lazyStartTurn(resolveRuntime, input) {
-	const turnPromise = resolveRuntime().then((runtime) => {
-		if (runtime.startTurn) return runtime.startTurn(input);
-		return legacyRunTurnAsStartTurn(runtime, input);
-	});
-	return {
-		requestId: input.requestId,
-		events: { async *[Symbol.asyncIterator]() {
-			yield* (await turnPromise).events;
-		} },
-		result: turnPromise.then((turn) => turn.result),
-		cancel(inputArgs) {
-			return turnPromise.then((turn) => turn.cancel(inputArgs));
-		},
-		closeStream(inputArgs) {
-			return turnPromise.then((turn) => turn.closeStream(inputArgs));
-		}
-	};
-}
-function legacyRunTurnAsStartTurn(runtime, input) {
-	const result = createDeferredResult();
-	result.promise.catch(() => {});
-	const queue = new LegacyRunTurnEventQueue();
-	let resultSettled = false;
-	const settleResult = (next) => {
-		if (resultSettled) return;
-		resultSettled = true;
-		result.resolve(next);
-	};
-	(async () => {
-		try {
-			for await (const event of runtime.runTurn(input)) {
-				if (event.type === "done") {
-					settleResult({
-						status: "completed",
-						...event.stopReason ? { stopReason: event.stopReason } : {}
-					});
-					continue;
-				}
-				if (event.type === "error") {
-					settleResult({
-						status: "failed",
-						error: {
-							message: event.message,
-							...event.code ? { code: event.code } : {},
-							...event.detailCode ? { detailCode: event.detailCode } : {},
-							...event.retryable === void 0 ? {} : { retryable: event.retryable }
-						}
-					});
-					continue;
-				}
-				queue.push(event);
-			}
-			settleResult({
-				status: "failed",
-				error: {
-					code: "ACP_TURN_FAILED",
-					message: "ACP turn ended without a terminal done event."
-				}
-			});
-		} catch (error) {
-			result.reject(error);
-			queue.fail(error);
-			return;
-		}
-		queue.close();
-	})();
-	return {
-		requestId: input.requestId,
-		events: queue.iterate(),
-		result: result.promise,
-		async cancel(inputArgs) {
-			await runtime.cancel({
-				handle: input.handle,
-				reason: inputArgs?.reason
-			});
-		},
-		async closeStream() {
-			queue.clear();
-			queue.close();
-		}
-	};
-}
-function createDeferredRuntime(state) {
-	const resolveRuntime = () => startRealService(state);
-	return {
-		async ensureSession(input) {
-			return await (await resolveRuntime()).ensureSession(input);
-		},
-		startTurn(input) {
-			return lazyStartTurn(resolveRuntime, input);
-		},
-		async *runTurn(input) {
-			yield* (await resolveRuntime()).runTurn(input);
-		},
-		async getCapabilities(input) {
-			return await (await resolveRuntime()).getCapabilities?.(input) ?? { controls: [] };
-		},
-		async getStatus(input) {
-			return await (await resolveRuntime()).getStatus?.(input) ?? {};
-		},
-		async setMode(input) {
-			await (await resolveRuntime()).setMode?.(input);
-		},
-		async setConfigOption(input) {
-			await (await resolveRuntime()).setConfigOption?.(input);
-		},
-		async doctor() {
-			return await (await resolveRuntime()).doctor?.() ?? {
-				ok: true,
-				message: "ok"
-			};
-		},
-		async prepareFreshSession(input) {
-			await (await resolveRuntime()).prepareFreshSession?.(input);
-		},
-		async cancel(input) {
-			await (await resolveRuntime()).cancel(input);
-		},
-		async close(input) {
-			await (await resolveRuntime()).close(input);
-		}
-	};
-}
-function createAcpxRuntimeService(params = {}) {
-	const state = {
-		ctx: null,
-		params,
-		realRuntime: null,
-		realService: null,
-		startPromise: null
-	};
-	return {
-		id: "acpx-runtime",
-		async start(ctx) {
-			if (process.env.OPENCLAW_SKIP_ACPX_RUNTIME === "1") {
-				ctx.logger.info("skipping embedded acpx runtime backend (OPENCLAW_SKIP_ACPX_RUNTIME=1)");
-				return;
-			}
-			state.ctx = ctx;
-			registerAcpRuntimeBackend({
-				id: ACPX_BACKEND_ID,
-				runtime: createDeferredRuntime(state)
-			});
-			ctx.logger.info("embedded acpx runtime backend registered lazily");
-		},
-		async stop(ctx) {
-			if (state.realService) await state.realService.stop?.(ctx);
-			else unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
-			state.ctx = null;
-			state.realRuntime = null;
-			state.realService = null;
-			state.startPromise = null;
-		}
-	};
-}
-//#endregion
+import { t as createAcpxRuntimeService } from "./register.runtime-CIbEVqqU.js";
 export { createAcpxRuntimeService };

package/dist/{runtime-BMXFIXQq.js → runtime-BaP1xg1D.js}

@@ -5,6 +5,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import fs from "node:fs/promises";
 import path, { resolve } from "node:path";
 import { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState } from "acpx/runtime";
+import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
 //#region extensions/acpx/src/runtime.ts
 function withOpenClawManagedTurnTimeout(input) {
@@ -63,7 +64,7 @@ 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" ? Number.parseInt(rawPid, 10) : void 0;
+	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) {

package/dist/{service-CvQo2rym.js → service-Dj4-xaW3.js}

@@ -1,3 +1,4 @@
+import { n as lazyStartRuntimeTurn } from "./register.runtime-CIbEVqqU.js";
 import { registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "./runtime-api.js";
 import { a as resolveAcpxPluginRoot, c as OPENCLAW_ACPX_LEASE_ID_ENV, d as createAcpxProcessLeaseStore, h as splitCommandParts, i as resolveAcpxPluginConfig, l as OPENCLAW_GATEWAY_INSTANCE_ID_ARG, m as quoteCommandPart, o as toAcpMcpServers, r as reapStaleOpenClawOwnedAcpxOrphans, s as OPENCLAW_ACPX_LEASE_ID_ARG, t as cleanupOpenClawOwnedAcpxProcessTree } from "./process-reaper-CAUlLOkM.js";
 import { createRequire } from "node:module";
@@ -800,137 +801,9 @@ const SKIP_RUNTIME_PROBE_ENV = "OPENCLAW_SKIP_ACPX_RUNTIME_PROBE";
 const ACPX_BACKEND_ID = "acpx";
 let runtimeModulePromise = null;
 function loadRuntimeModule() {
-	runtimeModulePromise ??= import("./runtime-BMXFIXQq.js");
+	runtimeModulePromise ??= import("./runtime-BaP1xg1D.js");
 	return runtimeModulePromise;
 }
-function createDeferredResult() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((resolvePromise, rejectPromise) => {
-			resolve = resolvePromise;
-			reject = rejectPromise;
-		}),
-		resolve,
-		reject
-	};
-}
-var LegacyRunTurnEventQueue = class {
-	constructor() {
-		this.items = [];
-		this.waits = [];
-		this.closed = false;
-	}
-	push(item) {
-		if (this.closed) return;
-		const waiter = this.waits.shift();
-		if (waiter) {
-			waiter.resolve(item);
-			return;
-		}
-		this.items.push(item);
-	}
-	clear() {
-		this.items.length = 0;
-	}
-	close() {
-		if (this.closed) return;
-		this.closed = true;
-		for (const waiter of this.waits.splice(0)) waiter.resolve(null);
-	}
-	fail(error) {
-		if (this.closed) return;
-		this.error = error;
-		this.closed = true;
-		for (const waiter of this.waits.splice(0)) waiter.reject(error);
-	}
-	async next() {
-		const item = this.items.shift();
-		if (item) return item;
-		if (this.error) throw this.error;
-		if (this.closed) return null;
-		return await new Promise((resolve, reject) => {
-			this.waits.push({
-				resolve,
-				reject
-			});
-		});
-	}
-	async *iterate() {
-		for (;;) {
-			const item = await this.next();
-			if (!item) return;
-			yield item;
-		}
-	}
-};
-function legacyRunTurnAsStartTurn(runtime, input) {
-	const result = createDeferredResult();
-	result.promise.catch(() => {});
-	const queue = new LegacyRunTurnEventQueue();
-	let resultSettled = false;
-	const settleResult = (next) => {
-		if (resultSettled) return;
-		resultSettled = true;
-		result.resolve(next);
-	};
-	(async () => {
-		try {
-			for await (const event of runtime.runTurn(input)) {
-				if (event.type === "done") {
-					settleResult({
-						status: "completed",
-						...event.stopReason ? { stopReason: event.stopReason } : {}
-					});
-					continue;
-				}
-				if (event.type === "error") {
-					settleResult({
-						status: "failed",
-						error: {
-							message: event.message,
-							...event.code ? { code: event.code } : {},
-							...event.detailCode ? { detailCode: event.detailCode } : {},
-							...event.retryable === void 0 ? {} : { retryable: event.retryable }
-						}
-					});
-					continue;
-				}
-				queue.push(event);
-			}
-			settleResult({
-				status: "failed",
-				error: {
-					code: "ACP_TURN_FAILED",
-					message: "ACP turn ended without a terminal done event."
-				}
-			});
-		} catch (error) {
-			result.reject(error);
-			queue.fail(error);
-			return;
-		}
-		queue.close();
-	})();
-	return {
-		requestId: input.requestId,
-		events: queue.iterate(),
-		result: result.promise,
-		async cancel(inputArgs) {
-			await runtime.cancel({
-				handle: input.handle,
-				reason: inputArgs?.reason
-			});
-		},
-		async closeStream() {
-			queue.clear();
-			queue.close();
-		}
-	};
-}
-function startRuntimeTurn(runtime, input) {
-	return runtime.startTurn?.(input) ?? legacyRunTurnAsStartTurn(runtime, input);
-}
 function createLazyDefaultRuntime(params) {
 	let runtime = null;
 	let runtimePromise = null;
@@ -959,20 +832,7 @@ function createLazyDefaultRuntime(params) {
 			return await (await resolveRuntime()).ensureSession(input);
 		},
 		startTurn(input) {
-			const turnPromise = resolveRuntime().then((resolved) => startRuntimeTurn(resolved, input));
-			return {
-				requestId: input.requestId,
-				events: { async *[Symbol.asyncIterator]() {
-					yield* (await turnPromise).events;
-				} },
-				result: turnPromise.then((turn) => turn.result),
-				cancel(inputArgs) {
-					return turnPromise.then((turn) => turn.cancel(inputArgs));
-				},
-				closeStream(inputArgs) {
-					return turnPromise.then((turn) => turn.closeStream(inputArgs));
-				}
-			};
+			return lazyStartRuntimeTurn(resolveRuntime, input);
 		},
 		async *runTurn(input) {
 			yield* (await resolveRuntime()).runTurn(input);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/acpx",
-  "version": "2026.5.27",
+  "version": "2026.5.28-beta.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/acpx",
-      "version": "2026.5.27",
+      "version": "2026.5.28-beta.1",
       "dependencies": {
         "@agentclientprotocol/claude-agent-acp": "0.37.0",
         "@zed-industries/codex-acp": "0.15.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/acpx",
-  "version": "2026.5.27",
+  "version": "2026.5.28-beta.1",
   "description": "OpenClaw ACP runtime backend with plugin-owned session and transport management.",
   "repository": {
     "type": "git",
@@ -26,19 +26,15 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.5.27"
+      "pluginApi": ">=2026.5.28-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.27",
+      "openclawVersion": "2026.5.28-beta.1",
       "staticAssets": [
         {
           "source": "./src/runtime-internals/mcp-proxy.mjs",
           "output": "mcp-proxy.mjs"
         },
-        {
-          "source": "./src/runtime-internals/error-format.mjs",
-          "output": "error-format.mjs"
-        },
         {
           "source": "./src/runtime-internals/mcp-command-line.mjs",
           "output": "mcp-command-line.mjs"
@@ -61,7 +57,7 @@
     "skills/**"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.5.27"
+    "openclaw": ">=2026.5.28-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/skills/acp-router/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: acp-router
-description: Route plain-language requests for Pi, Claude Code, Cursor, Copilot, OpenClaw ACP, OpenCode, Gemini CLI, Qwen, Kiro, Kimi, iFlow, Factory Droid, Kilocode, or explicit ACP harness work into either OpenClaw ACP runtime sessions or direct acpx-driven sessions ("telephone game" flow). For coding-agent thread requests, read this skill first, then use only `sessions_spawn` for thread creation. Codex chat binding defaults to the native Codex app-server plugin unless ACP is explicit or background spawn needs ACP.
+description: Route plain-language requests for Claude Code, Cursor, Copilot, OpenClaw ACP, OpenCode, Gemini CLI, Qwen, Kiro, Kimi, iFlow, Factory Droid, Kilocode, or explicit ACP harness work into either OpenClaw ACP runtime sessions or direct acpx-driven sessions ("telephone game" flow). For coding-agent thread requests, read this skill first, then use only `sessions_spawn` for thread creation. Codex chat binding defaults to the native Codex app-server plugin unless ACP is explicit or background spawn needs ACP.
 user-invocable: false
 ---
 
 # ACP Harness Router
 
-When user intent is "run this in Pi/Claude Code/Cursor/Copilot/OpenClaw/OpenCode/Gemini/Qwen/Kiro/Kimi/iFlow/Droid/Kilocode (ACP harness)", do not use subagent runtime or PTY scraping. Route through ACP-aware flows.
+When user intent is "run this in Claude Code/Cursor/Copilot/OpenClaw/OpenCode/Gemini/Qwen/Kiro/Kimi/iFlow/Droid/Kilocode (ACP harness)", do not use subagent runtime or PTY scraping. Route through ACP-aware flows.
 
 Codex is special: plain chat/conversation binding and control should use the native Codex app-server plugin (`/codex bind`, `/codex threads`, `/codex resume`) instead of the default ACP path. Use ACP for Codex only when the user explicitly names ACP/`/acp`/acpx, or when spawning background child sessions through `sessions_spawn` where a native Codex runtime spawn is not available yet.
 
@@ -14,7 +14,7 @@ Codex is special: plain chat/conversation binding and control should use the nat
 
 Trigger this skill when the user asks OpenClaw to:
 
-- run something in Pi / Claude Code / Cursor / Copilot / OpenClaw / OpenCode / Gemini / Qwen / Kiro / Kimi / iFlow / Droid / Kilocode
+- run something in Claude Code / Cursor / Copilot / OpenClaw / OpenCode / Gemini / Qwen / Kiro / Kimi / iFlow / Droid / Kilocode
 - run Codex explicitly through ACP, `/acp`, or acpx
 - continue existing harness work
 - relay instructions to an external coding harness
@@ -48,7 +48,6 @@ Do not use:
 
 Use these defaults when user names a harness directly:
 
-- "pi" -> `agentId: "pi"`
 - "openclaw" -> `agentId: "openclaw"`
 - "claude" or "claude code" -> `agentId: "claude"`
 - "codex" -> `agentId: "codex"` only for explicit ACP/acpx requests or background ACP runtime spawn
@@ -203,7 +202,6 @@ ${ACPX_CMD} codex sessions close oc-codex-<conversationId>
 - `kiro`
 - `openclaw`
 - `opencode`
-- `pi`
 - `qwen`
 
 ### Built-in adapter commands in acpx
@@ -222,7 +220,6 @@ Defaults are:
 - `kimi -> kimi acp`
 - `kiro -> kiro-cli acp`
 - `opencode -> npx -y opencode-ai acp`
-- `pi -> npx pi-acp@^0.0.22`
 - `qwen -> qwen --acp`
 
 If `~/.acpx/config.json` overrides `agents`, those overrides replace defaults.

package/dist/error-format.mjs

@@ -1,6 +0,0 @@
-export function formatErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message || error.name || "Error";
-  }
-  return String(error);
-}