pi-roundtable 0.1.0 → 0.2.0

package/src/core/routing/channel-router.test.ts

@@ -1,326 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-	Admission,
-	ChannelClaim,
-	InboundMessage,
-} from "../contract/channels.ts";
-import { PluginError } from "../errors.ts";
-import { silentLogger } from "../log.ts";
-import type { ChannelKey } from "../sessions.ts";
-import { ChannelQueue } from "./channel-queue.ts";
-import { ChannelRouter, orderClaims } from "./channel-router.ts";
-
-function message(overrides: Partial<InboundMessage> = {}): InboundMessage {
-	return {
-		channel: "discord:1",
-		messageId: "m1",
-		authorId: "owner",
-		authorName: "Riley",
-		authorIsBot: false,
-		isDirect: true,
-		mentionsBot: false,
-		repliesToBot: false,
-		text: "hi",
-		attachments: [],
-		...overrides,
-	};
-}
-
-/** A claim over `channels` (every channel when empty) that records what it does in `log`. */
-function claim(
-	name: string,
-	priority: number,
-	log: string[],
-	options: {
-		channels?: string[];
-		guild?: string;
-		admit?: (message: InboundMessage) => Admission | undefined;
-		deletes?: boolean;
-	} = {},
-): ChannelClaim {
-	const { channels = [], guild } = options;
-	return {
-		name,
-		priority,
-		owns: (channel, guildId) =>
-			channels.length === 0 ||
-			channels.includes(channel) ||
-			(guild !== undefined && guildId === guild),
-		admit:
-			options.admit ??
-			((m) => ({
-				kind: "turn",
-				run: async () => void log.push(`${name} ${m.text}`),
-				failure: `${name} failed`,
-			})),
-		background: async (turn) => {
-			log.push(`${name} background ${turn.text}`);
-			return { status: "ran" };
-		},
-		startFresh: async (channel) => {
-			log.push(`${name} fresh ${channel}`);
-			return name;
-		},
-		...(options.deletes
-			? {
-					deleteConversation: async (channel: ChannelKey) =>
-						void log.push(`${name} delete ${channel}`),
-				}
-			: {}),
-	};
-}
-
-function router(claims: ChannelClaim[], queue = new ChannelQueue()) {
-	return new ChannelRouter({
-		claims,
-		queue,
-		stop: () => false,
-		logger: silentLogger(),
-		forwardJoinMs: 10,
-	});
-}
-
-describe("orderClaims", () => {
-	test("orders by descending priority, keeping registration order among equals", () => {
-		const log: string[] = [];
-		const ordered = orderClaims([
-			claim("owner", 0, log),
-			claim("party", 20, log),
-			claim("first", 30, log),
-			claim("second", 30, log),
-			claim("agents", 100, log),
-		]);
-		expect(ordered.map((c) => c.name)).toEqual([
-			"agents",
-			"first",
-			"second",
-			"party",
-			"owner",
-		]);
-	});
-
-	test("refuses a claim name used twice", () => {
-		const log: string[] = [];
-		expect(() =>
-			orderClaims([claim("party", 20, log), claim("party", 0, log)]),
-		).toThrow(PluginError);
-	});
-});
-
-describe("ChannelRouter", () => {
-	test("the highest claim owning a channel answers there; the owner takes the rest", async () => {
-		const log: string[] = [];
-		const routing = router([
-			claim("owner", 0, log),
-			claim("party", 20, log, { channels: ["discord:party"] }),
-			claim("agents", 100, log, { channels: ["discord:agent"] }),
-		]);
-		await routing.handle(message({ channel: "discord:party", text: "a" }));
-		await routing.handle(message({ channel: "discord:agent", text: "b" }));
-		await routing.handle(message({ channel: "discord:dm", text: "c" }));
-		expect(log).toEqual(["party a", "agents b", "owner c"]);
-	});
-
-	test("a message the owning claim refuses is dropped, never passed to a lower claim", async () => {
-		const log: string[] = [];
-		const routing = router([
-			claim("owner", 0, log),
-			claim("agents", 100, log, {
-				channels: ["discord:agent"],
-				guild: "agent-guild",
-				admit: () => undefined,
-			}),
-		]);
-		await routing.handle(message({ guildId: "agent-guild", text: "notes" }));
-		await routing.handle(message({ guildId: "other", text: "hello" }));
-		expect(log).toEqual(["owner hello"]);
-	});
-
-	test("an empty message reaches no claim", async () => {
-		const log: string[] = [];
-		await router([claim("owner", 0, log)]).handle(message({ text: " " }));
-		expect(log).toEqual([]);
-	});
-
-	test("a message during a turn is offered to it, else marked until its own turn starts", async () => {
-		const log: string[] = [];
-		const queue = new ChannelQueue();
-		let takes = true;
-		let release = () => {};
-		const running = new Promise<void>((resolve) => {
-			release = resolve;
-		});
-		const routing = router(
-			[
-				claim("owner", 0, log, {
-					admit: (m) => ({
-						kind: "turn",
-						busy: {
-							steer: async () => takes,
-							react: async (emoji) => void log.push(`+${emoji} ${m.text}`),
-							unreact: async (emoji) => void log.push(`-${emoji} ${m.text}`),
-						},
-						run: async () => {
-							log.push(`run ${m.text}`);
-							if (m.text === "first") await running;
-						},
-						failure: "failed",
-					}),
-				}),
-			],
-			queue,
-		);
-		const first = routing.handle(message({ text: "first" }));
-		await Bun.sleep(1);
-		await routing.handle(message({ text: "steered" }));
-		takes = false;
-		const waiting = routing.handle(message({ text: "waiting" }));
-		await Bun.sleep(1);
-		release();
-		await Promise.all([first, waiting]);
-		expect(log).toEqual([
-			"run first",
-			"+↪️ steered",
-			"+⏳ waiting",
-			"-⏳ waiting",
-			"run waiting",
-		]);
-	});
-
-	test("a claim without busy handling is never marked", async () => {
-		const log: string[] = [];
-		const queue = new ChannelQueue();
-		const routing = router([claim("party", 0, log)], queue);
-		const first = routing.handle(message({ text: "one" }));
-		await routing.handle(message({ text: "two" }));
-		await first;
-		expect(log).toEqual(["party one", "party two"]);
-	});
-
-	test("a background admission runs as a background turn and reports when it did not run", async () => {
-		const log: string[] = [];
-		const routing = router([
-			{
-				...claim("agents", 0, log),
-				admit: (m) => ({
-					kind: "background",
-					turn: {
-						channel: m.channel,
-						mode: "owner",
-						author: { id: "ci", name: "CI" },
-						turnId: "webhook-1",
-						text: m.text,
-						report: true,
-					},
-					unanswered: (outcome) => log.push(`unanswered ${outcome.status}`),
-				}),
-				background: async () => ({ status: "skipped", reason: "busy" }),
-			},
-		]);
-		await routing.handle(message({ text: "build failed" }));
-		expect(log).toEqual(["unanswered skipped"]);
-	});
-
-	test("background turns and starting over go to the channel's owner when their queued turn starts", async () => {
-		const log: string[] = [];
-		const queue = new ChannelQueue();
-		const party = new Set<string>();
-		const routing = router(
-			[
-				claim("owner", 0, log),
-				{
-					...claim("party", 20, log),
-					owns: (channel) => party.has(channel),
-				},
-			],
-			queue,
-		);
-		let release = () => {};
-		const blocker = queue.run(
-			"discord:1",
-			() =>
-				new Promise<void>((resolve) => {
-					release = resolve;
-				}),
-		);
-		await Bun.sleep(1);
-		const turn = routing.background({
-			channel: "discord:1",
-			mode: "party",
-			author: { id: "owner", name: "Riley" },
-			turnId: "schedule-1",
-			text: "reminder",
-		});
-		const fresh = routing.startFresh("discord:1");
-		// Party mode turns on while the turn waits in the queue.
-		party.add("discord:1");
-		release();
-		await blocker;
-		expect(await turn).toEqual({ status: "ran" });
-		expect(await fresh).toBe("party");
-		expect(log).toEqual(["party background reminder", "party fresh discord:1"]);
-	});
-
-	test("deletes only through a claim that deletes, and never while the channel is busy", async () => {
-		const log: string[] = [];
-		const queue = new ChannelQueue();
-		const routing = router(
-			[
-				claim("owner", 0, log, { deletes: true }),
-				claim("party", 20, log, { channels: ["discord:party"] }),
-			],
-			queue,
-		);
-		await expect(routing.deleteConversation("discord:party")).rejects.toThrow(
-			"discord:party is not an owner conversation",
-		);
-		let release = () => {};
-		const blocker = queue.run(
-			"discord:1",
-			() =>
-				new Promise<void>((resolve) => {
-					release = resolve;
-				}),
-		);
-		await Bun.sleep(1);
-		expect(await routing.deleteConversation("discord:1")).toBe("busy");
-		release();
-		await blocker;
-		// The queue counts the finished task out once its tail settles.
-		await Bun.sleep(1);
-		expect(await routing.deleteConversation("discord:1")).toBe("deleted");
-		expect(log).toEqual(["owner delete discord:1"]);
-	});
-
-	test("reports stay in place only where the channel's owner says so", () => {
-		const log: string[] = [];
-		const routing = router([
-			claim("owner", 0, log),
-			{
-				...claim("party", 20, log, { channels: ["discord:party"] }),
-				postsInPlace: true,
-			},
-		]);
-		expect(routing.postsInPlace("discord:party")).toBe(true);
-		expect(routing.postsInPlace("discord:dm")).toBe(false);
-	});
-
-	test("a turn that throws is logged and the next still runs", async () => {
-		const log: string[] = [];
-		const routing = router([
-			claim("owner", 0, log, {
-				admit: (m) => ({
-					kind: "turn",
-					run: async () => {
-						if (m.text === "boom") throw new Error("boom");
-						log.push(`run ${m.text}`);
-					},
-					failure: "failed",
-				}),
-			}),
-		]);
-		await routing.handle(message({ text: "boom" }));
-		await routing.handle(message({ text: "next" }));
-		expect(log).toEqual(["run next"]);
-	});
-});

