@inceptionstack/roundhouse 0.5.11 → 0.5.13

package/package.json

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

package/src/gateway/gateway.ts

@@ -23,13 +23,14 @@ 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";
 import { hostname } from "node:os";
 import { join } from "node:path";
 import { injectToolsSection } from "./tools-inject";
+import { injectPersonaSection, loadPersona } from "./persona-inject";
 
 /** Bot username for command suffix validation (set during gateway init) */
 let _botUsername = "";
@@ -327,6 +328,14 @@ export class Gateway {
       await handleOrAbort(thread, message);
     });
 
+    // ── Load persona files at startup (cached for process lifetime) ───
+    loadPersona();
+
+    // ── 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(", ");
@@ -403,6 +412,7 @@ export class Gateway {
 
       // Inject tools section (after STT enrichment so voice-only messages get it too)
       if (agentMessage.text) {
+        agentMessage.text = injectPersonaSection(agentMessage.text);
         agentMessage.text = injectToolsSection(agentMessage.text);
       }
 

package/src/gateway/later-command.ts

@@ -33,7 +33,7 @@ function ensureLaterFile(): void {
 
 export async function handleLater(ctx: LaterCommandContext): Promise<void> {
   const { thread, text, postWithFallback } = ctx;
-  const idea = text.replace(/^\/later\s*/i, "").trim();
+  const idea = text.replace(/^\/later(@\S+)?\s*/i, "").trim();
 
   // No argument: show contents
   if (!idea) {

package/src/gateway/model-command.ts

@@ -3,25 +3,46 @@
  *
  * 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";
 import { join } from "node:path";
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync } 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;
@@ -37,17 +58,37 @@ function readSettings(): Record<string, any> {
 }
 
 function writeSettings(settings: Record<string, any>): void {
+  mkdirSync(join(homedir(), ".pi", "agent"), { recursive: true });
   writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
 }
 
 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 +98,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 +162,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);
+}

package/src/gateway/persona-inject.ts

@@ -0,0 +1,94 @@
+/**
+ * gateway/persona-inject.ts — Inject <persona> section into agent prompts
+ *
+ * Reads user.md and soul.md (user-customized or bundled defaults) and
+ * prepends them as a structured section so the agent has identity and
+ * user context on every turn.
+ *
+ * Cached with mtime-based invalidation: stat() on each turn (~0.1ms),
+ * only re-reads if files have been modified since last load.
+ */
+
+import { readFileSync, statSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ROUNDHOUSE_DIR } from "../config";
+
+let cachedPersona: string | null = null;
+let lastMtime = 0;
+
+const SOUL_PATH = join(ROUNDHOUSE_DIR, "soul.md");
+const USER_PATH = join(ROUNDHOUSE_DIR, "user.md");
+
+function getMaxMtime(): number {
+  let max = 0;
+  try { max = Math.max(max, statSync(SOUL_PATH).mtimeMs); } catch {}
+  try { max = Math.max(max, statSync(USER_PATH).mtimeMs); } catch {}
+  return max;
+}
+
+function loadFile(filename: string): string {
+  const userPath = join(ROUNDHOUSE_DIR, filename);
+  const bundledPath = join(dirname(fileURLToPath(import.meta.url)), filename);
+
+  try {
+    return readFileSync(userPath, "utf8");
+  } catch {
+    try {
+      return readFileSync(bundledPath, "utf8");
+    } catch {
+      return "";
+    }
+  }
+}
+
+function buildPersona(): string {
+  const soul = loadFile("soul.md").trim();
+  const user = loadFile("user.md").trim();
+
+  if (!soul && !user) return "";
+
+  const parts: string[] = [];
+  if (soul) parts.push(soul);
+  if (user) parts.push(user);
+  return parts.join("\n\n---\n\n");
+}
+
+/**
+ * Load persona files and cache the result.
+ * Call at gateway startup to eagerly load.
+ */
+export function loadPersona(): void {
+  cachedPersona = buildPersona();
+  lastMtime = getMaxMtime();
+}
+
+/**
+ * Reload persona from disk. Call after agent edits user.md/soul.md
+ * (e.g. from an IPC handler or post-tool-execution hook).
+ */
+export function reloadPersona(): void {
+  cachedPersona = buildPersona();
+  lastMtime = getMaxMtime();
+}
+
+/**
+ * Prepend a <persona> section to the prompt text.
+ * Only injects if soul.md or user.md have content.
+ * Auto-reloads if files have been modified since last load.
+ */
+export function injectPersonaSection(text: string): string {
+  if (cachedPersona === null) {
+    loadPersona();
+  } else {
+    // Cheap mtime check — auto-reload if agent edited the files
+    const currentMtime = getMaxMtime();
+    if (currentMtime !== lastMtime) {
+      reloadPersona();
+    }
+  }
+  if (!cachedPersona) return text;
+  // Escape any literal </persona> in content to prevent XML injection
+  const safe = cachedPersona.replace(/<\/persona>/gi, "&lt;/persona&gt;");
+  return `<persona>\n${safe}\n</persona>\n\n${text}`;
+}

package/src/gateway/soul.md

@@ -0,0 +1,35 @@
+# Who You Are
+
+_You're not a chatbot. You're a technical partner._
+
+## Core Identity
+
+**Name:** Loki
+**Role:** Senior engineer and ops partner. You help build, deploy, debug, and maintain software and infrastructure. You have opinions and you share them.
+
+## Core Truths
+
+**Be genuinely helpful, not performatively helpful.** Skip the filler — just help. Actions speak louder than words.
+
+**Have opinions.** When something is a bad pattern, say so. When there's a better approach, recommend it. You're not a yes-machine.
+
+**Be resourceful before asking.** Check the docs. Read the file. Try things. _Then_ ask if you're stuck.
+
+**Earn trust through competence.** You have access to tools, shell, and infrastructure. Use them wisely. Be careful with destructive operations. Be bold with read operations.
+
+**Think holistically.** Consider the broader context — architecture, maintainability, security, user experience.
+
+## Boundaries
+
+- Ask before destructive operations (deletions, config changes with blast radius)
+- Read freely — list, describe, get operations are safe
+- Private things stay private
+- Never send half-baked replies
+
+## Vibe
+
+Direct, technical, concise. Think senior engineer talking to senior engineer. Thorough when it matters, brief when it doesn't. No corporate speak.
+
+## Continuity
+
+Each session, you wake up fresh. Your workspace files _are_ your memory. Read them. Update them.

package/src/gateway/tools.md

@@ -10,6 +10,8 @@ Do NOT create files directly in `~/` or pollute the home directory. Use subdirec
 - `~/.roundhouse/workspace/later.md` — ideas saved via `/later`
 - `~/.roundhouse/workspace/<project>/` — project-specific files if needed
 
+> 💡 When looking for things to work on, check `~/.roundhouse/workspace/later.md` for saved ideas and tasks.
+
 ## roundhouse cron add
 
 Schedule recurring or one-shot jobs. The user may ask you to "remind me", "check every X", "do Y later", or "schedule Z".

package/src/gateway/user.md

@@ -0,0 +1,10 @@
+# About Your Human
+
+- **Name:** (not yet set)
+- **What to call them:** (use their Telegram username until they tell you otherwise)
+- **Timezone:** UTC
+- **Notes:** (learn about them through conversation)
+
+## Preferences
+
+- (Will be filled in as you learn what they prefer)

package/src/provisioning/bundle.ts

@@ -320,6 +320,8 @@ export function provisionWorkspaceFiles(opts: ProvisionOpts = {}): void {
   // Files to provision: [bundled filename, target filename]
   const files: [string, string][] = [
     ["tools.md", "tools.md"],
+    ["soul.md", "soul.md"],
+    ["user.md", "user.md"],
   ];
 
   try {