talon-agent 3.34.1 → 3.36.0

package/src/frontend/shared/model-commands.ts

@@ -0,0 +1,400 @@
+/**
+ * Frontend-agnostic `/model`, `/effort` and backend-switch operations.
+ *
+ * Telegram and Discord drive these through inline buttons and select
+ * menus; a text-only frontend (WhatsApp) has to do the same work from a
+ * typed argument — "the third model in the list", "switch to codex",
+ * "effort high". The state changes are identical either way, so they
+ * live here, shaped as plain data + plain-text outcomes that every
+ * frontend can wrap in its own markup. Nothing in this module knows
+ * about a socket, a bot API, or a keyboard.
+ */
+
+import type { TalonConfig } from "../../util/config.js";
+import type { Backend } from "../../core/agent-runtime/capabilities.js";
+import type { ReasoningEffortLevel } from "../../core/types.js";
+import {
+  getChatSettings,
+  setChatBackend,
+  setChatEffort,
+  setChatModelForBackend,
+  type EffortLevel,
+} from "../../storage/chat-settings.js";
+import { resolveModelId as resolveModelName } from "../../core/models/catalog.js";
+import { resolveActiveModelForChat } from "../../core/models/active-model.js";
+import {
+  getBackendIdForChat,
+  hasBackendPool,
+  hasChatBackendOverride,
+  listAvailableBackends,
+  rebindChat,
+  releaseChat,
+  resolveChatBackend,
+} 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 { logWarn } from "../../util/log.js";
+import {
+  displayReasoningEffort,
+  getActiveReasoningLevels,
+  supportsReasoningLevel,
+} from "./reasoning-levels.js";
+
+export type ModelCommandDeps = {
+  config: TalonConfig;
+  gateway?: { backend: Backend | null };
+};
+
+/** Outcome of a state-changing command, ready to be sent as-is. */
+export type CommandOutcome = { ok: boolean; text: string };
+
+/** One selectable catalog entry, numbered for text pickers. */
+type ModelChoice = {
+  /** 1-based position in the listing — what `/model <n>` refers to. */
+  index: number;
+  id: string;
+  displayName: string;
+  providerName: string;
+  free: boolean;
+};
+
+export type ModelOverview = {
+  backendId: string;
+  backendLabel: string;
+  hasBackendOverride: boolean;
+  backends: Array<{ id: string; label: string }>;
+  /** Resolved active model id, or null when the chat has none to run on. */
+  activeModel: string | null;
+  activeDisplay: string | null;
+  /** True when the chat pins a model other than the backend's default. */
+  hasModelOverride: boolean;
+  choices: ModelChoice[];
+};
+
+/** The backend + id serving a chat right now (pool-aware, test-safe). */
+export function resolveChatBackendPair(
+  chatId: string,
+  deps: ModelCommandDeps,
+): { backend: Backend | null; backendId: string } {
+  return {
+    backend: resolveChatBackend(chatId, deps.gateway?.backend ?? null),
+    backendId: hasBackendPool()
+      ? getBackendIdForChat(chatId)
+      : deps.config.backend,
+  };
+}
+
+/**
+ * The selectable catalog of the chat's backend, numbered in catalog
+ * order. Same call on the listing and on the pick, so `/model 3` names
+ * the same entry the user just read. Empty for fixed-model backends.
+ */
+async function listModelChoices(
+  backend: Backend | null,
+): Promise<ModelChoice[]> {
+  if (!backend?.models?.listModels) return [];
+  try {
+    const { models } = await backend.models.listModels("all");
+    return models
+      .filter((m) => m.selectable)
+      .map((m, i) => ({
+        index: i + 1,
+        id: m.id,
+        displayName: m.displayName,
+        providerName: m.providerName,
+        free: m.free === true,
+      }));
+  } catch (err) {
+    logWarn(
+      "settings",
+      `listModels failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return [];
+  }
+}
+
+/** Everything a text `/model` listing shows. */
+export async function describeChatModels(
+  chatId: string,
+  deps: ModelCommandDeps,
+): Promise<ModelOverview> {
+  const { backend, backendId } = resolveChatBackendPair(chatId, deps);
+  const backends = listAvailableBackends(deps.config);
+  const backendLabel =
+    backends.find((b) => b.id === backendId)?.label ??
+    backend?.label ??
+    backendId;
+  const { model, ref, source } = await resolveActiveModelForChat(
+    chatId,
+    backend,
+    backendId,
+    deps.config,
+  );
+  return {
+    backendId,
+    backendLabel,
+    hasBackendOverride: hasBackendPool() && hasChatBackendOverride(chatId),
+    backends,
+    activeModel: model,
+    activeDisplay: ref?.displayName ?? model,
+    hasModelOverride: source === "override-valid",
+    choices: await listModelChoices(backend),
+  };
+}
+
+/**
+ * Pin a model for the chat. `query` is a catalog id, a fuzzy name the
+ * backend resolves, or a 1-based number from `describeChatModels`.
+ * Mirrors Telegram's `/model <arg>`: the pick lands in the backend's
+ * own slot and the chat is pinned to that backend so a restart can't
+ * orphan the id.
+ */
+export async function selectChatModel(
+  chatId: string,
+  query: string,
+  deps: ModelCommandDeps,
+): Promise<CommandOutcome> {
+  const { backend, backendId } = resolveChatBackendPair(chatId, deps);
+  let wanted = query.trim();
+  if (/^\d+$/.test(wanted)) {
+    const choices = await listModelChoices(backend);
+    const choice = choices[Number(wanted) - 1];
+    if (!choice) {
+      return {
+        ok: false,
+        text: choices.length
+          ? `No model #${wanted} — the list has ${choices.length} entries.`
+          : `This backend has no numbered model list; give a model id instead.`,
+      };
+    }
+    wanted = choice.id;
+  }
+
+  if (!backend?.models?.resolveModelInfo) {
+    const model = resolveModelName(wanted);
+    setChatModelForBackend(chatId, backendId, model);
+    setChatBackend(chatId, backendId);
+    return { ok: true, text: `Model set to ${model}.` };
+  }
+  const resolution = await backend.models.resolveModelInfo(wanted);
+  if (resolution.kind !== "exact") {
+    return {
+      ok: false,
+      text:
+        backend.models.formatModelError?.(wanted, resolution) ??
+        `No model matched "${wanted}".`,
+    };
+  }
+  if (!resolution.model.selectable) {
+    return {
+      ok: false,
+      text:
+        resolution.model.unavailableReason ??
+        `${resolution.model.providerName} is not connected.`,
+    };
+  }
+  setChatModelForBackend(chatId, backendId, resolution.storedValue);
+  setChatBackend(chatId, backendId);
+  const tag = resolution.model.free ? " · free" : "";
+  return {
+    ok: true,
+    text: `Model set to ${resolution.storedValue} (${resolution.model.providerName}${tag}).`,
+  };
+}
+
+/** Clear the chat's pick on its current backend; other backends' picks stay. */
+export async function resetChatModel(
+  chatId: string,
+  deps: ModelCommandDeps,
+): Promise<CommandOutcome> {
+  const { backend, backendId } = resolveChatBackendPair(chatId, deps);
+  setChatModelForBackend(chatId, backendId, undefined);
+  const { model } = await resolveActiveModelForChat(
+    chatId,
+    backend,
+    backendId,
+    deps.config,
+  );
+  return {
+    ok: true,
+    text: model
+      ? `Model reset to default: ${model}.`
+      : `Model reset — no default available for backend ${backendId}; pick one with /model.`,
+  };
+}
+
+/** The backend an argument names, matched by id or label, else null. */
+export function matchBackendArg(
+  arg: string,
+  config: TalonConfig,
+): { id: string; label: string } | null {
+  const wanted = arg.trim().toLowerCase();
+  if (!wanted) return null;
+  return (
+    listAvailableBackends(config).find(
+      (b) => b.id.toLowerCase() === wanted || b.label.toLowerCase() === wanted,
+    ) ?? null
+  );
+}
+
+/**
+ * Drop the session state a backend switch invalidates. Session ids are
+ * not portable across backends; each backend's remembered model pick IS
+ * kept, so switching back restores it. `keepHistory` is for frontends
+ * whose local history store is the only record of the chat.
+ */
+function handOffChatSession(
+  chatId: string,
+  previous: Backend | null,
+  deps: ModelCommandDeps,
+  keepHistory: boolean,
+): void {
+  resetSession(chatId);
+  if (!keepHistory) clearHistory(chatId);
+  resetPulseCheckpoint(chatId);
+  previous?.sessions?.resetChat?.(chatId);
+  const next = resolveChatBackend(chatId, deps.gateway?.backend ?? null);
+  // Warming can take seconds on OpenCode/Kilo; the reply must not wait.
+  if (!next || next === previous) return;
+  void Promise.resolve(next.sessions?.warmSession?.(chatId)).catch((err) =>
+    logWarn(
+      "settings",
+      `[${chatId}] warm after backend switch failed: ${err instanceof Error ? err.message : String(err)}`,
+    ),
+  );
+}
+
+/** Model line for the post-switch confirmation. */
+async function describeModelAfterSwitch(
+  chatId: string,
+  backendId: string,
+  deps: ModelCommandDeps,
+): Promise<string> {
+  const backend = resolveChatBackend(chatId, deps.gateway?.backend ?? null);
+  const { model } = await resolveActiveModelForChat(
+    chatId,
+    backend,
+    backendId,
+    deps.config,
+  );
+  return model ? `model: ${model}` : "no default model — /model to pick one";
+}
+
+/**
+ * Rebind the chat to another backend. Same sequence as Telegram's
+ * backend submenu; re-selecting the backend already in use only pins
+ * the choice and costs the session nothing.
+ */
+export async function switchChatBackend(
+  chatId: string,
+  target: { id: string; label: string },
+  deps: ModelCommandDeps,
+  opts: { keepHistory?: boolean } = {},
+): Promise<CommandOutcome> {
+  const { backend: previous, backendId: previousId } = resolveChatBackendPair(
+    chatId,
+    deps,
+  );
+  if (previousId === target.id) {
+    setChatBackend(chatId, target.id);
+    return {
+      ok: true,
+      text: `Already on ${target.label} (${await describeModelAfterSwitch(chatId, target.id, deps)}).`,
+    };
+  }
+  const result = await rebindChat(chatId, target.id, deps.config);
+  if (!result.ok) {
+    return {
+      ok: false,
+      text: `Could not switch to ${target.label}: ${result.error ?? "rebind failed"}`,
+    };
+  }
+  setChatBackend(chatId, target.id);
+  handOffChatSession(chatId, previous, deps, opts.keepHistory === true);
+  return {
+    ok: true,
+    text: `Backend: ${target.label} (${await describeModelAfterSwitch(chatId, target.id, deps)}). Session started fresh.`,
+  };
+}
+
+/** Drop the per-chat backend override; the chat reverts to the default. */
+export async function resetChatBackend(
+  chatId: string,
+  deps: ModelCommandDeps,
+  opts: { keepHistory?: boolean } = {},
+): Promise<CommandOutcome> {
+  const { backend: previous } = resolveChatBackendPair(chatId, deps);
+  await releaseChat(chatId);
+  setChatBackend(chatId, undefined);
+  handOffChatSession(chatId, previous, deps, opts.keepHistory === true);
+  const { backendId } = resolveChatBackendPair(chatId, deps);
+  return {
+    ok: true,
+    text: `Backend reset to default (${backendId}; ${await describeModelAfterSwitch(chatId, backendId, deps)}).`,
+  };
+}
+
+export type EffortOverview = {
+  current: string;
+  levels: ReasoningEffortLevel[];
+  activeModel: string | null;
+  backendId: string;
+};
+
+/** Current effort and the levels the active model accepts. */
+export async function describeChatEffort(
+  chatId: string,
+  deps: ModelCommandDeps,
+): Promise<EffortOverview> {
+  const { backend, backendId } = resolveChatBackendPair(chatId, deps);
+  const reasoning = await getActiveReasoningLevels({
+    chatId,
+    backend,
+    backendId,
+    config: deps.config,
+  });
+  return {
+    current: displayReasoningEffort(
+      getChatSettings(chatId).effort,
+      reasoning.levels,
+    ),
+    levels: reasoning.levels,
+    activeModel: reasoning.activeModel,
+    backendId,
+  };
+}
+
+/** `/effort <level>` — validated against the active model's levels. */
+export async function setChatEffortLevel(
+  chatId: string,
+  arg: string,
+  deps: ModelCommandDeps,
+): Promise<CommandOutcome> {
+  const level = arg.trim().toLowerCase();
+  if (level === "reset" || level === "default" || level === "adaptive") {
+    setChatEffort(chatId, undefined);
+    return {
+      ok: true,
+      text: "Effort reset to adaptive (model decides when to think).",
+    };
+  }
+  const { levels, activeModel, backendId } = await describeChatEffort(
+    chatId,
+    deps,
+  );
+  if (levels.length === 0) {
+    return {
+      ok: false,
+      text: `No reasoning levels available for ${activeModel ?? "the active model"} on backend ${backendId}.`,
+    };
+  }
+  if (!supportsReasoningLevel(level, levels)) {
+    return {
+      ok: false,
+      text: `Unknown level for this model. Valid: ${levels.join(", ")}, or adaptive.`,
+    };
+  }
+  setChatEffort(chatId, level as EffortLevel);
+  return { ok: true, text: `Effort set to ${level}.` };
+}

