@agimon-ai/po-core 0.0.0-alpha.0

package/dist/src/pi/piSessionRuntime.cjs

@@ -0,0 +1,625 @@
+const require_index = require("../services/transcriptPages/index.cjs");
+const require_sessionProtocol = require("../schemas/sessionProtocol.cjs");
+const require_serverTelemetry = require("../../serverTelemetry.cjs");
+require("../../sessionProtocol.cjs");
+const require_index$1 = require("../services/acpSessionUpdates/index.cjs");
+const require_index$2 = require("../services/rpcTranscript/index.cjs");
+const require_index$3 = require("../services/sessionPresentation/index.cjs");
+let _earendil_works_chord_context = require("@earendil-works/chord/context");
+let _earendil_works_chord = require("@earendil-works/chord");
+let _earendil_works_pi_server = require("@earendil-works/pi-server");
+//#region src/pi/piSessionRuntime.ts
+const SETTLED = "agent_settled";
+const PROMPT_LATENCY_EVENT = "po_server.prompt_latency";
+const SELECTION_COMMANDS = /* @__PURE__ */ new Set([
+	"mode",
+	"domains",
+	"profile",
+	"minor"
+]);
+function isSelectionCommand(text) {
+	const match = /^\/(\S+)/.exec(text);
+	return match !== null && SELECTION_COMMANDS.has(match[1]);
+}
+async function sessionStats(runtime, sessionId) {
+	const stored = await runtime.getSessionStats();
+	const { contextUsage, sessionFile } = stored;
+	return {
+		sessionId,
+		...sessionFile === void 0 ? {} : { sessionFile },
+		totalMessages: stored.messageCount,
+		tokens: {
+			input: stored.usage.input,
+			output: stored.usage.output,
+			cacheRead: stored.usage.cacheRead,
+			cacheWrite: stored.usage.cacheWrite,
+			total: stored.usage.totalTokens
+		},
+		cost: stored.usage.cost.total,
+		...contextUsage === void 0 ? {} : { contextUsage }
+	};
+}
+/** Projects one in-process harness runtime as a Chord session service. */
+function createAgentSessionRuntime(options) {
+	const transcript = options.transcript ?? require_index$2.createRpcTranscript({
+		id: options.sessionId,
+		cwd: options.cwd,
+		name: options.sessionName,
+		now: Date.now,
+		retainEntries: 0
+	});
+	const presentation = require_index$3.createSessionPresentation();
+	const acpUpdates = require_index$1.createAcpSessionUpdateProjection();
+	let updateSequence = 0;
+	const inFlight = /* @__PURE__ */ new Map();
+	let historyGeneration = 0;
+	const summary = (snapshot) => {
+		const { transcript: _history, ...value } = snapshot;
+		return value;
+	};
+	const state = (0, _earendil_works_chord.replicatedState)({
+		snapshot: {
+			...summary(transcript.snapshot()),
+			fastMode: false
+		},
+		progress: null,
+		updates: [],
+		presentation: {
+			revision: 0,
+			dropped: 0,
+			events: [],
+			projections: []
+		}
+	});
+	options.runtime.readState().then((runtimeState) => {
+		if (!disposed) state.change(_earendil_works_chord_context.BACKGROUND_CONTEXT, (draft) => {
+			draft.snapshot.fastMode = runtimeState.fastMode === true;
+			draft.snapshot.locked = runtimeState.agentLocked === true;
+		});
+	}).catch((error) => {
+		if (!disposed) present({
+			type: "error",
+			error: String(error)
+		});
+	});
+	const present = (frame) => {
+		if (frame.type === "fast_mode_changed" && typeof frame.enabled === "boolean") state.change(_earendil_works_chord_context.BACKGROUND_CONTEXT, (draft) => {
+			draft.snapshot.fastMode = frame.enabled;
+		});
+		if (frame.type === "agent_lock_changed" && typeof frame.locked === "boolean") state.change(_earendil_works_chord_context.BACKGROUND_CONTEXT, (draft) => {
+			draft.snapshot.locked = frame.locked;
+		});
+		const entry = frame.entry;
+		if (frame.type === "entry_appended" && typeof entry?.seq === "number") frame = {
+			...frame,
+			transcriptCursor: require_index.transcriptCursor(options.sessionId, options.runtime.laneName, historyGeneration, entry.seq)
+		};
+		const next = presentation.record(frame);
+		if (next) state.change(_earendil_works_chord_context.BACKGROUND_CONTEXT, (draft) => {
+			draft.presentation = next;
+		});
+		return next !== void 0;
+	};
+	const settlers = /* @__PURE__ */ new Set();
+	const promptFailures = /* @__PURE__ */ new Set();
+	let promptLatency;
+	let lastToolResultAt;
+	let assistantMessageStartedAt;
+	let disposed = false;
+	const reportPromptLatency = (phase) => {
+		const active = promptLatency;
+		if (active === void 0 || active.reported.has(phase) || options.telemetry === void 0) return;
+		const now = Date.now();
+		active.reported.add(phase);
+		require_serverTelemetry.observe(options.telemetry.recordEvent(PROMPT_LATENCY_EVENT, {
+			session_id: options.sessionId,
+			phase,
+			duration_ms: now - active.startedAt,
+			stage_duration_ms: now - active.lastStageAt
+		}));
+		active.lastStageAt = now;
+	};
+	const rejectSettlers = (error) => {
+		for (const waiter of settlers) waiter.reject(error);
+		settlers.clear();
+	};
+	const unsubscribePresentation = (options.onPresentationFrame ?? ((listener) => options.runtime.onPresentationFrame(listener)))((frame) => {
+		if (disposed) return;
+		const message = typeof frame.message === "object" && frame.message !== null ? frame.message : void 0;
+		if (frame.type === "message_end" && message?.role === "toolResult") lastToolResultAt = Date.now();
+		if (frame.type === "message_start" && message?.role === "assistant") {
+			const now = Date.now();
+			assistantMessageStartedAt = now;
+			if (lastToolResultAt !== void 0 && options.telemetry) require_serverTelemetry.observe(options.telemetry.recordEvent("po_server.tool_result_to_response", {
+				session_id: options.sessionId,
+				duration_ms: now - lastToolResultAt
+			}));
+			lastToolResultAt = void 0;
+		}
+		if (frame.type === "message_end" && message?.role === "assistant") {
+			if (assistantMessageStartedAt !== void 0 && options.telemetry) require_serverTelemetry.observe(options.telemetry.recordEvent("po_server.assistant_message", {
+				session_id: options.sessionId,
+				duration_ms: Date.now() - assistantMessageStartedAt
+			}));
+			assistantMessageStartedAt = void 0;
+		}
+		if (frame.type === "agent_start") reportPromptLatency("agent_started");
+		else if (frame.type === "message_start" && message?.role === "assistant") reportPromptLatency("response_started");
+		else if (frame.type === "message_update" && message?.role === "assistant") reportPromptLatency("first_response");
+		else if (frame.type === "message_end" && message?.role === "assistant") reportPromptLatency("response_completed");
+		const reductionStartedAt = performance.now();
+		const reduction = transcript.apply(frame);
+		if (frame.type === "lifecycle_update" && frame.lifecycle !== void 0) state.change(_earendil_works_chord_context.BACKGROUND_CONTEXT, (draft) => {
+			const lifecycle = frame.lifecycle;
+			if ((draft.snapshot.lifecycle?.revision ?? -1) <= lifecycle.revision) draft.snapshot.lifecycle = lifecycle;
+		});
+		const updates = acpUpdates.apply(frame, reduction);
+		const reductionDurationMs = performance.now() - reductionStartedAt;
+		if (reduction.aggregate && options.telemetry) require_serverTelemetry.observe(options.telemetry.recordEvent("po_server.transcript.aggregate", {
+			session_id: options.sessionId,
+			...reduction.aggregate
+		}));
+		if (reduction.snapshot || updates.length > 0) state.change(_earendil_works_chord_context.BACKGROUND_CONTEXT, (draft) => {
+			if (reduction.snapshot) draft.snapshot = {
+				...summary(reduction.snapshot),
+				fastMode: draft.snapshot.fastMode ?? false,
+				locked: draft.snapshot.locked ?? false,
+				...draft.snapshot.lifecycle === void 0 ? {} : { lifecycle: draft.snapshot.lifecycle }
+			};
+			if (updates.length > 0) {
+				const events = draft.updates ?? [];
+				for (const update of updates) events.push({
+					sequence: ++updateSequence,
+					update
+				});
+				if (events.length > 128) events.splice(0, events.length - 128);
+				draft.updates = events;
+			}
+		});
+		if (reduction.progress) {
+			const progress = reduction.progress;
+			if (progress.type === "item_finished") inFlight.delete(progress.item.id);
+			else inFlight.set(progress.item.id, progress.item);
+		}
+		if (state.value.snapshot.phase === "idle") inFlight.clear();
+		if (frame.type === "navigation_end") historyGeneration += 1;
+		present(frame);
+		const publishStartedAt = performance.now();
+		reduction.snapshot || reduction.progress || updates.length;
+		const publishDurationMs = performance.now() - publishStartedAt;
+		if (options.telemetry && (reductionDurationMs >= 50 || publishDurationMs >= 50 || frame.type === SETTLED)) require_serverTelemetry.observe(options.telemetry.recordEvent("po_server.presentation_frame", {
+			session_id: options.sessionId,
+			"frame.type": frame.type,
+			phase: "reduce_and_publish",
+			duration_ms: reductionDurationMs + publishDurationMs
+		}));
+		if (frame.type === SETTLED) {
+			lastToolResultAt = void 0;
+			assistantMessageStartedAt = void 0;
+			reportPromptLatency("settled");
+			promptLatency = void 0;
+			const waiting = [...settlers];
+			settlers.clear();
+			for (const settle of waiting) settle.resolve();
+		}
+	});
+	const terminate = (error) => {
+		if (disposed) return;
+		disposed = true;
+		for (const fail of promptFailures) fail(error);
+		promptFailures.clear();
+		rejectSettlers(error);
+		unsubscribePresentation();
+	};
+	require_serverTelemetry.observe(options.runtime.exited.then(() => terminate(/* @__PURE__ */ new Error("The session runtime exited")), (error) => terminate(error instanceof Error ? error : new Error(String(error)))));
+	const requireLive = () => {
+		if (disposed) throw new Error("The session runtime is disposed");
+	};
+	const guardContext = (context) => {
+		requireLive();
+		context.abortSignal?.throwIfAborted();
+	};
+	const awaitSettled = () => {
+		let fail;
+		let finish;
+		const promise = new Promise((resolve, reject) => {
+			const waiter = {
+				resolve: () => {
+					settlers.delete(waiter);
+					resolve();
+				},
+				reject: (error) => {
+					settlers.delete(waiter);
+					reject(error);
+				}
+			};
+			fail = waiter.reject;
+			finish = waiter.resolve;
+			settlers.add(waiter);
+		});
+		require_serverTelemetry.observe(promise);
+		return {
+			promise,
+			resolve: finish,
+			reject: fail
+		};
+	};
+	const messageArgs = (input) => {
+		const args = typeof input === "string" ? { text: input } : input;
+		if (!args || typeof args.text !== "string") throw new Error("Prompt message must be a string");
+		if (args.images !== void 0 && (!Array.isArray(args.images) || !args.images.every((image) => image?.type === "image" && typeof image.data === "string" && typeof image.mimeType === "string"))) throw new Error("Invalid message images");
+		return {
+			message: args.text,
+			...args.images === void 0 ? {} : { images: args.images }
+		};
+	};
+	const hydrate = async () => {
+		const lifecycle = await options.runtime.readLifecycle();
+		if (disposed) return;
+		state.change(_earendil_works_chord_context.BACKGROUND_CONTEXT, (draft) => {
+			if ((draft.snapshot.lifecycle?.revision ?? -1) <= lifecycle.revision) draft.snapshot.lifecycle = lifecycle;
+			draft.presentation = presentation.resetCustomEntries();
+		});
+	};
+	let initializing;
+	return {
+		state,
+		async readTranscriptPage(args, context) {
+			guardContext(context);
+			if (args.threadId !== void 0) {
+				if (!options.readThreadTranscript) throw new Error("Child transcript reader is unavailable");
+				return options.readThreadTranscript(args.threadId, args, context);
+			}
+			const generation = historyGeneration;
+			const revision = state.value.presentation?.revision ?? 0;
+			const drafts = [...inFlight.values()];
+			const started = performance.now();
+			let snapshot;
+			const readEntries = () => snapshot ??= options.runtime.readEntries();
+			const page = await require_index.readTranscriptPage({
+				sessionId: options.runtime.sessionId,
+				laneName: options.runtime.laneName,
+				lane: {
+					getTipId: async () => (await readEntries()).leafId,
+					findEntries: async (query) => {
+						let entries = (await readEntries()).entries;
+						if (query.type) entries = entries.filter((e) => e.type === query.type);
+						if (query.customType) entries = entries.filter((e) => e.type === "custom" && e.customType === query.customType);
+						if (query.cursor) entries = entries.filter((e) => query.order === "oldestFirst" ? e.seq > query.cursor.seq : e.seq < query.cursor.seq);
+						if (query.order === "newestFirst") entries = entries.toReversed();
+						return query.limit === void 0 ? entries : entries.slice(0, query.limit);
+					}
+				}
+			}, args, generation, context);
+			if (options.telemetry) require_serverTelemetry.observe(options.telemetry.recordEvent("po_server.transcript_page", {
+				session_id: options.sessionId,
+				phase: args.direction ?? "latest",
+				duration_ms: performance.now() - started,
+				count: page.entries.length
+			}));
+			if (generation !== historyGeneration) throw new Error("STALE_TRANSCRIPT_CURSOR");
+			return {
+				...page,
+				revision,
+				drafts
+			};
+		},
+		initialize() {
+			initializing ??= hydrate().catch((error) => {
+				initializing = void 0;
+				throw error;
+			});
+			return initializing;
+		},
+		async prompt(text, context) {
+			guardContext(context);
+			const args = messageArgs(text);
+			const waitFor = typeof text === "string" ? "settled" : text.waitFor ?? "settled";
+			if (waitFor !== "accepted" && waitFor !== "settled") throw new Error("Invalid prompt acknowledgement mode");
+			let projection;
+			let latency;
+			let submitted = false;
+			let failed;
+			let rejectFailure;
+			const failure = new Promise((_resolve, reject) => {
+				rejectFailure = reject;
+			});
+			const fail = (error) => {
+				if (failed !== void 0) return;
+				failed = error;
+				projection?.reject(error);
+				rejectFailure(error);
+				if (latency !== void 0 && promptLatency === latency) {
+					reportPromptLatency("failed");
+					promptLatency = void 0;
+				}
+			};
+			const cancel = () => {
+				if (failed !== void 0) return;
+				fail(new Error("The session prompt was cancelled", { cause: context.abortSignal?.reason }));
+				if (submitted && waitFor === "settled") options.runtime.abort().catch(() => void 0);
+			};
+			const guardPrompt = () => {
+				if (failed !== void 0) throw failed;
+				guardContext(context);
+			};
+			const submit = async () => {
+				guardPrompt();
+				submitted = true;
+				const submission = await options.runtime.submitPrompt(args.message, args.images, "steer");
+				require_serverTelemetry.observe(submission.settled);
+				guardPrompt();
+				return submission;
+			};
+			const span = (name, callback) => {
+				const operation = options.telemetry ? options.telemetry.runInSpan(name, { session_id: options.sessionId }, callback) : callback();
+				require_serverTelemetry.observe(operation);
+				return operation;
+			};
+			const run = async () => {
+				guardPrompt();
+				const lifecycle = await options.runtime.readLifecycle();
+				guardPrompt();
+				if (lifecycle.operation !== null || settlers.size > 0) {
+					if (isSelectionCommand(args.message)) {
+						const handled = await options.runtime.dispatchCommand(args.message);
+						guardPrompt();
+						if (handled) return;
+					}
+				}
+				if (waitFor === "accepted" && !options.telemetry) {
+					await submit();
+					return;
+				}
+				const startedAt = Date.now();
+				if (promptLatency === void 0) latency = promptLatency = {
+					startedAt,
+					lastStageAt: startedAt,
+					reported: /* @__PURE__ */ new Set()
+				};
+				const settled = projection = awaitSettled();
+				let resolveAdmission;
+				const admitted = waitFor === "accepted" ? new Promise((resolve) => {
+					resolveAdmission = resolve;
+				}) : void 0;
+				const completion = span("po_server.prompt_to_settled", async () => {
+					const submission = await span("po_server.prompt_admission", submit);
+					guardPrompt();
+					if (submission.handledCommand) settled.resolve();
+					if (latency !== void 0 && promptLatency === latency) reportPromptLatency("accepted");
+					resolveAdmission?.();
+					await Promise.all([span("po_server.prompt_engine_settlement", () => submission.settled), span("po_server.prompt_projection_settlement", () => settled.promise)]);
+				}).catch((error) => {
+					const cause = error instanceof Error ? error : new Error(String(error));
+					fail(cause);
+					throw cause;
+				});
+				if (admitted) await Promise.race([admitted, completion]);
+				else await completion;
+			};
+			promptFailures.add(fail);
+			context.abortSignal?.addEventListener("abort", cancel, { once: true });
+			try {
+				await Promise.race([run(), failure]);
+			} catch (error) {
+				const cause = error instanceof Error ? error : new Error(String(error));
+				fail(cause);
+				throw cause;
+			} finally {
+				promptFailures.delete(fail);
+				context.abortSignal?.removeEventListener("abort", cancel);
+			}
+		},
+		async steer(text) {
+			requireLive();
+			const args = messageArgs(text);
+			await options.runtime.steer(args.message, args.images);
+		},
+		async abort() {
+			requireLive();
+			await options.runtime.abort((await options.runtime.readLifecycle()).operation?.id);
+		},
+		async abortOperation(args) {
+			requireLive();
+			if (!args || typeof args.operationId !== "string" || !args.operationId) throw new Error("Invalid operation identity");
+			await options.runtime.abort(args.operationId);
+		},
+		async setModel(model, context) {
+			guardContext(context);
+			if (!model || typeof model.provider !== "string" || typeof model.id !== "string") throw new Error("Invalid model");
+			await options.runtime.setModel(model);
+		},
+		async setFastMode(enabled, context) {
+			guardContext(context);
+			if (typeof enabled !== "boolean") throw new Error("Invalid fast mode");
+			await options.runtime.setFastMode(enabled);
+			state.change(context, (draft) => {
+				draft.snapshot.fastMode = enabled;
+			});
+		},
+		async setAgentLock(locked, context) {
+			guardContext(context);
+			if (typeof locked !== "boolean") throw new Error("Invalid agent lock");
+			await options.runtime.setAgentLock(locked);
+			state.change(context, (draft) => {
+				draft.snapshot.locked = locked;
+			});
+		},
+		async setThinking(thinkingLevel, context) {
+			guardContext(context);
+			if (![
+				"off",
+				"minimal",
+				"low",
+				"medium",
+				"high",
+				"xhigh",
+				"max"
+			].includes(thinkingLevel)) throw new Error("Invalid thinking level");
+			await options.runtime.setThinkingLevel(thinkingLevel);
+		},
+		async followUp(args, context) {
+			guardContext(context);
+			const message = messageArgs(args);
+			await options.runtime.followUp(message.message, message.images);
+		},
+		async enqueueAutomatic(args, context) {
+			guardContext(context);
+			const message = messageArgs(args);
+			return options.runtime.enqueueAutomatic(message.message, message.images);
+		},
+		async removeQueued(args, context) {
+			guardContext(context);
+			if (!args || typeof args.id !== "string" || !args.id) throw new Error("Invalid queue identity");
+			return options.runtime.removeQueued(args.id);
+		},
+		async promoteQueued(args, context) {
+			guardContext(context);
+			if (!args || typeof args.id !== "string" || !args.id || args.operationId !== void 0 && (typeof args.operationId !== "string" || !args.operationId)) throw new Error("Invalid queue promotion");
+			return options.runtime.promoteQueued(args.id, args.operationId);
+		},
+		async resumeQueue(context) {
+			guardContext(context);
+			await options.runtime.resumeQueue();
+		},
+		async clearQueue(context) {
+			guardContext(context);
+			return options.runtime.clearQueue();
+		},
+		async rewind(args, context) {
+			guardContext(context);
+			if (!args || typeof args.itemId !== "string" || !args.itemId) throw new Error("Invalid rewind identity");
+			const { entries } = await options.runtime.readEntries();
+			const entry = entries.toReversed().find((candidate) => {
+				if (candidate.type !== "message" || typeof candidate.id !== "string") return false;
+				const message = candidate.message;
+				if (!message || typeof message !== "object" || Array.isArray(message)) return false;
+				const record = message;
+				return candidate.id === args.itemId || record.id === args.itemId || record.role === "user" && typeof record.timestamp === "number" && args.itemId === `user-${record.timestamp}`;
+			});
+			if (!entry) throw new Error("The selected message is not in the active session tree.");
+			const result = await options.runtime.navigateTree(entry.id, {
+				...args.summarize === void 0 ? {} : { summarize: args.summarize },
+				...args.customInstructions === void 0 ? {} : { customInstructions: args.customInstructions },
+				...args.replaceInstructions === void 0 ? {} : { replaceInstructions: args.replaceInstructions },
+				...args.label === void 0 ? {} : { label: args.label }
+			});
+			if (!result.cancelled) await hydrate();
+			return result;
+		},
+		async extensionUiResponse(response, context) {
+			guardContext(context);
+			if (!response || typeof response.id !== "string" || !response.id || !("value" in response && typeof response.value === "string" || "confirmed" in response && typeof response.confirmed === "boolean" || "cancelled" in response && response.cancelled === true)) throw new Error("Invalid extension UI response");
+			if (!options.respondToExtensionUi?.({
+				...response,
+				type: "extension_ui_response"
+			})) throw new Error(`No pending extension UI request: ${response.id}`);
+			present({
+				type: "extension_ui_answered",
+				id: response.id
+			});
+			state.change(context, () => void 0);
+		},
+		async getState(context) {
+			guardContext(context);
+			const runtimeState = await options.runtime.readState();
+			return {
+				...runtimeState,
+				fastMode: runtimeState.fastMode === true
+			};
+		},
+		async getSessionStats(context) {
+			guardContext(context);
+			return sessionStats(options.runtime, options.sessionId);
+		},
+		async getCommands(context) {
+			guardContext(context);
+			return options.runtime.listCommands();
+		},
+		async getAvailableModels(context) {
+			guardContext(context);
+			return (await options.runtime.availableModels()).map((model) => ({
+				provider: model.provider,
+				id: model.id
+			}));
+		},
+		async getAvailableThinkingLevels(context) {
+			guardContext(context);
+			return await options.runtime.availableThinkingLevels();
+		},
+		async compact(args, context) {
+			guardContext(context);
+			await options.runtime.compact(args.customInstructions);
+			return null;
+		},
+		async setName(name, context) {
+			guardContext(context);
+			if (typeof name !== "string" || name.length > 256) throw new Error("Invalid session name");
+			await options.runtime.setName(name);
+		},
+		async dispose() {
+			terminate(/* @__PURE__ */ new Error("The session runtime is disposed"));
+		}
+	};
+}
+function endpointAttachment(endpoint) {
+	return {
+		invokeService: (call, publish, context) => endpoint.invoke(call, publish, context),
+		release: () => endpoint.dispose()
+	};
+}
+function managementHost() {
+	return { attachClient(presentation) {
+		const provider = new _earendil_works_chord.RemoteServiceProvider([{
+			service: require_sessionProtocol.DoomSessionManagementService,
+			mode: "singleton"
+		}]);
+		provider.provide(require_sessionProtocol.DoomSessionManagementService, {
+			attach: (sessionId, context) => presentation.attachSession(sessionId, context),
+			detach: (context) => presentation.detachSession(context)
+		});
+		return endpointAttachment((0, _earendil_works_chord.createRemoteServiceEndpoint)(provider));
+	} };
+}
+/** Creates the 0.85 routed host for one supervised Po session. */
+function createAgentServerService(options) {
+	const metadata = {
+		id: options.sessionId,
+		createdAt: options.createdAt,
+		storageVersion: 1,
+		cwd: options.cwd,
+		sessionName: options.sessionName
+	};
+	const runtime = createAgentSessionRuntime(options);
+	let closed = false;
+	return {
+		serverServices: managementHost(),
+		async resolveSession(sessionId) {
+			if (sessionId !== metadata.id) throw new _earendil_works_pi_server.SessionNotFoundError(`No session ${sessionId}`);
+			return metadata;
+		},
+		async openSession() {
+			if (closed) throw new _earendil_works_pi_server.SessionNotFoundError("The session service is closed");
+			await runtime.initialize();
+			const provider = new _earendil_works_chord.RemoteServiceProvider([{
+				service: require_sessionProtocol.DoomSessionService,
+				mode: "singleton"
+			}]);
+			provider.provide(require_sessionProtocol.DoomSessionService, runtime);
+			return {
+				attachClient: () => endpointAttachment((0, _earendil_works_chord.createRemoteServiceEndpoint)(provider)),
+				async close() {
+					if (closed) return;
+					closed = true;
+					provider.dispose();
+					await runtime.dispose();
+				}
+			};
+		}
+	};
+}
+//#endregion
+exports.createAgentServerService = createAgentServerService;
+exports.createAgentSessionRuntime = createAgentSessionRuntime;
+
+//# sourceMappingURL=piSessionRuntime.cjs.map