@agimon-ai/po-core 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/src/pi/piSessionRuntime.mjs

@@ -1,13 +1,13 @@
-import { readTranscriptPage, transcriptCursor } from "../services/transcriptPages/index.mjs";
-import { DoomSessionManagementService, DoomSessionService } from "../schemas/sessionProtocol.mjs";
+import { durableTranscriptLane, readTranscriptPage, transcriptCursor } from "../services/transcriptPages/index.mjs";
+import { normalizeSessionGroups } from "../schemas/sessionProtocol.mjs";
 import { observe } from "../../serverTelemetry.mjs";
+import { SessionServiceStateSchema } from "../schemas/sessionApiContracts.mjs";
+import { PoSessionContract } from "../schemas/protocolSessionContract.mjs";
 import "../../sessionProtocol.mjs";
-import { createAcpSessionUpdateProjection } from "../services/acpSessionUpdates/index.mjs";
-import { createRpcTranscript } from "../services/rpcTranscript/index.mjs";
 import { createSessionPresentation } from "../services/sessionPresentation/index.mjs";
-import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
-import { RemoteServiceProvider, createRemoteServiceEndpoint, replicatedState } from "@earendil-works/chord";
-import { SessionNotFoundError } from "@earendil-works/pi-server";
+import { Type } from "typebox";
+import { BACKGROUND_CONTEXT, withAbortSignal } from "@earendil-works/chord/context";
+import { copyJson, forbidden, local, opaque, replicatedState } from "@earendil-works/chord";
 //#region src/pi/piSessionRuntime.ts
 const SETTLED = "agent_settled";
 const PROMPT_LATENCY_EVENT = "po_server.prompt_latency";
@@ -17,16 +17,72 @@ const SELECTION_COMMANDS = /* @__PURE__ */ new Set([
 	"profile",
 	"minor"
 ]);
+/** How each attach frame moves `live.phase`; idle clears `live`. */
+const LIVE_PHASES = /* @__PURE__ */ new Map([
+	["agent_start", "turn"],
+	["agent_settled", "idle"],
+	["compaction_start", "compaction"],
+	["compaction_end", "idle"],
+	["auto_retry_start", "retry"],
+	["auto_retry_end", "turn"]
+]);
+/**
+* Pi streams partials near 100 Hz; `live` takes at most one write per window, so 15 a second per session.
+* ponytail: tuned on the S7 bench (8 children, 4 bash tails growing 1.6 KB/s each): 18.5 KB/s, p95 64 ms.
+* Output faster than that streams at its own rate; cap tool tails or slow tool writes if real runs exceed 20 KB/s.
+*/
+const LIVE_WRITE_INTERVAL_MS = 66;
 function isSelectionCommand(text) {
 	const match = /^\/(\S+)/.exec(text);
 	return match !== null && SELECTION_COMMANDS.has(match[1]);
 }
