@friendlyrobot/discord-pi-agent 0.11.3 → 0.13.0

package/dist/agent-service.d.ts

@@ -1,4 +1,5 @@
 import { type AgentSession } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
 import type { AgentStatus, ResolvedDiscordPiBridgeConfig, ThinkingLevel } from "./types";
 export declare class AgentService {
     private readonly config;
@@ -11,6 +12,14 @@ export declare class AgentService {
     initialize(): Promise<void>;
     getSession(): AgentSession | null;
     getAgentDir(): string;
+    /**
+     * Create a temporary in-memory session. For one-shot tasks like image
+     * description — no file persistence, no cleanup needed. The caller must
+     * setModel() before prompting and dispose() when done.
+     */
+    createTemporarySession(): Promise<AgentSession>;
+    /** Find a model by provider and ID. Returns undefined if not found. */
+    findModel(provider: string, modelId: string): Model<any> | undefined;
     createSession(sessionDir: string): Promise<AgentSession>;
     prompt(text: string): Promise<string>;
     reloadResources(): Promise<string>;

package/dist/image-description.d.ts

@@ -0,0 +1,11 @@
+import type { Model } from "@earendil-works/pi-ai";
+import type { AgentService } from "./agent-service";
+/**
+ * Use a vision-capable model to describe a media attachment (image or PDF),
+ * returning a text description that can be inlined into a prompt for a
+ * non-vision model.
+ *
+ * Creates a temporary in-memory session, sends the media, extracts the
+ * assistant's text reply, then disposes the session.
+ */
+export declare function describeImage(agentService: AgentService, imageData: string, mimeType: string, userText: string, visionModel: Model<any>): Promise<string>;

package/dist/index.js

@@ -143,7 +143,7 @@ async function collectReply(session, prompt, options = {}) {
     }
   });
   try {
-    await session.prompt(prompt);
+    await session.prompt(prompt, { images: options.images });
   } finally {
     unsubscribe();
   }
