talon-agent 3.34.0 → 3.35.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/admin.ts

@@ -7,7 +7,8 @@ import { readFileSync } from "node:fs";
 import type { TalonConfig } from "../../util/config.js";
 import { files, dirs } from "../../util/paths.js";
 import { tailFile } from "../../util/tail-file.js";
-import { escapeHtml } from "./formatting.js";
+import { escapeHtml, splitMessage } from "./formatting.js";
+import { TELEGRAM_MAX_TEXT } from "./actions/types.js";
 import { resetSession, getAllSessions } from "../../storage/sessions.js";
 import { clearHistory } from "../../storage/history.js";
 import { todayLogDate } from "../../storage/daily-log.js";
@@ -22,6 +23,72 @@ import { getPulseStatus } from "../../core/background/pulse.js";
 import { getHealthStatus, getRecentErrors } from "../../util/watchdog.js";
 import { formatDuration, formatModelLabel } from "./helpers/index.js";
 
+/**
+ * Reply with an HTML listing, split across messages when it outgrows
+ * Telegram's 4096-char cap. The per-item listings below (chats, cron,
+ * pulse) scale with the daemon's chat count, and a single oversized
+ * `ctx.reply` fails the whole command with 400 "message is too long".
+ * Entries are `\n\n`-separated and each carries balanced tags, so the
+ * paragraph-first splitter never cuts through markup.
+ */
+async function replyHtmlChunked(ctx: Context, text: string): Promise<void> {
+  for (const chunk of splitMessage(text, TELEGRAM_MAX_TEXT)) {
+    await ctx.reply(chunk, { parse_mode: "HTML" });
+  }
+}
+
+/** `/admin chats` — every active session, newest first, titled via getChat. */
+async function replyActiveChats(
+  ctx: Context,
+  bot: Bot,
+  config: TalonConfig,
+): Promise<void> {
+  const sessions = getAllSessions();
+  if (sessions.length === 0) {
+    await ctx.reply("No active sessions.");
+    return;
+  }
+  sessions.sort((a, b) => (b.info.lastActive || 0) - (a.info.lastActive || 0));
+
+  const titles = new Map<string, string>();
+  await Promise.all(
+    sessions.map(async (s) => {
+      try {
+        const id = parseInt(s.chatId, 10);
+        if (isNaN(id)) return;
+        const chat = await bot.api.getChat(id);
+        titles.set(
+          s.chatId,
+          "title" in chat
+            ? (chat.title ?? "DM")
+            : "first_name" in chat
+              ? (chat.first_name ?? "DM")
+              : "DM",
+        );
+      } catch {
+        /* inaccessible */
+      }
+    }),
+  );
+
+  const lines = sessions.map((s) => {
+    const age = s.info.lastActive
+      ? `${Math.round((Date.now() - s.info.lastActive) / 60000)}m ago`
+      : "?";
+    const title = titles.get(s.chatId) ?? s.chatId;
+    const model = formatModelLabel(
+      getChatSettings(s.chatId).model ?? config.model,
+    );
+    // `model` is a catalog id (OpenRouter/Kilo ids are free-form), so
+    // it gets the same escaping the title already had.
+    return `<b>${escapeHtml(title)}</b> <code>${s.chatId}</code>\n  ${s.info.turns} turns | ${age} | ${escapeHtml(model)}`;
+  });
+  await replyHtmlChunked(
+    ctx,
+    `<b>Active chats (${sessions.length})</b>\n\n` + lines.join("\n\n"),
+  );
+}
+
 export async function handleAdminCommand(
   ctx: Context,
   bot: Bot,
@@ -32,52 +99,7 @@ export async function handleAdminCommand(
 
   switch (subcommand) {
     case "chats": {
-      const sessions = getAllSessions();
-      if (sessions.length === 0) {
-        await ctx.reply("No active sessions.");
-        return;
-      }
-      sessions.sort(
-        (a, b) => (b.info.lastActive || 0) - (a.info.lastActive || 0),
-      );
-
-      const titles = new Map<string, string>();
-      await Promise.all(
-        sessions.map(async (s) => {
-          try {
-            const id = parseInt(s.chatId, 10);
-            if (isNaN(id)) return;
-            const chat = await bot.api.getChat(id);
-            titles.set(
-              s.chatId,
-              "title" in chat
-                ? (chat.title ?? "DM")
-                : "first_name" in chat
-                  ? (chat.first_name ?? "DM")
-                  : "DM",
-            );
-          } catch {
-            /* inaccessible */
-          }
-        }),
-      );
-
-      const lines = sessions.map((s) => {
-        const age = s.info.lastActive
-          ? `${Math.round((Date.now() - s.info.lastActive) / 60000)}m ago`
-          : "?";
-        const title = titles.get(s.chatId) ?? s.chatId;
-        const model = formatModelLabel(
-          getChatSettings(s.chatId).model ?? config.model,
-        );
-        // `model` is a catalog id (OpenRouter/Kilo ids are free-form), so
-        // it gets the same escaping the title already had.
-        return `<b>${escapeHtml(title)}</b> <code>${s.chatId}</code>\n  ${s.info.turns} turns | ${age} | ${escapeHtml(model)}`;
-      });
-      await ctx.reply(
-        `<b>Active chats (${sessions.length})</b>\n\n` + lines.join("\n\n"),
-        { parse_mode: "HTML" },
-      );
+      await replyActiveChats(ctx, bot, config);
       return;
     }
 
@@ -189,9 +211,9 @@ export async function handleAdminCommand(
           : "?";
         return `${j.enabled ? "\u2713" : "\u2717"} <b>${escapeHtml(j.name)}</b>\n  <code>${escapeHtml(describeSchedule(j))}</code> | ${j.type} | runs: ${j.runCount} | last: ${last} | next: ${next}`;
       });
-      await ctx.reply(
+      await replyHtmlChunked(
+        ctx,
         `<b>Cron Jobs (${jobs.length})</b>\n\n` + lines.join("\n\n"),
-        { parse_mode: "HTML" },
       );
       return;
     }
@@ -217,9 +239,10 @@ export async function handleAdminCommand(
           return `${p.enabled ? "\u2713" : "\u2717"} ${escapeHtml(title)}`;
         }),
       );
-      await ctx.reply(`<b>Pulse (${chats.length})</b>\n\n` + lines.join("\n"), {
-        parse_mode: "HTML",
-      });
+      await replyHtmlChunked(
+        ctx,
+        `<b>Pulse (${chats.length})</b>\n\n` + lines.join("\n"),
+      );
       return;
     }