@agimon-ai/doompi-core 0.0.1-alpha.100

package/dist/src/pi/piSessionRuntime.d.mts

@@ -0,0 +1,43 @@
+import { SessionService, SessionServiceState, SessionSnapshot, TranscriptPage, TranscriptPageRequest } from "../schemas/sessionProtocol.mjs";
+import "../../sessionProtocol.mjs";
+import { DirectHarnessFrame, DirectHarnessRuntime } from "../types/server/directHarnessRuntime.mjs";
+import { ServerTelemetry } from "../../serverTelemetry.mjs";
+import { RpcTranscript } from "../services/rpcTranscript/index.mjs";
+import { Context, MutableReplicatedState } from "@earendil-works/chord";
+import { ServerHost } from "@earendil-works/pi-server";
+//#region src/pi/piSessionRuntime.d.ts
+export interface AgentSessionRuntimeOptions {
+  runtime: DirectHarnessRuntime;
+  sessionId: string;
+  sessionName: string;
+  cwd: string;
+  telemetry?: ServerTelemetry;
+  /** Subscribes to the combined harness and headless presentation projection. */
+  onPresentationFrame?: (listener: (frame: DirectHarnessFrame) => void) => () => void;
+  /** Delivers one answered extension UI request to the session-scoped headless host. */
+  respondToExtensionUi?: (frame: DirectHarnessFrame) => boolean;
+  /** Test seam for the projection. */
+  transcript?: RpcTranscript;
+  readThreadTranscript?: (threadId: string, request: TranscriptPageRequest, context: Context) => Promise<TranscriptPage>;
+}
+export interface AgentSessionRuntime extends SessionService {
+  readonly state: MutableReplicatedState<SessionServiceState>;
+  initialize(): Promise<void>;
+  dispose(): Promise<void>;
+}
+/** Projects one in-process harness runtime as a Chord session service. */
+export declare function createAgentSessionRuntime(options: AgentSessionRuntimeOptions): AgentSessionRuntime;
+export interface AgentServerServiceOptions extends AgentSessionRuntimeOptions {
+  createdAt: number;
+}
+export interface DoomSessionMetadata {
+  id: string;
+  createdAt: number;
+  storageVersion: number;
+  cwd: string;
+  sessionName: string;
+}
+/** Creates the 0.85 routed host for one supervised DoomPi session. */
+export declare function createAgentServerService(options: AgentServerServiceOptions): ServerHost<DoomSessionMetadata>;
+//#endregion
+//# sourceMappingURL=piSessionRuntime.d.mts.map

package/dist/src/pi/piSessionRuntime.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"piSessionRuntime.d.mts","names":[],"sources":["../../../src/pi/piSessionRuntime.ts"],"mappings":";;;;;;;;iBA2FiB;EACf,SAAS;EACT;EACA;EACA;EACA,YAAY;;EAEZ,uBAAuB,WAAW,OAAO;;EAEzC,wBAAwB,OAAO;;EAE/B,aAAa;EACb,wBACE,kBACA,SAAS,uBACT,SAAS,YACN,QAAQ;;iBAGE,4BAA4B;WAClC,OAAO,uBAAuB;EACvC,cAAc;EACd,WAAW;;;wBAIG,0BAA0B,SAAS,6BAA6B;iBAwgB/D,kCAAkC;EACjD;;iBAGe;EACf;EACA;EACA;EACA;EACA;;;wBA2Bc,yBAAyB,SAAS,4BAA4B,WAAW"}

package/dist/src/pi/piSessionRuntime.mjs