@@ -238,6 +238,23 @@ class AgentService {
   getAgentDir() {
     return this.config.agentDir;
   }
+  async createTemporarySession() {
+    const { session } = await createAgentSession({
+      cwd: this.config.cwd,
+      agentDir: this.config.agentDir,
+      authStorage: this.authStorage,
+      modelRegistry: this.modelRegistry,
+      resourceLoader: this.resourceLoader,
+      settingsManager: this.settingsManager,
+      sessionManager: SessionManager.inMemory(),
+      thinkingLevel: "off"
+    });
+    logger4.debug({ sessionId: session.sessionId }, "temporary session created");
+    return session;
+  }
+  findModel(provider, modelId) {
+    return this.modelRegistry.find(provider, modelId);
+  }
   async createSession(sessionDir) {
     await fs.mkdir(sessionDir, { recursive: true });
     const { session } = await createAgentSession({
@@ -514,7 +531,8 @@ function resolveConfig(config) {
     promptLocale: config.promptLocale?.trim() || "en-AU",
     promptTransform: config.promptTransform || identityPromptTransform,
     startupMessage: config.startupMessage === undefined ? "Bot is online and ready." : config.startupMessage,
-    shutdownOnSignals: config.shutdownOnSignals ?? true
+    shutdownOnSignals: config.shutdownOnSignals ?? true,
+    visionModelId: config.visionModelId?.trim() || null
   };
 }
 function loadDiscordPiBridgeConfigFromEnv(overrides = {}) {
@@ -531,7 +549,8 @@ function loadDiscordPiBridgeConfigFromEnv(overrides = {}) {
     promptLocale: overrides.promptLocale || process.env.PI_PROMPT_LOCALE,
     promptTransform: overrides.promptTransform,
     startupMessage: overrides.startupMessage ?? readStartupMessageFromEnv(),
-    shutdownOnSignals: overrides.shutdownOnSignals
+    shutdownOnSignals: overrides.shutdownOnSignals,
+    visionModelId: overrides.visionModelId ?? process.env.PI_VISION_MODEL_ID
   });
 }
 function loadDiscordGatewayConfigFromEnv(overrides = {}) {
@@ -846,6 +865,65 @@ Use !model without args to see available models.`
   };
 }
 
+// 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 isPdf = mimeType === "application/pdf";
+  const imageContent = {
+    type: "image",
+    data: imageData,
+    mimeType
+  };
+  let promptText;
+  if (isPdf) {
+    promptText = userText.trim().length > 0 ? `The user sent a PDF document with the following message: "${userText}". Please extract and summarize the text content of this PDF. Be thorough — include all important details, sections, and data from the document.` : "Please extract and summarize the text content of this PDF 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?";
+  }
+  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();
+  }
+  if (!text) {
+    return "(Vision model returned no description.)";
+  }
+  logger5.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;
+    }
+    const content = msg.content;
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    const textBlocks = [];
+    for (const item of content) {
+      if (typeof item === "object" && item !== null && "type" in item && item.type === "text") {
+        textBlocks.push(item.text);
+      }
+    }
+    return textBlocks.join(`
+`).trim();
+  }
+  return "";
+}
+function isAssistantMessage(msg) {
+  return typeof msg === "object" && msg !== null && "role" in msg && msg.role === "assistant";
+}
+
 // src/message-chunker.ts
 import { marked } from "marked";
 var DISCORD_MESSAGE_LIMIT = 2000;
@@ -926,7 +1004,7 @@ function normalizeContextValue(value) {
 }
 
 // src/discord-gateway-client.ts
-var logger5 = createModuleLogger("discord-gateway");
+var logger6 = createModuleLogger("discord-gateway");
 function getAuthorDisplayName(message) {
   return message.member?.displayName || message.author.globalName || message.author.username;
 }
@@ -978,7 +1056,7 @@ async function addWorkingReaction(message) {
   try {
     await message.react(WORKING_EMOJI);
   } catch (error) {
-    logger5.debug({ messageId: message.id, error }, "failed to add working reaction");
+    logger6.debug({ messageId: message.id, error }, "failed to add working reaction");
   }
 }
 async function removeWorkingReaction(message) {
@@ -988,7 +1066,7 @@ async function removeWorkingReaction(message) {
       await reaction.users.remove(message.client.user);
     }
   } catch (error) {
-    logger5.debug({ messageId: message.id, error }, "failed to remove working reaction");
+    logger6.debug({ messageId: message.id, error }, "failed to remove working reaction");
   }
 }
 var TYPING_INTERVAL_MS = 9000;
@@ -1002,7 +1080,7 @@ async function sendTypingSafe(channel, channelKey) {
       headers: { Authorization: `Bot ${token}` }
     });
     if (res.ok) {
-      logger5.debug(`[TYPING] STATUS UPDATED OK`);
+      logger6.debug(`[TYPING] STATUS UPDATED OK`);
       return;
     }
     if (res.status === 429) {
@@ -1014,28 +1092,28 @@ async function sendTypingSafe(channel, channelKey) {
           retryMs = parsed.retry_after * 1000 + 500;
         }
       } catch {}
-      logger5.warn({ channelKey, retryMs, response: body }, `[TYPING] 429, retrying after ${retryMs}ms delay`);
+      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}` }
       });
-      logger5.info({ channelKey }, "[TYPING] retry done");
+      logger6.info({ channelKey }, "[TYPING] retry done");
       return;
     }
