@geminixiang/mikan 1.0.0-beta.7 → 1.0.0-beta.71

package/dist/adapters/discord/bot.js

@@ -1,10 +1,14 @@
 import { ApplicationCommandOptionType, Client, Events, GatewayIntentBits, Partials, } from "discord.js";
-import { readFileSync } from "fs";
-import { basename, join } from "path";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { discordTextPayload } from "./components.js";
+import { createConversationEvent, createConversationMessage, } from "../index.js";
 import * as log from "../../log.js";
-import { resolveChatSessionKey } from "../../sessions/policy.js";
-import { formatNothingRunning } from "../../platform-messages.js";
-import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, downloadUrlToFile, resolveOnlyScopedStopTarget, resolveStopTarget, withRetry, } from "../shared.js";
+import { createOfficeAddress } from "../../office/index.js";
+import { resolveChatSessionKey } from "../../sessions/session-key.js";
+import { formatNothingRunning } from "../messages.js";
+import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, MessagingIntakeTracker, downloadUrlToFile, resolveOnlyScopedStopTarget, resolveStopTarget, saveIncomingAttachments, shortNameToUnicodeEmoji, withRetry, } from "../shared.js";
+import { COMMAND_MANIFEST } from "../commands/manifest.js";
 import { processMessageIntake } from "../intake.js";
 import { createDiscordAdapters } from "./context.js";
 // discord.js: DiscordAPIError exposes `.status` (HTTP status) and a `.code`.
