pi-roundtable 0.7.19 → 0.9.0

package/src/core/define-roundtable.ts

@@ -13,17 +13,34 @@ import {
 	precheckPlugin,
 	scheduleStorePlugin,
 } from "./builtin/stores.ts";
-import { type RoundtableConfig, resolveConfig } from "./config/config.ts";
+import { warnDeprecations } from "./config/access.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";
 import type { ListenerConfig } from "./http/listeners.ts";
+import { identityPlugin } from "./identity/identity-plugin.ts";
 import { type JudgeModel, piJudgeModel } from "./judging/model-judge.ts";
 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 { speakerPolicy } from "./speakers.ts";
+import {
+	BRIDGE_MEMORY_FIX,
+	bridgeMemoryProblem,
+	configuredCrowd,
+	onClaudeBridge,
+} from "./runtime/bridge-guard.ts";
+import {
+	type AgentSessionsSlot,
+	agentSessionsSlot,
+	runtimePlugin,
+} from "./runtime/runtime-plugin.ts";
 import { toolTiers } from "./tool-tiers.ts";
 
 /** What `defineRoundtable` returns: give both to `new Roundtable(options, plugins)`. */
@@ -86,7 +103,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 +118,107 @@ function publicListener(
 	};
 }
 
+/**
+ * The owner the Discord parts act for: the primary owner, by the Discord user id among their
+ * identities, until those parts follow each turn's principal.
+ */
+export function discordOwnerOf(
+	config: ResolvedConfig,
+): ResolvedConfig["owner"] {
+	return {
+		...config.owner,
+		id: config.primaryOwner.discordId ?? config.owner.id,
+	};
+}
+
+/** 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 } = config;
+	const owner = discordOwnerOf(config);
+	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,
+			rootCommand: discord.rootCommand,
+			dataDir: config.dataDir,
+			...(discord.refusalHint === undefined
+				? {}
+				: { refusalHint: discord.refusalHint }),
+			channelContext: discord.channelContext,
+			...(discord.freshMarker === undefined
+				? {}
+				: { freshMarker: discord.freshMarker }),
+		}),
+		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,
+			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 },
+			...(discord.agentMemory ? { memory: discord.agentMemory } : {}),
+			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,
@@ -113,6 +226,7 @@ export async function defineRoundtable(
 ): Promise<DefinedRoundtable> {
 	const config = resolveConfig(input);
 	const { name, owner, discord } = config;
+	const crowd = configuredCrowd(config.access, config.plugins);
 	// Nothing here touches the process: the host applies the environment when it runs.
 	const modelRuntime =
 		overrides.modelRuntime ??
@@ -122,13 +236,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 =
+	const logger: Logger =
 		overrides.logger ??
 		createLogger(
-			discord.rootCommand,
+			config.slug,
 			errorReporter || errorSink
 				? (entry) => {
 						errorReporter?.record(entry);
@@ -136,17 +250,21 @@ 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");
+	if (config.memory && crowd && onClaudeBridge(config.model))
+		logger.warn(
+			{},
+			`${bridgeMemoryProblem(formatModelRef(config.model), crowd)} ${BRIDGE_MEMORY_FIX}`,
+		);
+	warnDeprecations(logger, config.deprecations);
+	// 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,31 +272,25 @@ 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 ?? [])],
+			toolTiers: toolTiers(config.toolTiers, logger),
+			listeners: [
+				...(config.http ? [publicListener(config.http)] : []),
+				...(overrides.listeners ?? []),
+			],
 			judgeModel: judgeThrough(modelRuntime, config.judge.model),
 			apiKey: (provider) => registry.getApiKeyForProvider(provider),
 			...(overrides.aborted ? { aborted: overrides.aborted } : {}),
 		},
 		plugins: [
+			identityPlugin({ rules: config.access, plugins: config.plugins }),
 			...(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 +298,30 @@ export async function defineRoundtable(
 				agentDir: config.agentDir,
 				dataDir: config.dataDir,
 				delegation: config.delegation,
+				perPrincipal: config.background.perPrincipal,
+				// 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 } : {}),
+				memory: config.memory,
+				...(crowd ? { crowd } : {}),
 			}),
-			seedsPlugin(config.agents),
+			...(assembly ? [assembly.agentServer, assembly.seeds] : []),
 			...config.plugins,
 			schedulerPlugin(),
 		],

package/src/core/discord/agent-panel.ts

@@ -47,7 +47,7 @@ export function agentPanel(options: AgentPanelOptions): AgentPanel {
 				interaction.isButton() &&
 				interaction.customId.startsWith(AGENT_BUTTON_PREFIX)
 			) {
-				if (!guard.isOwner(interaction)) return true;
+				if (!(await guard.allows(interaction))) return true;
 				await guard.run(interaction, () => commands.button(interaction));
 				return true;
 			}
@@ -55,7 +55,7 @@ export function agentPanel(options: AgentPanelOptions): AgentPanel {
 				interaction.isModalSubmit() &&
 				interaction.customId.startsWith(AGENT_MODAL_PREFIX)
 			) {
-				if (!guard.isOwner(interaction)) return true;
+				if (!(await guard.allows(interaction))) return true;
 				await interaction.deferReply({ flags: MessageFlags.Ephemeral });
 				await guard.run(interaction, () => commands.submit(interaction));
 				return true;

package/src/core/discord/card-audience.ts

@@ -0,0 +1,148 @@
+import { messages } from "../i18n/index.ts";
+import type { PromptScope } from "../interactions/prompts.ts";
+import { type Tier, tierAtLeast } from "../speakers.ts";
+import type {
+	DiscordOwners,
+	DiscordOwnersOptions,
+	DiscordUser,
+} from "./discord-owners.ts";
+
+/** The people a card is for. */
+export interface Audience {
+	/** Whether this user may answer, as they are when they press. */
+	allows(user: DiscordUser): Promise<boolean>;
+	/** The users the card mentions in a thread, in order. */
+	mentions: readonly string[];
+	/** Shown on the card; empty for none. */
+	note: string;
+	/** What someone else who presses it is told. */
+	refusal: string;
+}
+
+/** The primary owner, who answers every card the owners may, and who else holds a tier. */
+export type CardAudienceOptions = DiscordOwnersOptions;
+
+/**
+ * Whom a card is for, by the prompt scope of the turn that asks. The speaker's principal answers
+ * their own card on any of their Discord identities that is still theirs when they press when,
+ * for an approval, they hold its tier, checked again then, and, for an owner-tier one, they are
+ * an owner; the card mentions the identity that spoke where it is one of those, or else all of
+ * them. Where the scope
+ * escalates to the owners, every owner with a Discord identity answers it too, and a card the
+ * speaker cannot answer, or whose principal has no Discord identity, is theirs alone; where it
+ * escalates to no one, that card goes to no one. Without a scope, a card is the owners'.
+ */
+export class CardAudiences {
+	readonly #options: CardAudienceOptions;
+	readonly #owners: DiscordOwners;
+
+	constructor(options: CardAudienceOptions, owners: DiscordOwners) {
+		this.#options = options;
+		this.#owners = owners;
+	}
+
+	/** Who may approve a call held at `minTier`; undefined when no one may. */
+	approval(
+		scope: PromptScope | undefined,
+		minTier: Tier,
+	): Promise<Audience | undefined> {
+		return this.#audience(scope, minTier, {
+			note: messages().cardApproversNote,
+			refusal: messages().cardApproversRefusal,
+		});
+	}
+
+	/** Who may answer a question; undefined when no one may. */
+	question(scope: PromptScope | undefined): Promise<Audience | undefined> {
+		return this.#audience(scope, undefined, {
+			note: messages().cardAskerNote,
+			refusal: messages().cardAskerRefusal,
+		});
+	}
+
+	async #audience(
+		scope: PromptScope | undefined,
+		minTier: Tier | undefined,
+		words: { note(...userIds: string[]): string; refusal: string },
+	): Promise<Audience | undefined> {
+		const { ownerId } = this.#options;
+		const escalates = scope?.escalate !== "none";
+		const own = scope && (await this.#ownIdentities(scope, minTier));
+		if (scope && own) {
+			const primary = own.includes(ownerId);
+			const mentions = own.includes(scope.speakerId) ? [scope.speakerId] : own;
+			return {
+				allows: async (user) => {
+					// Read the links again: one moved or unlinked since the card was posted is no longer theirs.
+					if (
+						own.includes(user.id) &&
+						(await this.#stillOwn(scope.principalId, user.id))
+					)
+						return (
+							(primary && user.id === ownerId) ||
+							this.#owners.holds(user, minTier, scope.principalId)
+						);
+					return escalates && this.#owners.isOwner(user);
+				},
+				mentions,
+				note: primary ? "" : words.note(...mentions),
+				refusal: primary ? messages().cardOwnerOnly : words.refusal,
+			};
+		}
+		if (!escalates) return undefined;
+		return {
+			allows: (user) => this.#owners.isOwner(user),
+			mentions: await this.#owners.ids(),
+			note: "",
+			refusal: messages().cardOwnerOnly,
+		};
+	}
+
+	/** Whether the Discord user is still one of the principal's identities; false when that cannot be read. */
+	async #stillOwn(principalId: string, userId: string): Promise<boolean> {
+		return (
+			(await this.#discordIdentities(principalId))?.includes(userId) ?? false
+		);
+	}
+
+	/** The principal's Discord user ids; undefined, and logged, when they cannot be read. */
+	async #discordIdentities(principalId: string): Promise<string[] | undefined> {
+		const { identity, logger } = this.#options;
+		if (!identity) return undefined;
+		try {
+			return (await identity.identities(principalId))
+				.filter((link) => link.provider === "discord")
+				.map((link) => link.subject);
+		} catch (error) {
+			logger.warn(
+				{ principal: principalId, err: error },
+				"could not read the speaker's identities; none counts as theirs, so their card is the owners'",
+			);
+			return undefined;
+		}
+	}
+
+	/**
+	 * The Discord identities of the scope's principal when they may answer their own card: at the
+	 * tier it needs and, for an owner-tier call, an owner; undefined when they may not, or have
+	 * none.
+	 */
+	async #ownIdentities(
+		scope: PromptScope,
+		minTier: Tier | undefined,
+	): Promise<string[] | undefined> {
+		if (
+			!this.#options.identity ||
+			(minTier && !tierAtLeast(scope.tier, minTier))
+		)
+			return undefined;
+		// A turn whose tier defaulted to owner is not an owner's: its owner-tier call is the owners'.
+		if (
+			minTier === "owner" &&
+			!(await this.#owners.isOwnerPrincipal(scope.principalId))
+		)
+			return undefined;
+		const own = await this.#discordIdentities(scope.principalId);
+		return own && own.length > 0 ? own : undefined;
+	}
+}