@junghanacs/entwurf 0.31.0 → 0.33.0

package/pi/pi-durable/carrier/runtime.js

@@ -0,0 +1,402 @@
+                                                                     
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { clampThinkingLevel, getSupportedThinkingLevels,                         } from "@earendil-works/pi-ai";
+import {
+	                
+	                  
+	                    
+	                      
+	            
+	                 
+	               
+	Harness,
+	                          
+	              
+	ROOT_CONVERSATION_ID,
+	                
+	               
+} from "@earendil-works/pi-durable";
+import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
+import { ModelRuntime } from "entwurf-pi-dist:core/model-runtime.js";
+import { SettingsManager } from "entwurf-pi-dist:core/settings-manager.js";
+import {
+	configureHarnessHttp,
+	createCodingRegistry,
+	createHarnessSettings,
+	ExecutionEnvs,
+	findInitialAgentModel,
+} from "./harness-setup.js";
+import { selectSession } from "./sessions.js";
+import { Subagent } from "./subagent.js";
+
+const context = BACKGROUND_CONTEXT;
+
+                                                
+	                      
+	                               
+ 
+
+                         
+	                    
+	                                             
+	                         
+ 
+
+/** A conversation the user can switch to: the main one, or a subagent's. */
+                                      
+	                            
+	                       
+	                                                       
+	                        
+ 
+
+/** Everything the TUI renders. Plain values; no Harness objects cross this boundary. */
+                              
+	                                                                                            
+	                                            
+	                                        
+	                                                       
+	                                         
+	                                    
+	                                                        
+	                           
+ 
+
+                                    
+	                       
+	                                            
+ 
+
+/** What the TUI may ask for. */
+                                    
+	                                                              
+	                                                                    
+	                                                         
+	                       
+	                               
+	                                         
+	                             
+	                                             
+	                                                      
+ 
+
+                                     
+	                      
+	                                   
+	                                                                                                                 
+	                                           
+	                                                                                                           
+	                                                                       
+ 
+
+                                    
+	                                 
+	                                       
+	                                                                    
+	                                   
+	                                                                                                                   
+	                                                               
+	                       
+ 
+
+/** The agent document of a view; absent while the conversation has none. */
+export function agentOf(view                  )             {
+	return (view.docs["pi.agent"] ?? {})              ;
+}
+
+/** A subagent's task: the oldest user message of its conversation. The main conversation needs no title. */
+async function firstInput(harness         , id                )                              {
+	if (id === ROOT_CONVERSATION_ID) return {};
+	const conversation = (await harness.conversation(id, context)) ;
+	let first                         ;
+	let cursor                    ;
+	do {
+		const page = await conversation.entries({}, 256, cursor, context);
+		first = page.items.findLast((entry) => entry.kind === "pi.user") ?? first;
+		cursor = page.next;
+	} while (cursor !== undefined);
+	return titleOf(first);
+}
+
+/** The text of a user entry, as a one-line title. */
+function titleOf(entry                         )                     {
+	const message = entry?.model?.[0];
+	if (message?.role !== "user") return {};
+	const text =
+		typeof message.content === "string"
+			? message.content
+			: message.content.flatMap((block) => (block.type === "text" ? [block.text] : [])).join(" ");
+	return { title: text.replace(/\s+/g, " ").trim() };
+}
+
+export async function openDurable(options                     = {})                             {
+	if (options.model !== undefined && options.continueSession) {
+		throw new Error("An explicit model applies only to a new session, not to a continued one");
+	}
+	const location = await selectSession(options.cwd ?? process.cwd(), options.continueSession ?? false);
+	const envs = new ExecutionEnvs(location.cwd);
+	let harness                     ;
+	try {
+		const modelRuntime = await ModelRuntime.create();
+		const settingsManager = SettingsManager.create(location.cwd);
+		configureHarnessHttp(settingsManager);
+		const settings = createHarnessSettings(settingsManager);
+		const registry = createCodingRegistry(settingsManager, location.cwd);
+		registry.install(Subagent);
+		for (const extension of options.extensions ?? []) registry.install(extension);
+
+		const pendingReports            = [];
+		let report                           = (error) => pendingReports.push(error);
+		harness = await Harness.open(
+			await openNodeSqliteStorage(location.database),
+			{
+				models: modelRuntime,
+				registry,
+				settings,
+				env: envs.env,
+				onReport: (error) => report(error),
+			},
+			context,
+		);
+		const initial = location.created
+			? await findInitialAgentModel(settingsManager, modelRuntime, options.model)
+			: undefined;
+		if (options.model !== undefined) {
+			// pi resolves case-insensitive, partial and unknown ids too (a custom-id fallback with only a warning);
+			// an explicit model must be exactly one registered catalog model, named by its canonical id.
+			const asked = options.model;
+			const ref = initial?.model;
+			const thinking = initial?.thinkingLevel;
+			const registered = ref !== undefined && modelRuntime.getModel(ref.provider, ref.modelId) !== undefined;
+			const named =
+				ref !== undefined &&
+				(asked.model === ref.modelId || (thinking !== undefined && asked.model === `${ref.modelId}:${thinking}`));
+			if (ref === undefined || ref.provider !== asked.provider || !registered || !named) {
+				const resolved =
+					ref === undefined
+						? "none"
+						: `${ref.provider}/${ref.modelId}${thinking === undefined ? "" : `:${thinking}`}`;
+				throw new Error(
+					`explicit-model-not-exact: asked ${asked.provider}/${asked.model}, resolved ${resolved} (registered=${registered})`,
+				);
+			}
+		}
+		const root = await harness.root(context, {
+			agent: {
+				cwd: location.cwd,
+				...(initial?.model === undefined ? {} : { model: initial.model }),
+				...(initial?.thinkingLevel === undefined ? {} : { thinkingLevel: initial.thinkingLevel }),
+			},
+		});
+		const label = (id                )         => (id === root.id ? "main" : `subagent ${id}`);
+		const opened = harness;
+		const summaries                        = [];
+		let cursor                    ;
+		do {
+			const page = await opened.commit((tx) => tx.scanConversations({}, 256, cursor), context);
+			for (const { id } of page.items) summaries.push({ id, label: label(id), ...(await firstInput(opened, id)) });
+			cursor = page.next;
+		} while (cursor !== undefined);
+		let current               = root;
+		let conversation                                            = await root.viewState(context);
+		const models = ()                 =>
+			modelRuntime.getAvailableSnapshot().map((model) => ({
+				provider: model.provider,
+				modelId: model.id,
+				name: model.name,
+				contextWindow: model.contextWindow,
+			}));
+
+		let state              = {
+			session: { id: location.id, directory: location.directory, cwd: location.cwd },
+			conversation: conversation.value,
+			conversations: summaries,
+			models: models(),
+			notices: [],
+		};
+		const listeners = new Set            ();
+		let notifying = false;
+		// Commit listeners and Chord frames call this on the Session line; rendering runs afterwards, once per burst.
+		const update = (patch                      )       => {
+			state = { ...state, ...patch };
+			if (notifying) return;
+			notifying = true;
+			setImmediate(() => {
+				notifying = false;
+				for (const listener of listeners) listener();
+			});
+		};
+		let nextNotice = 1;
+		const notice = (level                 , message        )       => {
+			update({ notices: [...state.notices, { id: nextNotice++, level, message }].slice(-20) });
+		};
+		const fail = (error         )       => notice("error", error instanceof Error ? error.message : String(error));
+		report = (error) => notice("warning", error instanceof Error ? error.message : String(error));
+		for (const error of pendingReports) report(error);
+		let unsubscribe = conversation.subscribe((value) => update({ conversation: value }));
+		// Subagents appear as their conversations are created. A commit listener only records; it calls no Session API.
+		const unsubscribeCommits = harness.subscribeCommits((publication) => {
+			let conversations = state.conversations;
+			for (const change of publication.changes) {
+				if (change.type === "conversation") {
+					conversations = [...conversations, { id: change.value.id, label: label(change.value.id) }];
+				} else if (change.type === "entry" && change.value.kind === "pi.user") {
+					const id = change.value.conversationId;
+					conversations = conversations.map((summary) =>
+						summary.id === id && summary.title === undefined ? { ...summary, ...titleOf(change.value) } : summary,
+					);
+				}
+			}
+			if (conversations !== state.conversations) update({ conversations });
+		});
+
+		let tasks                                                ;
+		let unsubscribeTasks = ()       => {};
+		const closeTasks = ()       => {
+			unsubscribeTasks();
+			tasks?.dispose();
+			tasks = undefined;
+		};
+
+		let queue = Promise.resolve();
+		// One at a time, so toggles, switches, and key presses apply in order.
+		const command = (operation                     )                => {
+			queue = queue.then(operation).catch(fail);
+			return queue;
+		};
+		const watchAnswer = (submission            )       => {
+			void submission.wait(context).then((settled) => {
+				if (settled.status === "unanswered" && settled.reason !== "aborted") {
+					notice(
+						"error",
+						`No answer: ${settled.reason}${settled.detail === undefined ? "" : ` ${JSON.stringify(settled.detail)}`}`,
+					);
+				}
+			}, fail);
+		};
+		const agentModel = () => {
+			const ref = agentOf(state.conversation).model;
+			const model = ref === undefined ? undefined : modelRuntime.getModel(ref.provider, ref.modelId);
+			if (model === undefined)
+				throw new Error(ref === undefined ? "No model selected" : "Current model is unavailable");
+			return model;
+		};
+		const controller                    = {
+			submit: (text, whenBusy) =>
+				command(async () => watchAnswer(await current.submit({ type: "input", content: text, whenBusy }, context))),
+			compact: (instructions) =>
+				command(async () => {
+					const id = await current.compact(instructions, context);
+					// Report the outcome once it is known; the status line shows the compaction meanwhile.
+					void opened.waitForTask(id, context).then(async (receipt) => {
+						const outcome = receipt.state.outcome;
+						if (outcome.status === "completed") {
+							const { entryId, submissionId } = outcome.result;
+							// A summary written while busy is a submission: placed now, queued, or dropped as stale.
+							const status =
+								submissionId === undefined
+									? undefined
+									: (await (await opened.submission(submissionId, context))?.status(context))?.status;
+							notice(
+								"info",
+								entryId !== undefined || status === "done"
+									? "Compacted."
+									: status === "queued"
+										? "Compaction summary queued; it is placed at the next turn boundary."
+										: status === "unanswered"
+											? "Compaction summary dropped: the context changed under it."
+											: "Nothing to compact: the context fits in the recent window that is kept verbatim.",
+							);
+						} else if (outcome.status === "aborted") notice("info", "Compaction aborted.");
+						else
+							notice("error", `Compaction ${outcome.status}: ${outcome.error?.message ?? outcome.reason ?? ""}`);
+					}, fail);
+				}),
+			// Not queued: it waits until the conversation is idle.
+			abort: () => current.abort(context).catch(fail),
+			cycleThinking: () =>
+				command(async () => {
+					const model = agentModel();
+					if (!model.reasoning) throw new Error("Current model does not support thinking");
+					const levels = getSupportedThinkingLevels(model);
+					const level = agentOf(state.conversation).thinkingLevel ?? "off";
+					const next = levels[(levels.indexOf(level) + 1) % levels.length] ?? "off";
+					await current.configure({ thinkingLevel: next }, context);
+				}),
+			setModel: (ref) =>
+				command(async () => {
+					const model = modelRuntime.getModel(ref.provider, ref.modelId);
+					if (model === undefined) throw new Error(`Unknown model: ${ref.provider}/${ref.modelId}`);
+					const thinking                     = agentOf(state.conversation).thinkingLevel ?? "off";
+					await current.configure({ model: ref, thinkingLevel: clampThinkingLevel(model, thinking) }, context);
+				}),
+			toggleTasks: () =>
+				command(async () => {
+					if (tasks !== undefined) {
+						closeTasks();
+						update({ tasks: undefined });
+						return;
+					}
+					const graph = await opened.taskGraph(context);
+					tasks = graph;
+					unsubscribeTasks = graph.subscribe((value) => update({ tasks: value }));
+				}),
+			switchConversation: (id) =>
+				command(async () => {
+					const next = await opened.conversation(id, context);
+					if (next === undefined) throw new Error(`Conversation ${id} does not exist`);
+					const nextState = await next.viewState(context);
+					unsubscribe();
+					conversation.dispose();
+					current = next;
+					conversation = nextState;
+					unsubscribe = nextState.subscribe((value) => update({ conversation: value }));
+				}),
+		};
+
+		const saved = agentOf(state.conversation).model;
+		if (saved === undefined) notice("warning", "No model configured; select one with /model.");
+		else if (modelRuntime.getModel(saved.provider, saved.modelId) === undefined) {
+			notice("warning", `Saved model is unavailable: ${saved.provider}/${saved.modelId}`);
+		}
+		if (initial?.fallbackMessage !== undefined) notice("info", initial.fallbackMessage);
+		// The task panel starts open; /tasks hides it.
+		await controller.toggleTasks();
+		// Recovered work from an interrupted turn continues now.
+		harness.resume();
+
+		let closing                           ;
+		return {
+			view: {
+				current: () => state,
+				subscribe: (listener) => {
+					listeners.add(listener);
+					return () => listeners.delete(listener);
+				},
+			},
+			controller,
+			settings: settingsManager,
+			submitToRoot: (draft) => root.submit(draft, context),
+			close() {
+				closing ??= (async () => {
+					unsubscribe();
+					unsubscribeCommits();
+					conversation.dispose();
+					closeTasks();
+					try {
+						// Close writes no outcome: a running turn resumes with --continue.
+						await opened.close(context);
+						await envs.cleanup(context);
+					} finally {
+						await location.release();
+					}
+				})();
+				return closing;
+			},
+		};
+	} catch (error) {
+		await harness?.close(context).catch(() => {});
+		await location.release().catch(() => {});
+		throw error;
+	}
+}

