@friendlyrobot/discord-pi-agent 0.21.1 → 0.21.4

package/dist/index.js

@@ -1,1916 +1,69 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/agent-service.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-import {
-  AuthStorage,
-  createAgentSession,
-  DefaultResourceLoader,
-  ModelRegistry,
-  SessionManager,
-  SettingsManager
-} from "@earendil-works/pi-coding-agent";
-
-// src/logger.ts
-import pino from "pino";
-var loggerLevel = process.env.DISCORD_PI_AGENT_LOG_LEVEL || process.env.LOG_LEVEL || "info";
-var usePrettyTransport = process.stdout.isTTY;
-var baseOptions = {
-  level: loggerLevel
-};
-var logger = usePrettyTransport ? pino({
-  ...baseOptions,
-  transport: {
-    target: "pino-pretty",
-    options: {
-      colorize: true,
-      colorizeObjects: true,
-      levelFirst: true,
-      translateTime: "SYS:standard",
-      ignore: "pid,hostname",
-      singleLine: false,
-      messageFormat: "[{module}] {if direction}{direction} {end}{msg}"
-    }
-  }
-}) : pino(baseOptions);
-function createModuleLogger(moduleName) {
-  return logger.child({ module: moduleName });
-}
-
-// src/agent-model-service.ts
-var logger2 = createModuleLogger("agent-model-service");
-
-class AgentModelService {
-  config;
-  modelRegistry;
-  constructor(config, modelRegistry) {
-    this.config = config;
-    this.modelRegistry = modelRegistry;
-  }
-  findModel(provider, modelId) {
-    return this.modelRegistry.find(provider, modelId);
-  }
-  async ensureSessionHasConfiguredModel(session) {
-    if (session.model) {
-      logger2.debug({
-        model: `${session.model.provider}/${session.model.id}`
-      }, "retaining existing session model");
-      return;
-    }
-    const desiredModel = this.modelRegistry.find(this.config.modelProvider, this.config.modelId);
-    const availableModels = await this.modelRegistry.getAvailable();
-    logger2.debug({
-      count: availableModels.length,
-      matches: availableModels.filter((model) => {
-        return model.provider === this.config.modelProvider;
-      }).map((model) => `${model.provider}/${model.id}`)
-    }, "available models");
-    if (!desiredModel) {
-      throw new Error(`Configured model not found: ${this.config.modelProvider}/${this.config.modelId}. Check your pi agent config and installed extensions.`);
-    }
-    logger2.info({
-      to: `${desiredModel.provider}/${desiredModel.id}`
-    }, "setting initial session model");
-    await session.setModel(desiredModel);
-    await this.applyConfiguredThinkingLevelForSession(session);
-  }
-  async listModels(session) {
-    const availableModels = await this.modelRegistry.getAvailable();
-    const currentDisplay = session?.model ? `${session.model.provider}/${session.model.id}` : null;
-    const lines = availableModels.map((model) => {
-      const display = `${model.provider}/${model.id}`;
-      const marker = currentDisplay === display ? " (current)" : "";
-      return `  ${display}${marker}`;
-    });
-    return [
-      `Available models (${availableModels.length}):`,
-      ...lines,
-      `
-Usage: !model <provider/modelId> to switch.`
-    ].join(`
-`);
-  }
-  async switchModel(provider, modelId, session) {
-    const model = this.modelRegistry.find(provider, modelId);
-    if (!model) {
-      const availableModels = await this.modelRegistry.getAvailable();
-      const matches = availableModels.filter((availableModel) => {
-        return availableModel.provider === provider;
-      }).map((availableModel) => {
-        return `${availableModel.provider}/${availableModel.id}`;
-      });
-      const hint = matches.length > 0 ? `
-Models from "${provider}": ${matches.join(", ")}` : `
-Use !model to see all available models.`;
-      return `Model not found: ${provider}/${modelId}.${hint}`;
-    }
-    if (isSameModel(session.model, model)) {
-      return `Already using ${provider}/${modelId}.`;
-    }
-    await session.setModel(model);
-    await this.applyConfiguredThinkingLevelForSession(session);
-    const thinkingInfo = session.supportsThinking() ? ` (thinking: ${session.thinkingLevel})` : "";
-    return `Switched to ${provider}/${modelId}${thinkingInfo}.`;
-  }
-  getCurrentModelDisplay(session) {
-    if (!session?.model) {
-      return "(no model selected)";
-    }
-    return `${session.model.provider}/${session.model.id}`;
-  }
-  getThinkingLevel(session) {
-    if (!session.supportsThinking()) {
-      return { current: "off", available: [], supported: false };
-    }
-    return {
-      current: session.thinkingLevel,
-      available: session.getAvailableThinkingLevels(),
-      supported: true
+import { AgentService } from "./agent-service";
+import { resolveConfig } from "./config";
+import { startGatewayClient } from "./discord-gateway-client";
+import { createModuleLogger } from "./logger";
+import { SessionRegistry } from "./session-registry";
+const logger = createModuleLogger("index");
+export { formatDiscordPromptTime } from "./prompt-context";
+export { loadDiscordGatewayConfigFromEnv, resolveConfig } from "./config";
+/**
+ * Start the unified Discord gateway. Supports DM and forum thread sessions
+ * out of the box. Set discordAllowedForumChannelIds to enable forum support.
+ */
+export async function startDiscordGateway(config) {
+    const resolvedConfig = resolveConfig(config);
+    const agentService = new AgentService(resolvedConfig);
+    logger.info("initializing agent service");
+    await agentService.initialize();
+    logger.info(agentService.getStatus(), "agent ready");
+    const accessConfig = {
+        discordAllowedUserId: resolvedConfig.discordAllowedUserId,
+        discordAllowedForumChannelIds: resolvedConfig.discordAllowedForumChannelIds,
+        discordAllowedUserIds: resolvedConfig.discordAllowedUserIds,
+        startupMessage: resolvedConfig.startupMessage,
     };
-  }
-  setThinkingLevel(session, level) {
-    if (!session.supportsThinking()) {
-      return "Current model does not support reasoning/thinking.";
-    }
-    const available = session.getAvailableThinkingLevels();
-    if (!available.includes(level)) {
-      return `Invalid thinking level "${level}" for current model. Available: ${available.join(", ")}`;
+    const sessionRegistry = new SessionRegistry(agentService);
+    const client = await startGatewayClient(resolvedConfig, agentService, sessionRegistry, accessConfig);
+    const stop = createGatewayStopHandler(client, agentService, sessionRegistry, resolvedConfig);
+    if (resolvedConfig.shutdownOnSignals) {
+        registerSignalHandlers(stop);
     }
-    session.setThinkingLevel(level);
-    return `Thinking level set to "${level}".`;
-  }
-  async applyConfiguredThinkingLevelForSession(session) {
-    if (session.supportsThinking()) {
-      const available = session.getAvailableThinkingLevels();
-      if (available.includes(this.config.thinkingLevel)) {
-        session.setThinkingLevel(this.config.thinkingLevel);
-        logger2.debug({
-          level: this.config.thinkingLevel
-        }, "thinking level applied");
-      } else {
-        logger2.debug({
-          requested: this.config.thinkingLevel,
-          available
-        }, "thinking level not available for model");
-      }
-    }
-  }
-}
-function isSameModel(currentModel, desiredModel) {
-  if (!currentModel) {
-    return false;
-  }
-  return currentModel.provider === desiredModel.provider && currentModel.id === desiredModel.id;
-}
-
-// src/agent-resource-service.ts
-class AgentResourceService {
-  resourceLoader;
-  constructor(resourceLoader) {
-    this.resourceLoader = resourceLoader;
-  }
-  getSkillsSummary() {
-    const result = this.resourceLoader.getSkills();
-    const { skills } = result;
-    if (skills.length === 0) {
-      return "Skills: (none loaded)";
-    }
-    const names = skills.map((skill) => {
-      return skill.name;
-    });
-    return `Skills (${skills.length}): ${names.join(", ") || "(none)"}`;
-  }
-  getExtensionsSummary() {
-    const result = this.resourceLoader.getExtensions();
-    const { extensions, errors } = result;
-    if (extensions.length === 0) {
-      return "Extensions: (none loaded)";
-    }
-    const lines = extensions.map((extension) => {
-      const toolCount = extension.tools.size;
-      const commandCount = extension.commands.size;
-      const parts = [];
-      if (toolCount > 0) {
-        parts.push(`${toolCount} tool${toolCount !== 1 ? "s" : ""}`);
-      }
-      if (commandCount > 0) {
-        parts.push(`${commandCount} command${commandCount !== 1 ? "s" : ""}`);
-      }
-      const summary = parts.length > 0 ? ` (${parts.join(", ")})` : "";
-      return `  ${extension.path}${summary}`;
-    });
-    const header = `Extensions (${extensions.length}):`;
-    const errorLines = errors.length > 0 ? [
-      `Errors (${errors.length}):`,
-      ...errors.map((error) => {
-        return `  ${error.path}: ${error.error}`;
-      })
-    ] : [];
-    return [header, ...lines, ...errorLines].join(`
-`);
-  }
-  async reloadResources() {
-    await this.resourceLoader.reload();
-    const extensions = this.resourceLoader.getExtensions().extensions.map((extension) => {
-      return extension.path;
-    });
-    const skills = this.resourceLoader.getSkills();
-    const skillNames = skills.skills.map((skill) => {
-      return skill.name;
-    });
-    const agentsFiles = this.resourceLoader.getAgentsFiles().agentsFiles.map((file) => {
-      return file.path;
-    });
-    return [
-      "Resources reloaded.",
-      `Extensions (${extensions.length}): ${extensions.join(", ") || "(none)"}`,
-      `Skills (${skills.skills.length}): ${skillNames.join(", ") || "(none)"}`,
-      `AGENTS.md files (${agentsFiles.length}): ${agentsFiles.join(", ") || "(none)"}`
-    ].join(`
-`);
-  }
-}
-
-// src/debug-print.ts
-function debugPrint(body, title) {
-  const WIDTH = 80;
-  const label = title ?? "DEBUG";
-  function centeredFence(text) {
-    const inner = ` ${text} `;
-    const padLen = Math.floor((WIDTH - inner.length) / 2);
-    const pad = "=".repeat(padLen);
-    const result = pad + inner + pad;
-    return result.length < WIDTH ? result + "=" : result;
-  }
-  console.info(centeredFence(label));
-  console.info(body);
-  console.info(centeredFence(`${label} END`));
-}
-
-// src/markdown-table-transformer.ts
-import { Lexer } from "marked";
-var logger3 = createModuleLogger("markdown-table-transformer");
-var CODE_BLOCK_WRAPPER = "```\n{TABLE}\n```";
-async function transformMarkdownTablesToCodeBlocks(text) {
-  const normalized = normalizeCodeFences(text);
-  const formatted = await formatWithPrettier(normalized);
-  const tokens = Lexer.lex(formatted);
-  const result = [];
-  for (const token of tokens) {
-    if (token.type === "table") {
-      result.push(CODE_BLOCK_WRAPPER.replace("{TABLE}", token.raw.trimEnd()));
-    } else {
-      result.push(token.raw);
-    }
-  }
-  return formatWithPrettier(result.join(""));
-}
-function normalizeCodeFences(text) {
-  const lines = text.split(`
-`);
-  const result = [];
-  for (const line of lines) {
-    const trimmed = line.trimEnd();
-    if (trimmed.endsWith("```") && !trimmed.startsWith("```")) {
-      const beforeFence = trimmed.slice(0, -3).trimEnd();
-      if (beforeFence) {
-        result.push(beforeFence);
-      }
-      result.push("```");
-    } else if (trimmed.startsWith("```") && !isValidFenceLine(trimmed)) {
-      result.push("```");
-      const afterFence = trimmed.slice(3).trimStart();
-      if (afterFence) {
-        result.push(afterFence);
-      }
-    } else {
-      result.push(line);
-    }
-  }
-  return result.join(`
-`);
-}
-function isValidFenceLine(line) {
-  const trimmed = line.trimEnd();
-  if (trimmed === "```") {
-    return true;
-  }
-  const afterFence = trimmed.slice(3);
-  if (!afterFence) {
-    return true;
-  }
-  if (afterFence.codePointAt(0) > 127) {
-    return false;
-  }
-  const tokens = afterFence.trimStart().split(/\s+/);
-  if (tokens.length > 1) {
-    return false;
-  }
-  if (tokens[0].includes("`")) {
-    return false;
-  }
-  return true;
-}
-async function formatWithPrettier(text) {
-  const prettier = await import("prettier");
-  try {
-    const formatted = await prettier.format(text, {
-      parser: "markdown",
-      printWidth: 80
-    });
-    return formatted.trim();
-  } catch (error) {
-    logger3.error({
-      error
-    }, "Prettier formatting failed");
-    return text;
-  }
-}
-
-// src/agent-turn-runner.ts
-var logger4 = createModuleLogger("agent-turn-runner");
-async function runAgentTurn(session, prompt, options = {}) {
-  let streamedText = "";
-  let eventCount = 0;
-  let toolCount = 0;
-  const toolInputsByCallId = new Map;
-  const model = session.model ? `${session.model.provider}/${session.model.id}` : "none";
-  debugPrint(prompt, "Full Prompt");
-  const unsubscribe = session.subscribe((event) => {
-    eventCount += 1;
-    if (event.type === "message_update") {
-      if (event.assistantMessageEvent.type === "text_delta") {
-        streamedText += event.assistantMessageEvent.delta;
-      }
-      if (event.assistantMessageEvent.type === "thinking_delta") {}
-    }
-    if (event.type === "tool_execution_start") {
-      toolCount += 1;
-      const input = event.toolName === "bash" ? event.args.command : event.args;
-      toolInputsByCallId.set(event.toolCallId, input);
-      if (event.toolName === "bash") {
-        debugPrint(input, "CMD");
-      } else {
-        logger4.debug({
-          toolName: event.toolName
-        }, `agent tool start: [${event.toolName}]`);
-      }
-    }
-    if (event.type === "tool_execution_end") {
-      const input = toolInputsByCallId.get(event.toolCallId);
-      toolInputsByCallId.delete(event.toolCallId);
-      if (event.toolName === "bash") {
-        debugPrint(extractToolOutput(event.result), event.isError ? "BASH TOOL ERROR OUTPUT" : "BASH TOOL OUTPUT");
-      } else {
-        logger4.debug({
-          toolName: event.toolName,
-          isError: event.isError
-        }, `agent tool end: [${event.toolName}]`);
-      }
-    }
-  });
-  try {
-    await session.prompt(prompt, { images: options.images });
-  } finally {
-    unsubscribe();
-  }
-  const errorMessage = session.agent.state.errorMessage?.trim();
-  const fallbackText = getLatestAssistantText(session.messages);
-  const finalText = streamedText.trim() || fallbackText.trim();
-  if (errorMessage) {
-    return errorMessage;
-  }
-  if (finalText) {
-    const transformed = await transformMarkdownTablesToCodeBlocks(finalText);
-    debugPrint(finalText, "BEFORE TRANSFORM");
-    debugPrint(transformed, "TRANSFORMED");
-    return transformed;
-  }
-  return "No response generated.";
-}
-function extractToolOutput(output) {
-  if (typeof output === "object" && output !== null) {
-    const obj = output;
-    if (Array.isArray(obj.content)) {
-      return obj.content.map((item) => {
-        if (item.type === "text" && typeof item.text === "string") {
-          return item.text;
-        }
-        return JSON.stringify(item);
-      }).join(`
-`);
-    }
-  }
-  return String(output);
-}
-function getLatestAssistantText(messages) {
-  const latestAssistantMessage = [...messages].reverse().find((message) => {
-    return message.role === "assistant";
-  });
-  if (!latestAssistantMessage || !Array.isArray(latestAssistantMessage.content)) {
-    return "";
-  }
-  return latestAssistantMessage.content.filter((item) => {
-    return item.type === "text";
-  }).map((item) => {
-    return item.text;
-  }).join(`
-`).trim();
-}
-
-// src/agent-service.ts
-var logger5 = createModuleLogger("agent-service");
-
-class AgentService {
-  config;
-  authStorage;
-  modelRegistry;
-  settingsManager;
-  resourceLoader;
-  session = null;
-  models;
-  resources;
-  constructor(config) {
-    this.config = config;
-    this.authStorage = AuthStorage.create(path.join(config.agentDir, "auth.json"));
-    this.modelRegistry = ModelRegistry.create(this.authStorage, path.join(config.agentDir, "models.json"));
-    this.settingsManager = SettingsManager.create(config.cwd, config.agentDir);
-    this.resourceLoader = new DefaultResourceLoader({
-      cwd: config.cwd,
-      agentDir: config.agentDir,
-      settingsManager: this.settingsManager
-    });
-    this.models = new AgentModelService(config, this.modelRegistry);
-    this.resources = new AgentResourceService(this.resourceLoader);
-  }
-  async initialize() {
-    await fs.mkdir(this.config.agentDir, { recursive: true });
-    await fs.mkdir(this.getSessionDir(), { recursive: true });
-    logger5.info({
-      cwd: this.config.cwd,
-      agentDir: this.config.agentDir,
-      sessionDir: this.getSessionDir(),
-      modelProvider: this.config.modelProvider,
-      modelId: this.config.modelId,
-      thinkingLevel: this.config.thinkingLevel
-    }, "config");
-    await this.resourceLoader.reload();
-    logger5.info({
-      extensions: this.resourceLoader.getExtensions().extensions.map((extension) => extension.path),
-      agentsFiles: this.resourceLoader.getAgentsFiles().agentsFiles.map((file) => file.path)
-    }, "resources loaded");
-    await this.createOrResumeSession();
-    await this.ensureConfiguredModel();
-  }
-  getSession() {
-    return this.session;
-  }
-  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"
-    });
-    logger5.debug({ sessionId: session.sessionId }, "temporary session created");
-    return session;
-  }
-  async createSession(sessionDir) {
-    await fs.mkdir(sessionDir, { recursive: true });
-    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.continueRecent(this.config.cwd, sessionDir),
-      thinkingLevel: this.config.thinkingLevel
-    });
-    logger5.debug({
-      sessionDir,
-      sessionId: session.sessionId,
-      sessionFile: session.sessionFile
-    }, "scoped session created");
-    await this.models.ensureSessionHasConfiguredModel(session);
-    return session;
-  }
-  async prompt(text) {
-    const session = this.requireSession();
-    const transformedPrompt = await this.config.promptTransform({
-      rawContent: text,
-      discordMetadata: "",
-      now: () => "",
-      userMessage: () => text
-    });
-    return runAgentTurn(session, transformedPrompt);
-  }
-  async compact() {
-    const session = this.requireSession();
-    await session.compact();
-    return `Compaction finished for session ${session.sessionId}.`;
-  }
-  async resetSession() {
-    const previousSession = this.requireSession();
-    await previousSession.abort();
-    previousSession.dispose();
-    this.session = null;
-    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.create(this.config.cwd, this.getSessionDir()),
-      thinkingLevel: this.config.thinkingLevel
-    });
-    this.session = session;
-    await this.ensureConfiguredModel();
-    return `Started a fresh session. Old session kept at ${previousSession.sessionFile ?? "(unknown path)"}.`;
-  }
-  getStatus() {
-    const session = this.requireSession();
-    const model = this.models.getCurrentModelDisplay(session);
-    const contextUsage = session.getContextUsage();
-    const thinkingInfo = session.supportsThinking() ? `thinking: ${session.thinkingLevel} (available: ${session.getAvailableThinkingLevels().join(", ")})` : "thinking: not supported";
     return {
-      sessionId: session.sessionId,
-      sessionFile: session.sessionFile,
-      model,
-      streaming: session.isStreaming,
-      contextUsage,
-      thinkingInfo
+        client,
+        stop,
+        getStatus: () => {
+            return agentService.getStatus();
+        },
     };
-  }
-  async shutdown() {
-    const session = this.session;
-    if (session) {
-      await session.abort();
-      session.dispose();
-    }
-    await this.settingsManager.flush();
-  }
-  async createOrResumeSession() {
-    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.continueRecent(this.config.cwd, this.getSessionDir()),
-      thinkingLevel: this.config.thinkingLevel
-    });
-    this.session = session;
-    logger5.info({
-      sessionId: session.sessionId,
-      sessionFile: session.sessionFile,
-      restoredModel: session.model ? `${session.model.provider}/${session.model.id}` : null
-    }, "session ready");
-  }
-  async ensureConfiguredModel() {
-    await this.models.ensureSessionHasConfiguredModel(this.requireSession());
-  }
-  requireSession() {
-    if (!this.session) {
-      throw new Error("Agent session has not been initialized.");
-    }
-    return this.session;
-  }
-  getSessionDir() {
-    return path.join(this.config.agentDir, "sessions");
-  }
-}
-
-// src/config.ts
-import path2 from "node:path";
-import dotenv from "dotenv";
-function resolveConfig(config) {
-  const discordAllowedUserId = requireNonEmptyConfigValue("discordAllowedUserId", config.discordAllowedUserId);
-  const cwd = requireNonEmptyConfigValue("cwd", config.cwd);
-  return {
-    discordBotToken: requireNonEmptyConfigValue("discordBotToken", config.discordBotToken),
-    discordAllowedUserId,
-    cwd,
-    agentDir: config.agentDir?.trim() || path2.join(cwd, ".pi-agent"),
-    modelProvider: config.modelProvider?.trim() || "openrouter",
-    modelId: config.modelId?.trim() || "anthropic/claude-3.5-haiku",
-    thinkingLevel: parseThinkingLevel(config.thinkingLevel) || "medium",
-    promptTimeZone: config.promptTimeZone?.trim() || "UTC",
-    promptLocale: config.promptLocale?.trim() || "en-AU",
-    promptTransform: config.promptTransform || defaultPromptTransform,
-    startupMessage: config.startupMessage === undefined ? "Bot is online and ready." : config.startupMessage,
-    shutdownOnSignals: config.shutdownOnSignals ?? true,
-    visionModelId: config.visionModelId?.trim() || null,
-    discordAllowedForumChannelIds: config.discordAllowedForumChannelIds ?? [],
-    discordAllowedUserIds: config.discordAllowedUserIds ?? [
-      discordAllowedUserId
-    ]
-  };
-}
-function loadDiscordGatewayConfigFromEnv(overrides = {}) {
-  dotenv.config();
-  return resolveConfig({
-    discordBotToken: overrides.discordBotToken || process.env.DISCORD_BOT_TOKEN || "",
-    discordAllowedUserId: overrides.discordAllowedUserId || process.env.DISCORD_ALLOWED_USER_ID || "",
-    cwd: overrides.cwd || process.env.PI_AGENT_CWD || process.cwd(),
-    agentDir: overrides.agentDir || process.env.PI_AGENT_DIR,
-    modelProvider: overrides.modelProvider || process.env.PI_MODEL_PROVIDER,
-    modelId: overrides.modelId || process.env.PI_MODEL_ID,
-    thinkingLevel: parseThinkingLevel(overrides.thinkingLevel || process.env.PI_THINKING_LEVEL),
-    promptTimeZone: overrides.promptTimeZone || process.env.PI_PROMPT_TIME_ZONE,
-    promptLocale: overrides.promptLocale || process.env.PI_PROMPT_LOCALE,
-    promptTransform: overrides.promptTransform,
-    startupMessage: overrides.startupMessage ?? readStartupMessageFromEnv(),
-    shutdownOnSignals: overrides.shutdownOnSignals,
-    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")
-  });
-}
-function requireNonEmptyConfigValue(name, value) {
-  const trimmedValue = value.trim();
-  if (!trimmedValue) {
-    throw new Error(`Missing required config value: ${name}`);
-  }
-  return trimmedValue;
-}
-function readStartupMessageFromEnv() {
-  const value = process.env.DISCORD_STARTUP_MESSAGE;
-  if (value === undefined) {
-    return;
-  }
-  const trimmedValue = value.trim();
-  if (!trimmedValue || trimmedValue.toLowerCase() === "false") {
-    return false;
-  }
-  return trimmedValue;
-}
-function parseThinkingLevel(value) {
-  if (!value) {
-    return;
-  }
-  const trimmed = value.trim().toLowerCase();
-  const validLevels = [
-    "off",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh"
-  ];
-  if (validLevels.includes(trimmed)) {
-    return trimmed;
-  }
-  return;
-}
-function defaultPromptTransform(ctx) {
-  return [ctx.now(), ctx.discordMetadata, "", ctx.userMessage()].filter(Boolean).join(`
-`);
 }
