@openclaw/acpx 2026.5.16-beta.4 → 2026.5.16-beta.5

package/dist/register.runtime.js

@@ -1,16 +1,11 @@
-import { getAcpRuntimeBackend, registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "openclaw/plugin-sdk/acp-runtime-backend";
+import { getAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "openclaw/plugin-sdk/acp-runtime-backend";
 //#region extensions/acpx/register.runtime.ts
 const ACPX_BACKEND_ID = "acpx";
-const ENABLE_STARTUP_PROBE_ENV = "OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE";
-const SKIP_RUNTIME_PROBE_ENV = "OPENCLAW_SKIP_ACPX_RUNTIME_PROBE";
 let serviceModulePromise = null;
 function loadServiceModule() {
-	serviceModulePromise ??= import("./service-D_VrHPXx.js");
+	serviceModulePromise ??= import("./service-DsH8by3_.js");
 	return serviceModulePromise;
 }
-function shouldRunStartupProbe(env = process.env) {
-	return env[ENABLE_STARTUP_PROBE_ENV] !== "0" && env[SKIP_RUNTIME_PROBE_ENV] !== "1";
-}
 async function startRealService(state) {
 	if (state.realRuntime) return state.realRuntime;
 	if (!state.ctx) throw new Error("ACPX runtime service is not started");
@@ -26,49 +21,6 @@ async function startRealService(state) {
 	})();
 	return await state.startPromise;
 }
-function createDeferredRuntime(state) {
-	return {
-		async ensureSession(input) {
-			return await (await startRealService(state)).ensureSession(input);
-		},
-		async *runTurn(input) {
-			yield* (await startRealService(state)).runTurn(input);
-		},
-		async getCapabilities(input) {
-			return await (await startRealService(state)).getCapabilities?.(input) ?? { controls: [] };
-		},
-		async getStatus(input) {
-			return await (await startRealService(state)).getStatus?.(input) ?? {};
-		},
-		async setMode(input) {
-			await (await startRealService(state)).setMode?.(input);
-		},
-		async setConfigOption(input) {
-			await (await startRealService(state)).setConfigOption?.(input);
-		},
-		async doctor() {
-			return await (await startRealService(state)).doctor?.() ?? {
-				ok: true,
-				message: "ok"
-			};
-		},
-		async prepareFreshSession(input) {
-			await (await startRealService(state)).prepareFreshSession?.(input);
-		},
-		async cancel(input) {
-			await (await startRealService(state)).cancel(input);
-		},
-		async close(input) {
-			await (await startRealService(state)).close(input);
-		},
-		async probeAvailability() {
-			await (await startRealService(state)).probeAvailability();
-		},
-		isHealthy() {
-			return state.realRuntime?.isHealthy() ?? false;
-		}
-	};
-}
 function createAcpxRuntimeService(params = {}) {
 	const state = {
 		ctx: null,
@@ -85,15 +37,7 @@ function createAcpxRuntimeService(params = {}) {
 				return;
 			}
 			state.ctx = ctx;
-			if (shouldRunStartupProbe()) {
-				await startRealService(state);
-				return;
-			}
-			registerAcpRuntimeBackend({
-				id: ACPX_BACKEND_ID,
-				runtime: createDeferredRuntime(state)
-			});
-			ctx.logger.info("embedded acpx runtime backend registered lazily");
+			await startRealService(state);
 		},
 		async stop(ctx) {
 			if (state.realService) await state.realService.stop?.(ctx);

package/dist/{runtime-WxNI8VkM.js → runtime-DuZ9TePK.js}

@@ -6,6 +6,12 @@ import path, { resolve } from "node:path";
 import { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState } from "acpx/runtime";
 import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
 //#region extensions/acpx/src/runtime.ts
+function withOpenClawManagedTurnTimeout(input) {
+	return {
+		...input,
+		timeoutMs: 0
+	};
+}
 const CODEX_WRAPPER_STDERR_LOG_PREFIX = "codex-acp-wrapper.stderr";
 const CODEX_WRAPPER_ERROR_TAIL_MAX_CHARS = 6e3;
 function safeDiagnosticFilePart(value) {
@@ -569,7 +575,7 @@ var AcpxRuntime = class {
 		const command = await this.resolveCommandForHandle(input.handle);
 		const delegate = await this.resolveDelegateForHandle(input.handle);
 		try {
-			for await (const event of delegate.runTurn(input)) {
+			for await (const event of delegate.runTurn(withOpenClawManagedTurnTimeout(input))) {
 				if (event.type !== "error" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(event.message)) {
 					yield event;
 					continue;
@@ -592,6 +598,78 @@ var AcpxRuntime = class {
 			throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
 		}
 	}
+	startTurn(input) {
+		const readCodexTurnFailureStderr = () => this.readCodexTurnFailureStderr({ handle: input.handle });
+		const turnPromise = Promise.all([this.resolveCommandForHandle(input.handle), this.resolveDelegateForHandle(input.handle)]).then(async ([command, delegate]) => {
+			try {
+				return {
+					command,
+					turn: delegate.startTurn(withOpenClawManagedTurnTimeout(input))
+				};
+			} catch (error) {
+				if (!isCodexAcpCommand(command) || !isGenericInternalAcpError(error)) throw error;
+				const stderrTail = await readCodexTurnFailureStderr();
+				if (!stderrTail) throw error;
+				throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
+			}
+		});
+		return {
+			requestId: input.requestId,
+			events: { async *[Symbol.asyncIterator]() {
+				const { command, turn } = await turnPromise;
+				try {
+					for await (const event of turn.events) {
+						if (event.type !== "error" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(event.message)) {
+							yield event;
+							continue;
+						}
+						const stderrTail = await readCodexTurnFailureStderr();
+						if (!stderrTail) {
+							yield event;
+							continue;
+						}
+						yield {
+							...event,
+							code: "ACP_TURN_FAILED",
+							message: `Internal error: ${stderrTail}`
+						};
+					}
+				} catch (error) {
+					if (!isCodexAcpCommand(command) || !isGenericInternalAcpError(error)) throw error;
+					const stderrTail = await readCodexTurnFailureStderr();
+					if (!stderrTail) throw error;
+					throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
+				}
+			} },
+			result: turnPromise.then(async ({ command, turn }) => {
+				try {
+					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}`
+						}
+					};
+				} catch (error) {
+					if (!isCodexAcpCommand(command) || !isGenericInternalAcpError(error)) throw error;
+					const stderrTail = await this.readCodexTurnFailureStderr({ handle: input.handle });
+					if (!stderrTail) throw error;
+					throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
+				}
+			}),
+			cancel(inputArgs) {
+				return turnPromise.then(({ turn }) => turn.cancel(inputArgs));
+			},
+			closeStream(inputArgs) {
+				return turnPromise.then(({ turn }) => turn.closeStream(inputArgs));
+			}
+		};
+	}
 	getCapabilities() {
 		return this.delegate.getCapabilities();
 	}

package/dist/{service-D_VrHPXx.js → service-DsH8by3_.js}

@@ -1053,9 +1053,137 @@ const SKIP_RUNTIME_PROBE_ENV = "OPENCLAW_SKIP_ACPX_RUNTIME_PROBE";
 const ACPX_BACKEND_ID = "acpx";
 let runtimeModulePromise = null;
 function loadRuntimeModule() {
-	runtimeModulePromise ??= import("./runtime-WxNI8VkM.js");
+	runtimeModulePromise ??= import("./runtime-DuZ9TePK.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;
@@ -1083,6 +1211,22 @@ function createLazyDefaultRuntime(params) {
 		async ensureSession(input) {
 			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));
+				}
+			};
+		},
 		async *runTurn(input) {
 			yield* (await resolveRuntime()).runTurn(input);
 		},

package/openclaw.plugin.json

@@ -129,8 +129,8 @@
       "advanced": true
     },
     "timeoutSeconds": {
-      "label": "Prompt Timeout Seconds",
-      "help": "Timeout for each embedded runtime turn. Defaults to 120 seconds so slower Gemini CLI ACP startups have room to initialize.",
+      "label": "Runtime Operation Timeout Seconds",
+      "help": "Timeout for embedded ACP runtime startup and control operations. ACP turns use OpenClaw agent/run timeouts.",
       "advanced": true
     },
     "queueOwnerTtlSeconds": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/acpx",
-  "version": "2026.5.16-beta.4",
+  "version": "2026.5.16-beta.5",
   "description": "OpenClaw ACP runtime backend",
   "repository": {
     "type": "git",
@@ -26,10 +26,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.5.16-beta.4"
+      "pluginApi": ">=2026.5.16-beta.5"
     },
     "build": {
-      "openclawVersion": "2026.5.16-beta.4",
+      "openclawVersion": "2026.5.16-beta.5",
       "staticAssets": [
         {
           "source": "./src/runtime-internals/mcp-proxy.mjs",
@@ -59,7 +59,7 @@
     "skills/**"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.5.16-beta.4"
+    "openclaw": ">=2026.5.16-beta.5"
   },
   "peerDependenciesMeta": {
     "openclaw": {