package/pi/pi-durable/carrier/sessions.js

@@ -0,0 +1,56 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readdir, realpath } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import lockfile from "proper-lockfile";
+import { getAgentDir } from "entwurf-pi-dist:config.js";
+
+/** One session directory holding `session.sqlite`, locked by this process. */
+                                  
+	           
+	                  
+	                 
+	            
+	                 
+	                         
+ 
+
+/** A new session for `cwd`, or its newest one with `continueSession`. */
+export async function selectSession(cwdInput        , continueSession         )                           {
+	const cwd = await realpath(resolve(cwdInput));
+	const root = join(
+		getAgentDir(),
+		"experimental",
+		"durable-sessions",
+		createHash("sha256").update(cwd).digest("hex").slice(0, 24),
+	);
+	await mkdir(root, { recursive: true });
+
+	let directory        ;
+	let created = false;
+	if (continueSession) {
+		const entries = await readdir(root, { withFileTypes: true });
+		const newest = entries
+			.filter((entry) => entry.isDirectory() && /^\d{13}-[0-9a-f-]{36}$/u.test(entry.name))
+			.map((entry) => entry.name)
+			.sort()
+			.at(-1);
+		if (!newest) throw new Error(`No durable session exists for ${cwd}`);
+		directory = join(root, newest);
+	} else {
+		directory = join(root, `${String(Date.now()).padStart(13, "0")}-${randomUUID()}`);
+		await mkdir(directory);
+		created = true;
+	}
+
+	let release                     ;
+	try {
+		// A lock left by a crashed process goes stale after 10 s; wait that long before giving up.
+		release = await lockfile.lock(directory, {
+			realpath: false,
+			retries: { retries: 12, minTimeout: 1000, maxTimeout: 1000 },
+		});
+	} catch (error) {
+		throw new Error(`Session is already open in another process: ${directory}`, { cause: error });
+	}
+	return { id: basename(directory), directory, database: join(directory, "session.sqlite"), cwd, created, release };
+}

