pi-roundtable-sandbox 0.7.9 → 0.7.11

package/worker/pi-compaction.ts

@@ -0,0 +1,225 @@
+/**
+ * The worker session's compaction: the host's tiers, and the host's compactor reached over the broker.
+ */
+import type {
+	AgentSession,
+	AgentSessionEvent,
+	ExtensionFactory,
+	SessionBeforeCompactEvent,
+	SessionBeforeCompactResult,
+	SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import {
+	type CompactionHistory,
+	CompactionTiers,
+	compactionEngine,
+} from "pi-roundtable/kit";
+import type {
+	PiCompactionReport,
+	PiCompactMessage,
+	PiCompactRequest,
+	PiCompactResponse,
+	PiWorkerConfig,
+} from "../src/pi-protocol.ts";
+
+type CompactionEnd = Extract<AgentSessionEvent, { type: "compaction_end" }>;
+export type WorkerLog = (msg: string, fields?: Record<string, unknown>) => void;
+
+export interface WorkerCompactionOptions {
+	/** The session's entries, for the tiers' loop guard. */
+	history: CompactionHistory;
+	contextWindow(provider: string, id: string): number | undefined;
+	/** What the host told the worker at startup; no `compaction` means no host compactor. */
+	config: PiWorkerConfig;
+	/** The broker's Unix socket. */
+	socket: string;
+	log: WorkerLog;
+}
+
+/** The request the host's compactor reads: Pi's preparation, with the messages it keeps. */
+export function compactRequest(
+	event: SessionBeforeCompactEvent,
+): PiCompactRequest {
+	const { preparation } = event;
+	const start = event.branchEntries.findIndex(
+		(entry) => entry.id === preparation.firstKeptEntryId,
+	);
+	const keptMessages =
+		start < 0
+			? []
+			: event.branchEntries
+					.slice(start)
+					.flatMap((entry) =>
+						entry.type === "message" ? [entry.message] : [],
+					);
+	const { read, written, edited } = preparation.fileOps;
+	const modified = new Set([...written, ...edited]);
+	return {
+		reason: event.reason,
+		tokensBefore: preparation.tokensBefore,
+		firstKeptEntryId: preparation.firstKeptEntryId,
+		isSplitTurn: preparation.isSplitTurn,
+		messagesToSummarize: preparation.messagesToSummarize as PiCompactMessage[],
+		turnPrefixMessages: preparation.turnPrefixMessages as PiCompactMessage[],
+		keptMessages: keptMessages as PiCompactMessage[],
+		...(preparation.previousSummary === undefined
+			? {}
+			: { previousSummary: preparation.previousSummary }),
+		...(event.customInstructions === undefined
+			? {}
+			: { customInstructions: event.customInstructions }),
+		readFiles: [...read].filter((path) => !modified.has(path)).sort(),
+		modifiedFiles: [...modified].sort(),
+	};
+}
+
+/**
+ * Compacts as the host's own sessions do: large windows at the soft threshold through the host's
+ * compactor, past the hard ceiling through Pi's summary, which reaches the model over the broker.
+ */
+export class WorkerCompaction {
+	readonly #options: WorkerCompactionOptions;
+	readonly #tiers: CompactionTiers;
+	readonly #pending = new Set<Promise<void>>();
+
+	constructor(options: WorkerCompactionOptions) {
+		this.#options = options;
+		this.#tiers = new CompactionTiers(
+			options.history,
+			options.contextWindow,
+			options.config.compaction?.engine,
+		);
+	}
+
+	/** Pi's settings, with each model's reserve set so it compacts at its tier. */
+	settings(): SettingsManager {
+		return this.#tiers.settings();
+	}
+
+	/** The host compactor's handler, held back by the tiers; none when the host has no compactor. */
+	extensions(): { name: string; factory: ExtensionFactory }[] {
+		if (!this.#options.config.compaction) return [];
+		const handler: ExtensionFactory = (pi) => {
+			pi.on("session_before_compact", (event) => this.#compact(event));
+		};
+		return [
+			{
+				name: "host-compaction",
+				factory: this.#tiers.wrapCompactor(handler, (bypass) => {
+					this.#options.log("compaction skips the host compactor", bypass);
+					void this.#report({ type: "bypass", ...bypass });
+				}),
+			},
+		];
+	}
+
+	/** Logs a finished compaction and reports it to the host, which logs it for the channel. */
+	async ended(event: CompactionEnd, session: AgentSession): Promise<void> {
+		const { result } = event;
+		const { model, settingsManager } = session;
+		const report: PiCompactionReport = result
+			? {
+					type: "end",
+					reason: event.reason,
+					aborted: event.aborted,
+					willRetry: event.willRetry,
+					engine: compactionEngine(
+						result.details,
+						this.#options.config.compaction?.engine,
+					),
+					tokensBefore: result.tokensBefore,
+					...(result.estimatedTokensAfter === undefined
+						? {}
+						: { tokensAfter: result.estimatedTokensAfter }),
+					...(model
+						? {
+								nextCompactionAt:
+									model.contextWindow -
+									settingsManager.getCompactionSettings(model).reserveTokens,
+							}
+						: {}),
+				}
+			: {
+					type: "end",
+					reason: event.reason,
+					aborted: event.aborted,
+					willRetry: event.willRetry,
+					...(event.errorMessage === undefined
+						? {}
+						: { error: event.errorMessage.slice(0, 10_000) }),
+				};
+		const { type: _type, ...fields } = report;
+		this.#options.log(
+			result ? "conversation compacted" : "compaction failed",
+			fields,
+		);
+		await this.#report(report);
+	}
+
+	async #compact(
+		event: SessionBeforeCompactEvent,
+	): Promise<SessionBeforeCompactResult | undefined> {
+		const { log } = this.#options;
+		try {
+			// Local Unix-socket transport; no TCP connection or DNS lookup is made.
+			// nosemgrep: typescript.react.security.react-insecure-request.react-insecure-request
+			const response = await fetch("http://broker/compaction/compact", {
+				unix: this.#options.socket,
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify(compactRequest(event)),
+				signal: event.signal,
+			});
+			if (!response.ok) {
+				await response.body?.cancel();
+				log("compaction falls back to Pi's summary", {
+					fallback: `the broker answered ${response.status}`,
+				});
+				return undefined;
+			}
+			const answer = (await response.json()) as PiCompactResponse;
+			if (!answer.ok) {
+				log("compaction falls back to Pi's summary", {
+					fallback: answer.fallback,
+				});
+				return undefined;
+			}
+			return { compaction: answer.compaction };
+		} catch (error) {
+			log("compaction falls back to Pi's summary", {
+				fallback: `the compact request failed: ${String(error)}`,
+			});
+			return undefined;
+		}
+	}
+
+	/** Waits for the reports still on their way, so they reach the host while the turn is bound. */
+	async settled(): Promise<void> {
+		await Promise.allSettled([...this.#pending]);
+	}
+
+	#report(report: PiCompactionReport): Promise<void> {
+		const sending = this.#send(report).finally(() =>
+			this.#pending.delete(sending),
+		);
+		this.#pending.add(sending);
+		return sending;
+	}
+
+	async #send(report: PiCompactionReport): Promise<void> {
+		try {
+			// Local Unix-socket transport; no TCP connection or DNS lookup is made.
+			// nosemgrep: typescript.react.security.react-insecure-request.react-insecure-request
+			const response = await fetch("http://broker/compaction/report", {
+				unix: this.#options.socket,
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify(report),
+				signal: AbortSignal.timeout(5000),
+			});
+			await response.body?.cancel();
+		} catch (error) {
+			this.#options.log("compaction report failed", { error: String(error) });
+		}
+	}
+}

