@friendlyrobot/discord-pi-agent 0.14.1 → 0.16.0

package/dist/index.js

@@ -110,7 +110,7 @@ async function formatWithPrettier(text) {
 
 // src/reply-buffer.ts
 var logger3 = createModuleLogger("reply-buffer");
-async function collectReply(session, prompt, options = {}) {
+async function runPromptAndCollectReply(session, prompt, options = {}) {
   let streamedText = "";
   let eventCount = 0;
   let toolCount = 0;
@@ -278,7 +278,7 @@ class AgentService {
   async prompt(text) {
     const session = this.requireSession();
     const transformedPrompt = await this.config.promptTransform(text);
-    return collectReply(session, transformedPrompt, {
+    return runPromptAndCollectReply(session, transformedPrompt, {
       logPrefix: `[agent:${session.sessionId}]`
     });
   }
@@ -531,9 +531,10 @@ function isSameModel(currentModel, desiredModel) {
 import path2 from "node:path";
 import dotenv from "dotenv";
 function resolveConfig(config) {
+  const discordAllowedUserId = readRequiredValue("discordAllowedUserId", config.discordAllowedUserId);
   return {
     discordBotToken: readRequiredValue("discordBotToken", config.discordBotToken),
-    discordAllowedUserId: readRequiredValue("discordAllowedUserId", config.discordAllowedUserId),
+    discordAllowedUserId,
     cwd: readRequiredValue("cwd", config.cwd),
     agentDir: config.agentDir?.trim() || path2.join(config.cwd, ".pi-agent"),
     modelProvider: config.modelProvider?.trim() || "openrouter",
@@ -544,10 +545,13 @@ function resolveConfig(config) {
     promptTransform: config.promptTransform || identityPromptTransform,
     startupMessage: config.startupMessage === undefined ? "Bot is online and ready." : config.startupMessage,
     shutdownOnSignals: config.shutdownOnSignals ?? true,
-    visionModelId: config.visionModelId?.trim() || null
+    visionModelId: config.visionModelId?.trim() || null,
+    discordAllowedForumChannelIds: config.discordAllowedForumChannelIds ?? [],
+    discordAllowedUserIds: config.discordAllowedUserIds ?? [discordAllowedUserId],
+    sessionIdleTimeoutMs: config.sessionIdleTimeoutMs ?? null
   };
 }
-function loadDiscordPiBridgeConfigFromEnv(overrides = {}) {
+function loadDiscordGatewayConfigFromEnv(overrides = {}) {
   dotenv.config();
   return resolveConfig({
     discordBotToken: overrides.discordBotToken || process.env.DISCORD_BOT_TOKEN || "",
@@ -562,19 +566,11 @@ function loadDiscordPiBridgeConfigFromEnv(overrides = {}) {
     promptTransform: overrides.promptTransform,
     startupMessage: overrides.startupMessage ?? readStartupMessageFromEnv(),
     shutdownOnSignals: overrides.shutdownOnSignals,
-    visionModelId: overrides.visionModelId ?? process.env.PI_VISION_MODEL_ID
-  });
-}
-function loadDiscordGatewayConfigFromEnv(overrides = {}) {
-  const base = loadDiscordPiBridgeConfigFromEnv(overrides);
-  return {
-    ...base,
+    visionModelId: overrides.visionModelId ?? process.env.PI_VISION_MODEL_ID,
     discordAllowedForumChannelIds: overrides.discordAllowedForumChannelIds ?? parseStringArrayFromEnv("DISCORD_FORUM_CHANNEL_IDS") ?? [],
-    discordAllowedUserIds: overrides.discordAllowedUserIds ?? parseStringArrayFromEnv("DISCORD_ALLOWED_USER_IDS") ?? [
-      base.discordAllowedUserId
-    ],
-    sessionIdleTimeoutMs: overrides.sessionIdleTimeoutMs ?? parseOptionalIntFromEnv("DISCORD_SESSION_IDLE_TIMEOUT_MS") ?? null
-  };
+    discordAllowedUserIds: overrides.discordAllowedUserIds ?? parseStringArrayFromEnv("DISCORD_ALLOWED_USER_IDS"),
+    sessionIdleTimeoutMs: overrides.sessionIdleTimeoutMs ?? parseOptionalIntFromEnv("DISCORD_SESSION_IDLE_TIMEOUT_MS") ?? undefined
+  });
 }
 function readRequiredValue(name, value) {
   const trimmedValue = value.trim();
@@ -594,17 +590,6 @@ function readStartupMessageFromEnv() {
   }
   return trimmedValue;
 }
-function resolveGatewayConfig(config) {
-  const base = resolveConfig(config);
-  return {
-    ...base,
-    discordAllowedForumChannelIds: config.discordAllowedForumChannelIds ?? [],
-    discordAllowedUserIds: config.discordAllowedUserIds ?? [
-      base.discordAllowedUserId
-    ],
-    sessionIdleTimeoutMs: config.sessionIdleTimeoutMs ?? null
-  };
-}
 function parseThinkingLevel(value) {
   if (!value) {
     return;
@@ -644,7 +629,6 @@ function parseOptionalIntFromEnv(key) {
 
 // src/discord-gateway-client.ts
 import {
-  ChannelType,
   Client,
   Events,
   GatewayIntentBits,
@@ -669,7 +653,7 @@ function getSessionStatusText(session, promptQueue, extras) {
     `queue-busy: ${queueStatus.busy}`
   ];
   if (extras?.tools && extras.tools.length > 0) {
-    const toolNames = extras.tools.map((t) => t.name);
+    const toolNames = extras.tools.map((tool) => tool.name);
     lines.push("", `Tools (${extras.tools.length}): ${toolNames.join(", ")}`);
   }
   if (extras?.skillsSummary) {
@@ -691,260 +675,410 @@ function getThinkingInfo(session) {
     supported: true
   };
 }
-async function handleCommand(input, ctx) {
-  const { agentService, promptQueue, session } = ctx;
-  const trimmed = input.trim();
-  if (!trimmed.startsWith("!")) {
-    return { handled: false };
-  }
-  if (trimmed === "!help") {
-    const extraCommands = session ? `
-!archive - archive this thread and end the session` : "";
+function getEffectiveSession(context) {
+  return context.session ?? context.agentService.getSession();
+}
+function requireEffectiveSession(context) {
+  const session = getEffectiveSession(context);
+  if (!session) {
     return {
       handled: true,
-      response: [
-        "Commands:",
-        "!help - show this message",
-        "!status - show current session status",
-        "!thinking - show or set thinking/reasoning level",
-        "!model - list available models or switch to one",
-        "!compact - compact the persistent session",
-        "!reset-session - start a fresh persistent session",
-        "!reload - reload resources (AGENTS.md, extensions, skills, etc.)",
-        extraCommands,
-        "Any other text goes to the agent session."
-      ].filter(Boolean).join(`
-`)
+      response: "No active session."
     };
   }
-  if (trimmed === "!archive") {
-    if (!session) {
-      return {
-        handled: true,
-        response: "!archive is only available in forum threads."
-      };
-    }
+  return { session };
+}
+async function handleHelpCommand(trimmedInput, context) {
+  if (trimmedInput !== "!help") {
+    return null;
+  }
+  const extraCommands = context.session ? `
+!archive - archive this thread and end the session` : "";
+  return {
+    handled: true,
+    response: [
+      "Commands:",
+      "!help - show this message",
+      "!status - show current session status",
+      "!thinking - show or set thinking/reasoning level",
+      "!model - list available models or switch to one",
+      "!compact - compact the persistent session",
+      "!reset-session - start a fresh persistent session",
+      "!reload - reload resources (AGENTS.md, extensions, skills, etc.)",
+      extraCommands,
+      "Any other text goes to the agent session."
+    ].filter(Boolean).join(`
+`)
+  };
+}
+async function handleArchiveCommand(trimmedInput, context) {
+  if (trimmedInput !== "!archive") {
+    return null;
+  }
+  if (!context.session) {
     return {
       handled: true,
-      archive: true,
-      response: "Archiving thread and shutting down session."
+      response: "!archive is only available in forum threads."
     };
   }
-  if (trimmed === "!status") {
-    const effectiveSession = session ?? agentService.getSession();
-    if (!effectiveSession) {
+  return {
+    handled: true,
+    archive: true,
+    response: "Archiving thread and shutting down session."
+  };
+}
+async function handleStatusCommand(trimmedInput, context) {
+  if (trimmedInput !== "!status") {
+    return null;
+  }
+  const effectiveSession = requireEffectiveSession(context);
+  if ("handled" in effectiveSession) {
+    return effectiveSession;
+  }
+  const tools = effectiveSession.session.getAllTools();
+  const extensionsSummary = context.agentService.getExtensionsSummary();
+  const skillsSummary = context.agentService.getSkillsSummary();
+  return {
+    handled: true,
+    response: getSessionStatusText(effectiveSession.session, context.promptQueue, {
+      tools,
+      extensionsSummary,
+      skillsSummary
+    })
+  };
+}
+async function handleThinkingCommand(trimmedInput, context) {
+  if (trimmedInput !== "!thinking" && !trimmedInput.startsWith("!thinking ")) {
+    return null;
+  }
+  const effectiveSession = requireEffectiveSession(context);
+  if ("handled" in effectiveSession) {
+    return effectiveSession;
+  }
+  const parts = trimmedInput.split(" ");
+  if (parts.length === 1) {
+    const info = getThinkingInfo(effectiveSession.session);
+    if (!info.supported) {
       return {
         handled: true,
-        response: "No active session."
+        response: "Current model does not support reasoning/thinking."
       };
     }
-    const tools = effectiveSession.getAllTools();
-    const extensionsSummary = agentService.getExtensionsSummary();
-    const skillsSummary = agentService.getSkillsSummary();
     return {
       handled: true,
-      response: getSessionStatusText(effectiveSession, promptQueue, {
-        tools,
-        extensionsSummary,
-        skillsSummary
-      })
+      response: [
+        `Current: ${info.current}`,
+        `Available: ${info.available.join(", ")}`,
+        `Usage: !thinking <level>`
+      ].join(`
+`)
     };
   }
-  if (trimmed === "!thinking" || trimmed.startsWith("!thinking ")) {
-    const effectiveSession = session ?? agentService.getSession();
-    if (!effectiveSession) {
-      return {
-        handled: true,
-        response: "No active session."
-      };
-    }
-    const parts = trimmed.split(" ");
-    if (parts.length === 1) {
-      const info = getThinkingInfo(effectiveSession);
-      if (!info.supported) {
-        return {
-          handled: true,
-          response: "Current model does not support reasoning/thinking."
-        };
-      }
-      return {
-        handled: true,
-        response: [
-          `Current: ${info.current}`,
-          `Available: ${info.available.join(", ")}`,
-          `Usage: !thinking <level>`
-        ].join(`
-`)
-      };
-    }
-    const requestedLevel = parts[1];
-    if (!effectiveSession.supportsThinking()) {
-      return {
-        handled: true,
-        response: "Current model does not support reasoning/thinking."
-      };
-    }
-    const available = effectiveSession.getAvailableThinkingLevels();
-    if (!available.includes(requestedLevel)) {
-      return {
-        handled: true,
-        response: `Invalid thinking level "${requestedLevel}" for current model. Available: ${available.join(", ")}`
-      };
-    }
-    effectiveSession.setThinkingLevel(requestedLevel);
+  const requestedLevel = parts[1];
+  if (!effectiveSession.session.supportsThinking()) {
     return {
       handled: true,
-      response: `Thinking level set to "${requestedLevel}".`
+      response: "Current model does not support reasoning/thinking."
     };
   }
-  if (trimmed === "!model" || trimmed.startsWith("!model ")) {
-    const effectiveSession = session ?? agentService.getSession();
-    if (!effectiveSession) {
-      return {
-        handled: true,
-        response: "No active session."
-      };
-    }
-    const parts = trimmed.split(" ");
-    if (parts.length === 1) {
-      const current = agentService.getCurrentModelDisplay(effectiveSession);
-      const modelList = await agentService.listModels(effectiveSession);
-      return {
-        handled: true,
-        response: `Current model: ${current}
-
-${modelList}`
-      };
-    }
-    const arg = parts.slice(1).join(" ");
-    const slashIndex = arg.indexOf("/");
-    if (slashIndex === -1) {
-      return {
-        handled: true,
-        response: `Usage: !model <provider/modelId>
-Example: !model openrouter/anthropic/claude-sonnet-4
-Use !model without args to see available models.`
-      };
-    }
-    const provider = arg.substring(0, slashIndex).trim();
-    const modelId = arg.substring(slashIndex + 1).trim();
+  const available = effectiveSession.session.getAvailableThinkingLevels();
+  if (!available.includes(requestedLevel)) {
     return {
       handled: true,
-      response: await agentService.switchModel(provider, modelId, effectiveSession)
+      response: `Invalid thinking level "${requestedLevel}" for current model. Available: ${available.join(", ")}`
     };
   }
-  if (trimmed === "!compact") {
-    const effectiveSession = session ?? agentService.getSession();
-    if (!effectiveSession) {
-      return {
-        handled: true,
-        response: "No active session."
-      };
-    }
+  effectiveSession.session.setThinkingLevel(requestedLevel);
+  return {
+    handled: true,
+    response: `Thinking level set to "${requestedLevel}".`
+  };
+}
+async function handleModelCommand(trimmedInput, context) {
+  if (trimmedInput !== "!model" && !trimmedInput.startsWith("!model ")) {
+    return null;
+  }
+  const effectiveSession = requireEffectiveSession(context);
+  if ("handled" in effectiveSession) {
+    return effectiveSession;
+  }
+  const parts = trimmedInput.split(" ");
+  if (parts.length === 1) {
+    const current = context.agentService.getCurrentModelDisplay(effectiveSession.session);
+    const modelList = await context.agentService.listModels(effectiveSession.session);
     return {
       handled: true,
-      response: await promptQueue.enqueue(async () => {
-        await effectiveSession.compact();
-        return `Compaction finished for session ${effectiveSession.sessionId}.`;
-      })
+      response: `Current model: ${current}
+
+${modelList}`
     };
   }
-  if (trimmed === "!reload") {
+  const argument = parts.slice(1).join(" ");
+  const slashIndex = argument.indexOf("/");
+  if (slashIndex === -1) {
     return {
       handled: true,
-      response: await promptQueue.enqueue(async () => {
-        return agentService.reloadResources();
-      })
+      response: `Usage: !model <provider/modelId>
+` + `Example: !model openrouter/anthropic/claude-sonnet-4
+` + "Use !model without args to see available models."
     };
   }
-  if (trimmed === "!reset-session") {
-    if (session) {
-      return {
-        handled: true,
-        response: await promptQueue.enqueue(async () => {
-          const previousSession = session;
-          await previousSession.abort();
-          previousSession.dispose();
-          return `Session reset. Old session kept at ${previousSession.sessionFile ?? "(unknown path)"}. Use !archive to archive the thread and start fresh.`;
-        })
-      };
-    }
+  const provider = argument.substring(0, slashIndex).trim();
+  const modelId = argument.substring(slashIndex + 1).trim();
+  return {
+    handled: true,
+    response: await context.agentService.switchModel(provider, modelId, effectiveSession.session)
+  };
+}
+async function handleCompactCommand(trimmedInput, context) {
+  if (trimmedInput !== "!compact") {
+    return null;
+  }
+  const effectiveSession = requireEffectiveSession(context);
+  if ("handled" in effectiveSession) {
+    return effectiveSession;
+  }
+  return {
+    handled: true,
+    response: await context.promptQueue.enqueue(async () => {
+      await effectiveSession.session.compact();
+      return `Compaction finished for session ${effectiveSession.session.sessionId}.`;
+    })
+  };
+}
+async function handleReloadCommand(trimmedInput, context) {
+  if (trimmedInput !== "!reload") {
+    return null;
+  }
+  return {
+    handled: true,
+    response: await context.promptQueue.enqueue(async () => {
+      return context.agentService.reloadResources();
+    })
+  };
+}
+async function handleResetSessionCommand(trimmedInput, context) {
+  if (trimmedInput !== "!reset-session") {
+    return null;
+  }
+  if (context.session) {
     return {
       handled: true,
-      response: await promptQueue.enqueue(async () => {
-        return agentService.resetSession();
+      response: await context.promptQueue.enqueue(async () => {
+        const previousSession = context.session;
+        await previousSession.abort();
+        previousSession.dispose();
+        return `Session reset. Old session kept at ${previousSession.sessionFile ?? "(unknown path)"}. Use !archive to archive the thread and start fresh.`;
       })
     };
   }
   return {
     handled: true,
-    response: `Unknown command: ${trimmed}. Try !help.`
+    response: await context.promptQueue.enqueue(async () => {
+      return context.agentService.resetSession();
+    })
   };
 }
-
-// src/image-description.ts
-var logger5 = createModuleLogger("image-description");
-async function describeImage(agentService, imageData, mimeType, userText, visionModel) {
-  const session = await agentService.createTemporarySession();
-  await session.setModel(visionModel);
-  const mediaType = getMediaType(mimeType);
-  const imageContent = {
-    type: "image",
-    data: imageData,
-    mimeType
-  };
-  let promptText;
-  if (mediaType === "document") {
-    promptText = userText.trim().length > 0 ? `The user sent a document with the following message: "${userText}". Please extract and summarize the text content of this document. Be thorough — include all important details, sections, and data from the document.` : "Please extract and summarize the text content of this document. Be thorough — include all important details, sections, data, and key points.";
-  } else {
-    promptText = userText.trim().length > 0 ? `The user sent this image with the following message: "${userText}". Please describe the image in detail and address any questions from the user's message.` : "Please describe this image in detail. What do you see?";
+var commandHandlers = [
+  handleHelpCommand,
+  handleArchiveCommand,
+  handleStatusCommand,
+  handleThinkingCommand,
+  handleModelCommand,
+  handleCompactCommand,
+  handleReloadCommand,
+  handleResetSessionCommand
+];
+async function executeCommand(input, context) {
+  const trimmedInput = input.trim();
+  if (!trimmedInput.startsWith("!")) {
+    return { handled: false };
   }
-  let text = "";
-  try {
-    await session.prompt(promptText, { images: [imageContent] });
-    text = extractLastAssistantText(session);
-  } catch (error) {
-    logger5.error({ error, mimeType }, "vision model prompt failed");
-    text = "(Vision model failed to process the file.)";
-  } finally {
-    session.dispose();
+  for (const handler of commandHandlers) {
+    const result = await handler(trimmedInput, context);
+    if (result) {
+      return result;
+    }
   }
-  if (!text) {
-    return "(Vision model returned no description.)";
+  return {
+    handled: true,
+    response: `Unknown command: ${trimmedInput}. Try !help.`
+  };
+}
+
+// src/discord-attachments.ts
+var logger5 = createModuleLogger("discord-attachments");
+var TEXT_ATTACHMENT_EXTENSIONS = [
+  ".txt",
+  ".md",
+  ".json",
+  ".csv",
+  ".log",
+  ".yml",
+  ".yaml",
+  ".xml",
+  ".toml",
+  ".ini",
+  ".cfg"
+];
+var MAX_TEXT_ATTACHMENT_SIZE_BYTES = 25 * 1024 * 1024;
+var MEDIA_ATTACHMENT_EXTENSIONS = [
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".pdf",
+  ".docx",
+  ".doc",
+  ".pptx",
+  ".ppt",
+  ".xlsx",
+  ".xls"
+];
+var MAX_MEDIA_ATTACHMENT_SIZE_BYTES = 25 * 1024 * 1024;
+var OFFICE_MIME_TYPES = new Set([
+  "application/pdf",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/msword",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "application/vnd.ms-powerpoint",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.ms-excel"
+]);
+function isSupportedTextAttachment(attachment) {
+  const ext = attachment.name?.slice(attachment.name.lastIndexOf(".")).toLowerCase();
+  return Boolean(ext && TEXT_ATTACHMENT_EXTENSIONS.includes(ext));
+}
+function isSupportedMediaAttachment(attachment) {
+  const ext = attachment.name?.slice(attachment.name.lastIndexOf(".")).toLowerCase();
+  if (!ext || !MEDIA_ATTACHMENT_EXTENSIONS.includes(ext)) {
+    return false;
   }
-  logger5.debug({ textLength: text.length, mimeType }, "media described");
-  return text;
+  const contentType = attachment.contentType;
+  if (!contentType) {
+    return false;
+  }
+  return contentType.startsWith("image/") || OFFICE_MIME_TYPES.has(contentType);
 }
-function extractLastAssistantText(session) {
-  const messages = session.messages;
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (!msg || !isAssistantMessage(msg)) {
+async function readTextAttachments(message) {
+  const attachments = message.attachments;
+  if (attachments.size === 0) {
+    return [];
+  }
+  const results = [];
+  for (const [, attachment] of attachments) {
+    if (!isSupportedTextAttachment(attachment)) {
+      logger5.debug({ messageId: message.id, filename: attachment.name }, "skipping non-text attachment");
       continue;
     }
-    const content = msg.content;
-    if (!Array.isArray(content)) {
+    if (attachment.size > MAX_TEXT_ATTACHMENT_SIZE_BYTES) {
+      logger5.warn({
+        messageId: message.id,
+        filename: attachment.name,
+        size: attachment.size
+      }, "attachment too large, skipping");
       continue;
     }
-    const textBlocks = [];
-    for (const item of content) {
-      if (typeof item === "object" && item !== null && "type" in item && item.type === "text") {
-        textBlocks.push(item.text);
+    try {
+      logger5.info({
+        messageId: message.id,
+        filename: attachment.name,
+        size: attachment.size
+      }, "fetching attachment");
+      const response = await fetch(attachment.url);
+      if (!response.ok) {
+        logger5.warn({
+          messageId: message.id,
+          filename: attachment.name,
+          status: response.status
+        }, "failed to fetch attachment");
+        continue;
       }
+      const content = await response.text();
+      results.push({ filename: attachment.name, content });
+    } catch (error) {
+      logger5.error({ messageId: message.id, filename: attachment.name, error }, "error fetching attachment");
     }
-    return textBlocks.join(`
-`).trim();
   }
-  return "";
+  return results;
 }
-function getMediaType(mimeType) {
-  if (mimeType.startsWith("image/")) {
-    return "image";
+async function readMediaAttachments(message) {
+  const attachments = message.attachments;
+  if (attachments.size === 0) {
+    return [];
   }
-  return "document";
-}
-function isAssistantMessage(msg) {
-  return typeof msg === "object" && msg !== null && "role" in msg && msg.role === "assistant";
+  const results = [];
+  for (const [, attachment] of attachments) {
+    if (!isSupportedMediaAttachment(attachment)) {
+      continue;
+    }
+    if (attachment.size > MAX_MEDIA_ATTACHMENT_SIZE_BYTES) {
+      logger5.warn({
+        messageId: message.id,
+        filename: attachment.name,
+        size: attachment.size
+      }, "media attachment too large, skipping");
+      continue;
+    }
+    try {
+      logger5.info({
+        messageId: message.id,
+        filename: attachment.name,
+        size: attachment.size
+      }, "fetching media attachment");
+      const response = await fetch(attachment.url);
+      if (!response.ok) {
+        logger5.warn({
+          messageId: message.id,
+          filename: attachment.name,
+          status: response.status
+        }, "failed to fetch media attachment");
+        continue;
+      }
+      const buffer = await response.arrayBuffer();
+      results.push({
+        filename: attachment.name,
+        data: Buffer.from(buffer).toString("base64"),
+        mimeType: attachment.contentType ?? "application/octet-stream"
+      });
+    } catch (error) {
+      logger5.error({ messageId: message.id, filename: attachment.name, error }, "error fetching media attachment");
+    }
+  }
+  return results;
+}
+
+// src/discord-auth.ts
+import { ChannelType } from "discord.js";
+function getAuthorDisplayName(message) {
+  return message.member?.displayName || message.author.globalName || message.author.username;
+}
+function resolveMessageScope(message) {
+  if (message.channel.type === ChannelType.DM) {
+    return "dm";
+  }
+  if (message.channel.isThread()) {
+    return `thread:${message.channel.id}`;
+  }
+  return null;
+}
+function isAuthorizedMessage(message, scope, authConfig) {
+  if (scope === "dm") {
+    return message.author.id === authConfig.discordAllowedUserId;
+  }
+  if (scope.startsWith("thread:")) {
+    const channel = message.channel;
+    if (!channel.isThread()) {
+      return false;
+    }
+    const parentId = channel.parentId;
+    if (!parentId || !authConfig.discordAllowedForumChannelIds.includes(parentId)) {
+      return false;
+    }
+    return authConfig.discordAllowedUserIds.includes(message.author.id);
+  }
+  return false;
 }
 
 // src/message-chunker.ts
@@ -978,102 +1112,8 @@ function chunkMessage(text, maxChunkSize = SAFE_MESSAGE_LIMIT) {
   return chunks.map((chunk) => chunk.slice(0, DISCORD_MESSAGE_LIMIT));
 }
 
-// src/prompt-context.ts
-function buildDiscordMessageContextPrompt(userMessage, options) {
-  const contextEntries = [
-    ["scope", options.scope],
-    ["sent_at", options.sentAt],
-    ["sent_at_local", options.sentAtLocal],
-    ["message_id", options.messageId],
-    ["author_name", normalizeContextValue(options.authorName)],
-    ["author_id", options.authorId],
-    ["thread_title", normalizeContextValue(options.threadTitle)],
-    ["thread_id", options.threadId],
-    ["forum_channel_id", options.forumChannelId ?? undefined]
-  ].filter((entry) => {
-    return typeof entry[1] === "string" && entry[1].trim().length > 0;
-  });
-  const contextJson = JSON.stringify(Object.fromEntries(contextEntries), null, 2);
-  return [
-    "<discord_message_context>",
-    contextJson,
-    "</discord_message_context>",
-    "",
-    "User message:",
-    userMessage.trim()
-  ].join(`
-`);
-}
-function formatDiscordPromptTime(date, options = {}) {
-  const timeZone = options.timeZone || "UTC";
-  const locale = options.locale || "en-AU";
-  return new Intl.DateTimeFormat(locale, {
-    timeZone,
-    weekday: "short",
-    day: "numeric",
-    month: "short",
-    year: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
-    timeZoneName: "short"
-  }).format(date);
-}
-function normalizeContextValue(value) {
-  if (value === undefined) {
-    return;
-  }
-  return value.replace(/\s+/g, " ").trim();
-}
-
-// src/discord-gateway-client.ts
-var logger6 = createModuleLogger("discord-gateway");
-function getAuthorDisplayName(message) {
-  return message.member?.displayName || message.author.globalName || message.author.username;
-}
-function buildDiscordPromptContent(message, scope, content, config) {
-  const isThread = scope.startsWith("thread:") && message.channel.isThread();
-  return buildDiscordMessageContextPrompt(content, {
-    scope: scope === "dm" ? "dm" : "thread",
-    sentAt: message.createdAt.toISOString(),
-    sentAtLocal: formatDiscordPromptTime(message.createdAt, {
-      timeZone: config.promptTimeZone,
-      locale: config.promptLocale
-    }),
-    messageId: message.id,
-    authorId: message.author.id,
-    authorName: getAuthorDisplayName(message),
-    threadId: isThread ? message.channel.id : undefined,
-    threadTitle: isThread ? message.channel.name : undefined,
-    forumChannelId: isThread ? message.channel.parentId : undefined
-  });
-}
-function resolveScope(message) {
-  if (message.channel.type === ChannelType.DM) {
-    return "dm";
-  }
-  if (message.channel.isThread()) {
-    return `thread:${message.channel.id}`;
-  }
-  return null;
-}
-function isAuthorized(message, scope, authConfig) {
-  if (scope === "dm") {
-    return message.author.id === authConfig.discordAllowedUserId;
-  }
-  if (scope.startsWith("thread:")) {
-    const channel = message.channel;
-    if (!channel.isThread()) {
-      return false;
-    }
-    const parentId = channel.parentId;
-    if (!parentId || !authConfig.discordAllowedForumChannelIds.includes(parentId)) {
-      return false;
-    }
-    return authConfig.discordAllowedUserIds.includes(message.author.id);
-  }
-  return false;
-}
+// src/discord-replies.ts
+var logger6 = createModuleLogger("discord-replies");
 var WORKING_EMOJI = "⚙️";
 async function addWorkingReaction(message) {
   try {
@@ -1092,72 +1132,6 @@ async function removeWorkingReaction(message) {
     logger6.debug({ messageId: message.id, error }, "failed to remove working reaction");
   }
 }
-var TYPING_INTERVAL_MS = 9000;
-var typingIntervals = new Map;
-async function sendTypingSafe(channel, channelKey) {
-  try {
-    const token = channel.client.token;
-    const url = `https://discord.com/api/v10/channels/${channel.id}/typing`;
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { Authorization: `Bot ${token}` }
-    });
-    if (res.ok) {
-      logger6.debug(`[TYPING] STATUS UPDATED OK`);
-      return;
-    }
-    if (res.status === 429) {
-      const body = await res.text();
-      let retryMs = 3000;
-      try {
-        const parsed = JSON.parse(body);
-        if (typeof parsed.retry_after === "number") {
-          retryMs = parsed.retry_after * 1000 + 500;
-        }
-      } catch {}
-      logger6.warn({ channelKey, retryMs, response: body }, `[TYPING] 429, retrying after ${retryMs}ms delay`);
-      await new Promise((resolve) => setTimeout(resolve, retryMs));
-      await fetch(url, {
-        method: "POST",
-        headers: { Authorization: `Bot ${token}` }
-      });
-      logger6.info({ channelKey }, "[TYPING] retry done");
-      return;
-    }
-    logger6.warn({ channelKey, status: res.status }, "[TYPING] unexpected status");
-  } catch (error) {
-    logger6.warn({ channelKey, error }, "[TYPING] FAILED");
-  }
-}
-function startTypingForChannel(channel, channelKey) {
-  const existing = typingIntervals.get(channelKey);
-  if (existing) {
-    existing.refs += 1;
-    logger6.debug({ channelKey, refs: existing.refs }, "[TYPING] ref++ (reusing existing interval)");
-    return;
-  }
-  logger6.debug("[TYPING] started new interval");
-  sendTypingSafe(channel, channelKey);
-  const interval = setInterval(() => {
-    sendTypingSafe(channel, channelKey);
-  }, TYPING_INTERVAL_MS);
-  typingIntervals.set(channelKey, { interval, refs: 1 });
-}
-function stopTypingForChannel(channelKey) {
-  const entry = typingIntervals.get(channelKey);
-  if (!entry) {
-    logger6.debug({ channelKey }, "[TYPING] stop called but no entry found");
-    return;
-  }
-  entry.refs -= 1;
-  if (entry.refs <= 0) {
-    clearInterval(entry.interval);
-    typingIntervals.delete(channelKey);
-    logger6.debug("[TYPING] interval cleared (refs hit 0)");
-  } else {
-    logger6.debug("[TYPING] ref-- (interval still active)");
-  }
-}
 async function sendReply(message, text) {
   const channel = message.channel;
   if (!channel.isSendable()) {
@@ -1183,146 +1157,76 @@ async function sendReply(message, text) {
     }, "send reply failed");
   }
 }
-var TEXT_ATTACHMENT_EXTENSIONS = [
-  ".txt",
-  ".md",
-  ".json",
-  ".csv",
-  ".log",
-  ".yml",
-  ".yaml",
-  ".xml",
-  ".toml",
-  ".ini",
-  ".cfg"
-];
-var MAX_ATTACHMENT_SIZE_BYTES = 25 * 1024 * 1024;
-async function readTextAttachments(message) {
-  const attachments = message.attachments;
-  if (attachments.size === 0) {
-    return [];
-  }
-  const results = [];
-  for (const [, attachment] of attachments) {
-    const ext = attachment.name?.slice(attachment.name.lastIndexOf(".")).toLowerCase();
-    if (!ext || !TEXT_ATTACHMENT_EXTENSIONS.includes(ext)) {
-      logger6.debug({ messageId: message.id, filename: attachment.name, ext }, "skipping non-text attachment");
-      continue;
-    }
-    if (attachment.size > MAX_ATTACHMENT_SIZE_BYTES) {
-      logger6.warn({
-        messageId: message.id,
-        filename: attachment.name,
-        size: attachment.size
-      }, "attachment too large, skipping");
-      continue;
-    }
-    try {
-      logger6.info({
-        messageId: message.id,
-        filename: attachment.name,
-        size: attachment.size
-      }, "fetching attachment");
-      const response = await fetch(attachment.url);
-      if (!response.ok) {
-        logger6.warn({
-          messageId: message.id,
-          filename: attachment.name,
-          status: response.status
-        }, "failed to fetch attachment");
-        continue;
-      }
-      const content = await response.text();
-      results.push({ filename: attachment.name, content });
-    } catch (error) {
-      logger6.error({ messageId: message.id, filename: attachment.name, error }, "error fetching attachment");
-    }
-  }
-  return results;
-}
-var MEDIA_ATTACHMENT_EXTENSIONS = [
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".webp",
-  ".pdf",
-  ".docx",
-  ".doc",
-  ".pptx",
-  ".ppt",
-  ".xlsx",
-  ".xls"
-];
-var MAX_MEDIA_ATTACHMENT_SIZE = 25 * 1024 * 1024;
-var OFFICE_MIME_TYPES = new Set([
-  "application/pdf",
-  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  "application/msword",
-  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-  "application/vnd.ms-powerpoint",
-  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  "application/vnd.ms-excel"
-]);
-function isMediaAttachment(attachment) {
-  const ext = attachment.name?.slice(attachment.name.lastIndexOf(".")).toLowerCase();
-  if (!ext || !MEDIA_ATTACHMENT_EXTENSIONS.includes(ext)) {
-    return false;
-  }
-  const ct = attachment.contentType;
-  if (!ct) {
-    return false;
+
+// src/image-description.ts
+var logger7 = createModuleLogger("image-description");
+async function describeMediaAttachment(agentService, imageData, mimeType, userText, visionModel) {
+  const session = await agentService.createTemporarySession();
+  await session.setModel(visionModel);
+  const mediaType = getMediaType(mimeType);
+  const imageContent = {
+    type: "image",
+    data: imageData,
+    mimeType
+  };
+  let promptText;
+  if (mediaType === "document") {
+    promptText = userText.trim().length > 0 ? `The user sent a document with the following message: "${userText}". Please extract and summarize the text content of this document. Be thorough — include all important details, sections, and data from the document.` : "Please extract and summarize the text content of this document. Be thorough — include all important details, sections, data, and key points.";
+  } else {
+    promptText = userText.trim().length > 0 ? `The user sent this image with the following message: "${userText}". Please describe the image in detail and address any questions from the user's message.` : "Please describe this image in detail. What do you see?";
   }
-  return ct.startsWith("image/") || OFFICE_MIME_TYPES.has(ct);
-}
-async function readMediaAttachments(message) {
-  const attachments = message.attachments;
-  if (attachments.size === 0) {
-    return [];
+  let text = "";
+  try {
+    await session.prompt(promptText, { images: [imageContent] });
+    text = extractLastAssistantText(session);
+  } catch (error) {
+    logger7.error({ error, mimeType }, "vision model prompt failed");
+    text = "(Vision model failed to process the file.)";
+  } finally {
+    session.dispose();
   }
-  const results = [];
-  for (const [, attachment] of attachments) {
-    if (!isMediaAttachment(attachment)) {
+  if (!text) {
+    return "(Vision model returned no description.)";
+  }
+  logger7.debug({ textLength: text.length, mimeType }, "media described");
+  return text;
+}
+function extractLastAssistantText(session) {
+  const messages = session.messages;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg || !isAssistantMessage(msg)) {
       continue;
     }
-    if (attachment.size > MAX_MEDIA_ATTACHMENT_SIZE) {
-      logger6.warn({
-        messageId: message.id,
-        filename: attachment.name,
-        size: attachment.size
-      }, "media attachment too large, skipping");
+    const content = msg.content;
+    if (!Array.isArray(content)) {
       continue;
     }
-    try {
-      logger6.info({
-        messageId: message.id,
-        filename: attachment.name,
-        size: attachment.size
-      }, "fetching media attachment");
-      const response = await fetch(attachment.url);
-      if (!response.ok) {
-        logger6.warn({
-          messageId: message.id,
-          filename: attachment.name,
-          status: response.status
-        }, "failed to fetch media attachment");
-        continue;
+    const textBlocks = [];
+    for (const item of content) {
+      if (typeof item === "object" && item !== null && "type" in item && item.type === "text") {
+        textBlocks.push(item.text);
       }
-      const buffer = await response.arrayBuffer();
-      const base64 = Buffer.from(buffer).toString("base64");
-      results.push({
-        filename: attachment.name,
-        data: base64,
-        mimeType: attachment.contentType ?? "application/octet-stream"
-      });
-    } catch (error) {
-      logger6.error({ messageId: message.id, filename: attachment.name, error }, "error fetching media attachment");
     }
+    return textBlocks.join(`
+`).trim();
   }
-  return results;
+  return "";
+}
+function getMediaType(mimeType) {
+  if (mimeType.startsWith("image/")) {
+    return "image";
+  }
+  return "document";
+}
+function isAssistantMessage(msg) {
+  return typeof msg === "object" && msg !== null && "role" in msg && msg.role === "assistant";
 }
-function parseVisionModelId(visionModelId) {
-  const trimmed = visionModelId.trim();
+
+// src/discord-media-resolution.ts
+var logger8 = createModuleLogger("discord-media-resolution");
+function parseProviderModelId(value) {
+  const trimmed = value.trim();
   if (!trimmed) {
     return null;
   }
@@ -1335,7 +1239,7 @@ function parseVisionModelId(visionModelId) {
     modelId: trimmed.substring(slashIndex + 1)
   };
 }
-function getMediaLabel(filename, mimeType) {
+function getMediaAttachmentLabel(filename, mimeType) {
   if (mimeType === "application/pdf") {
     return `[PDF: ${filename}]`;
   }
@@ -1350,131 +1254,234 @@ function getMediaLabel(filename, mimeType) {
   }
   return `[Image: ${filename}]`;
 }
-async function resolveMediaAttachments(media, content, currentModel, config, agentService) {
+async function resolveMediaAttachmentsForPrompt(mediaAttachments, content, currentModel, config, agentService) {
   const modelSupportsVision = currentModel?.input.includes("image") ?? false;
   if (modelSupportsVision) {
-    const names = media.map((m) => m.filename).join(", ");
-    logger6.info({
-      count: media.length,
+    const names = mediaAttachments.map((media) => media.filename).join(", ");
+    logger8.info({
+      count: mediaAttachments.length,
       filenames: names,
       model: currentModel ? `${currentModel.provider}/${currentModel.id}` : "none"
     }, "passing media natively to vision-capable model");
-    const images = media.map((m) => ({
-      type: "image",
-      data: m.data,
-      mimeType: m.mimeType
-    }));
-    return { content, images };
+    return {
+      content,
+      images: mediaAttachments.map((media) => ({
+        type: "image",
+        data: media.data,
+        mimeType: media.mimeType
+      }))
+    };
   }
   if (!config.visionModelId) {
-    const names = media.map((m) => m.filename).join(", ");
-    logger6.info({ filenames: names }, "media attachments received but vision model not configured");
+    const names = mediaAttachments.map((media) => media.filename).join(", ");
+    logger8.info({ filenames: names }, "media attachments received but vision model not configured");
     const note = `
 
 [User sent media attachment(s): ${names}]
 ` + "(Media vision not configured. Set visionModelId to enable image/PDF/document understanding.)";
-    return { content: content ? content + note : note, images: [] };
+    return {
+      content: content ? content + note : note,
+      images: []
+    };
   }
-  const parsed = parseVisionModelId(config.visionModelId);
-  if (!parsed) {
+  const parsedVisionModelId = parseProviderModelId(config.visionModelId);
+  if (!parsedVisionModelId) {
     return { content, images: [] };
   }
-  const visionModel = agentService.findModel(parsed.provider, parsed.modelId);
+  const visionModel = agentService.findModel(parsedVisionModelId.provider, parsedVisionModelId.modelId);
   if (!visionModel) {
-    logger6.warn({ visionModelId: config.visionModelId }, "vision model not found in registry");
-    const names = media.map((m) => m.filename).join(", ");
+    logger8.warn({ visionModelId: config.visionModelId }, "vision model not found in registry");
+    const names = mediaAttachments.map((media) => media.filename).join(", ");
     const note = `
 
 [User sent media attachment(s): ${names}]
-(Vision model not found: ${config.visionModelId})`;
-    return { content: content ? content + note : note, images: [] };
+` + `(Vision model not found: ${config.visionModelId})`;
+    return {
+      content: content ? content + note : note,
+      images: []
+    };
   }
-  logger6.info({
-    count: media.length,
+  logger8.info({
+    count: mediaAttachments.length,
     visionModel: `${visionModel.provider}/${visionModel.id}`
   }, "describing media with vision model");
   const descriptions = [];
-  for (const m of media) {
-    const description = await describeImage(agentService, m.data, m.mimeType, content, visionModel);
-    const label = getMediaLabel(m.filename, m.mimeType);
+  for (const media of mediaAttachments) {
+    const description = await describeMediaAttachment(agentService, media.data, media.mimeType, content, visionModel);
+    const label = getMediaAttachmentLabel(media.filename, media.mimeType);
     descriptions.push(`${label}
 ${description}`);
   }
-  if (descriptions.length > 0) {
-    const prefix = descriptions.join(`
+  if (descriptions.length === 0) {
+    return { content, images: [] };
+  }
+  const descriptionPrefix = descriptions.join(`
 
 `);
-    return {
-      content: content ? `${prefix}
+  return {
+    content: content ? `${descriptionPrefix}
 
 ---
-${content}` : prefix,
-      images: []
-    };
-  }
-  return { content, images: [] };
+${content}` : descriptionPrefix,
+    images: []
+  };
 }
-async function startGatewayClient(config, agentService, sessionRegistry, authConfig) {
-  const client = new Client({
-    intents: [
-      GatewayIntentBits.DirectMessages,
-      GatewayIntentBits.Guilds,
-      GatewayIntentBits.GuildMessages,
-      GatewayIntentBits.MessageContent
-    ],
-    partials: [Partials.Channel]
-  });
-  client.once(Events.ClientReady, async (readyClient) => {
-    logger6.info({ userTag: readyClient.user.tag }, "logged in");
-    if (!authConfig.startupMessage) {
+
+// src/discord-typing.ts
+var logger9 = createModuleLogger("discord-typing");
+var TYPING_INTERVAL_MS = 9000;
+var typingIntervals = new Map;
+async function sendTypingSafe(channel, channelKey) {
+  try {
+    const token = channel.client.token;
+    const url = `https://discord.com/api/v10/channels/${channel.id}/typing`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { Authorization: `Bot ${token}` }
+    });
+    if (response.ok) {
+      logger9.debug("[TYPING] STATUS UPDATED OK");
       return;
     }
-    try {
-      const user = await readyClient.users.fetch(authConfig.discordAllowedUserId);
-      const dmChannel = await user.createDM();
-      await dmChannel.send(authConfig.startupMessage);
-      logger6.info({
-        userId: authConfig.discordAllowedUserId
-      }, "sent startup dm");
-    } catch (error) {
-      logger6.error({ error }, "failed to send startup dm");
-    }
-  });
-  client.on(Events.MessageCreate, async (message) => {
-    try {
-      await onMessage(message, config, agentService, sessionRegistry, authConfig);
-    } catch (error) {
-      logger6.error({ error, direction: "IN" }, "message handling failed");
-      await sendReply(message, "The bot hit an error while handling that message.");
+    if (response.status === 429) {
+      const body = await response.text();
+      let retryMs = 3000;
+      try {
+        const parsed = JSON.parse(body);
+        if (typeof parsed.retry_after === "number") {
+          retryMs = parsed.retry_after * 1000 + 500;
+        }
+      } catch {}
+      logger9.warn({ channelKey, retryMs, response: body }, `[TYPING] 429, retrying after ${retryMs}ms delay`);
+      await new Promise((resolve) => setTimeout(resolve, retryMs));
+      await fetch(url, {
+        method: "POST",
+        headers: { Authorization: `Bot ${token}` }
+      });
+      logger9.info({ channelKey }, "[TYPING] retry done");
+      return;
     }
+    logger9.warn({ channelKey, status: response.status }, "[TYPING] unexpected status");
+  } catch (error) {
+    logger9.warn({ channelKey, error }, "[TYPING] FAILED");
+  }
+}
+function startTypingForChannel(channel, channelKey) {
+  const existing = typingIntervals.get(channelKey);
+  if (existing) {
+    existing.refs += 1;
+    logger9.debug({ channelKey, refs: existing.refs }, "[TYPING] ref++ (reusing existing interval)");
+    return;
+  }
+  logger9.debug("[TYPING] started new interval");
+  sendTypingSafe(channel, channelKey);
+  const interval = setInterval(() => {
+    sendTypingSafe(channel, channelKey);
+  }, TYPING_INTERVAL_MS);
+  typingIntervals.set(channelKey, { interval, refs: 1 });
+}
+function stopTypingForChannel(channelKey) {
+  const entry = typingIntervals.get(channelKey);
+  if (!entry) {
+    logger9.debug({ channelKey }, "[TYPING] stop called but no entry found");
+    return;
+  }
+  entry.refs -= 1;
+  if (entry.refs <= 0) {
+    clearInterval(entry.interval);
+    typingIntervals.delete(channelKey);
+    logger9.debug("[TYPING] interval cleared (refs hit 0)");
+    return;
+  }
+  logger9.debug("[TYPING] ref-- (interval still active)");
+}
+
+// src/prompt-context.ts
+function buildDiscordMessageContextPrompt(userMessage, options) {
+  const contextEntries = [
+    ["scope", options.scope],
+    ["sent_at", options.sentAt],
+    ["sent_at_local", options.sentAtLocal],
+    ["message_id", options.messageId],
+    ["author_name", normalizeContextValue(options.authorName)],
+    ["author_id", options.authorId],
+    ["thread_title", normalizeContextValue(options.threadTitle)],
+    ["thread_id", options.threadId],
+    ["forum_channel_id", options.forumChannelId ?? undefined]
+  ].filter((entry) => {
+    return typeof entry[1] === "string" && entry[1].trim().length > 0;
   });
-  client.on(Events.ThreadDelete, async (thread) => {
-    const scope = `thread:${thread.id}`;
-    logger6.info({ threadId: thread.id, scope }, "thread deleted");
-    await sessionRegistry.remove(scope);
+  const contextJson = JSON.stringify(Object.fromEntries(contextEntries), null, 2);
+  return [
+    "<discord_message_context>",
+    contextJson,
+    "</discord_message_context>",
+    "",
+    "User message:",
+    userMessage.trim()
+  ].join(`
+`);
+}
+function formatDiscordPromptTime(date, options = {}) {
+  const timeZone = options.timeZone || "UTC";
+  const locale = options.locale || "en-AU";
+  return new Intl.DateTimeFormat(locale, {
+    timeZone,
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    year: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+    timeZoneName: "short"
+  }).format(date);
+}
+function normalizeContextValue(value) {
+  if (value === undefined) {
+    return;
+  }
+  return value.replace(/\s+/g, " ").trim();
+}
+
+// src/discord-message-handler.ts
+var logger10 = createModuleLogger("discord-message-handler");
+function buildDiscordPromptContent(message, scope, content, config) {
+  const isThread = scope.startsWith("thread:") && message.channel.isThread();
+  return buildDiscordMessageContextPrompt(content, {
+    scope: scope === "dm" ? "dm" : "thread",
+    sentAt: message.createdAt.toISOString(),
+    sentAtLocal: formatDiscordPromptTime(message.createdAt, {
+      timeZone: config.promptTimeZone,
+      locale: config.promptLocale
+    }),
+    messageId: message.id,
+    authorId: message.author.id,
+    authorName: getAuthorDisplayName(message),
+    threadId: isThread ? message.channel.id : undefined,
+    threadTitle: isThread ? message.channel.name : undefined,
+    forumChannelId: isThread ? message.channel.parentId : undefined
   });
-  await client.login(config.discordBotToken);
-  return client;
 }
-async function onMessage(message, config, agentService, sessionRegistry, authConfig) {
+async function handleDiscordMessage(message, config, agentService, sessionRegistry, authConfig) {
   if (message.author.bot) {
-    logger6.debug("ignored bot message");
+    logger10.debug("ignored bot message");
     return;
   }
   if (message.system) {
-    logger6.debug({ messageId: message.id }, "ignored system message");
+    logger10.debug({ messageId: message.id }, "ignored system message");
     return;
   }
-  const scope = resolveScope(message);
+  const scope = resolveMessageScope(message);
   if (scope === null) {
-    logger6.debug({
+    logger10.debug({
       messageId: message.id,
       channelType: message.channel.type
     }, "unsupported channel type, ignoring");
     return;
   }
-  if (!isAuthorized(message, scope, authConfig)) {
-    logger6.debug({
+  if (!isAuthorizedMessage(message, scope, authConfig)) {
+    logger10.debug({
       messageId: message.id,
       authorId: message.author.id,
       scope
@@ -1482,20 +1489,22 @@ async function onMessage(message, config, agentService, sessionRegistry, authCon
     return;
   }
   let content = message.content.trim();
-  const attachmentContents = await readTextAttachments(message);
-  if (attachmentContents.length > 0) {
-    const suffix = attachmentContents.map((a) => `
+  const textAttachments = await readTextAttachments(message);
+  if (textAttachments.length > 0) {
+    const attachmentSuffix = textAttachments.map((attachment) => {
+      return `
 
---- Attachment: ${a.filename} ---
-${a.content}`).join("");
-    content = content ? content + suffix : attachmentContents[0].content;
+--- Attachment: ${attachment.filename} ---
+${attachment.content}`;
+    }).join("");
+    content = content ? content + attachmentSuffix : textAttachments[0].content;
   }
   const mediaAttachments = await readMediaAttachments(message);
   if (!content && mediaAttachments.length === 0) {
-    logger6.debug({ messageId: message.id }, "ignored empty message (no text or images)");
+    logger10.debug({ messageId: message.id }, "ignored empty message (no text or images)");
     return;
   }
-  logger6.info({
+  logger10.info({
     direction: "IN",
     scope,
     messageId: message.id,
@@ -1504,19 +1513,18 @@ ${a.content}`).join("");
     content
   }, "message received");
   const channelKey = message.channel.id;
-  const canSend = message.channel.isSendable();
-  if (canSend) {
+  if (message.channel.isSendable()) {
     startTypingForChannel(message.channel, channelKey);
   }
   const { entry, created } = await sessionRegistry.getOrCreate(scope);
   const { session, promptQueue } = entry;
   if (created && scope.startsWith("thread:") && message.channel.isThread()) {
-    logger6.info({
+    logger10.info({
       scope,
       threadName: message.channel.name
     }, "new thread session");
   }
-  const commandResult = await handleCommand(content, {
+  const commandResult = await executeCommand(content, {
     agentService,
     promptQueue,
     session
@@ -1524,7 +1532,7 @@ ${a.content}`).join("");
   if (commandResult.handled) {
     stopTypingForChannel(channelKey);
     if (commandResult.archive && scope.startsWith("thread:")) {
-      logger6.info({ scope }, "archiving thread");
+      logger10.info({ scope }, "archiving thread");
       const archiveChannel = message.channel;
       if (archiveChannel.isSendable()) {
         await archiveChannel.send(commandResult.response ?? "Archiving...");
@@ -1534,12 +1542,12 @@ ${a.content}`).join("");
           await archiveChannel.setArchived(true);
         }
       } catch (error) {
-        logger6.error({ error }, "failed to archive thread");
+        logger10.error({ error }, "failed to archive thread");
       }
       await sessionRegistry.remove(scope);
       return;
     }
-    logger6.info({
+    logger10.info({
       messageId: message.id,
       command: content,
       hasResponse: Boolean(commandResult.response)
@@ -1551,7 +1559,7 @@ ${a.content}`).join("");
   }
   if (!message.channel.isSendable()) {
     stopTypingForChannel(channelKey);
-    logger6.debug({ messageId: message.id }, "channel not sendable");
+    logger10.debug({ messageId: message.id }, "channel not sendable");
     return;
   }
   await addWorkingReaction(message);
@@ -1565,15 +1573,15 @@ ${a.content}`).join("");
       let promptContent = content;
       let promptImages;
       if (mediaAttachments.length > 0) {
-        const resolved = await resolveMediaAttachments(mediaAttachments, promptContent, session.model, config, agentService);
-        promptContent = resolved.content;
-        if (resolved.images.length > 0) {
-          promptImages = resolved.images;
+        const resolvedPromptMedia = await resolveMediaAttachmentsForPrompt(mediaAttachments, promptContent, session.model, config, agentService);
+        promptContent = resolvedPromptMedia.content;
+        if (resolvedPromptMedia.images.length > 0) {
+          promptImages = resolvedPromptMedia.images;
         }
       }
       const wrappedContent = buildDiscordPromptContent(message, scope, promptContent, config);
       const transformedPrompt = await config.promptTransform(wrappedContent);
-      return collectReply(session, transformedPrompt, {
+      return runPromptAndCollectReply(session, transformedPrompt, {
         logPrefix: `[agent:${session.sessionId}]`,
         images: promptImages
       });
@@ -1585,6 +1593,51 @@ ${a.content}`).join("");
   await sendReply(message, response);
 }
 
+// src/discord-gateway-client.ts
+var logger11 = createModuleLogger("discord-gateway");
+async function startGatewayClient(config, agentService, sessionRegistry, authConfig) {
+  const client = new Client({
+    intents: [
+      GatewayIntentBits.DirectMessages,
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent
+    ],
+    partials: [Partials.Channel]
+  });
+  client.once(Events.ClientReady, async (readyClient) => {
+    logger11.info({ userTag: readyClient.user.tag }, "logged in");
+    if (!authConfig.startupMessage) {
+      return;
+    }
+    try {
+      const user = await readyClient.users.fetch(authConfig.discordAllowedUserId);
+      const dmChannel = await user.createDM();
+      await dmChannel.send(authConfig.startupMessage);
+      logger11.info({
+        userId: authConfig.discordAllowedUserId
+      }, "sent startup dm");
+    } catch (error) {
+      logger11.error({ error }, "failed to send startup dm");
+    }
+  });
+  client.on(Events.MessageCreate, async (message) => {
+    try {
+      await handleDiscordMessage(message, config, agentService, sessionRegistry, authConfig);
+    } catch (error) {
+      logger11.error({ error, direction: "IN" }, "message handling failed");
+      await sendReply(message, "The bot hit an error while handling that message.");
+    }
+  });
+  client.on(Events.ThreadDelete, async (thread) => {
+    const scope = `thread:${thread.id}`;
+    logger11.info({ threadId: thread.id, scope }, "thread deleted");
+    await sessionRegistry.remove(scope);
+  });
+  await client.login(config.discordBotToken);
+  return client;
+}
+
 // src/session-registry.ts
 import path3 from "node:path";
 
@@ -1601,7 +1654,7 @@ class PromptQueue {
           reject(error);
         }
       });
-      this.kick();
+      this.runNextTask();
     });
   }
   getSnapshot() {
@@ -1610,7 +1663,7 @@ class PromptQueue {
       busy: this.running
     };
   }
-  kick() {
+  runNextTask() {
     if (this.running) {
       return;
     }
@@ -1621,7 +1674,7 @@ class PromptQueue {
     this.running = true;
     next().finally(() => {
       this.running = false;
-      this.kick();
+      this.runNextTask();
     });
   }
 }
@@ -1637,7 +1690,7 @@ function sessionDirForScope(agentDir, scope) {
   }
   throw new Error(`Unknown session scope: ${scope}`);
 }
-var logger7 = createModuleLogger("session-registry");
+var logger12 = createModuleLogger("session-registry");
 
 class SessionRegistry {
   scopes = new Map;
@@ -1659,7 +1712,7 @@ class SessionRegistry {
       createdAt: new Date
     };
     this.scopes.set(scope, entry);
-    logger7.debug({
+    logger12.debug({
       scope,
       sessionDir,
       sessionId: session.sessionId
@@ -1671,7 +1724,7 @@ class SessionRegistry {
     if (!entry) {
       return;
     }
-    logger7.debug({ scope }, "removing scope");
+    logger12.debug({ scope }, "removing scope");
     await entry.session.abort();
     entry.session.dispose();
     this.scopes.delete(scope);
@@ -1683,7 +1736,7 @@ class SessionRegistry {
     return Array.from(this.scopes.keys());
   }
   async shutdownAll() {
-    logger7.info({ count: this.scopes.size }, "shutting down all scopes");
+    logger12.info({ count: this.scopes.size }, "shutting down all scopes");
     const scopes = Array.from(this.scopes.keys());
     for (const scope of scopes) {
       await this.remove(scope);
@@ -1692,13 +1745,13 @@ class SessionRegistry {
 }
 
 // src/index.ts
-var logger8 = createModuleLogger("index");
+var logger13 = createModuleLogger("index");
 async function startDiscordGateway(config) {
-  const resolvedConfig = resolveGatewayConfig(config);
+  const resolvedConfig = resolveConfig(config);
   const agentService = new AgentService(resolvedConfig);
-  logger8.info("initializing agent service");
+  logger13.info("initializing agent service");
   await agentService.initialize();
-  logger8.info(agentService.getStatus(), "agent ready");
+  logger13.info(agentService.getStatus(), "agent ready");
   const authConfig = {
     discordAllowedUserId: resolvedConfig.discordAllowedUserId,
     discordAllowedForumChannelIds: resolvedConfig.discordAllowedForumChannelIds,
@@ -1719,9 +1772,6 @@ async function startDiscordGateway(config) {
     }
   };
 }
-async function startDiscordPiBridge(config) {
-  return startDiscordGateway(config);
-}
 function createGatewayStopHandler(client, agentService, sessionRegistry, config) {
   let stopped = false;
   return async () => {
@@ -1729,7 +1779,7 @@ function createGatewayStopHandler(client, agentService, sessionRegistry, config)
       return;
     }
     stopped = true;
-    logger8.info({
+    logger13.info({
       cwd: config.cwd,
       agentDir: config.agentDir
     }, "stopping discord gateway");
@@ -1740,9 +1790,9 @@ function createGatewayStopHandler(client, agentService, sessionRegistry, config)
 }
 function registerSignalHandlers(stop) {
   const handleSignal = (signal) => {
-    logger8.info({ signal }, "received signal");
+    logger13.info({ signal }, "received signal");
     stop().finally(() => {
-      logger8.info("done");
+      logger13.info("done");
       process.exit(0);
     });
   };
@@ -1754,10 +1804,8 @@ function registerSignalHandlers(stop) {
   });
 }
 export {
-  startDiscordPiBridge,
   startDiscordGateway,
   resolveConfig,
-  loadDiscordPiBridgeConfigFromEnv,
   loadDiscordGatewayConfigFromEnv,
   formatDiscordPromptTime,
   buildDiscordMessageContextPrompt