@@ -25,13 +29,15 @@ const discordRetry = (fn) => withRetry(fn, { isRateLimited: discordIsRateLimited
 export class DiscordMessagingBot {
     constructor(handler, config) {
         this.botUserId = null;
+        this.stopped = false;
         this.queues = new Map();
+        this.intake = new MessagingIntakeTracker("Discord");
         this.startupTime = 0;
         this.channels = new Map();
         this.users = new Map();
         this.handler = handler;
         this.token = config.token;
-        this.workingDir = config.workingDir;
+        this.workspace = config.workspace;
         this.client = new Client({
             intents: [
                 GatewayIntentBits.Guilds,
@@ -46,8 +52,13 @@ export class DiscordMessagingBot {
     // Public API (implements MessagingBot)
     // ==========================================================================
     async start() {
+        this.stopped = false;
         await new Promise((resolve, reject) => {
             this.client.once(Events.ClientReady, async (readyClient) => {
+                if (this.stopped) {
+                    resolve();
+                    return;
+                }
                 this.botUserId = readyClient.user.id;
                 this.startupTime = Date.now();
                 log.logConnected("Discord");
@@ -55,48 +66,23 @@ export class DiscordMessagingBot {
                 this.loadCachedGuildData();
                 this.setupEventHandlers();
                 try {
-                    await readyClient.application.commands.set([
-                        {
-                            name: "login",
-                            description: "Store credentials in your private vault",
-                        },
-                        {
-                            name: "session",
-                            description: "Open the current session in the web viewer",
-                        },
-                        {
-                            name: "new",
-                            description: "Reset conversation history and start fresh",
-                        },
-                        {
-                            name: "stop",
-                            description: "Stop the current conversation",
-                        },
-                        {
-                            name: "model",
-                            description: "Switch this conversation's LLM model",
-                            options: [
-                                {
-                                    name: "model",
-                                    description: "provider/model[:thinking], e.g. anthropic/claude-sonnet-4-6:off",
-                                    type: ApplicationCommandOptionType.String,
-                                    required: false,
-                                },
-                            ],
-                        },
-                        {
-                            name: "sandbox",
-                            description: "Show or temporarily boost this conversation's sandbox limits",
+                    // Registration derives from the command manifest; routing below
+                    // handles new/stop natively and the rest through one generic path.
+                    await readyClient.application.commands.set(COMMAND_MANIFEST.filter((entry) => entry.discord).map((entry) => Object.assign({
+                        name: entry.name,
+                        description: entry.description,
+                    }, entry.arg
+                        ? {
                             options: [
                                 {
-                                    name: "action",
-                                    description: "Use 'boost' to temporarily apply the configured boost limits",
+                                    name: entry.arg.name,
+                                    description: entry.arg.description,
                                     type: ApplicationCommandOptionType.String,
-                                    required: false,
+                                    required: entry.arg.required,
                                 },
                             ],
-                        },
-                    ]);
+                        }
+                        : {})));
                 }
                 catch (err) {
                     log.logWarning("Failed to register Discord slash commands", err instanceof Error ? err.message : String(err));
@@ -107,10 +93,20 @@ export class DiscordMessagingBot {
             this.client.login(this.token).catch(reject);
         });
     }
+    async stop() {
+        this.stopped = true;
+        try {
+            this.client.destroy();
+        }
+        finally {
+            await this.intake.close();
+            await Promise.all([...this.queues.values()].map((queue) => queue.close()));
+        }
+    }
     async postMessage(channel, text) {
         return discordRetry(async () => {
             const ch = await this.fetchTextChannel(channel);
-            const msg = await ch.send(text);
+            const msg = await ch.send(discordTextPayload(text));
             return msg.id;
         });
     }
@@ -118,15 +114,18 @@ export class DiscordMessagingBot {
         await this.updateMessageRaw(channel, ts, text);
     }
     async addReaction(channel, messageTs, emoji) {
-        // Discord uses Unicode emoji directly (e.g. "👀"); accept a bare name too
-        // but Slack-style short names won't resolve, so pass through as-is.
+        // Discord's reaction API takes a Unicode character (or a custom emoji
+        // id); the `react` tool and prompt speak Slack-style short names, so
+        // translate here rather than push that mapping onto every caller.
         await discordRetry(async () => {
             const ch = await this.fetchTextChannel(channel);
             const msg = await ch.messages.fetch(messageTs);
-            await msg.react(emoji.replace(/^:|:$/g, ""));
+            await msg.react(shortNameToUnicodeEmoji(emoji));
         });
     }
     enqueueEvent(event) {
+        if (this.stopped)
+            return false;
         const conversationId = event.conversationId;
         const queue = this.getQueue(conversationId);
         if (queue.size() >= 5) {
@@ -134,16 +133,16 @@ export class DiscordMessagingBot {
             return false;
         }
         log.logInfo(`Enqueueing event for ${conversationId}: ${event.text.substring(0, 50)}`);
-        queue.enqueue(() => {
+        return queue.enqueue(() => {
             const context = createDiscordAdapters(event, this);
             return this.handler.handleEvent(event, this, context);
         });
-        return true;
     }
     getMessagingInfo() {
         return {
             name: "discord",
-            formattingGuide: "## Discord Formatting (Markdown)\nBold: **text**, Italic: *text*, Code: `code`, Block: ```language\ncode```\nLinks: [text](url)",
+            trustModel: "membership",
+            formattingGuide: "## Discord Formatting (Markdown)\nBold: **text**, Italic: *text*, Code: `code`, Block: ```language\ncode```\nLinks: [text](url), Spoiler: ||text||, Headings: # ## ###\nWrite ordinary Markdown, including tables — the adapter converts anything Discord cannot render. Use code blocks for code.",
             channels: this.getAllChannels(),
             users: this.getAllUsers(),
             diagnostics: {
@@ -158,14 +157,14 @@ export class DiscordMessagingBot {
         return discordRetry(async () => {
             const ch = await this.fetchTextChannel(channelId);
             const msg = await ch.messages.fetch(messageId);
-            await msg.edit(text);
+            await msg.edit(discordTextPayload(text));
         });
     }
     async postReply(channelId, replyToId, text) {
         return discordRetry(async () => {
             const ch = await this.fetchTextChannel(channelId);
             const replyTarget = await ch.messages.fetch(replyToId);
-            const sent = await replyTarget.reply(text);
+            const sent = await replyTarget.reply(discordTextPayload(text));
             return sent.id;
         });
     }
@@ -175,7 +174,7 @@ export class DiscordMessagingBot {
             const thread = await this.client.channels.fetch(threadOrMessageId);
             if (thread && (thread.isThread() || thread.isTextBased())) {
                 return discordRetry(async () => {
-                    const msg = await thread.send(text);
+                    const msg = await thread.send(discordTextPayload(text));
                     return msg.id;
                 });
             }
@@ -215,7 +214,7 @@ export class DiscordMessagingBot {
     async sendDirectMessage(userId, text) {
         return discordRetry(async () => {
             const user = await this.client.users.fetch(userId);
-            const msg = await user.send(text);
+            const msg = await user.send(discordTextPayload(text));
             return msg.id;
         });
     }
@@ -229,54 +228,33 @@ export class DiscordMessagingBot {
         return Array.from(this.users.values());
     }
     logToFile(channelId, entry) {
-        appendChannelLog(this.workingDir, channelId, entry);
+        appendChannelLog(this.workspace.office(createOfficeAddress("discord", channelId)), entry);
     }
     logBotResponse(channelId, text, ts) {
-        appendBotResponseLog(this.workingDir, channelId, text, ts);
+        appendBotResponseLog(this.workspace.office(createOfficeAddress("discord", channelId)), text, ts);
     }
     /**
      * Process attachments from a Discord message.
      * Downloads files before returning so the agent can read them immediately.
      */
-    async processAttachments(channelId, attachments, _messageId) {
-        const downloads = [];
-        // Discord attachments Collection - iterate over values
+    async processAttachments(channelId, attachments) {
+        const items = [];
         for (const attachment of attachments.values()) {
             if (!attachment.name) {
                 log.logWarning("Discord attachment missing name, skipping", attachment.url);
                 continue;
             }
-            const ts = Date.now();
-            const sanitizedName = attachment.name.replace(/[^a-zA-Z0-9._-]/g, "_");
-            const filename = `${ts}_${sanitizedName}`;
-            const localPath = `${channelId}/attachments/${filename}`;
-            const fullDir = join(this.workingDir, channelId, "attachments");
-            const result = {
+            items.push({
                 name: attachment.name,
-                localPath,
-            };
-            downloads.push(this.downloadAttachment(fullDir, filename, attachment.url)
-                .then(() => result)
-                .catch((err) => {
-                log.logWarning(`Failed to download Discord attachment`, `${filename}: ${err}`);
-                return null;
-            }));
-        }
-        const results = await Promise.all(downloads);
-        return results.filter((attachment) => attachment !== null);
-    }
-    /**
-     * Download an attachment from URL to local file
-     */
-    async downloadAttachment(dir, filename, url) {
-        try {
-            await downloadUrlToFile(url, join(dir, filename));
-        }
-        catch (err) {
-            throw new Error(`Download failed: ${err instanceof Error ? err.message : String(err)}`, {
-                cause: err,
+                download: (destPath) => downloadUrlToFile(attachment.url, destPath),
             });
         }
+        const office = this.workspace.office(createOfficeAddress("discord", channelId));
+        const { saved, failed } = await saveIncomingAttachments(office, items);
+        for (const failure of failed) {
+            log.logWarning(`Failed to download Discord attachment`, `${failure.name}: ${failure.error}`);
+        }
+        return saved.map((item) => ({ name: item.original, localPath: item.localPath }));
     }
     // ==========================================================================
     // Private - Event Handlers
@@ -290,16 +268,13 @@ export class DiscordMessagingBot {
         return queue;
     }
     resolveStopTarget(channelId, sessionKey) {
-        const directTarget = resolveStopTarget({
-            handler: this.handler,
-            conversationId: channelId,
-            sessionKey,
-        });
+        const address = createOfficeAddress("discord", channelId);
+        const directTarget = resolveStopTarget({ handler: this.handler, address, sessionKey });
         if (directTarget)
             return directTarget;
         if (sessionKey !== channelId)
             return null;
-        return resolveOnlyScopedStopTarget(this.handler, channelId);
+        return resolveOnlyScopedStopTarget(this.handler, address);
     }
     loadCachedGuildData() {
         for (const guild of this.client.guilds.cache.values()) {
@@ -346,7 +321,9 @@ export class DiscordMessagingBot {
         const userName = interaction.user.username;
         const platform = this.getMessagingInfo();
         const shouldUseEphemeral = !isDM;
-        const message = {
+        const message = createConversationMessage({
+            platform: "discord",
+            conversationId,
             id: interaction.id,
             sessionKey,
             conversationKind: isDM ? "direct" : "shared",
@@ -354,7 +331,7 @@ export class DiscordMessagingBot {
             userName,
             text: commandText,
             attachments: [],
-        };
+        });
         const respondPrivately = async (text, replace = false) => {
             if (interaction.replied || interaction.deferred) {
                 if (replace) {
@@ -383,189 +360,179 @@ export class DiscordMessagingBot {
                 await respondPrivately(formatted);
             },
             setTyping: async () => { },
-            setWorking: async () => { },
+            setWorking: async (working) => {
+                if (working && !interaction.replied && !interaction.deferred) {
+                    await interaction.deferReply({ ephemeral: shouldUseEphemeral });
+                }
+            },
             uploadFile: async (filePath, title) => {
                 await this.uploadFile(conversationId, filePath, title);
             },
             deleteResponse: async () => { },
         };
-        return { message, responder, platform };
+        return { address: message.address, message, responder, platform };
     }
     setupEventHandlers() {
-        this.client.on(Events.InteractionCreate, async (interaction) => {
-            if (!interaction.isChatInputCommand())
-                return;
-            if (interaction.commandName !== "login" &&
-                interaction.commandName !== "session" &&
-                interaction.commandName !== "new" &&
-                interaction.commandName !== "stop" &&
-                interaction.commandName !== "model" &&
-                interaction.commandName !== "sandbox") {
+        this.client.on(Events.InteractionCreate, (interaction) => {
+            void this.intake.run(() => this.handleInteractionCreate(interaction));
+        });
+        this.client.on(Events.MessageCreate, (message) => {
+            void this.intake.run(() => this.handleMessageCreate(message));
+        });
+    }
+    async handleInteractionCreate(interaction) {
+        if (!interaction.isChatInputCommand())
+            return;
+        const manifestEntry = COMMAND_MANIFEST.find((entry) => entry.discord && entry.name === interaction.commandName);
+        if (!manifestEntry)
+            return;
+        const isDM = !interaction.inGuild();
+        const { conversationId, threadTs } = this.resolveConversationContext({
+            channelId: interaction.channelId,
+            inGuild: interaction.inGuild(),
+            isThread: interaction.channel?.isThread() ?? false,
+            parentChannelId: interaction.channel && "parentId" in interaction.channel
+                ? interaction.channel.parentId
+                : null,
+        });
+        const sessionKey = resolveChatSessionKey({
+            conversationId,
+            conversationKind: isDM ? "direct" : "shared",
+            messageId: interaction.id,
+            persistentTopLevel: true,
+            threadTs,
+        });
+        const commandArg = manifestEntry.arg
+            ? interaction.options.getString(manifestEntry.arg.name)?.trim()
+            : undefined;
+        const commandText = commandArg
+            ? `/${interaction.commandName} ${commandArg}`
+            : `/${interaction.commandName}`;
+        this.logToFile(conversationId, {
+            date: new Date(interaction.createdTimestamp).toISOString(),
+            ts: interaction.id,
+            ...(threadTs ? { threadTs } : {}),
+            user: interaction.user.id,
+            userName: interaction.user.username,
+            text: commandText,
+            attachments: [],
+            isMessagingBot: false,
+        });
+        const context = this.createSlashCommandAdapters(interaction, commandText, sessionKey, conversationId);
+        try {
+            // Magic words are conversation-intake controls, not command handlers;
+            // the manifest's metadata routes them (today only `stop`).
+            if (manifestEntry.magicWord) {
+                const stopTarget = this.resolveStopTarget(conversationId, sessionKey);
+                if (stopTarget) {
+                    await this.handler.handleStop(createOfficeAddress("discord", conversationId), stopTarget, this);
+                    await context.responder.respond("Stopped the current conversation.");
+                }
+                else {
+                    await context.responder.respond(formatNothingRunning("discord"));
+                }
                 return;
             }
-            const isDM = !interaction.inGuild();
-            const { conversationId, threadTs } = this.resolveConversationContext({
-                channelId: interaction.channelId,
-                inGuild: interaction.inGuild(),
-                isThread: interaction.channel?.isThread() ?? false,
-                parentChannelId: interaction.channel && "parentId" in interaction.channel
-                    ? interaction.channel.parentId
-                    : null,
-            });
-            const sessionKey = resolveChatSessionKey({
+            const event = createConversationEvent({
+                platform: "discord",
+                type: "dm",
                 conversationId,
                 conversationKind: isDM ? "direct" : "shared",
-                messageId: interaction.id,
-                persistentTopLevel: true,
-                threadTs,
-            });
-            const modelOption = interaction.commandName === "model"
-                ? interaction.options.getString("model")?.trim()
-                : undefined;
-            const sandboxAction = interaction.commandName === "sandbox"
-                ? interaction.options.getString("action")?.trim()
-                : undefined;
-            const commandArg = modelOption ?? sandboxAction;
-            const commandText = commandArg
-                ? `/${interaction.commandName} ${commandArg}`
-                : `/${interaction.commandName}`;
-            this.logToFile(conversationId, {
-                date: new Date(interaction.createdTimestamp).toISOString(),
                 ts: interaction.id,
-                ...(threadTs ? { threadTs } : {}),
+                thread_ts: threadTs,
+                sessionKey,
                 user: interaction.user.id,
-                userName: interaction.user.username,
                 text: commandText,
                 attachments: [],
-                isMessagingBot: false,
             });
-            const context = this.createSlashCommandAdapters(interaction, commandText, sessionKey, conversationId);
-            try {
-                if (interaction.commandName === "new") {
-                    await this.handler.handleNewCommand(sessionKey, conversationId, this);
-                    await context.responder.respond("Started a new conversation.");
-                    return;
-                }
-                if (interaction.commandName === "stop") {
-                    const stopTarget = this.resolveStopTarget(conversationId, sessionKey);
-                    if (stopTarget) {
-                        await this.handler.handleStop(stopTarget, conversationId, this);
-                        await context.responder.respond("Stopped the current conversation.");
-                    }
-                    else {
-                        await context.responder.respond(formatNothingRunning("discord"));
-                    }
-                    return;
-                }
-                const event = {
-                    type: "dm",
-                    conversationId,
-                    conversationKind: isDM ? "direct" : "shared",
-                    ts: interaction.id,
-                    thread_ts: threadTs,
-                    sessionKey,
-                    user: interaction.user.id,
-                    text: commandText,
-                    attachments: [],
-                };
-                await this.handler.handleEvent(event, this, context);
-            }
-            catch (err) {
-                log.logWarning("Discord slash command error", err instanceof Error ? err.message : String(err));
-                if (!interaction.replied && !interaction.deferred) {
-                    await interaction.reply({
-                        content: `${interaction.commandName} command failed. Please try again later.`,
-                        ephemeral: !isDM,
-                    });
-                }
+            await this.handler.handleEvent(event, this, context);
+        }
+        catch (err) {
+            log.logWarning("Discord slash command error", err instanceof Error ? err.message : String(err));
+            if (!interaction.replied && !interaction.deferred) {
+                await interaction.reply({
+                    content: `${interaction.commandName} command failed. Please try again later.`,
+                    ephemeral: !isDM,
+                });
             }
+        }
+    }
+    async handleMessageCreate(msg) {
+        // Skip messages from before startup
+        if (msg.createdTimestamp < this.startupTime)
+            return;
+        // Skip bot messages
+        if (msg.author.bot)
+            return;
+        const isDM = msg.channel.type === 1; // ChannelType.DM = 1
+        const isInThread = msg.channel.isThread();
+        const referencedMsgId = msg.reference?.messageId;
+        const isThreadReply = isInThread || !!referencedMsgId;
+        const isMentioned = msg.mentions.users.has(this.botUserId ?? "");
+        const addressed = isDM || isMentioned || isThreadReply;
+        const { conversationId, threadTs } = this.resolveConversationContext({
+            channelId: msg.channelId,
+            inGuild: !isDM,
+            isThread: isInThread,
+            parentChannelId: "parentId" in msg.channel ? msg.channel.parentId : null,
+            referencedMsgId,
         });
-        this.client.on(Events.MessageCreate, async (msg) => {
-            // Skip messages from before startup
-            if (msg.createdTimestamp < this.startupTime)
-                return;
-            // Skip bot messages
-            if (msg.author.bot)
-                return;
-            const isDM = msg.channel.type === 1; // ChannelType.DM = 1
-            const isInThread = msg.channel.isThread();
-            const referencedMsgId = msg.reference?.messageId;
-            const isThreadReply = isInThread || !!referencedMsgId;
-            const isMentioned = msg.mentions.users.has(this.botUserId ?? "");
-            const isAutoReplyCandidate = !isDM && !isMentioned && !isThreadReply;
-            const { conversationId, threadTs } = this.resolveConversationContext({
-                channelId: msg.channelId,
-                inGuild: !isDM,
-                isThread: isInThread,
-                parentChannelId: "parentId" in msg.channel ? msg.channel.parentId : null,
-                referencedMsgId,
-            });
-            const userId = msg.author.id;
-            const userName = msg.author.username;
-            const msgId = msg.id;
-            // Track user
-            this.users.set(userId, {
-                id: userId,
-                userName,
-                displayName: msg.member?.displayName ?? userName,
-            });
-            // Track channel
-            if (!this.channels.has(conversationId) && "name" in msg.channel) {
-                const ch = msg.channel;
-                this.channels.set(conversationId, { id: conversationId, name: ch.name });
-            }
-            const conversationKind = isDM ? "direct" : "shared";
-            const sessionKey = resolveChatSessionKey({
-                conversationId,
-                conversationKind,
-                messageId: msgId,
-                persistentTopLevel: true,
-                threadTs,
-            });
-            const cleanedText = this.stripMessagingBotMention(msg.content);
-            const eventBase = {
-                type: isDM ? "dm" : "mention",
-                conversationId,
-                conversationKind,
+        const userId = msg.author.id;
+        const userName = msg.author.username;
+        const msgId = msg.id;
+        // Track user
+        this.users.set(userId, {
+            id: userId,
+            userName,
+            displayName: msg.member?.displayName ?? userName,
+        });
+        // Track channel
+        if (!this.channels.has(conversationId) && "name" in msg.channel) {
+            const ch = msg.channel;
+            this.channels.set(conversationId, { id: conversationId, name: ch.name });
+        }
+        const conversationKind = isDM ? "direct" : "shared";
+        const sessionKey = resolveChatSessionKey({
+            conversationId,
+            conversationKind,
+            messageId: msgId,
+            persistentTopLevel: true,
+            threadTs,
+        });
+        const cleanedText = this.stripMessagingBotMention(msg.content);
+        const eventBase = createConversationEvent({
+            platform: "discord",
+            type: isDM ? "dm" : "mention",
+            conversationId,
+            conversationKind,
+            ts: msgId,
+            thread_ts: threadTs,
+            sessionKey,
+            user: userId,
+            userName,
+            text: cleanedText,
+        });
+        await processMessageIntake({
+            eventBase,
+            addressed,
+            magicWord: { addressed, scopeFallback: "top-level" },
+            busyPolicy: "queue",
+            logEntryBase: {
+                date: msg.createdAt.toISOString(),
                 ts: msgId,
-                thread_ts: threadTs,
-                sessionKey,
+                ...(!isDM && threadTs ? { threadTs } : {}),
                 user: userId,
                 userName,
                 text: cleanedText,
-            };
-            // Handle stop before trigger gate — "stop" should never be auto-reply judged.
-            if (cleanedText.toLowerCase() === "stop" || cleanedText.toLowerCase() === "/stop") {
-                const stopTarget = this.resolveStopTarget(conversationId, sessionKey);
-                if (stopTarget) {
-                    await this.handler.handleStop(stopTarget, conversationId, this);
-                }
-                else if (!isAutoReplyCandidate) {
-                    await this.postMessage(conversationId, formatNothingRunning("discord"));
-                }
-                return;
-            }
-            await processMessageIntake({
-                eventBase,
-                workingDir: this.workingDir,
-                isAutoReplyCandidate,
-                logEntryBase: {
-                    date: msg.createdAt.toISOString(),
-                    ts: msgId,
-                    ...(!isDM && threadTs ? { threadTs } : {}),
-                    user: userId,
-                    userName,
-                    text: cleanedText,
-                    isMessagingBot: false,
-                },
-                log: (entry) => this.logToFile(conversationId, entry),
-                processAttachments: () => this.processAttachments(conversationId, msg.attachments, msgId),
-                queueKey: sessionKey,
-                enqueue: (queueKey, work) => this.getQueue(queueKey).enqueue(work),
-                handler: this.handler,
-                bot: this,
-                createContext: (event) => createDiscordAdapters(event, this),
-            });
+                isMessagingBot: false,
+            },
+            log: (entry) => this.logToFile(conversationId, entry),
+            processAttachments: () => this.processAttachments(conversationId, msg.attachments),
+            queueKey: sessionKey,
+            enqueue: (queueKey, work) => this.getQueue(queueKey).enqueue(work),
+            handler: this.handler,
+            bot: this,
+            createContext: (event) => createDiscordAdapters(event, this),
         });
     }
     async fetchTextChannel(channelId) {