package/src/frontend/telegram/auth-panel.ts

@@ -0,0 +1,205 @@
+/**
+ * /auth panel — sign the daemon's Claude and Codex CLIs back in from
+ * Telegram, admin only.
+ *
+ * The panel lists each provider's login state with a sign-in button. A
+ * tap starts the core login flow and rewrites the same message into the
+ * instructions the CLI printed: an "Open sign-in page" URL button plus,
+ * for Codex, the one-time device code, or, for Claude, a request to reply
+ * with the code the browser shows. The message is edited again when the
+ * CLI finishes, so the whole exchange lives in one bubble.
+ */
+
+import type { Context } from "grammy";
+import type { InlineKeyboardButton } from "grammy/types";
+import {
+  activeLoginFlow,
+  startLogin,
+  type LoginBinaries,
+  type LoginFlow,
+  type LoginPrompt,
+} from "../../core/auth/login-flow.js";
+import {
+  AUTH_PROVIDERS,
+  describeProviderStatus,
+  PROVIDER_LABELS,
+  readAllProviderStatus,
+  type AuthProvider,
+  type ProviderAuthStatus,
+} from "../../core/auth/status.js";
+import { logWarn } from "../../util/log.js";
+import { escapeHtml } from "./formatting.js";
+
+type AuthKeyboard = InlineKeyboardButton[][];
+
+export interface AuthPanel {
+  text: string;
+  keyboard: AuthKeyboard;
+}
+
+export function isAuthProvider(value: string): value is AuthProvider {
+  return (AUTH_PROVIDERS as readonly string[]).includes(value);
+}
+
+function statusIcon(s: ProviderAuthStatus): string {
+  if (!s.loggedIn || s.expired) return "🔴";
+  if (
+    s.loginExpiresAt !== undefined &&
+    s.loginExpiresAt - Date.now() < 7 * 86_400_000
+  )
+    return "🟡";
+  return "🟢";
+}
+
+/** The resting panel: one status line + one sign-in button per provider. */
+export function renderAuthPanel(statuses: ProviderAuthStatus[]): AuthPanel {
+  const lines = ["<b>🔑 Backend logins</b>", ""];
+  const keyboard: AuthKeyboard = [];
+  for (const s of statuses) {
+    const label = PROVIDER_LABELS[s.provider];
+    lines.push(
+      `${statusIcon(s)} <b>${label}</b> — ${escapeHtml(describeProviderStatus(s))}`,
+    );
+    const pending = activeLoginFlow(s.provider);
+    keyboard.push([
+      pending
+        ? {
+            text: `⏳ ${label} sign-in in progress…`,
+            callback_data: `auth:resume:${s.provider}`,
+          }
+        : {
+            text: `${s.loggedIn && !s.expired ? "🔄 Re-sign in to" : "🔑 Sign in to"} ${label}`,
+            callback_data: `auth:login:${s.provider}`,
+          },
+    ]);
+  }
+  keyboard.push([{ text: "↻ Refresh", callback_data: "auth:refresh" }]);
+  return { text: lines.join("\n"), keyboard };
+}
+
+/** The in-progress panel: the CLI's instructions, an open-link button, cancel. */
+export function renderLoginPrompt(
+  provider: AuthProvider,
+  prompt: LoginPrompt,
+): AuthPanel {
+  const label = PROVIDER_LABELS[provider];
+  const lines = [
+    `<b>🔑 Sign in to ${label}</b>`,
+    "",
+    "1. Open the sign-in page (button below) and log in.",
+  ];
+  if (prompt.code) {
+    lines.push(
+      `2. Enter this one-time code: <code>${escapeHtml(prompt.code)}</code>`,
+    );
+  }
+  if (prompt.needsCode) {
+    lines.push(
+      `${prompt.code ? 3 : 2}. Copy the code the page shows and <b>reply to this message</b> with it.`,
+    );
+  }
+  lines.push("", "<i>This link expires in 15 minutes.</i>");
+  return {
+    text: lines.join("\n"),
+    keyboard: [
+      [{ text: "🌐 Open sign-in page", url: prompt.url }],
+      [{ text: "✖ Cancel", callback_data: `auth:cancel:${provider}` }],
+    ],
+  };
+}
+
+export async function currentAuthPanel(): Promise<AuthPanel> {
+  return renderAuthPanel(await readAllProviderStatus());
+}
+
+/** Messages awaiting a pasted code, keyed by chat → prompt message id. */
+const awaitingCode = new Map<
+  string,
+  { provider: AuthProvider; messageId: number }
+>();
+
+export function pendingCodePrompt(
+  chatId: string,
+): { provider: AuthProvider; messageId: number } | undefined {
+  return awaitingCode.get(chatId);
+}
+
+async function editPanel(
+  ctx: Context,
+  chatId: number,
+  messageId: number,
+  panel: AuthPanel,
+): Promise<void> {
+  try {
+    await ctx.api.editMessageText(chatId, messageId, panel.text, {
+      parse_mode: "HTML",
+      reply_markup: { inline_keyboard: panel.keyboard },
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!/message is not modified/i.test(msg))
+      logWarn("bot", `auth panel edit failed: ${msg}`);
+  }
+}
+
+/**
+ * Start (or attach to) a login for `provider` and drive the panel message
+ * through prompt → outcome. Returns once the prompt is on screen; the
+ * outcome edit happens when the CLI exits.
+ */
+export async function driveLogin(
+  ctx: Context,
+  chatId: number,
+  messageId: number,
+  provider: AuthProvider,
+  bins: LoginBinaries,
+): Promise<void> {
+  const flow: LoginFlow =
+    activeLoginFlow(provider) ?? startLogin(provider, bins);
+  let prompt: LoginPrompt;
+  try {
+    prompt = await flow.prompt;
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    const panel = await currentAuthPanel();
+    await editPanel(ctx, chatId, messageId, {
+      text: `${panel.text}\n\n❌ Couldn't start ${PROVIDER_LABELS[provider]} sign-in: ${escapeHtml(detail)}`,
+      keyboard: panel.keyboard,
+    });
+    return;
+  }
+  if (prompt.needsCode)
+    awaitingCode.set(String(chatId), { provider, messageId });
+  await editPanel(ctx, chatId, messageId, renderLoginPrompt(provider, prompt));
+
+  void flow.done.then(async (outcome) => {
+    if (awaitingCode.get(String(chatId))?.messageId === messageId)
+      awaitingCode.delete(String(chatId));
+    const panel = await currentAuthPanel();
+    const label = PROVIDER_LABELS[provider];
+    const note = outcome.ok
+      ? `✅ ${label} signed in.`
+      : outcome.reason === "cancelled"
+        ? `✖ ${label} sign-in cancelled.`
+        : outcome.reason === "timeout"
+          ? `⌛ ${label} sign-in link expired. Tap the button to try again.`
+          : `❌ ${label} sign-in failed: ${escapeHtml(outcome.detail ?? "unknown error")}`;
+    await editPanel(ctx, chatId, messageId, {
+      text: `${panel.text}\n\n${note}`,
+      keyboard: panel.keyboard,
+    });
+  });
+}
+
+/** Feed a pasted code to the pending flow for this chat. True when consumed. */
+export function submitPendingCode(chatId: string, text: string): boolean {
+  const pending = awaitingCode.get(chatId);
+  if (!pending) return false;
+  const flow = activeLoginFlow(pending.provider);
+  if (!flow) {
+    awaitingCode.delete(chatId);
+    return false;
+  }
+  flow.submitCode(text);
+  return true;
+}

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

@@ -0,0 +1,70 @@
+/**
+ * `auth:*` callbacks — the /auth panel's buttons.
+ *
+ *   auth:login:<provider>   start a sign-in and show its instructions
+ *   auth:resume:<provider>  re-show the instructions of a running sign-in
+ *   auth:cancel:<provider>  abort a running sign-in
+ *   auth:refresh            re-read credential files and redraw
+ */
+
+import type { Context } from "grammy";
+import { activeLoginFlow } from "../../../core/auth/login-flow.js";
+import { currentAuthPanel, driveLogin, isAuthProvider } from "../auth-panel.js";
+import { loginBinariesFrom } from "../commands/auth.js";
+import { isAuthorizedAdmin } from "../commands/state.js";
+import { answerCallbackQuerySafe, type CallbackDeps } from "./shared.js";
+
+export async function handleAuthCallback(
+  ctx: Context,
+  data: string,
+  { config }: CallbackDeps,
+): Promise<void> {
+  if (!isAuthorizedAdmin(ctx)) {
+    await answerCallbackQuerySafe(ctx, { text: "Not authorized." });
+    return;
+  }
+  const chatId = ctx.chat?.id;
+  const messageId = ctx.callbackQuery?.message?.message_id;
+  if (chatId === undefined || messageId === undefined) {
+    await answerCallbackQuerySafe(ctx);
+    return;
+  }
+  const [, action, provider = ""] = data.split(":");
+
+  if (action === "refresh") {
+    await answerCallbackQuerySafe(ctx);
+    const panel = await currentAuthPanel();
+    await ctx.api
+      .editMessageText(chatId, messageId, panel.text, {
+        parse_mode: "HTML",
+        reply_markup: { inline_keyboard: panel.keyboard },
+      })
+      .catch(() => {});
+    return;
+  }
+
+  if (!isAuthProvider(provider)) {
+    await answerCallbackQuerySafe(ctx, { text: "Unknown provider" });
+    return;
+  }
+
+  if (action === "cancel") {
+    activeLoginFlow(provider)?.cancel();
+    await answerCallbackQuerySafe(ctx, { text: "Cancelled" });
+    return;
+  }
+
+  if (action === "login" || action === "resume") {
+    await answerCallbackQuerySafe(ctx, { text: "Starting sign-in…" });
+    await driveLogin(
+      ctx,
+      chatId,
+      messageId,
+      provider,
+      loginBinariesFrom(config),
+    );
+    return;
+  }
+
+  await answerCallbackQuerySafe(ctx, { text: "Invalid callback data" });
+}

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

@@ -9,6 +9,8 @@
  *   - `effort`   — `effort:*`
  *   - `metrics`  — `metrics:*` (today ↔ all-time panel grain)
  *   - `model`    — `model:*` (menu / backend / browse controller)
+ *   - `auth`     — `auth:*` (backend sign-in panel, admin only)
+ *   - `whatsapp` — `whatsapp:*` (WhatsApp link panel, admin only)
  *
  * `registerCallbacks` installs one `callback_query:data` listener that
  * dispatches on the data prefix, preserving the original order and the
@@ -25,6 +27,8 @@ import { handlePulseCallback } from "./pulse.js";
 import { handleEffortCallback } from "./effort.js";
 import { handleMetricsCallback } from "./metrics.js";
 import { handleModelCallback } from "./model.js";
+import { handleAuthCallback } from "./auth.js";
+import { handleWhatsAppCallback } from "./whatsapp.js";
 
 export { answerCallbackQuerySafe } from "./shared.js";
 
@@ -70,6 +74,18 @@ export function registerCallbacks(
       return;
     }
 
+    // Handle /auth (backend CLI sign-in) callbacks.
+    if (data.startsWith("auth:")) {
+      await handleAuthCallback(ctx, data, deps);
+      return;
+    }
+
+    // Handle /whatsapp (link status / pairing) callbacks.
+    if (data.startsWith("whatsapp:")) {
+      await handleWhatsAppCallback(ctx, data);
+      return;
+    }
+
     // Forward other callbacks to the AI backend
     handleCallbackQuery(ctx, bot, config);
   });