@songsid/agend 2.1.6-beta.7 → 2.1.6-beta.9

package/dist/fleet-manager.d.ts

@@ -479,6 +479,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * Classic channels use their effective backend merge chain, not the raw row.
      */
     getActiveUsageProviderIds(): ReadonlySet<string>;
+    /** Subscription providers used by the running/paused instances owned by one adapter. */
+    getUsageProviderIdsForAdapter(adapterId: string): ReadonlySet<string>;
     /** `[instance, effective backend, credential profile]` for everything that is
      * running or paused — the one place both usage views agree on who is live. */
     private activeBackendBindings;
@@ -1598,12 +1600,35 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Human-readable effective model, e.g. `auto (default)`. Used by /ctx. */
     modelDisplayForInstance(instanceName: string): string;
     private modelChoiceLabel;
-    /** Probe one backend's CLI env and cache it. Best-effort; never throws. */
+    /**
+     * Probe one backend's CLI env and cache it. Best-effort; never throws.
+     *
+     * `refreshVendorCatalog` is the "🔄 Refresh models" path only (#886): first
+     * ask the CLI to refetch its own catalog, for backends whose probe merely
+     * reads a file the CLI maintains. Every other caller leaves it off, so the
+     * startup and /model probes behave exactly as before. A failed vendor
+     * refresh fails the probe (null), which the menu reports instead of passing
+     * the old list off as fresh.
+     */
     private probeBackend;
     /** Background-probe every distinct backend in use at startup (non-blocking). */
     private probeCliEnvs;
     /** Best-effort model list for `/model`: cached CLI env first, else live probe. Never throws. */
     private getModelOptions;
+    /**
+     * The model list plus where it came from. `source` is "live" only when a probe
+     * actually ran and answered; a refresh that failed or ran out of time reports
+     * "cache" with the previous list, so a menu can say "could not refresh"
+     * instead of presenting an old list as a fresh one.
+     */
+    private getModelOptionsWithSource;
+    /**
+     * The /model menu's choices, in the one order all three pickers share:
+     * 🔄 Refresh first, then models, then (claude) "More models…". Refresh takes
+     * a slot inside Discord's 25-option select cap, so it is paid for from the
+     * model rows, never from "More models…".
+     */
+    private modelMenuChoices;
     /**
      * Model catalog behind the `list_models` tool.
      *
@@ -1653,6 +1678,18 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private claudeApiModelOptions;
     /** Replace a consumed "/model" menu with the full account catalog tier. */
     private expandClaudeModelMenu;
+    /**
+     * "🔄 Refresh models" (#886): probe live past both caches and redraw the menu.
+     *
+     * Past AgEnD's cli-env cache (refresh=true) and, where the backend supports
+     * it, past the CLI's own catalog cache too (codex: `codex debug models`).
+     * Without the second half, a codex refresh re-read the same models_cache.json
+     * and showed the old list as new.
+     *
+     * A failed refresh keeps the previous list and says so. It never blanks the
+     * menu, because a picker with no rows cannot even offer another refresh.
+     */
+    private refreshModelMenu;
     /** Consume a `/model` selection callback. Returns true for all model-select ids (incl. stale). */
     private handleModelSelection;
     /** Apply a model to an instance: runtime paste (claude-code) or persist + restart (others). */

package/dist/fleet-manager.js

@@ -44,7 +44,7 @@ import { StatuslineWatcher } from "./statusline-watcher.js";
 import { outboundHandlers } from "./outbound-handlers.js";
 import { handleWebRequest, broadcastSseEvent } from "./web-api.js";
 import { handleViewRequest, isViewPath } from "./view-api.js";
-import { formatDiscordUsageActivity, getUsageSnapshot, handleUsageRequest, isUsagePath, usageProviderIdForBackend } from "./usage/usage-api.js";
+import { filterUsageProviders, formatDiscordUsageActivity, getUsageSnapshot, handleUsageRequest, isUsagePath, usageProviderIdForBackend } from "./usage/usage-api.js";
 import { LOGIN_FLOWS, LOGIN_BACKEND_ALIASES, checkAuthStatus } from "./login-flows.js";
 import { LoginSession } from "./login-manager.js";
 import { LoginController, LOGIN_TOKEN_RESEND_PREFIX, POST_LOGIN_RECOVERY_DEADLINE_MS, announcePostLoginRecovery } from "./login-controller.js";
