arisa 4.3.0 → 4.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "4.3.0",
+  "version": "4.3.2",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/agent/agent-manager.js

@@ -3,6 +3,7 @@ import { readFile, stat, unlink } from "node:fs/promises";
 import { createAgentSession, DefaultResourceLoader, SessionManager, defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { createPiRuntime, hasProviderAuth } from "./pi-runtime.js";
+import { resolveChatModelSelection } from "./model-selection.js";
 import { appendArisaAgentsFile, arisaAgentsFile, arisaInstallDir, buildAgentRuntimeContext } from "./runtime-context.js";
 import { withTimeout } from "./prompt-timeout.js";
 import { buildPiToolPolicy, getCoreCodingTools } from "./core-tools.js";
@@ -126,9 +127,9 @@ export class AgentManager {
     this.sessions.delete(String(chatId));
   }
 
-  createSessionManager(chatId, workspaceDir = arisaInstallDir) {
+  createSessionManager(chatId, workspaceDir = arisaInstallDir, sessionRevision = 0) {
     const sessionKey = String(chatId);
-    const sessionDir = getChatPiSessionsDir(sessionKey);
+    const sessionDir = getChatPiSessionsDir(sessionKey, sessionRevision);
     if (this.pendingNewSessions.has(sessionKey)) {
       this.logger?.log("agent", `starting new persisted session for chat ${sessionKey}`);
       return { sessionManager: SessionManager.create(workspaceDir, sessionDir), isNewSession: true };
@@ -165,14 +166,16 @@ export class AgentManager {
 
   async getSessionContext(chatId, telegram) {
     const sessionKey = String(chatId);
-    const effectiveModelId = this.config.pi.model;
+    const modelSelection = resolveChatModelSelection(this.config, sessionKey);
+    const effectiveModelId = modelSelection.model;
+    const effectiveModelKey = `${modelSelection.provider}/${effectiveModelId}@${modelSelection.sessionRevision}`;
     if (this.sessions.has(sessionKey)) {
       const existing = this.sessions.get(sessionKey);
-      if (existing?.modelId === effectiveModelId) {
+      if (existing?.modelKey === effectiveModelKey) {
         this.logger?.log("agent", `reusing session for chat ${sessionKey}`);
         return existing;
       }
-      this.logger?.log("agent", `model changed for chat ${sessionKey}: ${existing?.modelId || "unknown"} -> ${effectiveModelId}; recreating session`);
+      this.logger?.log("agent", `model changed for chat ${sessionKey}: ${existing?.modelKey || "unknown"} -> ${effectiveModelKey}; recreating session`);
       this.sessions.delete(sessionKey);
       this.pendingNewSessions.add(sessionKey);
     }
@@ -192,7 +195,11 @@ export class AgentManager {
       customToolNames: [...arisaToolNames, "system_shell"]
     });
     await assertDirectory(policy.workspaceDir, "pi.workspaceDir");
-    const { sessionManager, isNewSession } = this.createSessionManager(sessionKey, policy.workspaceDir);
+    const { sessionManager, isNewSession } = this.createSessionManager(
+      sessionKey,
+      policy.workspaceDir,
+      modelSelection.sessionRevision
+    );
     const hasExistingSession = sessionManager.buildSessionContext().messages.length > 0;
     this.logger?.log("agent", `${hasExistingSession ? "resuming" : "creating"} session for chat ${sessionKey} with model ${effectiveModelId}`);
     const customTools = [
@@ -224,7 +231,7 @@ export class AgentManager {
       })}`);
     }
 
-    const ctx = { session, modelId: effectiveModelId };
+    const ctx = { session, modelId: effectiveModelId, modelKey: effectiveModelKey };
     this.sessions.set(sessionKey, ctx);
     if (isNewSession) {
       this.pendingNewSessions.delete(sessionKey);

package/src/core/agent/model-selection.js

@@ -0,0 +1,36 @@
+function chatKey(chatId) {
+  return String(chatId);
+}
+
+export function resolveChatModelSelection(config, chatId) {
+  const selection = config.pi.chatModels?.[chatKey(chatId)];
+  if (!selection || selection.provider !== config.pi.provider) {
+    return {
+      provider: config.pi.provider,
+      model: config.pi.model,
+      sessionRevision: 0
+    };
+  }
+  if (!Number.isSafeInteger(selection.sessionRevision) || selection.sessionRevision <= 0) {
+    throw new Error(`Invalid model session revision for chat ${chatId}`);
+  }
+  return selection;
+}
+
+export function resolveChatModel(config, chatId) {
+  return resolveChatModelSelection(config, chatId).model;
+}
+
+export function selectChatModel(config, chatId, model) {
+  if (model.provider !== config.pi.provider) {
+    throw new Error(`Cannot select model from provider ${model.provider}; active provider is ${config.pi.provider}`);
+  }
+  config.pi.chatModels ||= {};
+  const key = chatKey(chatId);
+  const sessionRevision = (config.pi.chatModels[key]?.sessionRevision || 0) + 1;
+  config.pi.chatModels[key] = {
+    provider: model.provider,
+    model: model.id,
+    sessionRevision
+  };
+}

package/src/core/agent/pi-runtime.js

@@ -53,6 +53,14 @@ export function listProviderModels(provider, runtime = createPiRuntime()) {
     .sort((a, b) => compareText(a.name || a.id, b.name || b.id));
 }
 
+export function formatPiModelOption(model) {
+  const capabilities = [
+    model.reasoning ? "reasoning" : null,
+    model.input?.includes("image") ? "image" : null
+  ].filter(Boolean).join(", ");
+  return capabilities ? `${model.id} [${capabilities}]` : model.id;
+}
+
 export function findPiModel({ provider, model, apiKey } = {}) {
   const runtime = createPiRuntime({ provider, apiKey });
   return {

package/src/core/config/config-defaults.js

@@ -14,9 +14,17 @@ export const daemonConfigDefaults = Object.freeze({
   queuePollIntervalMs: 250
 });
 
+export const telegramConfigDefaults = Object.freeze({
+  modelPickerPageSize: 8
+});
+
 export function applyConfigDefaults(config) {
   return {
     ...config,
+    telegram: {
+      ...telegramConfigDefaults,
+      ...(config.telegram || {})
+    },
     daemons: {
       ...daemonConfigDefaults,
       ...(config.daemons || {})

package/src/core/tools/daemon-processes.js

@@ -337,11 +337,16 @@ async function listChatDaemonRecords() {
   const records = [];
   for (const chatEntry of chatEntries) {
     if (!chatEntry.isDirectory()) continue;
+    let scope;
+    try {
+      scope = normalizeDaemonScope({ type: "chat", chatId: chatEntry.name });
+    } catch {
+      continue;
+    }
     const toolsRoot = path.join(chatsDir, chatEntry.name, "state", "tools");
     const toolEntries = await readdir(toolsRoot, { withFileTypes: true }).catch(() => []);
     for (const toolEntry of toolEntries) {
       if (!toolEntry.isDirectory()) continue;
-      const scope = { type: "chat", chatId: chatEntry.name };
       const meta = await readJson(daemonPaths({ toolName: toolEntry.name, scope }).metaFile, null);
       if (meta?.toolName && meta?.entryPath) records.push(meta);
     }

package/src/runtime/bootstrap.js

@@ -5,9 +5,10 @@ import { stdin as input, stdout as output } from "node:process";
 import { spawn } from "node:child_process";
 import { Bot } from "grammy";
 import { createPiOAuthLogin } from "../core/agent/pi-auth-login.js";
-import { createPiRuntime, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
-import { applyConfigDefaults } from "../core/config/config-defaults.js";
+import { createPiRuntime, formatPiModelOption, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
+import { applyConfigDefaults, telegramConfigDefaults } from "../core/config/config-defaults.js";
 import { buildDeviceCodeTelegramMessage } from "../transport/telegram/device-code-message.js";
+import { buildPagedInlineKeyboard } from "../transport/telegram/paged-inline-keyboard.js";
 import { configFile, ensureArisaHome } from "./paths.js";
 
 const ARISA_BANNER = [
@@ -100,30 +101,6 @@ function parseYesNo(value, fallback = true) {
   return null;
 }
 
-function buildPagedInlineKeyboard(action, items, { page = 0, pageSize = 8 } = {}) {
-  const pageCount = Math.max(1, Math.ceil(items.length / pageSize));
-  const currentPage = Math.max(0, Math.min(pageCount - 1, page));
-  const startIndex = currentPage * pageSize;
-  const rows = items.slice(startIndex, startIndex + pageSize).map((item, index) => ([{
-    text: item.text,
-    callback_data: `${action}:${startIndex + index}`
-  }]));
-
-  if (pageCount > 1) {
-    const navigation = [];
-    if (currentPage > 0) {
-      navigation.push({ text: "Previous", callback_data: `${action}-page:${currentPage - 1}` });
-    }
-    navigation.push({ text: `${currentPage + 1}/${pageCount}`, callback_data: "noop:page" });
-    if (currentPage < pageCount - 1) {
-      navigation.push({ text: "Next", callback_data: `${action}-page:${currentPage + 1}` });
-    }
-    rows.push(navigation);
-  }
-
-  return { inline_keyboard: rows };
-}
-
 function getIncomingChatMeta(ctx) {
   return {
     languageCode: ctx.from?.language_code || "",
@@ -138,11 +115,6 @@ function formatProviderOption(item) {
   return `${item.provider} (${item.modelCount} models, ${authLabel})`;
 }
 
-function formatModelOption(model) {
-  const capabilities = [model.reasoning ? "reasoning" : null, model.input?.includes("image") ? "image" : null].filter(Boolean).join(", ");
-  return capabilities ? `${model.id} [${capabilities}]` : model.id;
-}
-
 function selectPiLoginOption(options = []) {
   return options.find((option) => /device/i.test(`${option.id} ${option.label}`))
     || options.find((option) => /browser|oauth|web/i.test(`${option.id} ${option.label}`))
@@ -215,7 +187,7 @@ async function collectCliBootstrapChoices({ telegramApiKey, rl, ask }) {
   const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, runtime));
   console.log(`\nAvailable models for ${selectedProvider.provider}:`);
   models.forEach((model, index) => {
-    console.log(`${index + 1}. ${formatModelOption(model)}`);
+    console.log(`${index + 1}. ${formatPiModelOption(model)}`);
   });
 
   const selectedModel = selectByIndex(models, await ask("Select Pi model by number", "1"));
@@ -326,14 +298,20 @@ async function runTelegramBootstrap({ telegramApiKey, setupToken, botInfo }) {
   const askProvider = async (ctx = null, page = 0) => {
     state = "provider";
     await showSetupPrompt(ctx, "Select the Pi provider Arisa should use:", {
-      reply_markup: buildPagedInlineKeyboard("provider", providers.map((provider) => ({ text: formatProviderOption(provider) })), { page })
+      reply_markup: buildPagedInlineKeyboard("provider", providers.map((provider) => ({ text: formatProviderOption(provider) })), {
+        page,
+        pageSize: telegramConfigDefaults.modelPickerPageSize
+      })
     });
   };
 
   const askModel = async (ctx = null, page = 0) => {
     state = "model";
     const models = sortBootstrapModels(selectedProvider.provider, listProviderModels(selectedProvider.provider, createPiRuntime()));
-    const keyboard = buildPagedInlineKeyboard("model", models.map((model) => ({ text: formatModelOption(model) })), { page });
+    const keyboard = buildPagedInlineKeyboard("model", models.map((model) => ({ text: formatPiModelOption(model) })), {
+      page,
+      pageSize: telegramConfigDefaults.modelPickerPageSize
+    });
     keyboard.inline_keyboard.push([{ text: "Back to providers", callback_data: "back:provider" }]);
     await showSetupPrompt(ctx, `Select the model for ${selectedProvider.provider}:`, {
       reply_markup: keyboard

package/src/runtime/paths.js

@@ -72,8 +72,14 @@ export function getDaemonInstanceDir(toolName, scope = { type: "global" }) {
     : path.join(getChatToolStateDir(normalized.chatId, toolName), "daemon");
 }
 
-export function getChatPiSessionsDir(chatId) {
-  return path.join(getChatDir(chatId), "state", "pi-sessions");
+export function getChatPiSessionsDir(chatId, sessionRevision = 0) {
+  if (!Number.isSafeInteger(sessionRevision) || sessionRevision < 0) {
+    throw new Error(`Invalid Pi session revision: ${sessionRevision}`);
+  }
+  const sessionsDir = path.join(getChatDir(chatId), "state", "pi-sessions");
+  return sessionRevision === 0
+    ? sessionsDir
+    : path.join(sessionsDir, String(sessionRevision));
 }
 
 export function getToolDir(toolName) {

package/src/transport/telegram/bot.js

@@ -3,9 +3,12 @@ import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact, formatLocationText } from "./media.js";
 import { buildDeviceCodeTelegramMessage } from "./device-code-message.js";
+import { buildModelPicker, parseModelPickerAction } from "./model-picker.js";
 import { renderTelegramHtml } from "./text-format.js";
 import { buildPiAuthRecoveryBlockedMessage, buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue, getPiAuthStatus } from "../../core/agent/auth-flow.js";
 import { createPiOAuthLogin } from "../../core/agent/pi-auth-login.js";
+import { resolveChatModel, selectChatModel } from "../../core/agent/model-selection.js";
+import { createPiRuntime, listProviderModels } from "../../core/agent/pi-runtime.js";
 import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
 
 const slowPromptNoticeMs = 300_000;
@@ -410,6 +413,49 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     return perChatState.get(chatId);
   }
 
+  function getProviderModels() {
+    const runtime = createPiRuntime({
+      provider: config.pi.provider,
+      apiKey: config.pi.apiKey
+    });
+    return listProviderModels(config.pi.provider, runtime);
+  }
+
+  async function showModelPicker(ctx, page = 0) {
+    const picker = buildModelPicker({
+      provider: config.pi.provider,
+      models: getProviderModels(),
+      selectedModelId: resolveChatModel(config, ctx.chat.id),
+      page,
+      pageSize: config.telegram.modelPickerPageSize
+    });
+    const extra = { reply_markup: picker.replyMarkup };
+    const messageId = ctx.callbackQuery?.message?.message_id;
+    if (messageId) {
+      return ctx.api.editMessageText(ctx.chat.id, messageId, picker.text, extra);
+    }
+    return ctx.reply(picker.text, extra);
+  }
+
+  async function persistChatModel(chatId, model) {
+    const key = chatKey(chatId);
+    const hadSelections = Boolean(config.pi.chatModels);
+    const previousSelection = config.pi.chatModels?.[key];
+    selectChatModel(config, chatId, model);
+    try {
+      await saveConfig(config);
+    } catch (error) {
+      if (previousSelection) {
+        config.pi.chatModels[key] = previousSelection;
+      } else {
+        delete config.pi.chatModels[key];
+        if (!hadSelections) delete config.pi.chatModels;
+      }
+      throw error;
+    }
+    agentManager.resetSession(chatId);
+  }
+
   async function buildIncomingPrompt(ctx) {
     const chatId = ctx.chat.id;
     logger?.log("telegram", `message ${ctx.msg.message_id} in chat ${chatId}`);
@@ -684,6 +730,12 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     await handleNewCommand(ctx);
   });
 
+  bot.command("model", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    await showModelPicker(ctx);
+  });
+
   bot.command("auth", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -717,6 +769,67 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     }
   });
 
+  bot.on("callback_query:data", async (ctx, next) => {
+    const action = parseModelPickerAction(ctx.callbackQuery.data);
+    if (!action) return next();
+    if (action.type === "noop") {
+      await ctx.answerCallbackQuery();
+      return;
+    }
+
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig });
+    if (!auth.ok) {
+      await ctx.answerCallbackQuery({ text: "This chat is not authorized.", show_alert: true });
+      return;
+    }
+
+    try {
+      if (action.type === "page") {
+        await showModelPicker(ctx, action.value);
+        await ctx.answerCallbackQuery();
+        return;
+      }
+
+      if (getChatState(ctx.chat.id).processing) {
+        await ctx.answerCallbackQuery({
+          text: "Wait for the current response before changing models.",
+          show_alert: true
+        });
+        return;
+      }
+
+      const models = getProviderModels();
+      const model = models[action.value];
+      if (!model) {
+        await ctx.answerCallbackQuery({
+          text: "This model list is no longer current. Run /model again.",
+          show_alert: true
+        });
+        return;
+      }
+
+      const currentModelId = resolveChatModel(config, ctx.chat.id);
+      if (model.id === currentModelId) {
+        await ctx.answerCallbackQuery({ text: `Already using ${model.id}.` });
+        return;
+      }
+
+      await persistChatModel(ctx.chat.id, model);
+      await ctx.api.editMessageText(
+        ctx.chat.id,
+        ctx.callbackQuery.message.message_id,
+        `Model changed to ${model.provider}/${model.id}.\nA new chat context will start with your next message.`
+      );
+      await ctx.answerCallbackQuery({ text: `Using ${model.id}.` });
+    } catch (error) {
+      logger?.error("telegram", `model selection failed for chat ${ctx.chat.id}: ${getErrorMessage(error)}`);
+      await ctx.answerCallbackQuery({
+        text: "Could not change the model.",
+        show_alert: true
+      }).catch(() => {});
+    }
+  });
+
   bot.on("message", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -753,6 +866,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       config.telegram.chatMeta ||= {};
       await bot.api.setMyCommands([
         { command: "new", description: "Start a new chat context" },
+        { command: "model", description: "Choose the model for this chat" },
         { command: "auth", description: "Show Pi authentication status" }
       ]);
       if (!taskTimer) {

package/src/transport/telegram/model-picker.js

@@ -0,0 +1,25 @@
+import { formatPiModelOption } from "../../core/agent/pi-runtime.js";
+import { buildPagedInlineKeyboard } from "./paged-inline-keyboard.js";
+
+export function parseModelPickerAction(data) {
+  if (data === "noop:page") return { type: "noop", value: null };
+  const match = /^(model|model-page):(\d+)$/.exec(String(data || ""));
+  if (!match) return null;
+  return {
+    type: match[1] === "model" ? "select" : "page",
+    value: Number(match[2])
+  };
+}
+
+export function buildModelPicker({ provider, models, selectedModelId, page, pageSize }) {
+  if (!models.length) {
+    throw new Error(`No models available for provider ${provider}`);
+  }
+  const items = models.map((model) => ({
+    text: `${model.id === selectedModelId ? "✓ " : ""}${formatPiModelOption(model)}`
+  }));
+  return {
+    text: `Current model: ${provider}/${selectedModelId}\nSelect a model for this chat:`,
+    replyMarkup: buildPagedInlineKeyboard("model", items, { page, pageSize })
+  };
+}

package/src/transport/telegram/paged-inline-keyboard.js

@@ -0,0 +1,30 @@
+function requirePositiveInteger(value, name) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+}
+
+export function buildPagedInlineKeyboard(action, items, { page = 0, pageSize }) {
+  requirePositiveInteger(pageSize, "pageSize");
+  const pageCount = Math.max(1, Math.ceil(items.length / pageSize));
+  const currentPage = Math.max(0, Math.min(pageCount - 1, page));
+  const startIndex = currentPage * pageSize;
+  const rows = items.slice(startIndex, startIndex + pageSize).map((item, index) => ([{
+    text: item.text,
+    callback_data: `${action}:${startIndex + index}`
+  }]));
+
+  if (pageCount > 1) {
+    const navigation = [];
+    if (currentPage > 0) {
+      navigation.push({ text: "Previous", callback_data: `${action}-page:${currentPage - 1}` });
+    }
+    navigation.push({ text: `${currentPage + 1}/${pageCount}`, callback_data: "noop:page" });
+    if (currentPage < pageCount - 1) {
+      navigation.push({ text: "Next", callback_data: `${action}-page:${currentPage + 1}` });
+    }
+    rows.push(navigation);
+  }
+
+  return { inline_keyboard: rows };
+}

package/test/daemon-runtime.test.js

@@ -116,6 +116,38 @@ test("isolates daemon process files and context by chat scope", async () => {
   await Promise.all([first.stop(), second.stop()]);
 });
 
+test("supervisor ignores invalid chat directories and recovers valid daemons", async () => {
+  const invalidChatDir = path.join(homeDir, "chats", "24137857-c513-4f53-b39d-1b28f51ebbb6");
+  await mkdir(path.join(invalidChatDir, "state", "tools", "orphaned-tool"), { recursive: true });
+
+  const runtime = runtimeFor({ type: "chat", chatId: "202" }, {
+    autoStart: true,
+    startupContext: { health: "ok" }
+  });
+  let supervisor;
+
+  try {
+    await runtime.submit({ value: "before" }, { timeoutMs: 1_000 });
+    const oldPid = await runtime.getPid();
+    process.kill(oldPid, "SIGKILL");
+    await waitFor(() => !isProcessAlive(oldPid));
+
+    supervisor = createToolProcessSupervisor({ policy });
+    await supervisor.start();
+
+    const newPid = await waitFor(async () => {
+      const pid = await runtime.getPid();
+      const status = await readJson(runtime.paths.statusFile, {});
+      return pid && pid !== oldPid && status.state === "ready" ? pid : null;
+    });
+    assert.notEqual(newPid, oldPid);
+  } finally {
+    await supervisor?.stop();
+    await runtime.stop().catch(() => {});
+    await rm(invalidChatDir, { recursive: true, force: true });
+  }
+});
+
 test("rejects stale readiness even when the pid is alive", async () => {
   const status = {
     state: "ready",

package/test/model-selection.test.js

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import { resolveChatModel, selectChatModel } from "../src/core/agent/model-selection.js";
+import { applyConfigDefaults, telegramConfigDefaults } from "../src/core/config/config-defaults.js";
+import { getChatPiSessionsDir } from "../src/runtime/paths.js";
+import { buildModelPicker, parseModelPickerAction } from "../src/transport/telegram/model-picker.js";
+
+function createConfig() {
+  return {
+    telegram: {},
+    pi: {
+      provider: "openai-codex",
+      model: "gpt-default"
+    }
+  };
+}
+
+test("resolves the default model until a chat selects one", () => {
+  const config = createConfig();
+
+  assert.equal(resolveChatModel(config, 123), "gpt-default");
+
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-selected" });
+
+  assert.equal(resolveChatModel(config, 123), "gpt-selected");
+  assert.equal(resolveChatModel(config, 456), "gpt-default");
+  assert.deepEqual(config.pi.chatModels["123"], {
+    provider: "openai-codex",
+    model: "gpt-selected",
+    sessionRevision: 1
+  });
+});
+
+test("starts a distinct persisted Pi session revision on every model change", () => {
+  const config = createConfig();
+
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-a" });
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-b" });
+
+  assert.equal(config.pi.chatModels["123"].sessionRevision, 2);
+  assert.equal(
+    getChatPiSessionsDir(123, config.pi.chatModels["123"].sessionRevision),
+    path.join(getChatPiSessionsDir(123), "2")
+  );
+});
+
+test("ignores a chat selection from a different active provider", () => {
+  const config = createConfig();
+  config.pi.chatModels = {
+    123: { provider: "anthropic", model: "claude-selected" }
+  };
+
+  assert.equal(resolveChatModel(config, 123), "gpt-default");
+});
+
+test("rejects selecting a model outside the active provider", () => {
+  const config = createConfig();
+
+  assert.throws(
+    () => selectChatModel(config, 123, { provider: "anthropic", id: "claude-selected" }),
+    /active provider is openai-codex/
+  );
+});
+
+test("builds a paged model picker and marks the current model", () => {
+  const models = [
+    { provider: "openai-codex", id: "gpt-a", reasoning: false, input: ["text"] },
+    { provider: "openai-codex", id: "gpt-b", reasoning: true, input: ["text", "image"] },
+    { provider: "openai-codex", id: "gpt-c", reasoning: false, input: ["text"] }
+  ];
+
+  const picker = buildModelPicker({
+    provider: "openai-codex",
+    models,
+    selectedModelId: "gpt-b",
+    page: 0,
+    pageSize: 2
+  });
+
+  assert.match(picker.text, /openai-codex\/gpt-b/);
+  assert.equal(picker.replyMarkup.inline_keyboard[0][0].callback_data, "model:0");
+  assert.match(picker.replyMarkup.inline_keyboard[1][0].text, /^✓ gpt-b \[reasoning, image\]$/);
+  assert.equal(picker.replyMarkup.inline_keyboard[2][1].callback_data, "model-page:1");
+});
+
+test("parses only model picker callback data", () => {
+  assert.deepEqual(parseModelPickerAction("model:12"), { type: "select", value: 12 });
+  assert.deepEqual(parseModelPickerAction("model-page:2"), { type: "page", value: 2 });
+  assert.deepEqual(parseModelPickerAction("noop:page"), { type: "noop", value: null });
+  assert.equal(parseModelPickerAction("provider:1"), null);
+  assert.equal(parseModelPickerAction("model:-1"), null);
+});
+
+test("centralizes the model picker page size in Telegram config defaults", () => {
+  const config = applyConfigDefaults(createConfig());
+
+  assert.equal(config.telegram.modelPickerPageSize, telegramConfigDefaults.modelPickerPageSize);
+});