package/src/core/routing/conversation-kind.ts

@@ -1,14 +0,0 @@
-/** Whose conversation a channel holds, as starting it over reports it. */
-export type ConversationKind = "owner" | "party" | "agent";
-
-const isKind = (kind: string): kind is ConversationKind =>
-	kind === "owner" || kind === "party" || kind === "agent";
-
-/** Narrows what a claim's startFresh said; a claim the host does not know about is a bug. */
-export async function conversationKind(
-	whose: Promise<string>,
-): Promise<ConversationKind> {
-	const kind = await whose;
-	if (!isKind(kind)) throw new Error(`unknown conversation kind "${kind}"`);
-	return kind;
-}

package/src/core/routing/settle-turn.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { AgentRunError } from "../domain/errors.ts";
-import { settleTurn } from "./settle-turn.ts";
-
-describe("settleTurn", () => {
-	test("passes a finished turn's result through", async () => {
-		expect(await settleTurn(async () => ({ ok: true }), "turn")).toEqual({
-			ok: true,
-		});
-	});
-
-	test("turns a thrown error into a failed result naming what crashed", async () => {
-		const result = await settleTurn(async () => {
-			throw new Error("socket closed");
-		}, "party turn");
-		expect(result).toEqual({
-			ok: false,
-			error: new AgentRunError("party turn crashed: Error: socket closed"),
-		});
-	});
-});