@@ -1251,6 +1251,19 @@ export class FleetManager {
         }
         return providers;
     }
+    /** Subscription providers used by the running/paused instances owned by one adapter. */
+    getUsageProviderIdsForAdapter(adapterId) {
+        const providers = new Set();
+        for (const [name, backend, profile] of this.activeBackendBindings()) {
+            if (this.getInstanceAdapterId(name) !== adapterId)
+                continue;
+            const provider = usageProviderIdForBackend(backend);
+            if (!provider)
+                continue;
+            providers.add(profile ? `${provider}:${profile}` : provider);
+        }
+        return providers;
+    }
     /** `[instance, effective backend, credential profile]` for everything that is
      * running or paused — the one place both usage views agree on who is live. */
     activeBackendBindings() {
@@ -3060,11 +3073,15 @@ export class FleetManager {
             if (targets.length === 0)
                 return;
             try {
-                const payload = await getUsageSnapshot(false, this.getActiveUsageProviderIds());
-                const text = formatDiscordUsageActivity(payload);
+                // Fetch the shared snapshot once, then scope the projection to each
+                // adapter's own fleet/Classic instances.  Passing the fleet-wide active
+                // set here would make every bot advertise providers owned by a sibling
+                // bot (notably ClassicBot's Grok/Antigravity rows).
+                const payload = await getUsageSnapshot(false);
                 for (const adapter of targets) {
                     try {
-                        adapter.setActivity?.(text);
+                        const scoped = filterUsageProviders(payload, this.getUsageProviderIdsForAdapter(adapter.id));
+                        adapter.setActivity?.(formatDiscordUsageActivity(scoped));
                     }
                     catch {
                         // Presence is cosmetic; a failed update must not affect delivery.
@@ -3077,11 +3094,12 @@ export class FleetManager {
                 this.logger.debug("Discord usage presence refresh skipped");
             }
         })();
-        this.discordPresenceInFlight = run.finally(() => {
-            if (this.discordPresenceInFlight === run)
+        const done = run.finally(() => {
+            if (this.discordPresenceInFlight === done)
                 this.discordPresenceInFlight = null;
         });
-        return this.discordPresenceInFlight;
+        this.discordPresenceInFlight = done;
+        return done;
     }
     /**
      * Delete inbox files older than retentionDays (by mtime). Cleans the shared
@@ -9726,8 +9744,8 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
      * A model list is an aid: a vendor that stops answering must degrade to the
      * previous list, never stall the command that asked for it.
      */
-    async probeBackendBounded(backend) {
-        const work = this.probeBackend(backend);
+    async probeBackendBounded(backend, opts = {}) {
+        const work = this.probeBackend(backend, opts);
         work.catch(() => { });
         let timer;
         const deadline = new Promise(resolve => {
@@ -9791,12 +9809,23 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         const label = option.description ? `${option.label} — ${option.description}` : option.label;
         return option.id === currentModel ? `✓ ${label}` : label;
     }
-    /** Probe one backend's CLI env and cache it. Best-effort; never throws. */
-    async probeBackend(backend) {
+    /**
+     * Probe one backend's CLI env and cache it. Best-effort; never throws.
+     *
+     * `refreshVendorCatalog` is the "🔄 Refresh models" path only (#886): first
+     * ask the CLI to refetch its own catalog, for backends whose probe merely
+     * reads a file the CLI maintains. Every other caller leaves it off, so the
+     * startup and /model probes behave exactly as before. A failed vendor
+     * refresh fails the probe (null), which the menu reports instead of passing
+     * the old list off as fresh.
+     */
+    async probeBackend(backend, opts = {}) {
         try {
             const be = createBackend(backend, join(getAgendHome(), "cli-env"));
             if (!be.probeCLIEnv)
                 return null;
+            if (opts.refreshVendorCatalog && be.refreshModelCatalog)
+                await be.refreshModelCatalog();
             const probed = await be.probeCLIEnv({ workingDirectory: "", instanceDir: join(getAgendHome(), "cli-env"), instanceName: `probe-${backend}`, mcpServers: {} });
             const env = { backend, probedAt: Date.now(), ...probed };
             // An empty result must never overwrite a catalog we already have. Some
@@ -9845,22 +9874,48 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
     }
     /** Best-effort model list for `/model`: cached CLI env first, else live probe. Never throws. */
     async getModelOptions(instanceName, refresh = false, onLiveProbe) {
+        return (await this.getModelOptionsWithSource(instanceName, { refresh, onLiveProbe })).models;
+    }
+    /**
+     * The model list plus where it came from. `source` is "live" only when a probe
+     * actually ran and answered; a refresh that failed or ran out of time reports
+     * "cache" with the previous list, so a menu can say "could not refresh"
+     * instead of presenting an old list as a fresh one.
+     */
+    async getModelOptionsWithSource(instanceName, opts = {}) {
         const backendName = this.backendNameForInstance(instanceName);
         const cached = this.readCliEnv(backendName);
-        if (!refresh && cached?.models.length && !this.cliEnvNeedsRefresh(cached))
-            return cached.models;
+        if (!opts.refresh && cached?.models.length && !this.cliEnvNeedsRefresh(cached)) {
+            return { models: cached.models, source: "cache" };
+        }
         // About to go to the vendor: let the caller say so. A silent 1–10s pause on
         // an interactive command reads as another hang, which is the wrong lesson to
         // teach a user who has just been bitten by one.
-        onLiveProbe?.();
+        opts.onLiveProbe?.();
         // Stale, missing, or a forced refresh → probe live (also refreshes the cache).
         // A newly released model is invisible until this runs, which is why staleness
         // triggers it rather than waiting for the 24h hard expiry or a cold start.
-        const env = await this.probeBackendBounded(backendName);
+        const env = await this.probeBackendBounded(backendName, { refreshVendorCatalog: opts.refreshVendorCatalog });
         if (env?.models.length)
-            return env.models;
+            return { models: env.models, source: "live" };
         // Probe failed or timed out: the previous list is still the best answer.
-        return cached?.models ?? [];
+        return { models: cached?.models ?? [], source: "cache" };
+    }
+    /**
+     * The /model menu's choices, in the one order all three pickers share:
+     * 🔄 Refresh first, then models, then (claude) "More models…". Refresh takes
+     * a slot inside Discord's 25-option select cap, so it is paid for from the
+     * model rows, never from "More models…".
+     */
+    modelMenuChoices(instanceName, nonce, options, currentModel) {
+        const isClaude = this.backendNameForInstance(instanceName) === "claude-code";
+        const choices = [{ id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:__refresh__`, label: t("model.refresh") }];
+        for (const o of options.slice(0, isClaude ? 23 : 24)) {
+            choices.push({ id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:${o.id}`, label: this.modelChoiceLabel(o, currentModel) });
+        }
+        if (isClaude)
+            choices.push({ id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:__more__`, label: t("model.more") });
+        return choices;
     }
     /**
      * Model catalog behind the `list_models` tool.
@@ -10161,14 +10216,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         // Raw id for ✓-matching options; display resolves an inherited CLI default.
         const { model: currentModel, display: currentDisplay } = this.resolveInstanceModel(name);
         const nonce = randomBytes(6).toString("hex");
-        const isClaude = this.backendNameForInstance(name) === "claude-code";
-        const choices = options.slice(0, isClaude ? 24 : 25).map(o => ({
-            id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:${o.id}`,
-            label: this.modelChoiceLabel(o, currentModel),
-        }));
-        if (isClaude) {
-            choices.push({ id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:__more__`, label: t("model.more") });
-        }
+        const choices = this.modelMenuChoices(name, nonce, options, currentModel);
         const timer = setTimeout(() => this.pendingModelSelects.delete(nonce), CLASSIC_BACKEND_SELECTION_TIMEOUT_MS);
         timer.unref?.();
         this.pendingModelSelects.set(nonce, { instanceName: name, model: "", userId: data.userId, channelId: data.channelId, timer, respond: data.respond, respondChoices: data.respondChoices });
@@ -10194,15 +10242,7 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         }
         const { model: currentModel, display: currentDisplay } = this.resolveInstanceModel(instanceName);
         const nonce = randomBytes(6).toString("hex");
-        const isClaude = this.backendNameForInstance(instanceName) === "claude-code";
-        // Keep the more-models entry inside Discord's 25-option select cap.
-        const choices = options.slice(0, isClaude ? 24 : 25).map(o => ({
-            id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:${o.id}`,
-            label: this.modelChoiceLabel(o, currentModel),
-        }));
-        if (isClaude) {
-            choices.push({ id: `${MODEL_SELECT_CALLBACK_PREFIX}${nonce}:__more__`, label: t("model.more") });
-        }
+        const choices = this.modelMenuChoices(instanceName, nonce, options, currentModel);
         const respond = async (text) => {
             await adapter.sendText(chatId, text, { threadId });
             return undefined;
@@ -10286,6 +10326,64 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             await pending.respond(t("model.more_unavailable")).catch(() => { });
         }
     }
+    /**
+     * "🔄 Refresh models" (#886): probe live past both caches and redraw the menu.
+     *
+     * Past AgEnD's cli-env cache (refresh=true) and, where the backend supports
+     * it, past the CLI's own catalog cache too (codex: `codex debug models`).
+     * Without the second half, a codex refresh re-read the same models_cache.json
+     * and showed the old list as new.
+     *
+     * A failed refresh keeps the previous list and says so. It never blanks the
+     * menu, because a picker with no rows cannot even offer another refresh.
+     */
+    async refreshModelMenu(pending) {
+        const { models, source } = await this.getModelOptionsWithSource(pending.instanceName, {
+            refresh: true, refreshVendorCatalog: true,
+        });
+        if (models.length === 0) {
+            await pending.respond(t("model.list_unavailable", pending.instanceName)).catch(() => { });
+            return;
+        }
+        const { model: currentModel, display: currentDisplay } = this.resolveInstanceModel(pending.instanceName);
+        const nonce = randomBytes(6).toString("hex");
+        const choices = this.modelMenuChoices(pending.instanceName, nonce, models, currentModel);
+        const status = source === "live" ? t("model.refreshed") : t("model.refresh_failed");
+        const timer = setTimeout(() => {
+            const p = this.pendingModelSelects.get(nonce);
+            if (p) {
+                this.pendingModelSelects.delete(nonce);
+                p.respond(t("model.selection_expired")).catch(() => { });
+            }
+        }, CLASSIC_BACKEND_SELECTION_TIMEOUT_MS);
+        timer.unref?.();
+        this.pendingModelSelects.set(nonce, { ...pending, model: "", timer });
+        try {
+            if (pending.respondChoices) {
+                // Discord select menu: edit the same interaction reply in place.
+                await pending.respondChoices(`${status}\n${t("model.menu", `**${currentDisplay}**`)}`, choices);
+                return;
+            }
+            if (pending.adapter && pending.adapterChatId) {
+                // Telegram: retire the consumed keyboard, then post the redrawn menu.
+                if (pending.menuMessageId && pending.adapter.editMessageRemoveButtons) {
+                    await pending.adapter.editMessageRemoveButtons(pending.adapterChatId, pending.menuMessageId, t("model.refresh"), pending.adapterThreadId).catch(() => { });
+                }
+                const menuMessageId = await pending.adapter.promptUser(pending.adapterChatId, `${status}\n${t("model.menu", currentDisplay)}`, choices, { threadId: pending.adapterThreadId });
+                const fresh = this.pendingModelSelects.get(nonce);
+                if (fresh)
+                    fresh.menuMessageId = menuMessageId;
+                return;
+            }
+            await pending.respond(t("model.usage")).catch(() => { });
+        }
+        catch (err) {
+            this.pendingModelSelects.delete(nonce);
+            clearTimeout(timer);
+            this.logger.warn({ err, instanceName: pending.instanceName }, "Refreshed model menu failed");
+            await pending.respond(t("model.usage")).catch(() => { });
+        }
+    }
     /** Consume a `/model` selection callback. Returns true for all model-select ids (incl. stale). */
     async handleModelSelection(data) {
         if (!data.callbackData.startsWith(MODEL_SELECT_CALLBACK_PREFIX))
@@ -10311,6 +10409,12 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
             await this.expandClaudeModelMenu(pending);
             return true;
         }
+        // "🔄 Refresh models" is navigation too: re-probe past every cache and
+        // redraw the same menu with what came back.
+        if (model === "__refresh__") {
+            await this.refreshModelMenu(pending);
+            return true;
+        }
         // Send immediate "⏳ Switching..." feedback, then apply in background.
         const progressText = t("model.switching", pending.instanceName, model);
         let progressMsgId;