@inceptionstack/roundhouse 0.5.11 → 0.5.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.5.11",
+  "version": "0.5.12",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",

package/src/gateway/gateway.ts

@@ -23,7 +23,7 @@ import { isCommand as _isCmd, isCommandWithArgs as _isCmdArgs, resolveAgentThrea
 import { saveAttachments as _saveAttachments, type AttachmentResult } from "./attachments";
 import { handleStreaming as _handleStream } from "./streaming";
 import { handleNew, handleRestart, handleUpdate, handleCompact, handleStatus, handleStop, handleVerbose, handleDoctor, handleCrons, type CommandContext } from "./commands";
-import { handleModel } from "./model-command";
+import { handleModel, handleModelAction, MODEL_ACTION_ID } from "./model-command";
 import { handleLater } from "./later-command";
 import { TelegramAdapter } from "../transports";
 import type { TransportAdapter } from "../transports";
@@ -327,6 +327,11 @@ export class Gateway {
       await handleOrAbort(thread, message);
     });
 
+    // ── Handle inline keyboard callbacks ───
+    this.chat.onAction(MODEL_ACTION_ID, async (event: any) => {
+      await handleModelAction({ value: event.value, thread: event.thread });
+    });
+
     await this.chat.initialize();
 
     const platforms = Object.keys(this.config.chat.adapters).join(", ");

package/src/gateway/model-command.ts

@@ -3,6 +3,9 @@
  *
  * Allows switching the default AI model from Telegram.
  * Reads/writes ~/.pi/agent/settings.json (defaultProvider + defaultModel).
+ *
+ * When called without arguments, shows an inline keyboard with model buttons.
+ * When a button is clicked, the onAction handler applies the selection.
  */
 
 import { homedir } from "node:os";
@@ -10,18 +13,36 @@ import { join } from "node:path";
 import { readFileSync, writeFileSync } from "node:fs";
 
 /** Known model aliases → Bedrock model IDs */
