switchroom 0.16.4 → 0.16.5

package/telegram-plugin/gateway/gateway.ts

@@ -3317,6 +3317,23 @@ function releaseTurnBufferGate(key: string, endingTurn?: CurrentTurn): void {
  * Idempotent: a second purge is a no-op `.delete()` on a key already
  * gone — handlers that already purge elsewhere are unharmed.
  */
+function emitTurnRecord(turn: CurrentTurn, endedAt: number): void {
+  try {
+    const rec =
+      JSON.stringify({
+        ts: Math.floor(endedAt / 1000),
+        agent: process.env.SWITCHROOM_AGENT_NAME ?? 'unknown',
+        duration_ms: turn.startedAt > 0 ? endedAt - turn.startedAt : 0,
+        tools: turn.toolCallCount ?? 0,
+        status: turn.finalAnswerDelivered ? 'complete' : 'no_reply',
+        turn_id: turn.turnId,
+      }) + '\n'
+    appendFileSync('/state/agent/turns.jsonl', rec)
+  } catch {
+    // best-effort — never let metrics emission break turn teardown
+  }
+}
+
 function endCurrentTurnAtomic(turn: CurrentTurn): void {
   // PR-4e — keyed liveness + keyed clear (leak-close-at-origin). Flag-OFF: the
   // guard is `currentTurn === turn` and the clear nulls the singleton, verbatim.
@@ -3331,9 +3348,11 @@ function endCurrentTurnAtomic(turn: CurrentTurn): void {
   // Status-surface observability: one line at every turn CLEAR (with how far
   // the turn got), plus a DEGRADED warning when the turn did tool work but the
   // live feed never opened because its sends failed (the resume-400 signature).
+  const turnEndedAt = Date.now()
   process.stderr.write(
-    `telegram gateway: ${formatTurnLifecycle('clear', 'turn_end', turn, Date.now())}\n`,
+    `telegram gateway: ${formatTurnLifecycle('clear', 'turn_end', turn, turnEndedAt)}\n`,
   )
+  emitTurnRecord(turn, turnEndedAt)
   const degraded = detectStatusSurfaceDegraded(turn)
   if (degraded != null) {
     process.stderr.write(

package/telegram-plugin/gateway/model-command.ts

@@ -233,6 +233,53 @@ export interface ModelMenuReply {
 export const MODEL_CALLBACK_PREFIX = 'mdl:'
 const MODEL_CALLBACK_SELECT = 'mdl:s:'
 export const MODEL_CALLBACK_REFRESH = 'mdl:r'
+/** Callback prefix for sr-* (LiteLLM non-Anthropic) model selection. */
+export const MODEL_CALLBACK_SR = 'mdl:sr:'
+
+/**
+ * Friendly display names for sr-* synthetic model names. An sr-* model in
+ * LiteLLM has no entry in `model_group_settings.*.forward_client_headers_to_llm_api`
+ * so the Anthropic OAuth credential is NEVER forwarded — safe to route to
+ * OpenRouter. Names here are display-only; the raw `sr-*` id is what gets
+ * injected into the agent's session. See reference/rfcs/litellm-max-subscription-invariants.md § I6.
+ */
+export const SR_MODEL_LABELS: Record<string, string> = {
+  'sr-gemini-2.5-pro': 'Gemini 2.5 Pro',
+  'sr-gemini-2.5-flash': 'Gemini 2.5 Flash',
+  'sr-deepseek-r1': 'DeepSeek R1',
+  'sr-deepseek-v3': 'DeepSeek V3',
+  'sr-glm-5': 'GLM-5',
+}
+
+function srFriendlyLabel(srName: string): string {
+  return SR_MODEL_LABELS[srName] ?? srName.replace(/^sr-/, '').replace(/-/g, ' ')
+}
+
+/**
+ * Split picker-discovered options into native Claude options and sr-*
+ * (LiteLLM non-Anthropic) options. Options with "/" in the label or
+ * other non-native prefixes (e.g., "openrouter/...", "gpt-4") are
+ * silently dropped — they're internal LiteLLM routing paths, not
+ * user-facing switching targets.
+ */
+export function classifyDiscoveredOptions(options: ModelPickerOption[]): {
+  claude: ModelPickerOption[]
+  sr: ModelPickerOption[]
+} {
+  return {
+    // Native Claude picker labels start with an uppercase letter (e.g.
+    // "Default (recommended)", "Opus", "Sonnet") or with "claude-" for full
+    // model IDs. This excludes sr-* names, internal routing paths
+    // ("openrouter/..."), and non-Claude models exposed by GATEWAY_MODEL_DISCOVERY
+    // ("gpt-4", "gpt-4o", "voyage-law-2", etc.) — those are LiteLLM internals
+    // not meant as user-facing switching targets.
+    claude: options.filter(
+      (o) => !o.label.startsWith('sr-') && !o.label.includes('/') &&
+        (/^[A-Z]/.test(o.label) || o.label.startsWith('claude-')),
+    ),
+    sr: options.filter((o) => o.label.startsWith('sr-')),
+  }
+}
 
 export function modelSelectCallbackData(label: string): string {
   // Identity is the label's hash, not its index — a tap re-discovers
@@ -249,15 +296,29 @@ function busyReply(deps: Pick<ModelMenuDeps, 'escapeHtml'>): ModelMenuReply {
   }
 }
 
-function menuKeyboard(options: ModelPickerOption[]): ModelMenuKeyboardButton[][] {
+function menuKeyboard(
+  claudeOptions: ModelPickerOption[],
+  srOptions: ModelPickerOption[],
+): ModelMenuKeyboardButton[][] {
   // One option per row (labels + ✔ render cleanly at full width on
   // mobile), refresh on a trailing row.
-  const rows: ModelMenuKeyboardButton[][] = options.map((o) => [
+  const rows: ModelMenuKeyboardButton[][] = claudeOptions.map((o) => [
     {
       text: o.current ? `✅ ${o.label}` : o.label,
       callback_data: modelSelectCallbackData(o.label),
     },
   ])
+  // sr-* models are non-Anthropic (routed via LiteLLM → OpenRouter).
+  // Selection uses text-inject rather than cursor-nav — more reliable
+  // when the picker has many models (GATEWAY_MODEL_DISCOVERY=1).
+  for (const o of srOptions) {
+    rows.push([
+      {
+        text: `🌐 ${srFriendlyLabel(o.label)}`,
+        callback_data: `${MODEL_CALLBACK_SR}${o.label}`,
+      },
+    ])
+  }
   rows.push([{ text: '🔄 Refresh', callback_data: MODEL_CALLBACK_REFRESH }])
   return rows
 }
@@ -292,7 +353,8 @@ export async function buildModelMenu(
   // or a prior session switch). Labelling the ✔ row "Now:" was misleading —
   // it could read "Opus 4.8" while the live session is on Fable. Call it what
   // it is, and tell the operator a switch applies to the live session.
-  const current = discovered.options.find((o) => o.current)
+  const { claude: claudeOptions, sr: srOptions } = classifyDiscoveredOptions(discovered.options)
+  const current = claudeOptions.find((o) => o.current)
   const lines: string[] = [`<b>Model — ${deps.escapeHtml(deps.getAgentName())}</b>`]
   if (discovered.dismissFailed) {
     lines.push('⚠️ <i>The picker may still be open on the agent pane — check it before switching.</i>')
@@ -305,9 +367,10 @@ export async function buildModelMenu(
   }
   if (quota) lines.push(`Quota: ${deps.escapeHtml(quota)}`)
   lines.push('', 'Tap a model to switch the <b>live session</b>:')
+  if (srOptions.length > 0) lines.push('🌐 = non-Anthropic via LiteLLM (session only)')
   lines.push(PERSIST_NOTE)
 
-  return { text: lines.join('\n'), html: true, keyboard: menuKeyboard(discovered.options) }
+  return { text: lines.join('\n'), html: true, keyboard: menuKeyboard(claudeOptions, srOptions) }
 }
 
 export interface ModelCallbackOutcome {
@@ -346,6 +409,54 @@ export async function handleModelMenuCallback(
   if (data === MODEL_CALLBACK_REFRESH) {
     return { answer: 'Refreshed', reply: await buildModelMenu(deps) }
   }
+
+  // sr-* model tap: text-inject `/model sr-<name>` rather than cursor-nav.
+  // Text-inject is more reliable when the picker has many models; sr-* names
+  // are safe (no entry in model_group_settings → no OAuth forwarding). See I6.
+  if (data.startsWith(MODEL_CALLBACK_SR)) {
+    const srName = data.slice(MODEL_CALLBACK_SR.length)
+    if (!isValidModelArg(srName)) {
+      return { answer: 'Invalid model name', reply: await buildModelMenu(deps) }
+    }
+    if (deps.isBusy()) {
+      return {
+        answer: '⏳ Agent is mid-turn — tap again when it’s idle',
+        reply: busyReply(deps),
+        toastOnly: true,
+      }
+    }
+    let srResult: InjectResult
+    try {
+      srResult = await deps.inject(deps.getAgentName(), `/model ${srName}`)
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      return {
+        answer: 'Switch failed',
+        reply: await menuWithBanner(deps, `❌ Switch to <b>${deps.escapeHtml(srName)}</b> failed: ${deps.escapeHtml(msg)}`),
+      }
+    }
+    if (srResult.outcome === 'ok') {
+      const friendlyName = srFriendlyLabel(srName)
+      const confirmation =
+        srResult.output
+          .split('\n')
+          .map((l) => l.trim())
+          .find((l) => /set model|switched/i.test(l)) ?? `Switched to ${friendlyName} (session)`
+      return {
+        answer: confirmation,
+        reply: await menuWithBanner(deps, `✅ ${deps.escapeHtml(confirmation)}`),
+        selectedModel: srName,
+      }
+    }
+    return {
+      answer: 'Switch failed',
+      reply: await menuWithBanner(
+        deps,
+        `❌ Switch to <b>${deps.escapeHtml(srFriendlyLabel(srName))}</b> failed — agent may be mid-turn`,
+      ),
+    }
+  }
+
   if (!data.startsWith(MODEL_CALLBACK_SELECT)) {
     return { answer: 'Unknown action', reply: await buildModelMenu(deps) }
   }

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

@@ -253,7 +253,10 @@ import {
   handleModelMenuCallback,
   modelSelectCallbackData,
   sessionModelFromConfirmation,
+  classifyDiscoveredOptions,
   MODEL_CALLBACK_REFRESH,
+  MODEL_CALLBACK_SR,
+  SR_MODEL_LABELS,
   type ModelMenuDeps,
 } from "../gateway/model-command.js";
 import { labelTag } from "../../src/agents/model-picker.js";
@@ -422,3 +425,134 @@ describe("sessionModelFromConfirmation", () => {
     expect(out.reply.keyboard).toBeDefined();
   });
 });
+
+// ---------------------------------------------------------------------------
+// Ship D — sr-* (LiteLLM non-Anthropic) model support
+// ---------------------------------------------------------------------------
+
+const OPTIONS_WITH_SR = [
+  { index: 1, label: "Default (recommended)", detail: "Opus 4.8 with 1M context", current: false },
+  { index: 2, label: "Sonnet", detail: "Sonnet 4.6", current: true },
+  { index: 3, label: "sr-gemini-2.5-pro", detail: "", current: false },
+  { index: 4, label: "sr-deepseek-r1", detail: "", current: false },
+  // internal path — should be filtered out
+  { index: 5, label: "openrouter/google/gemini-2.5-pro", detail: "", current: false },
+  // bare OpenAI models from GATEWAY_MODEL_DISCOVERY — should also be filtered out
+  { index: 6, label: "gpt-4", detail: "", current: false },
+  { index: 7, label: "gpt-4o", detail: "", current: false },
+  { index: 8, label: "voyage-law-2", detail: "", current: false },
+  // full claude ID — should be in claude bucket
+  { index: 9, label: "claude-opus-4-8", detail: "", current: false },
+];
+
+describe("classifyDiscoveredOptions", () => {
+  it("puts native Claude options in claude, sr-* in sr, drops others", () => {
+    const { claude, sr } = classifyDiscoveredOptions(OPTIONS_WITH_SR);
+    expect(claude.map((o) => o.label)).toEqual([
+      "Default (recommended)", "Sonnet", "claude-opus-4-8",
+    ]);
+    expect(sr.map((o) => o.label)).toEqual(["sr-gemini-2.5-pro", "sr-deepseek-r1"]);
+    // openrouter/*, gpt-*, voyage-* not present in either bucket
+    const all = [...claude, ...sr];
+    expect(all.find((o) => o.label.includes("openrouter"))).toBeUndefined();
+    expect(all.find((o) => o.label.startsWith("gpt-"))).toBeUndefined();
+    expect(all.find((o) => o.label.startsWith("voyage-"))).toBeUndefined();
+  });
+
+  it("handles a list with no sr-* models", () => {
+    const { claude, sr } = classifyDiscoveredOptions(OPTIONS);
+    expect(claude).toHaveLength(3);
+    expect(sr).toHaveLength(0);
+  });
+});
+
+describe("SR_MODEL_LABELS", () => {
+  it("has friendly names for the standard sr-* models", () => {
+    expect(SR_MODEL_LABELS["sr-gemini-2.5-pro"]).toBe("Gemini 2.5 Pro");
+    expect(SR_MODEL_LABELS["sr-deepseek-r1"]).toBe("DeepSeek R1");
+  });
+});
+
+describe("buildModelMenu — with sr-* models", () => {
+  function makeMenuDepsWithSr(overrides: Partial<ModelMenuDeps> = {}) {
+    return makeMenuDeps({
+      discover: async () => ({
+        ok: true as const,
+        options: OPTIONS_WITH_SR,
+        currentLabel: "Sonnet",
+      }),
+      ...overrides,
+    });
+  }
+
+  it("shows 🌐 buttons for sr-* models, normal buttons for claude models", async () => {
+    const { deps } = makeMenuDepsWithSr();
+    const menu = await buildModelMenu(deps);
+    expect(menu.keyboard).toBeDefined();
+    const allButtons = menu.keyboard!.flat();
+    // 🌐 buttons for sr-*
+    expect(allButtons.find((b) => b.text === "🌐 Gemini 2.5 Pro")).toBeDefined();
+    expect(allButtons.find((b) => b.text === "🌐 DeepSeek R1")).toBeDefined();
+    // Regular buttons for Claude models
+    expect(allButtons.find((b) => b.text === "Default (recommended)")).toBeDefined();
+    // openrouter/* not shown at all
+    expect(allButtons.find((b) => b.text.includes("openrouter"))).toBeUndefined();
+  });
+
+  it("sr-* buttons use mdl:sr: callback prefix", async () => {
+    const { deps } = makeMenuDepsWithSr();
+    const menu = await buildModelMenu(deps);
+    const srButton = menu.keyboard!.flat().find((b) => b.text === "🌐 Gemini 2.5 Pro");
+    expect(srButton?.callback_data).toBe(`${MODEL_CALLBACK_SR}sr-gemini-2.5-pro`);
+  });
+
+  it("shows 🌐 = non-Anthropic legend when sr-* models are present", async () => {
+    const { deps } = makeMenuDepsWithSr();
+    const menu = await buildModelMenu(deps);
+    expect(menu.text).toContain("🌐 = non-Anthropic");
+  });
+
+  it("no legend when no sr-* models in picker", async () => {
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps);
+    expect(menu.text).not.toContain("🌐 = non-Anthropic");
+  });
+});
+
+describe("handleModelMenuCallback — sr-* selection", () => {
+  function makeMenuDepsWithSr(overrides: Partial<ModelMenuDeps> = {}) {
+    return makeMenuDeps({
+      discover: async () => ({
+        ok: true as const,
+        options: OPTIONS_WITH_SR,
+        currentLabel: "Sonnet",
+      }),
+      ...overrides,
+    });
+  }
+
+  it("sr-* tap uses inject path, not cursor nav", async () => {
+    const { deps, calls, injectCalls } = makeMenuDepsWithSr();
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_SR}sr-gemini-2.5-pro`, deps);
+    // inject was called with the raw /model command
+    expect(injectCalls).toContainEqual({ agent: "klanker", command: "/model sr-gemini-2.5-pro" });
+    // select (cursor nav) was NOT called
+    expect(calls.select).toHaveLength(0);
+    expect(out.answer).toContain("Set model to sonnet");
+    expect(out.selectedModel).toBe("sr-gemini-2.5-pro");
+    expect(out.reply.keyboard).toBeDefined();
+  });
+
+  it("sr-* tap while busy returns toast-only with no inject", async () => {
+    const { deps, injectCalls } = makeMenuDepsWithSr({ isBusy: () => true });
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_SR}sr-gemini-2.5-pro`, deps);
+    expect(out.toastOnly).toBe(true);
+    expect(injectCalls).toHaveLength(0);
+  });
+
+  it("rejects malformed sr-* callback data", async () => {
+    const { deps } = makeMenuDepsWithSr();
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_SR}bad name with spaces`, deps);
+    expect(out.answer).toBe("Invalid model name");
+  });
+});