@@ -0,0 +1,571 @@
+import { readTranscriptPage, transcriptCursor } from "../services/transcriptPages/index.mjs";
+import { DoomSessionManagementService, DoomSessionService } from "../schemas/sessionProtocol.mjs";
+import { contextTokensOf, contextUsageOf, latestAssistantUsage } from "../services/contextUsage/index.mjs";
+import "../../sessionProtocol.mjs";
+import { createAcpSessionUpdateProjection } from "../services/acpSessionUpdates/index.mjs";
+import { createRpcTranscript } from "../services/rpcTranscript/index.mjs";
+import { observe } from "../../serverTelemetry.mjs";
+import { createSessionPresentation } from "../services/sessionPresentation/index.mjs";
+import { RemoteServiceProvider, createRemoteServiceEndpoint, replicatedState } from "@earendil-works/chord";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { SessionNotFoundError } from "@earendil-works/pi-server";
+//#region src/pi/piSessionRuntime.ts
+const SETTLED = "agent_settled";
+const PROMPT_LATENCY_EVENT = "doompi_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, state, models] = await Promise.all([
+		runtime.getSessionStats(),
+		runtime.readState(),
+		runtime.availableModels()
+	]);
+	const recent = await runtime.lane.findEntries({
+		type: "message",
+		order: "newestFirst",
+		limit: 100
+	}, BACKGROUND_CONTEXT);
+	const contextTokens = contextTokensOf(latestAssistantUsage([...recent].reverse()));
+	const selected = typeof state.model === "object" && state.model !== null ? state.model : void 0;
+	const model = models.find((candidate) => candidate.provider === selected?.provider && candidate.id === selected?.id);
+	const contextUsage = contextUsageOf(contextTokens, model?.contextWindow);
+	const sessionFile = typeof state.sessionFile === "string" ? state.sessionFile : void 0;
+	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 ?? createRpcTranscript({
+		id: options.sessionId,
+		cwd: options.cwd,
+		name: options.sessionName,
+		now: Date.now,
+		retainEntries: 0
+	});
+	const presentation = createSessionPresentation();
+	const acpUpdates = createAcpSessionUpdateProjection();
+	let updateSequence = 0;
+	const inFlight = /* @__PURE__ */ new Map();
+	let historyGeneration = 0;
+	const summary = (snapshot) => {
+		const { transcript: _history, ...value } = snapshot;
+		return value;
+	};
+	const state = replicatedState({
+		snapshot: summary(transcript.snapshot()),
+		progress: null,
+		updates: [],
+		presentation: {
+			revision: 0,
+			dropped: 0,
+			events: [],
+			projections: []
+		}
+	});
+	const present = (frame) => {
+		const entry = frame.entry;
+		if (frame.type === "entry_appended" && typeof entry?.seq === "number") frame = {
+			...frame,
+			transcriptCursor: transcriptCursor(options.sessionId, options.runtime.laneName, historyGeneration, entry.seq)
+		};
+		const next = presentation.record(frame);
+		if (next) state.change(BACKGROUND_CONTEXT, (draft) => {
+			draft.presentation = next;
+		});
+		return next !== void 0;
+	};
+	const settlers = /* @__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);
+		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();
+	};
+	options.runtime.exited.then(() => {
+		disposed = true;
+		rejectSettlers(/* @__PURE__ */ new Error("The session runtime exited"));
+	}, (error) => {
+		disposed = true;
+		rejectSettlers(error instanceof Error ? error : new Error(String(error)));
+	});
+	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) observe(options.telemetry.recordEvent("doompi_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) observe(options.telemetry.recordEvent("doompi_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(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) observe(options.telemetry.recordEvent("doompi_server.transcript.aggregate", {
+			session_id: options.sessionId,
+			...reduction.aggregate
+		}));
+		if (reduction.snapshot || updates.length > 0) state.change(BACKGROUND_CONTEXT, (draft) => {
+			if (reduction.snapshot) draft.snapshot = {
+				...summary(reduction.snapshot),
+				...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)) observe(options.telemetry.recordEvent("doompi_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 requireLive = () => {
+		if (disposed) throw new Error("The session runtime is disposed");
+	};
+	const guardContext = (context) => {
+		requireLive();
+		context.abortSignal?.throwIfAborted();
+	};
+	const awaitSettled = (context) => {
+		let fail;
+		let finish;
+		return {
+			promise: new Promise((resolve, reject) => {
+				const cleanup = () => {
+					settlers.delete(waiter);
+					context.abortSignal?.removeEventListener("abort", cancel);
+				};
+				const waiter = {
+					resolve: () => {
+						cleanup();
+						resolve();
+					},
+					reject: (error) => {
+						cleanup();
+						reject(error);
+					}
+				};
+				const cancel = () => {
+					waiter.reject(new Error("The session prompt was cancelled", { cause: context.abortSignal?.reason }));
+					options.runtime.abort().catch(() => void 0);
+				};
+				fail = waiter.reject;
+				finish = waiter.resolve;
+				settlers.add(waiter);
+				context.abortSignal?.addEventListener("abort", cancel, { once: true });
+			}),
+			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(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();
+			const page = await readTranscriptPage(options.runtime, args, generation, context);
+			if (options.telemetry) observe(options.telemetry.recordEvent("doompi_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");
+			if ((await options.runtime.readLifecycle()).operation !== null || settlers.size > 0) {
+				if (isSelectionCommand(args.message) && await options.runtime.dispatchCommand(args.message)) return;
+				throw new Error("A turn is already running");
+			}
+			if (waitFor === "accepted") {
+				if (!options.telemetry) {
+					await options.runtime.submitPrompt(args.message, args.images);
+					return;
+				}
+				const telemetry = options.telemetry;
+				const startedAt = Date.now();
+				promptLatency = {
+					startedAt,
+					lastStageAt: startedAt,
+					reported: /* @__PURE__ */ new Set()
+				};
+				const settled = awaitSettled(BACKGROUND_CONTEXT);
+				let resolveAdmission;
+				let rejectAdmission;
+				const admitted = new Promise((resolve, reject) => {
+					resolveAdmission = resolve;
+					rejectAdmission = reject;
+				});
+				observe(telemetry.runInSpan("doompi_server.prompt_to_settled", { session_id: options.sessionId }, async () => {
+					let accepted = false;
+					try {
+						const submission = await telemetry.runInSpan("doompi_server.prompt_admission", { session_id: options.sessionId }, () => options.runtime.submitPrompt(args.message, args.images));
+						if (submission.handledCommand) settled.resolve();
+						reportPromptLatency("accepted");
+						accepted = true;
+						resolveAdmission();
+						await Promise.all([telemetry.runInSpan("doompi_server.prompt_engine_settlement", { session_id: options.sessionId }, () => submission.settled), telemetry.runInSpan("doompi_server.prompt_projection_settlement", { session_id: options.sessionId }, () => settled.promise)]);
+					} catch (error) {
+						reportPromptLatency("failed");
+						promptLatency = void 0;
+						const failure = error instanceof Error ? error : new Error(String(error));
+						settled.reject(failure);
+						if (!accepted) {
+							await settled.promise.catch(() => void 0);
+							rejectAdmission(failure);
+						}
+						throw failure;
+					}
+				}));
+				await admitted;
+				return;
+			}
+			const startedAt = Date.now();
+			promptLatency = {
+				startedAt,
+				lastStageAt: startedAt,
+				reported: /* @__PURE__ */ new Set()
+			};
+			const settled = awaitSettled(context);
+			const run = async () => {
+				try {
+					const submit = () => options.runtime.submitPrompt(args.message, args.images);
+					const submission = options.telemetry ? await options.telemetry.runInSpan("doompi_server.prompt_admission", { session_id: options.sessionId }, submit) : await submit();
+					if (submission.handledCommand) settled.resolve();
+					reportPromptLatency("accepted");
+					const engineSettlement = options.telemetry ? options.telemetry.runInSpan("doompi_server.prompt_engine_settlement", { session_id: options.sessionId }, () => submission.settled) : submission.settled;
+					const projectionSettlement = options.telemetry ? options.telemetry.runInSpan("doompi_server.prompt_projection_settlement", { session_id: options.sessionId }, () => settled.promise) : settled.promise;
+					await Promise.all([engineSettlement, projectionSettlement]);
+				} catch (error) {
+					reportPromptLatency("failed");
+					promptLatency = void 0;
+					settled.reject(error instanceof Error ? error : new Error(String(error)));
+					await settled.promise;
+				}
+			};
+			if (options.telemetry) await options.telemetry.runInSpan("doompi_server.prompt_to_settled", { session_id: options.sessionId }, run);
+			else await run();
+		},
+		async steer(text) {
+			requireLive();
+			const args = messageArgs(text);
+			const { operation } = await options.runtime.readLifecycle();
+			if (operation === null || operation.status === "aborting") {
+				await options.runtime.enqueueAutomatic(args.message, args.images);
+				return;
+			}
+			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 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 || 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);
+			return await options.runtime.readState();
+		},
+		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() {
+			if (disposed) return;
+			disposed = true;
+			unsubscribePresentation();
+			rejectSettlers(/* @__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 RemoteServiceProvider([{
+			service: DoomSessionManagementService,
+			mode: "singleton"
+		}]);
+		provider.provide(DoomSessionManagementService, {
+			attach: (sessionId, context) => presentation.attachSession(sessionId, context),
+			detach: (context) => presentation.detachSession(context)
+		});
+		return endpointAttachment(createRemoteServiceEndpoint(provider));
+	} };
+}
+/** Creates the 0.85 routed host for one supervised DoomPi 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 SessionNotFoundError(`No session ${sessionId}`);
+			return metadata;
+		},
+		async openSession() {
+			if (closed) throw new SessionNotFoundError("The session service is closed");
+			await runtime.initialize();
+			const provider = new RemoteServiceProvider([{
+				service: DoomSessionService,
+				mode: "singleton"
+			}]);
+			provider.provide(DoomSessionService, runtime);
+			return {
+				attachClient: () => endpointAttachment(createRemoteServiceEndpoint(provider)),
+				async close() {
+					if (closed) return;
+					closed = true;
+					provider.dispose();
+					await runtime.dispose();
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { createAgentServerService, createAgentSessionRuntime };
+
+//# sourceMappingURL=piSessionRuntime.mjs.map