+function parts(value) {
+	return Array.isArray(value) ? value.filter((part) => typeof part === "object" && part !== null) : [];
+}
+/** Pi's streaming assistant message, cut to the strict-JSON parts a client renders. */
+function liveMessage(message) {
+	const content = [];
+	for (const part of parts(message.content)) {
+		if (part.type === "text" && typeof part.text === "string") content.push({
+			type: "text",
+			text: part.text
+		});
+		if (part.type === "thinking" && typeof part.thinking === "string") content.push({
+			type: "thinking",
+			thinking: part.thinking,
+			...part.redacted === true ? { redacted: true } : {}
+		});
+	}
+	return {
+		role: "assistant",
+		content,
+		model: typeof message.model === "string" ? message.model : "",
+		timestamp: typeof message.timestamp === "number" ? message.timestamp : 0
+	};
+}
+function liveResult(result) {
+	const content = [];
+	for (const part of parts(result.content)) {
+		if (part.type === "text" && typeof part.text === "string") content.push({
+			type: "text",
+			text: part.text
+		});
+		if (part.type === "image" && typeof part.data === "string" && typeof part.mimeType === "string") content.push({
+			type: "image",
+			data: part.data,
+			mimeType: part.mimeType
+		});
+	}
+	return {
+		content,
+		...result.details === void 0 ? {} : { details: copyJson(result.details, { omitUndefinedProperties: true }) }
+	};
+}
 async function sessionStats(runtime, sessionId) {
 	const stored = await runtime.getSessionStats();
-	const { contextUsage, sessionFile } = stored;
+	const { contextUsage } = stored;
 	return {
 		sessionId,
-		...sessionFile === void 0 ? {} : { sessionFile },
 		totalMessages: stored.messageCount,
 		tokens: {
 			input: stored.usage.input,
@@ -41,29 +97,13 @@ async function sessionStats(runtime, sessionId) {
 }
 /** 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()),
-			fastMode: false
+			fastMode: false,
+			locked: false
 		},
-		progress: null,
-		updates: [],
 		presentation: {
 			revision: 0,
 			dropped: 0,
@@ -98,7 +138,6 @@ function createAgentSessionRuntime(options) {
 		if (next) state.change(BACKGROUND_CONTEXT, (draft) => {
 			draft.presentation = next;
 		});
-		return next !== void 0;
 	};
 	const settlers = /* @__PURE__ */ new Set();
 	const promptFailures = /* @__PURE__ */ new Set();
@@ -123,8 +162,82 @@ function createAgentSessionRuntime(options) {
 		for (const waiter of settlers) waiter.reject(error);
 		settlers.clear();
 	};
+	let pendingMessage;
+	const pendingResults = /* @__PURE__ */ new Map();
+	let liveCooldown;
+	const flushLive = () => {
+		if (pendingMessage === void 0 && pendingResults.size === 0) return;
+		const message = pendingMessage;
+		const results = [...pendingResults];
+		pendingMessage = void 0;
+		pendingResults.clear();
+		state.change(BACKGROUND_CONTEXT, (draft) => {
+			const live = draft.live ??= {
+				phase: "turn",
+				tools: {}
+			};
+			if (message) live.message = message;
+			for (const [toolCallId, partialResult] of results) {
+				const tool = live.tools[toolCallId];
+				if (tool) tool.partialResult = partialResult;
+			}
+		});
+	};
+	const coolLive = () => {
+		liveCooldown = void 0;
+		if (pendingMessage !== void 0 || pendingResults.size > 0) throttleLive();
+	};
+	const throttleLive = () => {
+		if (liveCooldown !== void 0) return;
+		flushLive();
+		liveCooldown = setTimeout(coolLive, LIVE_WRITE_INTERVAL_MS);
+	};
+	const updateLive = (frame, role) => {
+		const write = (mutate) => state.change(BACKGROUND_CONTEXT, (draft) => mutate(draft.live ??= {
+			phase: "turn",
+			tools: {}
+		}));
+		const phase = LIVE_PHASES.get(frame.type);
+		const live = state.value.live;
+		const toolCallId = typeof frame.toolCallId === "string" ? frame.toolCallId : "";
+		if (phase === "idle") {
+			if (live) state.change(BACKGROUND_CONTEXT, (draft) => {
+				delete draft.live;
+			});
+		} else if (phase !== void 0) write((next) => {
+			next.phase = phase;
+		});
+		else if (frame.type === "message_update" && role === "assistant") {
+			pendingMessage = liveMessage(frame.message);
+			throttleLive();
+		} else if (frame.type === "message_start" && role === "assistant") {
+			const message = liveMessage(frame.message);
+			write((next) => {
+				next.message = message;
+			});
+		} else if (frame.type === "message_end" && role === "assistant") {
+			if (live?.message) write((next) => {
+				delete next.message;
+			});
+		} else if (frame.type === "tool_execution_start" && toolCallId) {
+			const tool = {
+				toolCallId,
+				toolName: typeof frame.toolName === "string" ? frame.toolName : "",
+				args: copyJson(frame.args ?? null, { omitUndefinedProperties: true })
+			};
+			write((next) => {
+				next.tools[toolCallId] = tool;
+			});
+		} else if (frame.type === "tool_execution_update" && live?.tools[toolCallId]) {
+			pendingResults.set(toolCallId, liveResult(frame.partialResult ?? {}));
+			throttleLive();
+		} else if (frame.type === "tool_execution_end" && live?.tools[toolCallId]) write((next) => {
+			delete next.tools[toolCallId];
+		});
+	};
 	const unsubscribePresentation = (options.onPresentationFrame ?? ((listener) => options.runtime.onPresentationFrame(listener)))((frame) => {
 		if (disposed) return;
+		if (frame.type !== "message_update" && frame.type !== "tool_execution_update") flushLive();
 		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") {
@@ -147,51 +260,19 @@ function createAgentSessionRuntime(options) {
 		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);
+		const presentStartedAt = performance.now();
 		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("po_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),
-				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)) observe(options.telemetry.recordEvent("po_server.presentation_frame", {
+		const presentDurationMs = performance.now() - presentStartedAt;
+		if (options.telemetry && (presentDurationMs >= 50 || frame.type === SETTLED)) observe(options.telemetry.recordEvent("po_server.presentation_frame", {
 			session_id: options.sessionId,
 			"frame.type": frame.type,
-			phase: "reduce_and_publish",
-			duration_ms: reductionDurationMs + publishDurationMs
+			phase: "publish",
+			duration_ms: presentDurationMs
 		}));
 		if (frame.type === SETTLED) {
 			lastToolResultAt = void 0;
@@ -202,6 +283,7 @@ function createAgentSessionRuntime(options) {
 			settlers.clear();
 			for (const settle of waiting) settle.resolve();
 		}
+		updateLive(frame, message?.role);
 	});
 	const terminate = (error) => {
 		if (disposed) return;
@@ -210,6 +292,7 @@ function createAgentSessionRuntime(options) {
 		promptFailures.clear();
 		rejectSettlers(error);
 		unsubscribePresentation();
+		clearTimeout(liveCooldown);
 	};
 	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 = () => {
@@ -272,24 +355,11 @@ function createAgentSessionRuntime(options) {
 			}
 			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 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);
-					}
-				}
+				lane: durableTranscriptLane((query, limit, cursor, scanContext) => options.runtime.scanEntries(query, limit, cursor, scanContext), (readContext) => options.runtime.readIdentities(readContext))
 			}, args, generation, context);
 			if (options.telemetry) observe(options.telemetry.recordEvent("po_server.transcript_page", {
 				session_id: options.sessionId,
@@ -300,8 +370,7 @@ function createAgentSessionRuntime(options) {
 			if (generation !== historyGeneration) throw new Error("STALE_TRANSCRIPT_CURSOR");
 			return {
 				...page,
-				revision,
-				drafts
+				revision
 			};
 		},
 		initialize() {
@@ -534,7 +603,11 @@ function createAgentSessionRuntime(options) {
 		},
 		async getCommands(context) {
 			guardContext(context);
-			return options.runtime.listCommands();
+			return options.runtime.listCommands().map(({ name, description }) => ({
+				name,
+				description,
+				source: "extension"
+			}));
 		},
 		async getAvailableModels(context) {
 			guardContext(context);
@@ -557,68 +630,202 @@ function createAgentSessionRuntime(options) {
 			if (typeof name !== "string" || name.length > 256) throw new Error("Invalid session name");
 			await options.runtime.setName(name);
 		},
+		async setGroups(groups, context) {
+			guardContext(context);
+			await options.runtime.setGroups(normalizeSessionGroups(groups));
+		},
 		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()
-	};
+/** Host-local, shared by every connection: one projected runtime per live session generation. */
+const SessionStateValue = Type.Union([Type.Null(), SessionServiceStateSchema]);
+/** Host-local, shared by every connection: one projected runtime per live session generation. */
+const PoSessionCore = local("po.session-core", {
+	version: 1,
+	input: Type.Object({
+		sessionId: Type.String({ minLength: 1 }),
+		generation: Type.Integer({ minimum: 0 })
+	}),
+	members: {
+		runtime: opaque("po.agent-session-runtime@1"),
+		state: SessionStateValue,
+		alive: Type.Boolean()
+	}
+});
+/** Linger keeps a quickly reattaching browser on the same projection. */
+const SESSION_CORE_LINGER_MS = 3e4;
+function contextOf(ctx) {
+	return withAbortSignal(ctx.signal, BACKGROUND_CONTEXT);
 }
-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));
-	} };
+function untilAborted(signal) {
+	return new Promise((resolve) => {
+		if (signal.aborted) resolve();
+		else signal.addEventListener("abort", () => resolve(), { once: true });
+	});
 }
-/** 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 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();
+/**
+* Serves `po.session` on `host`. `resolve` returns the session a principal may reach, or
+* undefined to refuse it.
+*/
+function serveAgentSessions(host, options) {
+	const bindings = /* @__PURE__ */ new Map();
+	const keyOf = (sessionId, generation) => `${generation}\0${sessionId}`;
+	host.serve(PoSessionCore, ({ sessionId, generation }, _principal, self) => {
+		const binding = bindings.get(keyOf(sessionId, generation));
+		if (binding === void 0) throw forbidden(`No session ${sessionId}`);
+		const state = self.state("state", SessionStateValue, null);
+		const alive = self.state("alive", Type.Boolean(), true);
+		const runtime = self.resource("runtime", {
+			version: 1,
+			open: async () => {
+				const created = createAgentSessionRuntime(binding.options);
+				try {
+					await created.initialize();
+				} catch (error) {
+					await created.dispose();
+					throw error;
 				}
-			};
-		}
-	};
+				return created;
+			},
+			close: (created) => created.dispose()
+		});
+		self.on("mirror", runtime, (created) => created.state, (value, ctx) => state.replace(ctx, value, { diff: true }));
+		const exited = binding.exited;
+		if (exited !== void 0) self.task(async (ctx) => {
+			await Promise.race([exited, untilAborted(ctx.signal)]);
+			if (!ctx.signal.aborted) alive.replace(ctx, false);
+		});
+		return {
+			runtime: self.expose(runtime),
+			state,
+			alive
+		};
+	}, { linger: SESSION_CORE_LINGER_MS });
+	host.serve(PoSessionContract, (input, principal, self) => {
+		const { sessionId } = input;
+		const binding = options.resolve(sessionId, principal);
+		if (binding === void 0) throw forbidden(`No session ${sessionId}`);
+		bindings.set(keyOf(sessionId, binding.generation), binding);
+		const core = self.get(PoSessionCore, {
+			sessionId,
+			generation: binding.generation
+		});
+		const live = (ctx) => {
+			if (!binding.permitted()) throw forbidden("This session belongs to Desktop.");
+			const runtime = core.runtime;
+			if (runtime === void 0) throw new Error("The session runtime is not ready.");
+			return [runtime, contextOf(ctx)];
+		};
+		return {
+			variant: "default",
+			state: core.state,
+			alive: core.alive,
+			readTranscriptPage: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.readTranscriptPage(args, context);
+			},
+			prompt: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.prompt(args, context);
+			},
+			steer: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.steer(args, context);
+			},
+			abort: (ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.abort(context);
+			},
+			abortOperation: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.abortOperation(args, context);
+			},
+			setModel: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.setModel(args, context);
+			},
+			setThinking: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.setThinking(args, context);
+			},
+			setFastMode: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.setFastMode(args, context);
+			},
+			setAgentLock: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.setAgentLock(args, context);
+			},
+			followUp: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.followUp(args, context);
+			},
+			enqueueAutomatic: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.enqueueAutomatic(args, context);
+			},
+			removeQueued: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.removeQueued(args, context);
+			},
+			promoteQueued: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.promoteQueued(args, context);
+			},
+			resumeQueue: (ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.resumeQueue(context);
+			},
+			clearQueue: (ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.clearQueue(context);
+			},
+			rewind: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.rewind(args, context);
+			},
+			extensionUiResponse: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.extensionUiResponse(args, context);
+			},
+			getState: (ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.getState(context);
+			},
+			getSessionStats: (ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.getSessionStats(context);
+			},
+			getCommands: (ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.getCommands(context);
+			},
+			getAvailableModels: (ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.getAvailableModels(context);
+			},
+			getAvailableThinkingLevels: (ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.getAvailableThinkingLevels(context);
+			},
+			compact: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.compact(args, context);
+			},
+			setName: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.setName(args, context);
+			},
+			setGroups: (args, ctx) => {
+				const [runtime, context] = live(ctx);
+				return runtime.setGroups(args, context);
+			}
+		};
+	});
 }
 //#endregion
-export { createAgentServerService, createAgentSessionRuntime };
+export { createAgentSessionRuntime, serveAgentSessions };
 
 //# sourceMappingURL=piSessionRuntime.mjs.map