talon-agent 4.3.2 → 4.3.3

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

@@ -0,0 +1,29 @@
+/**
+ * `model:done` / `model:noop` / unparseable — ack-only callbacks. Nothing
+ * to redraw; each answers the query itself.
+ */
+
+import type { Context } from "grammy";
+import { answerCallbackQuerySafe } from "../shared.js";
+import type { ModelOutcome } from "./types.js";
+
+// Acknowledge fast (within Telegram's 30s window) so the user
+// doesn't see a perpetual loading spinner.
+export async function handleDone(
+  ctx: Context,
+): Promise<ModelOutcome | undefined> {
+  await answerCallbackQuerySafe(ctx, { text: "Done" });
+  try {
+    await ctx.deleteMessage();
+  } catch {
+    /* might lack delete permission */
+  }
+  return undefined;
+}
+
+export async function handleNoop(
+  ctx: Context,
+): Promise<ModelOutcome | undefined> {
+  await answerCallbackQuerySafe(ctx);
+  return undefined;
+}

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

@@ -0,0 +1,54 @@
+/**
+ * View navigation — `model:menu`, `model:browse`, `model:nav:*`,
+ * `model:backends`. No state changes; each just names the view to redraw.
+ */
+
+import type { ModelCallback } from "../../model-callbacks.js";
+import type { ModelOutcome } from "./types.js";
+
+export async function showMenu(): Promise<ModelOutcome> {
+  return { view: { kind: "menu" } };
+}
+
+export async function showBrowse(): Promise<ModelOutcome> {
+  return { view: { kind: "browse" } };
+}
+
+export async function navBackToProviders(): Promise<ModelOutcome> {
+  return { view: { kind: "browse", backToGroups: true, page: 1 } };
+}
+
+export async function navProvider(
+  _ctx: unknown,
+  action: Extract<ModelCallback, { kind: "nav-provider" }>,
+): Promise<ModelOutcome> {
+  return { view: { kind: "browse", provider: action.provider, page: 1 } };
+}
+
+export async function navPage(
+  _ctx: unknown,
+  action: Extract<ModelCallback, { kind: "nav-page" }>,
+): Promise<ModelOutcome> {
+  return {
+    view: {
+      kind: "browse",
+      page: action.page,
+      filter: action.filter,
+      provider: action.provider,
+    },
+  };
+}
+
+// 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.
+export async function navFilter(
+  _ctx: unknown,
+  action: Extract<ModelCallback, { kind: "nav-filter" }>,
+): Promise<ModelOutcome> {
+  return { view: { kind: "browse", filter: action.filter, page: 1 } };
+}
+
+export async function showBackends(): Promise<ModelOutcome> {
+  return { view: { kind: "backends" } };
+}

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