pi-roundtable 0.9.3 → 0.9.6

package/src/core/discord/channel-operations.ts

@@ -38,7 +38,7 @@ const message = { channelId: id, messageId: id };
 const strict = { additionalProperties: false } as const;
 
 /** One upload may carry at most this much, in all files together. */
-const CHANNEL_UPLOAD_MAX_BYTES = 8 * 1024 * 1024;
+export const CHANNEL_UPLOAD_MAX_BYTES = 8 * 1024 * 1024;
 
 const file = Type.Object(
 	{
@@ -70,12 +70,90 @@ const files = Type.Optional(
 	}),
 );
 
+/** A file a session sends: one on its disk by path, or small generated data inline. */
+const localFile = Type.Object(
+	{
+		path: Type.Optional(
+			Type.String({
+				minLength: 1,
+				maxLength: 4096,
+				description:
+					"A file on disk inside the workspace or the scratch dir; prefer this for any file you have",
+			}),
+		),
+		filename: Type.Optional(
+			Type.String({
+				...file.properties.filename,
+				description:
+					"The attachment file name, without a path; defaults to the path's base name, required with dataBase64",
+			}),
+		),
+		dataBase64: Type.Optional(
+			Type.String({
+				...file.properties.dataBase64,
+				description:
+					"Small generated content as standard base64, without a data URL prefix; never base64 a file you have on disk, give its path",
+			}),
+		),
+		description: file.properties.description,
+	},
+	strict,
+);
+const localFiles = Type.Optional(
+	Type.Array(localFile, {
+		minItems: 1,
+		maxItems: 10,
+		description:
+			"Images or files to add, each with exactly one of path or dataBase64; at most 8 MiB in total for the whole call",
+	}),
+);
+
 export interface ChannelTool {
 	readonly operation: ChannelOperation;
 	readonly schema: Readonly<TSchema>;
 	readonly description: string;
 }
 
+const sendMessage = (attached: typeof files | typeof localFiles) => ({
+	operation: "send" as const,
+	schema: Type.Object(
+		{
+			...channel,
+			content: Type.Optional(Type.String({ maxLength: 2000 })),
+			files: attached,
+		},
+		strict,
+	),
+	description:
+		"Send a message, optionally with images or files; it triggers no @ mentions.",
+});
+
+const editMessage = (attached: typeof files | typeof localFiles) => ({
+	operation: "edit" as const,
+	schema: Type.Object(
+		{
+			...message,
+			content: Type.Optional(Type.String({ maxLength: 2000 })),
+			files: attached,
+			keepAttachmentIds: Type.Optional(
+				Type.Array(id, {
+					maxItems: 10,
+					description:
+						"Omit to keep every old attachment; an empty array removes them all; listed ids keep only those attachments",
+				}),
+			),
+		},
+		strict,
+	),
+	description: "Edit a message the bot itself sent.",
+});
+
+/** The tools that upload files; a session's files may name a path, which it reads before the call. */
+export const FILE_CHANNEL_TOOLS: readonly string[] = Object.freeze([
+	"discord_send_message",
+	"discord_edit_message",
+]);
+
 /** Discord tool descriptions and schemas, each gated by one channel operation. */
 export const CHANNEL_TOOLS: Readonly<Record<string, ChannelTool>> = freeze<
 	Record<string, ChannelTool>
@@ -164,38 +242,8 @@ export const CHANNEL_TOOLS: Readonly<Record<string, ChannelTool>> = freeze<
 		schema: Type.Object(channel, strict),
 		description: "Read the channel's pinned messages.",
 	},
-	discord_send_message: {
-		operation: "send",
-		schema: Type.Object(
-			{
-				...channel,
-				content: Type.Optional(Type.String({ maxLength: 2000 })),
-				files,
-			},
-			strict,
-		),
-		description:
-			"Send a message, optionally with images or files; it triggers no @ mentions.",
-	},
-	discord_edit_message: {
-		operation: "edit",
-		schema: Type.Object(
-			{
-				...message,
-				content: Type.Optional(Type.String({ maxLength: 2000 })),
-				files,
-				keepAttachmentIds: Type.Optional(
-					Type.Array(id, {
-						maxItems: 10,
-						description:
-							"Omit to keep every old attachment; an empty array removes them all; listed ids keep only those attachments",
-					}),
-				),
-			},
-			strict,
-		),
-		description: "Edit a message the bot itself sent.",
-	},
+	discord_send_message: sendMessage(files),
+	discord_edit_message: editMessage(files),
 	discord_delete_message: {
 		operation: "delete",
 		schema: Type.Object(message, strict),
@@ -251,6 +299,25 @@ export const CHANNEL_TOOLS: Readonly<Record<string, ChannelTool>> = freeze<
 	},
 });
 