-const MODEL_ALIASES: Record<string, { provider: string; model: string; label: string }> = {
-  "opus": { provider: "amazon-bedrock", model: "us.anthropic.claude-opus-4-6", label: "Claude Opus 4.6" },
-  "opus-4.6": { provider: "amazon-bedrock", model: "us.anthropic.claude-opus-4-6", label: "Claude Opus 4.6" },
+export const MODEL_ALIASES: Record<string, { provider: string; model: string; label: string }> = {
+  // Anthropic Claude
   "opus-4.7": { provider: "amazon-bedrock", model: "us.anthropic.claude-opus-4-7", label: "Claude Opus 4.7" },
+  "opus": { provider: "amazon-bedrock", model: "us.anthropic.claude-opus-4-6", label: "Claude Opus 4.6" },
   "sonnet": { provider: "amazon-bedrock", model: "us.anthropic.claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
-  "sonnet-4.6": { provider: "amazon-bedrock", model: "us.anthropic.claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
   "haiku": { provider: "amazon-bedrock", model: "us.anthropic.claude-haiku-4-5", label: "Claude Haiku 4.5" },
-  "haiku-4.5": { provider: "amazon-bedrock", model: "us.anthropic.claude-haiku-4-5", label: "Claude Haiku 4.5" },
+  // DeepSeek
+  "deepseek": { provider: "amazon-bedrock", model: "us.deepseek.r1-v1:0", label: "DeepSeek R1" },
+  // Meta Llama
+  "llama": { provider: "amazon-bedrock", model: "us.meta.llama4-maverick-17b-instruct-v1:0", label: "Llama 4 Maverick" },
+  // Amazon Nova
+  "nova-pro": { provider: "amazon-bedrock", model: "us.amazon.nova-pro-v1:0", label: "Amazon Nova Pro" },
+  // Mistral
+  "mistral": { provider: "amazon-bedrock", model: "us.mistral.mistral-large-2411-v1:0", label: "Mistral Large" },
 };
 
+/** Models shown in the inline keyboard (max 8, ordered by preference) */
+const KEYBOARD_MODELS = [
+  "opus-4.7", "opus", "sonnet", "haiku",
+  "deepseek", "llama", "nova-pro", "mistral",
+] as const;
+
+/** Action ID for model selection callbacks */
+export const MODEL_ACTION_ID = "model_select";
+
 const SETTINGS_PATH = join(homedir(), ".pi", "agent", "settings.json");
 
+/** Callback data prefix used by @chat-adapter/telegram (coupled: if adapter changes this, buttons break) */
+const CALLBACK_PREFIX = "chat:";
+
 export interface ModelCommandContext {
   thread: any;
   text: string;
@@ -43,11 +64,30 @@ function writeSettings(settings: Record<string, any>): void {
 function getCurrentModel(settings: Record<string, any>): string {
   const provider = settings.defaultProvider ?? "unknown";
   const model = settings.defaultModel ?? "unknown";
-  // Try to find a friendly label
   for (const [alias, info] of Object.entries(MODEL_ALIASES)) {
-    if (info.provider === provider && info.model === model) return `${info.label} (${alias})`;
+    if (info.provider === provider && info.model === model) return `${info.label}`;
   }
-  return `${provider}/${model}`;
+  return `${model}`;
+}
+
+function encodeCallbackData(actionId: string, value: string): string {
+  return `${CALLBACK_PREFIX}${JSON.stringify({ a: actionId, v: value })}`;
+}
+
+function buildInlineKeyboard(): { inline_keyboard: Array<Array<{ text: string; callback_data: string }>> } {
+  // Layout: 2 buttons per row for compact display
+  const buttons = KEYBOARD_MODELS.map(alias => {
+    const info = MODEL_ALIASES[alias];
+    return {
+      text: info.label,
+      callback_data: encodeCallbackData(MODEL_ACTION_ID, alias),
+    };
+  });
+  const rows: Array<Array<{ text: string; callback_data: string }>> = [];
+  for (let i = 0; i < buttons.length; i += 2) {
+    rows.push(buttons.slice(i, i + 2));
+  }
+  return { inline_keyboard: rows };
 }
 
 export async function handleModel(ctx: ModelCommandContext): Promise<void> {
@@ -57,31 +97,61 @@ export async function handleModel(ctx: ModelCommandContext): Promise<void> {
 
   const settings = readSettings();
 
-  // No argument: show current model + available options
+  // No argument: show inline keyboard
   if (!target) {
     const current = getCurrentModel(settings);
-    const aliases = Object.entries(MODEL_ALIASES)
-      .filter(([alias]) => !alias.includes(".")) // Show short aliases only
-      .map(([alias, info]) => `  \`${alias}\` → ${info.label}`)
-      .join("\n");
+    const msgText = `🤖 Current model: <b>${current}</b>\n\nSelect a model:`;
+
+    // Try to send with inline keyboard via telegramFetch
+    const adapter = thread?.adapter;
+    if (adapter?.telegramFetch) {
+      const chatId = thread?.platformThreadId?.split(":")?.[1] ?? thread?.id?.split(":")?.[1];
+      if (chatId) {
+        try {
+          await adapter.telegramFetch("sendMessage", {
+            chat_id: chatId,
+            text: msgText,
+            parse_mode: "HTML",
+            reply_markup: buildInlineKeyboard(),
+          });
+          return;
+        } catch (err) {
+          console.warn("[roundhouse] /model inline keyboard failed, falling back:", (err as Error).message);
+        }
+      }
+    }
 
+    // Fallback: plain text
+    const aliases = KEYBOARD_MODELS.map(a => `  \`${a}\` → ${MODEL_ALIASES[a].label}`).join("\n");
     await postWithFallback(thread, `🤖 *Current model:* ${current}\n\n*Available:*\n${aliases}\n\n_Usage:_ \`/model sonnet\``);
     return;
   }
 
-  // Resolve alias or use as raw model ID
+  // Resolve alias
+  await applyModelSelection(target, settings, thread, postWithFallback);
+}
+
+/**
+ * Apply a model selection (used by both /model <arg> and inline keyboard callback).
+ */
+export async function applyModelSelection(
+  target: string,
+  settings: Record<string, any> | null,
+  thread: any,
+  postWithFallback: (thread: any, text: string) => Promise<void>,
+): Promise<void> {
+  if (!settings) settings = readSettings();
+
   const resolved = MODEL_ALIASES[target];
   if (!resolved) {
-    // Check if it looks like a full model ID (contains a dot or slash)
     if (target.includes(".") || target.includes("/")) {
-      // Use as-is with current provider
       const provider = settings.defaultProvider ?? "amazon-bedrock";
       settings.defaultModel = target;
       settings.defaultProvider = provider;
       writeSettings(settings);
-      await postWithFallback(thread, `✅ Model set to: \`${provider}/${target}\`\n\n⚠️ Restart needed: \`/restart\``);
+      await postWithFallback(thread, `✅ Model set to: \`${provider}/${target}\``);
     } else {
-      const aliases = Object.keys(MODEL_ALIASES).filter(a => !a.includes(".")).join(", ");
+      const aliases = Object.keys(MODEL_ALIASES).join(", ");
       await postWithFallback(thread, `❌ Unknown model: \`${target}\`\n\nAvailable: ${aliases}`);
     }
     return;
@@ -91,6 +161,26 @@ export async function handleModel(ctx: ModelCommandContext): Promise<void> {
   settings.defaultModel = resolved.model;
   writeSettings(settings);
 
-  await postWithFallback(thread, `✅ Model switched to: *${resolved.label}*\n\n⚠️ Takes effect on next agent turn (new sessions use new model).`);
+  await postWithFallback(thread, `✅ Switched to *${resolved.label}*`);
   console.log(`[roundhouse] /model: switched to ${resolved.provider}/${resolved.model}`);
 }
+
+/**
+ * Handle inline keyboard callback for model selection.
+ * Call this from chat.onAction(MODEL_ACTION_ID, ...).
+ */
+export async function handleModelAction(event: {
+  value?: string;
+  thread: any;
+}): Promise<void> {
+  const alias = event.value;
+  if (!alias || !MODEL_ALIASES[alias]) return;
+
+  const postFn = async (_t: any, text: string) => {
+    if (!event.thread) return;
+    try { await event.thread.post({ markdown: text }); }
+    catch { try { await event.thread.post(text); } catch {} }
+  };
+
+  await applyModelSelection(alias, null, event.thread, postFn);
+}