talon-agent 4.3.2 → 4.3.3

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 "./shared.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);
 }