+/**
+ * The channel tools as a session offers them: a file may name a path on the session's disk, which
+ * `resolveChannelFiles` reads into `CHANNEL_TOOLS`' inline form before the call runs.
+ */
+export const SESSION_CHANNEL_TOOLS: Readonly<Record<string, ChannelTool>> =
+	freeze<Record<string, ChannelTool>>({
+		...CHANNEL_TOOLS,
+		discord_send_message: {
+			...sendMessage(localFiles),
+			description:
+				"Send a message, optionally with images or files; it triggers no @ mentions. To send a file you have on disk, give its path; base64 is for small generated data only.",
+		},
+		discord_edit_message: {
+			...editMessage(localFiles),
+			description:
+				"Edit a message the bot itself sent. To add a file you have on disk, give its path; base64 is for small generated data only.",
+		},
+	});
+
 /** A tool call that cannot be run as asked; the code is safe to show the caller. */
 export class ChannelToolError extends Error {
 	constructor(readonly code: string) {

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

@@ -34,10 +34,9 @@ import type { ChannelExecutor } from "./channel-operations.ts";
 import type { ComposedCommands } from "./compose-commands.ts";
 import type { ChannelInfo, DiscordConnection } from "./connection.ts";
 import { DiscordThreadHost } from "./dispatch-thread-host.ts";
-import type { ThreadHost } from "./dispatch-threads.ts";
 import { DEFAULT_FRESH_MARKER, postFreshMarker } from "./fresh-marker.ts";
-import { toInbound } from "./inbound-message.ts";
-import type { CardChannel } from "./owner-cards.ts";
+import { lateAnswerMessage, toInbound } from "./inbound-message.ts";
+import type { CardChannel, LateTurn } from "./owner-cards.ts";
 import { DiscordOwnerOps } from "./owner-discord.ts";
 import { stopPanel } from "./stop-button.ts";
 
@@ -86,6 +85,7 @@ export class DiscordSurface
 	});
 
 	#interactions: ComposedCommands = { commands: [], modules: [] };
+	#onMessage: ((message: InboundMessage) => void) | undefined;
 
 	constructor(options: DiscordSurfaceOptions) {
 		this.#options = options;
@@ -118,7 +118,7 @@ export class DiscordSurface
 	}
 
 	/** Threads for background dispatches, in the channel that started each. */
-	threadHost(): ThreadHost {
+	threadHost(): DiscordThreadHost {
 		return new DiscordThreadHost(this.#client);
 	}
 
@@ -209,8 +209,25 @@ export class DiscordSurface
 		};
 	}
 