package/src/core/runtime/compaction-tiers.test.ts

@@ -1,227 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-	type ExtensionAPI,
-	SessionManager,
-	shouldCompact,
-} from "@earendil-works/pi-coding-agent";
-import {
-	CompactionTiers,
-	compactionEngine,
-	HARD_COMPACT_TOKENS,
-	SOFT_COMPACT_TOKENS,
-} from "./compaction-tiers.ts";
-
-const WINDOWS: Record<string, number> = {
-	"anthropic/claude-opus-5-5": 1_000_000,
-	"anthropic/claude-200k-opus-5-5": 200_000,
-};
-const LARGE = { provider: "anthropic", id: "claude-opus-5-5" };
-const SMALL = { provider: "anthropic", id: "claude-200k-opus-5-5" };
-const PI_RESERVE = 16_384;
-/** The `engine` a compaction extension records in its compactions' details. */
-const EXTENSION_ENGINE = "acme-compaction";
-
-/** pi estimates a message at a token per four characters. */
-function text(tokens: number): string {
-	return "x".repeat(tokens * 4);
-}
-
-function say(session: SessionManager, tokens: number): string {
-	return session.appendMessage({
-		role: "user",
-		content: text(tokens),
-		timestamp: Date.now(),
-	});
-}
-
-/** Appends a compaction that leaves about `left` tokens: its summary and one small kept message. */
-function compacted(
-	session: SessionManager,
-	engine: "extension" | "pi",
-	left: number,
-): void {
-	const kept = say(session, 1_000);
-	session.appendCompaction(
-		text(left - 1_000),
-		kept,
-		SOFT_COMPACT_TOKENS,
-		engine === "extension" ? { engine: EXTENSION_ENGINE } : {},
-	);
-}
-
-function tiersOver(session: SessionManager): CompactionTiers {
-	return new CompactionTiers(
-		session,
-		(provider, id) => WINDOWS[`${provider}/${id}`],
-		EXTENSION_ENGINE,
-	);
-}
-
-/** The context size the model compacts past, as pi's own check sees it. */
-function trigger(tiers: CompactionTiers, model = LARGE): number {
-	const settings = tiers.settings().getCompactionSettings(model);
-	const window = WINDOWS[`${model.provider}/${model.id}`] ?? 0;
-	const at = window - settings.reserveTokens;
-	expect(shouldCompact(at, window, settings)).toBe(false);
-	expect(shouldCompact(at + 1, window, settings)).toBe(true);
-	return at;
-}
-
-type Handler = (event: unknown, ctx: unknown) => unknown;
-
-/** Loads a stand-in for a compaction extension through the tiers' wrapper. */
-function loadExtension(tiers: CompactionTiers) {
-	const extensionCalls: number[] = [];
-	const bypasses: { reason: string; tokensBefore: number }[] = [];
-	const handlers = new Map<string, Handler>();
-	const onStart: Handler = () => undefined;
-	tiers.wrapCompactor(
-		(pi) => {
-			pi.on("session_start", onStart as never);
-			pi.on("session_before_compact", (event) => {
-				extensionCalls.push(event.preparation.tokensBefore);
-				return { compaction: { summary: "extension" } } as never;
-			});
-		},
-		(bypass) => bypasses.push(bypass),
-	)({
-		on: (event: string, handler: Handler) => handlers.set(event, handler),
-	} as unknown as ExtensionAPI);
-	const compact = (tokensBefore: number) =>
-		handlers.get("session_before_compact")?.(
-			{ type: "session_before_compact", preparation: { tokensBefore } },
-			{},
-		);
-	return { compact, extensionCalls, bypasses, onStart, handlers };
-}
-
-describe("soft threshold", () => {
-	test("a 1M model compacts past 300k", () => {
-		const tiers = tiersOver(SessionManager.inMemory("/tmp"));
-		expect(trigger(tiers)).toBe(SOFT_COMPACT_TOKENS);
-	});
-
-	test("a 200k model keeps pi's default reserve", () => {
-		const tiers = tiersOver(SessionManager.inMemory("/tmp"));
-		expect(tiers.settings().getCompactionSettings(SMALL).reserveTokens).toBe(
-			PI_RESERVE,
-		);
-		expect(trigger(tiers, SMALL)).toBe(200_000 - PI_RESERVE);
-	});
-
-	test("an unknown model keeps pi's default reserve", () => {
-		const tiers = tiersOver(SessionManager.inMemory("/tmp"));
-		expect(
-			tiers.settings().getCompactionSettings({ provider: "x", id: "y" })
-				.reserveTokens,
-		).toBe(PI_RESERVE);
-	});
-});
-
-describe("hard ceiling", () => {
-	test("a compaction above 500k skips the extension, so pi's summary runs", async () => {
-		const extension = loadExtension(tiersOver(SessionManager.inMemory("/tmp")));
-		expect(await extension.compact(HARD_COMPACT_TOKENS + 1)).toBeUndefined();
-		expect(extension.extensionCalls).toEqual([]);
-		expect(extension.bypasses).toEqual([
-			{
-				reason: "above the hard ceiling",
-				tokensBefore: HARD_COMPACT_TOKENS + 1,
-			},
-		]);
-	});
-
-	test("a compaction at or below 500k goes to the extension", async () => {
-		const extension = loadExtension(tiersOver(SessionManager.inMemory("/tmp")));
-		expect(await extension.compact(HARD_COMPACT_TOKENS)).toEqual({
-			compaction: { summary: "extension" },
-		});
-		expect(await extension.compact(SOFT_COMPACT_TOKENS + 1)).toEqual({
-			compaction: { summary: "extension" },
-		});
-		expect(extension.extensionCalls).toEqual([
-			HARD_COMPACT_TOKENS,
-			SOFT_COMPACT_TOKENS + 1,
-		]);
-		expect(extension.bypasses).toEqual([]);
-	});
-
-	test("after the extension left more than 500k, the next compaction is pi's", async () => {
-		const session = SessionManager.inMemory("/tmp");
-		say(session, 10_000);
-		compacted(session, "extension", 520_000);
-		const tiers = tiersOver(session);
-		expect(tiers.latest()?.contextTokens).toBeGreaterThan(HARD_COMPACT_TOKENS);
-		const extension = loadExtension(tiers);
-		expect(await extension.compact(450_000)).toBeUndefined();
-		expect(extension.extensionCalls).toEqual([]);
-		expect(extension.bypasses[0]?.reason).toContain(
-			"The extension's last compaction",
-		);
-	});
-
-	test("only session_before_compact is wrapped", () => {
-		const extension = loadExtension(tiersOver(SessionManager.inMemory("/tmp")));
-		expect(extension.handlers.get("session_start")).toBe(extension.onStart);
-	});
-});
-
-describe("no compaction loop", () => {
-	test("the extension leaving the context near 300k moves the next compaction to 500k", () => {
-		const session = SessionManager.inMemory("/tmp");
-		say(session, 10_000);
-		compacted(session, "extension", 310_000);
-		const tiers = tiersOver(session);
-		// The same request's next check sees about what the extension left, and does not compact again.
-		const settings = tiers.settings().getCompactionSettings(LARGE);
-		expect(shouldCompact(311_000, 1_000_000, settings)).toBe(false);
-		expect(trigger(tiers)).toBe(HARD_COMPACT_TOKENS);
-
-		session.appendMessage({
-			role: "user",
-			content: "small",
-			timestamp: Date.now(),
-		});
-		compacted(session, "extension", 280_000);
-		expect(trigger(tiers)).toBe(HARD_COMPACT_TOKENS);
-	});
-
-	test("a compaction well below 300k keeps the soft threshold", () => {
-		const session = SessionManager.inMemory("/tmp");
-		say(session, 10_000);
-		compacted(session, "extension", 310_000);
-		const tiers = tiersOver(session);
-		expect(trigger(tiers)).toBe(HARD_COMPACT_TOKENS);
-		// pi's summary at the ceiling brings the session back to the soft tier.
-		compacted(session, "pi", 30_000);
-		expect(trigger(tiers)).toBe(SOFT_COMPACT_TOKENS);
-	});
-
-	test("pi's summary leaving the context near 500k falls back to pi's own threshold", () => {
-		const session = SessionManager.inMemory("/tmp");
-		say(session, 10_000);
-		compacted(session, "pi", 480_000);
-		expect(trigger(tiersOver(session))).toBe(1_000_000 - PI_RESERVE);
-	});
-
-	test("the extension leaving the context near 500k still leaves pi the ceiling", () => {
-		const session = SessionManager.inMemory("/tmp");
-		say(session, 10_000);
-		compacted(session, "extension", 480_000);
-		expect(trigger(tiersOver(session))).toBe(HARD_COMPACT_TOKENS);
-	});
-});
-
-describe("compaction engine", () => {
-	test("a compaction is the extension's only when it records the engine the plugin declared", () => {
-		expect(
-			compactionEngine({ engine: EXTENSION_ENGINE }, EXTENSION_ENGINE),
-		).toBe("extension");
-		expect(compactionEngine({ engine: "other" }, EXTENSION_ENGINE)).toBe("pi");
-		expect(compactionEngine({}, EXTENSION_ENGINE)).toBe("pi");
-		expect(compactionEngine(undefined, EXTENSION_ENGINE)).toBe("pi");
-		expect(compactionEngine({ engine: EXTENSION_ENGINE }, undefined)).toBe(
-			"pi",
-		);
-	});
-});

