talon-agent 4.3.2 → 4.4.0

package/src/frontend/telegram/callbacks/model/select.ts

@@ -0,0 +1,100 @@
+/**
+ * Model selection — `model:<id>`, `model:reset`, `model:toggle-free`.
+ *
+ * Every branch resolves the *per-chat* backend so the pick is validated
+ * against, and stored under, the backend the chat actually runs on.
+ */
+
+import type { Context } from "grammy";
+import {
+  setChatModelForBackend,
+  setChatBackend,
+} from "../../../../storage/chat-settings.js";
+import { resolveModelId as resolveModelName } from "../../../../core/models/catalog.js";
+import { getBackendIdForChat } from "../../../../core/engine/backend-controller/index.js";
+import { resolveActiveModelForChat } from "../../../../core/models/active-model.js";
+import type { ModelCallback } from "../../model-callbacks.js";
+import { resolveBackendForChat, toggleChatFreeOnly } from "../../model-menu.js";
+import { answerCallbackQuerySafe, type CallbackDeps } from "../query.js";
+import type { ModelOutcome } from "./types.js";
+
+export async function handleSelect(
+  ctx: Context,
+  action: Extract<ModelCallback, { kind: "select" }>,
+  cid: string,
+  { config, gateway }: CallbackDeps,
+): Promise<ModelOutcome | undefined> {
+  // Resolve selection against the *per-chat* backend — if the
+  // chat has switched to openai-agents we must validate the id
+  // against that catalog, not the global default's.
+  const be = resolveBackendForChat(cid, gateway);
+  const beId = getBackendIdForChat(cid);
+  if (be?.models?.resolveModelInfo) {
+    const resolution = await be.models?.resolveModelInfo(action.modelId);
+    if (resolution.kind !== "exact" || !resolution.model.selectable) {
+      await answerCallbackQuerySafe(ctx, {
+        text:
+          resolution.kind === "exact"
+            ? (resolution.model.unavailableReason ?? "Unavailable")
+            : "Model is unavailable",
+      });
+      return undefined;
+    }
+    // Persist the pick into the chat's *backend-specific* slot.
+    // Switching backends later restores each side's prior choice
+    // automatically — the slot isn't shared across backends.
+    setChatModelForBackend(cid, beId, resolution.storedValue);
+    // Also pin the chat to this backend so a restart doesn't
+    // unbind to the role-default and orphan the model id.
+    setChatBackend(cid, beId);
+    return {
+      toast: `Model: ${resolution.model.displayName}`,
+      view: { kind: "menu" },
+    };
+  }
+  setChatModelForBackend(cid, beId, resolveModelName(action.modelId));
+  setChatBackend(cid, beId);
+  const { model: resolved } = await resolveActiveModelForChat(
+    cid,
+    be,
+    beId,
+    config,
+  );
+  return { toast: `Model: ${resolved ?? "(unset)"}`, view: { kind: "menu" } };
+}
+
+export async function handleReset(
+  _ctx: Context,
+  _action: Extract<ModelCallback, { kind: "reset" }>,
+  cid: string,
+  { config, gateway }: CallbackDeps,
+): Promise<ModelOutcome> {
+  // Clear this backend's slot only — other backends' picks stay.
+  // Compute the toast through the resolver so the label names the
+  // backend's actual default (or "No model selected" when there
+  // isn't one — catalog-driven backend, no operator config).
+  const be = resolveBackendForChat(cid, gateway);
+  const beId = getBackendIdForChat(cid);
+  setChatModelForBackend(cid, beId, undefined);
+  const { model: resolvedDefault } = await resolveActiveModelForChat(
+    cid,
+    be,
+    beId,
+    config,
+  );
+  return {
+    toast: resolvedDefault
+      ? `Model reset to default (${resolvedDefault})`
+      : `Model reset — no default available, pick one`,
+    view: { kind: "menu" },
+  };
+}
+
+export async function handleToggleFree(
+  _ctx: Context,
+  _action: Extract<ModelCallback, { kind: "toggle-free" }>,
+  cid: string,
+): Promise<ModelOutcome> {
+  const next = toggleChatFreeOnly(cid);
+  return { toast: `Free only: ${next ? "on" : "off"}`, view: { kind: "menu" } };
+}

package/src/frontend/telegram/callbacks/model/types.ts

