switchroom 0.16.7 → 0.16.9

package/telegram-plugin/tests/model-command.test.ts

@@ -18,6 +18,8 @@ import {
   parseModelCommand,
   handleModelCommand,
   isValidModelArg,
+  isSrModel,
+  isClaudeModel,
   MODEL_ALIASES,
   type ModelCommandDeps,
 } from "../gateway/model-command.js";
@@ -35,6 +37,7 @@ function okResult(output: string): InjectResult {
 
 function makeDeps(overrides: Partial<ModelCommandDeps> = {}) {
   const calls: Array<{ agent: string; command: string }> = [];
+  const restartCalls: string[] = [];
   const deps: ModelCommandDeps = {
     inject: async (agent, command) => {
       calls.push({ agent, command });
@@ -45,9 +48,11 @@ function makeDeps(overrides: Partial<ModelCommandDeps> = {}) {
     escapeHtml: (s) =>
       s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"),
     preBlock: (s) => `<pre>${s}</pre>`,
+    getActiveSessionModel: () => null,
+    scheduleRestart: async (reason) => { restartCalls.push(reason); },
     ...overrides,
   };
-  return { deps, calls };
+  return { deps, calls, restartCalls };
 }
 
 describe("parseModelCommand", () => {
@@ -237,6 +242,97 @@ describe("handleModelCommand — set", () => {
   });
 });
 
+describe("isSrModel / isClaudeModel helpers", () => {
+  it("isSrModel is true only for sr-* names", () => {
+    expect(isSrModel("sr-gemini-2.5-pro")).toBe(true);
+    expect(isSrModel("sr-deepseek-r1")).toBe(true);
+    expect(isSrModel("claude-sonnet-4-6")).toBe(false);
+    expect(isSrModel("sonnet")).toBe(false);
+    expect(isSrModel("")).toBe(false);
+  });
+
+  it("isClaudeModel is true for aliases and claude-* ids", () => {
+    for (const alias of MODEL_ALIASES) {
+      expect(isClaudeModel(alias), alias).toBe(true);
+    }
+    expect(isClaudeModel("claude-opus-4-8")).toBe(true);
+    expect(isClaudeModel("claude-sonnet-4-6[1m]")).toBe(true);
+    expect(isClaudeModel("sr-gemini-2.5-pro")).toBe(false);
+    expect(isClaudeModel("gpt-4")).toBe(false);
+  });
+});
+
+describe("handleModelCommand — sr-* → Claude graceful restart", () => {
+  it("schedules restart instead of injecting when session is on sr-* and target is Claude alias", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => "sr-gemini-2.5-pro",
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "opus" }, deps);
+    // Must NOT inject
+    expect(calls).toHaveLength(0);
+    // Must schedule a restart
+    expect(restartCalls).toHaveLength(1);
+    expect(restartCalls[0]).toContain("opus");
+    expect(restartCalls[0]).toContain("sr-to-claude");
+    // Reply mentions the sr-* model and ~30s
+    expect(reply.text).toContain("sr-gemini-2.5-pro");
+    expect(reply.text).toContain("30s");
+    expect(reply.html).toBe(true);
+  });
+
+  it("schedules restart when session is on sr-* and target is a full claude-* id", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => "sr-deepseek-r1",
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "claude-opus-4-8" }, deps);
+    expect(calls).toHaveLength(0);
+    expect(restartCalls).toHaveLength(1);
+    expect(reply.text).toContain("sr-deepseek-r1");
+    expect(reply.text).toContain("30s");
+  });
+
+  it("does NOT restart when switching between Claude models (no sr-* session)", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => "Opus 4.8",
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "sonnet" }, deps);
+    // Normal inject path: still injects, no restart
+    expect(calls).toHaveLength(1);
+    expect(restartCalls).toHaveLength(0);
+    expect(reply.text).toContain("Set model to sonnet");
+  });
+
+  it("does NOT restart when switching from Claude to sr-* (no session override)", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => null,
+    });
+    await handleModelCommand({ kind: "set", model: "sr-gemini-2.5-pro" }, deps);
+    // sr-* is not a Claude model — no restart
+    expect(restartCalls).toHaveLength(0);
+    expect(calls).toHaveLength(1);
+  });
+
+  it("surfaces scheduleRestart failures without propagating the error", async () => {
+    const { deps, calls } = makeDeps({
+      getActiveSessionModel: () => "sr-deepseek-r1",
+      scheduleRestart: async () => { throw new Error("hostd unreachable"); },
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "sonnet" }, deps);
+    expect(calls).toHaveLength(0);
+    expect(reply.text).toContain("Could not schedule restart");
+    expect(reply.text).toContain("hostd unreachable");
+  });
+
+  it("null session model (no prior override) still uses normal inject path for Claude target", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => null,
+    });
+    await handleModelCommand({ kind: "set", model: "opus" }, deps);
+    expect(calls).toHaveLength(1);
+    expect(restartCalls).toHaveLength(0);
+  });
+});
+
 describe("inject allowlist contract", () => {
   it("/model stays on the inject allowlist (the set path depends on it)", async () => {
     const { INJECT_COMMANDS } = await import("../../src/agents/inject.js");
@@ -258,6 +354,7 @@ import {
   MODEL_CALLBACK_HEADER,
   MODEL_CALLBACK_SR,
   SR_MODEL_LABELS,
+  isSrToClaudeTransition,
   type ModelMenuDeps,
 } from "../gateway/model-command.js";
 import { labelTag } from "../../src/agents/model-picker.js";
@@ -578,3 +675,29 @@ describe("handleModelMenuCallback — sr-* selection", () => {
     expect(out.answer).toBe("Invalid model name");
   });
 });
+
+// ---------------------------------------------------------------------------
+// isSrToClaudeTransition helper (used by gateway callback handler)
+// ---------------------------------------------------------------------------
+
+describe("isSrToClaudeTransition", () => {
+  it("true when prev is sr-* and next is not sr-*", () => {
+    expect(isSrToClaudeTransition("sr-gemini-2.5-pro", "Haiku 4.5")).toBe(true);
+    expect(isSrToClaudeTransition("sr-deepseek-r1", "Fable 5")).toBe(true);
+    expect(isSrToClaudeTransition("sr-deepseek-r1", "claude-opus-4-8")).toBe(true);
+  });
+
+  it("false when prev is not sr-* (Claude → Claude)", () => {
+    expect(isSrToClaudeTransition("Opus 4.8", "Haiku 4.5")).toBe(false);
+    expect(isSrToClaudeTransition(null, "Sonnet")).toBe(false);
+    expect(isSrToClaudeTransition(undefined, "Sonnet")).toBe(false);
+  });
+
+  it("false when prev is sr-* but next is also sr-* (sr-* → sr-*)", () => {
+    expect(isSrToClaudeTransition("sr-gemini-2.5-pro", "sr-deepseek-r1")).toBe(false);
+  });
+
+  it("false when switching to sr-* from Claude (Claude → sr-*)", () => {
+    expect(isSrToClaudeTransition("Sonnet", "sr-gemini-2.5-pro")).toBe(false);
+  });
+});

package/telegram-plugin/uat/scenarios/jtbd-model-litellm-sr-dm.test.ts

@@ -57,7 +57,12 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
         const openrouterHeader = flat.find(
           (b) => b.text.includes("OpenRouter") && b.callbackData === "mdl:h",
         );
-        const srButton = flat.find((b) => b.callbackData?.startsWith("mdl:sr:"));
+        // Prefer a fast non-reasoning model for the E2E test; reasoning models
+        // (deepseek-r1, o1, o3) take 2-5 min per response and hit the silence poke.
+        const srButton =
+          flat.find((b) => b.callbackData?.startsWith("mdl:sr:") && /flash/.test(b.callbackData)) ??
+          flat.find((b) => b.callbackData?.startsWith("mdl:sr:") && !/r1|o1|o3|thinking/.test(b.callbackData)) ??
+          flat.find((b) => b.callbackData?.startsWith("mdl:sr:"));
 
         if (!srButton) {
           console.log("No sr-* buttons in menu — agent not LiteLLM-enabled or no sr-* models registered. Skipping.");
@@ -86,8 +91,10 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
         expect((kbAfter ?? []).flat().length, "menu keeps buttons after sr-* tap").toBeGreaterThan(0);
 
         // ── 3. Send a quick message to generate a LiteLLM-routed turn ──
+        // Use 120s — fast models (gemini-flash, deepseek-v3) respond in <10s,
+        // but the request still has to go through the model switch inject + proxy.
         await sc.sendDM("Just reply with the word OK.");
-        await sc.expectMessage(/ok/i, { from: "bot", timeout: 60_000 });
+        await sc.expectMessage(/ok/i, { from: "bot", timeout: 120_000 });
 
         // ── 4. LiteLLM spend attribution ────────────────────────────────
         if (spendBefore >= 0) {
@@ -97,14 +104,19 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
           expect(spendAfter, `agent:${AGENT} log_count increased after turn`).toBeGreaterThan(spendBefore);
         }
 
-        // ── Restore: switch back to configured model ────────────────────
+        // ── Restore: switch back to a Claude subscription model ─────────
+        // Re-fetch keyboard so we have the latest state after sr-* switch.
+        // Look for any Claude model (mdl:s:) button — those are Max/Pro
+        // subscription models and don't trigger slow reasoning. If graceful
+        // restart is implemented, pressing a claude button fires a restart
+        // (not a deepseek/gemini inject), so no secondary LiteLLM calls.
         const currentKb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
-        const restoreBtn = (currentKb ?? []).flat().find(
-          (b) => b.callbackData?.startsWith("mdl:s:") && /Default|Sonnet|claude-sonnet/i.test(b.text),
-        );
+        const restoreBtn = (currentKb ?? []).flat().find((b) => b.callbackData?.startsWith("mdl:s:"));
         if (restoreBtn?.callbackData) {
           await sc.driver.pressButton(sc.botUserId, menu.messageId, restoreBtn.callbackData);
-          await new Promise((r) => setTimeout(r, 4_000));
+          // Wait for the restart to complete (graceful restart PR #2619) or for
+          // the in-place inject to propagate — 15s is sufficient for either path.
+          await new Promise((r) => setTimeout(r, 15_000));
         }
 
         console.log(`✅ sr-* model switch (${srName}) verified end-to-end through LiteLLM`);
@@ -112,7 +124,7 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
         await sc.tearDown();
       }
     },
-    180_000,
+    210_000,
   );
 
   it(
@@ -121,9 +133,11 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
       const sc = await spinUp({ agent: AGENT });
       try {
         await sc.sendDM("/model");
+        // 60s — test 2 runs after test 1's restore restart, which takes ~15s.
+        // If the restart is still finishing when /model lands, it may be queued.
         const menu = await sc.expectMessage(/Default \(new sessions\):/i, {
           from: "bot",
-          timeout: 30_000,
+          timeout: 60_000,
         });
         const kb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
         const flat = (kb ?? []).flat();
@@ -142,6 +156,6 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
         await sc.tearDown();
       }
     },
-    60_000,
+    120_000,
   );
 });