@friendlyrobot/discord-pi-agent 0.16.0 → 0.17.0

package/README.md

@@ -132,7 +132,6 @@ Pretty console logs use:
 
 - `discordAllowedForumChannelIds` — string array of forum channel IDs to respond in
 - `discordAllowedUserIds` — string array of allowed user IDs (defaults to `[discordAllowedUserId]`)
-- `sessionIdleTimeoutMs` — auto-shutdown idle thread sessions (null = never)
 
 ## Env helpers
 
@@ -149,7 +148,6 @@ Pretty console logs use:
 - `DISCORD_STARTUP_MESSAGE`
 - `DISCORD_FORUM_CHANNEL_IDS` — comma-separated forum channel IDs
 - `DISCORD_ALLOWED_USER_IDS` — comma-separated allowed user IDs
-- `DISCORD_SESSION_IDLE_TIMEOUT_MS` — idle timeout in ms
 
 If `PI_AGENT_CWD` is missing it falls back to `process.cwd()`.
 Set `DISCORD_STARTUP_MESSAGE=false` to disable the startup DM.

package/dist/agent-model-service.d.ts

@@ -0,0 +1,20 @@
+import type { AgentSession, ModelRegistry as ModelRegistryType } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ResolvedDiscordGatewayConfig, ThinkingLevel } from "./types";
+export declare class AgentModelService {
+    private readonly config;
+    private readonly modelRegistry;
+    constructor(config: ResolvedDiscordGatewayConfig, modelRegistry: ModelRegistryType);
+    findModel(provider: string, modelId: string): Model<any> | undefined;
+    ensureSessionHasConfiguredModel(session: AgentSession): Promise<void>;
+    listModels(session?: AgentSession | null): Promise<string>;
+    switchModel(provider: string, modelId: string, session: AgentSession): Promise<string>;
+    getCurrentModelDisplay(session?: AgentSession | null): string;
+    getThinkingLevel(session: AgentSession): {
+        current: ThinkingLevel;
+        available: ThinkingLevel[];
+        supported: boolean;
+    };
+    setThinkingLevel(session: AgentSession, level: ThinkingLevel): string;
+    private applyConfiguredThinkingLevelForSession;
+}

package/dist/agent-resource-service.d.ts

@@ -0,0 +1,8 @@
+import type { DefaultResourceLoader } from "@earendil-works/pi-coding-agent";
+export declare class AgentResourceService {
+    private readonly resourceLoader;
+    constructor(resourceLoader: DefaultResourceLoader);
+    getSkillsSummary(): string;
+    getExtensionsSummary(): string;
+    reloadResources(): Promise<string>;
+}

package/dist/agent-service.d.ts

@@ -1,6 +1,7 @@
 import { type AgentSession } from "@earendil-works/pi-coding-agent";