package/worker/pi-main.ts

@@ -9,7 +9,6 @@ import {
 	DefaultResourceLoader,
 	ModelRuntime,
 	SessionManager,
-	SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 import {
 	activeToolsExtension,
@@ -29,6 +28,7 @@ import {
 	type PiTurnRequest as PartyTurnRequest,
 	type PiTurnResponse as PartyTurnResponse,
 	PI_MEDIA_LIMITS,
+	type PiWorkerConfig,
 	safeFileName,
 	type PiTurnContext as TurnContext,
 	validatePiTurn,
@@ -36,6 +36,7 @@ import {
 	PI_OUTBOX as WORKSPACE_OUTBOX,
 } from "../src/pi-protocol.ts";
 import { boundedText } from "../src/protocol.ts";
+import { WorkerCompaction } from "./pi-compaction.ts";
 import type { PiWorkerContent } from "./pi-content.ts";
 import { speakerMemoryExtension } from "./pi-memory.ts";
 import {
@@ -46,6 +47,8 @@ import {
 import { boundedFile, brokerToolsExtension } from "./pi-tools.ts";
 
 let content: PiWorkerContent;
+/** The session's compaction, whose reports must reach the host before the turn's result. */
+let workerCompaction: WorkerCompaction | undefined;
 let baseTools: string[] = [];
 const THINKING = "low";
 const MCP_CONNECT_TIMEOUT_MS = 45_000;
@@ -94,6 +97,7 @@ function startForwarder(): void {
 			// pi-lens-ignore: unchecked-throwing-call -- the server builds request.url, always an absolute URL
 			const url = new URL(request.url);
 			const hasBody = request.method !== "GET" && request.method !== "HEAD";
+			const started = Date.now();
 			const response = await fetch(
 				`http://broker${url.pathname}${url.search}`,
 				{
@@ -105,7 +109,20 @@ function startForwarder(): void {
 						: undefined,
 					signal: request.signal,
 				},
-			);
+			).catch((error: unknown) => {
+				log("broker call failed", {
+					path: url.pathname,
+					latencyMs: Date.now() - started,
+					error: String(error),
+				});
+				throw error;
+			});
+			if (response.status >= 400)
+				log("broker call failed", {
+					path: url.pathname,
+					status: response.status,
+					latencyMs: Date.now() - started,
+				});
 			return new Response(response.body, {
 				status: response.status,
 				statusText: response.statusText,
@@ -127,6 +144,22 @@ async function mcpServers(): Promise<McpToolsResponse["servers"]> {
 	return ((await response.json()) as McpToolsResponse).servers;
 }
 
+/** Whether the host compacts for this worker; an older broker without the route has no compactor. */
+async function workerConfig(): Promise<PiWorkerConfig> {
+	// Local Unix-socket transport; no TCP connection or DNS lookup is made.
+	// nosemgrep: typescript.react.security.react-insecure-request.react-insecure-request
+	const response = await fetch("http://broker/worker/config", {
+		unix: join(CONTAINER_RUN_DIR, BROKER_SOCKET),
+	});
+	if (response.status === 404) {
+		await response.body?.cancel();
+		return {};
+	}
+	if (!response.ok)
+		throw new Error(`the broker answered ${response.status} for worker/config`);
+	return (await response.json()) as PiWorkerConfig;
+}
+
 /** pi-mcp-adapter registers tools only after its eager connection completes. */
 async function waitForTools(
 	session: AgentSession,
@@ -142,6 +175,7 @@ async function waitForTools(
 
 async function createSession(
 	servers: McpToolsResponse["servers"],
+	config: PiWorkerConfig,
 ): Promise<AgentSession> {
 	const SKILLS = content.skillsDir ? loadSkillIndex(content.skillsDir) : [];
 	const agentDir = process.env.PI_CODING_AGENT_DIR ?? "/tmp/pi-agent";
@@ -151,6 +185,19 @@ async function createSession(
 	const modelRuntime = await ModelRuntime.create({
 		authPath: join(agentDir, "auth.json"),
 	});
+	const sessionManager = SessionManager.continueRecent(
+		CONTAINER_WORKSPACE,
+		sessionDir,
+	);
+	const compaction = new WorkerCompaction({
+		history: sessionManager,
+		contextWindow: (provider, id) =>
+			modelRuntime.getModel(provider, id)?.contextWindow,
+		config,
+		socket: join(CONTAINER_RUN_DIR, BROKER_SOCKET),
+		log,
+	});
+	workerCompaction = compaction;
 	const resourceLoader = new DefaultResourceLoader({
 		cwd: CONTAINER_WORKSPACE,
 		agentDir,
@@ -189,6 +236,7 @@ async function createSession(
 				factory: speakerMemoryExtension(() => turnContext),
 			},
 			...(content.extensions?.(() => turnContext) ?? []),
+			...compaction.extensions(),
 			...(servers.length > 0
 				? [
 						{
@@ -218,11 +266,10 @@ async function createSession(
 		thinkingLevel: THINKING,
 		modelRuntime,
 		resourceLoader,
-		sessionManager: SessionManager.continueRecent(
-			CONTAINER_WORKSPACE,
-			sessionDir,
-		),
-		settingsManager: SettingsManager.inMemory({}),
+		sessionManager,
+		// Large windows compact at the soft threshold through the host's compactor, and through Pi's
+		// summary past the hard ceiling, as the host's own sessions do.
+		settingsManager: compaction.settings(),
 		noTools: "builtin",
 	});
 	const model = modelRuntime.getModel(content.model.provider, content.model.id);
@@ -240,6 +287,17 @@ async function createSession(
 	);
 	if (missing.length > 0)
 		throw new Error(`tools are not registered: ${missing.join(", ")}`);
+	session.subscribe((event) => {
+		if (event.type === "compaction_end") void compaction.ended(event, session);
+		else if (event.type === "auto_retry_start")
+			log("model call retried", {
+				attempt: event.attempt,
+				error: event.errorMessage,
+			});
+	});
+	log("compaction ready", {
+		hostCompactor: config.compaction?.engine ?? null,
+	});
 	return session;
 }
 
@@ -262,6 +320,21 @@ async function runTurn(
 	const toolCalls: string[] = [];
 	const unsubscribe = session.subscribe((event) => {
 		if (event.type === "tool_execution_start") toolCalls.push(event.toolName);
+		else if (event.type === "tool_execution_end" && event.isError)
+			log("tool failed", {
+				turnId: turn.turnId,
+				tool: event.toolName,
+				error: textOf(event.result?.content ?? []).slice(0, 2000),
+			});
+		else if (
+			event.type === "message_end" &&
+			event.message.role === "assistant" &&
+			event.message.stopReason === "error"
+		)
+			log("model call failed", {
+				turnId: turn.turnId,
+				error: event.message.errorMessage,
+			});
 	});
 	try {
 		await session.prompt(
@@ -276,6 +349,7 @@ async function runTurn(
 				: undefined,
 		);
 	} catch (error) {
+		log("prompt failed", { turnId: turn.turnId, error: String(error) });
 		return { ok: false, error: `prompt failed: ${String(error)}` };
 	} finally {
 		clearTimeout(timer);
@@ -327,10 +401,12 @@ async function main(): Promise<void> {
 
 	startForwarder();
 	const servers = await mcpServers();
-	const session = await createSession(servers);
+	const session = await createSession(servers, await workerConfig());
 
 	const brokerSocket = join(CONTAINER_RUN_DIR, BROKER_SOCKET);
 	log("sandbox worker ready", { profile, tools: activeTools.length });
+	// A broker that stays unreachable is logged once, not every quarter second.
+	let pollFailing = false;
 	for (;;) {
 		try {
 			// Local Unix-socket transport; no TCP connection or DNS lookup is made.
@@ -356,10 +432,15 @@ async function main(): Promise<void> {
 				await boundedText(next.body, 96 * 1024 * 1024),
 			);
 			validatePiTurn(turn);
-			const result = await runTurn(session, turn).catch(() => ({
-				ok: false as const,
-				error: "Worker output failed",
-			}));
+			pollFailing = false;
+			const result = await runTurn(session, turn).catch((error: unknown) => {
+				log("turn output failed", {
+					turnId: turn.turnId,
+					error: String(error),
+				});
+				return { ok: false as const, error: "Worker output failed" };
+			});
+			await workerCompaction?.settled();
 			// Local Unix-socket transport; no TCP connection or DNS lookup is made.
 			// nosemgrep: typescript.react.security.react-insecure-request.react-insecure-request
 			const sent = await fetch("http://broker/worker/result", {
@@ -370,7 +451,9 @@ async function main(): Promise<void> {
 				signal: AbortSignal.timeout(60_000),
 			});
 			await sent.body?.cancel();
-		} catch {
+		} catch (error) {
+			if (!pollFailing) log("broker poll failed", { error: String(error) });
+			pollFailing = true;
 			await Bun.sleep(250);
 		}
 	}

package/worker/precheck-main.ts

@@ -0,0 +1,147 @@
+// Runs one schedule's precheck script inside its sealed container and prints its answer.
+// The script is untrusted: the container, not this file, is the boundary.
+import { randomUUID } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { BROKER_PATH, boundedText, isRecord } from "../src/protocol.ts";
+import { unixBrokerRequest } from "./transport.ts";
+
+interface Input {
+	script: string;
+	firedAt: string;
+	timeZone: string;
+	today: string;
+	schedule: { id: number; title: string };
+	servers: { name: string; tools: string[] }[];
+}
+
+function isInput(value: unknown): value is Input {
+	return (
+		isRecord(value) &&
+		typeof value.script === "string" &&
+		typeof value.firedAt === "string" &&
+		typeof value.timeZone === "string" &&
+		typeof value.today === "string" &&
+		isRecord(value.schedule) &&
+		Array.isArray(value.servers)
+	);
+}
+
+const REFUSALS: Record<number, string> = {
+	403: "that server or tool is not granted to this script",
+	404: "that server is not granted to this script",
+	410: "the run ended",
+	409: "the script made two MCP calls at once; await each before the next",
+	429: "the script made too many MCP calls",
+};
+
+/** The MCP calls a script makes, each through the host's broker. */
+function mcpClient(servers: Input["servers"]) {
+	const call = async (
+		server: string,
+		tool: string,
+		args: Record<string, unknown> = {},
+	): Promise<Record<string, unknown>> => {
+		const granted = servers.find((s) => s.name === server);
+		if (!granted?.tools.includes(tool))
+			throw new Error(`${server}/${tool} is not granted to this script`);
+		const { status, body } = await unixBrokerRequest(
+			`/mcp/${server}`,
+			{
+				jsonrpc: "2.0",
+				id: 1,
+				method: "tools/call",
+				params: { name: tool, arguments: args },
+			},
+			// Tests run the worker outside a container; there the host sets only HOME.
+			process.env.PRECHECK_BROKER_SOCKET ?? BROKER_PATH,
+		);
+		if (status !== 200)
+			throw new Error(
+				`${server}/${tool}: ${REFUSALS[status] ?? "the broker call failed"}`,
+			);
+		if (!isRecord(body)) throw new Error(`${server}/${tool}: no answer`);
+		if (isRecord(body.error))
+			throw new Error(`${server}/${tool}: ${String(body.error.message)}`);
+		const result = body.result;
+		if (!isRecord(result)) throw new Error(`${server}/${tool}: no result`);
+		if (result.isError === true)
+			throw new Error(`${server}/${tool}: ${firstText(result) ?? "failed"}`);
+		return result;
+	};
+	return {
+		call,
+		/** The result's structured content, or its first text content parsed as JSON (or as text). */
+		async json(
+			server: string,
+			tool: string,
+			args: Record<string, unknown> = {},
+		): Promise<unknown> {
+			const result = await call(server, tool, args);
+			if (result.structuredContent !== undefined)
+				return result.structuredContent;
+			const text = firstText(result);
+			if (text === undefined) return undefined;
+			try {
+				return JSON.parse(text);
+			} catch {
+				return text;
+			}
+		},
+	};
+}
+
+function firstText(result: Record<string, unknown>): string | undefined {
+	const content = Array.isArray(result.content) ? result.content : [];
+	const text = content.find(
+		(item): item is { text: string } =>
+			isRecord(item) && item.type === "text" && typeof item.text === "string",
+	);
+	return text?.text;
+}
+
+function message(error: unknown): string {
+	return (error instanceof Error ? error.message : String(error)).slice(
+		0,
+		1000,
+	);
+}
+
+/** Runs the script and returns what to print; never throws. */
+async function answer(): Promise<string> {
+	try {
+		const input: unknown = JSON.parse(
+			await boundedText(Bun.stdin.stream(), 64 * 1024),
+		);
+		if (!isInput(input)) throw new Error("invalid precheck input");
+		// stdout carries only the answer; whatever the script logs goes to stderr.
+		for (const level of ["log", "info", "debug", "warn"] as const)
+			console[level] = console.error;
+		const path = join(tmpdir(), `precheck-${randomUUID()}.mjs`);
+		await Bun.write(path, input.script);
+		let module: unknown;
+		try {
+			module = await import(path);
+		} finally {
+			await rm(path, { force: true });
+		}
+		const check = isRecord(module) ? module.default : undefined;
+		if (typeof check !== "function")
+			throw new Error("the script has no default export function");
+		const result: unknown = await check({
+			mcp: mcpClient(input.servers),
+			firedAt: new Date(input.firedAt),
+			timeZone: input.timeZone,
+			today: input.today,
+			schedule: input.schedule,
+		});
+		return JSON.stringify({ ok: true, result: result ?? null });
+	} catch (error) {
+		return JSON.stringify({ ok: false, error: message(error) });
+	}
+}
+
+// Exit once the answer is written, even if the script left timers or sockets behind.
+await Bun.write(Bun.stdout, await answer());
+process.exit(0);