@@ -0,0 +1,39 @@
+/**
+ * Types for the `model:*` callback handlers.
+ *
+ * A handler mutates at most one piece of chat-settings (or pool) state and
+ * hands the router what to do next: a toast to answer the query with (or a
+ * plain ack) and the view to redraw. It returns `undefined` when it already
+ * answered the query itself — an error toast, or the "done" close — and
+ * there is nothing to redraw.
+ */
+
+import type { Context } from "grammy";
+import type { ModelCallback } from "../../model-callbacks.js";
+import type { CallbackDeps } from "../query.js";
+
+export type ModelView =
+  | { kind: "menu" }
+  | { kind: "backends" }
+  | {
+      kind: "browse";
+      page?: number;
+      filter?: "all" | "free";
+      provider?: string;
+      backToGroups?: boolean;
+    };
+
+export type ModelOutcome = { toast?: string; view: ModelView };
+
+export type ModelCallbackHandler<A extends ModelCallback = ModelCallback> = (
+  ctx: Context,
+  action: A,
+  cid: string,
+  deps: CallbackDeps,
+) => Promise<ModelOutcome | undefined>;
+
+export type ModelCallbackHandlers = {
+  [K in ModelCallback["kind"]]: ModelCallbackHandler<
+    Extract<ModelCallback, { kind: K }>
+  >;
+};

package/src/frontend/telegram/callbacks/model/views.ts

@@ -0,0 +1,116 @@
+/**
+ * Re-render the /model message in one of its three views: main menu,
+ * backend submenu, or browse.
+ */
+
+import type { Context } from "grammy";
+import { escapeHtml } from "../../formatting.js";
+import {
+  renderModelMenuText,
+  renderModelMenuKeyboard,
+  renderModelBrowseKeyboard,
+  renderBackendMenuKeyboard,
+  renderBackendMenuText,
+} from "../../helpers/index.js";
+import {
+  buildModelMenuViewForChat,
+  buildModelBrowseViewForChat,
+  buildBackendMenuViewForChat,
+} from "../../model-menu.js";
+import { editOrIgnoreSame, type CallbackDeps } from "../query.js";
+import type { ModelView } from "./types.js";
+
+export async function renderModelView(
+  ctx: Context,
+  view: ModelView,
+  cid: string,
+  deps: CallbackDeps,
+): Promise<void> {
+  if (view.kind === "menu") return renderMenu(ctx, cid, deps);
+  if (view.kind === "backends") return renderBackends(ctx, cid, deps);
+  return renderBrowse(ctx, view, cid, deps);
+}
+
+async function renderMenu(
+  ctx: Context,
+  cid: string,
+  { config, gateway }: CallbackDeps,
+): Promise<void> {
+  const view = await buildModelMenuViewForChat(cid, config, gateway);
+  if (!view) return;
+  await editOrIgnoreSame(
+    ctx,
+    renderModelMenuText(view.state),
+    renderModelMenuKeyboard(view.state),
+  );
+}
+
+async function renderBackends(
+  ctx: Context,
+  cid: string,
+  { config }: CallbackDeps,
+): Promise<void> {
+  const menu = buildBackendMenuViewForChat(cid, config);
+  await editOrIgnoreSame(
+    ctx,
+    renderBackendMenuText({
+      activeBackend: menu.activeBackend,
+      hasBackendOverride: menu.hasBackendOverride,
+      defaultBackendLabel: menu.defaultBackendLabel,
+    }),
+    renderBackendMenuKeyboard({
+      available: menu.available,
+      activeBackendId: menu.activeBackend.id,
+      hasBackendOverride: menu.hasBackendOverride,
+    }),
+  );
+}
+
+// browse view — controller picks the per-chat backend and
+// applies the chat's freeOnly preference when the caller
+// doesn't override the filter explicitly. `backToGroups`
+// means "drop any cached provider drill" so we omit `provider`.
+async function renderBrowse(
+  ctx: Context,
+  view: Extract<ModelView, { kind: "browse" }>,
+  cid: string,
+  { config, gateway }: CallbackDeps,
+): Promise<void> {
+  const browse = await buildModelBrowseViewForChat(
+    cid,
+    config,
+    {
+      ...(view.filter !== undefined ? { filter: view.filter } : {}),
+      ...(view.page !== undefined ? { page: view.page } : {}),
+      ...(view.provider !== undefined && !view.backToGroups
+        ? { provider: view.provider }
+        : {}),
+    },
+    gateway,
+  );
+  if (!browse) return;
+  const lines = [
+    `<b>Model:</b> <code>${escapeHtml(browse.activeDisplay)}</code>`,
+    ...browse.modelDetails.map(escapeHtml),
+    ...(browse.filter === "free" && browse.freeCount > 0
+      ? ["<i>Filter: free-tier only.</i>"]
+      : []),
+  ];
+  await editOrIgnoreSame(
+    ctx,
+    lines.join("\n"),
+    renderModelBrowseKeyboard(
+      browse.modelButtons,
+      {
+        page: browse.page,
+        totalPages: browse.totalPages,
+        filter: browse.filter,
+        freeCount: browse.freeCount,
+        totalCount: browse.totalCount,
+      },
+      browse.view,
+      browse.provider,
+      "model:menu",
+    ),
+  );
+}

