pi-roundtable 0.10.0 → 0.11.0

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

@@ -0,0 +1,192 @@
+import { existsSync, readFileSync } from "node:fs";
+import { chmod, mkdir, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { AttachmentBuilder, MessageFlags } from "discord.js";
+import { messages } from "../i18n/index.ts";
+import type { Logger } from "../log.ts";
+
+/** The most characters of one card's copy text; a longer one gets no copy button. */
+export const COPY_TEXT_LIMIT = 20_000;
+/** How many cards' copy texts are kept by default, the newest. */
+const COPY_KEEP = 100;
+/** How many days a copy text is kept by default. */
+const COPY_KEEP_DAYS = 30;
+
+interface Entry {
+	text: string;
+	at: number;
+}
+
+export interface CardCopiesOptions {
+	/** A JSON file that keeps the texts across restarts; without it they live in memory only. */
+	path?: string;
+	/** How many cards' texts are kept, the newest; default `COPY_KEEP`. */
+	keep?: number;
+	/** How many days a text is kept; default `COPY_KEEP_DAYS`. */
+	keepDays?: number;
+	logger: Logger;
+	/** Replaceable in tests. */
+	now?: () => number;
+}
+
+/**
+ * The text behind an approval card's copy button, by the card's id: the button's custom id holds
+ * the id only, so the text is looked up when it is pressed, also after the process restarted when
+ * there is a file. Bounded by count and age. The file is written off the hot path, one write at a
+ * time and a burst of cards in one, through a temporary file that replaces it whole, readable by
+ * the host's user only; one that cannot be read or written is logged and the texts that remain
+ * are kept in memory. Discarding a conversation does not remove its cards' texts: they age out.
+ */
+export class CardCopies {
+	readonly #options: CardCopiesOptions;
+	readonly #entries = new Map<string, Entry>();
+	#writing: Promise<void> | undefined;
+	#dirty = false;
+
+	constructor(options: CardCopiesOptions) {
+		this.#options = options;
+		const { path, logger } = options;
+		if (!path || !existsSync(path)) return;
+		try {
+			const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+			if (typeof parsed !== "object" || parsed === null)
+				throw new Error("not a JSON object");
+			for (const [id, entry] of Object.entries(parsed)) {
+				const { text, at } = entry as Partial<Entry>;
+				if (typeof text === "string" && typeof at === "number")
+					this.#entries.set(id, { text, at });
+			}
+			this.#prune();
+		} catch (error) {
+			logger.warn(
+				{ path, err: error },
+				"card copy texts not read; copy buttons of earlier cards will say they are gone",
+			);
+		}
+	}
+
+	/** Keeps a card's copy text. */
+	remember(id: string, text: string): void {
+		this.#entries.set(id, { text, at: this.#now() });
+		this.#prune();
+		this.#schedule();
+	}
+
+	/** A card's copy text; undefined when it was never kept or has aged out. */
+	recall(id: string): string | undefined {
+		const entry = this.#entries.get(id);
+		if (!entry) return undefined;
+		if (this.#now() - entry.at > this.#keepMs()) {
+			this.#entries.delete(id);
+			return undefined;
+		}
+		return entry.text;
+	}
+
+	/** Resolves once what was remembered so far is on disk; for a host that stops and for tests. */
+	async flush(): Promise<void> {
+		while (this.#writing) await this.#writing;
+	}
+
+	#now(): number {
+		return (this.#options.now ?? Date.now)();
+	}
+
+	#keepMs(): number {
+		return (this.#options.keepDays ?? COPY_KEEP_DAYS) * 24 * 60 * 60_000;
+	}
+
+	#prune(): void {
+		const now = this.#now();
+		const keep = this.#options.keep ?? COPY_KEEP;
+		for (const [id, entry] of this.#entries)
+			if (now - entry.at > this.#keepMs()) this.#entries.delete(id);
+		for (const id of this.#entries.keys()) {
+			if (this.#entries.size <= keep) return;
+			this.#entries.delete(id);
+		}
+	}
+
+	/** Writes the file after the call that asked, once at a time; asks made meanwhile share the next write. */
+	#schedule(): void {
+		if (!this.#options.path) return;
+		this.#dirty = true;
+		if (this.#writing) return;
+		this.#writing = this.#drain().finally(() => {
+			this.#writing = undefined;
+		});
+	}
+
+	async #drain(): Promise<void> {
+		// Let the caller finish before the entries are serialized.
+		await Promise.resolve();
+		while (this.#dirty) {
+			this.#dirty = false;
+			await this.#write();
+		}
+	}
+
+	async #write(): Promise<void> {
+		const { path, logger } = this.#options;
+		if (!path) return;
+		try {
+			await mkdir(dirname(path), { recursive: true });
+			const temporary = `${path}.tmp`;
+			await writeFile(
+				temporary,
+				`${JSON.stringify(Object.fromEntries(this.#entries))}\n`,
+				{ mode: 0o600 },
+			);
+			// A temporary file left by an earlier run keeps its mode, so set it.
+			await chmod(temporary, 0o600);
+			await rename(temporary, path);
+		} catch (error) {
+			logger.warn({ path, err: error }, "card copy texts not saved");
+		}
+	}
+}
+
+/** Discord's limit for the text of a message. */
+const MESSAGE_LIMIT = 2_000;
+/** A button label's limit. */
+const LABEL_LIMIT = 80;
+
+/**
+ * The copy button an approval offers: its label and text; none when there is no text, and none,
+ * reported through `tooLong`, when the text is over `COPY_TEXT_LIMIT`.
+ */
+export function offeredCopy(
+	copy: { label?: string; text: string } | undefined,
+	tooLong: (chars: number) => void,
+): { label: string; text: string } | undefined {
+	if (!copy || copy.text === "") return undefined;
+	if (copy.text.length > COPY_TEXT_LIMIT) {
+		tooLong(copy.text.length);
+		return undefined;
+	}
+	const label = copy.label?.trim();
+	return {
+		label: label ? label.slice(0, LABEL_LIMIT) : messages().cardCopyLabel,
+		text: copy.text,
+	};
+}
+
+/** The reply to a press of a copy button: the text in a code block, or a file when it does not fit one. */
+export function copyReply(text: string) {
+	const block = `\`\`\`\n${text}\n\`\`\``;
+	const inline = !text.includes("```") && block.length <= MESSAGE_LIMIT;
+	return {
+		content: inline ? block : messages().cardCopyFile,
+		...(inline
+			? {}
+			: {
+					files: [
+						new AttachmentBuilder(Buffer.from(text, "utf8"), {
+							name: "copy.txt",
+						}),
+					],
+				}),
+		flags: MessageFlags.Ephemeral as const,
+		allowedMentions: { parse: [] as never[] },
+	};
+}

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

@@ -1,30 +1,64 @@
 import type { Message } from "discord.js";
 import type {
 	ChannelContext,
+	ChannelContextAttachmentOptions,
 	ChannelContextMessage,
 	ChannelContextOptions,
 } from "../contract/channel-context.ts";
 import type { InboundMessage } from "../contract/channels.ts";
 import { parseChannelKey } from "../contract/surface.ts";
+import { MAX_TURN_IMAGES } from "../domain/attachment.ts";
 import type { Logger } from "../log.ts";
+import { contextImages, type SkippedImage } from "./context-images.ts";
 import type { BotIdentity } from "./inbound-message.ts";
 
-export type ChannelContextSettings = Required<ChannelContextOptions>;
+/** The most bytes one image may be: the core's limit for any attachment. */
+const MAX_IMAGE_BYTES = 25 * 1024 * 1024;
+
+/** The options with every default filled in, the attachments' too. */
+export type ChannelContextSettings = Required<
+	Omit<ChannelContextOptions, "attachments">
+> & { attachments: Required<ChannelContextAttachmentOptions> };
 
 /** The defaults of `ChannelContextOptions`. */
 export const CHANNEL_CONTEXT_DEFAULTS: Readonly<
-	Required<ChannelContextOptions>
+	Omit<Required<ChannelContextOptions>, "attachments"> & {
+		attachments: Readonly<Required<ChannelContextAttachmentOptions>>;
+	}
 > = Object.freeze({
 	fetch: 50,
 	keep: 15,
 	similarity: 0.8,
 	messageChars: 500,
 	botMessageChars: 80,
+	foreignWebhook: () => false,
+	attachments: Object.freeze({ images: 0, maxBytes: 10 * 1024 * 1024 }),
 });
 
+/** The host's options, then the call's, over the defaults; the attachments' members merge one by one. */
+function resolvedSettings(
+	host: ChannelContextOptions,
+	call: ChannelContextOptions,
+): ChannelContextSettings {
+	const merged = {
+		...CHANNEL_CONTEXT_DEFAULTS,
+		...defined(host),
+		...defined(call),
+	};
+	return {
+		...merged,
+		attachments: {
+			...CHANNEL_CONTEXT_DEFAULTS.attachments,
+			...defined(host.attachments ?? {}),
+			...defined(call.attachments ?? {}),
+		} as Required<ChannelContextAttachmentOptions>,
+	};
+}
+
 /** Throws on a value outside what the configuration accepts: a programming error of the caller. */
 function assertChannelContextSettings(settings: ChannelContextSettings): void {
 	const { fetch, keep, similarity, messageChars, botMessageChars } = settings;
+	const { images, maxBytes } = settings.attachments;
 	const positive = { fetch, keep, messageChars, botMessageChars };
 	for (const [name, value] of Object.entries(positive))
 		if (!Number.isInteger(value) || value < 1)
@@ -35,6 +69,18 @@ function assertChannelContextSettings(settings: ChannelContextSettings): void {
 		throw new RangeError(
 			`channel context option similarity must be between 0 and 1, got ${similarity}`,
 		);
+	if (typeof settings.foreignWebhook !== "function")
+		throw new TypeError(
+			"channel context option foreignWebhook must be a function",
+		);
+	if (!Number.isInteger(images) || images < 0 || images > MAX_TURN_IMAGES)
+		throw new RangeError(
+			`channel context option attachments.images must be an integer from 0 to ${MAX_TURN_IMAGES}, got ${images}`,
+		);
+	if (!Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > MAX_IMAGE_BYTES)
+		throw new RangeError(
+			`channel context option attachments.maxBytes must be an integer from 1 to ${MAX_IMAGE_BYTES}, got ${maxBytes}`,
+		);
 }
 
 /** What channel context reads of one fetched message. */
@@ -45,16 +91,28 @@ export interface ContextSourceMessage {
 	bot: boolean;
 	/** The assistant posted it: its bot user, or a webhook of its application such as an agent's voice. */
 	own: boolean;
+	/** The webhook it was posted through, when that is a webhook of the assistant's application. */
+	webhookId?: string;
+	/** The files attached to it. */
+	attachments?: readonly ContextSourceAttachment[];
 	/** When it was posted, in epoch milliseconds. */
 	at: number;
 	text: string;
 }
 
+/** A file attached to a fetched message, as Discord describes it. */
+export interface ContextSourceAttachment {
+	name: string;
+	contentType: string;
+	size: number;
+	url: string;
+}
+
 /** The options that were given: a key set to undefined is the same as a missing one. */
-function defined(options: ChannelContextOptions): ChannelContextOptions {
+function defined<T extends object>(options: T): Partial<T> {
 	return Object.fromEntries(
 		Object.entries(options).filter(([, value]) => value !== undefined),
-	);
+	) as Partial<T>;
 }
 
 function attachmentLabel(contentType: string | null | undefined): string {
@@ -96,8 +154,17 @@ export function contextSourceOf(
 			message.author.username,
 		bot: message.author.bot,
 		own: message.author.id === botId || ownWebhook,
+		...(ownWebhook && message.webhookId
+			? { webhookId: message.webhookId }
+			: {}),
 		at: message.createdTimestamp,
 		text: parts.join(" "),
+		attachments: [...message.attachments.values()].map((file) => ({
+			name: file.name,
+			contentType: file.contentType ?? "",
+			size: file.size,
+			url: file.url,
+		})),
 	};
 }
 
@@ -126,10 +193,14 @@ function similarity(a: string, b: string): number {
 	return longest / longer.length;
 }
 
-/** Consecutive messages of one author at least `threshold` alike become the later one. */
+/**
+ * Consecutive messages of one author at least `threshold` alike become the later one. A `foreign`
+ * message is one of a webhook that carries many people, so it also needs the same name.
+ */
 function merged(
 	messages: readonly ContextSourceMessage[],
 	threshold: number,
+	foreign: (message: ContextSourceMessage) => boolean,
 ): ContextSourceMessage[] {
 	const out: ContextSourceMessage[] = [];
 	for (const message of messages) {
@@ -137,6 +208,7 @@ function merged(
 		if (
 			last &&
 			last.authorId === message.authorId &&
+			(!foreign(message) || last.authorName === message.authorName) &&
 			similarity(last.text, message.text) >= threshold
 		)
 			out[out.length - 1] = message;
@@ -155,7 +227,9 @@ export interface ChannelContextSelection {
 	seen: ReadonlySet<string>;
 	/** The owners' user ids. */
 	owners: readonly string[];
-	settings: ChannelContextSettings;
+	/** What the selection reads of the settings; without `foreignWebhook` every webhook of the application is the assistant's. */
+	settings: Omit<ChannelContextSettings, "foreignWebhook" | "attachments"> &
+		Partial<Pick<ChannelContextSettings, "foreignWebhook">>;
 }
 
 /**
@@ -168,12 +242,19 @@ export function selectChannelContext(
 	{ seen, owners, settings }: ChannelContextSelection,
 ): { messages: ChannelContextMessage[]; window: string[] } {
 	const ordered = fetched.toSorted((a, b) => a.at - b.at);
-	const lastOwn = ordered.findLastIndex((message) => message.own);
+	// A webhook of the application that the host calls foreign speaks for other people, not for the assistant.
+	const foreign = (message: ContextSourceMessage) =>
+		message.webhookId !== undefined &&
+		settings.foreignWebhook?.(message.webhookId) === true;
+	const assistants = (message: ContextSourceMessage) =>
+		message.own && !foreign(message);
+	const lastOwn = ordered.findLastIndex(assistants);
 	const window = ordered.slice(lastOwn + 1);
 	// Cut before comparing: the comparison is quadratic in the text lengths.
 	const fresh = window
 		.filter(
-			(message) => !message.own && !seen.has(message.id) && message.text !== "",
+			(message) =>
+				!assistants(message) && !seen.has(message.id) && message.text !== "",
 		)
 		.map((message) => ({
 			...message,
@@ -182,7 +263,9 @@ export function selectChannelContext(
 				message.bot ? settings.botMessageChars : settings.messageChars,
 			),
 		}));
-	const kept = merged(fresh, settings.similarity).slice(-settings.keep);
+	const kept = merged(fresh, settings.similarity, foreign).slice(
+		-settings.keep,
+	);
 	return {
 		window: window.map((message) => message.id),
 		messages: kept.map((message) => ({
@@ -193,6 +276,10 @@ export function selectChannelContext(
 			owner: !message.bot && owners.includes(message.authorId),
 			text: message.text,
 			at: new Date(message.at),
+			attachments: (message.attachments ?? []).map((file) => ({
+				...file,
+				messageId: message.id,
+			})),
 		})),
 	};
 }
@@ -236,6 +323,21 @@ export function formatChannelContext(
 	].join("\n");
 }
 
+/** The messages with a note in the text of each for an image that was asked for and not attached. */
+function withSkipNotes(
+	messages: readonly ChannelContextMessage[],
+	skipped: readonly SkippedImage[],
+): ChannelContextMessage[] {
+	return messages.map((message) => {
+		const notes = skipped
+			.filter((image) => image.messageId === message.id)
+			.map((image) => `[image not attached: ${image.name}: ${image.reason}]`);
+		return notes.length === 0
+			? { ...message }
+			: { ...message, text: [message.text, ...notes].join(" ") };
+	});
+}
+
 /** How many delivered message ids are remembered per channel, and how many channels. */
 const SEEN_PER_CHANNEL = 500;
 const SEEN_CHANNELS = 1_000;
@@ -252,6 +354,8 @@ export interface ChannelContextReaderOptions {
 	/** The host's settings; `false` turns channel context off for every claim. */
 	settings: ChannelContextOptions | false;
 	logger: Logger;
+	/** Fetches the images of messages; replaceable in tests. */
+	fetchImpl?: typeof fetch;
 }
 
 /**
@@ -280,11 +384,7 @@ export class ChannelContextReader {
 			return undefined;
 		const { surface, id: channelId } = parseChannelKey(message.channel);
 		if (surface !== "discord") return undefined;
-		const settings = {
-			...CHANNEL_CONTEXT_DEFAULTS,
-			...defined(host),
-			...defined(options),
-		};
+		const settings = resolvedSettings(host, options);
 		assertChannelContextSettings(settings);
 		const seen = this.#seenIn(channelId);
 		seen.add(message.messageId);
@@ -304,7 +404,13 @@ export class ChannelContextReader {
 			for (const id of window) seen.add(id);
 			this.#trim(seen);
 			if (messages.length === 0) return undefined;
-			return { messages, text: formatChannelContext(messages) };
+			const { images, skipped } = await this.#images(messages, settings);
+			const noted = withSkipNotes(messages, skipped);
+			return {
+				messages: noted,
+				text: formatChannelContext(noted),
+				...(images.length > 0 ? { images } : {}),
+			};
 		} catch (error) {
 			logger.warn(
 				{ channel: message.channel, err: error },
@@ -314,6 +420,27 @@ export class ChannelContextReader {
 		}
 	}
 
+	/** The images of the kept messages the settings ask for, the newest first; none when they ask for none. */
+	async #images(
+		messages: readonly ChannelContextMessage[],
+		settings: ChannelContextSettings,
+	) {
+		const { images: count, maxBytes } = settings.attachments;
+		if (count === 0) return { images: [], skipped: [] };
+		const candidates = messages
+			.toReversed()
+			.flatMap((message) => message.attachments ?? [])
+			.filter((file) => file.contentType.startsWith("image/"));
+		return contextImages(candidates, {
+			count,
+			maxBytes,
+			logger: this.#options.logger,
+			...(this.#options.fetchImpl
+				? { fetchImpl: this.#options.fetchImpl }
+				: {}),
+		});
+	}
+
 	/** The owners' user ids; none, logged, when they cannot be read, since marking them is not worth failing for. */
 	async #owners(): Promise<readonly string[]> {
 		try {

package/src/core/discord/context-images.ts

@@ -0,0 +1,164 @@
+import {
+	isModelImage,
+	prepareImageBytes,
+	sniffImageType,
+} from "../attachments/image-prep.ts";
+import type { ChannelContextAttachment } from "../contract/channel-context.ts";
+import type { ModelImage } from "../domain/attachment.ts";
+import type { Logger } from "../log.ts";
+
+/** Why an image of a channel message was not attached to the turn; fixed words, never an error's text. */
+export type SkippedReason =
+	| "unsupported type"
+	| "too large"
+	| "download failed"
+	| "could not be decoded";
+
+export interface SkippedImage {
+	messageId: string;
+	name: string;
+	reason: SkippedReason;
+}
+
+/** How long one image may take to download. */
+const FETCH_TIMEOUT_MS = 15_000;
+/** How long all the images of one call may take to download, whatever their number. */
+const DEADLINE_MS = 20_000;
+/** How many images are downloaded at once. */
+const CONCURRENCY = 2;
+
+/** The bytes of a response, or undefined once they pass `max`. */
+async function boundedBody(
+	response: Response,
+	max: number,
+): Promise<Uint8Array | undefined> {
+	if (!response.body) return new Uint8Array();
+	const reader = response.body.getReader();
+	const chunks: Uint8Array[] = [];
+	let size = 0;
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			size += value.byteLength;
+			if (size > max) {
+				await reader.cancel();
+				return undefined;
+			}
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const data = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		data.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return data;
+}
+
+/**
+ * Fetches up to `count` of the candidates' images, in the order given, and prepares them as a
+ * turn's own images are (see `prepareImageBytes`). A candidate that is not an image the model
+ * accepts (by its declared type, and by its bytes, which give the type it is sent as), is over
+ * `maxBytes` (by Discord's size or by what arrives), cannot be fetched, or cannot be decoded is
+ * skipped with its reason; a candidate of a type the model does not accept does not count toward
+ * `count`, and at most twice `count` are tried. Two are downloaded at once, and all of them share
+ * one deadline: the candidates that are still to be fetched when it passes are skipped as
+ * undownloadable. Bytes stay in memory and nothing about them is logged.
+ */
+export async function contextImages(
+	candidates: readonly ChannelContextAttachment[],
+	options: {
+		count: number;
+		maxBytes: number;
+		fetchImpl?: typeof fetch;
+		logger: Logger;
+		/** Replaceable in tests; default 20 seconds. */
+		deadlineMs?: number;
+	},
+): Promise<{ images: ModelImage[]; skipped: SkippedImage[] }> {
+	const { count } = options;
+	const deadline = AbortSignal.timeout(options.deadlineMs ?? DEADLINE_MS);
+	const images: ModelImage[] = [];
+	const skipped: SkippedImage[] = [];
+	const skip = (file: ChannelContextAttachment, reason: SkippedReason) =>
+		skipped.push({ messageId: file.messageId, name: file.name, reason });
+	let tried = 0;
+	let next = 0;
+	while (images.length < count && next < candidates.length) {
+		// Never start more downloads than there are images still wanted, so none is wasted.
+		const batch: ChannelContextAttachment[] = [];
+		const room = Math.min(CONCURRENCY, count - images.length);
+		while (
+			batch.length < room &&
+			next < candidates.length &&
+			tried < count * 2
+		) {
+			const file = candidates[next++] as ChannelContextAttachment;
+			if (
+				!isModelImage({ contentType: file.contentType }) ||
+				!file.url.startsWith("https://")
+			) {
+				skip(file, "unsupported type");
+				continue;
+			}
+			tried++;
+			batch.push(file);
+		}
+		if (batch.length === 0) break;
+		const fetched = await Promise.all(
+			batch.map((file) => oneImage(file, options, deadline)),
+		);
+		for (const [index, result] of fetched.entries()) {
+			const file = batch[index] as ChannelContextAttachment;
+			if ("image" in result) images.push(result.image);
+			else skip(file, result.skipped);
+		}
+	}
+	return { images, skipped };
+}
+
+/** One candidate's image, or why it is skipped. */
+async function oneImage(
+	file: ChannelContextAttachment,
+	options: {
+		maxBytes: number;
+		fetchImpl?: typeof fetch;
+		logger: Logger;
+	},
+	deadline: AbortSignal,
+): Promise<{ image: ModelImage } | { skipped: SkippedReason }> {
+	const { maxBytes, logger, fetchImpl = fetch } = options;
+	if (file.size > maxBytes) return { skipped: "too large" };
+	if (deadline.aborted) return { skipped: "download failed" };
+	let data: Uint8Array | undefined;
+	try {
+		const response = await fetchImpl(file.url, {
+			signal: AbortSignal.any([
+				deadline,
+				AbortSignal.timeout(FETCH_TIMEOUT_MS),
+			]),
+		});
+		if (!response.ok) {
+			await response.body?.cancel();
+			return { skipped: "download failed" };
+		}
+		data = await boundedBody(response, maxBytes);
+	} catch (error) {
+		logger.warn({ err: error }, "channel context image not fetched");
+		return { skipped: "download failed" };
+	}
+	if (!data) return { skipped: "too large" };
+	// The bytes say what it is; Discord's type is a guess from the file's name.
+	const type = sniffImageType(data);
+	if (!type) return { skipped: "unsupported type" };
+	try {
+		return { image: await prepareImageBytes(data, type) };
+	} catch (error) {
+		logger.warn({ err: error }, "channel context image not decoded");
+		return { skipped: "could not be decoded" };
+	}
+}

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

@@ -47,6 +47,8 @@ export function press(
 	} = {},
 ) {
 	const replies: string[] = [];
+	/** Everything a reply carried besides its text. */
+	const replied: { files?: unknown[]; flags?: unknown }[] = [];
 	const updates: CardPayload[] = [];
 	const modals: unknown[] = [];
 	// SAFETY: the cards read only these members of an interaction.
@@ -65,8 +67,13 @@ export function press(
 		},
 		values: options.values ?? [],
 		fields: { getTextInputValue: () => options.text ?? "" },
-		reply: async (answer: { content: string }) => {
+		reply: async (answer: {
+			content: string;
+			files?: unknown[];
+			flags?: unknown;
+		}) => {
 			replies.push(answer.content);
+			replied.push(answer);
 		},
 		update: async (payload: CardPayload) => {
 			updates.push(payload);
@@ -76,7 +83,7 @@ export function press(
 		},
 		deferUpdate: async () => undefined,
 	} as unknown as Interaction;
-	return { interaction, replies, updates, modals };
+	return { interaction, replies, replied, updates, modals };
 }
 
 /** Lets a posted card settle. */