package/pi/pi-durable/carrier/subagent.js

@@ -0,0 +1,55 @@
+                                                     
+import {                        Type } from "@earendil-works/pi-ai";
+import {
+	AssistantEntry,
+	configure,
+	defineExtension,
+	defineTool,
+	             
+	               
+	                      
+} from "@earendil-works/pi-durable";
+
+async function answerText(api                  , answer         , context         )                  {
+	const entry = await api.commit((tx) => tx.entry(AssistantEntry, answer), context);
+	const message = entry?.model?.[0]                                ;
+	return message?.content.flatMap((content) => (content.type === "text" ? [content.text] : [])).join("") ?? "";
+}
+
+/**
+ * A foreground subagent: each call creates a child conversation owned by the call's task, runs the task there, and
+ * returns the child's answer. Aborting the call aborts the child. The child outlives the call, so the user can switch
+ * to it and keep talking.
+ */
+export const Subagent            = defineExtension({
+	name: "subagent",
+	tools: [
+		defineTool({
+			name: "subagent",
+			description:
+				"Delegate a self-contained task to a subagent with the same tools and get its answer back. Give it everything it needs to know; it does not see this conversation.",
+			parameters: Type.Object({ task: Type.String({ description: "What the subagent should do" }) }),
+			// A rerun after a crash finds the child it created and the submission it made.
+			replay: "safe",
+			execute: async (args, api, context) => {
+				const child = await api.commit(async (tx) => {
+					const existing = (await tx.scanConversations({ ownerTaskId: api.taskId }, 1)).items[0];
+					if (existing !== undefined) return existing.id;
+					// Starts as a copy of this conversation's agent; without this extension it cannot delegate further.
+					const created = await tx.createConversation({ ownership: { kind: "task", taskId: api.taskId } });
+					await configure(tx, created.id, { extensions: { remove: [Subagent] } });
+					return created.id;
+				}, context);
+				await api.details({ conversationId: child }, context);
+				const handle = (await api.conversation(child, context)) ;
+				const request = { type: "input", content: args.task, requestId: `subagent:${api.taskId}` }         ;
+				const settled = await (await handle.submit(request, context)).wait(context);
+				if (settled.status !== "done" || settled.type !== "input") {
+					throw new Error(`Subagent ${child} failed: ${settled.status}`);
+				}
+				const text = await answerText(api, settled.answer, context);
+				return { content: [{ type: "text", text }], details: { conversationId: child } };
+			},
+		}),
+	],
+});