pi-roundtable 0.22.5 → 0.23.1

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

@@ -15,17 +15,20 @@ import {
 	SeparatorBuilder,
 	SeparatorSpacingSize,
 	StringSelectMenuBuilder,
+	type StringSelectMenuInteraction,
 	StringSelectMenuOptionBuilder,
 	TextDisplayBuilder,
 	TextInputBuilder,
 	TextInputStyle,
 } from "discord.js";
 import {
-	type Agent,
-	MAX_AVATAR_PROMPT_CHARS,
-	MAX_PROMPT_CHARS,
-} from "../agents/agent-store.ts";
-import type { AvatarMode } from "../agents/agent-tools.ts";
+	CATALOG,
+	type CharacterInput,
+	CLASS_IDS,
+	type PaletteName,
+} from "../../characters/index.ts";
+import { characterOf } from "../agents/agent-rules.ts";
+import { type Agent, MAX_PROMPT_CHARS } from "../agents/agent-store.ts";
 import { AgentError } from "../domain/errors.ts";
 import { messages } from "../i18n/index.ts";
 import { THINKING_LEVELS, thinkingLabel } from "../models.ts";
@@ -68,22 +71,18 @@ export function formModels(
 		: offered;
 }
 
-type Action = "edit" | "redraw" | "newprompt" | "editavatar" | "model";
-const ACTIONS: readonly Action[] = [
-	"edit",
-	"redraw",
-	"newprompt",
-	"editavatar",
-	"model",
-];
+type Action = "edit" | "model";
+/** The buttons of the panel; the look is chosen with the two selects, `class` and `color`. */
+const ACTIONS: readonly Action[] = ["edit", "model"];
+type LookAction = "class" | "color";
 
 export interface AgentCommandsOptions {
 	store: Pick<AgentDirectory, "agentByChannel" | "groupByChannel" | "agent">;
 	team: Pick<
 		AgentTeam,
-		"redrawAvatar" | "update" | "modelOf" | "usableModels" | "defaultModel"
+		"dress" | "update" | "modelOf" | "usableModels" | "defaultModel"
 	>;
-	studio: Pick<AvatarStudio, "url" | "canDraw">;
+	studio: Pick<AvatarStudio, "url">;
 	/** The skills an agent carries; without the skills addon the panel lists none. */
 	skills?: Pick<SkillRegistry, "carried">;
 }
