pi-roundtable 0.24.2 → 0.26.0

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

@@ -0,0 +1,155 @@
+import { AgentError } from "../domain/errors.ts";
+import type { Agent, AgentGroup } from "./agent-rules.ts";
+import {
+	checkAgentName,
+	checkDisplayName,
+	MAX_GROUP_MEMBERS,
+	MIN_GROUP_MEMBERS,
+} from "./agent-rules.ts";
+import {
+	type AgentRow,
+	type GroupRow,
+	toAgent,
+	toGroup,
+} from "./agent-schema.ts";
+
+/**
+ * The agents and groups a guild holds in memory, and the checks that read them: every inbound
+ * message asks, and only this process changes them. The store writes the rows and keeps these
+ * maps in step.
+ */
+export abstract class AgentBook {
+	protected readonly agentMap = new Map<string, Agent>();
+	/** Agents whose character column holds a value, readable or not. */
+	protected readonly dressed = new Set<string>();
+	protected readonly groupMap = new Map<string, AgentGroup>();
+
+	agents(): Agent[] {
+		return [...this.agentMap.values()];
+	}
+
+	agent(name: string): Agent | undefined {
+		return this.agentMap.get(name);
+	}
+
+	/** The active agent with that name, or an error the caller can show. */
+	activeAgent(name: string): Agent {
+		const agent = this.agentMap.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.agentMap.values())
+			if (agent.channelId === channelId && agent.status === "active")
+				return agent;
+		return undefined;
+	}
+
+	groups(): AgentGroup[] {
+		return [...this.groupMap.values()];
+	}
+
+	group(name: string): AgentGroup | undefined {
+		return this.groupMap.get(name);
+	}
+
+	groupByChannel(channelId: string): AgentGroup | undefined {
+		for (const group of this.groupMap.values())
+			if (group.channelId === channelId && group.status === "active")
+				return group;
+		return undefined;
+	}
+
+	protected activeNames(): string {
+		return (
+			this.agents()
+				.flatMap((a) => (a.status === "active" ? [a.name] : []))
+				.join(", ") || "none"
+		);
+	}
+
+	/** Names are shared between agents and groups, archived ones included. */
+	protected checkFree(name: string): void {
+		if (this.agentMap.has(name) || this.groupMap.has(name))
+			throw new AgentError(
+				`The name "${name}" is taken, archived agents and groups included.`,
+			);
+	}
+
+	/** A name that createAgent would accept, checked before its channel is made. */
+	checkNewName(name: string): void {
+		checkAgentName(name);
+		this.checkFree(name);
+	}
+
+	protected keepAgent(row: AgentRow | undefined): Agent {
+		if (!row) throw new AgentError("the agent was not found");
+		return this.keepAgentRow(row);
+	}
+
+	protected keepAgentRow(row: AgentRow): Agent {
+		const agent = toAgent(row);
+		this.agentMap.set(agent.name, agent);
+		if (row.character !== null && row.character !== undefined)
+			this.dressed.add(agent.name);
+		else this.dressed.delete(agent.name);
+		return agent;
+	}
+
+	/** Whether the stored column holds a character, even one this version cannot read. */
+	hasStoredCharacter(name: string): boolean {
+		return this.dressed.has(name);
+	}
+
+	protected 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; a `displayName` is checked too. */
+	checkNewGroup(
+		name: string,
+		members: readonly string[],
+		host: string,
+		displayName?: string,
+	): void {
+		checkAgentName(name);
+		if (displayName !== undefined) checkDisplayName(displayName);
+		this.checkFree(name);
+		this.checkMembers(members, host);
+	}
+
+	/** The archived group, when it could be restored now; otherwise the error that says why not. */
+	checkRestorableGroup(name: string): AgentGroup {
+		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 not archived.`);
+		this.checkMembers(current.members, current.host);
+		return current;
+	}
+
+	protected keepGroup(row: GroupRow | undefined): AgentGroup {
+		if (!row) throw new AgentError("the group was not found");
+		const group = toGroup(row);
+		this.groupMap.set(group.name, group);
+		return group;
+	}
+}

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

@@ -7,7 +7,11 @@ export type { ContextUse };
 /** The part of the runtime the agent team drives. */
 export type AgentTurnRunner = Pick<
 	AgentRuntime,
-	"runTurn" | "heldActions" | "startFresh" | "contextUsage"
+	| "runTurn"
+	| "heldActions"
+	| "startFresh"
+	| "deleteConversation"
+	| "contextUsage"
 >;
 
 /** One agent's message in a channel, posted under its name and avatar. */

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

@@ -1,5 +1,6 @@
 import { messages } from "../i18n/index.ts";
 import { type OwnerIdentity, ownerWords } from "../identity.ts";
+import type { AgentTools } from "../plugin.ts";
 import { addressee, type Speaker } from "../speakers.ts";
 import type { Agent, AgentGroup, Backlog } from "./agent-store.ts";
 
@@ -25,6 +26,8 @@ export function agentSystemPrompt(input: {
 	speaker?: Speaker;
 	/** Whether the session offers generate_image; true only with an image provider. Default false. */
 	images?: boolean;
+	/** "chat-only": the agent has no shell, file tools or workspace, and the prompt says so. Default "full". */
+	agentTools?: AgentTools;
 }): string {
 	const { agent, coordinator, shared, workDir, owner, shellUser, group } =
 		input;
@@ -37,7 +40,9 @@ export function agentSystemPrompt(input: {
 		`You are "${agent.displayName}" (agent name \`${agent.name}\`), one of ${o.name}'s agents in ${o.his} Discord agent server. Each agent owns one channel and one conversation; you all share ${o.his} tools and ${o.his} memory.`,
 		roleText(agent, coordinator, who),
 		`The team: agent_list shows every agent and group; agent_get and agent_update read and improve any agent's prompt, display name, model, and thinking level, yours included; agent_create adds an agent with its own channel; agent_avatar changes an agent's look (class, colors, parts); schedule_list with agent reads another agent's schedules. A message marked as coming from another agent is that agent speaking, not ${w.name}; only ${w.name} approves held actions.`,
-		`Your shell and file tools run on ${o.his} VPS as the user ${shellUser}, in the shared workspace ${workDir}.${input.scratchDir ? ` Write temporary files under the scratch dir ${input.scratchDir} ($TMPDIR), not elsewhere in /tmp; make them with \`mktemp -p "$TMPDIR"\`, since a bare \`mktemp\` ignores $TMPDIR on some systems.` : ""} Commands that are destructive or change the system, and writes outside the workspace${input.scratchDir ? " and the scratch dir" : ""}, are held for ${w.his} confirmation: tell ${w.him} exactly what will run and ask ${w.him} to confirm. To show a file you have, attach it to your reply with attach_file or give its path to discord_send_message; never read an image or base64 a file to send it.${input.images ? " To make a new picture, describe it to generate_image, which saves it and attaches it to your reply." : ""}`,
+		input.agentTools === "chat-only"
+			? `You have no shell or file tools and no workspace on ${o.his} machine: you work through the conversation and the tools listed to you.${input.images ? " To make a new picture, describe it to generate_image, which saves it and attaches it to your reply." : ""}`
+			: `Your shell and file tools run on ${o.his} VPS as the user ${shellUser}, in the shared workspace ${workDir}.${input.scratchDir ? ` Write temporary files under the scratch dir ${input.scratchDir} ($TMPDIR), not elsewhere in /tmp; make them with \`mktemp -p "$TMPDIR"\`, since a bare \`mktemp\` ignores $TMPDIR on some systems.` : ""} Commands that are destructive or change the system, and writes outside the workspace${input.scratchDir ? " and the scratch dir" : ""}, are held for ${w.his} confirmation: tell ${w.him} exactly what will run and ask ${w.him} to confirm. To show a file you have, attach it to your reply with attach_file or give its path to discord_send_message; never read an image or base64 a file to send it.${input.images ? " To make a new picture, describe it to generate_image, which saves it and attaches it to your reply." : ""}`,
 	];
 	if (group) {
 		const others = group.members

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

@@ -2,6 +2,7 @@ import { readCharacter } from "../../characters/index.ts";
 import { scopeToGuild } from "../db/guild-scope.ts";
 import type { Migration } from "../db/migrations.ts";
 import type { ThinkingLevel } from "../models.ts";
+import { promptHistoryMigration } from "../modules/prompts/prompt-history.ts";
 import type { Agent, AgentGroup, AgentStatus } from "./agent-rules.ts";
 
 export interface AgentRow {
@@ -133,5 +134,7 @@ export function agentMigrations(guildId: string): Migration[] {
 				await sql`ALTER TABLE agents ADD COLUMN IF NOT EXISTS character jsonb`;
 			},
 		},
+		// The change history of the agents' prompts; the prompts plugin creates the same table for its documents.
+		promptHistoryMigration("agent-prompt-history"),
 	];
 }

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

@@ -0,0 +1,179 @@
+import type { SQL } from "bun";
+import type { CharacterSpec } from "../../characters/index.ts";
+import type { AgentStatus } from "./agent-rules.ts";
+import type { AgentRow, GroupRow } from "./agent-schema.ts";
+
+/**
+ * The SQL the agent store runs for one guild. The store holds the rows in memory and decides
+ * what may change; each method here only writes the statement and returns the rows it touched.
+ */
+export class AgentStatements {
+	readonly #sql: SQL;
+	readonly #guild: string;
+
+	constructor(sql: SQL, guildId: string) {
+		this.#sql = sql;
+		this.#guild = guildId;
+	}
+
+	/** Inserts a seed agent unless one of that name exists; no row comes back when one does. */
+	insertSeed(seed: {
+		name: string;
+		displayName: string;
+		prompt: string;
+		avatarPrompt: string;
+		channelId: string | null;
+	}): Promise<AgentRow[]> {
+		return 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})
+				ON CONFLICT DO NOTHING
+				RETURNING *`;
+	}
+
+	insertAgent(agent: {
+		name: string;
+		displayName: string;
+		prompt: string;
+		avatarPrompt: string;
+		channelId: string | null;
+		avatarHash: string | null;
+		character: CharacterSpec | null;
+	}): Promise<AgentRow[]> {
+		return 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}, ${agent.prompt}, ${agent.avatarPrompt},
+				${agent.channelId}, ${agent.avatarHash},
+				${agent.character}::jsonb)
+			RETURNING *`;
+	}
+
+	/** Writes every column of an agent; `characterSet` false leaves the stored character alone. */
+	updateAgent(
+		name: string,
+		row: {
+			displayName: string;
+			prompt: string;
+			avatarPrompt: string;
+			avatarHash: string | null;
+			characterSet: boolean;
+			character: CharacterSpec | null;
+			channelId: string | null;
+			model: string | null;
+			thinking: string | null;
+		},
+	): Promise<AgentRow[]> {
+		return this.#sql`
+			UPDATE agents SET
+				display_name = ${row.displayName},
+				prompt = ${row.prompt},
+				avatar_prompt = ${row.avatarPrompt},
+				avatar_hash = ${row.avatarHash},
+				character = CASE WHEN ${row.characterSet} THEN ${row.character}::jsonb ELSE character END,
+				channel_id = ${row.channelId},
+				model = ${row.model},
+				thinking = ${row.thinking},
+				updated_at = now()
+			WHERE guild_id = ${this.#guild} AND name = ${name}
+			RETURNING *`;
+	}
+
+	archiveAgent(name: string): Promise<AgentRow[]> {
+		return this.#sql`
+			UPDATE agents SET status = 'archived', updated_at = now()
+			WHERE guild_id = ${this.#guild} AND name = ${name} RETURNING *`;
+	}
+
+	restoreAgent(name: string, channelId: string | null): Promise<AgentRow[]> {
+		return this.#sql`
+			UPDATE agents SET status = 'active', channel_id = ${channelId},
+				updated_at = now()
+			WHERE guild_id = ${this.#guild} AND name = ${name}
+			RETURNING *`;
+	}
+
+	/** Deletes the agent's row, its group cursors and its prompt history together. */
+	async deleteAgent(name: string): Promise<void> {
+		await this.#sql.begin(async (tx) => {
+			await tx`DELETE FROM agent_group_cursors WHERE guild_id = ${this.#guild} AND agent_name = ${name}`;
+			await tx`DELETE FROM prompt_history WHERE guild_id = ${this.#guild} AND kind = 'agent' AND name = ${name}`;
+			await tx`DELETE FROM agents WHERE guild_id = ${this.#guild} AND name = ${name}`;
+		});
+	}
+
+	/** Gives an agent a character and picture only while it has no character. */
+	dressIfUndressed(
+		name: string,
+		character: CharacterSpec,
+		avatarHash: string,
+	): Promise<AgentRow[]> {
+		return 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 *`;
+	}
+
+	/** Sets the picture only while the agent is active and still wears `character`. */
+	setAvatarIfLook(
+		name: string,
+		character: CharacterSpec,
+		avatarHash: string,
+	): Promise<AgentRow[]> {
+		return 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 *`;
+	}
+
+	insertGroup(group: {
+		name: string;
+		displayName: string;
+		channelId: string | null;
+		members: readonly string[];
+		host: string;
+	}): Promise<GroupRow[]> {
+		return this.#sql`
+			INSERT INTO agent_groups (guild_id, name, display_name, channel_id, members, host)
+			VALUES (${this.#guild}, ${group.name}, ${group.displayName}, ${group.channelId},
+				${group.members.join(",")}, ${group.host})
+			RETURNING *`;
+	}
+
+	updateGroup(
+		name: string,
+		row: {
+			displayName: string;
+			members: readonly string[];
+			host: string;
+			status: AgentStatus;
+		},
+	): Promise<GroupRow[]> {
+		return this.#sql`
+			UPDATE agent_groups SET
+				display_name = ${row.displayName},
+				members = ${row.members.join(",")},
+				host = ${row.host},
+				status = ${row.status}
+			WHERE guild_id = ${this.#guild} AND name = ${name}
+			RETURNING *`;
+	}
+
+	restoreGroup(name: string, channelId: string | null): Promise<GroupRow[]> {
+		return this.#sql`
+			UPDATE agent_groups SET status = 'active', channel_id = ${channelId}
+			WHERE guild_id = ${this.#guild} AND name = ${name}
+			RETURNING *`;
+	}
+
+	/** Deletes the group's row, messages and cursors, in the Discord channel's log and each room's. */
+	async deleteGroup(name: string): Promise<void> {
+		const rooms = `${name}@%`;
+		await this.#sql.begin(async (tx) => {
+			await tx`DELETE FROM agent_group_cursors WHERE guild_id = ${this.#guild} AND (group_name = ${name} OR group_name LIKE ${rooms})`;
+			await tx`DELETE FROM agent_group_messages WHERE guild_id = ${this.#guild} AND (group_name = ${name} OR group_name LIKE ${rooms})`;
+			await tx`DELETE FROM agent_groups WHERE guild_id = ${this.#guild} AND name = ${name}`;
+		});
+	}
+}