pi-roundtable 0.7.18 → 0.8.0

package/src/core/builtin/agent-server.ts

@@ -11,28 +11,26 @@ import { FileAvatarStudio } from "../agents/avatar-studio.ts";
 import { RelevanceScorer } from "../agents/group-round.ts";
 import { discordKey } from "../agents/team-keys.ts";
 import { ownerAttachmentDir } from "../attachments/attachment-dir.ts";
-import type { AgentRuntime, AgentSessions } from "../contract/runtime.ts";
+import type { AgentSessions } from "../contract/runtime.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
 import { ConfigError } from "../domain/errors.ts";
-import type { InterimTextMode } from "../domain/interim.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import { ConfirmationJudge } from "../judging/confirmation-judge.ts";
-import { AGENT_BRIEF, EffortJudge } from "../judging/effort-judge.ts";
-import {
-	AUTO_THINKING,
-	formatModelRef,
-	type ModelRef,
-	type ThinkingLevel,
-} from "../models.ts";
+import { AUTO_THINKING, formatModelRef, type ModelRef } from "../models.ts";
 import type { ErrorReporter } from "../ops/error-reporter.ts";
 import type { PluginContext, RoundtablePlugin } from "../plugin.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
 import { agentPromptExtension } from "../runtime/extensions/agent-prompt.ts";
-import { PendingConfirmationStore } from "../runtime/pending-confirmation-store.ts";
-import { PiAgentRuntime } from "../runtime/pi-agent-runtime.ts";
-import { AGENTS, BACKGROUND_TURNS, SCHEDULES, SKILLS } from "../services.ts";
+import type { AgentSessionsSlot } from "../runtime/runtime-plugin.ts";
+import {
+	AGENTS,
+	BACKGROUND_TURNS,
+	RUNTIME,
+	SCHEDULES,
+	SKILLS,
+} from "../services.ts";
 import type { SessionTool } from "../sessions.ts";
-import type { Speaker, SpeakerPolicy, Tier } from "../speakers.ts";
+import type { SpeakerPolicy, Tier } from "../speakers.ts";
 import { DISCORD } from "./discord.ts";
 import { agentOnly } from "./session-tool.ts";
 
@@ -45,15 +43,15 @@ export interface AgentServerOptions {
 	assistant: string;
 	/** Who may talk to the agents, and at which tier. */
 	speakers: SpeakerPolicy;
-	/** Shared with the rest of the host, so logins refresh in one place. */
+	/** Shared with the rest of the host, so logins refresh in one place; lists the models an agent may run. */
 	modelRuntime: ModelRuntime;
-	agentDir: string;
 	dataDir: string;
-	/** The model of agents and of the assistant, and the thinking level a judge falls back to. */
+	/** The model of agents and of the assistant. */
 	model: ModelRef;
-	thinking: ThinkingLevel;
-	/** How sure the judges must be before their answer is used. */
+	/** How sure the confirmation judge must be before its answer is used. */
 	judgeThreshold: number;
+	/** Where the agent server hands the runtime plugin its per-agent settings. */
+	agents?: AgentSessionsSlot;
 	/** The shell's shared working directory. */
 	workDir: string;
 	/**
@@ -73,10 +71,6 @@ export interface AgentServerOptions {
 	avatarReference: string;
 	/** Reports the process's own errors to an agent; without one nothing is reported. */
 	errorReporter?: ErrorReporter;
-	/** Whether turns post the text they write before their final answer as they go; default "on". */
-	interimText?: InterimTextMode;
-	/** An intermediate text this long or longer is posted as an ordinary message; default 400. */
-	interimPrimaryChars?: number;
 }
 
 /** The name of the agent server's plugin, as `serviceStarted` events name it. */
@@ -109,11 +103,9 @@ const AGENT_TIERS: Readonly<Record<string, Tier>> = {
 	channel_read: "member",
 };
 
