pi-roundtable 0.7.19 → 0.8.0

package/src/core/define-roundtable.ts

@@ -13,7 +13,12 @@ import {
 	precheckPlugin,
 	scheduleStorePlugin,
 } from "./builtin/stores.ts";
-import { type RoundtableConfig, resolveConfig } from "./config/config.ts";
+import {
+	type ResolvedConfig,
+	type RoundtableConfig,
+	resolveConfig,
+} from "./config/config.ts";
+import { conversationsPlugin } from "./conversations/conversations-plugin.ts";
 import { ConfigError } from "./domain/errors.ts";
 import { JudgeError } from "./errors.ts";
 import type { RoundtableOptions } from "./host.ts";
@@ -23,6 +28,11 @@ import { createLogger, type LogEntry, type Logger } from "./log.ts";
 import { formatModelRef, type ModelRef } from "./models.ts";
 import { ErrorReporter } from "./ops/error-reporter.ts";
 import type { RoundtablePlugin } from "./plugin.ts";
+import {
+	type AgentSessionsSlot,
+	agentSessionsSlot,
+	runtimePlugin,
+} from "./runtime/runtime-plugin.ts";
 import { speakerPolicy } from "./speakers.ts";
 import { toolTiers } from "./tool-tiers.ts";
 
@@ -86,7 +96,7 @@ function judgeThrough(modelRuntime: ModelRuntime, ref: ModelRef): JudgeModel {
 
 /** The listener `config.http` names: its unix socket when it has one, else its TCP port. */
 function publicListener(
-	http: ReturnType<typeof resolveConfig>["http"],
+	http: NonNullable<ResolvedConfig["http"]>,
 ): ListenerConfig {
 	if (http.socketPath)
 		return {
@@ -101,11 +111,95 @@ function publicListener(
 	};
 }
 
+/** The Discord bot and the agent server that lives there, each in its place in the plugin list. */
+interface DiscordAssembly {
+	discord: RoundtablePlugin;
+	admin: RoundtablePlugin[];
+	skills: RoundtablePlugin[];
+	agentServer: RoundtablePlugin;
+	seeds: RoundtablePlugin;
+}
+
+function discordAssembly(
+	config: ResolvedConfig,
+	discord: NonNullable<ResolvedConfig["discord"]>,
+	shared: {
+		modelRuntime: ModelRuntime;
+		agentSessions: AgentSessionsSlot;
+		errorReporter: ErrorReporter | undefined;
+	},
+): DiscordAssembly {
+	const { name, owner } = config;
+	const speakers = speakerPolicy({
+		owners: [owner.id],
+		...(config.speakers.admins ? { admins: config.speakers.admins } : {}),
+		...(config.speakers.members ? { members: config.speakers.members } : {}),
+	});
+	const sharedPrompt = config.prompts.shared
+		? readPrompt(config.prompts.shared, "prompts.shared")
+		: readPrompt(join(ASSETS, "prompts", "shared.md"), "prompts.shared");
+	const guest = config.prompts.guest
+		? readPrompt(config.prompts.guest, "prompts.guest")
+		: readPrompt(join(ASSETS, "prompts", "shared-guest.md"), "prompts.guest");
+	const { errorReporter } = shared;
+	return {
+		discord: discordPlugin({
+			token: discord.token,
+			ownerId: owner.id,
+			ownerName: owner.name,
+			speakers,
+			rootCommand: discord.rootCommand,
+			dataDir: config.dataDir,
+			...(discord.refusalHint === undefined
+				? {}
+				: { refusalHint: discord.refusalHint }),
+		}),
+		admin: discord.admin ? [discordAdminPlugin({ owner })] : [],
+		skills: config.skills
+			? [
+					skillsPlugin({
+						guildId: discord.guild,
+						reposDir: config.skills.reposDir ?? join(config.dataDir, "repos"),
+						writtenDir: join(config.dataDir, "skills"),
+						builtinDir: config.skills.builtinDir ?? join(ASSETS, "skills"),
+					}),
+				]
+			: [],
+		agentServer: agentServerPlugin({
+			guildId: discord.guild,
+			entryChannelId: discord.entryChannel,
+			owner,
+			assistant: name,
+			speakers,
+			modelRuntime: shared.modelRuntime,
+			dataDir: config.dataDir,
+			model: config.model,
+			judgeThreshold: config.judge.threshold,
+			agents: shared.agentSessions,
+			workDir: config.workDir,
+			scratchDir: config.scratchDir,
+			shellUser: userInfo().username,
+			prompts: { shared: sharedPrompt, guest },
+			avatarListener: "public",
+			// resolveConfig refuses Discord without a public address.
+			avatarUrl: config.http?.publicUrl ?? "",
+			avatarReference: config.avatar ?? join(ASSETS, "neutral.png"),
+			// An ops agent's reports are the agent server's to deliver.
+			...(errorReporter && "agent" in errorReporter.destination
+				? { errorReporter }
+				: {}),
+		}),
+		seeds: seedsPlugin(config.agents),
+	};
+}
+
 /**
  * The host's options and the plugin list of a configured bot: the built-in plugins in their
  * fixed order (each service one provides is read by the ones after it), then the operator's, then the scheduler, so a due schedule fires only once
  * everything it reaches runs. The memory, Discord administration, and skills addons are left out
- * when the configuration switches them off. Configuration mistakes stop here, naming the key and the fix.
+ * when the configuration switches them off. Without `discord` the Discord plugins, the skills,
+ * the agent server and its seeds are left out, and the runtime still runs every turn of
+ * `context.turns`. Configuration mistakes stop here, naming the key and the fix.
  */
 export async function defineRoundtable(
 	input: RoundtableConfig,
@@ -122,13 +216,13 @@ export async function defineRoundtable(
 		}));
 	const registry = new ModelRegistry(modelRuntime);
 	const errorReporter = config.ops
-		? new ErrorReporter({ opsAgent: config.ops.agent, app: name })
+		? new ErrorReporter({ destination: config.ops, app: name })
 		: undefined;
 	const { errorSink } = overrides;
 	const logger =
 		overrides.logger ??
 		createLogger(
-			discord.rootCommand,
+			config.slug,
 			errorReporter || errorSink
 				? (entry) => {
 						errorReporter?.record(entry);
@@ -136,17 +230,15 @@ export async function defineRoundtable(
 					}
 				: undefined,
 		);
-	const speakers = speakerPolicy({
-		owners: [owner.id],
-		...(config.speakers.admins ? { admins: config.speakers.admins } : {}),
-		...(config.speakers.members ? { members: config.speakers.members } : {}),
-	});
-	const shared = config.prompts.shared
-		? readPrompt(config.prompts.shared, "prompts.shared")
-		: readPrompt(join(ASSETS, "prompts", "shared.md"), "prompts.shared");
-	const guest = config.prompts.guest
-		? readPrompt(config.prompts.guest, "prompts.guest")
-		: readPrompt(join(ASSETS, "prompts", "shared-guest.md"), "prompts.guest");
+	// The agent server hands the runtime its per-agent settings once it sets up.
+	const agentSessions = agentSessionsSlot();
+	const assembly = discord
+		? discordAssembly(config, discord, {
+				modelRuntime,
+				agentSessions,
+				errorReporter,
+			})
+		: undefined;
 	return {
 		options: {
 			logger,
@@ -154,12 +246,15 @@ export async function defineRoundtable(
 				locale: config.locale,
 				timeZone: config.timeZone,
 				assistant: name,
-				rootCommand: discord.rootCommand,
+				rootCommand: config.slug,
 				agentDir: config.agentDir,
 			},
 			database: { url: config.databaseUrl },
 			toolTiers: toolTiers(config.toolTiers),
-			listeners: [publicListener(config.http), ...(overrides.listeners ?? [])],
+			listeners: [
+				...(config.http ? [publicListener(config.http)] : []),
+				...(overrides.listeners ?? []),
+			],
 			judgeModel: judgeThrough(modelRuntime, config.judge.model),
 			apiKey: (provider) => registry.getApiKeyForProvider(provider),
 			...(overrides.aborted ? { aborted: overrides.aborted } : {}),
@@ -168,17 +263,7 @@ export async function defineRoundtable(
 			...(config.memory ? [memoryPlugin({ owner })] : []),
 			scheduleStorePlugin(),
 			precheckPlugin(),
-			discordPlugin({
-				token: discord.token,
-				ownerId: owner.id,
-				ownerName: owner.name,
-				speakers,
-				rootCommand: discord.rootCommand,
-				dataDir: config.dataDir,
-				...(discord.refusalHint === undefined
-					? {}
-					: { refusalHint: discord.refusalHint }),
-			}),
+			...(assembly ? [assembly.discord] : []),
 			modulesPlugin({
 				owner,
 				assistant: name,
@@ -186,42 +271,27 @@ export async function defineRoundtable(
 				agentDir: config.agentDir,
 				dataDir: config.dataDir,
 				delegation: config.delegation,
+				// A conversation's reports are the modules' to deliver.
+				...(errorReporter && "conversation" in errorReporter.destination
+					? { errorReporter }
+					: {}),
 			}),
-			...(discord.admin ? [discordAdminPlugin({ owner })] : []),
-			...(config.skills
-				? [
-						skillsPlugin({
-							guildId: discord.guild,
-							reposDir: config.skills.reposDir ?? join(config.dataDir, "repos"),
-							writtenDir: join(config.dataDir, "skills"),
-							builtinDir: config.skills.builtinDir ?? join(ASSETS, "skills"),
-						}),
-					]
-				: []),
-			agentServerPlugin({
-				guildId: discord.guild,
-				entryChannelId: discord.entryChannel,
+			...(assembly?.admin ?? []),
+			...(assembly?.skills ?? []),
+			conversationsPlugin(),
+			runtimePlugin({
 				owner,
-				assistant: name,
-				speakers,
 				modelRuntime,
 				agentDir: config.agentDir,
 				dataDir: config.dataDir,
 				model: config.model,
 				thinking: config.thinking,
 				judgeThreshold: config.judge.threshold,
-				workDir: config.workDir,
-				scratchDir: config.scratchDir,
-				shellUser: userInfo().username,
-				prompts: { shared, guest },
-				avatarListener: "public",
-				avatarUrl: config.http.publicUrl,
-				avatarReference: config.avatar ?? join(ASSETS, "neutral.png"),
+				agents: agentSessions,
 				interimText: config.interimText,
 				interimPrimaryChars: config.interimPrimaryChars,
-				...(errorReporter ? { errorReporter } : {}),
 			}),
-			seedsPlugin(config.agents),
+			...(assembly ? [assembly.agentServer, assembly.seeds] : []),
 			...config.plugins,
 			schedulerPlugin(),
 		],

package/src/core/discord/discord-adapter.ts

@@ -0,0 +1,9 @@
+import type { DiscordAdapterConfig, DiscordConfig } from "../config/config.ts";
+
+/**
+ * The Discord adapter, for `adapters: [discord({ ... })]` in roundtable.config.ts: the same
+ * settings, and the same host, as the top-level `discord`.
+ */
+export function discord(options: DiscordConfig): DiscordAdapterConfig {
+	return { adapter: "discord", discord: options };
+}

package/src/core/discord/owner-cards.ts

@@ -103,7 +103,8 @@ interface Audience {
 
 /**
  * The owner's cards in the assistant's channels: approvals of held actions and ask_user questions,
- * answered with buttons, a menu, or a form. Only the owner may answer; an unanswered card
+ * answered with buttons, a menu, or a form. The owner may answer, and so may the speaker whose
+ * turn asks, when the card allows (a question always; an approval at its tier); an unanswered card
  * expires after 30 minutes and a stopped turn cancels it. Open cards live in memory, so a
  * restart abandons them; pressing one then says it no longer works.
  */
@@ -262,12 +263,19 @@ export class OwnerCards implements InteractionModule {
 		};
 	}
 
-	/** An approval is for the speakers whose tier holds the tool, the owner alone by default. */
+	/**
+	 * An approval is for the speaker whose turn held the call, when their tier holds it, and for
+	 * the owner; the owner's alone by default. Nobody else in the channel may approve it.
+	 */
 	#approvers(minTier: Tier, speaker: Speaker | undefined): Audience {
 		const { ownerId, speakers } = this.#options;
-		const mentionId =
-			speaker && tierAtLeast(speaker.tier, minTier) ? speaker.id : ownerId;
-		if (minTier === "owner" || !speakers)
+		if (
+			minTier === "owner" ||
+			!speakers ||
+			!speaker ||
+			speaker.id === ownerId ||
+			!tierAtLeast(speaker.tier, minTier)
+		)
 			return {
 				allows: (user) => user.id === ownerId,
 				mentionId: ownerId,
@@ -276,12 +284,15 @@ export class OwnerCards implements InteractionModule {
 			};
 		return {
 			allows: (user) => {
+				if (user.id === ownerId) return true;
+				if (user.id !== speaker.id) return false;
+				// Their tier when they press, in case it was lowered during the turn.
 				const who = speakers.resolve({ ...user, name: "" });
 				return who !== undefined && tierAtLeast(who.tier, minTier);
 			},
-			mentionId,
-			note: messages().cardApproversNote(minTier),
-			refusal: messages().cardApproversRefusal(minTier),
+			mentionId: speaker.id,
+			note: messages().cardApproversNote(speaker.id),
+			refusal: messages().cardApproversRefusal,
 		};
 	}
 

package/src/core/domain/conversation.ts

@@ -26,6 +26,11 @@ export interface PendingConfirmation {
 	selectionId: string;
 	heldAt: Date;
 	calls: HeldCall[];
+	/**
+	 * The speaker whose turn held the calls. Besides the owner, only they may approve them, at a
+	 * tier that holds them; without one, the owner alone may.
+	 */
+	speakerId?: string;
 }
 
 /** A file produced for a reply; data is raw bytes, not a path or base64. */

package/src/core/domain/owner-prompts.ts

@@ -33,7 +33,7 @@ export interface OwnerPrompts {
 		title: string,
 		message: string,
 		signal?: AbortSignal,
-		/** The lowest tier that may approve; the owner only when absent. */
+		/** The tier the turn's speaker needs to approve it themselves; the owner may always approve, and only the owner when absent. */
 		minTier?: Tier,
 	): Promise<Approval>;
 	/** Asks them a question; undefined when it expired or was cancelled. */

package/src/core/domain/ports.ts

@@ -3,6 +3,7 @@ import type { Speaker } from "../speakers.ts";
 import type { TurnAttachments } from "./attachment.ts";
 import type { ChannelKey } from "./conversation.ts";
 import type { InterimPosts } from "./interim.ts";
+import type { TurnProgress } from "./progress.ts";
 
 export type { AgentTurnScope };
 
@@ -38,6 +39,11 @@ export interface TurnRequest {
 	 * hands the channel its reply goes to. Absent = only the final reply is posted.
 	 */
 	interim?: InterimPosts;
+	/**
+	 * Hears what the turn writes and which tools it runs, as it goes, until the turn ends. A runtime
+	 * without live progress never calls it.
+	 */
+	progress?: (event: TurnProgress) => void;
 }
 
 /** The judge's question and answer shapes. */

package/src/core/domain/progress.ts

@@ -0,0 +1,10 @@
+/**
+ * What a running turn reports as it goes, for a surface that shows it live. Text arrives in
+ * chunks joined over a short interval; a tool is named with a short one-line preview of its
+ * arguments, never their full text, and ends with whether it succeeded. The final reply still
+ * arrives through `sendReply`.
+ */
+export type TurnProgress =
+	| { type: "text"; delta: string }
+	| { type: "tool_start"; id: string; tool: string; preview?: string }
+	| { type: "tool_end"; id: string; tool: string; ok: boolean };

package/src/core/events.ts

@@ -50,6 +50,7 @@ export class EventBus {
 	readonly sink: EventSink = {
 		turnStarted: (turn) => void this.deliver("turnStarted", turn),
 		turnEnded: (turn) => void this.deliver("turnEnded", turn),
+		turnProgress: (event) => void this.deliver("turnProgress", event),
 		changed: () => void this.deliver("changed"),
 	};
 }

package/src/core/host.ts

@@ -32,7 +32,7 @@ import {
 	conversationTurns,
 } from "./routing/conversation-turns.ts";
 import { surfacePort } from "./routing/surface-port.ts";
-import { AGENTS } from "./services.ts";
+import { CONVERSATIONS, RUNTIME } from "./services.ts";
 import { setTimeZone } from "./time.ts";
 import { type ToolTierTable, toolTiers } from "./tool-tiers.ts";
 
@@ -196,6 +196,8 @@ export class Roundtable {
 			deleteConversation: (channel) => router().deleteConversation(channel),
 			stop: (channel) => router().stop(channel),
 			postsInPlace: (channel) => router().postsInPlace(channel),
+			owns: (channel) => router().owns(channel),
+			takesBackground: (channel) => router().takesBackground(channel),
 		};
 	}
 
@@ -210,7 +212,7 @@ export class Roundtable {
 		});
 	}
 
-	/** Turns over the agent server's runtime and the surfaces; every call before linking is refused with NotLinkedError. */
+	/** Turns over the runtime plugin's runtime and the surfaces; every call before linking is refused with NotLinkedError. */
 	#turns(): ConversationTurns {
 		return conversationTurns({
 			linked: () => {
@@ -222,8 +224,9 @@ export class Roundtable {
 			runtime: () => {
 				if (!this.#services)
 					throw new NotLinkedError("the host has not started yet.");
-				return this.#services.get(AGENTS).runtime;
+				return this.#services.get(RUNTIME);
 			},
+			registry: () => this.#services?.find(CONVERSATIONS),
 			surfaces: this.#surfaces(),
 			events: this.#events.sink,
 			selection: () => {