@@ -133,8 +132,7 @@ export class AgentCommands {
 
 	#panel(agent: Agent, note?: string): AgentPanelMessage {
 		const text = messages();
-		// Without an image provider nothing can be drawn, so the avatar buttons are not offered.
-		const drawing = this.#options.studio.canDraw;
+		const look = characterOf(agent);
 		const inline = agent.prompt.length <= INLINE_PROMPT_CHARS;
 		const { model, thinking } = this.#options.team.modelOf(agent.name);
 		const follows =
@@ -168,9 +166,10 @@ export class AgentCommands {
 			)
 			.addTextDisplayComponents(
 				new TextDisplayBuilder().setContent(
-					drawing
-						? text.agentAvatarPromptText(agent.avatarPrompt)
-						: text.agentNoImageProvider,
+					text.agentLook(
+						CATALOG.classes[look.class].label,
+						look.palette ?? look.colors.primary,
+					),
 				),
 				new TextDisplayBuilder().setContent(
 					inline
@@ -196,15 +195,14 @@ export class AgentCommands {
 				new SeparatorBuilder().setSpacing(SeparatorSpacingSize.Small),
 			)
 			.addActionRowComponents(
+				new ActionRowBuilder<StringSelectMenuBuilder>()
+					.addComponents(this.#lookMenu("class", agent.name, look.class))
+					.toJSON(),
+				new ActionRowBuilder<StringSelectMenuBuilder>()
+					.addComponents(this.#lookMenu("color", agent.name, look.palette))
+					.toJSON(),
 				new ActionRowBuilder<ButtonBuilder>().addComponents(
 					button("edit", text.agentEditPromptLabel, ButtonStyle.Primary),
-					...(drawing
-						? [
-								button("redraw", text.agentRedrawLabel),
-								button("newprompt", text.agentNewAvatarPromptLabel),
-								button("editavatar", text.agentEditAvatarLabel),
-							]
-						: []),
 					button("model", text.agentModelLabel),
 				),
 			)
@@ -227,23 +225,54 @@ export class AgentCommands {
 		};
 	}
 
-	/** A panel button: a form opens, or a redraw starts. */
+	/** A dropdown of the look: the 24 classes or the 8 colors, the agent's own chosen. */
+	#lookMenu(
+		action: LookAction,
+		name: string,
+		current: string | undefined,
+	): StringSelectMenuBuilder {
+		const text = messages();
+		const option = (label: string, value: string, description?: string) => {
+			const built = new StringSelectMenuOptionBuilder()
+				.setLabel(label)
+				.setValue(value)
+				.setDefault(value === current);
+			return description
+				? built.setDescription(description.slice(0, 100))
+				: built;
+		};
+		return new StringSelectMenuBuilder()
+			.setCustomId(`${AGENT_BUTTON_PREFIX}${action}:${name}`)
+			.setPlaceholder(
+				action === "class"
+					? text.agentClassPlaceholder
+					: text.agentColorPlaceholder,
+			)
+			.addOptions(
+				action === "class"
+					? CLASS_IDS.map((id) =>
+							option(CATALOG.classes[id].label, id, CATALOG.classes[id].jobs),
+						)
+					: (Object.keys(CATALOG.palettes) as PaletteName[]).map((id) =>
+							option(id.charAt(0).toUpperCase() + id.slice(1), id),
+						),
+			);
+	}
+
+	/** A panel button: a form opens. */
 	async button(interaction: ButtonInteraction): Promise<void> {
 		const [action, name] = interaction.customId
 			.slice(AGENT_BUTTON_PREFIX.length)
 			.split(":");
 		const agent = name ? this.#options.store.agent(name) : undefined;
-		if (!agent || !ACTIONS.includes(action as Action))
-			throw new OwnerFacingError(messages().agentNotFound);
-		if (action === "redraw") {
-			await interaction.deferReply({ flags: MessageFlags.Ephemeral });
-			await interaction.editReply(await this.#avatar(agent.name, "redraw"));
-			return;
-		}
+		if (!agent) throw new OwnerFacingError(messages().agentNotFound);
+		// A panel posted before 0.23 still carries the redraw buttons.
+		if (!ACTIONS.includes(action as Action))
+			throw new OwnerFacingError(messages().agentPanelOutdated);
 		await interaction.showModal(
 			action === "model"
 				? await this.#modelModal(agent)
-				: this.#modal(action as Action, agent),
+				: this.#editModal(agent),
 		);
 	}
 
@@ -292,7 +321,7 @@ export class AgentCommands {
 			);
 	}
 
-	#modal(action: Action, agent: Agent): ModalBuilder {
+	#editModal(agent: Agent): ModalBuilder {
 		const field = (
 			id: string,
 			label: string,
@@ -308,50 +337,23 @@ export class AgentCommands {
 			if (value) input.setValue(value);
 			return new LabelBuilder().setLabel(label).setTextInputComponent(input);
 		};
-		const modal = new ModalBuilder().setCustomId(
-			`${AGENT_MODAL_PREFIX}${action}:${agent.name}`,
-		);
-		if (action === "edit")
-			return modal
-				.setTitle(
-					messages().agentEditModalTitle(agent.displayName).slice(0, 45),
-				)
-				.addLabelComponents(
-					field(
-						"display",
-						messages().agentDisplayNameLabel,
-						TextInputStyle.Short,
-						32,
-						agent.displayName,
-					),
-					field(
-						"prompt",
-						messages().agentPromptLabel,
-						TextInputStyle.Paragraph,
-						MAX_PROMPT_CHARS,
-						agent.prompt,
-					),
-				);
-		if (action === "newprompt")
-			return modal
-				.setTitle(messages().agentNewAvatarPromptLabel)
-				.addLabelComponents(
-					field(
-						"text",
-						messages().agentAvatarPromptLabel,
-						TextInputStyle.Paragraph,
-						MAX_AVATAR_PROMPT_CHARS,
-						agent.avatarPrompt,
-					),
-				);
-		return modal
-			.setTitle(messages().agentEditAvatarLabel)
+		return new ModalBuilder()
+			.setCustomId(`${AGENT_MODAL_PREFIX}edit:${agent.name}`)
+			.setTitle(messages().agentEditModalTitle(agent.displayName).slice(0, 45))
 			.addLabelComponents(
 				field(
-					"text",
-					messages().agentEditAvatarField,
+					"display",
+					messages().agentDisplayNameLabel,
+					TextInputStyle.Short,
+					32,
+					agent.displayName,
+				),
+				field(
+					"prompt",
+					messages().agentPromptLabel,
 					TextInputStyle.Paragraph,
-					MAX_AVATAR_PROMPT_CHARS,
+					MAX_PROMPT_CHARS,
+					agent.prompt,
 				),
 			);
 	}
@@ -383,23 +385,43 @@ export class AgentCommands {
 			await interaction.editReply(this.#panel(updated, messages().agentSaved));
 			return;
 		}
-		const mode: AvatarMode = action === "newprompt" ? "new_prompt" : "edit";
-		await interaction.editReply(
-			await this.#avatar(agent.name, mode, value("text")),
-		);
+		throw new OwnerFacingError(messages().agentPanelOutdated);
+	}
+
+	/**
+	 * A choice in one of the panel's two dropdowns, class or color; the reply is deferred by the
+	 * caller. The choice goes through `dress`, which keeps the colors on a new class and the
+	 * class on a new color.
+	 */
+	async select(interaction: StringSelectMenuInteraction): Promise<void> {
+		const [action, name] = interaction.customId
+			.slice(AGENT_BUTTON_PREFIX.length)
+			.split(":");
+		const chosen = interaction.values[0];
+		if (
+			!name ||
+			chosen === undefined ||
+			(action !== "class" && action !== "color")
+		)
+			throw new OwnerFacingError(messages().agentNotFound);
+		const input: CharacterInput =
+			action === "class"
+				? { class: chosen as CharacterInput["class"] }
+				: { palette: chosen as PaletteName };
+		await interaction.editReply(await this.#dress(name, input));
 	}
 
-	async #avatar(name: string, mode: AvatarMode, text?: string) {
+	async #dress(name: string, input: CharacterInput) {
 		try {
-			const agent = await this.#options.team.redrawAvatar(name, mode, text);
-			return this.#panel(agent, messages().agentAvatarRedrawn);
+			const agent = await this.#options.team.dress(name, input);
+			return this.#panel(agent, messages().agentLookChanged);
 		} catch (error) {
 			if (!(error instanceof AgentError)) throw error;
 			const agent = this.#options.store.agent(name);
 			return agent
 				? this.#panel(
 						agent,
-						messages().agentAvatarFailed(error.message).slice(0, 300),
+						messages().agentLookFailed(error.message).slice(0, 300),
 					)
 				: ownerPanel({
 						title: messages().ownerFailedTitle,

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

@@ -17,7 +17,7 @@ export interface AgentPanelOptions {
 	skills?: Pick<SkillRegistry, "carried">;
 }
 
-/** An agent's panel: its prompt, picture, model, and skills, with buttons and forms to change them. */
+/** An agent's panel: its prompt, look, model, and skills, with dropdowns, buttons and forms to change them. */
 export interface AgentPanel {
 	/**
 	 * The panel of the agent whose channel this is. Throws OwnerFacingError, which a command run
@@ -25,7 +25,7 @@ export interface AgentPanel {
 	 */
 	open(channelId: string): AgentPanelMessage;
 	/**
-	 * Answers the panel's own buttons and form, for the owner only and deferred as Discord needs;
+	 * Answers the panel's own buttons, dropdowns and form, for the owner only and deferred as Discord needs;
 	 * true when it handled the interaction. The custom ids are fixed, so panels already posted keep working.
 	 */
 	handles(interaction: Interaction): Promise<boolean>;
@@ -51,6 +51,15 @@ export function agentPanel(options: AgentPanelOptions): AgentPanel {
 				await guard.run(interaction, () => commands.button(interaction));
 				return true;
 			}
+			if (
+				interaction.isStringSelectMenu() &&
+				interaction.customId.startsWith(AGENT_BUTTON_PREFIX)
+			) {
+				if (!(await guard.allows(interaction))) return true;
+				await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+				await guard.run(interaction, () => commands.select(interaction));
+				return true;
+			}
 			if (
 				interaction.isModalSubmit() &&
 				interaction.customId.startsWith(AGENT_MODAL_PREFIX)

package/src/core/discord/connection.ts

@@ -1,8 +1,8 @@
 import type { AgentChannels, DashboardBoard } from "../agents/agent-ports.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
 import type { OwnerOperations } from "../modules/discord-admin/discord-admin.ts";
+import type { ThreadHost } from "../threads/dispatch-threads.ts";
 import type { ChannelExecutor } from "./channel-operations.ts";
-import type { ThreadHost } from "./dispatch-threads.ts";
 
 /** What Discord calls a channel, for the web app's lists. */
 export type ChannelInfo =

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

@@ -12,7 +12,7 @@ import {
 	type REST,
 } from "discord.js";
 import type { AgentChannels, DashboardBoard } from "../agents/agent-ports.ts";
-import type { ChatSurface } from "../contract/surface.ts";
+import type { ChatSurface, SurfaceThreads } from "../contract/surface.ts";
 import type {
 	ChannelKey,
 	InboundMessage,
@@ -25,6 +25,7 @@ import type { PromptScope, Prompts } from "../interactions/prompts.ts";
 import type { Logger } from "../log.ts";
 import type { OwnerOperations } from "../modules/discord-admin/discord-admin.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
+import { threadsOfHost } from "../threads/host-threads.ts";
 import { DiscordAgentChannels, DiscordDashboard } from "./agent-discord.ts";
 import {
 	type ContextSourceMessage,
@@ -77,6 +78,14 @@ export class DiscordSurface
 	readonly surface = "discord";
 	readonly supportsFiles = true;
 	readonly formatting: string | undefined;
+	/** Dispatch threads, through the client as it is when each call is made. */
+	readonly threads: SurfaceThreads = threadsOfHost({
+		open: (parentId, name, line) =>
+			this.threadHost().open(parentId, name, line),
+		post: (threadId, text) => this.threadHost().post(threadId, text),
+		send: (threadId, text) => this.threadHost().send(threadId, text),
+		close: (threadId) => this.threadHost().close(threadId),
+	});
 	readonly #options: DiscordSurfaceOptions;
 	readonly #client = new Client({
 		intents: [

package/src/core/discord/dispatch-thread-host.ts

@@ -6,7 +6,7 @@ import {
 } from "discord.js";
 import type { InterimMessage } from "../domain/interim.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
-import type { ThreadHost } from "./dispatch-threads.ts";
+import type { ThreadHost } from "../threads/dispatch-threads.ts";
 
 /** Parents a dispatch thread may start in; DMs, threads, forums, and voice chats keep posting in place. */
 const HOSTS: readonly ChannelType[] = [

package/src/core/domain/conversation.ts

@@ -26,6 +26,12 @@ export interface HeldCall {
 	 * a restart honors them; a private conversation ignores them.
 	 */
 	approverIds?: string[];
+	/**
+	 * The hold classes of the rules that held it, as `<rule>.<class>` ids (see `HoldRule.holdClasses`),
+	 * or a rule's bare name for a rule that reports none, kept with the call across a restart. Absent for a call held before 0.23 or by a check that
+	 * has no classes: its classes are unknown, and yolo mode always asks a card for it.
+	 */
+	holdClasses?: string[];
 }
 
 export interface PendingConfirmation {
@@ -55,6 +61,17 @@ export type TurnResult =
 	| { ok: true; text: string; thinking?: string; files?: ReplyFile[] }
 	| { ok: false; error: Error; stopped?: true };
 
+/**
+ * Who a reply speaks as on a surface that shows authors, such as an agent in a room: the name to
+ * show and, for an agent of the agent team, its stable name.
+ */
+export interface PostAuthor {
+	/** The name to show, such as an agent's display name. */
+	name: string;
+	/** The agent's name, when an agent of the agent team speaks. */
+	agent?: string;
+}
+
 export interface OutboundReply {
 	/** The assistant's thinking for this turn, posted as a quiet line before the card. */
 	thinking?: string;
@@ -64,4 +81,11 @@ export interface OutboundReply {
 	chunks: string[];
 	/** Files the run produced, posted after the text. */
 	files?: ReplyFile[];
+	/**
+	 * Who speaks, for a surface that shows authors, such as a room of an agent. Absent = the
+	 * assistant. Discord posts agents through webhooks and ignores it.
+	 */
+	author?: PostAuthor;
+	/** Set only on the reply for a turn that ended in an error. A surface may show it; Discord ignores it. */
+	failed?: true;
 }