-function parseStringArrayFromEnv(key) {
-  const value = process.env[key];
-  if (!value) {
-    return;
-  }
-  return value.split(",").map((id) => id.trim()).filter(Boolean);
-}
-
-// src/discord-gateway-client.ts
-import { Client, Events, GatewayIntentBits, Partials } from "discord.js";
-
-// src/session-registry.ts
-import path3 from "node:path";
-
-// src/prompt-queue.ts
-class PromptQueue {
-  queue = [];
-  running = false;
-  enqueue(task) {
-    return new Promise((resolve, reject) => {
-      this.queue.push(async () => {
-        try {
-          resolve(await task());
-        } catch (error) {
-          reject(error);
+function createGatewayStopHandler(client, agentService, sessionRegistry, config) {
+    let stopped = false;
+    return async () => {
+        if (stopped) {
+            return;
         }
-      });
-      this.runNextTask();
-    });
-  }
-  getSnapshot() {
-    return {
-      pending: this.queue.length,
-      busy: this.running
-    };
-  }
-  runNextTask() {
-    if (this.running) {
-      return;
-    }
-    const next = this.queue.shift();
-    if (!next) {
-      return;
-    }
-    this.running = true;
-    next().finally(() => {
-      this.running = false;
-      this.runNextTask();
-    });
-  }
-}
-
-// src/message-chunker.ts
-import { marked } from "marked";
-var DISCORD_MESSAGE_LIMIT = 2000;
-var SAFE_MESSAGE_LIMIT = 1900;
-function chunkMessage(text, maxChunkSize = SAFE_MESSAGE_LIMIT) {
-  if (text.length <= maxChunkSize) {
-    return [text];
-  }
-  const tokens = marked.lexer(text);
-  const chunks = [];
-  let currentTokens = [];
-  let currentSize = 0;
-  const flushChunk = () => {
-    if (currentTokens.length > 0) {
-      chunks.push(currentTokens.map((t) => t.raw).join("").trim());
-      currentTokens = [];
-      currentSize = 0;
-    }
-  };
-  for (const token of tokens) {
-    const size = token.raw.length;
-    if (currentSize + size > maxChunkSize && currentTokens.length > 0) {
-      flushChunk();
-    }
-    currentTokens.push(token);
-    currentSize += size;
-  }
-  flushChunk();
-  return chunks.map((chunk) => chunk.slice(0, DISCORD_MESSAGE_LIMIT));
-}
-
-// src/discord-replies.ts
-var logger6 = createModuleLogger("discord-replies");
-var DISCORD_MESSAGE_LIMIT2 = 2000;
-var FENCE_OVERHEAD = 8;
-var MAX_CODE_FENCE_CONTENT = DISCORD_MESSAGE_LIMIT2 - FENCE_OVERHEAD;
-function chunkByLines(text, maxSize) {
-  const lines = text.split(`
-`);
-  const chunks = [];
-  let current = "";
-  for (const line of lines) {
-    const candidate = current ? current + `
-` + line : line;
-    if (candidate.length > maxSize) {
-      if (current) {
-        chunks.push(current);
-        current = line;
-      } else {
-        chunks.push(line.slice(0, maxSize));
-        current = line.slice(maxSize);
-      }
-    } else {
-      current = candidate;
-    }
-  }
-  if (current) {
-    chunks.push(current);
-  }
-  return chunks;
-}
-var DEFAULT_WORKING_EMOJI = "⚙️";
-async function addWorkingReaction(message, emoji = DEFAULT_WORKING_EMOJI) {
-  try {
-    await message.react(emoji);
-  } catch (error) {
-    logger6.debug({ messageId: message.id, error }, "failed to add working reaction");
-  }
-}
-async function removeWorkingReaction(message, emoji = DEFAULT_WORKING_EMOJI) {
-  try {
-    const reaction = message.reactions.cache.get(emoji);
-    if (reaction) {
-      await reaction.users.remove(message.client.user);
-    }
-  } catch (error) {
-    logger6.debug({ messageId: message.id, error }, "failed to remove working reaction");
-  }
-}
-async function sendReply(message, text) {
-  const channel = message.channel;
-  if (!channel.isSendable()) {
-    logger6.debug({
-      messageId: message.id
-    }, "reply skipped, channel not sendable");
-    return;
-  }
-  const chunks = chunkMessage(text);
-  const [firstChunk, ...remainingChunks] = chunks;
-  if (!firstChunk) {
-    return;
-  }
-  try {
-    await message.reply(firstChunk);
-    for (const chunk of remainingChunks) {
-      await channel.send(chunk);
-    }
-  } catch (error) {
-    logger6.error({
-      messageId: message.id,
-      error
-    }, "send reply failed");
-  }
-}
-async function sendCommandReply(message, text) {
-  const channel = message.channel;
-  if (!channel.isSendable()) {
-    logger6.debug({
-      messageId: message.id
-    }, "command reply skipped, channel not sendable");
-    return;
-  }
-  const chunks = chunkByLines(text, MAX_CODE_FENCE_CONTENT).map((c) => `\`\`\`
-${c}
-\`\`\``);
-  const [firstChunk, ...remainingChunks] = chunks;
-  if (!firstChunk) {
-    return;
-  }
-  try {
-    await message.reply(firstChunk);
-    for (const chunk of remainingChunks) {
-      await channel.send(chunk);
-    }
-  } catch (error) {
-    logger6.error({
-      messageId: message.id,
-      error
-    }, "send command reply failed");
-  }
-}
-
-// src/session-registry.ts
-function sessionDirForScope(agentDir, scope) {
-  if (scope === "dm") {
-    return path3.join(agentDir, "sessions");
-  }
-  if (scope.startsWith("thread:")) {
-    const threadId = scope.slice(7);
-    return path3.join(agentDir, "sessions", `thread-${threadId}`);
-  }
-  throw new Error(`Unknown session scope: ${scope}`);
-}
-var logger7 = createModuleLogger("session-registry");
-
-class SessionRegistry {
-  scopes = new Map;
-  agentService;
-  constructor(agentService) {
-    this.agentService = agentService;
-  }
-  async getOrCreate(scope) {
-    const existing = this.scopes.get(scope);
-    if (existing) {
-      return { entry: existing, created: false };
-    }
-    const sessionDir = sessionDirForScope(this.agentService.getAgentDir(), scope);
-    const session = await this.agentService.createSession(sessionDir);
-    const promptQueue = new PromptQueue;
-    const entry = {
-      session,
-      promptQueue,
-      createdAt: new Date,
-      workingEmoji: DEFAULT_WORKING_EMOJI
-    };
-    this.scopes.set(scope, entry);
-    logger7.debug({
-      scope,
-      sessionDir,
-      sessionId: session.sessionId
-    }, "scope registered");
-    return { entry, created: true };
-  }
-  async remove(scope) {
-    const entry = this.scopes.get(scope);
-    if (!entry) {
-      return;
-    }
-    logger7.debug({ scope }, "removing scope");
-    await entry.session.abort();
-    entry.session.dispose();
-    this.scopes.delete(scope);
-  }
-  get(scope) {
-    return this.scopes.get(scope);
-  }
-  getScopes() {
-    return Array.from(this.scopes.keys());
-  }
-  async shutdownAll() {
-    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);
-    }
-  }
-}
-
-// src/session-commands.ts
-function getSessionStatusText(session, promptQueue, extras) {
-  const model = session.model ? `${session.model.provider}/${session.model.id}` : "(no model selected)";
-  const contextUsage = session.getContextUsage();
-  const contextLine = contextUsage ? contextUsage.tokens === null || contextUsage.percent === null ? `context: ?/${contextUsage.contextWindow}` : `context: ${contextUsage.tokens}/${contextUsage.contextWindow} (${Math.round(contextUsage.percent)}%)` : "context: (unavailable)";
-  const thinkingInfo = session.supportsThinking() ? `thinking: ${session.thinkingLevel} (available: ${session.getAvailableThinkingLevels().join(", ")})` : "thinking: not supported";
-  const queueStatus = promptQueue.getSnapshot();
-  const lines = [
-    `model: ${model}`,
-    `session-id: ${session.sessionId}`,
-    `session-file: ${session.sessionFile ?? "(none)"}`,
-    `streaming: ${session.isStreaming}`,
-    thinkingInfo,
-    contextLine,
-    `queue-pending: ${queueStatus.pending}`,
-    `queue-busy: ${queueStatus.busy}`
-  ];
-  if (extras?.tools && extras.tools.length > 0) {
-    const toolNames = extras.tools.map((tool) => tool.name);
-    lines.push("", `Tools (${extras.tools.length}): ${toolNames.join(", ")}`);
-  }
-  if (extras?.skillsSummary) {
-    lines.push("", extras.skillsSummary);
-  }
-  if (extras?.extensionsSummary) {
-    lines.push("", extras.extensionsSummary);
-  }
-  return lines.join(`
-`);
-}
-function getEffectiveSession(context) {
-  return context.session ?? context.agentService.getSession();
-}
-function requireEffectiveSession(context) {
-  const session = getEffectiveSession(context);
-  if (!session) {
-    return {
-      handled: true,
-      response: "No active session."
+        stopped = true;
+        logger.info({
+            cwd: config.cwd,
+            agentDir: config.agentDir,
+        }, "stopping discord gateway");
+        client.destroy();
+        await sessionRegistry.shutdownAll();
+        await agentService.shutdown();
     };
-  }
-  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.)",
-      "!reaction - show or set the working reaction emoji",
-      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,
-      response: "!archive is only available in forum threads."
-    };
-  }
-  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.resources.getExtensionsSummary();
-  const skillsSummary = context.agentService.resources.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 = context.agentService.models.getThinkingLevel(effectiveSession.session);
-    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];
-  return {
-    handled: true,
-    response: context.agentService.models.setThinkingLevel(effectiveSession.session, 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.models.getCurrentModelDisplay(effectiveSession.session);
-    const modelList = await context.agentService.models.listModels(effectiveSession.session);
-    return {
-      handled: true,
-      response: `Current model: ${current}
-
-${modelList}`
-    };
-  }
-  const argument = parts.slice(1).join(" ");
-  const slashIndex = argument.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 = argument.substring(0, slashIndex).trim();
-  const modelId = argument.substring(slashIndex + 1).trim();
-  return {
-    handled: true,
-    response: await context.agentService.models.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.resources.reloadResources();
-    })
-  };
-}
-async function handleResetSessionCommand(trimmedInput, context) {
-  if (trimmedInput !== "!reset-session") {
-    return null;
-  }
-  const effectiveSession = requireEffectiveSession(context);
-  if ("handled" in effectiveSession) {
-    return effectiveSession;
-  }
-  let newSession;
-  const response = await context.promptQueue.enqueue(async () => {
-    const previousSessionFile = effectiveSession.session.sessionFile;
-    await effectiveSession.session.abort();
-    effectiveSession.session.dispose();
-    const sessionDir = sessionDirForScope(context.agentService.getAgentDir(), context.scope);
-    newSession = await context.agentService.createSession(sessionDir);
-    return `Started a fresh session. Old session kept at ${previousSessionFile ?? "(unknown path)"}.`;
-  });
-  return {
-    handled: true,
-    response,
-    newSession
-  };
-}
-async function handleReactionCommand(trimmedInput, _context) {
-  if (trimmedInput !== "!reaction" && !trimmedInput.startsWith("!reaction ")) {
-    return null;
-  }
-  const parts = trimmedInput.split(" ");
-  if (parts.length === 1) {
-    return {
-      handled: true,
-      response: `Current working reaction: ${_context.workingEmoji}
-` + `Usage: !reaction <emoji> to change it.
-` + `Examples: !reaction \uD83D\uDD04 or !reaction ⏳`
-    };
-  }
-  const emoji = parts.slice(1).join(" ").trim();
-  if (!emoji) {
-    return {
-      handled: true,
-      response: "Please provide an emoji. Example: !reaction \uD83D\uDD04"
-    };
-  }
-  return {
-    handled: true,
-    workingEmoji: emoji,
-    response: `Working reaction emoji set to ${emoji}`
-  };
-}
-var commandHandlers = [
-  handleHelpCommand,
-  handleArchiveCommand,
-  handleStatusCommand,
-  handleThinkingCommand,
-  handleModelCommand,
-  handleCompactCommand,
-  handleReloadCommand,
-  handleResetSessionCommand,
-  handleReactionCommand
-];
-async function executeSessionCommand(input, context) {
-  const trimmedInput = input.trim();
-  if (!trimmedInput.startsWith("!")) {
-    return { handled: false };
-  }
-  for (const handler of commandHandlers) {
-    const result = await handler(trimmedInput, context);
-    if (result) {
-      return result;
-    }
-  }
-  return {
-    handled: true,
-    response: `Unknown command: ${trimmedInput}. Try !help.`
-  };
-}
-
-// src/discord-attachments.ts
-var logger8 = 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;
-  }
-  const contentType = attachment.contentType;
-  if (!contentType) {
-    return false;
-  }
-  return contentType.startsWith("image/") || OFFICE_MIME_TYPES.has(contentType);
-}
-async function readTextAttachments(message) {
-  const attachments = message.attachments;
-  if (attachments.size === 0) {
-    return [];
-  }
-  const results = [];
-  for (const [, attachment] of attachments) {
-    if (!isSupportedTextAttachment(attachment)) {
-      logger8.debug({ messageId: message.id, filename: attachment.name }, "skipping non-text attachment");
-      continue;
-    }
-    if (attachment.size > MAX_TEXT_ATTACHMENT_SIZE_BYTES) {
-      logger8.warn({
-        messageId: message.id,
-        filename: attachment.name,
-        size: attachment.size
-      }, "attachment too large, skipping");
-      continue;
-    }
-    try {
-      logger8.info({
-        messageId: message.id,
-        filename: attachment.name,
-        size: attachment.size
-      }, "fetching attachment");
-      const response = await fetch(attachment.url);
-      if (!response.ok) {
-        logger8.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) {
-      logger8.error({ messageId: message.id, filename: attachment.name, error }, "error fetching attachment");
-    }
-  }
-  return results;
-}
-async function readMediaAttachments(message) {
-  const attachments = message.attachments;
-  if (attachments.size === 0) {
-    return [];
-  }
-  const results = [];
-  for (const [, attachment] of attachments) {
-    if (!isSupportedMediaAttachment(attachment)) {
-      continue;
-    }
-    if (attachment.size > MAX_MEDIA_ATTACHMENT_SIZE_BYTES) {
-      logger8.warn({
-        messageId: message.id,
-        filename: attachment.name,
-        size: attachment.size
-      }, "media attachment too large, skipping");
-      continue;
-    }
-    try {
-      logger8.info({
-        messageId: message.id,
-        filename: attachment.name,
-        size: attachment.size
-      }, "fetching media attachment");
-      const response = await fetch(attachment.url);
-      if (!response.ok) {
-        logger8.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) {
-      logger8.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, accessConfig) {
-  if (scope === "dm") {
-    return message.author.id === accessConfig.discordAllowedUserId;
-  }
-  if (scope.startsWith("thread:")) {
-    const channel = message.channel;
-    if (!channel.isThread()) {
-      return false;
-    }
-    const parentId = channel.parentId;
-    if (!parentId || !accessConfig.discordAllowedForumChannelIds.includes(parentId)) {
-      return false;
-    }
-    return accessConfig.discordAllowedUserIds.includes(message.author.id);
-  }
-  return false;
-}
-
-// src/media-description.ts
-var logger9 = createModuleLogger("media-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?";
-  }
-  let text = "";
-  try {
-    await session.prompt(promptText, { images: [imageContent] });
-    text = extractLastAssistantText(session);
-  } catch (error) {
-    logger9.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.)";
-  }
-  logger9.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 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";
-}
-
-// src/discord-media-resolution.ts
-var logger10 = createModuleLogger("discord-media-resolution");
-function parseProviderModelId(value) {
-  const trimmed = value.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)
-  };
-}
-function getMediaAttachmentLabel(filename, mimeType) {
-  if (mimeType === "application/pdf") {
-    return `[PDF: ${filename}]`;
-  }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || mimeType === "application/msword") {
-    return `[Word: ${filename}]`;
-  }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" || mimeType === "application/vnd.ms-excel") {
-    return `[Excel: ${filename}]`;
-  }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.presentationml.presentation" || mimeType === "application/vnd.ms-powerpoint") {
-    return `[PowerPoint: ${filename}]`;
-  }
-  return `[Image: ${filename}]`;
-}
-async function resolveMediaAttachmentsForPrompt(mediaAttachments, content, currentModel, config, agentService) {
-  const modelSupportsVision = currentModel?.input.includes("image") ?? false;
-  if (modelSupportsVision) {
-    const names = mediaAttachments.map((media) => media.filename).join(", ");
-    logger10.info({
-      count: mediaAttachments.length,
-      filenames: names,
-      model: currentModel ? `${currentModel.provider}/${currentModel.id}` : "none"
-    }, "passing media natively to vision-capable model");
-    return {
-      content,
-      images: mediaAttachments.map((media) => ({
-        type: "image",
-        data: media.data,
-        mimeType: media.mimeType
-      }))
-    };
-  }
-  if (!config.visionModelId) {
-    const names = mediaAttachments.map((media) => media.filename).join(", ");
-    logger10.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: []
-    };
-  }
-  const parsedVisionModelId = parseProviderModelId(config.visionModelId);
-  if (!parsedVisionModelId) {
-    return { content, images: [] };
-  }
-  const visionModel = agentService.models.findModel(parsedVisionModelId.provider, parsedVisionModelId.modelId);
-  if (!visionModel) {
-    logger10.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: []
+function registerSignalHandlers(stop) {
+    const handleSignal = (signal) => {
+        logger.info({ signal }, "received signal");
+        void stop().finally(() => {
+            logger.info("done");
+            process.exit(0);
+        });
     };
-  }
-  logger10.info({
-    count: mediaAttachments.length,
-    visionModel: `${visionModel.provider}/${visionModel.id}`
-  }, "describing media with vision model");
-  const descriptions = [];
-  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) {
-    return { content, images: [] };
-  }
-  const descriptionPrefix = descriptions.join(`
-
-`);
-  return {
-    content: content ? `${descriptionPrefix}
-
----
-${content}` : descriptionPrefix,
-    images: []
-  };
-}
-
-// src/discord-typing.ts
-var logger11 = 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}` }
+    process.on("SIGINT", () => {
+        handleSignal("SIGINT");
     });
-    if (response.ok) {
-      return;
-    }
-    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 {}
-      logger11.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}` }
-      });
-      logger11.warn({ channelKey }, "[TYPING] retry done");
-      return;
-    }
-    logger11.warn({ channelKey, status: response.status }, "[TYPING] unexpected status");
-  } catch (error) {
-    logger11.error({ channelKey, error }, "[TYPING] FAILED");
-  }
-}
-function startTypingForChannel(channel, channelKey) {
-  const existing = typingIntervals.get(channelKey);
-  if (existing) {
-    existing.refs += 1;
-    return;
-  }
-  logger11.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) {
-    return;
-  }
-  entry.refs -= 1;
-  if (entry.refs <= 0) {
-    clearInterval(entry.interval);
-    typingIntervals.delete(channelKey);
-    return;
-  }
-}
-
-// src/prompt-context.ts
-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 wrapXmlTag(tag, content) {
-  return `<${tag}>${content}</${tag}>`;
-}
-
-// src/discord-message-handler.ts
-var logger12 = createModuleLogger("discord-message-handler");
-function formatDiscordMessageMetadata(message, scope) {
-  const isThread = scope.startsWith("thread:") && message.channel.isThread();
-  const contextEntries = [
-    ["scope", scope === "dm" ? "dm" : "thread"],
-    ["sent_at", message.createdAt.toISOString()],
-    ["sent_at_local", formatDiscordPromptTime(message.createdAt)],
-    ["message_id", message.id],
-    [
-      "author_name",
-      getAuthorDisplayName(message).replace(/\s+/g, " ").trim() || undefined
-    ],
-    ["author_id", message.author.id],
-    [
-      "thread_title",
-      isThread ? (message.channel.name ?? "").replace(/\s+/g, " ").trim() : undefined
-    ],
-    ["thread_id", isThread ? message.channel.id : undefined],
-    [
-      "forum_channel_id",
-      isThread ? message.channel.parentId ?? undefined : undefined
-    ]
-  ].filter((entry) => {
-    return typeof entry[1] === "string" && entry[1].length > 0;
-  });
-  const contextJson = JSON.stringify(Object.fromEntries(contextEntries), null, 2);
-  return `<discord_message_context>${contextJson}</discord_message_context>`;
-}
-async function handleDiscordMessage(message, config, agentService, sessionRegistry, accessConfig) {
-  if (message.author.bot) {
-    return;
-  }
-  if (message.system) {
-    return;
-  }
-  const scope = resolveMessageScope(message);
-  if (scope === null) {
-    logger12.debug({
-      messageId: message.id,
-      channelType: message.channel.type
-    }, "unsupported channel type, ignoring");
-    return;
-  }
-  if (!isAuthorizedMessage(message, scope, accessConfig)) {
-    logger12.debug({
-      messageId: message.id,
-      authorId: message.author.id,
-      scope
-    }, "unauthorized");
-    return;
-  }
-  let content = message.content.trim();
-  const textAttachments = await readTextAttachments(message);
-  if (textAttachments.length > 0) {
-    const attachmentSuffix = textAttachments.map((attachment) => {
-      return `
-
---- Attachment: ${attachment.filename} ---
-${attachment.content}`;
-    }).join("");
-    content = content ? content + attachmentSuffix : textAttachments[0].content;
-  }
-  const mediaAttachments = await readMediaAttachments(message);
-  if (!content && mediaAttachments.length === 0) {
-    logger12.debug({ messageId: message.id }, "ignored empty message (no text or images)");
-    return;
-  }
-  logger12.info({
-    scope,
-    content
-  }, "message received");
-  const channelKey = message.channel.id;
-  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()) {
-    logger12.info({
-      scope,
-      threadName: message.channel.name
-    }, "new thread session");
-  }
-  const commandResult = await executeSessionCommand(content, {
-    agentService,
-    promptQueue,
-    session,
-    scope,
-    workingEmoji: entry.workingEmoji
-  });
-  if (commandResult.handled) {
-    stopTypingForChannel(channelKey);
-    if (commandResult.workingEmoji) {
-      entry.workingEmoji = commandResult.workingEmoji;
-      logger12.info({ scope, emoji: commandResult.workingEmoji }, "working emoji updated");
-    }
-    if (commandResult.newSession) {
-      entry.session = commandResult.newSession;
-      logger12.info({ scope, sessionId: commandResult.newSession.sessionId }, "session replaced");
-    }
-    if (commandResult.archive && scope.startsWith("thread:")) {
-      logger12.info({ scope }, "archiving thread");
-      const archiveChannel = message.channel;
-      if (archiveChannel.isSendable()) {
-        await archiveChannel.send(`\`\`\`
-${commandResult.response ?? "Archiving..."}
-\`\`\``);
-      }
-      try {
-        if (archiveChannel.isThread()) {
-          await archiveChannel.setArchived(true);
-        }
-      } catch (error) {
-        logger12.error({ error }, "failed to archive thread");
-      }
-      await sessionRegistry.remove(scope);
-      return;
-    }
-    logger12.info({
-      messageId: message.id,
-      command: content,
-      hasResponse: Boolean(commandResult.response)
-    }, `command handled: ${content}`);
-    if (commandResult.response) {
-      await sendCommandReply(message, commandResult.response);
-    }
-    return;
-  }
-  if (!message.channel.isSendable()) {
-    stopTypingForChannel(channelKey);
-    logger12.debug({ messageId: message.id }, "channel not sendable");
-    return;
-  }
-  await addWorkingReaction(message, entry.workingEmoji);
-  const queuePosition = promptQueue.getSnapshot().pending;
-  if (queuePosition > 0) {
-    await sendReply(message, `Queued. ${queuePosition} request(s) ahead of this one.`);
-  }
-  let response;
-  try {
-    response = await promptQueue.enqueue(async () => {
-      let promptContent = content;
-      let promptImages;
-      if (mediaAttachments.length > 0) {
-        const resolvedPromptMedia = await resolveMediaAttachmentsForPrompt(mediaAttachments, promptContent, session.model, config, agentService);
-        promptContent = resolvedPromptMedia.content;
-        if (resolvedPromptMedia.images.length > 0) {
-          promptImages = resolvedPromptMedia.images;
-        }
-      }
-      const discordMetadata = formatDiscordMessageMetadata(message, scope);
-      const transformedPrompt = await config.promptTransform({
-        rawContent: promptContent,
-        discordMetadata,
-        now: () => wrapXmlTag("datetime", formatDiscordPromptTime(new Date, {
-          timeZone: config.promptTimeZone,
-          locale: config.promptLocale
-        })),
-        userMessage: () => wrapXmlTag("user_message", promptContent)
-      });
-      return runAgentTurn(session, transformedPrompt, {
-        images: promptImages
-      });
-    });
-  } finally {
-    stopTypingForChannel(channelKey);
-    await removeWorkingReaction(message, entry.workingEmoji);
-  }
-  await sendReply(message, response);
-}
-
-// src/discord-gateway-client.ts
-var logger13 = createModuleLogger("discord-gateway");
-async function startGatewayClient(config, agentService, sessionRegistry, accessConfig) {
-  const client = new Client({
-    intents: [
-      GatewayIntentBits.DirectMessages,
-      GatewayIntentBits.Guilds,
-      GatewayIntentBits.GuildMessages,
-      GatewayIntentBits.MessageContent
-    ],
-    partials: [Partials.Channel]
-  });
-  client.once(Events.ClientReady, async (readyClient) => {
-    logger13.info({ userTag: readyClient.user.tag }, "logged in");
-    if (!accessConfig.startupMessage) {
-      return;
-    }
-    try {
-      const user = await readyClient.users.fetch(accessConfig.discordAllowedUserId);
-      const dmChannel = await user.createDM();
-      await dmChannel.send(accessConfig.startupMessage);
-      logger13.info({
-        userId: accessConfig.discordAllowedUserId
-      }, "sent startup dm");
-    } catch (error) {
-      logger13.error({ error }, "failed to send startup dm");
-    }
-  });
-  client.on(Events.MessageCreate, async (message) => {
-    try {
-      await handleDiscordMessage(message, config, agentService, sessionRegistry, accessConfig);
-    } catch (error) {
-      logger13.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}`;
-    logger13.info({ threadId: thread.id, scope }, "thread deleted");
-    await sessionRegistry.remove(scope);
-  });
-  await client.login(config.discordBotToken);
-  return client;
-}
-
-// src/index.ts
-var logger14 = createModuleLogger("index");
-async function startDiscordGateway(config) {
-  const resolvedConfig = resolveConfig(config);
-  const agentService = new AgentService(resolvedConfig);
-  logger14.info("initializing agent service");
-  await agentService.initialize();
-  logger14.info(agentService.getStatus(), "agent ready");
-  const accessConfig = {
-    discordAllowedUserId: resolvedConfig.discordAllowedUserId,
-    discordAllowedForumChannelIds: resolvedConfig.discordAllowedForumChannelIds,
-    discordAllowedUserIds: resolvedConfig.discordAllowedUserIds,
-    startupMessage: resolvedConfig.startupMessage
-  };
-  const sessionRegistry = new SessionRegistry(agentService);
-  const client = await startGatewayClient(resolvedConfig, agentService, sessionRegistry, accessConfig);
-  const stop = createGatewayStopHandler(client, agentService, sessionRegistry, resolvedConfig);
-  if (resolvedConfig.shutdownOnSignals) {
-    registerSignalHandlers(stop);
-  }
-  return {
-    client,
-    stop,
-    getStatus: () => {
-      return agentService.getStatus();
-    }
-  };
-}
-function createGatewayStopHandler(client, agentService, sessionRegistry, config) {
-  let stopped = false;
-  return async () => {
-    if (stopped) {
-      return;
-    }
-    stopped = true;
-    logger14.info({
-      cwd: config.cwd,
-      agentDir: config.agentDir
-    }, "stopping discord gateway");
-    client.destroy();
-    await sessionRegistry.shutdownAll();
-    await agentService.shutdown();
-  };
-}
-function registerSignalHandlers(stop) {
-  const handleSignal = (signal) => {
-    logger14.info({ signal }, "received signal");
-    stop().finally(() => {
-      logger14.info("done");
-      process.exit(0);
+    process.on("SIGTERM", () => {
+        handleSignal("SIGTERM");
     });
-  };
-  process.on("SIGINT", () => {
-    handleSignal("SIGINT");
-  });
-  process.on("SIGTERM", () => {
-    handleSignal("SIGTERM");
-  });
 }
-export {
-  startDiscordGateway,
-  resolveConfig,
-  loadDiscordGatewayConfigFromEnv,
-  formatDiscordPromptTime
-};