package/src/core/runtime/extensions/ask-user.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { OwnerAnswer, OwnerQuestion } from "../../domain/owner-prompts.ts";
-import { messages } from "../../i18n/index.ts";
-import { TEST_OWNER as OWNER } from "../../testing/owner.ts";
-import { PromptSlot } from "../prompt-slot.ts";
-import { ASK_USER_TOOL, askUserExtension } from "./ask-user.ts";
-
-interface Tool {
-	name: string;
-	execute: (
-		id: string,
-		params: unknown,
-		signal?: AbortSignal,
-	) => Promise<{ content: { text: string }[] }>;
-}
-
-/** ask_user over a slot whose cards answer with `answer`, recording each question. */
-function askUser(answer: OwnerAnswer | undefined, bound = true) {
-	const asked: { title: string; question: OwnerQuestion }[] = [];
-	const slot = new PromptSlot();
-	slot.bind(
-		bound
-			? {
-					confirm: async () => "expired",
-					ask: async (title, question) => {
-						asked.push({ title, question });
-						return answer;
-					},
-				}
-			: undefined,
-		"infra",
-	);
-	let tool: Tool | undefined;
-	askUserExtension(
-		slot,
-		OWNER,
-	)({
-		registerTool: (t: Tool) => {
-			tool = t;
-		},
-	} as unknown as ExtensionAPI);
-	if (tool?.name !== ASK_USER_TOOL) throw new Error("ask_user not registered");
-	const t = tool;
-	return {
-		asked,
-		call: async (params: unknown) =>
-			(await t.execute("call-1", params)).content[0]?.text ?? "",
-	};
-}
-
-describe("ask_user", () => {
-	test("a single choice comes back as the chosen label", async () => {
-		const { asked, call } = askUser({ choices: ["Sunday"] });
-		const text = await call({
-			question: "Which day?",
-			options: [
-				{ label: "Saturday" },
-				{ label: "Sunday", description: "afternoon" },
-			],
-		});
-		expect(text).toBe("Riley chose: Sunday");
-		expect(asked[0]).toEqual({
-			title: messages().askTitle("infra"),
-			question: {
-				question: "Which day?",
-				options: [
-					{ label: "Saturday" },
-					{ label: "Sunday", description: "afternoon" },
-				],
-				multi: false,
-				allowOther: false,
-			},
-		});
-	});
-
-	test("several choices and the owner's own words", async () => {
-		const { asked, call } = askUser({
-			choices: ["Saturday", "Monday"],
-			text: "Wednesday works too",
-		});
-		const text = await call({
-			question: "Which days?",
-			options: [{ label: "Saturday" }, { label: "Monday" }],
-			multi: true,
-			allow_other: true,
-		});
-		expect(text).toBe(
-			"Riley chose: Saturday; Monday\nRiley wrote: Wednesday works too",
-		);
-		expect(asked[0]?.question).toMatchObject({ multi: true, allowOther: true });
-	});
-
-	test("a free-text question", async () => {
-		const { asked, call } = askUser({ choices: [], text: "call me Nova" });
-		expect(await call({ question: "What name?" })).toBe(
-			"Riley wrote: call me Nova",
-		);
-		expect(asked[0]?.question.options).toEqual([]);
-	});
-
-	test("no answer in time says so", async () => {
-		const { call } = askUser(undefined);
-		expect(await call({ question: "?" })).toStartWith("No answer");
-	});
-
-	test("a turn he did not start tells the model to ask in its reply", async () => {
-		const { asked, call } = askUser({ choices: ["x"] }, false);
-		expect(await call({ question: "?" })).toContain(
-			"Ask him in your reply instead",
-		);
-		expect(asked).toHaveLength(0);
-	});
-});