@rivus/agent 0.16.2 → 0.16.6

package/dist/acp.js

@@ -1,768 +1,2 @@
-import { _ as createAgentLoopToolExecutionStart, c as toEffectAgentLoop, g as createAgentLoopToolExecutionEnd, h as createAgentLoopThinkingDelta, m as createAgentLoopTextDelta, o as fromEffectAgentLoop, s as toCompatibilityAgentLoopInput, v as createAgentLoopToolExecutionUpdate, y as createAgentLoopTurnStart } from "./chunks/agent-loop.js";
-import * as acp from "@agentclientprotocol/sdk";
-import { Effect, Stream } from "effect";
-import { randomUUID } from "node:crypto";
-import { Readable, Writable } from "node:stream";
-import { spawn } from "node:child_process";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-//#region src/adapters/acp/runtime/acp-agent-loop.ts
-function createAcpAgentLoop$1(options) {
-	return {
-		run: (input) => Stream.fromAsyncIterable(runAcpSession(input, options), (error) => error),
-		supportsSteering: true
-	};
-}
-async function* runAcpSession(input, options) {
-	const session = await options.resolveSession(input);
-	const updates = [];
-	const tools = /* @__PURE__ */ new Map();
-	let wake;
-	let abortCancellation;
-	let abortFailure;
-	let abortSettled = false;
-	let aborted = false;
-	let currentTurn = startAcpTurn(input.text, session, input, updates, tools, () => {
-		wake?.();
-		wake = void 0;
-	});
-	const onAbort = () => {
-		aborted = true;
-		abortCancellation ??= settleCancelledTurn(session, currentTurn.promise, options.cancellationSettleTimeoutMs ?? 5e3);
-		abortCancellation.then(() => {
-			abortSettled = true;
-			wake?.();
-			wake = void 0;
-		}, (error) => {
-			abortFailure = error;
-			wake?.();
-			wake = void 0;
-		});
-	};
-	input.abortSignal.addEventListener("abort", onAbort, { once: true });
-	const takeSteering = () => input.steering ? Effect.runPromise(input.steering.next()) : void 0;
-	let steering = takeSteering();
-	try {
-		if (input.abortSignal.aborted) onAbort();
-		while (!currentTurn.completed || updates.length > 0) {
-			if (abortFailure !== void 0) throw abortFailure;
-			if (aborted && abortSettled) break;
-			const event = updates.shift();
-			if (event) yield event;
-			else {
-				const signal = await Promise.race([
-					new Promise((resolve) => {
-						wake = () => resolve({ type: "wake" });
-					}),
-					...steering ? [steering.then((text) => ({
-						text,
-						type: "steer"
-					}))] : [],
-					currentTurn.promise.then(() => ({ type: "turn_completed" }), () => ({ type: "turn_completed" }))
-				]);
-				if (signal.type === "steer") {
-					await Promise.resolve(session.cancel({ preserveSession: true }));
-					await currentTurn.promise;
-					updates.push(createAgentLoopTurnStart());
-					currentTurn = startAcpTurn(createSteeringTurnPrompt(signal.text), session, input, updates, tools, () => {
-						wake?.();
-						wake = void 0;
-					});
-					steering = takeSteering();
-				}
-				if (signal.type === "turn_completed" && currentTurn.completed) break;
-				if (signal.type === "wake") wake = void 0;
-			}
-		}
-		if (!aborted) {
-			await currentTurn.promise;
-			if (currentTurn.failure !== void 0) throw currentTurn.failure;
-		}
-	} finally {
-		input.abortSignal.removeEventListener("abort", onAbort);
-		if (abortCancellation) await abortCancellation;
-		if (options.disposeSessionAfterRun !== false) await session.dispose?.();
-	}
-}
-async function settleCancelledTurn(session, currentTurn, timeoutMs) {
-	await Promise.resolve(session.cancel({ preserveSession: false }));
-	if (await settlesWithin(currentTurn, timeoutMs)) return;
-	if (session.invalidate) await session.invalidate();
-	else await session.dispose?.();
-}
-async function settlesWithin(promise, timeoutMs) {
-	let timeout;
-	try {
-		return await Promise.race([promise.then(() => true), new Promise((resolve) => {
-			timeout = setTimeout(() => resolve(false), timeoutMs);
-		})]);
-	} finally {
-		if (timeout) clearTimeout(timeout);
-	}
-}
-function createSteeringTurnPrompt(text) {
-	return [
-		"用户刚刚在当前任务执行期间发送了一条 steering 消息。",
-		"请先直接回答这条消息；如果它是关于当前任务的进度或概念问题，先给出清晰解释。",
-		"只有消息明确要求改变任务时才执行动作；不要把用户自然语言当作 shell 命令。",
-		"回答后基于当前会话已有状态继续任务；不得重放最初指令或重复已经完成的步骤。",
-		"用户消息：",
-		text
-	].join("\n");
-}
-function startAcpTurn(text, session, input, updates, tools, notify) {
-	let completed = false;
-	let failure;
-	return {
-		promise: session.prompt(text, (update) => {
-			updates.push(...mapAcpSessionUpdate(update, tools));
-			notify();
-		}).then(() => void 0).catch((error) => {
-			if (!input.abortSignal.aborted) failure = error;
-		}).finally(() => {
-			completed = true;
-			notify();
-		}),
-		get completed() {
-			return completed;
-		},
-		get failure() {
-			return failure;
-		}
-	};
-}
-function mapAcpSessionUpdate(update, tools) {
-	if (update.sessionUpdate === "agent_message_chunk") {
-		const text = readTextContent(update.content);
-		return text === void 0 ? [] : [createAgentLoopTextDelta(text)];
-	}
-	if (update.sessionUpdate === "agent_thought_chunk") {
-		const text = readTextContent(update.content);
-		return text === void 0 ? [] : [createAgentLoopThinkingDelta(text)];
-	}
-	if (update.sessionUpdate === "tool_call") {
-		if (!update.toolCallId || !update.title) return [];
-		const name = update.name?.trim() || update.title;
-		const state = {
-			input: update.rawInput,
-			name
-		};
-		tools.set(update.toolCallId, state);
-		const start = createAgentLoopToolExecutionStart({
-			input: state.input,
-			toolCallId: update.toolCallId,
-			toolName: state.name
-		});
-		if (update.status === "completed" || update.status === "failed") {
-			tools.delete(update.toolCallId);
-			return [start, createAgentLoopToolExecutionEnd({
-				isError: update.status === "failed",
-				result: update.rawOutput,
-				toolCallId: update.toolCallId,
-				toolName: state.name
-			})];
-		}
-		return [start];
-	}
-	if (update.sessionUpdate !== "tool_call_update") return [];
-	if (!update.toolCallId) return [];
-	const prior = tools.get(update.toolCallId);
-	const state = {
-		input: update.rawInput ?? prior?.input,
-		name: update.name?.trim() || update.title?.trim() || prior?.name || update.toolCallId
-	};
-	tools.set(update.toolCallId, state);
-	if (update.status === "completed" || update.status === "failed") {
-		tools.delete(update.toolCallId);
-		return [createAgentLoopToolExecutionEnd({
-			isError: update.status === "failed",
-			result: update.rawOutput,
-			toolCallId: update.toolCallId,
-			toolName: state.name
-		})];
-	}
-	return [createAgentLoopToolExecutionUpdate({
-		input: state.input,
-		partialResult: update.rawOutput,
-		toolCallId: update.toolCallId,
-		toolName: state.name
-	})];
-}
-function readTextContent(content) {
-	if (!isRecord$1(content) || content.type !== "text" || typeof content.text !== "string") return void 0;
-	return content.text;
-}
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null;
-}
-//#endregion
-//#region src/adapters/acp/runtime/acp-agent-server.ts
-function createAcpAgentServer$1(options) {
-	const sessions = /* @__PURE__ */ new Set();
-	const active = /* @__PURE__ */ new Map();
-	return acp.agent({ name: options.agentName ?? "rivus" }).onRequest(acp.methods.agent.initialize, ({ params }) => ({
-		agentCapabilities: {},
-		agentInfo: {
-			name: options.agentName ?? "rivus",
-			version: "1"
-		},
-		protocolVersion: params.protocolVersion === acp.PROTOCOL_VERSION ? params.protocolVersion : acp.PROTOCOL_VERSION
-	})).onRequest(acp.methods.agent.session.new, () => {
-		const sessionId = randomUUID();
-		sessions.add(sessionId);
-		return { sessionId };
-	}).onRequest(acp.methods.agent.session.prompt, async ({ client, params }) => {
-		if (!sessions.has(params.sessionId)) throw new Error(`Unknown ACP session: ${params.sessionId}`);
-		if (active.has(params.sessionId)) throw new Error(`ACP session is already active: ${params.sessionId}`);
-		const controller = new AbortController();
-		active.set(params.sessionId, controller);
-		const sessionKey = `acp:${params.sessionId}`;
-		const releasePermissionBridge = options.permissionBridge?.bind(sessionKey, async (request) => {
-			const response = await client.request(acp.methods.client.session.requestPermission, {
-				options: request.options.map((option) => ({ ...option })),
-				sessionId: params.sessionId,
-				toolCall: {
-					...request.toolCall.rawInput === void 0 ? {} : { rawInput: request.toolCall.rawInput },
-					...request.toolCall.title === void 0 ? {} : { title: request.toolCall.title },
-					toolCallId: request.toolCall.toolCallId
-				}
-			});
-			return response.outcome.outcome === "selected" ? { optionId: response.outcome.optionId } : void 0;
-		});
-		try {
-			await Effect.runPromise(options.loop.run({
-				abortSignal: controller.signal,
-				runId: randomUUID(),
-				sessionKey,
-				text: readPromptText(params.prompt)
-			}).pipe(Stream.runForEach((event) => Effect.tryPromise({
-				catch: (cause) => cause,
-				try: async () => {
-					const update = mapAgentLoopEvent(event);
-					if (update) await client.notify(acp.methods.client.session.update, {
-						sessionId: params.sessionId,
-						update
-					});
-				}
-			}))));
-			return { stopReason: controller.signal.aborted ? "cancelled" : "end_turn" };
-		} finally {
-			releasePermissionBridge?.();
-			active.delete(params.sessionId);
-		}
-	}).onNotification(acp.methods.agent.session.cancel, ({ params }) => {
-		active.get(params.sessionId)?.abort();
-	});
-}
-async function serveAcpAgentOnStdio$1(app) {
-	const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-	await app.connect(stream).closed;
-}
-function readPromptText(prompt) {
-	const parts = prompt.flatMap((content) => content.type === "text" ? [content.text] : []);
-	if (parts.length !== prompt.length) throw new Error("Rivus ACP facade currently accepts text prompt content only");
-	return parts.join("\n");
-}
-function mapAgentLoopEvent(event) {
-	if (event.type === "assistant_text_delta") return {
-		content: {
-			text: event.delta,
-			type: "text"
-		},
-		sessionUpdate: "agent_message_chunk"
-	};
-	if (event.type === "assistant_thinking_delta") return {
-		content: {
-			text: event.delta,
-			type: "text"
-		},
-		sessionUpdate: "agent_thought_chunk"
-	};
-	if (event.type === "tool_execution_start") return {
-		name: event.toolName,
-		rawInput: event.input,
-		sessionUpdate: "tool_call",
-		status: "in_progress",
-		title: event.toolName,
-		toolCallId: event.toolCallId
-	};
-	if (event.type === "tool_execution_update") return {
-		name: event.toolName,
-		rawInput: event.input,
-		rawOutput: event.partialResult,
-		sessionUpdate: "tool_call_update",
-		status: "in_progress",
-		title: event.toolName,
-		toolCallId: event.toolCallId
-	};
-	if (event.type === "tool_execution_end") return {
-		name: event.toolName,
-		rawOutput: event.result,
-		sessionUpdate: "tool_call_update",
-		status: event.isError ? "failed" : "completed",
-		title: event.toolName,
-		toolCallId: event.toolCallId
-	};
-}
-//#endregion
-//#region src/adapters/acp/runtime/acp-permission-policy.ts
-async function decideAcpPermission(request, policy) {
-	const selection = await policy?.(request);
-	if (!selection || !request.options.some((option) => option.optionId === selection.optionId)) return { outcome: "cancelled" };
-	return {
-		optionId: selection.optionId,
-		outcome: "selected"
-	};
-}
-//#endregion
-//#region src/adapters/acp/runtime/acp-stdio-agent-loop.ts
-async function buildAcpSession(processConnection, options, input) {
-	const mcpServers = createMcpServers(options, input);
-	const persisted = await options.sessionStore?.load(input.sessionKey);
-	if (persisted) return restoreAcpSession(processConnection, options, persisted.sessionId, mcpServers);
-	const session = await processConnection.connection.agent.buildSession({
-		cwd: options.workingDirectory,
-		mcpServers
-	}).start();
-	await options.sessionStore?.save(input.sessionKey, { sessionId: session.sessionId });
-	return session;
-}
-function createMcpServers(options, input) {
-	return (options.mcpServers?.(input) ?? []).map((server) => ({
-		args: [...server.args],
-		command: server.command,
-		env: server.env.map(({ name, value }) => ({
-			name,
-			value
-		})),
-		name: server.name,
-		type: "stdio"
-	}));
-}
-async function restoreAcpSession(processConnection, options, sessionId, mcpServers) {
-	const session = new ResumedAcpSession(processConnection, sessionId);
-	try {
-		if (processConnection.agentCapabilities?.loadSession) await processConnection.connection.agent.request(acp.methods.agent.session.load, {
-			cwd: options.workingDirectory,
-			mcpServers,
-			sessionId
-		});
-		else if (processConnection.agentCapabilities?.sessionCapabilities?.resume) await processConnection.connection.agent.request(acp.methods.agent.session.resume, {
-			cwd: options.workingDirectory,
-			mcpServers,
-			sessionId
-		});
-		else throw new AcpSessionResumeUnavailable(sessionId);
-		session.clearReplay();
-		return session;
-	} catch (error) {
-		session.dispose();
-		throw new AcpSessionResumeFailed(sessionId, error);
-	}
-}
-function createAcpStdioAgentLoop$1(options) {
-	let pendingConnection;
-	let activeConnection;
-	let ownedChild;
-	const sessionKeys = /* @__PURE__ */ new Map();
-	const resolveConnection = () => {
-		if (pendingConnection) return pendingConnection;
-		let current;
-		current = openConnection(options, sessionKeys, (child) => {
-			ownedChild = child;
-		});
-		pendingConnection = current;
-		current.then((processConnection) => {
-			if (pendingConnection !== current) {
-				processConnection.connection.close();
-				terminateChild(processConnection.child, options.terminationTimeoutMs);
-				return;
-			}
-			activeConnection = processConnection;
-			processConnection.connection.closed.finally(() => {
-				if (pendingConnection !== current) return;
-				pendingConnection = void 0;
-				activeConnection = void 0;
-				if (ownedChild === processConnection.child) ownedChild = void 0;
-				sessionKeys.clear();
-				for (const session of processConnection.sessions.values()) session.dispose();
-				processConnection.sessions.clear();
-				processConnection.sessionUpdateHandlers.clear();
-				terminateChild(processConnection.child, options.terminationTimeoutMs);
-			});
-		}, () => {
-			if (pendingConnection === current) {
-				pendingConnection = void 0;
-				activeConnection = void 0;
-				ownedChild = void 0;
-				sessionKeys.clear();
-			}
-		});
-		return current;
-	};
-	return {
-		dispose: async () => {
-			const current = pendingConnection;
-			pendingConnection = void 0;
-			const processConnection = activeConnection;
-			activeConnection = void 0;
-			if (processConnection) {
-				for (const session of processConnection.sessions.values()) session.dispose();
-				processConnection.sessions.clear();
-				processConnection.sessionUpdateHandlers.clear();
-				processConnection.connection.close();
-			}
-			sessionKeys.clear();
-			const child = ownedChild;
-			ownedChild = void 0;
-			if (child) await terminateChild(child, options.terminationTimeoutMs);
-			await current?.catch(() => void 0);
-		},
-		loop: createAcpAgentLoop$1({
-			disposeSessionAfterRun: false,
-			resolveSession: async (input) => {
-				const processConnection = await resolveConnection();
-				const current = processConnection.sessions.get(input.sessionKey);
-				if (current?.isReusable) return current;
-				if (current) {
-					current.dispose();
-					processConnection.sessions.delete(input.sessionKey);
-				}
-				const session = new SdkAcpAgentSession(await buildAcpSession(processConnection, options, input), processConnection.connection.agent, input.sessionKey, options.sessionStore);
-				sessionKeys.set(session.sessionId, input.sessionKey);
-				processConnection.sessions.set(input.sessionKey, session);
-				return session;
-			}
-		})
-	};
-}
-var SdkAcpAgentSession = class {
-	session;
-	agent;
-	sessionKey;
-	sessionStore;
-	reusable = true;
-	constructor(session, agent, sessionKey, sessionStore) {
-		this.session = session;
-		this.agent = agent;
-		this.sessionKey = sessionKey;
-		this.sessionStore = sessionStore;
-	}
-	get sessionId() {
-		return this.session.sessionId;
-	}
-	get isReusable() {
-		return this.reusable;
-	}
-	cancel(options) {
-		if (options?.preserveSession !== true) this.reusable = false;
-		return this.agent.notify(acp.methods.agent.session.cancel, { sessionId: this.session.sessionId });
-	}
-	dispose() {
-		this.reusable = false;
-		this.session.dispose();
-	}
-	async invalidate() {
-		this.reusable = false;
-		this.session.dispose();
-		await this.sessionStore?.delete(this.sessionKey);
-	}
-	async prompt(text, onUpdate) {
-		const failure = this.session.prompt(text).then(() => new Promise(() => void 0), (error) => Promise.reject(error));
-		for (;;) {
-			const message = await Promise.race([this.session.nextUpdate(), failure]);
-			if (message.kind === "stop") return { stopReason: message.stopReason };
-			onUpdate(message.update);
-		}
-	}
-};
-var ResumedAcpSession = class {
-	processConnection;
-	sessionId;
-	updates = [];
-	waiters = [];
-	disposed = false;
-	failure;
-	constructor(processConnection, sessionId) {
-		this.processConnection = processConnection;
-		this.sessionId = sessionId;
-		processConnection.sessionUpdateHandlers.set(sessionId, (notification) => {
-			this.enqueue({
-				kind: "session_update",
-				update: notification.update
-			});
-		});
-	}
-	clearReplay() {
-		this.updates.splice(0);
-	}
-	dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		this.processConnection.sessionUpdateHandlers.delete(this.sessionId);
-		const error = /* @__PURE__ */ new Error(`ACP session ${this.sessionId} observer disposed`);
-		for (const waiter of this.waiters.splice(0)) waiter.reject(error);
-		this.updates.splice(0);
-	}
-	nextUpdate() {
-		if (this.updates.length > 0) return Promise.resolve(this.updates.shift());
-		if (this.failure !== void 0) return Promise.reject(this.failure);
-		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error(`ACP session ${this.sessionId} observer disposed`));
-		return new Promise((resolve, reject) => this.waiters.push({
-			reject,
-			resolve
-		}));
-	}
-	prompt(text) {
-		if (this.disposed) return Promise.reject(/* @__PURE__ */ new Error(`ACP session ${this.sessionId} observer disposed`));
-		const response = this.processConnection.connection.agent.request(acp.methods.agent.session.prompt, {
-			prompt: [{
-				text,
-				type: "text"
-			}],
-			sessionId: this.sessionId
-		});
-		response.then((result) => this.enqueue({
-			kind: "stop",
-			stopReason: result.stopReason
-		}), (error) => this.fail(error));
-		return response;
-	}
-	enqueue(message) {
-		if (this.disposed) return;
-		const waiter = this.waiters.shift();
-		if (waiter) waiter.resolve(message);
-		else this.updates.push(message);
-	}
-	fail(error) {
-		if (this.failure !== void 0 || this.disposed) return;
-		this.failure = error;
-		for (const waiter of this.waiters.splice(0)) waiter.reject(error);
-	}
-};
-var AcpSessionResumeUnavailable = class extends Error {
-	sessionId;
-	name = "AcpSessionResumeUnavailable";
-	constructor(sessionId) {
-		super(`ACP Agent cannot load or resume persisted session ${sessionId}`);
-		this.sessionId = sessionId;
-	}
-};
-var AcpSessionResumeFailed = class extends Error {
-	sessionId;
-	cause;
-	name = "AcpSessionResumeFailed";
-	constructor(sessionId, cause) {
-		super(`ACP Agent failed to restore persisted session ${sessionId}`);
-		this.sessionId = sessionId;
-		this.cause = cause;
-	}
-};
-async function openConnection(options, sessionKeys, onSpawn) {
-	const child = spawn(options.command, [...options.arguments ?? []], {
-		cwd: options.workingDirectory,
-		env: { ...options.environment },
-		stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		]
-	});
-	onSpawn(child);
-	child.stderr.setEncoding("utf8");
-	if (options.onStderr) child.stderr.on("data", options.onStderr);
-	else child.stderr.resume();
-	const sessionUpdateHandlers = /* @__PURE__ */ new Map();
-	const app = acp.client({ name: options.clientName ?? "rivus" }).onRequest(acp.methods.client.session.requestPermission, async ({ params }) => {
-		const sessionKey = sessionKeys.get(params.sessionId);
-		return { outcome: await decideAcpPermission(toPermissionRequest(params), sessionKey && options.permissionPolicy ? (request) => options.permissionPolicy?.(request, { sessionKey }) : void 0) };
-	}).onNotification(acp.methods.client.session.update, ({ params }) => {
-		sessionUpdateHandlers.get(params.sessionId)?.(params);
-	});
-	const stream = acp.ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
-	const connection = app.connect(stream);
-	try {
-		const initialized = await withTimeout(connection.agent.request(acp.methods.agent.initialize, {
-			clientCapabilities: {},
-			clientInfo: {
-				name: options.clientName ?? "rivus",
-				version: "1"
-			},
-			protocolVersion: acp.PROTOCOL_VERSION
-		}), options.initializationTimeoutMs ?? 1e4, "ACP initialization timed out");
-		if (initialized.protocolVersion !== acp.PROTOCOL_VERSION) throw new Error(`ACP protocol version ${initialized.protocolVersion} is not supported`);
-		return {
-			...initialized.agentCapabilities ? { agentCapabilities: initialized.agentCapabilities } : {},
-			child,
-			connection,
-			sessionUpdateHandlers,
-			sessions: /* @__PURE__ */ new Map()
-		};
-	} catch (error) {
-		connection.close(error);
-		await terminateChild(child, options.terminationTimeoutMs);
-		throw error;
-	}
-}
-function toPermissionRequest(request) {
-	return {
-		options: request.options,
-		sessionId: request.sessionId,
-		toolCall: {
-			...request.toolCall.rawInput === void 0 ? {} : { rawInput: request.toolCall.rawInput },
-			...request.toolCall.title == null ? {} : { title: request.toolCall.title },
-			toolCallId: request.toolCall.toolCallId
-		}
-	};
-}
-async function terminateChild(child, timeoutMs = 2e3) {
-	if (child.exitCode !== null || child.signalCode !== null) return;
-	child.kill("SIGTERM");
-	if (await waitForChildExit(child, timeoutMs)) return;
-	child.kill("SIGKILL");
-	if (!await waitForChildExit(child, timeoutMs)) throw new Error(`ACP child did not exit after SIGKILL within ${timeoutMs}ms`);
-}
-function waitForChildExit(child, timeoutMs) {
-	if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(true);
-	return new Promise((resolve) => {
-		const onExit = () => {
-			clearTimeout(timeout);
-			resolve(true);
-		};
-		const timeout = setTimeout(() => {
-			child.removeListener("exit", onExit);
-			resolve(false);
-		}, timeoutMs);
-		timeout.unref();
-		child.once("exit", onExit);
-	});
-}
-function withTimeout(promise, timeoutMs, message) {
-	return new Promise((resolve, reject) => {
-		const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`${message} after ${timeoutMs}ms`)), timeoutMs);
-		promise.then((value) => {
-			clearTimeout(timeout);
-			resolve(value);
-		}, (error) => {
-			clearTimeout(timeout);
-			reject(error);
-		});
-	});
-}
-//#endregion
-//#region src/adapters/compatibility/agent-execution/acp/acp-runtime.ts
-function createAcpAgentLoop(options) {
-	return fromEffectAgentLoop(createAcpAgentLoop$1({
-		...options.cancellationSettleTimeoutMs === void 0 ? {} : { cancellationSettleTimeoutMs: options.cancellationSettleTimeoutMs },
-		...options.disposeSessionAfterRun === void 0 ? {} : { disposeSessionAfterRun: options.disposeSessionAfterRun },
-		resolveSession: (input) => options.resolveSession(toCompatibilityAgentLoopInput(input))
-	}));
-}
-function createAcpAgentServer(options) {
-	return createAcpAgentServer$1({
-		...options.agentName === void 0 ? {} : { agentName: options.agentName },
-		loop: toEffectAgentLoop(options.loop),
-		...options.permissionBridge ? { permissionBridge: options.permissionBridge } : {},
-		workingDirectory: options.workingDirectory
-	});
-}
-function serveAcpAgentOnStdio(app) {
-	return serveAcpAgentOnStdio$1(app);
-}
-function createAcpStdioAgentLoop(options) {
-	const handle = createAcpStdioAgentLoop$1({
-		...options.arguments ? { arguments: options.arguments } : {},
-		...options.clientName === void 0 ? {} : { clientName: options.clientName },
-		command: options.command,
-		...options.environment ? { environment: options.environment } : {},
-		...options.initializationTimeoutMs === void 0 ? {} : { initializationTimeoutMs: options.initializationTimeoutMs },
-		...options.mcpServers ? { mcpServers: (input) => options.mcpServers(toCompatibilityAgentLoopInput(input)) } : {},
-		...options.onStderr ? { onStderr: options.onStderr } : {},
-		...options.permissionPolicy ? { permissionPolicy: options.permissionPolicy } : {},
-		...options.sessionStore ? { sessionStore: options.sessionStore } : {},
-		...options.terminationTimeoutMs === void 0 ? {} : { terminationTimeoutMs: options.terminationTimeoutMs },
-		workingDirectory: options.workingDirectory
-	});
-	return {
-		dispose: () => handle.dispose(),
-		loop: fromEffectAgentLoop(handle.loop)
-	};
-}
-//#endregion
-//#region src/adapters/acp/runtime/acp-permission-bridge.ts
-function createAcpPermissionBridge() {
-	const policies = /* @__PURE__ */ new Map();
-	return {
-		bind: (sessionKey, policy) => {
-			if (policies.has(sessionKey)) throw new Error(`ACP permission bridge is already bound: ${sessionKey}`);
-			policies.set(sessionKey, policy);
-			return () => {
-				if (policies.get(sessionKey) === policy) policies.delete(sessionKey);
-			};
-		},
-		policy: async (request, context) => policies.get(context.sessionKey)?.(request)
-	};
-}
-//#endregion
-//#region src/adapters/acp/runtime/acp-session-store.ts
-/**
-* A small deployment-owned store for ACP provider session identities.
-* The file contains no prompts or credentials, only session-key bindings.
-*/
-function createJsonAcpSessionStore(options) {
-	let recordsPromise;
-	let writeChain = Promise.resolve();
-	const readRecords = async () => {
-		try {
-			const raw = await readFile(options.filePath, "utf8");
-			const parsed = JSON.parse(raw);
-			if (!isRecord(parsed)) throw new Error("ACP session store must contain an object");
-			const records = /* @__PURE__ */ new Map();
-			for (const [sessionKey, value] of Object.entries(parsed)) {
-				if (!isRecord(value) || typeof value.sessionId !== "string" || value.sessionId.trim() === "") throw new Error(`invalid ACP session record for ${sessionKey}`);
-				records.set(sessionKey, { sessionId: value.sessionId });
-			}
-			return records;
-		} catch (error) {
-			if (isMissingFile(error)) return /* @__PURE__ */ new Map();
-			throw error;
-		}
-	};
-	const records = async () => {
-		recordsPromise ??= readRecords();
-		return recordsPromise;
-	};
-	const persist = async (value) => {
-		const temporaryPath = `${options.filePath}.tmp-${process.pid}-${Date.now()}`;
-		await mkdir(dirname(options.filePath), { recursive: true });
-		await writeFile(temporaryPath, `${JSON.stringify(Object.fromEntries(value), null, 2)}\n`, "utf8");
-		await rename(temporaryPath, options.filePath);
-	};
-	return {
-		delete: async (sessionKey) => {
-			writeChain = writeChain.then(async () => {
-				const current = await records();
-				if (!current.delete(sessionKey)) return;
-				await persist(current);
-			});
-			await writeChain;
-		},
-		load: async (sessionKey) => (await records()).get(sessionKey),
-		save: async (sessionKey, record) => {
-			writeChain = writeChain.then(async () => {
-				const current = await records();
-				current.set(sessionKey, { sessionId: record.sessionId });
-				await persist(current);
-			});
-			await writeChain;
-		}
-	};
-}
-function isMissingFile(error) {
-	return isRecord(error) && error.code === "ENOENT";
-}
-function isRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-//#endregion
+import { AcpSessionResumeFailed, AcpSessionResumeUnavailable, createAcpPermissionBridge, createJsonAcpSessionStore, createLegacyAcpAgentLoop as createAcpAgentLoop, createLegacyAcpAgentServer as createAcpAgentServer, createLegacyAcpStdioAgentLoop as createAcpStdioAgentLoop, decideAcpPermission, serveLegacyAcpAgentOnStdio as serveAcpAgentOnStdio } from "@rivus/runtime/acp";
 export { AcpSessionResumeFailed, AcpSessionResumeUnavailable, createAcpAgentLoop, createAcpAgentServer, createAcpPermissionBridge, createAcpStdioAgentLoop, createJsonAcpSessionStore, decideAcpPermission, serveAcpAgentOnStdio };