+	/**
+	 * Hands the router a card's late answer as a message from whoever answered, in the card's
+	 * channel, so the conversation's claim answers it as theirs; dropped (logged) before start.
+	 */
+	resume(turn: LateTurn): void {
+		const onMessage = this.#onMessage;
+		if (!onMessage) {
+			this.#options.logger.warn(
+				{ channelId: turn.channelId },
+				"late card answer before the surface started; dropped",
+			);
+			return;
+		}
+		onMessage(lateAnswerMessage(turn));
+	}
+
 	async start(onMessage: (message: InboundMessage) => void): Promise<void> {
 		const { logger, token } = this.#options;
+		this.#onMessage = onMessage;
 		this.#client.on(Events.MessageCreate, (message) => {
 			toInbound(message, {
 				botId: this.#client.user?.id,

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

@@ -4,6 +4,7 @@ import {
 	type Message,
 	ThreadAutoArchiveDuration,
 } from "discord.js";
+import type { InterimMessage } from "../domain/interim.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
 import type { ThreadHost } from "./dispatch-threads.ts";
 
@@ -53,6 +54,16 @@ export class DiscordThreadHost implements ThreadHost {
 		for (const chunk of splitReply(text)) await thread.send({ content: chunk });
 	}
 
+	async send(threadId: string, text: string): Promise<InterimMessage> {
+		const thread = await this.#thread(threadId);
+		const message = await thread.send({ content: text });
+		return {
+			edit: async (change) => {
+				await message.edit({ content: change });
+			},
+		};
+	}
+
 	async close(threadId: string): Promise<void> {
 		const thread = await this.#thread(threadId);
 		// Locking needs Manage Threads; without it the thread is only archived.

package/src/core/discord/dispatch-threads.ts

@@ -7,6 +7,7 @@ import {
 } from "node:fs";
 import { dirname } from "node:path";
 import type { ChannelKey } from "../domain/conversation.ts";
+import type { InterimMessage, InterimPosts } from "../domain/interim.ts";
 import { messages } from "../i18n/index.ts";
 import type { Logger } from "../log.ts";
 
@@ -27,6 +28,11 @@ export interface ThreadHost {
 		line: (thread?: string) => string,
 	): Promise<string | undefined>;
 	post(threadId: string, text: string): Promise<void>;
+	/**
+	 * Posts one message of at most Discord's 2000 characters and resolves to it, so it can be
+	 * edited in place; without it a thread has no `interim` posts.
+	 */
+	send?(threadId: string, text: string): Promise<InterimMessage>;
 	/** Archives the thread, and locks it when allowed. */
 	close(threadId: string): Promise<void>;
 }
@@ -40,6 +46,12 @@ export interface DispatchThread {
 	readonly mention: string;
 	/** Posts in the thread; a failure is logged. */
 	post(text: string): Promise<void>;
+	/**
+	 * Where the dispatch posts its progress as it goes, under the same name as its report, such
+	 * as a coding worker's interim text; absent when the host cannot edit a message it posted.
+	 * Unlike `post`, a failure rejects.
+	 */
+	readonly interim?: InterimPosts;
 	/** Posts the final report, if any, then archives the thread. Runs once; never rejects. */
 	close(report?: string): Promise<void>;
 }
@@ -132,6 +144,7 @@ export class DispatchThreads {
 	#thread(id: string): DispatchThread {
 		const { host, logger } = this.#options;
 		let closed = false;
+		const send = host.send?.bind(host);
 		const post = async (text: string) => {
 			try {
 				await host.post(id, text);
@@ -144,6 +157,7 @@ export class DispatchThreads {
 			channel: `${PREFIX}${id}`,
 			mention: `<#${id}>`,
 			post,
+			...(send ? { interim: { post: (text: string) => send(id, text) } } : {}),
 			close: async (report) => {
 				if (closed) return;
 				closed = true;

package/src/core/discord/inbound-message.ts

@@ -2,6 +2,7 @@ import { type Message, MessageReferenceType } from "discord.js";
 import type { InboundMessage } from "../contract/channels.ts";
 import { channelKey } from "../contract/surface.ts";
 import type { AttachmentRef } from "../domain/attachment.ts";
+import type { LateTurn } from "./owner-cards.ts";
 
 /** Who the bot is on Discord, as far as the client knows it. */
 export interface BotIdentity {
@@ -113,3 +114,36 @@ export async function toInbound(
 		...(referenced ? { reference: referenceOf(referenced, mention) } : {}),
 	};
 }
+
+/**
+ * A card's late answer as a message from whoever answered, in the card's channel, standing in
+ * for the card's message: the router resolves its author as any other's, and the claim answers it.
+ */
+export function lateAnswerMessage(turn: LateTurn): InboundMessage {
+	const { user } = turn;
+	const roles = user.roleIds;
+	return {
+		channel: channelKey("discord", turn.channelId),
+		messageId: turn.messageId,
+		actor: {
+			provider: "discord",
+			subject: user.id,
+			name: user.name,
+			surface: "discord",
+			...(roles ? { roles: roles.map((role) => `discord:role:${role}`) } : {}),
+			...(turn.guildId ? { space: turn.guildId } : {}),
+			legacyId: user.id,
+		},
+		authorId: user.id,
+		authorName: user.name,
+		authorIsBot: false,
+		...(roles ? { authorRoleIds: roles } : {}),
+		...(turn.guildId ? { space: turn.guildId } : {}),
+		isDirect: turn.isDirect,
+		// Pressing the assistant's card speaks to it, as a mention does.
+		mentionsBot: true,
+		repliesToBot: true,
+		text: turn.text,
+		attachments: [],
+	};
+}

package/src/core/discord/owner-card-rows.ts

@@ -0,0 +1,98 @@
+import {
+	ActionRowBuilder,
+	ButtonBuilder,
+	ButtonStyle,
+	LabelBuilder,
+	ModalBuilder,
+	StringSelectMenuBuilder,
+	TextInputBuilder,
+	TextInputStyle,
+} from "discord.js";
+import { messages } from "../i18n/index.ts";
+import type { OwnerAnswer, OwnerQuestion } from "../interactions/prompts.ts";
+import { type ownerPanel, plain } from "./owner-panel.ts";
+
+/** The prefix of every card control's custom id. */
+export const CARD_PREFIX = "roundtable:card:";
+/** The menu value of "Other…". */
+export const OTHER = "other";
+/** The answer form's text field. */
+export const TEXT_FIELD = "text";
+
+export type Rows = NonNullable<Parameters<typeof ownerPanel>[0]["rows"]>;
+
+/** A question's controls: a menu of its options, or a button that opens the answer form. */
+export function askRows(
+	id: string,
+	question: OwnerQuestion,
+	disabled: boolean,
+): Rows {
+	if (question.options.length === 0)
+		return [
+			new ActionRowBuilder<ButtonBuilder>().addComponents(
+				new ButtonBuilder()
+					.setCustomId(`${CARD_PREFIX}${id}:write`)
+					.setLabel(messages().cardAnswerLabel)
+					.setStyle(ButtonStyle.Primary)
+					.setDisabled(disabled),
+			),
+		];
+	// Discord menus take 25 options; "Other…" takes the last place when the options fill it.
+	const options = question.options
+		.slice(0, question.allowOther ? 24 : 25)
+		.map((option, i) => ({
+			label: option.label.slice(0, 100),
+			value: String(i),
+			...(option.description
+				? { description: option.description.slice(0, 100) }
+				: {}),
+		}));
+	if (question.allowOther)
+		options.push({
+			label: messages().cardOtherLabel,
+			value: OTHER,
+			description: messages().cardOtherDescription,
+		});
+	return [
+		new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
+			new StringSelectMenuBuilder()
+				.setCustomId(`${CARD_PREFIX}${id}:pick`)
+				.setPlaceholder(
+					question.multi
+						? messages().cardPickManyPlaceholder
+						: messages().cardPickOnePlaceholder,
+				)
+				.setMinValues(1)
+				.setMaxValues(question.multi ? options.length : 1)
+				.addOptions(options)
+				.setDisabled(disabled),
+		),
+	];
+}
+
+export function answerModal(id: string): ModalBuilder {
+	return new ModalBuilder()
+		.setCustomId(`${CARD_PREFIX}${id}:text`)
+		.setTitle(messages().cardModalTitle)
+		.addLabelComponents(
+			new LabelBuilder()
+				.setLabel(messages().cardModalField)
+				.setTextInputComponent(
+					new TextInputBuilder()
+						.setCustomId(TEXT_FIELD)
+						.setStyle(TextInputStyle.Paragraph)
+						.setRequired(true)
+						.setMaxLength(1000),
+				),
+		);
+}
+
+export function answeredLine(answer: OwnerAnswer): string {
+	const parts = [
+		...answer.choices.map(plain),
+		...(answer.text !== undefined
+			? [messages().cardQuote(plain(answer.text))]
+			: []),
+	];
+	return messages().cardAnswered(parts);
+}

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

@@ -56,6 +56,9 @@ export function press(
 		isModalSubmit: () => kind === "modal",
 		isFromMessage: () => true,
 		customId,
+		inGuild: () => true,
+		guildId: "300000000000000003",
+		message: { id: "400000000000000004" },
 		user: { id: options.user ?? OWNER },
 		member: {
 			roles: { cache: new Map((options.roles ?? []).map((r) => [r, r])) },