talon-agent 3.17.0 → 3.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "3.17.0",
+  "version": "3.19.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/backend/codex/plan-usage.ts

@@ -95,6 +95,10 @@ export function parseCodexUsage(body: unknown): PlanUsage | undefined {
       primary_window?: RawWindow | null;
       secondary_window?: RawWindow | null;
     };
+    rate_limit_reset_credits?: {
+      available_count?: number;
+      applicable_available_count?: number;
+    } | null;
   } | null;
   const limit = data?.rate_limit;
   if (!limit) return undefined;
@@ -108,6 +112,10 @@ export function parseCodexUsage(body: unknown): PlanUsage | undefined {
   return {
     ...(data?.plan_type ? { plan: data.plan_type } : {}),
     windows,
+    ...(typeof data?.rate_limit_reset_credits?.available_count === "number" &&
+    data.rate_limit_reset_credits.available_count > 0
+      ? { resetsAvailable: data.rate_limit_reset_credits.available_count }
+      : {}),
     fetchedAt: Date.now(),
   };
 }

package/src/backend/kilo/factory.ts

@@ -69,25 +69,8 @@ const kiloFactory: BackendFactory = {
       // through to `config.backendDefaults.kilo`.
       getDefaultModelId: () => undefined,
       getRawModelInfo: (id) => kiloGetModelInfo(id),
-      getSettingsPresentation: async (m, options) => {
-        // Kilo's internal helper returns the bare picker shape;
-        // wrap into the canonical `ModelPickerResult`. Kilo doesn't
-        // expose pagination or a free-tier filter so the result is
-        // always page 1 of 1 with filter "all".
-        const inner = await kiloGetSettingsPresentation(
-          m,
-          options?.callbackPrefix,
-        );
-        return {
-          ...inner,
-          view: "models" as const,
-          page: 1,
-          totalPages: 1,
-          filter: "all" as const,
-          freeCount: 0,
-          totalCount: inner.modelButtons.length,
-        };
-      },
+      getSettingsPresentation: (m, options) =>
+        kiloGetSettingsPresentation(m, options),
       getProviders: () => kiloGetProviders(),
       getProviderModels: (p, pg, ps) => kiloGetProviderModels(p, pg, ps),
       formatModelError: (q, r) => kiloFormatModelError(q, r),

package/src/backend/opencode/factory.ts

@@ -66,21 +66,8 @@ const opencodeFactory: BackendFactory = {
       // Catalog-driven backend with no canonical default.
       getDefaultModelId: () => undefined,
       getRawModelInfo: (id) => ocGetModelInfo(id),
-      getSettingsPresentation: async (m, options) => {
-        const inner = await ocGetSettingsPresentation(
-          m,
-          options?.callbackPrefix,
-        );
-        return {
-          ...inner,
-          view: "models" as const,
-          page: 1,
-          totalPages: 1,
-          filter: "all" as const,
-          freeCount: 0,
-          totalCount: inner.modelButtons.length,
-        };
-      },
+      getSettingsPresentation: (m, options) =>
+        ocGetSettingsPresentation(m, options),
       getProviders: () => ocGetProviders(),
       getProviderModels: (p, pg, ps) => ocGetProviderModels(p, pg, ps),
       formatModelError: (q, r) => ocFormatModelError(q, r),

package/src/backend/remote-server/model-catalog/presentation.ts

@@ -35,8 +35,40 @@ export interface RemotePresentationOptions {
    * true where the transport accepts arbitrary characters (Discord).
    */
   allowCallbackSeparators: boolean;
-  /** How many quick-pick buttons to offer (Telegram 4, Discord 24). */
+  /**
+   * Default page size when the frontend doesn't ask for one — also the
+   * legacy quick-pick count (Telegram 4, Discord 24).
+   */
   quickPickLimit: number;
+  /**
+   * Flat model lists longer than this collapse into provider chips, so a
+   * catalog of several hundred models opens as a handful of providers
+   * rather than dozens of indistinguishable pages. Defaults to 60.
+   */
+  groupThreshold?: number;
+}
+
+/** Paging / filtering knobs, mirroring `ModelPickerOptions`. */
+export interface RemotePickerOptions {
+  callbackPrefix?: string;
+  navCallbackPrefix?: string;
+  page?: number;
+  pageSize?: number;
+  filter?: "all" | "free";
+  provider?: string;
+}
+
+/** What the frontend needs to render one page of the picker. */
+export interface RemotePickerResult {
+  modelButtons: Array<ModelButton>;
+  modelDetails: Array<string>;
+  view: "groups" | "models";
+  page: number;
+  totalPages: number;
+  filter: "all" | "free";
+  freeCount: number;
+  totalCount: number;
+  provider?: string;
 }
 
 function getAvailabilityLabel(model: RemoteModelCatalogEntry) {
@@ -69,8 +101,8 @@ export interface RemoteModelPresentation {
   ): Array<RemoteModelCatalogEntry>;
   getSettingsPresentation(
     activeModel: string,
-    callbackPrefix?: string,
-  ): Promise<{ modelButtons: Array<ModelButton>; modelDetails: Array<string> }>;
+    options?: RemotePickerOptions,
+  ): Promise<RemotePickerResult>;
   renderModelSummary(
     activeModel: string,
     defaultModel: string,
@@ -92,6 +124,7 @@ export function createRemoteModelPresentation(
     maxCallbackIdLength,
     allowCallbackSeparators,
     quickPickLimit,
+    groupThreshold = 60,
   } = options;
 
   function isCallbackSafeModelID(modelID: string): boolean {
@@ -140,30 +173,64 @@ export function createRemoteModelPresentation(
 
   async function getSettingsPresentation(
     activeModel: string,
-    callbackPrefix = "settings:model:",
-  ): Promise<{
-    modelButtons: Array<ModelButton>;
-    modelDetails: Array<string>;
-  }> {
+    options: RemotePickerOptions = {},
+  ): Promise<RemotePickerResult> {
+    const callbackPrefix = options.callbackPrefix ?? "settings:model:";
+    const navPrefix = options.navCallbackPrefix ?? "settings:models";
     const catalog = await getCatalog();
     const current = getRemoteModelInfo(catalog, activeModel);
-    const picks = getQuickPickModels(catalog, activeModel);
 
-    const modelButtons: Array<ModelButton> = picks.map((m) => {
-      const btnLabel =
-        m.id.length <= 20 ? m.id : m.name.length <= 20 ? m.name : m.id;
-      const txt = m.free ? `${btnLabel} ★` : btnLabel;
-      const sel =
-        current && m.id === current.id && m.providerID === current.providerID;
-      return {
-        text: sel ? `✓ ${txt}` : txt,
-        callback_data: `${callbackPrefix}${m.id}`,
-      };
-    });
-    modelButtons.push({
-      text: "Reset",
-      callback_data: `${callbackPrefix}reset`,
-    });
+    const filter = options.filter === "free" ? "free" : "all";
+    const selectable = catalog.connectedModels.filter((m) =>
+      isCallbackSafeModelID(m.id),
+    );
+    const freeCount = selectable.filter((m) => m.free).length;
+    const scoped = selectable.filter(
+      (m) =>
+        (filter === "all" || m.free) &&
+        (!options.provider || m.providerID === options.provider),
+    );
+
+    // A remote catalog can run to hundreds of models, and only the first
+    // page's worth ever fit on screen — so offer the provider list as the
+    // way in when nothing narrower was asked for and the flat list would be
+    // unreadable anyway.
+    const providers = catalog.connectedProviders;
+    const asGroups =
+      !options.provider &&
+      providers.length > 1 &&
+      scoped.length > groupThreshold;
+
+    const pageSize = Math.max(1, options.pageSize ?? quickPickLimit);
+    const source = asGroups ? providers : scoped;
+    const totalPages = Math.max(1, Math.ceil(source.length / pageSize));
+    const page = Math.min(Math.max(1, options.page ?? 1), totalPages);
+    const slice = source.slice((page - 1) * pageSize, page * pageSize);
+
+    const modelButtons: Array<ModelButton> = asGroups
+      ? (slice as typeof providers).map((p) => ({
+          text: `${p.name} (${p.modelCount})`,
+          callback_data: `${navPrefix}:provider:${p.id}`,
+        }))
+      : (slice as typeof scoped).map((m) => {
+          const btnLabel =
+            m.id.length <= 20 ? m.id : m.name.length <= 20 ? m.name : m.id;
+          const txt = m.free ? `${btnLabel} ★` : btnLabel;
+          const sel =
+            current &&
+            m.id === current.id &&
+            m.providerID === current.providerID;
+          return {
+            text: sel ? `✓ ${txt}` : txt,
+            callback_data: `${callbackPrefix}${m.id}`,
+          };
+        });
+    if (!asGroups) {
+      modelButtons.push({
+        text: "Reset",
+        callback_data: `${callbackPrefix}reset`,
+      });
+    }
 
     const details: Array<string> = [];
     if (current) {
@@ -189,7 +256,17 @@ export function createRemoteModelPresentation(
       );
     }
     details.push("Hint: use /model <name> to switch.");
-    return { modelButtons, modelDetails: details };
+    return {
+      modelButtons,
+      modelDetails: details,
+      view: asGroups ? "groups" : "models",
+      page,
+      totalPages,
+      filter,
+      freeCount,
+      totalCount: selectable.length,
+      ...(options.provider ? { provider: options.provider } : {}),
+    };
   }
 
   async function renderModelSummary(

package/src/backend/remote-server/model-catalog/provider.ts

@@ -19,6 +19,10 @@ import type {
   RemoteModelCatalogEntry,
   RemoteModelResolution,
 } from "./types.js";
+import type {
+  RemotePickerOptions,
+  RemotePickerResult,
+} from "./presentation.js";
 
 export interface RemoteModelProviderDeps {
   /** Human label — "OpenCode" / "Kilo" — used in error strings. */
@@ -36,8 +40,8 @@ export interface RemoteModelProviderDeps {
   formatUnavailableModel(model: RemoteModelCatalogEntry): string;
   getSettingsPresentation(
     activeModel: string,
-    callbackPrefix?: string,
-  ): Promise<{ modelButtons: ModelButton[]; modelDetails: string[] }>;
+    options?: RemotePickerOptions,
+  ): Promise<RemotePickerResult>;
 }
 
 export interface RemoteModelProvider {
@@ -45,8 +49,8 @@ export interface RemoteModelProvider {
   getModelInfo(id: string): Promise<UnifiedModelInfo | undefined>;
   getSettingsPresentation(
     activeModel: string,
-    callbackPrefix?: string,
-  ): Promise<{ modelButtons: ModelButton[]; modelDetails: string[] }>;
+    options?: RemotePickerOptions,
+  ): Promise<RemotePickerResult>;
   getProviders(): Promise<UnifiedProviderInfo[]>;
   getProviderModels(
     providerId: string,
@@ -118,8 +122,8 @@ export function createRemoteModelProvider(
       return entry ? toUnifiedModelInfo(entry) : undefined;
     },
 
-    getSettingsPresentation(activeModel, callbackPrefix = "settings:model:") {
-      return deps.getSettingsPresentation(activeModel, callbackPrefix);
+    getSettingsPresentation(activeModel, options) {
+      return deps.getSettingsPresentation(activeModel, options);
     },
 
     async getProviders() {

package/src/core/agent-runtime/capabilities.ts

@@ -245,6 +245,8 @@ export interface PlanUsage {
   /** Subscription tier (`max`, `pro`, …) when known. */
   plan?: string;
   windows: PlanWindow[];
+  /** How many one-shot rate-limit resets are still banked, when the plan has them. */
+  resetsAvailable?: number;
   /** Epoch ms of the read, so renderers can flag figures as aged. */
   fetchedAt: number;
 }

package/src/frontend/discord/callbacks/components.ts

@@ -29,6 +29,14 @@ import {
 } from "discord.js";
 import type { TalonConfig } from "../../../util/config.js";
 import type { Gateway } from "../../../core/engine/gateway.js";
+import {
+  buildModelPickerView,
+  buildBackendPickerView,
+  decodeModelNav,
+  MODEL_NAV_PREFIX,
+  MODEL_PAGE_SIZE,
+} from "../model-picker.js";
+import { metricsViewRow, renderMetricsView } from "../commands/admin.js";
 import {
   getChatSettings,
   setChatModelForBackend,
@@ -52,7 +60,12 @@ import { execute } from "../../../core/engine/dispatcher.js";
 import {
   getBackendIdForChat,
   resolveChatBackend,
+  listAvailableBackends,
+  rebindChat,
 } from "../../../core/engine/backend-controller/index.js";
+import { resetSession } from "../../../storage/sessions.js";
+import { clearHistory } from "../../../storage/history.js";
+import { resetPulseCheckpoint } from "../../../core/background/pulse.js";
 import { resolveActiveModelForChat } from "../../../core/models/active-model.js";
 import {
   displayReasoningEffort,
@@ -68,7 +81,6 @@ import {
   DISCORD_MAX_TEXT,
 } from "../formatting.js";
 import { chatIdFromInteraction, type ComponentInteraction } from "./shared.js";
-import { metricsViewRow, renderMetricsView } from "../commands/admin.js";
 
 export async function handleComponentInteraction(
   interaction: ComponentInteraction,
@@ -287,6 +299,38 @@ export async function handleComponentInteraction(
     const be = resolveChatBackend(chatId, gateway?.backend);
     const beId = getBackendIdForChat(chatId);
 
+    // In the provider view the select carries chips, not models — picking
+    // one drills into that provider rather than choosing anything.
+    if (value?.startsWith("provider:") && be?.models?.getSettingsPresentation) {
+      const providerId = value.slice("provider:".length);
+      const { model: activeNow } = await resolveActiveModelForChat(
+        chatId,
+        be,
+        beId,
+        config,
+      );
+      const pres = await be.models.getSettingsPresentation(activeNow ?? "", {
+        callbackPrefix: "model:",
+        navCallbackPrefix: MODEL_NAV_PREFIX,
+        pageSize: MODEL_PAGE_SIZE,
+        provider: providerId,
+      });
+      const view = buildModelPickerView(
+        pres,
+        activeNow ?? "_No model selected_",
+        beId,
+      );
+      try {
+        await interaction.update({
+          content: view.content,
+          components: view.components,
+        });
+      } catch {
+        /* ignore */
+      }
+      return;
+    }
+
     if (value === "reset") {
       // Clear THIS backend's slot only — other backends stay intact.
       setChatModelForBackend(chatId, beId, undefined);
@@ -320,35 +364,219 @@ export async function handleComponentInteraction(
       const current = resolvedCurrent ?? "";
       const pres = await be.models?.getSettingsPresentation(current, {
         callbackPrefix: "model:",
+        navCallbackPrefix: MODEL_NAV_PREFIX,
+        pageSize: MODEL_PAGE_SIZE,
       });
       const modelInfo = resolvedCurrent
         ? await be.models?.getRawModelInfo?.(resolvedCurrent)
         : undefined;
       const displayName =
         modelInfo?.displayName ?? resolvedCurrent ?? "_No model selected_";
-      const menu = new StringSelectMenuBuilder()
-        .setCustomId("model:select")
-        .setPlaceholder("Pick a model")
-        .addOptions(
-          pres.modelButtons.slice(0, 25).map((b) => ({
-            label: safeSlice(b.text.replace(/^✓ /, ""), 100),
-            value: safeSlice(b.callback_data.replace(/^model:/, ""), 100),
-            default: b.text.startsWith("✓"),
-          })),
-        );
-      const row = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
-        menu,
+      const view = buildModelPickerView(pres, displayName, beId);
+      try {
+        await interaction.update({
+          content: view.content,
+          components: view.components,
+        });
+      } catch {
+        /* ignore */
+      }
+    }
+    return;
+  }
+
+  // ── /model pager — page arrows, free-tier toggle, provider drill ────────
+  // Pure navigation: re-render the same panel at the requested page without
+  // touching the chat's selected model.
+  if (customId.startsWith(`${MODEL_NAV_PREFIX}:`)) {
+    // Backend submenu — the one nav action that isn't a re-page.
+    if (customId === `${MODEL_NAV_PREFIX}:backends`) {
+      const view = buildBackendPickerView(
+        listAvailableBackends(config),
+        getBackendIdForChat(chatId),
       );
       try {
         await interaction.update({
-          content: [`**Model:** \`${displayName}\``, ...pres.modelDetails].join(
-            "\n",
-          ),
-          components: [row],
+          content: view.content,
+          components: view.components,
+        });
+      } catch {
+        /* ignore */
+      }
+      return;
+    }
+
+    const target = decodeModelNav(customId);
+    if (!target) {
+      try {
+        await interaction.deferUpdate();
+      } catch {
+        /* ignore */
+      }
+      return;
+    }
+    const be = resolveChatBackend(chatId, gateway?.backend);
+    const beId = getBackendIdForChat(chatId);
+    const { model: current } = await resolveActiveModelForChat(
+      chatId,
+      be,
+      beId,
+      config,
+    );
+    if (!be?.models?.getSettingsPresentation) {
+      try {
+        await interaction.deferUpdate();
+      } catch {
+        /* ignore */
+      }
+      return;
+    }
+    const pres = await be.models.getSettingsPresentation(current ?? "", {
+      callbackPrefix: "model:",
+      navCallbackPrefix: MODEL_NAV_PREFIX,
+      pageSize: MODEL_PAGE_SIZE,
+      page: target.page,
+      filter: target.filter,
+      ...(target.provider ? { provider: target.provider } : {}),
+    });
+    const modelInfo = current
+      ? await be.models?.getRawModelInfo?.(current)
+      : undefined;
+    const view = buildModelPickerView(
+      pres,
+      modelInfo?.displayName ?? current ?? "_No model selected_",
+      beId,
+    );
+    try {
+      await interaction.update({
+        content: view.content,
+        components: view.components,
+      });
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+
+  // ── /model backend switch ───────────────────────────────────────────────
+  // Rebinding drops this chat's session (it isn't portable across backends)
+  // but keeps each backend's remembered model pick, so switching back
+  // restores what was selected there before.
+  if (customId === "model:backend-select" && interaction.isStringSelectMenu()) {
+    const backendId = interaction.values[0] ?? "";
+    const available = listAvailableBackends(config);
+    if (!available.some((b) => b.id === backendId)) {
+      await interaction.reply({
+        content: "Backend not available.",
+        flags: MessageFlags.Ephemeral,
+      });
+      return;
+    }
+
+    // Booting a cold backend takes seconds — Kilo and OpenCode spawn a server
+    // and sweep MCP registrations — and Discord drops an interaction that
+    // isn't acknowledged within three. Ack first, edit the panel after.
+    try {
+      await interaction.deferUpdate();
+    } catch {
+      /* already acknowledged */
+    }
+    const fail = async (text: string): Promise<void> => {
+      try {
+        await interaction.followUp({
+          content: text,
+          flags: MessageFlags.Ephemeral,
         });
       } catch {
         /* ignore */
       }
+    };
+
+    // Resolve the outgoing backend before rebinding — afterwards the chat
+    // already points at the new one and the old instance is unreachable.
+    const previousId = getBackendIdForChat(chatId);
+    const previous = resolveChatBackend(chatId, gateway?.backend);
+    const alreadyThere = previousId === backendId;
+    const result = alreadyThere
+      ? { ok: true as const }
+      : await rebindChat(chatId, backendId, config);
+    if (!result.ok) {
+      await fail(result.error?.slice(0, 200) ?? "Rebind failed.");
+      return;
+    }
+    setChatBackend(chatId, backendId);
+
+    // The pool accepts a backend whose SDK is installed, but the SDK may only
+    // be a client for a CLI that isn't (OpenCode and Kilo spawn `opencode` /
+    // `kilo`). That surfaces here, on the first real call. Reading the
+    // catalog is the cheapest way to find out, and it is needed for the panel
+    // anyway — so treat a throw as "this backend can't serve" and put the
+    // chat back where it was rather than stranding it somewhere unusable.
+    let next = resolveChatBackend(chatId, gateway?.backend);
+    let newModel: string | undefined;
+    let pres;
+    try {
+      newModel =
+        (await resolveActiveModelForChat(chatId, next, backendId, config))
+          .model ?? undefined;
+      if (next?.models?.getSettingsPresentation) {
+        pres = await next.models.getSettingsPresentation(newModel ?? "", {
+          callbackPrefix: "model:",
+          navCallbackPrefix: MODEL_NAV_PREFIX,
+          pageSize: MODEL_PAGE_SIZE,
+        });
+      }
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      logError("discord", `Backend switch to ${backendId} failed`, err);
+      if (!alreadyThere) {
+        await rebindChat(chatId, previousId, config).catch(() => undefined);
+        setChatBackend(chatId, previousId);
+      }
+      await fail(
+        `⚠️ \`${backendId}\` could not start — staying on \`${previousId}\`.\n` +
+          `\`\`\`\n${safeSlice(reason, 300)}\n\`\`\``,
+      );
+      return;
+    }
+
+    // Only now is the switch known to hold. Session state doesn't port across
+    // backends, so it goes — but each backend's remembered model pick stays.
+    // A re-pick of the backend already in use clears nothing: the retry after
+    // a timed-out interaction must not cost the session a second time.
+    if (!alreadyThere) {
+      resetSession(chatId);
+      clearHistory(chatId);
+      resetPulseCheckpoint(chatId);
+      previous?.sessions?.resetChat?.(chatId);
+    }
+
+    next = resolveChatBackend(chatId, gateway?.backend);
+    // Warming is fire-and-forget: it can take seconds on OpenCode/Kilo and
+    // the interaction still has a panel to redraw.
+    if (next && next !== previous) {
+      void Promise.resolve(next.sessions?.warmSession?.(chatId)).catch(
+        () => undefined,
+      );
+    }
+
+    try {
+      await interaction.editReply(
+        pres
+          ? {
+              ...buildModelPickerView(
+                pres,
+                newModel ?? "_No model selected_",
+                backendId,
+              ),
+            }
+          : {
+              content: `**Backend:** \`${backendId}\` · model \`${newModel ?? "none"}\``,
+              components: [],
+            },
+      );
+    } catch {
+      /* ignore */
     }
     return;
   }

package/src/frontend/discord/commands/settings.ts

@@ -46,6 +46,11 @@ import {
 import { resolveActiveModelForChat } from "../../../core/models/active-model.js";
 import { safeSlice } from "../formatting.js";
 import { reply } from "./shared.js";
+import {
+  buildModelPickerView,
+  MODEL_NAV_PREFIX,
+  MODEL_PAGE_SIZE,
+} from "../model-picker.js";
 
 export async function handleModel(
   i: ChatInputCommandInteraction,
@@ -94,6 +99,8 @@ export async function handleModel(
     if (be?.models?.getSettingsPresentation) {
       const pres = await be.models?.getSettingsPresentation(activeModel, {
         callbackPrefix: "model:",
+        navCallbackPrefix: MODEL_NAV_PREFIX,
+        pageSize: MODEL_PAGE_SIZE,
       });
       const modelInfo = activeModel
         ? await be.models?.getRawModelInfo?.(activeModel)
@@ -102,25 +109,10 @@ export async function handleModel(
         modelInfo?.displayName ??
         (activeModel ? formatModelLabel(activeModel) : "_No model selected_");
 
-      // Build select menu from the top 25 models. Discord caps select-menu
-      // options at 25; if the backend exposes more, use `/model name:<value>`
-      // (autocomplete-backed) to pick anything outside this list.
-      const options = pres.modelButtons.slice(0, 25).map((b) => ({
-        label: safeSlice(b.text.replace(/^✓ /, ""), 100),
-        value: safeSlice(b.callback_data.replace(/^model:/, ""), 100),
-        default: b.text.startsWith("✓"),
-      }));
-      const menu = new StringSelectMenuBuilder()
-        .setCustomId("model:select")
-        .setPlaceholder("Pick a model")
-        .addOptions(options);
-      const row = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
-        menu,
-      );
-      const lines = [`**Model:** \`${displayName}\``, ...pres.modelDetails];
+      const view = buildModelPickerView(pres, displayName, beId);
       await i.editReply({
-        content: lines.join("\n"),
-        components: [row],
+        content: view.content,
+        components: view.components,
         allowedMentions: { parse: [] },
       });
     } else {

package/src/frontend/discord/helpers.ts

@@ -293,6 +293,12 @@ export function renderUsageMessage(entries: BackendUsageEntry[]): string {
     const age = entry.plan.ageLabel ? ` *(${entry.plan.ageLabel})*` : "";
     const plan = entry.plan.plan ? ` · ${entry.plan.plan}` : "";
     lines.push("", `**${name}**${plan}${age}`);
+    if (entry.plan.resetsAvailable) {
+      const n = entry.plan.resetsAvailable;
+      lines.push(
+        `  • You have **${n}** usage limit reset${n === 1 ? "" : "s"} available`,
+      );
+    }
     for (const w of entry.plan.windows) {
       const reset = w.resetLabel ? ` reset ${w.resetLabel}` : "";
       lines.push(

package/src/frontend/discord/model-picker.ts

@@ -0,0 +1,234 @@
+/**
+ * Model picker rendering — select menu plus pager controls.
+ *
+ * The backend already paginates and filters the catalog
+ * (`getSettingsPresentation` returns page / totalPages / filter / provider);
+ * this only lays that out as Discord components. A select menu caps at 25
+ * options, so without the pager everything past the first 25 models was
+ * unreachable from the UI.
+ *
+ * Navigation state rides in the custom_id — `model:nav:page:3:free` — which
+ * is what keeps the handler stateless across re-renders.
+ */
+
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  StringSelectMenuBuilder,
+  type APIActionRowComponent,
+  type APIComponentInMessageActionRow,
+} from "discord.js";
+import type { ModelPickerResult } from "../../core/types.js";
+import { safeSlice } from "./formatting.js";
+
+export const MODEL_NAV_PREFIX = "model:nav";
+/** Discord's hard cap on select-menu options — also the page size we request. */
+export const MODEL_PAGE_SIZE = 25;
+
+/** Where a nav button points. Decoded from a `model:nav:…` custom_id. */
+export type ModelNavTarget = {
+  page: number;
+  filter: "all" | "free";
+  provider?: string;
+};
+
+export function decodeModelNav(customId: string): ModelNavTarget | null {
+  if (!customId.startsWith(`${MODEL_NAV_PREFIX}:`)) return null;
+  const parts = customId.slice(MODEL_NAV_PREFIX.length + 1).split(":");
+  const [kind] = parts;
+
+  if (kind === "providers") return { page: 1, filter: "all" };
+  if (kind === "provider") {
+    return { page: 1, filter: "all", provider: parts[1] };
+  }
+  if (kind === "page") {
+    const page = Number(parts[1]);
+    const filter = parts[2] === "free" ? "free" : "all";
+    return {
+      page: Number.isFinite(page) && page > 0 ? page : 1,
+      filter,
+      ...(parts[3] ? { provider: parts[3] } : {}),
+    };
+  }
+  if (kind === "filter") {
+    const filter = parts[1] === "free" ? "free" : "all";
+    return { page: 1, filter, ...(parts[2] ? { provider: parts[2] } : {}) };
+  }
+  return null;
+}
+
+function navId(suffix: string, provider?: string): string {
+  const base = `${MODEL_NAV_PREFIX}:${suffix}`;
+  return provider ? `${base}:${provider}` : base;
+}
+
+/**
+ * Buttons under the select: page arrows, a page counter, the free-tier
+ * toggle, and a way back to the provider list. Five buttons is exactly one
+ * Action Row, so this never spills into a second row.
+ */
+function controlRow(
+  pres: ModelPickerResult,
+): ActionRowBuilder<ButtonBuilder> | null {
+  const buttons: ButtonBuilder[] = [];
+  const { page, totalPages, filter, freeCount, provider } = pres;
+
+  if (totalPages > 1) {
+    buttons.push(
+      new ButtonBuilder()
+        .setCustomId(navId(`page:${page - 1}:${filter}`, provider))
+        .setLabel("◀")
+        .setStyle(ButtonStyle.Secondary)
+        .setDisabled(page <= 1),
+      // A disabled button is the only way to render a static counter
+      // inline with the arrows.
+      new ButtonBuilder()
+        .setCustomId(navId("noop"))
+        .setLabel(`${page}/${totalPages}`)
+        .setStyle(ButtonStyle.Secondary)
+        .setDisabled(true),
+      new ButtonBuilder()
+        .setCustomId(navId(`page:${page + 1}:${filter}`, provider))
+        .setLabel("▶")
+        .setStyle(ButtonStyle.Secondary)
+        .setDisabled(page >= totalPages),
+    );
+  }
+
+  // A filter that would keep everything is just a button that does nothing —
+  // offer it only when part of the catalog costs money.
+  if (freeCount > 0 && freeCount < pres.totalCount) {
+    buttons.push(
+      new ButtonBuilder()
+        .setCustomId(
+          navId(`filter:${filter === "free" ? "all" : "free"}`, provider),
+        )
+        .setLabel(filter === "free" ? `All models` : `Free only (${freeCount})`)
+        .setStyle(ButtonStyle.Secondary),
+    );
+  }
+
+  if (provider) {
+    buttons.push(
+      new ButtonBuilder()
+        .setCustomId(navId("providers"))
+        .setLabel("← Providers")
+        .setStyle(ButtonStyle.Secondary),
+    );
+  }
+
+  if (buttons.length === 0) return null;
+  return new ActionRowBuilder<ButtonBuilder>().addComponents(buttons);
+}
+
+export interface ModelPickerView {
+  content: string;
+  components: APIActionRowComponent<APIComponentInMessageActionRow>[];
+}
+
+/** Select of the backends config exposes, plus a way back to the models. */
+export function buildBackendPickerView(
+  backends: { id: string; label: string }[],
+  currentId: string,
+): ModelPickerView {
+  const menu = new StringSelectMenuBuilder()
+    .setCustomId("model:backend-select")
+    .setPlaceholder("Pick a backend")
+    .addOptions(
+      backends.map((b) => ({
+        label: safeSlice(b.label || b.id, 100),
+        value: safeSlice(b.id, 100),
+        description: b.id === currentId ? "current" : undefined,
+        default: b.id === currentId,
+      })),
+    );
+
+  const back = new ActionRowBuilder<ButtonBuilder>().addComponents(
+    new ButtonBuilder()
+      .setCustomId(navId("page:1:all"))
+      .setLabel("← Models")
+      .setStyle(ButtonStyle.Secondary),
+  );
+
+  return {
+    content: [
+      `**Backend:** \`${currentId}\``,
+      "",
+      "_Switching clears this chat's session — each backend keeps its own model pick._",
+    ].join("\n"),
+    components: [
+      new ActionRowBuilder<StringSelectMenuBuilder>()
+        .addComponents(menu)
+        .toJSON(),
+      back.toJSON(),
+    ],
+  };
+}
+
+/**
+ * Lay out one page of the picker. In the `groups` view the select lists
+ * providers to drill into; in `models` it lists selectable models.
+ */
+export function buildModelPickerView(
+  pres: ModelPickerResult,
+  displayName: string,
+  backendId: string,
+): ModelPickerView {
+  const isGroups = pres.view === "groups";
+  const options = pres.modelButtons.slice(0, MODEL_PAGE_SIZE).map((b) => ({
+    // Discord's own guidance is ~38 characters before a label starts
+    // truncating visually, well under the 100-character hard cap.
+    label: safeSlice(b.text.replace(/^✓ /, ""), 100),
+    value: safeSlice(
+      isGroups
+        ? b.callback_data.replace(/^.*:provider:/, "provider:")
+        : b.callback_data.replace(/^model:/, ""),
+      100,
+    ),
+    default: !isGroups && b.text.startsWith("✓"),
+  }));
+
+  const components: APIActionRowComponent<APIComponentInMessageActionRow>[] =
+    [];
+
+  if (options.length > 0) {
+    const menu = new StringSelectMenuBuilder()
+      .setCustomId("model:select")
+      .setPlaceholder(isGroups ? "Pick a provider" : "Pick a model")
+      .addOptions(options);
+    components.push(
+      new ActionRowBuilder<StringSelectMenuBuilder>()
+        .addComponents(menu)
+        .toJSON(),
+    );
+  }
+
+  const controls = controlRow(pres);
+  if (controls) components.push(controls.toJSON());
+
+  // Own row: the control row is already at Discord's five-button ceiling
+  // whenever the catalog pages.
+  components.push(
+    new ActionRowBuilder<ButtonBuilder>()
+      .addComponents(
+        new ButtonBuilder()
+          .setCustomId(navId("backends"))
+          .setLabel(`⚙ Backend: ${backendId}`)
+          .setStyle(ButtonStyle.Secondary),
+      )
+      .toJSON(),
+  );
+
+  const scope = pres.provider ? ` · ${pres.provider}` : "";
+  const counts =
+    pres.totalPages > 1
+      ? ` · ${pres.totalCount} model${pres.totalCount === 1 ? "" : "s"}`
+      : "";
+  const lines = [
+    `**Model:** \`${displayName}\`${scope}${counts}`,
+    ...pres.modelDetails,
+  ];
+
+  return { content: lines.join("\n"), components };
+}

package/src/frontend/shared/status-context.ts

@@ -303,7 +303,9 @@ export interface PlanWindowDisplay {
 export interface PlanDisplay {
   plan: string | undefined;
   windows: PlanWindowDisplay[];
-  /** Set only once the figures have aged, e.g. "12m ago". */
+  /** Set only when the account still has one-shot rate-limit resets left. */
+  resetsAvailable: number | undefined;
+  /** Set only when the figures have aged, e.g. "12m ago". */
   ageLabel: string | undefined;
 }
 
@@ -330,6 +332,7 @@ export function buildPlanDisplay(
   const age = Date.now() - usage.fetchedAt;
   return {
     plan: usage.plan,
+    resetsAvailable: usage.resetsAvailable,
     ageLabel:
       age > PLAN_STALE_AFTER_MS
         ? formatRelativeAge(usage.fetchedAt)

package/src/frontend/telegram/helpers/diagnostics.ts

@@ -222,6 +222,12 @@ export function renderUsageMessage(entries: BackendUsageEntry[]): string {
     const age = entry.plan.ageLabel ? ` <i>(${entry.plan.ageLabel})</i>` : "";
     const plan = entry.plan.plan ? ` · ${escapeHtml(entry.plan.plan)}` : "";
     lines.push("", `<b>${name}</b>${plan}${age}`);
+    if (entry.plan.resetsAvailable) {
+      const n = entry.plan.resetsAvailable;
+      lines.push(
+        `  • You have <b>${n}</b> usage limit reset${n === 1 ? "" : "s"} available`,
+      );
+    }
     for (const w of entry.plan.windows) {
       const reset = w.resetLabel ? ` reset ${w.resetLabel}` : "";
       lines.push(