-import type { Model } from "@earendil-works/pi-ai";
-import type { AgentStatus, ResolvedDiscordGatewayConfig, ThinkingLevel } from "./types";
+import { AgentModelService } from "./agent-model-service";
+import { AgentResourceService } from "./agent-resource-service";
+import type { AgentStatus, ResolvedDiscordGatewayConfig } from "./types";
 export declare class AgentService {
     private readonly config;
     private readonly authStorage;
@@ -8,6 +9,8 @@ export declare class AgentService {
     private readonly settingsManager;
     private readonly resourceLoader;
     private session;
+    readonly models: AgentModelService;
+    readonly resources: AgentResourceService;
     constructor(config: ResolvedDiscordGatewayConfig);
     initialize(): Promise<void>;
     getSession(): AgentSession | null;
@@ -18,31 +21,14 @@ export declare class AgentService {
      * 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>;
-    getSkillsSummary(): string;
-    reloadResources(): Promise<string>;
-    getExtensionsSummary(): string;
     compact(): Promise<string>;
     resetSession(): Promise<string>;
     getStatus(): AgentStatus;
     shutdown(): Promise<void>;
     private createOrResumeSession;
     private ensureConfiguredModel;
-    private ensureModelForSession;
     private requireSession;
-    private applyConfiguredThinkingLevel;
-    private applyConfiguredThinkingLevelForSession;
-    listModels(session?: AgentSession | null): Promise<string>;
-    switchModel(provider: string, modelId: string, session?: AgentSession | null): Promise<string>;
-    getCurrentModelDisplay(session?: AgentSession | null): string;
-    getThinkingLevel(): {
-        current: ThinkingLevel;
-        available: ThinkingLevel[];
-        supported: boolean;
-    };
-    setThinkingLevel(level: ThinkingLevel): string;
     private getSessionDir;
 }

package/dist/index.js

@@ -39,6 +39,200 @@ 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
+    };
+  }
+  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(", ")}`;
+    }
+    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;
@@ -57,7 +251,7 @@ function debugPrint(body, title) {
 
 // src/markdown-table-transformer.ts
 import { Lexer } from "marked";
-var logger2 = createModuleLogger("markdown-table-transformer");
+var logger3 = createModuleLogger("markdown-table-transformer");
 var CODE_BLOCK_WRAPPER = "```\n{TABLE}\n```";
 async function transformMarkdownTablesToCodeBlocks(text) {
   const normalized = normalizeCodeFences(text);
@@ -101,7 +295,7 @@ async function formatWithPrettier(text) {
     });
     return formatted.trim();
   } catch (error) {
-    logger2.error({
+    logger3.error({
       error
     }, "Prettier formatting failed");
     return text;
@@ -109,7 +303,7 @@ async function formatWithPrettier(text) {
 }
 
 // src/reply-buffer.ts
-var logger3 = createModuleLogger("reply-buffer");
+var logger4 = createModuleLogger("reply-buffer");
 async function runPromptAndCollectReply(session, prompt, options = {}) {
   let streamedText = "";
   let eventCount = 0;
@@ -126,20 +320,20 @@ async function runPromptAndCollectReply(session, prompt, options = {}) {
     }
     if (event.type === "tool_execution_start") {
       toolCount += 1;
-      logger3.debug({
+      logger4.debug({
         toolName: event.toolName,
         input: event.toolName === "bash" ? event.args.command : event.args
       }, `tool start: [${event.toolName}] `);
     }
     if (event.type === "tool_execution_end") {
-      logger3.debug({
+      logger4.debug({
         toolName: event.toolName,
         isError: event.isError,
         output: truncateForLog(extractToolOutput(event.result))
       }, `tool end: [${event.toolName}]`);
     }
     if (event.type === "agent_end") {
-      logger3.debug("agent end");
+      logger4.debug("agent end");
     }
   });
   try {
@@ -193,7 +387,7 @@ function getLatestAssistantText(messages) {
 }
 
 // src/agent-service.ts
-var logger4 = createModuleLogger("agent-service");
+var logger5 = createModuleLogger("agent-service");
 
 class AgentService {
   config;
@@ -202,6 +396,8 @@ class AgentService {
   settingsManager;
   resourceLoader;
   session = null;
+  models;
+  resources;
   constructor(config) {
     this.config = config;
     this.authStorage = AuthStorage.create(path.join(config.agentDir, "auth.json"));
@@ -212,11 +408,13 @@ class AgentService {
       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 });
-    logger4.info({
+    logger5.info({
       cwd: this.config.cwd,
       agentDir: this.config.agentDir,
       sessionDir: this.getSessionDir(),
@@ -225,7 +423,7 @@ class AgentService {
       thinkingLevel: this.config.thinkingLevel
     }, "config");
     await this.resourceLoader.reload();
-    logger4.info({
+    logger5.info({
       extensions: this.resourceLoader.getExtensions().extensions.map((extension) => extension.path),
       agentsFiles: this.resourceLoader.getAgentsFiles().agentsFiles.map((file) => file.path)
     }, "resources loaded");
@@ -249,12 +447,9 @@ class AgentService {
       sessionManager: SessionManager.inMemory(),
       thinkingLevel: "off"
     });
-    logger4.debug({ sessionId: session.sessionId }, "temporary session created");
+    logger5.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({
@@ -267,70 +462,18 @@ class AgentService {
       sessionManager: SessionManager.continueRecent(this.config.cwd, sessionDir),
       thinkingLevel: this.config.thinkingLevel
     });
-    logger4.debug({
+    logger5.debug({
       sessionDir,
       sessionId: session.sessionId,
       sessionFile: session.sessionFile
     }, "scoped session created");
-    await this.ensureModelForSession(session);
+    await this.models.ensureSessionHasConfiguredModel(session);
     return session;
   }
   async prompt(text) {
     const session = this.requireSession();
     const transformedPrompt = await this.config.promptTransform(text);
-    return runPromptAndCollectReply(session, transformedPrompt, {
-      logPrefix: `[agent:${session.sessionId}]`
-    });
-  }
-  getSkillsSummary() {
-    const result = this.resourceLoader.getSkills();
-    const { skills } = result;
-    if (skills.length === 0) {
-      return "Skills: (none loaded)";
-    }
-    const names = skills.map((s) => s.name);
-    return `Skills (${skills.length}): ${names.join(", ") || "(none)"}`;
-  }
-  async reloadResources() {
-    await this.resourceLoader.reload();
-    const extensions = this.resourceLoader.getExtensions().extensions.map((ext) => ext.path);
-    const skills = this.resourceLoader.getSkills();
-    const skillNames = skills.skills.map((s) => s.name);
-    const agentsFiles = this.resourceLoader.getAgentsFiles().agentsFiles.map((f) => f.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(`
-`);
-  }
-  getExtensionsSummary() {
-    const result = this.resourceLoader.getExtensions();
-    const { extensions, errors } = result;
-    if (extensions.length === 0) {
-      return "Extensions: (none loaded)";
-    }
-    const lines = extensions.map((ext) => {
-      const toolCount = ext.tools.size;
-      const commandCount = ext.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 `  ${ext.path}${summary}`;
-    });
-    const header = `Extensions (${extensions.length}):`;
-    const errorLines = errors.length > 0 ? [
-      `Errors (${errors.length}):`,
-      ...errors.map((e) => `  ${e.path}: ${e.error}`)
-    ] : [];
-    return [header, ...lines, ...errorLines].join(`
-`);
+    return runPromptAndCollectReply(session, transformedPrompt);
   }
   async compact() {
     const session = this.requireSession();
@@ -358,7 +501,7 @@ class AgentService {
   }
   getStatus() {
     const session = this.requireSession();
-    const model = session.model ? `${session.model.provider}/${session.model.id}` : "(no model selected)";
+    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 {
@@ -390,38 +533,14 @@ class AgentService {
       thinkingLevel: this.config.thinkingLevel
     });
     this.session = session;
-    logger4.info({
+    logger5.info({
       sessionId: session.sessionId,
       sessionFile: session.sessionFile,
       restoredModel: session.model ? `${session.model.provider}/${session.model.id}` : null
     }, "session ready");
   }
   async ensureConfiguredModel() {
-    await this.ensureModelForSession(this.requireSession());
-  }
-  async ensureModelForSession(session) {
-    if (session.model) {
-      logger4.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();
-    logger4.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.`);
-    }
-    logger4.info({
-      to: `${desiredModel.provider}/${desiredModel.id}`
-    }, "setting initial session model");
-    await session.setModel(desiredModel);
-    await this.applyConfiguredThinkingLevelForSession(session);
+    await this.models.ensureSessionHasConfiguredModel(this.requireSession());
   }
   requireSession() {
     if (!this.session) {
@@ -429,103 +548,10 @@ class AgentService {
     }
     return this.session;
   }
-  async applyConfiguredThinkingLevel() {
-    await this.applyConfiguredThinkingLevelForSession(this.requireSession());
-  }
-  async applyConfiguredThinkingLevelForSession(session) {
-    if (session.supportsThinking()) {
-      const available = session.getAvailableThinkingLevels();
-      if (available.includes(this.config.thinkingLevel)) {
-        session.setThinkingLevel(this.config.thinkingLevel);
-        logger4.debug({
-          level: this.config.thinkingLevel
-        }, "thinking level applied");
-      } else {
-        logger4.debug({
-          requested: this.config.thinkingLevel,
-          available
-        }, "thinking level not available for model");
-      }
-    }
-  }
-  async listModels(session) {
-    const effectiveSession = session ?? this.session;
-    const availableModels = await this.modelRegistry.getAvailable();
-    const currentDisplay = effectiveSession?.model ? `${effectiveSession.model.provider}/${effectiveSession.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 effectiveSession = session ?? this.requireSession();
-    const model = this.modelRegistry.find(provider, modelId);
-    if (!model) {
-      const availableModels = await this.modelRegistry.getAvailable();
-      const matches = availableModels.filter((m) => {
-        return m.provider === provider;
-      }).map((m) => `${m.provider}/${m.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(effectiveSession.model, model)) {
-      return `Already using ${provider}/${modelId}.`;
-    }
-    await effectiveSession.setModel(model);
-    await this.applyConfiguredThinkingLevelForSession(effectiveSession);
-    const thinkingInfo = effectiveSession.supportsThinking() ? ` (thinking: ${effectiveSession.thinkingLevel})` : "";
-    return `Switched to ${provider}/${modelId}${thinkingInfo}.`;
-  }
-  getCurrentModelDisplay(session) {
-    const effectiveSession = session ?? this.session;
-    if (!effectiveSession?.model) {
-      return "(no model selected)";
-    }
-    return `${effectiveSession.model.provider}/${effectiveSession.model.id}`;
-  }
-  getThinkingLevel() {
-    const session = this.requireSession();
-    if (!session.supportsThinking()) {
-      return { current: "off", available: [], supported: false };
-    }
-    return {
-      current: session.thinkingLevel,
-      available: session.getAvailableThinkingLevels(),
-      supported: true
-    };
-  }
-  setThinkingLevel(level) {
-    const session = this.requireSession();
-    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(", ")}`;
-    }
-    session.setThinkingLevel(level);
-    return `Thinking level set to "${level}".`;
-  }
   getSessionDir() {
     return path.join(this.config.agentDir, "sessions");
   }
 }
-function isSameModel(currentModel, desiredModel) {
-  if (!currentModel) {
-    return false;
-  }
-  return currentModel.provider === desiredModel.provider && currentModel.id === desiredModel.id;
-}
 
 // src/config.ts
 import path2 from "node:path";
@@ -547,8 +573,7 @@ function resolveConfig(config) {
     shutdownOnSignals: config.shutdownOnSignals ?? true,
     visionModelId: config.visionModelId?.trim() || null,
     discordAllowedForumChannelIds: config.discordAllowedForumChannelIds ?? [],
-    discordAllowedUserIds: config.discordAllowedUserIds ?? [discordAllowedUserId],
-    sessionIdleTimeoutMs: config.sessionIdleTimeoutMs ?? null
+    discordAllowedUserIds: config.discordAllowedUserIds ?? [discordAllowedUserId]
   };
 }
 function loadDiscordGatewayConfigFromEnv(overrides = {}) {
@@ -568,8 +593,7 @@ function loadDiscordGatewayConfigFromEnv(overrides = {}) {
     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"),
-    sessionIdleTimeoutMs: overrides.sessionIdleTimeoutMs ?? parseOptionalIntFromEnv("DISCORD_SESSION_IDLE_TIMEOUT_MS") ?? undefined
+    discordAllowedUserIds: overrides.discordAllowedUserIds ?? parseStringArrayFromEnv("DISCORD_ALLOWED_USER_IDS")
   });
 }
 function readRequiredValue(name, value) {
@@ -618,14 +642,6 @@ function parseStringArrayFromEnv(key) {
   }
   return value.split(",").map((id) => id.trim()).filter(Boolean);
 }
-function parseOptionalIntFromEnv(key) {
-  const value = process.env[key];
-  if (!value) {
-    return;
-  }
-  const parsed = parseInt(value, 10);
-  return Number.isNaN(parsed) ? undefined : parsed;
-}
 
 // src/discord-gateway-client.ts
 import {
@@ -665,16 +681,6 @@ function getSessionStatusText(session, promptQueue, extras) {
   return lines.join(`
 `);
 }
-function getThinkingInfo(session) {
-  if (!session.supportsThinking()) {
-    return { current: "off", available: [], supported: false };
-  }
-  return {
-    current: session.thinkingLevel,
-    available: session.getAvailableThinkingLevels(),
-    supported: true
-  };
-}
 function getEffectiveSession(context) {
   return context.session ?? context.agentService.getSession();
 }
@@ -736,8 +742,8 @@ async function handleStatusCommand(trimmedInput, context) {
     return effectiveSession;
   }
   const tools = effectiveSession.session.getAllTools();
-  const extensionsSummary = context.agentService.getExtensionsSummary();
-  const skillsSummary = context.agentService.getSkillsSummary();
+  const extensionsSummary = context.agentService.resources.getExtensionsSummary();
+  const skillsSummary = context.agentService.resources.getSkillsSummary();
   return {
     handled: true,
     response: getSessionStatusText(effectiveSession.session, context.promptQueue, {
@@ -757,7 +763,7 @@ async function handleThinkingCommand(trimmedInput, context) {
   }
   const parts = trimmedInput.split(" ");
   if (parts.length === 1) {
-    const info = getThinkingInfo(effectiveSession.session);
+    const info = context.agentService.models.getThinkingLevel(effectiveSession.session);
     if (!info.supported) {
       return {
         handled: true,
@@ -775,23 +781,9 @@ async function handleThinkingCommand(trimmedInput, context) {
     };
   }
   const requestedLevel = parts[1];
-  if (!effectiveSession.session.supportsThinking()) {
-    return {
-      handled: true,
-      response: "Current model does not support reasoning/thinking."
-    };
-  }
-  const available = effectiveSession.session.getAvailableThinkingLevels();
-  if (!available.includes(requestedLevel)) {
-    return {
-      handled: true,
-      response: `Invalid thinking level "${requestedLevel}" for current model. Available: ${available.join(", ")}`
-    };
-  }
-  effectiveSession.session.setThinkingLevel(requestedLevel);
   return {
     handled: true,
-    response: `Thinking level set to "${requestedLevel}".`
+    response: context.agentService.models.setThinkingLevel(effectiveSession.session, requestedLevel)
   };
 }
 async function handleModelCommand(trimmedInput, context) {
@@ -804,8 +796,8 @@ async function handleModelCommand(trimmedInput, context) {
   }
   const parts = trimmedInput.split(" ");
   if (parts.length === 1) {
-    const current = context.agentService.getCurrentModelDisplay(effectiveSession.session);
-    const modelList = await context.agentService.listModels(effectiveSession.session);
+    const current = context.agentService.models.getCurrentModelDisplay(effectiveSession.session);
+    const modelList = await context.agentService.models.listModels(effectiveSession.session);
     return {
       handled: true,
       response: `Current model: ${current}
@@ -827,7 +819,7 @@ ${modelList}`
   const modelId = argument.substring(slashIndex + 1).trim();
   return {
     handled: true,
-    response: await context.agentService.switchModel(provider, modelId, effectiveSession.session)
+    response: await context.agentService.models.switchModel(provider, modelId, effectiveSession.session)
   };
 }
 async function handleCompactCommand(trimmedInput, context) {
@@ -853,7 +845,7 @@ async function handleReloadCommand(trimmedInput, context) {
   return {
     handled: true,
     response: await context.promptQueue.enqueue(async () => {
-      return context.agentService.reloadResources();
+      return context.agentService.resources.reloadResources();
     })
   };
 }
@@ -907,7 +899,7 @@ async function executeCommand(input, context) {
 }
 
 // src/discord-attachments.ts
-var logger5 = createModuleLogger("discord-attachments");
+var logger6 = createModuleLogger("discord-attachments");
 var TEXT_ATTACHMENT_EXTENSIONS = [
   ".txt",
   ".md",
@@ -969,11 +961,11 @@ async function readTextAttachments(message) {
   const results = [];
   for (const [, attachment] of attachments) {
     if (!isSupportedTextAttachment(attachment)) {
-      logger5.debug({ messageId: message.id, filename: attachment.name }, "skipping non-text attachment");
+      logger6.debug({ messageId: message.id, filename: attachment.name }, "skipping non-text attachment");
       continue;
     }
     if (attachment.size > MAX_TEXT_ATTACHMENT_SIZE_BYTES) {
-      logger5.warn({
+      logger6.warn({
         messageId: message.id,
         filename: attachment.name,
         size: attachment.size
@@ -981,14 +973,14 @@ async function readTextAttachments(message) {
       continue;
     }
     try {
-      logger5.info({
+      logger6.info({
         messageId: message.id,
         filename: attachment.name,
         size: attachment.size
       }, "fetching attachment");
       const response = await fetch(attachment.url);
       if (!response.ok) {
-        logger5.warn({
+        logger6.warn({
           messageId: message.id,
           filename: attachment.name,
           status: response.status
@@ -998,7 +990,7 @@ async function readTextAttachments(message) {
       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;
@@ -1014,7 +1006,7 @@ async function readMediaAttachments(message) {
       continue;
     }
     if (attachment.size > MAX_MEDIA_ATTACHMENT_SIZE_BYTES) {
-      logger5.warn({
+      logger6.warn({
         messageId: message.id,
         filename: attachment.name,
         size: attachment.size
@@ -1022,14 +1014,14 @@ async function readMediaAttachments(message) {
       continue;
     }
     try {
-      logger5.info({
+      logger6.info({
         messageId: message.id,
         filename: attachment.name,
         size: attachment.size
       }, "fetching media attachment");
       const response = await fetch(attachment.url);
       if (!response.ok) {
-        logger5.warn({
+        logger6.warn({
           messageId: message.id,
           filename: attachment.name,
           status: response.status
@@ -1043,7 +1035,7 @@ async function readMediaAttachments(message) {
         mimeType: attachment.contentType ?? "application/octet-stream"
       });
     } catch (error) {
-      logger5.error({ messageId: message.id, filename: attachment.name, error }, "error fetching media attachment");
+      logger6.error({ messageId: message.id, filename: attachment.name, error }, "error fetching media attachment");
     }
   }
   return results;
@@ -1113,13 +1105,13 @@ function chunkMessage(text, maxChunkSize = SAFE_MESSAGE_LIMIT) {
 }
 
 // src/discord-replies.ts
-var logger6 = createModuleLogger("discord-replies");
+var logger7 = createModuleLogger("discord-replies");
 var WORKING_EMOJI = "⚙️";
 async function addWorkingReaction(message) {
   try {
     await message.react(WORKING_EMOJI);
   } catch (error) {
-    logger6.debug({ messageId: message.id, error }, "failed to add working reaction");
+    logger7.debug({ messageId: message.id, error }, "failed to add working reaction");
   }
 }
 async function removeWorkingReaction(message) {
@@ -1129,13 +1121,13 @@ async function removeWorkingReaction(message) {
       await reaction.users.remove(message.client.user);
     }
   } catch (error) {
-    logger6.debug({ messageId: message.id, error }, "failed to remove working reaction");
+    logger7.debug({ messageId: message.id, error }, "failed to remove working reaction");
   }
 }
 async function sendReply(message, text) {
   const channel = message.channel;
   if (!channel.isSendable()) {
-    logger6.debug({
+    logger7.debug({
       messageId: message.id
     }, "reply skipped, channel not sendable");
     return;
@@ -1151,7 +1143,7 @@ async function sendReply(message, text) {
       await channel.send(chunk);
     }
   } catch (error) {
-    logger6.error({
+    logger7.error({
       messageId: message.id,
       error
     }, "send reply failed");
@@ -1159,7 +1151,7 @@ async function sendReply(message, text) {
 }
 
 // src/image-description.ts
-var logger7 = createModuleLogger("image-description");
+var logger8 = createModuleLogger("image-description");
 async function describeMediaAttachment(agentService, imageData, mimeType, userText, visionModel) {
   const session = await agentService.createTemporarySession();
   await session.setModel(visionModel);
@@ -1180,7 +1172,7 @@ async function describeMediaAttachment(agentService, imageData, mimeType, userTe
     await session.prompt(promptText, { images: [imageContent] });
     text = extractLastAssistantText(session);
   } catch (error) {
-    logger7.error({ error, mimeType }, "vision model prompt failed");
+    logger8.error({ error, mimeType }, "vision model prompt failed");
     text = "(Vision model failed to process the file.)";
   } finally {
     session.dispose();
@@ -1188,7 +1180,7 @@ async function describeMediaAttachment(agentService, imageData, mimeType, userTe
   if (!text) {
     return "(Vision model returned no description.)";
   }
-  logger7.debug({ textLength: text.length, mimeType }, "media described");
+  logger8.debug({ textLength: text.length, mimeType }, "media described");
   return text;
 }
 function extractLastAssistantText(session) {
@@ -1224,7 +1216,7 @@ function isAssistantMessage(msg) {
 }
 
 // src/discord-media-resolution.ts
-var logger8 = createModuleLogger("discord-media-resolution");
+var logger9 = createModuleLogger("discord-media-resolution");
 function parseProviderModelId(value) {
   const trimmed = value.trim();
   if (!trimmed) {
@@ -1258,7 +1250,7 @@ async function resolveMediaAttachmentsForPrompt(mediaAttachments, content, curre
   const modelSupportsVision = currentModel?.input.includes("image") ?? false;
   if (modelSupportsVision) {
     const names = mediaAttachments.map((media) => media.filename).join(", ");
-    logger8.info({
+    logger9.info({
       count: mediaAttachments.length,
       filenames: names,
       model: currentModel ? `${currentModel.provider}/${currentModel.id}` : "none"
@@ -1274,7 +1266,7 @@ async function resolveMediaAttachmentsForPrompt(mediaAttachments, content, curre
   }
   if (!config.visionModelId) {
     const names = mediaAttachments.map((media) => media.filename).join(", ");
-    logger8.info({ filenames: names }, "media attachments received but vision model not configured");
+    logger9.info({ filenames: names }, "media attachments received but vision model not configured");
     const note = `
 
 [User sent media attachment(s): ${names}]
@@ -1288,9 +1280,9 @@ async function resolveMediaAttachmentsForPrompt(mediaAttachments, content, curre
   if (!parsedVisionModelId) {
     return { content, images: [] };
   }
-  const visionModel = agentService.findModel(parsedVisionModelId.provider, parsedVisionModelId.modelId);
+  const visionModel = agentService.models.findModel(parsedVisionModelId.provider, parsedVisionModelId.modelId);
   if (!visionModel) {
-    logger8.warn({ visionModelId: config.visionModelId }, "vision model not found in registry");
+    logger9.warn({ visionModelId: config.visionModelId }, "vision model not found in registry");
     const names = mediaAttachments.map((media) => media.filename).join(", ");
     const note = `
 
@@ -1301,7 +1293,7 @@ async function resolveMediaAttachmentsForPrompt(mediaAttachments, content, curre
       images: []
     };
   }
-  logger8.info({
+  logger9.info({
     count: mediaAttachments.length,
     visionModel: `${visionModel.provider}/${visionModel.id}`
   }, "describing media with vision model");
@@ -1328,7 +1320,7 @@ ${content}` : descriptionPrefix,
 }
 
 // src/discord-typing.ts
-var logger9 = createModuleLogger("discord-typing");
+var logger10 = createModuleLogger("discord-typing");
 var TYPING_INTERVAL_MS = 9000;
 var typingIntervals = new Map;
 async function sendTypingSafe(channel, channelKey) {
@@ -1340,7 +1332,7 @@ async function sendTypingSafe(channel, channelKey) {
       headers: { Authorization: `Bot ${token}` }
     });
     if (response.ok) {
-      logger9.debug("[TYPING] STATUS UPDATED OK");
+      logger10.debug("[TYPING] STATUS UPDATED OK");
       return;
     }
     if (response.status === 429) {
@@ -1352,28 +1344,28 @@ async function sendTypingSafe(channel, channelKey) {
           retryMs = parsed.retry_after * 1000 + 500;
         }
       } catch {}
-      logger9.warn({ channelKey, retryMs, response: body }, `[TYPING] 429, retrying after ${retryMs}ms delay`);
+      logger10.warn({ channelKey, retryMs, response: body }, `[TYPING] 429, retrying after ${retryMs}ms delay`);
       await new Promise((resolve) => setTimeout(resolve, retryMs));
       await fetch(url, {
         method: "POST",
         headers: { Authorization: `Bot ${token}` }
       });
-      logger9.info({ channelKey }, "[TYPING] retry done");
+      logger10.info({ channelKey }, "[TYPING] retry done");
       return;
     }
-    logger9.warn({ channelKey, status: response.status }, "[TYPING] unexpected status");
+    logger10.warn({ channelKey, status: response.status }, "[TYPING] unexpected status");
   } catch (error) {
-    logger9.warn({ channelKey, error }, "[TYPING] FAILED");
+    logger10.warn({ channelKey, error }, "[TYPING] FAILED");
   }
 }
 function startTypingForChannel(channel, channelKey) {
   const existing = typingIntervals.get(channelKey);
   if (existing) {
     existing.refs += 1;
-    logger9.debug({ channelKey, refs: existing.refs }, "[TYPING] ref++ (reusing existing interval)");
+    logger10.debug({ channelKey, refs: existing.refs }, "[TYPING] ref++ (reusing existing interval)");
     return;
   }
-  logger9.debug("[TYPING] started new interval");
+  logger10.debug("[TYPING] started new interval");
   sendTypingSafe(channel, channelKey);
   const interval = setInterval(() => {
     sendTypingSafe(channel, channelKey);
@@ -1383,17 +1375,17 @@ function startTypingForChannel(channel, channelKey) {
 function stopTypingForChannel(channelKey) {
   const entry = typingIntervals.get(channelKey);
   if (!entry) {
-    logger9.debug({ channelKey }, "[TYPING] stop called but no entry found");
+    logger10.debug({ channelKey }, "[TYPING] stop called but no entry found");
     return;
   }
   entry.refs -= 1;
   if (entry.refs <= 0) {
     clearInterval(entry.interval);
     typingIntervals.delete(channelKey);
-    logger9.debug("[TYPING] interval cleared (refs hit 0)");
+    logger10.debug("[TYPING] interval cleared (refs hit 0)");
     return;
   }
-  logger9.debug("[TYPING] ref-- (interval still active)");
+  logger10.debug("[TYPING] ref-- (interval still active)");
 }
 
 // src/prompt-context.ts
@@ -1445,7 +1437,7 @@ function normalizeContextValue(value) {
 }
 
 // src/discord-message-handler.ts
-var logger10 = createModuleLogger("discord-message-handler");
+var logger11 = createModuleLogger("discord-message-handler");
 function buildDiscordPromptContent(message, scope, content, config) {
   const isThread = scope.startsWith("thread:") && message.channel.isThread();
   return buildDiscordMessageContextPrompt(content, {
@@ -1465,23 +1457,23 @@ function buildDiscordPromptContent(message, scope, content, config) {
 }
 async function handleDiscordMessage(message, config, agentService, sessionRegistry, authConfig) {
   if (message.author.bot) {
-    logger10.debug("ignored bot message");
+    logger11.debug("ignored bot message");
     return;
   }
   if (message.system) {
-    logger10.debug({ messageId: message.id }, "ignored system message");
+    logger11.debug({ messageId: message.id }, "ignored system message");
     return;
   }
   const scope = resolveMessageScope(message);
   if (scope === null) {
-    logger10.debug({
+    logger11.debug({
       messageId: message.id,
       channelType: message.channel.type
     }, "unsupported channel type, ignoring");
     return;
   }
   if (!isAuthorizedMessage(message, scope, authConfig)) {
-    logger10.debug({
+    logger11.debug({
       messageId: message.id,
       authorId: message.author.id,
       scope
@@ -1501,10 +1493,10 @@ ${attachment.content}`;
   }
   const mediaAttachments = await readMediaAttachments(message);
   if (!content && mediaAttachments.length === 0) {
-    logger10.debug({ messageId: message.id }, "ignored empty message (no text or images)");
+    logger11.debug({ messageId: message.id }, "ignored empty message (no text or images)");
     return;
   }
-  logger10.info({
+  logger11.info({
     direction: "IN",
     scope,
     messageId: message.id,
@@ -1519,7 +1511,7 @@ ${attachment.content}`;
   const { entry, created } = await sessionRegistry.getOrCreate(scope);
   const { session, promptQueue } = entry;
   if (created && scope.startsWith("thread:") && message.channel.isThread()) {
-    logger10.info({
+    logger11.info({
       scope,
       threadName: message.channel.name
     }, "new thread session");
@@ -1532,7 +1524,7 @@ ${attachment.content}`;
   if (commandResult.handled) {
     stopTypingForChannel(channelKey);
     if (commandResult.archive && scope.startsWith("thread:")) {
-      logger10.info({ scope }, "archiving thread");
+      logger11.info({ scope }, "archiving thread");
       const archiveChannel = message.channel;
       if (archiveChannel.isSendable()) {
         await archiveChannel.send(commandResult.response ?? "Archiving...");
@@ -1542,12 +1534,12 @@ ${attachment.content}`;
           await archiveChannel.setArchived(true);
         }
       } catch (error) {
-        logger10.error({ error }, "failed to archive thread");
+        logger11.error({ error }, "failed to archive thread");
       }
       await sessionRegistry.remove(scope);
       return;
     }
-    logger10.info({
+    logger11.info({
       messageId: message.id,
       command: content,
       hasResponse: Boolean(commandResult.response)
@@ -1559,7 +1551,7 @@ ${attachment.content}`;
   }
   if (!message.channel.isSendable()) {
     stopTypingForChannel(channelKey);
-    logger10.debug({ messageId: message.id }, "channel not sendable");
+    logger11.debug({ messageId: message.id }, "channel not sendable");
     return;
   }
   await addWorkingReaction(message);
@@ -1582,7 +1574,6 @@ ${attachment.content}`;
       const wrappedContent = buildDiscordPromptContent(message, scope, promptContent, config);
       const transformedPrompt = await config.promptTransform(wrappedContent);
       return runPromptAndCollectReply(session, transformedPrompt, {
-        logPrefix: `[agent:${session.sessionId}]`,
         images: promptImages
       });
     });
@@ -1594,7 +1585,7 @@ ${attachment.content}`;
 }
 
 // src/discord-gateway-client.ts
-var logger11 = createModuleLogger("discord-gateway");
+var logger12 = createModuleLogger("discord-gateway");
 async function startGatewayClient(config, agentService, sessionRegistry, authConfig) {
   const client = new Client({
     intents: [
@@ -1606,7 +1597,7 @@ async function startGatewayClient(config, agentService, sessionRegistry, authCon
     partials: [Partials.Channel]
   });
   client.once(Events.ClientReady, async (readyClient) => {
-    logger11.info({ userTag: readyClient.user.tag }, "logged in");
+    logger12.info({ userTag: readyClient.user.tag }, "logged in");
     if (!authConfig.startupMessage) {
       return;
     }
@@ -1614,24 +1605,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);
-      logger11.info({
+      logger12.info({
         userId: authConfig.discordAllowedUserId
       }, "sent startup dm");
     } catch (error) {
-      logger11.error({ error }, "failed to send startup dm");
+      logger12.error({ error }, "failed to send startup dm");
     }
   });
   client.on(Events.MessageCreate, async (message) => {
     try {
       await handleDiscordMessage(message, config, agentService, sessionRegistry, authConfig);
     } catch (error) {
-      logger11.error({ error, direction: "IN" }, "message handling failed");
+      logger12.error({ error, direction: "IN" }, "message handling failed");
       await sendReply(message, "The bot hit an error while handling that message.");
     }
   });
   client.on(Events.ThreadDelete, async (thread) => {
     const scope = `thread:${thread.id}`;
-    logger11.info({ threadId: thread.id, scope }, "thread deleted");
+    logger12.info({ threadId: thread.id, scope }, "thread deleted");
     await sessionRegistry.remove(scope);
   });
   await client.login(config.discordBotToken);
@@ -1690,7 +1681,7 @@ function sessionDirForScope(agentDir, scope) {
   }
   throw new Error(`Unknown session scope: ${scope}`);
 }
-var logger12 = createModuleLogger("session-registry");
+var logger13 = createModuleLogger("session-registry");
 
 class SessionRegistry {
   scopes = new Map;
@@ -1712,7 +1703,7 @@ class SessionRegistry {
       createdAt: new Date
     };
     this.scopes.set(scope, entry);
-    logger12.debug({
+    logger13.debug({
       scope,
       sessionDir,
       sessionId: session.sessionId
@@ -1724,7 +1715,7 @@ class SessionRegistry {
     if (!entry) {
       return;
     }
-    logger12.debug({ scope }, "removing scope");
+    logger13.debug({ scope }, "removing scope");
     await entry.session.abort();
     entry.session.dispose();
     this.scopes.delete(scope);
@@ -1736,7 +1727,7 @@ class SessionRegistry {
     return Array.from(this.scopes.keys());
   }
   async shutdownAll() {
-    logger12.info({ count: this.scopes.size }, "shutting down all scopes");
+    logger13.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);
@@ -1745,13 +1736,13 @@ class SessionRegistry {
 }
 
 // src/index.ts
-var logger13 = createModuleLogger("index");
+var logger14 = createModuleLogger("index");
 async function startDiscordGateway(config) {
   const resolvedConfig = resolveConfig(config);
   const agentService = new AgentService(resolvedConfig);
-  logger13.info("initializing agent service");
+  logger14.info("initializing agent service");
   await agentService.initialize();
-  logger13.info(agentService.getStatus(), "agent ready");
+  logger14.info(agentService.getStatus(), "agent ready");
   const authConfig = {
     discordAllowedUserId: resolvedConfig.discordAllowedUserId,
     discordAllowedForumChannelIds: resolvedConfig.discordAllowedForumChannelIds,
@@ -1779,7 +1770,7 @@ function createGatewayStopHandler(client, agentService, sessionRegistry, config)
       return;
     }
     stopped = true;
-    logger13.info({
+    logger14.info({
       cwd: config.cwd,
       agentDir: config.agentDir
     }, "stopping discord gateway");
@@ -1790,9 +1781,9 @@ function createGatewayStopHandler(client, agentService, sessionRegistry, config)
 }
 function registerSignalHandlers(stop) {
   const handleSignal = (signal) => {
-    logger13.info({ signal }, "received signal");
+    logger14.info({ signal }, "received signal");
     stop().finally(() => {
-      logger13.info("done");
+      logger14.info("done");
       process.exit(0);
     });
   };

package/dist/reply-buffer.d.ts

@@ -1,7 +1,6 @@
 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 runPromptAndCollectReply(session: AgentSession, prompt: string, options?: CollectReplyOptions): Promise<string>;

package/dist/types.d.ts

@@ -25,8 +25,6 @@ export type DiscordGatewayConfig = {
     discordAllowedForumChannelIds?: string[];
     /** Which users can interact in forum threads (defaults to [discordAllowedUserId]). */
     discordAllowedUserIds?: string[];
-    /** Auto-shutdown idle thread sessions after this many ms. */
-    sessionIdleTimeoutMs?: number;
 };
 export type ResolvedDiscordGatewayConfig = {
     discordBotToken: string;
@@ -45,7 +43,6 @@ export type ResolvedDiscordGatewayConfig = {
     visionModelId: string | null;
     discordAllowedForumChannelIds: string[];
     discordAllowedUserIds: string[];
-    sessionIdleTimeoutMs: number | null;
 };
 export type ContextUsageStatus = {
     tokens: number | null;

package/package.json

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