@openclaw/acpx 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/register.runtime-BbS2JTTv.js

@@ -1,263 +0,0 @@
-import { getAcpRuntimeBackend, registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "openclaw/plugin-sdk/acp-runtime-backend";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-//#region extensions/acpx/src/runtime-turn.ts
-/**
-* ACPX turn adapters. Modern runtimes can expose startTurn directly; legacy
-* runtimes that only stream runTurn events are adapted to the newer contract.
-*/
-function isCancellationStopReason(stopReason) {
-	return stopReason === "cancel" || stopReason === "cancelled" || stopReason === "manual-cancel";
-}
-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 toLintErrorObject(this.error, "Non-Error thrown");
-		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 = createDeferred();
-	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: event.status ?? (isCancellationStopReason(event.stopReason) ? "cancelled" : "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();
-		}
-	};
-}
-/** Start an ACP turn, adapting legacy runTurn-only runtimes when needed. */
-function startRuntimeTurn(runtime, input) {
-	return runtime.startTurn?.(input) ?? legacyRunTurnAsStartTurn(runtime, input);
-}
-/** Start an ACP turn through a lazy runtime resolver. */
-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));
-		}
-	};
-}
-function toLintErrorObject(value, fallbackMessage) {
-	if (value instanceof Error) return value;
-	if (typeof value === "string") return new Error(value);
-	const error = new Error(fallbackMessage, { cause: value });
-	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
-	return error;
-}
-//#endregion
-//#region extensions/acpx/src/runtime-proxy.ts
-/** Create an ACP runtime facade backed by an async runtime resolver. */
-function createLazyAcpRuntimeProxy(resolveRuntime) {
-	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);
-		}
-	};
-}
-//#endregion
-//#region extensions/acpx/register.runtime.ts
-/**
-* Lazy ACPX runtime service registration. The plugin exposes an ACP backend
-* immediately, then imports the heavier service only when a session needs it.
-*/
-const ACPX_BACKEND_ID = "acpx";
-const loadServiceModule = createLazyRuntimeModule(() => import("./service-CBZSAymH.js"));
-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: createAcpxRuntimeServiceLocal } = await loadServiceModule();
-		const service = createAcpxRuntimeServiceLocal(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 createLazyAcpRuntimeProxy(resolveRuntime);
-}
-/** Creates the plugin service that registers ACPX as an ACP runtime backend. */
-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 { createLazyAcpRuntimeProxy as n, createAcpxRuntimeService as t };