pi-roundtable 0.24.1 → 0.25.0

package/src/core/agents/agent-store.ts

@@ -3,7 +3,12 @@ import type { CharacterSpec } from "../../characters/index.ts";
 import type { Migration } from "../db/migrations.ts";
 import { AgentError } from "../domain/errors.ts";
 import type { ThinkingLevel } from "../models.ts";
+import {
+	PromptHistory,
+	type PromptVersion,
+} from "../modules/prompts/prompt-history.ts";
 import type { AgentDirectory } from "../services.ts";
+import { AgentBook } from "./agent-book.ts";
 import {
 	type Agent,
 	type AgentGroup,
@@ -17,7 +22,6 @@ import {
 	checkPrompt,
 	checkThinking,
 	type GroupMessage,
-	MAX_GROUP_MEMBERS,
 	MIN_GROUP_MEMBERS,
 } from "./agent-rules.ts";
 import {
@@ -25,9 +29,9 @@ import {
 	agentMigrations,
 	agentsMigration,
 	type GroupRow,
-	toAgent,
 	toGroup,
 } from "./agent-schema.ts";
+import { AgentStatements } from "./agent-statements.ts";
 import { GroupMessages } from "./group-messages.ts";
 
 export {
@@ -55,22 +59,23 @@ import { isCheckDatabase } from "../db/check-database.ts";
  * Agents, groups, and group messages, in the database. Agents and groups are also held
  * in memory, because every inbound message asks and only this process changes them.
  */
-export class PgAgentStore implements AgentDirectory {
+export class PgAgentStore extends AgentBook implements AgentDirectory {
 	readonly #sql: SQL;
-	readonly #agents = new Map<string, Agent>();
-	/** Agents whose character column holds a value, readable or not. */
-	readonly #dressed = new Set<string>();
-	readonly #groups = new Map<string, AgentGroup>();
 	/** The tail of the agent and group writes, which run one at a time so none reads a map another is about to change. */
 	#queue: Promise<unknown> = Promise.resolve();
 
 	readonly #guild: string;
+	readonly #statements: AgentStatements;
 	readonly #messages: GroupMessages;
+	readonly #prompts: PromptHistory;
 
 	private constructor(sql: SQL, guildId: string) {
+		super();
 		this.#sql = sql;
 		this.#guild = guildId;
+		this.#statements = new AgentStatements(sql, guildId);
 		this.#messages = new GroupMessages(sql, guildId);
+		this.#prompts = new PromptHistory(sql, guildId);
 	}
 
 	/** The store's tables; the host runs this before any store attaches. */
@@ -94,11 +99,11 @@ export class PgAgentStore implements AgentDirectory {
 			.#sql`SELECT * FROM agents WHERE guild_id = ${this.#guild}`;
 		const groups: GroupRow[] = await this
 			.#sql`SELECT * FROM agent_groups WHERE guild_id = ${this.#guild}`;
-		this.#agents.clear();
-		this.#groups.clear();
-		this.#dressed.clear();
-		for (const row of agents) this.#keepAgentRow(row);
-		for (const row of groups) this.#groups.set(row.name, toGroup(row));
+		this.agentMap.clear();
+		this.groupMap.clear();
+		this.dressed.clear();
+		for (const row of agents) this.keepAgentRow(row);
+		for (const row of groups) this.groupMap.set(row.name, toGroup(row));
 	}
 
 	/** Inserts seed agents that do not exist yet; existing rows, edited or not, are left alone. */
@@ -106,15 +111,14 @@ export class PgAgentStore implements AgentDirectory {
 		return this.#serial(async () => {
 			const added: string[] = [];
 			for (const seed of seeds) {
-				const rows: AgentRow[] = await this.#sql`
-				INSERT INTO agents (guild_id, name, display_name, prompt, avatar_prompt, channel_id)
-				VALUES (${this.#guild}, ${seed.name}, ${seed.displayName}, ${seed.prompt}, ${seed.avatarPrompt ?? ""},
-					${seed.channelId ?? null})
-				ON CONFLICT DO NOTHING
-				RETURNING *`;
+				const rows = await this.#statements.insertSeed({
+					...seed,
+					avatarPrompt: seed.avatarPrompt ?? "",
+					channelId: seed.channelId ?? null,
+				});
 				// Only the inserted rows join the map: reloading it whole would drop a write that
 				// committed after its SELECT.
-				if (rows[0]) added.push(this.#keepAgent(rows[0]).name);
+				if (rows[0]) added.push(this.keepAgent(rows[0]).name);
 			}
 			return added;
 		});
@@ -126,66 +130,6 @@ export class PgAgentStore implements AgentDirectory {
 		return run;
 	}
 
-	agents(): Agent[] {
-		return [...this.#agents.values()];
-	}
-
-	agent(name: string): Agent | undefined {
-		return this.#agents.get(name);
-	}
-
-	/** The active agent with that name, or an error the caller can show. */
-	activeAgent(name: string): Agent {
-		const agent = this.#agents.get(name);
-		if (!agent)
-			throw new AgentError(
-				`There is no agent "${name}". Active agents: ${this.#activeNames()}.`,
-			);
-		if (agent.status !== "active")
-			throw new AgentError(
-				`Agent "${name}" is archived. Active agents: ${this.#activeNames()}.`,
-			);
-		return agent;
-	}
-
-	agentByChannel(channelId: string): Agent | undefined {
-		for (const agent of this.#agents.values())
-			if (agent.channelId === channelId && agent.status === "active")
-				return agent;
-		return undefined;
-	}
-
-	groups(): AgentGroup[] {
-		return [...this.#groups.values()];
-	}
-
-	group(name: string): AgentGroup | undefined {
-		return this.#groups.get(name);
-	}
-
-	groupByChannel(channelId: string): AgentGroup | undefined {
-		for (const group of this.#groups.values())
-			if (group.channelId === channelId && group.status === "active")
-				return group;
-		return undefined;
-	}
-
-	#activeNames(): string {
-		return (
-			this.agents()
-				.flatMap((a) => (a.status === "active" ? [a.name] : []))
-				.join(", ") || "none"
-		);
-	}
-
-	/** Names are shared between agents and groups, archived ones included. */
-	#checkFree(name: string): void {
-		if (this.#agents.has(name) || this.#groups.has(name))
-			throw new AgentError(
-				`The name "${name}" is taken, archived agents and groups included.`,
-			);
-	}
-
 	async createAgent(agent: {
 		name: string;
 		displayName: string;
@@ -203,23 +147,20 @@ export class PgAgentStore implements AgentDirectory {
 			checkPrompt(agent.prompt);
 			const avatarPrompt = agent.avatarPrompt ?? "";
 			if (avatarPrompt !== "") checkAvatarPrompt(avatarPrompt);
-			this.#checkFree(agent.name);
-			const rows: AgentRow[] = await this.#sql`
-			INSERT INTO agents (guild_id, name, display_name, prompt, avatar_prompt, channel_id, avatar_hash, character)
-			VALUES (${this.#guild}, ${agent.name}, ${agent.displayName.trim()}, ${agent.prompt}, ${avatarPrompt},
-				${agent.channelId ?? null}, ${agent.avatarHash ?? null},
-				${agent.character ?? null}::jsonb)
-			RETURNING *`;
-			return this.#keepAgent(rows[0]);
+			this.checkFree(agent.name);
+			const rows = await this.#statements.insertAgent({
+				name: agent.name,
+				displayName: agent.displayName.trim(),
+				prompt: agent.prompt,
+				avatarPrompt,
+				channelId: agent.channelId ?? null,
+				avatarHash: agent.avatarHash ?? null,
+				character: agent.character ?? null,
+			});
+			return this.keepAgent(rows[0]);
 		});
 	}
 
-	/** A name that createAgent would accept, checked before its channel is made. */
-	checkNewName(name: string): void {
-		checkAgentName(name);
-		this.#checkFree(name);
-	}
-
 	async updateAgent(
 		name: string,
 		change: {
@@ -233,6 +174,8 @@ export class PgAgentStore implements AgentDirectory {
 			model?: string | null;
 			thinking?: ThinkingLevel | null;
 		},
+		/** Who made the change; a changed prompt is kept in the agent's prompt history under this name. */
+		by = "unknown",
 	): Promise<Agent> {
 		return this.#serial(async () => {
 			const current = this.activeAgent(name);
@@ -249,65 +192,112 @@ export class PgAgentStore implements AgentDirectory {
 				change.thinking === undefined
 					? (current.thinking ?? null)
 					: change.thinking;
-			const rows: AgentRow[] = await this.#sql`
-			UPDATE agents SET
-				display_name = ${change.displayName?.trim() ?? current.displayName},
-				prompt = ${change.prompt ?? current.prompt},
-				avatar_prompt = ${change.avatarPrompt ?? current.avatarPrompt},
-				avatar_hash = ${change.avatarHash ?? current.avatarHash ?? null},
-				character = CASE WHEN ${change.character !== undefined} THEN ${change.character ?? null}::jsonb ELSE character END,
-				channel_id = ${change.channelId ?? current.channelId ?? null},
-				model = ${model},
-				thinking = ${thinking},
-				updated_at = now()
-			WHERE guild_id = ${this.#guild} AND name = ${name}
-			RETURNING *`;
-			return this.#keepAgent(rows[0]);
+			const row = {
+				displayName: change.displayName?.trim() ?? current.displayName,
+				prompt: change.prompt ?? current.prompt,
+				avatarPrompt: change.avatarPrompt ?? current.avatarPrompt,
+				avatarHash: change.avatarHash ?? current.avatarHash ?? null,
+				characterSet: change.character !== undefined,
+				character: change.character ?? null,
+				channelId: change.channelId ?? current.channelId ?? null,
+				model,
+				thinking,
+			};
+			const prompt = change.prompt;
+			// A new prompt and its history row commit together, so no change goes unrecorded.
+			const rows =
+				prompt !== undefined && prompt !== current.prompt
+					? await this.#sql.begin(async (tx) => {
+							const written = await new AgentStatements(
+								tx,
+								this.#guild,
+							).updateAgent(name, row);
+							await this.#prompts.record(
+								"agent",
+								name,
+								{ action: "set", text: prompt, previous: current.prompt, by },
+								tx,
+							);
+							return written;
+						})
+					: await this.#statements.updateAgent(name, row);
+			return this.keepAgent(rows[0]);
 		});
 	}
 
-	/** Archives an agent and takes it out of every group; says which groups it left. */
+	/** The changes of an agent's prompt, newest first. */
+	promptHistory(name: string, limit?: number): Promise<PromptVersion[]> {
+		return this.#prompts.list("agent", name, limit);
+	}
+
+	/**
+	 * Archives an agent and takes it out of every group; says which groups it left. A group this
+	 * would leave with too few members is archived whole, its members kept, so it can be restored
+	 * once they are all active again.
+	 */
 	async archiveAgent(name: string): Promise<AgentGroup[]> {
 		return this.#serial(async () => {
-			const rows: AgentRow[] = await this.#sql`
-			UPDATE agents SET status = 'archived', updated_at = now()
-			WHERE guild_id = ${this.#guild} AND name = ${name} RETURNING *`;
-			this.#keepAgent(rows[0]);
+			this.keepAgent((await this.#statements.archiveAgent(name))[0]);
 			const left: AgentGroup[] = [];
 			for (const group of this.groups()) {
 				if (group.status !== "active" || !group.members.includes(name))
 					continue;
 				const members = group.members.filter((m) => m !== name);
+				if (members.length < MIN_GROUP_MEMBERS) {
+					left.push(await this.#writeGroup(group.name, { status: "archived" }));
+					continue;
+				}
 				const host = group.host === name ? (members[0] ?? name) : group.host;
-				left.push(
-					await this.#writeGroup(group.name, {
-						members,
-						host,
-						status: members.length < MIN_GROUP_MEMBERS ? "archived" : "active",
-					}),
-				);
+				left.push(await this.#writeGroup(group.name, { members, host }));
 			}
 			return left;
 		});
 	}
 
-	#keepAgent(row: AgentRow | undefined): Agent {
-		if (!row) throw new AgentError("the agent was not found");
-		return this.#keepAgentRow(row);
-	}
-
-	#keepAgentRow(row: AgentRow): Agent {
-		const agent = toAgent(row);
-		this.#agents.set(agent.name, agent);
-		if (row.character !== null && row.character !== undefined)
-			this.#dressed.add(agent.name);
-		else this.#dressed.delete(agent.name);
-		return agent;
+	/**
+	 * Returns an archived agent to the active ones, on a new channel when its old one is gone. It
+	 * does not rejoin the groups it left.
+	 */
+	async restoreAgent(name: string, channelId?: string): Promise<Agent> {
+		return this.#serial(async () => {
+			const current = this.agentMap.get(name);
+			if (!current) throw new AgentError(`There is no agent "${name}".`);
+			if (current.status === "active")
+				throw new AgentError(`"${name}" is not archived.`);
+			const rows = await this.#statements.restoreAgent(
+				name,
+				channelId ?? current.channelId ?? null,
+			);
+			return this.keepAgent(rows[0]);
+		});
 	}
 
-	/** Whether the stored column holds a character, even one this version cannot read. */
-	hasStoredCharacter(name: string): boolean {
-		return this.#dressed.has(name);
+	/**
+	 * Deletes an archived agent, its group cursors and its prompt history, and takes it out of the
+	 * archived groups that still list it; its name is free again, and a new agent of that name
+	 * starts with an empty history. An active agent is never deleted: archive it first.
+	 */
+	async deleteAgent(name: string): Promise<void> {
+		return this.#serial(async () => {
+			const current = this.agentMap.get(name);
+			if (!current) throw new AgentError(`There is no agent "${name}".`);
+			if (current.status === "active")
+				throw new AgentError(
+					`"${name}" is active; archive it before deleting it.`,
+				);
+			await this.#statements.deleteAgent(name);
+			this.agentMap.delete(name);
+			this.dressed.delete(name);
+			// An archived group still lists the agent; a new agent of this name must not join it unasked.
+			for (const group of this.groups()) {
+				if (!group.members.includes(name)) continue;
+				const members = group.members.filter((m) => m !== name);
+				await this.#writeGroup(group.name, {
+					members,
+					host: group.host === name ? (members[0] ?? "") : group.host,
+				});
+			}
+		});
 	}
 
 	/**
@@ -320,12 +310,13 @@ export class PgAgentStore implements AgentDirectory {
 		avatarHash: string,
 	): Promise<boolean> {
 		return this.#serial(async () => {
-			const rows: AgentRow[] = await this.#sql`
-			UPDATE agents SET character = ${character}::jsonb, avatar_hash = ${avatarHash}, updated_at = now()
-			WHERE guild_id = ${this.#guild} AND name = ${name} AND character IS NULL
-			RETURNING *`;
+			const rows = await this.#statements.dressIfUndressed(
+				name,
+				character,
+				avatarHash,
+			);
 			if (!rows[0]) return false;
-			this.#keepAgentRow(rows[0]);
+			this.keepAgentRow(rows[0]);
 			return true;
 		});
 	}
@@ -341,38 +332,17 @@ export class PgAgentStore implements AgentDirectory {
 		avatarHash: string,
 	): Promise<boolean> {
 		return this.#serial(async () => {
-			const rows: AgentRow[] = await this.#sql`
-			UPDATE agents SET avatar_hash = ${avatarHash}, updated_at = now()
-			WHERE guild_id = ${this.#guild} AND name = ${name} AND status = 'active'
-				AND character = ${character}::jsonb
-			RETURNING *`;
+			const rows = await this.#statements.setAvatarIfLook(
+				name,
+				character,
+				avatarHash,
+			);
 			if (!rows[0]) return false;
-			this.#keepAgentRow(rows[0]);
+			this.keepAgentRow(rows[0]);
 			return true;
 		});
 	}
 
-	#checkMembers(members: readonly string[], host: string): void {
-		if (
-			new Set(members).size !== members.length ||
-			members.length < MIN_GROUP_MEMBERS ||
-			members.length > MAX_GROUP_MEMBERS
-		)
-			throw new AgentError(
-				`A group has ${MIN_GROUP_MEMBERS} to ${MAX_GROUP_MEMBERS} different members.`,
-			);
-		for (const member of members) this.activeAgent(member);
-		if (!members.includes(host))
-			throw new AgentError(`The host "${host}" must be one of the members.`);
-	}
-
-	/** Checks a new group before its channel is made. */
-	checkNewGroup(name: string, members: readonly string[], host: string): void {
-		checkAgentName(name);
-		this.#checkFree(name);
-		this.#checkMembers(members, host);
-	}
-
 	async createGroup(group: {
 		name: string;
 		displayName: string;
@@ -384,12 +354,12 @@ export class PgAgentStore implements AgentDirectory {
 		return this.#serial(async () => {
 			this.checkNewGroup(group.name, group.members, group.host);
 			checkDisplayName(group.displayName);
-			const rows: GroupRow[] = await this.#sql`
-			INSERT INTO agent_groups (guild_id, name, display_name, channel_id, members, host)
-			VALUES (${this.#guild}, ${group.name}, ${group.displayName.trim()}, ${group.channelId ?? null},
-				${group.members.join(",")}, ${group.host})
-			RETURNING *`;
-			return this.#keepGroup(rows[0]);
+			const rows = await this.#statements.insertGroup({
+				...group,
+				displayName: group.displayName.trim(),
+				channelId: group.channelId ?? null,
+			});
+			return this.keepGroup(rows[0]);
 		});
 	}
 
@@ -398,7 +368,7 @@ export class PgAgentStore implements AgentDirectory {
 		change: { displayName?: string; members?: string[]; host?: string },
 	): Promise<AgentGroup> {
 		return this.#serial(async () => {
-			const current = this.#groups.get(name);
+			const current = this.groupMap.get(name);
 			if (current?.status !== "active")
 				throw new AgentError(`There is no active group "${name}".`);
 			if (change.displayName !== undefined)
@@ -407,7 +377,7 @@ export class PgAgentStore implements AgentDirectory {
 			const host =
 				change.host ??
 				(members.includes(current.host) ? current.host : (members[0] ?? ""));
-			this.#checkMembers(members, host);
+			this.checkMembers(members, host);
 			return this.#writeGroup(name, {
 				displayName: change.displayName?.trim() ?? current.displayName,
 				members,
@@ -421,6 +391,38 @@ export class PgAgentStore implements AgentDirectory {
 		return this.#serial(() => this.#writeGroup(name, { status: "archived" }));
 	}
 
+	/**
+	 * Returns an archived group to the active ones, on a new channel when its old one is gone. Its
+	 * members must all be active still and number enough; otherwise it refuses and stays archived.
+	 */
+	async restoreGroup(name: string, channelId?: string): Promise<AgentGroup> {
+		return this.#serial(async () => {
+			const current = this.checkRestorableGroup(name);
+			const rows = await this.#statements.restoreGroup(
+				name,
+				channelId ?? current.channelId ?? null,
+			);
+			return this.keepGroup(rows[0]);
+		});
+	}
+
+	/**
+	 * Deletes an archived group with its messages and cursors, in the Discord channel's log and in
+	 * each room's (`<group>@<surface>`); its name is free again. An active group is never deleted.
+	 */
+	async deleteGroup(name: string): Promise<void> {
+		return this.#serial(async () => {
+			const current = this.groupMap.get(name);
+			if (!current) throw new AgentError(`There is no group "${name}".`);
+			if (current.status === "active")
+				throw new AgentError(
+					`"${name}" is active; archive it before deleting it.`,
+				);
+			await this.#statements.deleteGroup(name);
+			this.groupMap.delete(name);
+		});
+	}
+
 	async #writeGroup(
 		name: string,
 		change: {
@@ -430,24 +432,15 @@ export class PgAgentStore implements AgentDirectory {
 			status?: AgentStatus;
 		},
 	): Promise<AgentGroup> {
-		const current = this.#groups.get(name);
+		const current = this.groupMap.get(name);
 		if (!current) throw new AgentError(`There is no group "${name}".`);
-		const rows: GroupRow[] = await this.#sql`
-			UPDATE agent_groups SET
-				display_name = ${change.displayName ?? current.displayName},
-				members = ${(change.members ?? current.members).join(",")},
-				host = ${change.host ?? current.host},
-				status = ${change.status ?? current.status}
-			WHERE guild_id = ${this.#guild} AND name = ${name}
-			RETURNING *`;
-		return this.#keepGroup(rows[0]);
-	}
-
-	#keepGroup(row: GroupRow | undefined): AgentGroup {
-		if (!row) throw new AgentError("the group was not found");
-		const group = toGroup(row);
-		this.#groups.set(group.name, group);
-		return group;
+		const rows = await this.#statements.updateGroup(name, {
+			displayName: change.displayName ?? current.displayName,
+			members: change.members ?? current.members,
+			host: change.host ?? current.host,
+			status: change.status ?? current.status,
+		});
+		return this.keepGroup(rows[0]);
 	}
 
 	appendGroupMessage(

package/src/core/agents/agent-team-fixture.ts

@@ -203,6 +203,10 @@ export class FakeRuntime implements AgentTurnRunner {
 	async startFresh(session: ChannelKey) {
 		this.fresh.push(session);
 	}
+	deleted: ChannelKey[] = [];
+	async deleteConversation(session: ChannelKey) {
+		this.deleted.push(session);
+	}
 	usage = new Map<ChannelKey, ContextUse>();
 	contextUsage(session: ChannelKey) {
 		return this.usage.get(session);
@@ -244,7 +248,17 @@ export const script: {
 	prompt: PromptSection[];
 	/** The tools plugins defined for agents. */
 	tools: string[];
-} = { scores: undefined, prompt: [], tools: [] };
+	/** The prompt every agent's starts with; read before each turn, so a test may change it. */
+	shared: string;
+	/** The one a speaker other than the owner gets instead; empty falls back to `shared`. */
+	guest: string;
+} = {
+	scores: undefined,
+	prompt: [],
+	tools: [],
+	shared: "Shared rules.",
+	guest: "",
+};
 let queue: ChannelQueue;
 let team: AgentTeam;
 let skillStore: TestStore<SkillStore>;
@@ -323,7 +337,9 @@ export function useTeamFixture(
 			"agent_groups",
 			"agent_group_messages",
 			"agent_group_cursors",
+			"prompt_history",
 			"skills",
+			"skill_versions",
 			"skill_groups",
 			"agent_skills",
 		])
@@ -361,6 +377,8 @@ export function useTeamFixture(
 		script.scores = undefined;
 		script.prompt = [];
 		script.tools = [];
+		script.shared = "Shared rules.";
+		script.guest = "";
 		queue = channelQueue();
 		removedSchedules.length = 0;
 		stops.length = 0;
@@ -420,7 +438,8 @@ export function useTeamFixture(
 				return () => stops.push(`hide ${channel}`);
 			},
 			workDir: "/tmp/agents/work",
-			sharedPrompt: "Shared rules.",
+			sharedPrompt: () => script.shared,
+			guestPrompt: () => script.guest,
 			skills,
 			logger: silentLogger(),
 		});