package/src/frontend/telegram/callbacks/model.ts

@@ -1,359 +1,89 @@
 /**
- * `model:*` callbacks — the /model menu controller. Each branch mutates at
- * most one piece of chat-settings (or pool) state and then re-renders one of
- * three views: main menu, backend submenu, or browse.
+ * `model:*` callbacks — the /model menu controller. Each handler mutates at
+ * most one piece of chat-settings (or pool) state, then the router
+ * re-renders one of three views: main menu, backend submenu, or browse.
  *
  * The controller always resolves the *per-chat* backend so the menu reflects
  * active per-chat overrides instead of the global chat-role default.
+ *
+ * Callback data is parsed by `parseModelCallback` (model-callbacks.ts); the
+ * table below maps each parsed `kind` to its handler in `model/`:
+ *   - `control` — done / noop / unknown (ack only)
+ *   - `select`  — select / reset / toggle-free
+ *   - `nav`     — menu / browse / nav-* / backends (view changes only)
+ *   - `backend` — backend-select / backend-default (rebind + handoff)
+ *   - `views`   — the three renderers
  */
 
 import type { Context } from "grammy";
-import {
-  setChatModelForBackend,
-  setChatBackend,
-} from "../../../storage/chat-settings.js";
-import { resolveModelId as resolveModelName } from "../../../core/models/catalog.js";
-import { resetSession } from "../../../storage/sessions.js";
-import { clearHistory } from "../../../storage/history.js";
-import {
-  getBackendIdForChat,
-  listAvailableBackends,
-  rebindChat,
-  releaseChat,
-} from "../../../core/engine/backend-controller/index.js";
-import { resetPulseCheckpoint } from "../../../core/background/pulse.js";
-import { escapeHtml } from "../formatting.js";
-import {
-  renderModelMenuText,
-  renderModelMenuKeyboard,
-  renderModelBrowseKeyboard,
-  renderBackendMenuKeyboard,
-  renderBackendMenuText,
-} from "../helpers/index.js";
 import { parseModelCallback } from "../model-callbacks.js";
+import { answerCallbackQuerySafe, type CallbackDeps } from "./query.js";
+import { handleDone, handleNoop } from "./model/control.js";
+import { handleSelect, handleReset, handleToggleFree } from "./model/select.js";
 import {
-  buildModelMenuViewForChat,
-  buildModelBrowseViewForChat,
-  buildBackendMenuViewForChat,
-  resolveBackendForChat,
-  toggleChatFreeOnly,
-} from "../model-menu.js";
-import { resolveActiveModelForChat } from "../../../core/models/active-model.js";
-import {
-  answerCallbackQuerySafe,
-  editOrIgnoreSame,
-  type CallbackDeps,
-} from "./shared.js";
-import { logWarn } from "../../../util/log.js";
+  showMenu,
+  showBrowse,
+  navBackToProviders,
+  navProvider,
+  navPage,
+  navFilter,
+  showBackends,
+} from "./model/nav.js";
+import { handleBackendSelect, handleBackendDefault } from "./model/backend.js";
+import { renderModelView } from "./model/views.js";
+import type {
+  ModelCallbackHandler,
+  ModelCallbackHandlers,
+} from "./model/types.js";
 
