talon-agent 1.5.0 → 1.6.0

package/src/backend/claude-sdk/warm.ts

@@ -0,0 +1,89 @@
+/**
+ * Session warm-up — cold-start optimization.
+ *
+ * Spawns a throwaway SDK subprocess in streaming input mode, calls
+ * getContextUsage() to populate contextWindow and baseline contextTokens,
+ * then tears it down. Fire-and-forget — does not block the caller.
+ */
+
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { getSession } from "../../storage/sessions.js";
+import { rebuildSystemPrompt } from "../../util/config.js";
+import { getPluginPromptAdditions } from "../../core/plugin.js";
+import { log, logWarn } from "../../util/log.js";
+import { getConfig } from "./state.js";
+import { buildSdkOptions } from "./options.js";
+
+export async function warmSession(chatId: string): Promise<void> {
+  // Guard against being called before initAgent()
+  try {
+    getConfig();
+  } catch {
+    return;
+  }
+
+  const abort = new AbortController();
+  try {
+    rebuildSystemPrompt(getConfig(), getPluginPromptAdditions());
+    const { options } = buildSdkOptions(chatId);
+
+    // Streaming input mode: pass an async iterable that never yields a user message
+    const neverYield = async function* (): AsyncGenerator<never> {
+      await new Promise<never>((_, reject) => {
+        abort.signal.addEventListener("abort", () =>
+          reject(new Error("aborted")),
+        );
+      });
+    };
+
+    const q = query({
+      prompt: neverYield(),
+      options: { ...options, abortController: abort },
+    });
+
+    // Drain the stream in the background so the SDK's internal message loop
+    // doesn't stall — control responses are processed in readMessages() which
+    // needs the inputStream consumer to not back-pressure.
+    const drainPromise = (async () => {
+      try {
+        for await (const _ of q) {
+          // discard SDK messages; we only care about the control response
+        }
+      } catch {
+        // expected: abort causes the stream to end with an error
+      }
+    })();
+
+    // Race getContextUsage against a timeout so /reset doesn't hang
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+    const timeout = new Promise<never>((_, reject) => {
+      timeoutId = setTimeout(
+        () => reject(new Error("warm-up timed out")),
+        15_000,
+      );
+    });
+    let ctx: Awaited<ReturnType<typeof q.getContextUsage>>;
+    try {
+      ctx = await Promise.race([q.getContextUsage(), timeout]);
+    } finally {
+      if (timeoutId !== undefined) clearTimeout(timeoutId);
+    }
+    const session = getSession(chatId);
+    if (ctx.maxTokens > 0) session.usage.contextWindow = ctx.maxTokens;
+    if (ctx.totalTokens > 0) session.usage.contextTokens = ctx.totalTokens;
+    log(
+      "agent",
+      `[${chatId}] warm-up: context ${ctx.totalTokens}/${ctx.maxTokens} (${ctx.percentage.toFixed(1)}%) model=${ctx.model}`,
+    );
+
+    abort.abort();
+    await drainPromise;
+  } catch (err) {
+    abort.abort();
+    // Non-fatal — /status will just show 0 until first real message
+    logWarn(
+      "agent",
+      `[${chatId}] warm-up failed: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}

package/src/bootstrap.ts

@@ -47,6 +47,10 @@ export type BootstrapResult = {
   config: TalonConfig;
 };
 
+export type BackendAndDispatcherResult = {
+  backend: QueryBackend;
+};
+
 // ── Bootstrap: config, env, plugins, workspace, storage ──────────────────────
 
 /**
@@ -102,7 +106,7 @@ export async function bootstrap(
 export async function initBackendAndDispatcher(
   config: TalonConfig,
   frontend: Frontend,
-): Promise<void> {
+): Promise<BackendAndDispatcherResult> {
   let backend: QueryBackend;
 
   if (config.backend === "opencode") {
@@ -112,10 +116,18 @@ export async function initBackendAndDispatcher(
     backend = { query: (params) => opencodeHandleMessage(params) };
     log("bot", "Backend: OpenCode");
   } else {
-    const { initAgent: initClaudeAgent, handleMessage: claudeHandleMessage } =
-      await import("./backend/claude-sdk/index.js");
-    initClaudeAgent(config, frontend.getBridgePort);
-    backend = { query: (params) => claudeHandleMessage(params) };
+    const {
+      initAgent: initClaudeAgent,
+      handleMessage: claudeHandleMessage,
+      warmSession: claudeWarmSession,
+      updateSystemPrompt: claudeUpdateSystemPrompt,
+    } = await import("./backend/claude-sdk/index.js");
+    await initClaudeAgent(config, frontend.getBridgePort);
+    backend = {
+      query: (params) => claudeHandleMessage(params),
+      warmSession: (chatId) => claudeWarmSession(chatId),
+      updateSystemPrompt: (prompt) => claudeUpdateSystemPrompt(prompt),
+    };
     log("bot", "Backend: Claude SDK");
   }
 
@@ -160,4 +172,6 @@ export async function initBackendAndDispatcher(
     claudeBinary: config.claudeBinary,
     workspace: config.workspace,
   });
+
+  return { backend };
 }

package/src/cli.ts

@@ -282,23 +282,37 @@ async function runSetup(): Promise<void> {
     if (botName) teamsBotDisplayName = botName;
   }
 
+  // Discover models from SDK; fall back to static list if SDK isn't available
+  const {
+    registerClaudeModels,
+    registerClaudeModelsStatic,
+    CLAUDE_MODELS_STATIC,
+  } = await import("./backend/claude-sdk/models.js");
+  try {
+    const { dirs } = await import("./util/paths.js");
+    await registerClaudeModels({
+      model: config.model,
+      cwd: dirs.workspace,
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      ...(config.claudeBinary
+        ? { pathToClaudeCodeExecutable: config.claudeBinary }
+        : {}),
+    });
+  } catch {
+    // Setup wizard may run before Claude Code is installed — use static list
+    registerClaudeModelsStatic(CLAUDE_MODELS_STATIC);
+  }
+  const { getModels } = await import("./core/models.js");
+  const registeredModels = getModels();
+
   const model = await p.select({
     message: "Default model",
     initialValue: config.model,
-    options: [
-      {
-        value: "claude-sonnet-4-6",
-        label: `Sonnet 4.6  ${pc.dim("\u2014 fast, balanced")}`,
-      },
-      {
-        value: "claude-opus-4-6",
-        label: `Opus 4.6    ${pc.dim("\u2014 smartest")}`,
-      },
-      {
-        value: "claude-haiku-4-5",
-        label: `Haiku 4.5   ${pc.dim("\u2014 fastest, cheapest")}`,
-      },
-    ],
+    options: registeredModels.map((m) => ({
+      value: m.id,
+      label: `${m.displayName.padEnd(12)}${m.description ? pc.dim(`\u2014 ${m.description}`) : ""}`,
+    })),
   });
   if (p.isCancel(model)) {
     p.cancel("Cancelled.");
@@ -652,7 +666,8 @@ async function startChat(): Promise<void> {
   const gateway = new Gateway();
   const frontend = createTerminalFrontend(config, gateway);
   await frontend.init();
-  await initBackendAndDispatcher(config, frontend);
+  const { backend } = await initBackendAndDispatcher(config, frontend);
+  gateway.backend = backend;
 
   process.on("SIGINT", () => {
     flushSessions();

package/src/core/dream.ts

@@ -20,6 +20,8 @@ import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import { files as pathFiles, dirs } from "../util/paths.js";
 import { log, logError, logWarn } from "../util/log.js";
 import { getPluginMcpServers } from "./plugin.js";
+import { DISALLOWED_TOOLS_BACKGROUND } from "../backend/claude-sdk/constants.js";
+import { getDefaultModel } from "./models.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -178,7 +180,8 @@ If commands fail, log the error and continue — this stage is optional.`
     throw new Error(`Failed to read dream prompt from ${promptPath}`);
   }
 
-  const model = configRef.dreamModel ?? configRef.model ?? "claude-sonnet-4-6";
+  const model =
+    configRef.dreamModel ?? configRef.model ?? getDefaultModel("balanced");
   const workspace = configRef.workspace ?? dirs.workspace;
 
   // Set up dream log file
@@ -208,22 +211,7 @@ If commands fail, log the error and continue — this stage is optional.`
     mcpServers: configRef.mempalace
       ? getPluginMcpServers("", "dream", ["mempalace"])
       : {},
-    disallowedTools: [
-      "EnterPlanMode",
-      "ExitPlanMode",
-      "EnterWorktree",
-      "ExitWorktree",
-      "TodoWrite",
-      "TodoRead",
-      "TaskCreate",
-      "TaskUpdate",
-      "TaskGet",
-      "TaskList",
-      "TaskOutput",
-      "TaskStop",
-      "AskUserQuestion",
-      "Agent",
-    ],
+    disallowedTools: [...DISALLOWED_TOOLS_BACKGROUND],
   };
 
   const timeoutPromise = new Promise<never>((_, reject) =>

package/src/core/gateway-actions.ts

@@ -27,7 +27,7 @@ import {
   type CronJobType,
 } from "../storage/cron-store.js";
 import { log } from "../util/log.js";
-import type { ActionResult } from "./types.js";
+import type { ActionResult, QueryBackend } from "./types.js";
 
 /** Extract readable text from HTML using cheerio (proper DOM parser). */
 function extractText(html: string, maxLength = 8000): string {
@@ -42,6 +42,7 @@ function extractText(html: string, maxLength = 8000): string {
 export async function handleSharedAction(
   body: Record<string, unknown>,
   chatId: number,
+  backend?: QueryBackend | null,
 ): Promise<ActionResult | null> {
   const action = body.action as string;
 
@@ -324,17 +325,7 @@ export async function handleSharedAction(
         // Rebuild system prompt on the freshConfig, then update the backend's
         // live config reference so subsequent messages use the new prompt
         rebuildSystemPrompt(freshConfig, getPluginPromptAdditions());
-        try {
-          const { updateSystemPrompt } =
-            await import("../backend/claude-sdk/index.js");
-          updateSystemPrompt(freshConfig.systemPrompt);
-        } catch (err) {
-          // Non-fatal — OpenCode backend doesn't expose updateSystemPrompt
-          log(
-            "gateway",
-            `reload_plugins: could not update backend prompt: ${err instanceof Error ? err.message : err}`,
-          );
-        }
+        backend?.updateSystemPrompt?.(freshConfig.systemPrompt);
 
         log("gateway", `reload_plugins: ${names.length} plugins loaded`);
         return {

package/src/core/gateway.ts

@@ -21,7 +21,7 @@ import { getActiveSessionCount } from "../storage/sessions.js";
 import { log, logError, logDebug } from "../util/log.js";
 import { handleSharedAction } from "./gateway-actions.js";
 import { handlePluginAction } from "./plugin.js";
-import type { FrontendActionHandler } from "./types.js";
+import type { FrontendActionHandler, QueryBackend } from "./types.js";
 
 // ── Per-chat context state ───────────────────────────────────────────────────
 
@@ -80,6 +80,9 @@ export class Gateway {
   private server: ReturnType<typeof createServer> | null = null;
   private port = 0;
 
+  /** The active backend — set by bootstrap after initialization. */
+  backend: QueryBackend | null = null;
+
   // ── Frontend handler registration ────────────────────────────────────────
 
   setFrontendHandler(handler: FrontendActionHandler | null): void {
@@ -195,7 +198,7 @@ export class Gateway {
       }
 
       // Shared actions last — provides in-memory fallbacks for history, cron, etc.
-      const shared = await handleSharedAction(body, chatId);
+      const shared = await handleSharedAction(body, chatId, this.backend);
       if (shared) {
         logDebug(
           "gateway",

package/src/core/heartbeat.ts

@@ -18,6 +18,8 @@ import { files as pathFiles, dirs } from "../util/paths.js";
 import { log, logError, logWarn } from "../util/log.js";
 import { toYMD } from "../util/time.js";
 import { getPluginMcpServers } from "./plugin.js";
+import { DISALLOWED_TOOLS_BACKGROUND } from "../backend/claude-sdk/constants.js";
+import { getDefaultModel } from "./models.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -263,7 +265,7 @@ async function runHeartbeatAgent(
   }
 
   const model =
-    configRef.heartbeatModel ?? configRef.model ?? "claude-sonnet-4-6";
+    configRef.heartbeatModel ?? configRef.model ?? getDefaultModel("balanced");
 
   // Set up heartbeat log file
   const heartbeatLogFile = await createHeartbeatLogFile();
@@ -292,22 +294,7 @@ async function runHeartbeatAgent(
       : {}),
     // Load all registered plugin MCP servers (excludes frontend-specific tools like telegram)
     mcpServers: getPluginMcpServers("", "heartbeat"),
-    disallowedTools: [
-      "EnterPlanMode",
-      "ExitPlanMode",
-      "EnterWorktree",
-      "ExitWorktree",
-      "TodoWrite",
-      "TodoRead",
-      "TaskCreate",
-      "TaskUpdate",
-      "TaskGet",
-      "TaskList",
-      "TaskOutput",
-      "TaskStop",
-      "AskUserQuestion",
-      "Agent",
-    ],
+    disallowedTools: [...DISALLOWED_TOOLS_BACKGROUND],
   };
 
   // NOTE: The timeout races against the agent promise but cannot abort the

package/src/core/models.ts

@@ -0,0 +1,149 @@
+/**
+ * Model registry — single source of truth for available models.
+ *
+ * Backends register their models during initialization. Frontends read
+ * from the registry to build dynamic model pickers, resolve aliases,
+ * and query capabilities. No model names are hardcoded outside this
+ * system and the backend-specific model definition files.
+ */
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type ModelTier = "premium" | "balanced" | "economy";
+
+export type ModelCapabilities = {
+  /** Whether the model supports the 1M token context window. */
+  supports1mContext: boolean;
+};
+
+export type ModelInfo = {
+  /** Canonical model ID (e.g. "claude-sonnet-4-6"). */
+  id: string;
+  /** Human-readable display name for UIs (e.g. "Sonnet 4.6"). */
+  displayName: string;
+  /** Short description for setup wizard (e.g. "fast, balanced"). */
+  description?: string;
+  /** Aliases that resolve to this model (e.g. ["sonnet", "sonnet-4.6"]). */
+  aliases: string[];
+  /** Provider identifier (e.g. "anthropic", "openai"). */
+  provider: string;
+  /** Model capabilities used for backend configuration. */
+  capabilities: ModelCapabilities;
+  /** Tier for UI grouping and fallback ordering. */
+  tier: ModelTier;
+  /** Model to fall back to on overload/timeout. */
+  fallback?: string;
+};
+
+// ── Tier sort order ─────────────────────────────────────────────────────────
+
+const TIER_ORDER: Record<ModelTier, number> = {
+  premium: 0,
+  balanced: 1,
+  economy: 2,
+};
+
+// ── Registry state ──────────────────────────────────────────────────────────
+
+const models = new Map<string, ModelInfo>();
+const aliasIndex = new Map<string, string>();
+
+// ── Registration ────────────────────────────────────────────────────────────
+
+/** Register one or more models. Idempotent — re-registration overwrites. */
+export function registerModels(infos: ModelInfo[]): void {
+  for (const info of infos) {
+    // Clear stale aliases from any previous registration of this model ID
+    const prev = models.get(info.id);
+    if (prev) {
+      aliasIndex.delete(prev.id.toLowerCase());
+      for (const alias of prev.aliases) {
+        aliasIndex.delete(alias.toLowerCase());
+      }
+    }
+    models.set(info.id, info);
+    // Index the canonical ID itself as an alias
+    aliasIndex.set(info.id.toLowerCase(), info.id);
+    for (const alias of info.aliases) {
+      aliasIndex.set(alias.toLowerCase(), info.id);
+    }
+  }
+}
+
+// ── Queries ─────────────────────────────────────────────────────────────────
+
+/** Get a model by canonical ID. */
+export function getModel(id: string): ModelInfo | undefined {
+  return models.get(id);
+}
+
+/** List all registered models, optionally filtered by provider. Sorted by tier. */
+export function getModels(provider?: string): ModelInfo[] {
+  let result = [...models.values()];
+  if (provider) {
+    result = result.filter((m) => m.provider === provider);
+  }
+  return result.sort((a, b) => TIER_ORDER[a.tier] - TIER_ORDER[b.tier]);
+}
+
+/**
+ * Resolve a user input (alias or full ID) to the canonical model ID.
+ * Returns the input unchanged if no match is found (passthrough for
+ * unknown/custom model names).
+ */
+export function resolveModelId(input: string): string {
+  const lower = input.trim().toLowerCase();
+  return aliasIndex.get(lower) ?? input.trim();
+}
+
+/**
+ * Resolve a user input to the full ModelInfo, or undefined if not found.
+ */
+export function resolveModel(input: string): ModelInfo | undefined {
+  const id = resolveModelId(input);
+  return models.get(id);
+}
+
+/** Get the fallback model ID for a given model, or null if none configured. */
+export function getFallbackModel(modelId: string): string | null {
+  return models.get(modelId)?.fallback ?? null;
+}
+
+/** Check whether a model supports the 1M token context window. */
+export function supports1mContext(modelId: string): boolean {
+  const info = models.get(modelId);
+  // Default to true for unknown models (don't restrict capabilities we can't check)
+  return info?.capabilities.supports1mContext ?? true;
+}
+
+/**
+ * Get the default model for a given tier. Returns the first registered model
+ * matching the tier, or the first model overall, or the hardcoded fallback.
+ */
+export function getDefaultModel(tier: ModelTier = "balanced"): string {
+  const byTier = [...models.values()].find((m) => m.tier === tier);
+  if (byTier) return byTier.id;
+  const first = models.values().next();
+  if (!first.done) return first.value.id;
+  return "claude-sonnet-4-6"; // ultimate fallback if registry is empty
+}
+
+// ── Provider-scoped clearing ────────────────────────────────────────────────
+
+/** Remove all models for a specific provider (and their aliases). */
+export function clearModelsByProvider(provider: string): void {
+  for (const [id, info] of models) {
+    if (info.provider !== provider) continue;
+    aliasIndex.delete(id.toLowerCase());
+    for (const alias of info.aliases) {
+      aliasIndex.delete(alias.toLowerCase());
+    }
+    models.delete(id);
+  }
+}
+
+/** Clear the entire registry. For tests only. */
+export function clearModels(): void {
+  models.clear();
+  aliasIndex.clear();
+}

package/src/core/types.ts

@@ -33,6 +33,10 @@ export type QueryResult = {
 /** Backend interface — any AI provider implements this. */
 export interface QueryBackend {
   query(params: QueryParams): Promise<QueryResult>;
+  /** Pre-warm a session (cold-start optimization). Optional — not all backends support this. */
+  warmSession?(chatId: string): Promise<void>;
+  /** Update the system prompt on the live backend config. Optional — used by plugin hot-reload. */
+  updateSystemPrompt?(prompt: string): void;
 }
 
 // ── Execution context ───────────────────────────────────────────────────────

package/src/frontend/teams/index.ts

@@ -217,9 +217,7 @@ export function createTeamsFrontend(
               resetSession(talonChatId);
               clearHistory(talonChatId);
               log("teams", `Session reset by ${msg.senderName}`);
-              const { warmSession } =
-                await import("../../backend/claude-sdk/index.js");
-              await warmSession(talonChatId);
+              await gateway.backend?.warmSession?.(talonChatId);
               const card = buildAdaptiveCard("Session cleared.");
               await proxyFetch(webhookUrl, {
                 method: "POST",

package/src/frontend/telegram/callbacks.ts

@@ -22,6 +22,7 @@ import {
 import { handleCallbackQuery } from "./handlers.js";
 import { escapeHtml } from "./formatting.js";
 import { renderSettingsText, renderSettingsKeyboard } from "./helpers.js";
+import { getModels } from "../../core/models.js";
 
 export function registerCallbacks(bot: Bot, config: TalonConfig): void {
   // ── Callback query handler ──────────────────────────────────────────────────
@@ -214,36 +215,23 @@ export function registerCallbacks(bot: Bot, config: TalonConfig): void {
         });
       }
       const current = getChatSettings(cid).model ?? config.model;
-      const isModel = (id: string) => current.includes(id);
+      // Build model buttons dynamically from the registry
+      const models = getModels();
+      const modelButtons = models.map((m) => ({
+        text: current.includes(m.id)
+          ? `\u2713 ${m.displayName}`
+          : m.displayName,
+        callback_data: `model:${m.aliases[0] ?? m.id}`,
+      }));
+      const rows: Array<Array<{ text: string; callback_data: string }>> = [];
+      for (let i = 0; i < modelButtons.length; i += 2) {
+        rows.push(modelButtons.slice(i, i + 2));
+      }
+      rows.push([{ text: "Reset to default", callback_data: "model:reset" }]);
       try {
         await ctx.editMessageText(
           `<b>Model:</b> <code>${escapeHtml(current)}</code>`,
-          {
-            parse_mode: "HTML",
-            reply_markup: {
-              inline_keyboard: [
-                [
-                  {
-                    text: isModel("sonnet")
-                      ? "\u2713 Sonnet 4.6"
-                      : "Sonnet 4.6",
-                    callback_data: "model:sonnet",
-                  },
-                  {
-                    text: isModel("opus") ? "\u2713 Opus 4.6" : "Opus 4.6",
-                    callback_data: "model:opus",
-                  },
-                ],
-                [
-                  {
-                    text: isModel("haiku") ? "\u2713 Haiku 4.5" : "Haiku 4.5",
-                    callback_data: "model:haiku",
-                  },
-                  { text: "Reset to default", callback_data: "model:reset" },
-                ],
-              ],
-            },
-          },
+          { parse_mode: "HTML", reply_markup: { inline_keyboard: rows } },
         );
       } catch {
         /* message unchanged */

package/src/frontend/telegram/commands.ts

@@ -38,7 +38,7 @@ import { appendDailyLog } from "../../storage/daily-log.js";
 import { escapeHtml } from "./formatting.js";
 import { handleAdminCommand } from "./admin.js";
 import { getLoadedPlugins } from "../../core/plugin.js";
-import { warmSession } from "../../backend/claude-sdk/index.js";
+import { getModels } from "../../core/models.js";
 import {
   formatDuration,
   formatTokenCount,
@@ -56,7 +56,11 @@ export function setAdminUserId(id: number | undefined): void {
   ADMIN_USER_ID = id ?? 0;
 }
 
-export function registerCommands(bot: Bot, config: TalonConfig): void {
+export function registerCommands(
+  bot: Bot,
+  config: TalonConfig,
+  gateway?: { backend: import("../../core/types.js").QueryBackend | null },
+): void {
   bot.command("start", (ctx) =>
     ctx.reply(
       [
@@ -142,7 +146,7 @@ export function registerCommands(bot: Bot, config: TalonConfig): void {
     clearHistory(cid);
     resetPulseCheckpoint(cid);
     // Warm up the new session so /status has context data immediately
-    await warmSession(cid);
+    await gateway?.backend?.warmSession?.(cid);
     await ctx.reply("Session cleared.");
   });
 
@@ -179,33 +183,24 @@ export function registerCommands(bot: Bot, config: TalonConfig): void {
 
     if (!arg) {
       const current = settings.model ?? config.model;
-      const isModel = (id: string) => current.includes(id);
+      // Build model buttons dynamically from the registry
+      const models = getModels();
+      const modelButtons = models.map((m) => ({
+        text: current.includes(m.id)
+          ? `\u2713 ${m.displayName}`
+          : m.displayName,
+        callback_data: `model:${m.aliases[0] ?? m.id}`,
+      }));
+      // Two models per row, plus a reset button on the last row
+      const rows: Array<Array<{ text: string; callback_data: string }>> = [];
+      for (let i = 0; i < modelButtons.length; i += 2) {
+        rows.push(modelButtons.slice(i, i + 2));
+      }
+      rows.push([{ text: "Reset to default", callback_data: "model:reset" }]);
+
       await ctx.reply(
         `<b>Model:</b> <code>${escapeHtml(current)}</code>\nSelect a model:`,
-        {
-          parse_mode: "HTML",
-          reply_markup: {
-            inline_keyboard: [
-              [
-                {
-                  text: isModel("sonnet") ? "\u2713 Sonnet 4.6" : "Sonnet 4.6",
-                  callback_data: "model:sonnet",
-                },
-                {
-                  text: isModel("opus") ? "\u2713 Opus 4.6" : "Opus 4.6",
-                  callback_data: "model:opus",
-                },
-              ],
-              [
-                {
-                  text: isModel("haiku") ? "\u2713 Haiku 4.5" : "Haiku 4.5",
-                  callback_data: "model:haiku",
-                },
-                { text: "Reset to default", callback_data: "model:reset" },
-              ],
-            ],
-          },
-        },
+        { parse_mode: "HTML", reply_markup: { inline_keyboard: rows } },
       );
       return;
     }