pi-roundtable 0.1.0 → 0.2.1

package/src/core/builtin/modules.ts

@@ -1,31 +1,33 @@
 import { join } from "node:path";
 import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import type { SurfacePort } from "../contract/surface.ts";
 import { scheduleCommands } from "../discord/schedule-commands.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import type { ModelRef, ThinkingLevel } from "../models.ts";
-import { BackgroundTurns } from "../modules/background/background-turns.ts";
+import { ConversationBackgroundTurns } from "../modules/background/background-turns.ts";
 import { delegateExtension } from "../modules/delegation/delegate.ts";
 import {
+	DefaultDelegator,
 	type DelegationWorker,
-	Delegator,
 } from "../modules/delegation/delegator.ts";
-import { SolWorker } from "../modules/delegation/sol-worker.ts";
-import { discordAdminExtension } from "../modules/discord-admin/discord-admin.ts";
-import { ownerMemoryExtension } from "../modules/memory/owner-memory.ts";
+import { WebResearchWorker } from "../modules/delegation/web-research-worker.ts";
 import { notifyExtension } from "../modules/notify/notify.ts";
 import { Scheduler } from "../modules/schedules/scheduler.ts";
-import {
-	type AgentChannelLookup,
-	schedulesExtension,
-} from "../modules/schedules/schedules.ts";
+import { schedulesExtension } from "../modules/schedules/schedules.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
-import type {
-	SessionContext,
-	SessionTool,
-	SessionToolSnapshot,
-} from "../sessions.ts";
-import { THE_SPEAKER } from "../speakers.ts";
+import {
+	AGENTS,
+	BACKGROUND_TURNS,
+	DELEGATION,
+	SCHEDULES,
+} from "../services.ts";
+import type { SessionContext } from "../sessions.ts";
+import { DELEGATE_TOOL } from "../shared/delegate-tool.ts";
+import { SCHEDULE_TOOLS } from "../shared/schedule-tools.ts";
+import { THE_SPEAKER, type Tier } from "../speakers.ts";
+import { DISCORD } from "./discord.ts";
+import { fixed } from "./session-tool.ts";
 
 export interface ModulesOptions {
 	/** Who the tools serve in the owner's own sessions. */
@@ -42,58 +44,68 @@ export interface ModulesOptions {
 		thinking: ThinkingLevel;
 		worker?: DelegationWorker;
 	};
-	/** Another agent's channel, for reading its schedules; throws ScheduleError when unknown. */
-	agentChannelOf?: AgentChannelLookup;
 }
 
-/** A session tool whose extension never changes. */
-function fixed(
-	name: string,
-	factory: SessionToolSnapshot["factory"],
-): SessionTool {
-	return { name, phase: "tools", snapshot: () => ({ revision: 0, factory }) };
-}
+/**
+ * Admins schedule and delegate; every speaker may list schedules and use the web tools the
+ * delegated worker and pi-web-access give. Notifying the owner stays with the owner.
+ */
+const MODULE_TIERS: Readonly<Record<string, Tier>> = {
+	...Object.fromEntries(
+		[...SCHEDULE_TOOLS, DELEGATE_TOOL].map((tool) => [tool, "admin" as const]),
+	),
+	schedule_list: "member",
+	web_search: "member",
+	fetch_content: "member",
+	get_search_content: "member",
+};
 
 /**
- * The owner's modules: memory, notifications, schedules, delegated tasks, and Discord reading
- * and management, each a session tool, and the turns nobody wrote. The delegator's running jobs
- * join the shutdown drain.
+ * The owner's modules: notifications, schedules, and delegated tasks, each a session tool, and
+ * the turns nobody wrote. The delegator's running jobs join the shutdown drain.
  */
 export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
