@0xmaxma/claude-gateway 1.7.10 → 1.8.1

package/dist/agent/runner.js

@@ -51,6 +51,7 @@ const slack_client_1 = require("../api/slack-client");
 const markdown_1 = require("../telegram/markdown");
 const skills_1 = require("../skills");
 const builtin_commands_1 = require("./builtin-commands");
+const model_catalog_1 = require("./model-catalog");
 const safe_mode_1 = require("./safe-mode");
 const recovery_executor_1 = require("./recovery-executor");
 const recovery_policy_1 = require("./recovery-policy");
@@ -434,7 +435,7 @@ class AgentRunner extends events_1.EventEmitter {
                     // Check if this is a built-in channel command
                     const trimmedContent = content.trim();
                     if ((0, builtin_commands_1.isBuiltinCommand)(trimmedContent, channelSource)) {
-                        this.handleSessionCommand(chatId, trimmedContent)
+                        this.handleSessionCommand(chatId, trimmedContent, meta)
                             .then(() => this.writeTypingDone(chatId))
                             .catch((err) => {
                             this.logger.error('Session command failed', { error: err.message });
@@ -685,8 +686,24 @@ class AgentRunner extends events_1.EventEmitter {
             return;
         }
         if (command === 'get_models') {
-            const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-            respond({ models: availableModels.map(m => ({ id: m.id, label: m.label })) });
+            // Live catalog first, static list as the fallback (issue #409). The
+            // picker is a UI action, so a slow or unreachable catalog must not hang
+            // it — fetchModelCatalog is bounded and never rejects.
+            void this.availableModels()
+                .then((availableModels) => {
+                const configuredIds = new Set((this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS).map(m => m.id));
+                const configured = availableModels.filter(m => configuredIds.has(m.id));
+                const live = availableModels.filter(m => !configuredIds.has(m.id));
+                respond({
+                    models: availableModels.map(m => ({ id: m.id, label: m.label })),
+                    configuredModels: configured.map(m => ({ id: m.id, label: m.label })),
+                    liveModels: live.map(m => ({ id: m.id, label: m.label })),
+                });
+            })
+                // Without this the request would hang and the picker with it: the
+                // receiver is blocked on this response. Every other async branch in
+                // this handler answers on rejection too.
+                .catch((err) => respond({ success: false, error: String(err) }, 500));
             return;
         }
         // `/cli` webview terminal viewer — create a pairing on behalf of an
@@ -735,15 +752,7 @@ class AgentRunner extends events_1.EventEmitter {
                 respond({ success: false, error: err.message });
                 return;
             }
-            let restarted = false;
-            const restartPromises = [];
-            for (const [key, session] of this.sessions) {
-                if (session.source !== 'api') {
-                    restarted = true;
-                    restartPromises.push(this.restartProcess(key));
-                }
-            }
-            await Promise.all(restartPromises);
+            const restarted = await this.restartChannelSessions();
             respond({ success: true, model: newModel, restarted });
             return;
         }
@@ -788,9 +797,7 @@ class AgentRunner extends events_1.EventEmitter {
                     return respond({ success: true, text: 'No active session found.' });
                 }
                 const effectiveModel = this.agentConfig.claude.model;
-                const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-                const modelConfig = availableModels.find(m => m.id === effectiveModel);
-                const contextWindow = modelConfig?.contextWindow ?? 200000;
+                const contextWindow = await this.contextWindowFor(effectiveModel);
                 const contextTokens = meta.lastInputTokens ?? 0;
                 const usedPct = Math.round((contextTokens / contextWindow) * 100);
                 let msgs;
@@ -1879,7 +1886,7 @@ class AgentRunner extends events_1.EventEmitter {
     /**
      * Dispatch a session management command to the appropriate handler.
      */
-    async handleSessionCommand(chatId, content) {
+    async handleSessionCommand(chatId, content, meta = {}) {
         const agentId = this.agentConfig.id;
         if (content.startsWith('/sessions')) {
             await this.handleCommandSessions(agentId, chatId);
@@ -1901,10 +1908,88 @@ class AgentRunner extends events_1.EventEmitter {
             const name = content.replace('/rename', '').trim();
             await this.handleCommandRename(agentId, chatId, name);
         }
+        else if (content.startsWith('/models')) {
+            await this.handleCommandModels(chatId);
+        }
+        else if (content.startsWith('/model')) {
+            await this.handleCommandModel(chatId, content.replace('/model', '').trim(), meta);
+        }
         else if (content.startsWith('/stop')) {
             await this.handleCommandStop(chatId);
         }
     }
+    /**
+     * /models — the model picker for channels without an inline keyboard.
+     *
+     * Telegram never reaches this: its receiver answers `/models` itself with a
+     * button keyboard and does not forward the message. Discord and LINE have no
+     * picker of their own, so they get the list as text plus the command that
+     * selects from it (issue #409).
+     *
+     * A channel listed in BUILTIN_COMMANDS but missing a branch here is worse
+     * than one not listed at all — the gate swallows the message and the user
+     * gets silence instead of the agent's reply. `/model` on Discord was in
+     * exactly that state before this.
+     */
+    async handleCommandModels(chatId) {
+        const models = await this.availableModels();
+        const configuredIds = new Set((this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS).map(m => m.id));
+        const configured = models.filter(m => configuredIds.has(m.id));
+        const live = models.filter(m => !configuredIds.has(m.id));
+        const current = this.agentConfig.claude.model;
+        const lines = [`Current model: ${current}`, '', 'Configured models'];
+        for (const m of configured) {
+            const marker = m.id === current ? '✅ ' : '• ';
+            lines.push(`${marker}${m.label} — \`${m.id}\``);
+        }
+        if (live.length) {
+            lines.push('', 'More models (live)');
+            for (const m of live) {
+                const marker = m.id === current ? '✅ ' : '• ';
+                lines.push(`${marker}${m.label} — \`${m.id}\``);
+            }
+        }
+        lines.push('', 'Switch with /model <id or alias>');
+        this.writeAutoForward(chatId, lines.join('\n'));
+    }
+    /**
+     * /model — show the current model, or switch to one from the catalog.
+     *
+     * An unrecognised argument is refused rather than persisted: unlike the API
+     * (where the caller is authenticated and the provider validates the id), a
+     * typo in a chat message would otherwise be written into config.json and
+     * break the agent's next spawn. Anything the catalog knows — including a
+     * model that exists only upstream and not in the static list — is accepted.
+     */
+    async handleCommandModel(chatId, arg, meta = {}) {
+        const current = this.agentConfig.claude.model;
+        if (!arg) {
+            this.writeAutoForward(chatId, `Current model: ${current}\n\nUse /models to see the list.`);
+            return;
+        }
+        if (!this.isDirectChat(meta)) {
+            this.writeAutoForward(chatId, 'Switching models is only available in a direct message with the bot — '
+                + 'it changes the model for every chat of this agent and restarts them. '
+                + 'Use /models here to see the list.');
+            return;
+        }
+        const models = await this.selectableModels();
+        const wanted = arg.toLowerCase();
+        const match = models.find((m) => m.id.toLowerCase() === wanted || m.alias.toLowerCase() === wanted);
+        if (!match) {
+            this.writeAutoForward(chatId, `Unknown model "${arg}". Use /models to see the list.`);
+            return;
+        }
+        if (match.id === current) {
+            this.writeAutoForward(chatId, `Already using ${match.label} (${match.id}).`);
+            return;
+        }
+        await this.setModel(match.id);
+        // Same restart the Telegram picker's set_model does — the running session
+        // was spawned with the old model and would otherwise keep using it.
+        const restarted = await this.restartChannelSessions();
+        this.writeAutoForward(chatId, `Model set to ${match.label} (${match.id}).${restarted ? ' Restarting the session…' : ''}`);
+    }
     /**
      * /sessions — list all sessions for this chat.
      */
@@ -1933,9 +2018,7 @@ class AgentRunner extends events_1.EventEmitter {
             return;
         }
         const effectiveModel = this.agentConfig.claude.model;
-        const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-        const modelConfig = availableModels.find(m => m.id === effectiveModel);
-        const contextWindow = modelConfig?.contextWindow ?? 200000;
+        const contextWindow = await this.contextWindowFor(effectiveModel);
         const contextTokens = meta.lastInputTokens ?? 0;
         const usedPct = Math.round((contextTokens / contextWindow) * 100);
         let msgs;
@@ -2053,9 +2136,7 @@ class AgentRunner extends events_1.EventEmitter {
         const meta = index.sessions.find(s => s.id === sessionId);
         const name = meta?.name ?? 'Session';
         const compactModel = this.agentConfig.claude.model;
-        const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-        const modelConfig = availableModels.find(m => m.id === compactModel);
-        const contextWindow = modelConfig?.contextWindow ?? 200000;
+        const contextWindow = await this.contextWindowFor(compactModel);
         this.writeAutoForward(chatId, `⏳ Compacting session "${name}"...`);
         try {
             const compactor = new compactor_1.SessionCompactor(this.sessionStore);
@@ -2263,9 +2344,9 @@ class AgentRunner extends events_1.EventEmitter {
                 //     bystander (mirrors the image-size-threshold path).
                 //   - hasLikelyOutstandingBackgroundWork(): regardless of which tier
                 //     called restartOrDefer — even today's aggressive default — a
-                //     session that dispatched a background Agent/Workflow tool_use and
-                //     then ended its OWN turn looks idle here, but a sub-agent it
-                //     launched may still be doing real work. SIGKILLing it now would
+                //     session that dispatched a background Agent/Workflow/Monitor
+                //     tool_use and then ended its OWN turn looks idle here, but that
+                //     dispatch may still be doing real work. SIGKILLing it now would
                 //     silently destroy that in-flight work with no notification or
                 //     recovery (the incident this guards against: a CLAUDE.md-triggered
                 //     restart killed a session mid-way through 3 dispatched code-review
@@ -2470,8 +2551,9 @@ class AgentRunner extends events_1.EventEmitter {
     startIdleCleaner() {
         this.idleCleanerTimer = setInterval(async () => {
             for (const [id, proc] of this.sessions) {
-                // A parent that just dispatched Agent/Workflow work is CLI-idle but its
-                // sub-agent may still need this session to receive the task notification.
+                // A parent that just dispatched Agent/Workflow/Monitor work is CLI-idle
+                // but that dispatch may still need this session to receive its
+                // eventual task notification.
                 if (proc.hasLikelyOutstandingBackgroundWork())
                     continue;
                 if (proc.isIdle(this.idleTimeoutMs)) {
@@ -2571,7 +2653,10 @@ class AgentRunner extends events_1.EventEmitter {
     stopTelegramReceiver() {
         if (!this.receiver)
             return;
-        this.receiver.stop();
+        // Hot-remove is a config-change response, not a shutdown: detach immediately
+        // and let teardown finish in the background rather than blocking the caller
+        // for the SIGKILL grace period. stop() never rejects.
+        void this.receiver.stop();
         this.receiver = null;
         this.logger.info('TelegramReceiver stopped', { agentId: this.agentConfig.id });
     }
@@ -2587,7 +2672,10 @@ class AgentRunner extends events_1.EventEmitter {
     stopDiscordReceiver() {
         if (!this.discordReceiver)
             return;
-        this.discordReceiver.stop();
+        // Hot-remove is a config-change response, not a shutdown: detach immediately
+        // and let teardown finish in the background rather than blocking the caller
+        // for the SIGKILL grace period. stop() never rejects.
+        void this.discordReceiver.stop();
         this.discordReceiver = null;
         this.logger.info('DiscordReceiver stopped', { agentId: this.agentConfig.id });
     }
@@ -2609,10 +2697,17 @@ class AgentRunner extends events_1.EventEmitter {
             clearTimeout(buf.timer);
         }
         this.channelCoalesce.clear();
-        this.receiver?.stop();
-        this.discordReceiver?.stop();
+        // Receiver teardown now resolves only once the child has exited, so it must
+        // be awaited or shutdown() can exit the gateway out from under a receiver
+        // that is still shutting down (issue #405). Run it concurrently with session
+        // teardown rather than serially — both are bounded, neither depends on the
+        // other, and shutdown latency is user-visible.
+        const receiversStopped = [this.receiver?.stop(), this.discordReceiver?.stop()];
         this.stopLineReply();
-        await Promise.all([...this.sessions.values()].map((s) => s.stop()));
+        await Promise.all([
+            ...receiversStopped,
+            ...[...this.sessions.values()].map((s) => s.stop()),
+        ]);
         this.sessions.clear();
     }
     /**
@@ -3412,9 +3507,7 @@ class AgentRunner extends events_1.EventEmitter {
                     responseText = `Session: (unnamed)\nMessages: ${messageCount}\nContext used: 0%\nModel: ${effectiveModel}`;
                 }
                 else {
-                    const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-                    const modelConfig = availableModels.find((m) => m.id === effectiveModel);
-                    const contextWindow = modelConfig?.contextWindow ?? 200000;
+                    const contextWindow = await this.contextWindowFor(effectiveModel);
                     const contextUsedPct = Math.round(((meta.lastInputTokens ?? 0) / contextWindow) * 100);
                     result = { sessionId, sessionName: meta.name, messageCount, archivedCount: meta.archivedCount ?? 0, contextUsedPct, model: effectiveModel };
                     responseText = [
@@ -3471,9 +3564,7 @@ class AgentRunner extends events_1.EventEmitter {
                 const ch = 'api';
                 const activeSession = this.sessions.get(sessionId);
                 const compactEffectiveModel = opts?.model ?? activeSession?.modelOverride ?? this.agentConfig.claude.model;
-                const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-                const modelConfig = availableModels.find((m) => m.id === compactEffectiveModel);
-                const contextWindow = modelConfig?.contextWindow ?? 200000;
+                const contextWindow = await this.contextWindowFor(compactEffectiveModel);
                 const compactor = new compactor_1.SessionCompactor(this.sessionStore);
                 const compactResult = await compactor.compact(agentId, storeChatId, sessionId, compactEffectiveModel, contextWindow, ch);
                 await this.sessionStore.updateSessionMeta(agentId, storeChatId, sessionId, {
@@ -3507,6 +3598,88 @@ class AgentRunner extends events_1.EventEmitter {
         persist('assistant', responseText, forcePersist);
         return { result, responseText };
     }
+    /**
+     * Whether an inbound channel message came from a 1:1 chat with the bot.
+     *
+     * Gates the one channel command that reaches past its own chat: `/model <x>`
+     * rewrites `config.json` for the whole agent and restarts every session in
+     * every chat. The channel access gates do not cover that. Discord's, in a
+     * guild, checks the guild, the channel, and a mention — never the user
+     * (`allowFrom` in mcp/tools/discord/access.ts is DM-only), so without this
+     * any member of an allowlisted channel could switch the model out from under
+     * everyone else and kill their in-flight turns. LINE forwards group and room
+     * messages the same way. Telegram's receiver answers `/model` itself behind
+     * a private-chat + allowlist check and does not forward it here.
+     *
+     * Fails closed: a channel that does not report a chat type cannot switch.
+     * Listing models (`/models`, bare `/model`) is unaffected — it reads nothing
+     * and changes nothing.
+     */
+    isDirectChat(meta) {
+        const kind = meta['chat_type'] ?? meta['line_chat_type'] ?? meta['slack_chat_type'];
+        return kind === 'direct' || kind === 'user';
+    }
+    /**
+     * Restart every non-api session so a model change actually takes effect.
+     *
+     * `setModel` only rewrites config — a session process was spawned with the
+     * old model on its command line and keeps using it until it is restarted.
+     * Reporting "model set" without this is a false success: the next turn still
+     * runs on the previous model. Returns whether anything was restarted.
+     */
+    async restartChannelSessions() {
+        const restartPromises = [];
+        for (const [key, session] of this.sessions) {
+            if (session.source !== 'api')
+                restartPromises.push(this.restartProcess(key));
+        }
+        await Promise.all(restartPromises);
+        return restartPromises.length > 0;
+    }
+    /**
+     * The model list this gateway offers: the live catalog when one is reachable,
+     * the configured/static list otherwise (issue #409). Cached upstream, so the
+     * six callers that only want one model's context window pay for at most one
+     * fetch a minute between them.
+     */
+    async availableModels() {
+        const staticModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
+        return (await (0, model_catalog_1.fetchModelCatalog)(staticModels)) ?? staticModels;
+    }
+    /**
+     * Context window for a model id. Resolving this through the live catalog is
+     * what keeps `/session`'s "context used" percentage and `/compact`'s window
+     * honest for a model that exists only upstream — before, any such model fell
+     * through to the 200k default no matter how large its real window.
+     */
+    async contextWindowFor(modelId) {
+        const models = await this.availableModels();
+        // Configured list second, not just as the catalog's fallback: the catalog
+        // *replaces* the list rather than merging with it, so a configured model
+        // the upstream catalog does not list (the local `[1m]` ids are exactly
+        // that shape) would otherwise drop to the 200k default — reporting
+        // /session context use against a fifth of the real window and handing
+        // SessionCompactor a window small enough to compact far too early.
+        return models.find((m) => m.id === modelId)?.contextWindow
+            ?? (this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS).find((m) => m.id === modelId)?.contextWindow
+            ?? model_catalog_1.DEFAULT_CONTEXT_WINDOW;
+    }
+    /**
+     * Models `/model <arg>` may switch to: what the catalog offers, plus the
+     * configured list.
+     *
+     * The union is only for *resolution*, never for the `/models` listing — the
+     * listing has to reflect what upstream actually offers, or a model removed
+     * upstream would linger in the picker forever, which is the bug this all
+     * started from. Without the union a user who switches to a live-only model
+     * is trapped: their previous configured model is no longer nameable.
+     */
+    async selectableModels() {
+        const live = await this.availableModels();
+        const configured = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
+        const ids = new Set(live.map((m) => m.id));
+        return [...live, ...configured.filter((m) => !ids.has(m.id))];
+    }
     async setModel(newModel) {
         // Allow any model string through — BYOK/third-party models (openrouter/* etc.)
         // are validated by the upstream provider, not the local config list.
@@ -3555,9 +3728,7 @@ class AgentRunner extends events_1.EventEmitter {
         if (!meta)
             return null;
         const effectiveModel = this.agentConfig.claude.model;
-        const availableModels = this.gatewayConfig.gateway.models ?? exports.DEFAULT_MODELS;
-        const modelConfig = availableModels.find((m) => m.id === effectiveModel);
-        const contextWindow = modelConfig?.contextWindow ?? 200000;
+        const contextWindow = await this.contextWindowFor(effectiveModel);
         const contextUsedPct = Math.round(((meta.lastInputTokens ?? 0) / contextWindow) * 100);
         return {
             sessionId: meta.id,