-/** The tables the agent server keeps: its agents and groups, and the held actions. */
+/** The tables the agent server keeps: its agents and groups. */
 export interface AgentServerStores {
 	agents: PgAgentStore;
-	/** Held actions, kept across a restart. */
-	confirmations: PendingConfirmationStore;
 }
 
 /** Attaches the agent server's stores over the host's migrated pool. */
@@ -121,16 +113,14 @@ async function attachStores(
 	sql: SQL,
 	guildId: string,
 ): Promise<AgentServerStores> {
-	return {
-		agents: await PgAgentStore.attach(sql, guildId),
-		confirmations: await PendingConfirmationStore.attach(sql),
-	};
+	return { agents: await PgAgentStore.attach(sql, guildId) };
 }
 
 /**
- * The agent server: the team with its channels and dashboard, and the runtime that runs every
- * agent turn. The skills the agents carry come from the skills addon when it is on. It claims the agent channels, starts the team in the
- * background, and hands what it built to the plugins after it.
+ * The agent server: the team with its channels and dashboard, run on the runtime plugin's runtime,
+ * which it hands its per-agent settings. The skills the agents carry come from the skills addon
+ * when it is on. It claims the agent channels, starts the team in the background, and hands what
+ * it built to the plugins after it.
  */
 export function agentServerPlugin(
 	options: AgentServerOptions,
@@ -141,18 +131,13 @@ export function agentServerPlugin(
 	) => Promise<AgentServerStores> = (context, guildId) =>
 		attachStores(context.database(), guildId),
 ): RoundtablePlugin {
-	let runtime: AgentRuntime | undefined;
 	return {
 		name: AGENT_SERVER_PLUGIN,
-		// The agent server's own tables; the host runs them before any setup, in this order.
-		migrations: [
-			PendingConfirmationStore.migration,
-			...PgAgentStore.migrations(options.guildId),
-		],
+		// The agent server's own tables; the host runs them before any setup, in this order. The
+		// held actions' table is the runtime plugin's.
+		migrations: PgAgentStore.migrations(options.guildId),
 		provides: [AGENTS],
-		preflight: async () => {
-			await runtime?.preflight?.();
-		},
+		requires: [RUNTIME],
 		setup: async (context) => {
 			const discord = context.services.get(DISCORD);
 			const schedules = context.services.get(SCHEDULES);
@@ -168,10 +153,8 @@ export function agentServerPlugin(
 			await studio.init();
 			// Absent when the skills addon is off: the agents then carry none.
 			const skills = context.services.find(SKILLS);
-			const { agents: store, confirmations: heldActions } = await openStores(
-				context,
-				options.guildId,
-			);
+			const { agents: store } = await openStores(context, options.guildId);
+			const running = context.services.get(RUNTIME);
 			const judge = providers.judge;
 			const confirmations = new ConfirmationJudge({
 				judge,
@@ -194,11 +177,7 @@ export function agentServerPlugin(
 				store,
 				channels: connection.agentChannels(options.guildId),
 				studio,
-				// The runtime is built next, with this team's tools.
-				runtime: () => {
-					if (!runtime) throw new Error("the runtime is built with the team");
-					return runtime;
-				},
+				runtime: () => running,
 				confirmations,
 				scorer: new RelevanceScorer(judge, logger, options.owner),
 				models: {
@@ -247,50 +226,7 @@ export function agentServerPlugin(
 				skills: (name) => built.skillsOf(name),
 				turnChannel: (scope) => built.turnChannel(scope),
 			};
-			const prompts = (channel: ChannelKey, speaker?: Speaker) =>
-				context.surfaces.prompts(channel, speaker);
-			// A plugin that fills the runtime slot replaces the whole conversation runtime; without
-			// one the agent server runs Pi, built from the options below.
-			const running: AgentRuntime = providers.filled.has("runtime")
-				? providers.runtime({
-						logger,
-						env: context.env,
-						owner: { id: options.owner.id, name: options.owner.name },
-						sessions: context.sessions,
-						toolTiers: context.toolTiers,
-						prompts,
-						agents: agentSessions,
-						confirmations: heldActions,
-						judge,
-					})
-				: new PiAgentRuntime({
-						owner: options.owner,
-						sessions: context.sessions,
-						agentDir: options.agentDir,
-						modelRuntime: options.modelRuntime,
-						dataDir: options.dataDir,
-						model: options.model,
-						thinking: options.thinking,
-						effort: new EffortJudge({
-							judge,
-							brief: AGENT_BRIEF,
-							fallback: options.thinking,
-							threshold: options.judgeThreshold,
-							logger,
-						}),
-						confirmations: heldActions,
-						toolTiers: context.toolTiers,
-						agents: agentSessions,
-						prompts,
-						logger,
-						...(options.interimText
-							? { interimText: options.interimText }
-							: {}),
-						...(options.interimPrimaryChars
-							? { interimPrimaryChars: options.interimPrimaryChars }
-							: {}),
-					});
-			runtime = running;
+			options.agents?.bind(agentSessions);
 			context.services.provide(AGENTS, {
 				team: built,
 				directory: store,
@@ -325,7 +261,6 @@ export function agentServerPlugin(
 				});
 			return {
 				services: [
-					{ name: "runtime", stop: () => running.dispose?.() },
 					{ name: "dashboard", stop: () => dashboard.stop() },
 					{
 						name: AGENT_TEAM_SERVICE,

package/src/core/builtin/modules.ts

@@ -1,8 +1,14 @@
 import { join } from "node:path";
 import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { OWNER_TARGET } from "../agents/agent-claim.ts";
 import type { SurfacePort } from "../contract/surface.ts";
 import { scheduleCommands } from "../discord/schedule-commands.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
+import {
+	ConfigError,
+	DelegationError,
+	ScheduleError,
+} from "../domain/errors.ts";
 import { messages } from "../i18n/index.ts";
 import type { OwnerIdentity } from "../identity.ts";
 import type { ModelRef, ThinkingLevel } from "../models.ts";
@@ -17,7 +23,9 @@ import { notifyExtension } from "../modules/notify/notify.ts";
 import { precheckScriptHoldRule } from "../modules/schedules/precheck-tools.ts";
 import { Scheduler } from "../modules/schedules/scheduler.ts";
 import { schedulesExtension } from "../modules/schedules/schedules.ts";
+import type { ErrorReporter } from "../ops/error-reporter.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
+import { splitReply } from "../presentation/reply-splitter.ts";
 import {
 	AGENTS,
 	BACKGROUND_TURNS,
@@ -33,6 +41,11 @@ import { DISCORD } from "./discord.ts";
 import { fixed } from "./session-tool.ts";
 
 export interface ModulesOptions {
+	/**
+	 * Reports the process's own errors to a conversation, connected when the modules start; one
+	 * that reports to an agent is the agent server's to connect.
+	 */
+	errorReporter?: ErrorReporter;
 	/** Who the tools serve in the owner's own sessions. */
 	owner: OwnerIdentity & { id: string };
 	/** The name a turn the process itself starts is written by. */
@@ -65,19 +78,32 @@ const MODULE_TIERS: Readonly<Record<string, Tier>> = {
 
 /**
  * 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.
+ * the turns nobody wrote. The delegator's running jobs join the shutdown drain. Without Discord
+ * there are no owner's messages: no `notify_owner`, and a conversation no chat surface carries
+ * can neither schedule nor delegate. Without the owner's background target no session gets the
+ * schedule or delegation tools.
  */
 export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 	const { owner } = options;
-	// Outside the agent server a conversation has no channel of its own to post a run in.
+	// A conversation no chat surface carries posts its runs in the owner's messages, when there are any.
 	const channelFor = async (
 		channel: ChannelKey,
 		surfaces: SurfacePort,
-		ownerChannel: () => Promise<ChannelKey>,
-	) => (surfaces.of(channel) ? channel : ownerChannel());
+		ownerChannel: (() => Promise<ChannelKey>) | undefined,
+		refused: (message: string) => Error,
+	) => {
+		if (surfaces.of(channel)) return channel;
+		if (ownerChannel) return ownerChannel();
+		throw refused(
+			"this conversation has no chat surface to post a run in, and the host has no owner's messages to post it in instead",
+		);
+	};
+	// Set up once the modules set up; the preflight reads it after every plugin linked.
+	let reportsReach: (() => void) | undefined;
 	return {
 		name: "modules",
 		provides: [BACKGROUND_TURNS, DELEGATION],
+		preflight: () => reportsReach?.(),
 		setup: ({
 			conversations,
 			services,
@@ -89,13 +115,29 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 			const schedules = services.get(SCHEDULES);
 			// Absent when a plugin list leaves the prechecks plugin out: then none can be attached.
 			const prechecks = services.find(PRECHECKS);
-			const discord = services.get(DISCORD);
-			const { connection } = discord;
+			// Absent on a host without Discord: then there are no owner's messages and no threads.
+			const discord = services.find(DISCORD);
+			const connection = discord?.connection;
+			const ownerChannel = connection
+				? () => connection.ownerChannel()
+				: undefined;
 			// 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, surfaces, () => connection.ownerChannel());
+			const scheduleChannelFor = (channel: ChannelKey) =>
+				channelFor(
+					channel,
+					surfaces,
+					ownerChannel,
+					(message) => new ScheduleError(message),
+				);
+			const delegateChannelFor = (channel: ChannelKey) =>
+				channelFor(
+					channel,
+					surfaces,
+					ownerChannel,
+					(message) => new DelegationError(message),
+				);
 			const background = new ConversationBackgroundTurns({
 				conversations,
 				system: { id: "assistant", name: options.assistant },
@@ -113,7 +155,7 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 					}),
 				targets: (name) => conversations.target(name),
 				deliver: (job, outcome) => background.runDelegated(job, outcome),
-				threads: discord.threads,
+				...(discord ? { threads: discord.threads } : {}),
 				logger,
 			});
 			services.provide(BACKGROUND_TURNS, background);
@@ -121,9 +163,60 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 			// An agent session serves every speaker, so its tools name none.
 			const served = (session: SessionContext) =>
 				session.agent ? THE_SPEAKER : owner;
+			// Schedules and delegated reports run as the owner's background turns; without a plugin
+			// contributing that target, as on a host without the agent server, none could ever start,
+			// so no session gets the tools. Read when a session is made, after every plugin set up.
+			const ownerTurns = () =>
+				conversations.target(OWNER_TARGET.name) !== undefined;
+			// A reporter for an ops agent is the agent server's to connect.
+			const reporter =
+				options.errorReporter &&
+				"conversation" in options.errorReporter.destination
+					? options.errorReporter
+					: undefined;
+			if (reporter && "conversation" in reporter.destination) {
+				const channel = reporter.destination.conversation;
+				// A report that no surface can post, or that no conversation owns, would only be logged;
+				// its report turn is the owner's background turn, which runs only where a claim takes one.
+				reportsReach = () => {
+					if (!surfaces.of(channel))
+						throw new ConfigError(
+							`config ops.conversation: no chat surface serves ${JSON.stringify(channel)}, so its error reports could never be posted. Name a conversation of a surface a plugin brings, or leave ops out.`,
+						);
+					if (!conversations.owns(channel))
+						throw new ConfigError(
+							`config ops.conversation: no plugin's conversations own ${JSON.stringify(channel)}, so nothing answers its error reports. Name a conversation a plugin's claim owns, or leave ops out.`,
+						);
+					if (!ownerTurns())
+						throw new ConfigError(
+							`config ops.conversation: no plugin contributes the "${OWNER_TARGET.name}" background target, so the report turns of ${JSON.stringify(channel)} could never run. Configure discord, whose agent server contributes it, add a plugin that contributes it, or leave ops out.`,
+						);
+					if (!conversations.takesBackground(channel))
+						throw new ConfigError(
+							`config ops.conversation: the claim that owns ${JSON.stringify(channel)} takes no background turns, so nothing answers its error reports. Name a conversation whose claim takes background turns, or leave ops out.`,
+						);
+				};
+			}
 			return {
 				services: [
 					{ name: "delegator", busy: () => delegator.runningChannels() },
+					...(reporter
+						? [
+								{
+									name: "error-reports",
+									start: () =>
+										reporter.connect({
+											post: (channel, text) =>
+												surfaces.sendReply(channel, {
+													chunks: splitReply(text),
+												}),
+											turn: (channel, text) =>
+												background.runErrorReport(channel, text),
+											logger,
+										}),
+								},
+							]
+						: []),
 				],
 				// Saving a precheck script that calls a held tool waits for the owner, as the call would.
 				holdRules: [
@@ -134,34 +227,40 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 					}),
 				],
 				sessionTools: [
-					fixed("notify", () => notifyExtension(connection, owner)),
+					...(connection
+						? [fixed("notify", () => notifyExtension(connection, owner))]
+						: []),
 					fixed("schedules", (session) =>
-						schedulesExtension(
-							{
-								store: schedules,
-								owner: { id: owner.id, name: owner.name },
-								channelFor: ownerChannelFor,
-								...(prechecks ? { prechecks } : {}),
-								holds: () => sessions().holds,
-							},
-							session.homeChannel,
-							served(session),
-							session.agent ? agentChannelOf : undefined,
-							session.speaker,
-						),
+						ownerTurns()
+							? schedulesExtension(
+									{
+										store: schedules,
+										owner: { id: owner.id, name: owner.name },
+										channelFor: scheduleChannelFor,
+										...(prechecks ? { prechecks } : {}),
+										holds: () => sessions().holds,
+									},
+									session.homeChannel,
+									served(session),
+									session.agent ? agentChannelOf : undefined,
+									session.speaker,
+								)
+							: null,
 					),
 					fixed("delegate", (session) =>
-						delegateExtension(
-							{
-								delegator,
-								owner: { id: owner.id, name: owner.name },
-								channelFor: ownerChannelFor,
-							},
-							session.homeChannel,
-							served(session),
-							session.turnChannel,
-							session.speaker,
-						),
+						ownerTurns()
+							? delegateExtension(
+									{
+										delegator,
+										owner: { id: owner.id, name: owner.name },
+										channelFor: delegateChannelFor,
+									},
+									session.homeChannel,
+									served(session),
+									session.turnChannel,
+									session.speaker,
+								)
+							: null,
 					),
 				],
 				toolTiers: MODULE_TIERS,

package/src/core/builtin/stores.ts

@@ -4,7 +4,8 @@ import { PgMemoryStore } from "../modules/memory/owner-memory-store.ts";
 import { memoryPrecheckRegistry } from "../modules/schedules/prechecks.ts";
 import { PgScheduleStore } from "../modules/schedules/schedule-store.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
-import { MEMORY, PRECHECKS, SCHEDULES } from "../services.ts";
+import { MEMORY, type MemoryStore, PRECHECKS, SCHEDULES } from "../services.ts";
+import type { SessionTool } from "../sessions.ts";
 import { THE_SPEAKER, type Tier } from "../speakers.ts";
 import { fixed } from "./session-tool.ts";
 
@@ -14,12 +15,37 @@ export interface MemoryOptions {
 }
 
 /** 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>> = {
+export const MEMORY_TIERS: Readonly<Record<string, Tier>> = {
 	memory_add: "member",
 	memory_search: "member",
 	memory_remove: "member",
 };
 
+/** The memory tools and prompt block of every conversation, over the given store. */
+export function memorySessionTool(
+	memory: MemoryStore,
+	owner: MemoryOptions["owner"],
+): SessionTool {
+	return fixed("owner-memory", (session) => {
+		// An agent session serves every speaker, so its tools name none.
+		if (session.agent)
+			return ownerMemoryExtension(
+				memory,
+				owner.id,
+				THE_SPEAKER,
+				session.speaker,
+			);
+		// Any other conversation may admit a member or an admin, who reads and changes their own
+		// memory; an owner-tier speaker, such as remote MCP, speaks as the owner.
+		const speaker = () => {
+			const current = session.speaker();
+			return current?.tier === "owner" ? undefined : current;
+		};
+		// Its tools keep the owner's words, so the owner's own chats read as before.
+		return ownerMemoryExtension(memory, owner.id, owner, speaker, false);
+	});
+}
+
 /**
  * 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
@@ -35,18 +61,7 @@ export function memoryPlugin(options: MemoryOptions): RoundtablePlugin {
 			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,
-						),
-					),
-				],
+				sessionTools: [memorySessionTool(memory, owner)],
 				toolTiers: MEMORY_TIERS,
 			};
 		},

package/src/core/config/adapters.ts

@@ -0,0 +1,57 @@
+import { ConfigError } from "../domain/errors.ts";
+import { bool, optional, shape, text } from "./schema.ts";
+
+/** The Discord settings, at the top level or in a Discord adapter. */
+export const discordShape = shape({
+	token: text,
+	guild: text,
+	entryChannel: text,
+	rootCommand: optional(text),
+	admin: optional(bool),
+	refusalHint: optional(text),
+});
+
+/** The adapters `adapters` takes, by the name their factory gives them. */
+const ADAPTERS = ["discord"] as const;
+
+/**
+ * The configuration with its adapters in the places the host reads them: a Discord adapter's
+ * settings as the top-level `discord`. Throws a ConfigError naming the adapter by its place.
+ */
+// pi-lens-ignore: no-unknown-returns — the configuration as written is untyped until the schema checks it
+export function liftAdapters(input: unknown): unknown {
+	if (typeof input !== "object" || input === null || !("adapters" in input))
+		return input;
+	const { adapters, ...rest } = input as Record<string, unknown>;
+	if (adapters === undefined) return rest;
+	if (!Array.isArray(adapters))
+		throw new ConfigError(
+			`config adapters: expected a list of adapters, such as [discord({ ... })] with discord from pi-roundtable/discord, got ${JSON.stringify(adapters)}. Fix the value in roundtable.config.ts.`,
+		);
+	const lifted: Record<string, unknown> = { ...rest };
+	adapters.forEach((entry: unknown, index) => {
+		const at = `adapters[${index}]`;
+		const name =
+			typeof entry === "object" && entry !== null
+				? (entry as { adapter?: unknown }).adapter
+				: undefined;
+		if (typeof name !== "string")
+			throw new ConfigError(
+				`config ${at}: expected an adapter, an object its factory makes such as discord({ ... }) from pi-roundtable/discord, got ${JSON.stringify(entry)}. Fix the value in roundtable.config.ts.`,
+			);
+		if (!(ADAPTERS as readonly string[]).includes(name))
+			throw new ConfigError(
+				`config ${at}: unknown adapter ${JSON.stringify(name)}. The adapters are ${ADAPTERS.join(", ")}; a chat network that comes as a plugin, such as pi-roundtable-webchat's webChat(), belongs in plugins.`,
+			);
+		if (lifted.discord !== undefined)
+			throw new ConfigError(
+				`config ${at}: Discord is configured twice, at the top level or by another adapter. Keep one.`,
+			);
+		const { adapter: _adapter, ...settings } = entry as Record<string, unknown>;
+		lifted.discord = shape({ discord: discordShape }).check(
+			settings,
+			at,
+		).discord;
+	});
+	return lifted;
+}