-/**
- * Run the backend-side half of a chat's session handoff.
- *
- * A backend switch already clears Talon's own stores (session row,
- * history, pulse checkpoint), but those are only half the state.
- * `performSessionReset` also drives the backend capability slots, and
- * the switch path skipped them entirely:
- *
- *   - the OUTGOING backend keeps in-process per-chat state that no
- *     amount of clearing Talon's stores touches. openai-agents holds a
- *     `MemorySession` map keyed by chat id, so switching away and back
- *     resurrected the old conversation the operator meant to drop.
- *   - the INCOMING backend was never warmed, so the first turn after a
- *     switch paid the full cold start — on OpenCode/Kilo that is session
- *     creation plus a per-plugin MCP registration sweep.
- *
- * The warm is deliberately fire-and-forget: it can take seconds, and the
- * callback still has a toast to answer and a menu to redraw. Telegram
- * expires an unanswered callback query, so blocking here would trade a
- * cold first turn for a visibly stuck button.
- */
-function handOffBackendSession(
-  chatId: string,
-  previousBackend: ReturnType<typeof resolveBackendForChat>,
-  gateway: CallbackDeps["gateway"],
-): void {
-  previousBackend?.sessions?.resetChat?.(chatId);
-  const nextBackend = resolveBackendForChat(chatId, gateway);
-  // Same instance on a no-op switch — warming it again is harmless
-  // (every step is idempotent) but pointless, so skip it.
-  if (!nextBackend || nextBackend === previousBackend) return;
-  void Promise.resolve(nextBackend.sessions?.warmSession?.(chatId)).catch(
-    (err) =>
-      logWarn(
-        "bot",
-        `[${chatId}] warm after backend switch failed: ${err instanceof Error ? err.message : String(err)}`,
-      ),
-  );
-}
+// Null-prototype so a parsed kind can never resolve an inherited
+// Object.prototype method via `handlers[kind]`.
+export const MODEL_CALLBACK_HANDLERS: ModelCallbackHandlers = Object.assign(
+  Object.create(null),
+  {
+    done: handleDone,
+    noop: handleNoop,
+    unknown: handleNoop,
+    select: handleSelect,
+    reset: handleReset,
+    "toggle-free": handleToggleFree,
+    menu: showMenu,
+    browse: showBrowse,
+    "nav-back-to-providers": navBackToProviders,
+    "nav-provider": navProvider,
+    "nav-page": navPage,
+    "nav-filter": navFilter,
+    backends: showBackends,
+    "backend-select": handleBackendSelect,
+    "backend-default": handleBackendDefault,
+  } satisfies ModelCallbackHandlers,
+);
 
 export async function handleModelCallback(
   ctx: Context,
   data: string,
   cid: string,
-  { config, gateway }: CallbackDeps,
+  deps: CallbackDeps,
 ): Promise<void> {
   const action = parseModelCallback(data);
-
-  // Acknowledge fast (within Telegram's 30s window) so the user
-  // doesn't see a perpetual loading spinner.
-  if (action.kind === "done") {
-    await answerCallbackQuerySafe(ctx, { text: "Done" });
-    try {
-      await ctx.deleteMessage();
-    } catch {
-      /* might lack delete permission */
-    }
-    return;
-  }
-  if (action.kind === "noop" || action.kind === "unknown") {
+  // Every parsed kind has a handler; the cast only widens the parameter
+  // type so the union action can be passed through.
+  const handler = MODEL_CALLBACK_HANDLERS[action.kind] as
+    ModelCallbackHandler | undefined;
+  if (!handler) {
     await answerCallbackQuerySafe(ctx);
     return;
   }
-
-  // State-mutating actions.
-  let toast: string | undefined;
-  let viewAfter: "menu" | "browse" | "backends" = "menu";
-  let browsePage: number | undefined;
-  let browseFilter: "all" | "free" | undefined;
-  let browseProvider: string | undefined;
-  let browseBackToGroups = false;
-
-  if (action.kind === "select") {
-    // Resolve selection against the *per-chat* backend — if the
-    // chat has switched to openai-agents we must validate the id
-    // against that catalog, not the global default's.
-    const be = resolveBackendForChat(cid, gateway);
-    const beId = getBackendIdForChat(cid);
-    if (be?.models?.resolveModelInfo) {
-      const resolution = await be.models?.resolveModelInfo(action.modelId);
-      if (resolution.kind !== "exact" || !resolution.model.selectable) {
-        await answerCallbackQuerySafe(ctx, {
-          text:
-            resolution.kind === "exact"
-              ? (resolution.model.unavailableReason ?? "Unavailable")
-              : "Model is unavailable",
-        });
-        return;
-      }
-      // Persist the pick into the chat's *backend-specific* slot.
-      // Switching backends later restores each side's prior choice
-      // automatically — the slot isn't shared across backends.
-      setChatModelForBackend(cid, beId, resolution.storedValue);
-      // Also pin the chat to this backend so a restart doesn't
-      // unbind to the role-default and orphan the model id.
-      setChatBackend(cid, beId);
-      toast = `Model: ${resolution.model.displayName}`;
-    } else {
-      setChatModelForBackend(cid, beId, resolveModelName(action.modelId));
-      setChatBackend(cid, beId);
-      const { model: resolved } = await resolveActiveModelForChat(
-        cid,
-        be,
-        beId,
-        config,
-      );
-      toast = `Model: ${resolved ?? "(unset)"}`;
-    }
-  } else if (action.kind === "reset") {
-    // Clear this backend's slot only — other backends' picks stay.
-    // Compute the toast through the resolver so the label names the
-    // backend's actual default (or "No model selected" when there
-    // isn't one — catalog-driven backend, no operator config).
-    const be = resolveBackendForChat(cid, gateway);
-    const beId = getBackendIdForChat(cid);
-    setChatModelForBackend(cid, beId, undefined);
-    const { model: resolvedDefault } = await resolveActiveModelForChat(
-      cid,
-      be,
-      beId,
-      config,
-    );
-    toast = resolvedDefault
-      ? `Model reset to default (${resolvedDefault})`
-      : `Model reset — no default available, pick one`;
-  } else if (action.kind === "toggle-free") {
-    const next = toggleChatFreeOnly(cid);
-    toast = `Free only: ${next ? "on" : "off"}`;
-  } else if (action.kind === "menu") {
-    viewAfter = "menu";
-  } else if (action.kind === "browse") {
-    viewAfter = "browse";
-  } else if (action.kind === "nav-back-to-providers") {
-    viewAfter = "browse";
-    browseBackToGroups = true;
-    browsePage = 1;
-  } else if (action.kind === "nav-provider") {
-    viewAfter = "browse";
-    browseProvider = action.provider;
-    browsePage = 1;
-  } else if (action.kind === "nav-page") {
-    viewAfter = "browse";
-    browsePage = action.page;
-    browseFilter = action.filter;
-    browseProvider = action.provider;
-  } else if (action.kind === "nav-filter") {
-    // Legacy support — current UX promotes free-toggle on the main
-    // menu, but a `model:nav:filter:*` payload from an old message
-    // still routes to the browse view with that filter applied.
-    viewAfter = "browse";
-    browseFilter = action.filter;
-    browsePage = 1;
-  } else if (action.kind === "backends") {
-    viewAfter = "backends";
-  } else if (action.kind === "backend-select") {
-    // Rebind chat to the chosen backend. Verify the requested id
-    // is on the enabled list to keep the menu and the operation
-    // in sync — `config.enabledBackends` is a UX filter and we
-    // honour it here too.
-    const available = listAvailableBackends(config);
-    if (!available.some((b) => b.id === action.backendId)) {
-      await answerCallbackQuerySafe(ctx, {
-        text: "Backend not available",
-      });
-      return;
-    }
-    // Resolve the outgoing backend BEFORE rebinding — afterwards this
-    // chat already points at the new one and the old in-process state
-    // would be unreachable.
-    const previousBackend = resolveBackendForChat(cid, gateway);
-    const result = await rebindChat(cid, action.backendId, config);
-    if (!result.ok) {
-      await answerCallbackQuerySafe(ctx, {
-        text: result.error?.slice(0, 200) ?? "Rebind failed",
-      });
-      return;
-    }
-    setChatBackend(cid, action.backendId);
-    // Switching backends drops the previous backend's per-chat
-    // session state (it's not portable across backends). We DO
-    // NOT clear `modelByBackend` — keeping each backend's prior
-    // pick means switching back-and-forth restores each side's
-    // last choice automatically (Codex chat keeps gpt-5.5,
-    // OpenRouter chat keeps owl-alpha, etc).
-    resetSession(cid);
-    clearHistory(cid);
-    resetPulseCheckpoint(cid);
-    handOffBackendSession(cid, previousBackend, gateway);
-    const label =
-      available.find((b) => b.id === action.backendId)?.label ??
-      action.backendId;
-    // Toast names the model the new backend will actually run
-    // (per-chat slot if remembered, else canonical / operator
-    // default; "no default" if catalog-driven with no config).
-    const newBackend = resolveBackendForChat(cid, gateway);
-    const { model: resolvedNewModel } = await resolveActiveModelForChat(
-      cid,
-      newBackend,
-      action.backendId,
-      config,
-    );
-    toast = resolvedNewModel
-      ? `Backend: ${label} (model: ${resolvedNewModel})`
-      : `Backend: ${label} — no default model, /model to pick one`;
-    viewAfter = "menu";
-  } else if (action.kind === "backend-default") {
-    // Drop the per-chat backend override; chat reverts to the
-    // global chat-role backend. Per-backend model picks are
-    // preserved (modelByBackend stays intact) so reverting and
-    // switching back later still restores prior choices.
-    const previousBackend = resolveBackendForChat(cid, gateway);
-    await releaseChat(cid);
-    setChatBackend(cid, undefined);
-    resetSession(cid);
-    clearHistory(cid);
-    resetPulseCheckpoint(cid);
-    handOffBackendSession(cid, previousBackend, gateway);
-    // Resolve the now-default backend's model for the toast.
-    const defaultBackend = resolveBackendForChat(cid, gateway);
-    const defaultBackendId = getBackendIdForChat(cid);
-    const { model: resolvedRoleModel } = await resolveActiveModelForChat(
-      cid,
-      defaultBackend,
-      defaultBackendId,
-      config,
-    );
-    toast = resolvedRoleModel
-      ? `Backend reset to default (model: ${resolvedRoleModel})`
-      : `Backend reset to default — no model picked, /model to pick one`;
-    viewAfter = "menu";
-  }
+  const outcome = await handler(ctx, action, cid, deps);
+  if (!outcome) return;
 
   // Selection / reset / toggle confirmations toast briefly.
-  if (toast !== undefined) {
-    await answerCallbackQuerySafe(ctx, { text: toast });
+  if (outcome.toast !== undefined) {
+    await answerCallbackQuerySafe(ctx, { text: outcome.toast });
   } else {
     await answerCallbackQuerySafe(ctx);
   }
 
   // Re-render the message in the appropriate view.
-  if (viewAfter === "menu") {
-    const view = await buildModelMenuViewForChat(cid, config, gateway);
-    if (!view) return;
-    await editOrIgnoreSame(
-      ctx,
-      renderModelMenuText(view.state),
-      renderModelMenuKeyboard(view.state),
-    );
-    return;
-  }
-
-  if (viewAfter === "backends") {
-    const menu = buildBackendMenuViewForChat(cid, config);
-    await editOrIgnoreSame(
-      ctx,
-      renderBackendMenuText({
-        activeBackend: menu.activeBackend,
-        hasBackendOverride: menu.hasBackendOverride,
-        defaultBackendLabel: menu.defaultBackendLabel,
-      }),
-      renderBackendMenuKeyboard({
-        available: menu.available,
-        activeBackendId: menu.activeBackend.id,
-        hasBackendOverride: menu.hasBackendOverride,
-      }),
-    );
-    return;
-  }
-
-  // browse view — controller picks the per-chat backend and
-  // applies the chat's freeOnly preference when the caller
-  // doesn't override the filter explicitly. `browseBackToGroups`
-  // means "drop any cached provider drill" so we omit `provider`.
-  const browse = await buildModelBrowseViewForChat(
-    cid,
-    config,
-    {
-      ...(browseFilter !== undefined ? { filter: browseFilter } : {}),
-      ...(browsePage !== undefined ? { page: browsePage } : {}),
-      ...(browseProvider !== undefined && !browseBackToGroups
-        ? { provider: browseProvider }
-        : {}),
-    },
-    gateway,
-  );
-  if (!browse) return;
-  const lines = [
-    `<b>Model:</b> <code>${escapeHtml(browse.activeDisplay)}</code>`,
-    ...browse.modelDetails.map(escapeHtml),
-    ...(browse.filter === "free" && browse.freeCount > 0
-      ? ["<i>Filter: free-tier only.</i>"]
-      : []),
-  ];
-  await editOrIgnoreSame(
-    ctx,
-    lines.join("\n"),
-    renderModelBrowseKeyboard(
-      browse.modelButtons,
-      {
-        page: browse.page,
-        totalPages: browse.totalPages,
-        filter: browse.filter,
-        freeCount: browse.freeCount,
-        totalCount: browse.totalCount,
-      },
-      browse.view,
-      browse.provider,
-      "model:menu",
-    ),
-  );
+  await renderModelView(ctx, outcome.view, cid, deps);
 }

package/src/frontend/telegram/callbacks/pulse.ts

@@ -9,7 +9,7 @@ import {
   enablePulse,
   isPulseEnabled,
 } from "../../../core/background/pulse.js";
-import { answerCallbackQuerySafe } from "./shared.js";
+import { answerCallbackQuerySafe } from "./query.js";
 
 export async function handlePulseCallback(
   ctx: Context,