-	const { owner, agentChannelOf } = options;
+	const { owner } = options;
 	// Outside the agent server a conversation has no channel of its own to post a run in.
 	const channelFor = async (
 		channel: ChannelKey,
-		surfaceOwnerChannel: () => Promise<ChannelKey>,
-	) => (channel.startsWith("discord:") ? channel : surfaceOwnerChannel());
+		surfaces: SurfacePort,
+		ownerChannel: () => Promise<ChannelKey>,
+	) => (surfaces.of(channel) ? channel : ownerChannel());
 	return {
 		name: "modules",
-		setup: ({ conversations, core, logger }) => {
-			const { stores, discord } = core;
-			const { surface } = discord;
+		provides: [BACKGROUND_TURNS, DELEGATION],
+		setup: ({ conversations, services, logger, surfaces }) => {
+			const schedules = services.get(SCHEDULES);
+			const discord = services.get(DISCORD);
+			const { connection } = discord;
+			// Another agent's channel, for schedule_list; asked when a tool runs, after the agent server set up.
+			const agentChannelOf = (agent: string) =>
+				services.get(AGENTS).team.channelOf(agent);
 			const ownerChannelFor = (channel: ChannelKey) =>
-				channelFor(channel, () => surface.ownerChannel());
-			const background = new BackgroundTurns({
+				channelFor(channel, surfaces, () => connection.ownerChannel());
+			const background = new ConversationBackgroundTurns({
 				conversations,
 				system: { id: "assistant", name: options.assistant },
 				logger,
 			});
-			const delegator = new Delegator({
+			const delegator = new DefaultDelegator({
 				worker:
 					options.delegation.worker ??
-					new SolWorker({
+					new WebResearchWorker({
 						modelRuntime: options.modelRuntime,
 						agentDir: options.agentDir,
 						workDir: join(options.dataDir, "delegate"),
 						model: options.delegation.model,
 						thinking: options.delegation.thinking,
 					}),
+				targets: (name) => conversations.target(name),
 				deliver: (job, outcome) => background.runDelegated(job, outcome),
 				threads: discord.threads,
 				logger,
 			});
-			core.provide("background", background);
-			core.provide("delegator", delegator);
+			services.provide(BACKGROUND_TURNS, background);
+			services.provide(DELEGATION, delegator);
 			// An agent session serves every speaker, so its tools name none.
 			const served = (session: SessionContext) =>
 				session.agent ? THE_SPEAKER : owner;
@@ -102,19 +114,11 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 					{ name: "delegator", busy: () => delegator.runningChannels() },
 				],
 				sessionTools: [
-					fixed("owner-memory", (session) =>
-						ownerMemoryExtension(
-							stores.memory,
-							served(session),
-							// The owner's own chats have one speaker; the agent server's have several.
-							session.agent ? session.speaker : undefined,
-						),
-					),
-					fixed("notify", () => notifyExtension(surface, owner)),
+					fixed("notify", () => notifyExtension(connection, owner)),
 					fixed("schedules", (session) =>
 						schedulesExtension(
 							{
-								store: stores.schedules,
+								store: schedules,
 								owner: { id: owner.id, name: owner.name },
 								channelFor: ownerChannelFor,
 							},
@@ -137,10 +141,8 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 							session.speaker,
 						),
 					),
-					fixed("discord-admin", () =>
-						discordAdminExtension(surface.ownerDiscord(), owner),
-					),
 				],
+				toolTiers: MODULE_TIERS,
 			};
 		},
 	};
@@ -153,12 +155,22 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 export function schedulerPlugin(): RoundtablePlugin {
 	return {
 		name: "schedules",
-		setup: ({ core, logger }) => {
+		setup: ({ conversations, services, env, logger }) => {
+			const schedules = services.get(SCHEDULES);
 			const scheduler = new Scheduler({
-				store: core.stores.schedules,
-				runner: core.background,
+				store: schedules,
+				runner: services.get(BACKGROUND_TURNS),
 				logger,
 			});
+			// Without Discord there are no schedule commands; the scheduler still fires.
+			const discord = services.find(DISCORD);
+			discord?.commands.add(
+				scheduleCommands(
+					discord.guard,
+					schedules,
+					(target) => conversations.target(target)?.label(env.locale) ?? target,
+				),
+			);
 			return {
 				services: [
 					{
@@ -167,9 +179,6 @@ export function schedulerPlugin(): RoundtablePlugin {
 						stop: () => scheduler.stop(),
 					},
 				],
-				interactions: [
-					scheduleCommands(core.discord.guard, core.stores.schedules),
-				],
 			};
 		},
 	};

package/src/core/builtin/session-tool.ts

@@ -0,0 +1,24 @@
+import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import type {
+	AgentTurnScope,
+	SessionTool,
+	SessionToolSnapshot,
+} from "../sessions.ts";
+
+/** A session tool whose extension never changes. */
+export function fixed(
+	name: string,
+	factory: SessionToolSnapshot["factory"],
+): SessionTool {
+	return { name, phase: "tools", snapshot: () => ({ revision: 0, factory }) };
+}
+
+/** A session tool whose extension never changes, for agent sessions only. */
+export function agentOnly(
+	name: string,
+	factory: (scope: AgentTurnScope) => ExtensionFactory,
+): SessionTool {
+	return fixed(name, (session) =>
+		session.agent ? factory(session.agent) : null,
+	);
+}

package/src/core/builtin/skills.ts

@@ -0,0 +1,72 @@
+import type { SQL } from "bun";
+import { StoredSkillRegistry } from "../modules/skills/skill-registry.ts";
+import { SkillStore } from "../modules/skills/skill-store.ts";
+import {
+	SKILL_LIST_TOOL,
+	SKILL_TOOLS,
+	skillToolsExtension,
+} from "../modules/skills/skill-tools.ts";
+import type { RoundtablePlugin } from "../plugin.ts";
+import { AGENTS, SKILLS } from "../services.ts";
+import type { Tier } from "../speakers.ts";
+import { agentOnly } from "./session-tool.ts";
+
+export interface SkillsOptions {
+	/** The guild whose agents' skills the store keeps. */
+	guildId: string;
+	/** Where the registry reads and writes skills. */
+	reposDir: string;
+	writtenDir: string;
+	builtinDir: string;
+}
+
+/** Admins manage skills; every speaker may look one up. */
+const SKILL_TIERS: Readonly<Record<string, Tier>> = {
+	...Object.fromEntries(SKILL_TOOLS.map((tool) => [tool, "admin" as const])),
+	[SKILL_LIST_TOOL]: "member",
+};
+
+/**
+ * The skills agents carry: the tables, the registry provided as `SKILLS`, and the skill tools of
+ * agent sessions. An addon; `skills: false` leaves it out, and agents carry none.
+ */
+export function skillsPlugin(
+	options: SkillsOptions,
+	/** Opens the store; a test hands a stand-in, so the plugin can be set up without a database. */
+	openStore: (sql: SQL, guildId: string) => Promise<SkillStore> = (
+		sql,
+		guildId,
+	) => SkillStore.attach(sql, guildId),
+): RoundtablePlugin {
+	let registry: StoredSkillRegistry | undefined;
+	return {
+		name: "skills",
+		migrations: SkillStore.migrations(options.guildId),
+		provides: [SKILLS],
+		// The skills are read once every plugin is set up, so a plugin may still place some in setup.
+		preflight: () => registry?.init(),
+		setup: async ({ database, services, logger }) => {
+			const built = new StoredSkillRegistry({
+				store: await openStore(database(), options.guildId),
+				reposDir: options.reposDir,
+				writtenDir: options.writtenDir,
+				builtinDir: options.builtinDir,
+				logger,
+			});
+			registry = built;
+			services.provide(SKILLS, built);
+			return {
+				sessionTools: [
+					agentOnly("skill-tools", () =>
+						skillToolsExtension(built, (name) => {
+							// The agent server is set up after this plugin and read when a session is built.
+							services.get(AGENTS).directory.activeAgent(name);
+						}),
+					),
+				],
+				agentSelection: () => ({ tools: SKILL_TOOLS, groups: [] }),
+				toolTiers: SKILL_TIERS,
+			};
+		},
+	};
+}

package/src/core/builtin/stores.ts

@@ -1,41 +1,65 @@
-import { AgentStore } from "../agents/agent-store.ts";
-import { OwnerMemoryStore } from "../modules/memory/owner-memory-store.ts";
-import { ScheduleStore } from "../modules/schedules/schedule-store.ts";
-import { SkillStore } from "../modules/skills/skill-store.ts";
+import type { OwnerIdentity } from "../identity.ts";
+import { ownerMemoryExtension } from "../modules/memory/owner-memory.ts";
+import { PgMemoryStore } from "../modules/memory/owner-memory-store.ts";
+import { PgScheduleStore } from "../modules/schedules/schedule-store.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
-import { PendingConfirmationStore } from "../runtime/pending-confirmation-store.ts";
+import { MEMORY, SCHEDULES } from "../services.ts";
+import { THE_SPEAKER, type Tier } from "../speakers.ts";
+import { fixed } from "./session-tool.ts";
 
-export interface StoresOptions {
-	/** The owner's Discord id: the speaker whose memory the first rows belong to. */
-	ownerId: string;
-	/** The agent server's guild; every agent-server row carries it. */
-	guildId: string;
+export interface MemoryOptions {
+	/** The owner: whose memory the first rows belong to, and whom the tools serve in the owner's own sessions. */
+	owner: OwnerIdentity & { id: string };
 }
 
+/** Each speaker keeps a memory of their own, so every tier may use the tools; the owner's reaches only the owner's turns. */
+const MEMORY_TIERS: Readonly<Record<string, Tier>> = {
+	memory_add: "member",
+	memory_search: "member",
+	memory_remove: "member",
+};
+
 /**
- * The core's own tables and the stores over them. The host migrates them over its one pool
- * before any setup, in this order, and closes the pool after every service has stopped.
+ * The remembered facts of each speaker: the table, the store over it provided as `MEMORY`, and
+ * the memory tools and prompt block of every conversation. An addon; `memory: false` leaves it
+ * out. The host migrates the table over its one pool before any setup.
  */
-export function storesPlugin(options: StoresOptions): RoundtablePlugin {
-	const { ownerId, guildId } = options;
+export function memoryPlugin(options: MemoryOptions): RoundtablePlugin {
+	const { owner } = options;
+	return {
+		name: "memory",
+		migrations: PgMemoryStore.migrations(owner.id),
+		provides: [MEMORY],
+		setup: ({ database, services }) => {
+			const memory = PgMemoryStore.attach(database(), owner.id);
+			services.provide(MEMORY, memory);
+			return {
+				sessionTools: [
+					fixed("owner-memory", (session) =>
+						ownerMemoryExtension(
+							memory,
+							owner.id,
+							// An agent session serves every speaker, so its tools name none.
+							session.agent ? THE_SPEAKER : owner,
+							// The owner's own chats have one speaker; the agent server's have several.
+							session.agent ? session.speaker : undefined,
+						),
+					),
+				],
+				toolTiers: MEMORY_TIERS,
+			};
+		},
+	};
+}
+
+/** The scheduled turns' table, and the store over it provided as `SCHEDULES`. */
+export function scheduleStorePlugin(): RoundtablePlugin {
 	return {
-		name: "stores",
-		migrations: [
-			...OwnerMemoryStore.migrations(ownerId),
-			ScheduleStore.migration,
-			PendingConfirmationStore.migration,
-			...AgentStore.migrations(guildId),
-			...SkillStore.migrations(guildId),
-		],
-		setup: async ({ database, core }) => {
-			const sql = database();
-			core.provide("stores", {
-				memory: OwnerMemoryStore.attach(sql, ownerId),
-				schedules: await ScheduleStore.attach(sql),
-				confirmations: await PendingConfirmationStore.attach(sql),
-				agents: await AgentStore.attach(sql, guildId),
-				skills: await SkillStore.attach(sql, guildId),
-			});
+		name: "schedule-store",
+		migrations: [PgScheduleStore.migration],
+		provides: [SCHEDULES],
+		setup: async ({ database, services }) => {
+			services.provide(SCHEDULES, await PgScheduleStore.attach(database()));
 			return {};
 		},
 	};

package/src/core/config/config.ts

@@ -18,6 +18,7 @@ import {
 	number,
 	oneOf,
 	optional,
+	orOff,
 	record,
 	shape,
 	text,
@@ -48,6 +49,17 @@ export interface RoundtableConfig {
 		entryChannel: string;
 		/** The root slash command, without the slash; default the lowercase assistant name. */
 		rootCommand?: string;
+		/**
+		 * Whether the owner's conversations have Discord administration tools; default true. `false`
+		 * leaves the `discord-admin` addon out.
+		 */
+		admin?: boolean;
+		/**
+		 * Text appended as it is to the refusal a non-owner gets from the root command, such as a
+		 * pointer to the commands anyone may use; include the space or punctuation your language
+		 * needs before it. Default none.
+		 */
+		refusalHint?: string;
 	};
 	database: { url: string };
 	/** Where the process keeps its files, such as pictures, attachments, and skills. */
@@ -74,19 +86,31 @@ export interface RoundtableConfig {
 	agents?: AgentSeed[];
 	/**
 	 * Where the agents' avatars are served: the public address that reaches it, and the TCP port
-	 * (default 3000) or unix socket the process listens on.
+	 * (default 3000) or unix socket the process listens on. `socketMode` is the socket file's
+	 * permission bits (default `0o660`); widen it only for a proxy that runs as another user.
 	 */
 	http: {
 		publicUrl: string;
 		port?: number;
 		hostname?: string;
 		socketPath?: string;
+		socketMode?: number;
 	};
 	/** A picture of your own for agents without one, and the style reference for drawing them; default a plain bot. */
 	avatar?: string;
 	/** The agents' shared working directory; default `<dataDir>/work`. */
 	workDir?: string;
-	skills?: { builtinDir?: string; reposDir?: string };
+	/**
+	 * Where the skill registry reads built-in skills and keeps linked repositories. `false` leaves
+	 * the `skills` addon out: agents carry no skills, and no skill tools exist. Stored skills stay
+	 * in their tables.
+	 */
+	skills?: false | { builtinDir?: string; reposDir?: string };
+	/**
+	 * Whether each speaker's memory is kept and offered as tools; default true. `false` leaves the
+	 * `memory` addon out: no memory tools, no memory prompt block, and the table stays as it is.
+	 */
+	memory?: boolean;
 	/** The agent that investigates the process's own errors, by name. */
 	ops?: { agent: string };
 	plugins?: RoundtablePlugin[];
@@ -116,6 +140,8 @@ const schema = shape({
 		guild: text,
 		entryChannel: text,
 		rootCommand: optional(text),
+		admin: optional(bool),
+		refusalHint: optional(text),
 	}),
 	database: shape({ url: text }),
 	dataDir: text,
@@ -158,12 +184,14 @@ const schema = shape({
 		port: optional(integer(1, 65535)),
 		hostname: optional(text),
 		socketPath: optional(text),
+		socketMode: optional(integer(0, 0o777)),
 	}),
 	avatar: optional(text),
 	workDir: optional(text),
 	skills: optional(
-		shape({ builtinDir: optional(text), reposDir: optional(text) }),
+		orOff(shape({ builtinDir: optional(text), reposDir: optional(text) })),
 	),
+	memory: optional(bool),
 	ops: optional(shape({ agent: text })),
 	plugins: optional(
 		list(
@@ -187,6 +215,8 @@ export interface ResolvedConfig {
 		guild: string;
 		entryChannel: string;
 		rootCommand: string;
+		admin: boolean;
+		refusalHint?: string;
 	};
 	databaseUrl: string;
 	dataDir: string;
@@ -206,10 +236,13 @@ export interface ResolvedConfig {
 		port: number;
 		hostname?: string;
 		socketPath?: string;
+		socketMode?: number;
 	};
 	avatar?: string;
 	workDir: string;
-	skills: { builtinDir?: string; reposDir?: string };
+	/** `false` when the skills addon is off. */
+	skills: false | { builtinDir?: string; reposDir?: string };
+	memory: boolean;
 	ops?: { agent: string };
 	plugins: RoundtablePlugin[];
 }
@@ -243,6 +276,10 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 			rootCommand:
 				config.discord.rootCommand ??
 				name.toLowerCase().replace(/[^a-z0-9-]+/g, "-"),
+			admin: config.discord.admin ?? true,
+			...(config.discord.refusalHint === undefined
+				? {}
+				: { refusalHint: config.discord.refusalHint }),
 		},
 		databaseUrl: config.database.url,
 		dataDir: config.dataDir,
@@ -275,10 +312,14 @@ export function resolveConfig(input: unknown): ResolvedConfig {
 			port: config.http.port ?? 3000,
 			...(config.http.hostname ? { hostname: config.http.hostname } : {}),
 			...(config.http.socketPath ? { socketPath: config.http.socketPath } : {}),
+			...(config.http.socketMode === undefined
+				? {}
+				: { socketMode: config.http.socketMode }),
 		},
 		...(config.avatar ? { avatar: config.avatar } : {}),
 		workDir: config.workDir ?? `${config.dataDir}/work`,
 		skills: config.skills ?? {},
+		memory: config.memory ?? true,
 		...(config.ops ? { ops: config.ops } : {}),
 		plugins: config.plugins ?? [],
 	};

package/src/core/config/schema.ts

@@ -115,6 +115,12 @@ export const guarded = <T>(
 	},
 });
 
+/** `false`, or whatever `item` accepts: a feature that is switched off, or configured. */
+export const orOff = <T>(item: Field<T>): Field<T | false> => ({
+	describe: `false, or ${item.describe}`,
+	check: (value, path) => (value === false ? false : item.check(value, path)),
+});
+
 /** A field that may be left out. */
 export type Optional<T> = { optional: Field<T> };