-    logger5.warn({ channelKey, status: res.status }, "[TYPING] unexpected status");
+    logger6.warn({ channelKey, status: res.status }, "[TYPING] unexpected status");
   } catch (error) {
-    logger5.warn({ channelKey, error }, "[TYPING] FAILED");
+    logger6.warn({ channelKey, error }, "[TYPING] FAILED");
   }
 }
 function startTypingForChannel(channel, channelKey) {
   const existing = typingIntervals.get(channelKey);
   if (existing) {
     existing.refs += 1;
-    logger5.debug({ channelKey, refs: existing.refs }, "[TYPING] ref++ (reusing existing interval)");
+    logger6.debug({ channelKey, refs: existing.refs }, "[TYPING] ref++ (reusing existing interval)");
     return;
   }
-  logger5.debug("[TYPING] started new interval");
+  logger6.debug("[TYPING] started new interval");
   sendTypingSafe(channel, channelKey);
   const interval = setInterval(() => {
     sendTypingSafe(channel, channelKey);
@@ -1045,22 +1123,22 @@ function startTypingForChannel(channel, channelKey) {
 function stopTypingForChannel(channelKey) {
   const entry = typingIntervals.get(channelKey);
   if (!entry) {
-    logger5.debug({ channelKey }, "[TYPING] stop called but no entry found");
+    logger6.debug({ channelKey }, "[TYPING] stop called but no entry found");
     return;
   }
   entry.refs -= 1;
   if (entry.refs <= 0) {
     clearInterval(entry.interval);
     typingIntervals.delete(channelKey);
-    logger5.debug("[TYPING] interval cleared (refs hit 0)");
+    logger6.debug("[TYPING] interval cleared (refs hit 0)");
   } else {
-    logger5.debug("[TYPING] ref-- (interval still active)");
+    logger6.debug("[TYPING] ref-- (interval still active)");
   }
 }
 async function sendReply(message, text) {
   const channel = message.channel;
   if (!channel.isSendable()) {
-    logger5.debug({
+    logger6.debug({
       messageId: message.id
     }, "reply skipped, channel not sendable");
     return;
@@ -1076,13 +1154,25 @@ async function sendReply(message, text) {
       await channel.send(chunk);
     }
   } catch (error) {
-    logger5.error({
+    logger6.error({
       messageId: message.id,
       error
     }, "send reply failed");
   }
 }
-var TEXT_ATTACHMENT_EXTENSIONS = [".txt", ".md", ".json", ".csv", ".log", ".yml", ".yaml", ".xml", ".toml", ".ini", ".cfg"];
+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;
@@ -1093,28 +1183,185 @@ async function readTextAttachments(message) {
   for (const [, attachment] of attachments) {
     const ext = attachment.name?.slice(attachment.name.lastIndexOf(".")).toLowerCase();
     if (!ext || !TEXT_ATTACHMENT_EXTENSIONS.includes(ext)) {
-      logger5.debug({ messageId: message.id, filename: attachment.name, ext }, "skipping non-text attachment");
+      logger6.debug({ messageId: message.id, filename: attachment.name, ext }, "skipping non-text attachment");
       continue;
     }
     if (attachment.size > MAX_ATTACHMENT_SIZE_BYTES) {
-      logger5.warn({ messageId: message.id, filename: attachment.name, size: attachment.size }, "attachment too large, skipping");
+      logger6.warn({
+        messageId: message.id,
+        filename: attachment.name,
+        size: attachment.size
+      }, "attachment too large, skipping");
       continue;
     }
     try {
-      logger5.info({ messageId: message.id, filename: attachment.name, size: attachment.size }, "fetching attachment");
+      logger6.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");
+        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) {
-      logger5.error({ messageId: message.id, filename: attachment.name, error }, "error fetching attachment");
+      logger6.error({ messageId: message.id, filename: attachment.name, error }, "error fetching attachment");
     }
   }
   return results;
 }
+var MEDIA_ATTACHMENT_EXTENSIONS = [
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".pdf"
+];
+var MAX_MEDIA_ATTACHMENT_SIZE = 25 * 1024 * 1024;
+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;
+  }
+  return ct.startsWith("image/") || ct === "application/pdf";
+}
+async function readMediaAttachments(message) {
+  const attachments = message.attachments;
+  if (attachments.size === 0) {
+    return [];
+  }
+  const results = [];
+  for (const [, attachment] of attachments) {
+    if (!isMediaAttachment(attachment)) {
+      continue;
+    }
+    if (attachment.size > MAX_MEDIA_ATTACHMENT_SIZE) {
+      logger6.warn({
+        messageId: message.id,
+        filename: attachment.name,
+        size: attachment.size
+      }, "media attachment too large, skipping");
+      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 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 results;
+}
+function parseVisionModelId(visionModelId) {
+  const trimmed = visionModelId.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex === -1) {
+    return null;
+  }
+  return {
+    provider: trimmed.substring(0, slashIndex),
+    modelId: trimmed.substring(slashIndex + 1)
+  };
+}
+async function resolveMediaAttachments(media, 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,
+      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 };
+  }
+  if (!config.visionModelId) {
+    const names = media.map((m) => m.filename).join(", ");
+    logger6.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 understanding.)";
+    return { content: content ? content + note : note, images: [] };
+  }
+  const parsed = parseVisionModelId(config.visionModelId);
+  if (!parsed) {
+    return { content, images: [] };
+  }
+  const visionModel = agentService.findModel(parsed.provider, parsed.modelId);
+  if (!visionModel) {
+    logger6.warn({ visionModelId: config.visionModelId }, "vision model not found in registry");
+    const names = media.map((m) => m.filename).join(", ");
+    const note = `
+
+[User sent media attachment(s): ${names}]
+(Vision model not found: ${config.visionModelId})`;
+    return { content: content ? content + note : note, images: [] };
+  }
+  logger6.info({
+    count: media.length,
+    visionModel: `${visionModel.provider}/${visionModel.id}`
+  }, "describing media with vision model");
+  const descriptions = [];
+  for (const m of media) {
+    const isPdf = m.mimeType === "application/pdf";
+    const description = await describeImage(agentService, m.data, m.mimeType, content, visionModel);
+    const label = isPdf ? `[PDF: ${m.filename}]` : `[Image: ${m.filename}]`;
+    descriptions.push(`${label}
+${description}`);
+  }
+  if (descriptions.length > 0) {
+    const prefix = descriptions.join(`
+
+`);
+    return {
+      content: content ? `${prefix}
+
+---
+${content}` : prefix,
+      images: []
+    };
+  }
+  return { content, images: [] };
+}
 async function startGatewayClient(config, agentService, sessionRegistry, authConfig) {
   const client = new Client({
     intents: [
@@ -1126,7 +1373,7 @@ async function startGatewayClient(config, agentService, sessionRegistry, authCon
     partials: [Partials.Channel]
   });
   client.once(Events.ClientReady, async (readyClient) => {
-    logger5.info({ userTag: readyClient.user.tag }, "logged in");
+    logger6.info({ userTag: readyClient.user.tag }, "logged in");
     if (!authConfig.startupMessage) {
       return;
     }
@@ -1134,24 +1381,24 @@ async function startGatewayClient(config, agentService, sessionRegistry, authCon
       const user = await readyClient.users.fetch(authConfig.discordAllowedUserId);
       const dmChannel = await user.createDM();
       await dmChannel.send(authConfig.startupMessage);
-      logger5.info({
+      logger6.info({
         userId: authConfig.discordAllowedUserId
       }, "sent startup dm");
     } catch (error) {
-      logger5.error({ error }, "failed to send startup dm");
+      logger6.error({ error }, "failed to send startup dm");
     }
   });
   client.on(Events.MessageCreate, async (message) => {
     try {
       await onMessage(message, config, agentService, sessionRegistry, authConfig);
     } catch (error) {
-      logger5.error({ error, direction: "IN" }, "message handling failed");
+      logger6.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}`;
-    logger5.info({ threadId: thread.id, scope }, "thread deleted");
+    logger6.info({ threadId: thread.id, scope }, "thread deleted");
     await sessionRegistry.remove(scope);
   });
   await client.login(config.discordBotToken);
@@ -1159,23 +1406,23 @@ async function startGatewayClient(config, agentService, sessionRegistry, authCon
 }
 async function onMessage(message, config, agentService, sessionRegistry, authConfig) {
   if (message.author.bot) {
-    logger5.debug("ignored bot message");
+    logger6.debug("ignored bot message");
     return;
   }
   if (message.system) {
-    logger5.debug({ messageId: message.id }, "ignored system message");
+    logger6.debug({ messageId: message.id }, "ignored system message");
     return;
   }
   const scope = resolveScope(message);
   if (scope === null) {
-    logger5.debug({
+    logger6.debug({
       messageId: message.id,
       channelType: message.channel.type
     }, "unsupported channel type, ignoring");
     return;
   }
   if (!isAuthorized(message, scope, authConfig)) {
-    logger5.debug({
+    logger6.debug({
       messageId: message.id,
       authorId: message.author.id,
       scope
@@ -1191,11 +1438,12 @@ async function onMessage(message, config, agentService, sessionRegistry, authCon
 ${a.content}`).join("");
     content = content ? content + suffix : attachmentContents[0].content;
   }
-  if (!content) {
-    logger5.debug({ messageId: message.id }, "ignored empty message");
+  const mediaAttachments = await readMediaAttachments(message);
+  if (!content && mediaAttachments.length === 0) {
+    logger6.debug({ messageId: message.id }, "ignored empty message (no text or images)");
     return;
   }
-  logger5.info({
+  logger6.info({
     direction: "IN",
     scope,
     messageId: message.id,
@@ -1211,7 +1459,7 @@ ${a.content}`).join("");
   const { entry, created } = await sessionRegistry.getOrCreate(scope);
   const { session, promptQueue } = entry;
   if (created && scope.startsWith("thread:") && message.channel.isThread()) {
-    logger5.info({
+    logger6.info({
       scope,
       threadName: message.channel.name
     }, "new thread session");
@@ -1224,7 +1472,7 @@ ${a.content}`).join("");
   if (commandResult.handled) {
     stopTypingForChannel(channelKey);
     if (commandResult.archive && scope.startsWith("thread:")) {
-      logger5.info({ scope }, "archiving thread");
+      logger6.info({ scope }, "archiving thread");
       const archiveChannel = message.channel;
       if (archiveChannel.isSendable()) {
         await archiveChannel.send(commandResult.response ?? "Archiving...");
@@ -1234,12 +1482,12 @@ ${a.content}`).join("");
           await archiveChannel.setArchived(true);
         }
       } catch (error) {
-        logger5.error({ error }, "failed to archive thread");
+        logger6.error({ error }, "failed to archive thread");
       }
       await sessionRegistry.remove(scope);
       return;
     }
-    logger5.info({
+    logger6.info({
       messageId: message.id,
       command: content,
       hasResponse: Boolean(commandResult.response)
@@ -1251,7 +1499,7 @@ ${a.content}`).join("");
   }
   if (!message.channel.isSendable()) {
     stopTypingForChannel(channelKey);
-    logger5.debug({ messageId: message.id }, "channel not sendable");
+    logger6.debug({ messageId: message.id }, "channel not sendable");
     return;
   }
   await addWorkingReaction(message);
@@ -1262,10 +1510,20 @@ ${a.content}`).join("");
   let response;
   try {
     response = await promptQueue.enqueue(async () => {
-      const promptContent = buildDiscordPromptContent(message, scope, content, config);
-      const transformedPrompt = await config.promptTransform(promptContent);
+      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 wrappedContent = buildDiscordPromptContent(message, scope, promptContent, config);
+      const transformedPrompt = await config.promptTransform(wrappedContent);
       return collectReply(session, transformedPrompt, {
-        logPrefix: `[agent:${session.sessionId}]`
+        logPrefix: `[agent:${session.sessionId}]`,
+        images: promptImages
       });
     });
   } finally {
@@ -1327,7 +1585,7 @@ function sessionDirForScope(agentDir, scope) {
   }
   throw new Error(`Unknown session scope: ${scope}`);
 }
-var logger6 = createModuleLogger("session-registry");
+var logger7 = createModuleLogger("session-registry");
 
 class SessionRegistry {
   scopes = new Map;
@@ -1349,7 +1607,7 @@ class SessionRegistry {
       createdAt: new Date
     };
     this.scopes.set(scope, entry);
-    logger6.debug({
+    logger7.debug({
       scope,
       sessionDir,
       sessionId: session.sessionId
@@ -1361,7 +1619,7 @@ class SessionRegistry {
     if (!entry) {
       return;
     }
-    logger6.debug({ scope }, "removing scope");
+    logger7.debug({ scope }, "removing scope");
     await entry.session.abort();
     entry.session.dispose();
     this.scopes.delete(scope);
@@ -1373,7 +1631,7 @@ class SessionRegistry {
     return Array.from(this.scopes.keys());
   }
   async shutdownAll() {
-    logger6.info({ count: this.scopes.size }, "shutting down all scopes");
+    logger7.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);
@@ -1382,13 +1640,13 @@ class SessionRegistry {
 }
 
 // src/index.ts
-var logger7 = createModuleLogger("index");
+var logger8 = createModuleLogger("index");
 async function startDiscordGateway(config) {
   const resolvedConfig = resolveGatewayConfig(config);
   const agentService = new AgentService(resolvedConfig);
-  logger7.info("initializing agent service");
+  logger8.info("initializing agent service");
   await agentService.initialize();
-  logger7.info(agentService.getStatus(), "agent ready");
+  logger8.info(agentService.getStatus(), "agent ready");
   const authConfig = {
     discordAllowedUserId: resolvedConfig.discordAllowedUserId,
     discordAllowedForumChannelIds: resolvedConfig.discordAllowedForumChannelIds,
@@ -1419,7 +1677,7 @@ function createGatewayStopHandler(client, agentService, sessionRegistry, config)
       return;
     }
     stopped = true;
-    logger7.info({
+    logger8.info({
       cwd: config.cwd,
       agentDir: config.agentDir
     }, "stopping discord gateway");
@@ -1430,9 +1688,9 @@ function createGatewayStopHandler(client, agentService, sessionRegistry, config)
 }
 function registerSignalHandlers(stop) {
   const handleSignal = (signal) => {
-    logger7.info({ signal }, "received signal");
+    logger8.info({ signal }, "received signal");
     stop().finally(() => {
-      logger7.info("done");
+      logger8.info("done");
       process.exit(0);
     });
   };

package/dist/reply-buffer.d.ts

@@ -1,6 +1,8 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { ImageContent } from "@earendil-works/pi-ai";
 type CollectReplyOptions = {
     logPrefix?: string;
+    images?: ImageContent[];
 };
 export declare function collectReply(session: AgentSession, prompt: string, options?: CollectReplyOptions): Promise<string>;
 export {};

package/dist/types.d.ts

@@ -14,6 +14,13 @@ export type DiscordPiBridgeConfig = {
     promptTransform?: PromptTransform;
     startupMessage?: string | false;
     shutdownOnSignals?: boolean;
+    /**
+     * Vision model to use for describing images when the main model
+     * lacks vision support. Format: "provider/modelId"
+     * (e.g. "openrouter/google/gemini-2.5-flash").
+     * Defaults to null (image handling disabled).
+     */
+    visionModelId?: string | null;
 };
 export type ResolvedDiscordPiBridgeConfig = {
     discordBotToken: string;
@@ -28,6 +35,8 @@ export type ResolvedDiscordPiBridgeConfig = {
     promptTransform: PromptTransform;
     startupMessage: string | false;
     shutdownOnSignals: boolean;
+    /** Vision model provider/modelId for image description (null = disabled). */
+    visionModelId: string | null;
 };
 export type ContextUsageStatus = {
     tokens: number | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friendlyrobot/discord-pi-agent",
-  "version": "0.11.3",
+  "version": "0.13.0",
   "description": "Reusable Discord gateway bridge for persistent pi agent sessions",
   "license": "MIT",
   "type": "module",