switchroom 0.16.29 → 0.16.46

package/telegram-plugin/uat/driver.ts

@@ -72,6 +72,45 @@ export interface ObservedMessage {
    * must be silent, only the final answer should ping.
    */
   silent: boolean;
+  /**
+   * The rich-formatting entities Telegram actually attached to the
+   * rendered message (bold / italic / code / pre / text_link / …),
+   * normalized from mtcute's `Message.entities`. This is what the
+   * highest-fidelity UAT layer asserts on: not the markdown we SENT, but
+   * the entity structure Telegram PARSED and will render. Empty array for
+   * a plain-text message with no formatting.
+   *
+   * Empty (never undefined) when the message body could not be decoded to
+   * real text+entities (see `text === "\x01"` sentinel below).
+   */
+  entities: ObservedEntity[];
+  /**
+   * The `t.me/c/<internal_chat>/<msgid>` (or `t.me/<username>/<msgid>`)
+   * permalink to this message, for human eyeball reference in UAT output.
+   * `undefined` for chats that don't support message links (private DMs) —
+   * mtcute's `Message.link` getter throws there, so we swallow and leave it
+   * unset rather than fail the observation.
+   */
+  link?: string;
+}
+
+/**
+ * One rich-formatting entity as Telegram parsed it, flattened from
+ * mtcute's `MessageEntity` into the fields a UAT assertion cares about.
+ * `kind` is mtcute's entity kind (`bold`, `italic`, `code`, `pre`,
+ * `text_link`, `blockquote`, …); `text` is the exact inner substring the
+ * entity spans; `offset`/`length` are UTF-16 code-unit coordinates (the
+ * same units Telegram uses on the wire).
+ */
+export interface ObservedEntity {
+  kind: string;
+  offset: number;
+  length: number;
+  text: string;
+  /** Destination for `text_link` entities; undefined otherwise. */
+  url?: string;
+  /** Language info string for `pre` fenced blocks; undefined otherwise. */
+  language?: string;
 }
 
 export interface ObservedButton {
@@ -142,11 +181,21 @@ export class Driver {
     await this.client.connect();
     // `connect()` opens the transport but does NOT start the updates
     // dispatch loop — that's `start()`'s job. For a returning session
-    // (no interactive login) we have to call `startUpdatesLoop()`
-    // ourselves, otherwise `onNewMessage` / `onEditMessage` never
-    // fire and `observeMessages` silently waits forever. Symptom:
-    // `expectMessage` timing out even though the bot's reply has
-    // arrived in the chat (visible in Telegram).
+    // (no interactive login) we have to drive that lifecycle ourselves,
+    // otherwise `onNewMessage` / `onEditMessage` never fire and
+    // `observeMessages` silently waits forever. Symptom: `expectMessage`
+    // timing out even though the bot's reply has arrived in the chat
+    // (visible in Telegram).
+    //
+    // `notifyLoggedIn` is the lifecycle call `start()` makes from its
+    // login callback but a manually-imported session skips — it tells the
+    // updates manager the client is authorized (and seeds self into the
+    // peer cache). mtcute 0.30's own docs recommend calling it, or
+    // otherwise ensuring the user is logged in, before `startUpdatesLoop`.
+    // Resolve self from the imported session and notify BEFORE starting
+    // the loop, matching what `start()` does internally.
+    const me = await this.client.getMe();
+    await this.client.notifyLoggedIn(me.raw);
     await this.client.startUpdatesLoop();
   }
 
@@ -290,18 +339,30 @@ export class Driver {
       else queue.push(m);
     };
 
-    const onNew = (msg: Message): void => {
-      const observed = toObserved(msg, false);
-      if (observed.chatId !== chatId) return;
-      if (targetThread !== undefined && observed.threadId !== targetThread) return;
-      dispatch(observed);
-    };
-    const onEdit = (msg: Message): void => {
-      const observed = toObserved(msg, true);
+    // Defensive wrapper: a throw inside the listener propagates out of
+    // mtcute's `onNewMessage`/`onEditMessage` emitter (it does not catch
+    // listener errors) and drops the update entirely, so `observeMessages`
+    // would silently never yield it. `toObserved` is already hardened against
+    // the known `PeersIndex` throw, but any future getter that throws must
+    // NOT be allowed to swallow an observation — log and move on instead.
+    const dispatchObserved = (msg: Message, edited: boolean): void => {
+      let observed: ObservedMessage;
+      try {
+        observed = toObserved(msg, edited);
+      } catch (err) {
+        // eslint-disable-next-line no-console -- harness diagnostic
+        console.warn(
+          `[uat/driver] observeMessages: dropping unobservable message ` +
+          `(id=${msg.id}): ${err instanceof Error ? err.message : String(err)}`,
+        );
+        return;
+      }
       if (observed.chatId !== chatId) return;
       if (targetThread !== undefined && observed.threadId !== targetThread) return;
       dispatch(observed);
     };
+    const onNew = (msg: Message): void => dispatchObserved(msg, false);
+    const onEdit = (msg: Message): void => dispatchObserved(msg, true);
 
     c.onNewMessage.add(onNew);
     c.onEditMessage.add(onEdit);
@@ -838,15 +899,411 @@ export class Driver {
 }
 
 function toObserved(msg: Message, edited: boolean): ObservedMessage {
+  // Bot API 10.1 rich messages (`sendMessage` with `{ markdown }`) used to
+  // arrive as `messageMediaUnsupported` with an empty `message.message` on
+  // the pinned mtcute (0.27.x). With mtcute >=0.30 the message decodes to
+  // real text + entities, so we surface those directly. The
+  // `messageMediaUnsupported` sentinel path is KEPT as a defensive fallback:
+  // if a future Bot API / TL-layer change ever regresses the decode, the
+  // `\x01` sentinel still lets text-presence assertions fire (and the
+  // formatting scenario will flag the empty-entities case loudly rather than
+  // silently pass). It is no longer expected to trigger on the happy path.
+  const rawText = msg.text ?? "";
+  // Bot API 10.1 rich messages (`sendRichMessage({ markdown })`) arrive on the
+  // wire in a NEW TL field — `message.richMessage` — with the legacy `message`
+  // string left EMPTY and NO `entities`. mtcute 0.30 does not yet map that
+  // field onto `Message.text`/`Message.entities`, so `msg.text` is "" and the
+  // observation looks textless. This is the sibling case to the
+  // `messageMediaUnsupported` sentinel below: the visible text is on the wire,
+  // just in a shape the getter doesn't decode. Flatten the `richMessage`
+  // page-block/RichText tree ourselves into plain text + entities. (Confirmed
+  // via a raw-TL dump on the uat-host runner, #2744.)
+  const richDecoded =
+    rawText === "" && msg.raw._ === "message"
+      ? decodeRichMessage((msg.raw as { richMessage?: unknown }).richMessage)
+      : null;
+  const isRichMedia = rawText === "" && !richDecoded &&
+    msg.raw._ === "message" && msg.raw.media?._ === "messageMediaUnsupported";
+  // Resolve chat/sender ids from the RAW TL peer, not the `msg.chat` /
+  // `msg.sender` getters. Those getters look the peer up in the update's
+  // `PeersIndex` and THROW `MtArgumentError` ("peer not available in this
+  // index") when it's absent — which happens for the driver because it runs
+  // on `MemoryStorage` (empty peer cache each connect), so an incoming bot
+  // reply can arrive before that peer has been cached. An unguarded throw
+  // here propagates out of the mtcute `onNewMessage`/`onEditMessage` emitter
+  // (that emitter does not catch listener errors), so the WHOLE update is
+  // dropped and `observeMessages` never yields it — the exact "bot replied
+  // fast but `expectMessage` timed out" failure. `getMarkedPeerId` reads the
+  // raw TL peer directly and never touches the index, so it can't throw.
+  const chatId = getMarkedPeerId(msg.raw.peerId);
+  const rawFrom = msg.raw._ === "message" || msg.raw._ === "messageService"
+    ? msg.raw.fromId
+    : undefined;
+  const senderUserId = rawFrom
+    ? getMarkedPeerId(rawFrom)
+    : chatId; // no explicit sender ⇒ the DM peer is the sender (bot reply in a DM)
   return {
-    chatId: msg.chat.id,
+    chatId,
     messageId: msg.id,
     threadId: msg.replyToMessage?.threadId ?? undefined,
-    text: msg.text ?? "",
-    senderUserId: msg.sender.id,
-    fromBot: msg.sender.type === "user" && msg.sender.isBot === true,
+    text: isRichMedia ? "\x01" : (richDecoded ? richDecoded.text : rawText),
+    senderUserId,
+    fromBot: safeIsFromBot(msg),
     date: msg.date,
     edited,
     silent: msg.isSilent,
+    entities: isRichMedia
+      ? []
+      : (richDecoded ? richDecoded.entities : toObservedEntities(msg)),
+    link: safeMessageLink(msg),
+  };
+}
+
+/**
+ * Flatten mtcute's `Message.entities` into the `ObservedEntity[]` the UAT
+ * assertions consume. Pulls the entity `url` (text_link) and `language`
+ * (pre) out of the discriminated `params` union so scenarios can assert on
+ * link destinations and fenced-block languages, not just the span kind.
+ */
+function toObservedEntities(msg: Message): ObservedEntity[] {
+  // Real mtcute always populates `.entities` (empty array for unformatted
+  // text). Guard against a message shape that lacks it (e.g. a hand-rolled
+  // test double) so the observation degrades to "no entities" rather than
+  // throwing and taking down the whole scenario.
+  const entities = msg.entities ?? [];
+  return entities.map((e): ObservedEntity => {
+    const params = e.params;
+    return {
+      kind: e.kind,
+      offset: e.offset,
+      length: e.length,
+      text: e.text,
+      url: params.kind === "text_link" ? params.url : undefined,
+      language: params.kind === "pre" ? params.language : undefined,
+    };
+  });
+}
+
+/**
+ * Decode a Bot API 10.1 rich message (`message.richMessage`) into flat
+ * `{ text, entities }`, mirroring what `Message.text` + `Message.entities`
+ * would carry if mtcute mapped the field. Returns `null` when the value isn't
+ * a `richMessage` (so callers fall back to the legacy `message` string).
+ *
+ * On the wire a `richMessage` is Telegram's Instant-View page tree: a list of
+ * `pageBlock`s, each carrying a `RichText` node (or, for tables/lists,
+ * structured children). We model the block kinds Telegram's GFM parser
+ * actually emits for a chat rich message, all shapes grounded against
+ * `@mtcute/tl@223.0.0` (the TL layer mtcute 0.30 ships):
+ *
+ *   - `pageBlockParagraph`      — styled inline text (`.text: RichText`).
+ *   - `pageBlockPreformatted`   — fenced code → one `pre` entity spanning the
+ *                                 whole block, carrying `.language`.
+ *   - `pageBlockHeader` /       — a markdown heading (`# …` / `## …`) →
+ *     `pageBlockSubheader`        rendered as a `bold` entity over the line
+ *                                 (Telegram has no first-class heading entity;
+ *                                 GFM headings surface as bold on a phone).
+ *   - `pageBlockBlockquote` /   — `> …` quote → a `blockquote` entity over the
+ *     `pageBlockPullquote`        quote body (`.text`; `.caption` follows on a
+ *                                 newline, unstyled).
+ *   - `pageBlockList`           — unordered list; `.items: PageListItem[]`
+ *                                 (`pageListItemText.text: RichText` or
+ *                                 `pageListItemBlocks.blocks: PageBlock[]`),
+ *                                 each item rendered `• ` + inline content.
+ *   - `pageBlockOrderedList`    — ordered list; `.items: PageListOrderedItem[]`
+ *                                 (`…Text` / `…Blocks`) each carrying a `.num`
+ *                                 label rendered `<num>. ` + content.
+ *   - `pageBlockTable`          — `.title: RichText`, `.rows: PageTableRow[]`,
+ *                                 each `.cells: PageTableCell[]` with an
+ *                                 optional `.text: RichText` (+ `.header`).
+ *                                 Cells join with " | ", rows with newlines;
+ *                                 header cells emit a `bold` entity.
+ *   - `pageBlockDivider`        — a horizontal rule (`---`) → a literal "———"
+ *                                 line, no entity.
+ *
+ * NOTE (grounding): TL layer 223 has NO `textSpoiler` RichText kind. GFM
+ * spoiler syntax (`||…||`) surfaces on the IV wire as `textMarked`
+ * ("highlighted text") — so `textMarked` maps to the Bot API `spoiler`
+ * entity. `textStrike`/`textUnderline` ARE first-class RichText kinds and
+ * map to `strikethrough`/`underline` directly.
+ *
+ * Blocks are joined with a newline. The RichText tree is a
+ * discriminated union: leaf `textPlain` carries a string; `textConcat` holds a
+ * `texts[]` sequence; the styled wrappers (`textBold`/`textItalic`/`textFixed`/
+ * `textUrl`/…) nest another RichText in `.text`. We flatten depth-first,
+ * tracking UTF-16 code-unit offsets (JS string `.length` is already UTF-16, the
+ * same units Telegram uses on the wire) and emit an `ObservedEntity` for each
+ * styled span so the render-fidelity assertions see the same entity structure
+ * the legacy `entities` path produces.
+ */
+export function decodeRichMessage(
+  rich: unknown,
+): { text: string; entities: ObservedEntity[] } | null {
+  const rm = rich as
+    | { _?: string; blocks?: Array<Record<string, unknown>> }
+    | undefined;
+  if (!rm || rm._ !== "richMessage" || !Array.isArray(rm.blocks)) return null;
+
+  let text = "";
+  const entities: ObservedEntity[] = [];
+
+  const emit = (
+    kind: string,
+    start: number,
+    extra?: { url?: string; language?: string },
+  ): void => {
+    const length = text.length - start;
+    if (length <= 0) return;
+    entities.push({
+      kind,
+      offset: start,
+      length,
+      text: text.slice(start, start + length),
+      url: extra?.url,
+      language: extra?.language,
+    });
+  };
+
+  // Depth-first walk of a RichText node, appending plain text to `text` and
+  // pushing an entity for each styled wrapper (mapping TL kinds to mtcute's).
+  const walk = (node: unknown): void => {
+    const n = node as {
+      _?: string;
+      text?: unknown;
+      texts?: unknown[];
+      url?: string;
+    };
+    if (!n || typeof n._ !== "string") return;
+    switch (n._) {
+      case "textEmpty":
+        return;
+      case "textPlain":
+        if (typeof n.text === "string") text += n.text;
+        return;
+      case "textConcat":
+        for (const t of n.texts ?? []) walk(t);
+        return;
+      case "textBold": {
+        const s = text.length;
+        walk(n.text);
+        emit("bold", s);
+        return;
+      }
+      case "textItalic": {
+        const s = text.length;
+        walk(n.text);
+        emit("italic", s);
+        return;
+      }
+      case "textUnderline": {
+        const s = text.length;
+        walk(n.text);
+        emit("underline", s);
+        return;
+      }
+      case "textStrike": {
+        const s = text.length;
+        walk(n.text);
+        emit("strikethrough", s);
+        return;
+      }
+      case "textFixed": {
+        // Inline fixed-width (`code_token`) → Bot API `code` entity.
+        const s = text.length;
+        walk(n.text);
+        emit("code", s);
+        return;
+      }
+      case "textMarked": {
+        // TL layer 223 has no `textSpoiler`; GFM `||spoiler||` rides the
+        // IV "highlighted text" node (`textMarked`) → Bot API `spoiler`.
+        const s = text.length;
+        walk(n.text);
+        emit("spoiler", s);
+        return;
+      }
+      case "textUrl": {
+        const s = text.length;
+        walk(n.text);
+        emit("text_link", s, { url: n.url });
+        return;
+      }
+      case "textEmail": {
+        const s = text.length;
+        walk(n.text);
+        emit("email", s);
+        return;
+      }
+      default:
+        // Any other wrapper (marked/sub/superscript/phone/anchor/…) — keep its
+        // visible text but don't classify the span; the render assertions only
+        // key off the kinds the gateway emits.
+        if (n.text !== undefined) walk(n.text);
+        return;
+    }
   };
+
+  // Emit a span that Telegram has no first-class entity for (heading, table
+  // header) but which renders styled on a phone — we pick the closest Bot API
+  // entity so the render-fidelity assertions can key off it.
+  const emitOver = (kind: string, start: number): void => emit(kind, start);
+
+  // Walk one IV page-block, appending its text to `text` and pushing entities.
+  // Recursive: lists/tables nest paragraph-like children.
+  const walkBlock = (block: Record<string, unknown> | undefined): void => {
+    if (!block || typeof block._ !== "string") return;
+    switch (block._) {
+      case "pageBlockPreformatted": {
+        // Fenced code block → one `pre` entity spanning the whole block, with
+        // the language string Telegram tagged the fence with.
+        const s = text.length;
+        walk(block.text);
+        const length = text.length - s;
+        if (length > 0) {
+          entities.push({
+            kind: "pre",
+            offset: s,
+            length,
+            text: text.slice(s, s + length),
+            url: undefined,
+            language: (block.language as string) || undefined,
+          });
+        }
+        return;
+      }
+      case "pageBlockHeader":
+      case "pageBlockSubheader": {
+        // GFM heading (`#`/`##`) → no first-class Telegram heading entity;
+        // it renders bold on a phone, so we model it as a `bold` span.
+        const s = text.length;
+        walk(block.text);
+        emitOver("bold", s);
+        return;
+      }
+      case "pageBlockBlockquote":
+      case "pageBlockPullquote": {
+        // `> …` quote → `blockquote` entity over the quote body. `.caption`
+        // (if any) follows on its own line, unstyled.
+        const s = text.length;
+        walk(block.text);
+        emitOver("blockquote", s);
+        const caption = block.caption as Record<string, unknown> | undefined;
+        if (caption && caption._ && caption._ !== "textEmpty") {
+          text += "\n";
+          walk(caption);
+        }
+        return;
+      }
+      case "pageBlockList": {
+        // Unordered list. Items are pageListItemText (RichText) or
+        // pageListItemBlocks (nested page blocks); each gets a "• " bullet.
+        const items = (block.items as Array<Record<string, unknown>>) ?? [];
+        items.forEach((item, i) => {
+          if (i > 0) text += "\n";
+          text += "• ";
+          if (item._ === "pageListItemText") {
+            walk(item.text);
+          } else if (item._ === "pageListItemBlocks") {
+            const blocks = (item.blocks as Array<Record<string, unknown>>) ?? [];
+            blocks.forEach((b, j) => {
+              if (j > 0) text += "\n";
+              walkBlock(b);
+            });
+          }
+        });
+        return;
+      }
+      case "pageBlockOrderedList": {
+        // Ordered list. Items carry a `.num` label ("1", "2", …).
+        const items = (block.items as Array<Record<string, unknown>>) ?? [];
+        items.forEach((item, i) => {
+          if (i > 0) text += "\n";
+          text += `${(item.num as string) || String(i + 1)}. `;
+          if (item._ === "pageListOrderedItemText") {
+            walk(item.text);
+          } else if (item._ === "pageListOrderedItemBlocks") {
+            const blocks = (item.blocks as Array<Record<string, unknown>>) ?? [];
+            blocks.forEach((b, j) => {
+              if (j > 0) text += "\n";
+              walkBlock(b);
+            });
+          }
+        });
+        return;
+      }
+      case "pageBlockTable": {
+        // `.title` (optional) on its own line, then rows joined by newline,
+        // cells within a row joined by " | ". Header cells emit a `bold` span.
+        const title = block.title as Record<string, unknown> | undefined;
+        let wroteTitle = false;
+        if (title && title._ && title._ !== "textEmpty") {
+          walk(title);
+          wroteTitle = true;
+        }
+        const rows = (block.rows as Array<Record<string, unknown>>) ?? [];
+        rows.forEach((row, ri) => {
+          if (ri > 0 || wroteTitle) text += "\n";
+          const cells = (row.cells as Array<Record<string, unknown>>) ?? [];
+          cells.forEach((cell, ci) => {
+            if (ci > 0) text += " | ";
+            const s = text.length;
+            if (cell.text !== undefined) walk(cell.text);
+            if (cell.header) emitOver("bold", s);
+          });
+        });
+        return;
+      }
+      case "pageBlockDivider": {
+        // Horizontal rule (`---`). No entity; a literal rule line.
+        text += "———";
+        return;
+      }
+      default:
+        // pageBlockParagraph, footer, kicker, title, subtitle, and any other
+        // text-bearing block — inline walk of `.text`.
+        walk(block.text);
+        return;
+    }
+  };
+
+  for (const block of rm.blocks) {
+    if (text.length > 0) text += "\n"; // join blocks in send order
+    walkBlock(block);
+  }
+
+  return { text, entities };
+}
+
+/**
+ * `Message.link` throws (`MtArgumentError`) for chats that don't support
+ * message permalinks — notably private DMs, which is exactly where most
+ * UAT scenarios run. Swallow that and leave the field unset rather than
+ * blow up the whole observation; group/channel messages still get a real
+ * `t.me/c/<chat>/<msgid>` link for human eyeball reference.
+ */
+function safeMessageLink(msg: Message): string | undefined {
+  try {
+    return msg.link;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Whether the message was sent by a bot. Reads `msg.sender`, which resolves
+ * the peer via the update's `PeersIndex` and THROWS `MtArgumentError` when
+ * that peer isn't cached (the driver's `MemoryStorage` starts empty, so an
+ * incoming reply can arrive before its sender is cached). We only need
+ * `fromBot` for coarse classification, and `expectMessage`'s `from: "bot"`
+ * filter keys off `senderUserId` (resolved from the raw peer above), not this
+ * flag — so a swallowed lookup degrades to `false` rather than dropping the
+ * whole observation. Group/DM messages with a cached sender still classify
+ * correctly.
+ */
+function safeIsFromBot(msg: Message): boolean {
+  try {
+    return msg.sender.type === "user" && msg.sender.isBot === true;
+  } catch {
+    return false;
+  }
 }

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

@@ -49,16 +49,28 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
           timeout: 60_000,
         });
 
-        // ── 1. Section headers ──────────────────────────────────────────
+        // ── 1. Main page → External page navigation ────────────────────
+        // Nested-page design: the main page carries the Claude buttons + a
+        // "🌐 External models ▸" button; sr-* models and the billed-separately
+        // header live on the second page, reached by pressing mdl:page:ext.
+        const mainKb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
+        const mainFlat = (mainKb ?? []).flat().filter((b) => b.callbackData);
+        const extOpen = mainFlat.find((b) => b.callbackData === "mdl:page:ext");
+        expect(extOpen, "🌐 External models ▸ open button on the main page").toBeDefined();
+        expect(menu.text).toContain("Max/Pro subscription");
+
+        // Open the external page and re-read the keyboard.
+        await sc.driver.pressButton(sc.botUserId, menu.messageId, "mdl:page:ext");
+        await new Promise((r) => setTimeout(r, 2_000));
+        const extMsg = await sc.driver.getMessage(sc.botUserId, menu.messageId);
+        expect(extMsg?.text ?? "", "external page body").toContain("billed separately");
         const kb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
         const flat = (kb ?? []).flat().filter((b) => b.callbackData);
 
-        const claudeHeader = flat.find(
-          (b) => b.text.includes("Claude") && b.text.includes("subscription") && b.callbackData === "mdl:h",
-        );
-        const openrouterHeader = flat.find(
-          (b) => b.text.includes("OpenRouter") && b.callbackData === "mdl:h",
+        const externalHeader = flat.find(
+          (b) => b.text.includes("External") && b.callbackData === "mdl:h",
         );
+        const backButton = flat.find((b) => b.callbackData === "mdl:page:main");
         // Prefer deepseek-v3 (non-thinking, consistently fast) for the E2E test.
         // gemini-2.5-flash may run in thinking mode via OpenRouter (5+ min latency),
         // reasoning models (deepseek-r1, o1, o3) also take 2-5 min and hit the
@@ -70,14 +82,12 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
           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.");
+          console.log("No sr-* buttons on the external page — agent not LiteLLM-enabled or no sr-* models registered. Skipping.");
           return;
         }
 
-        expect(claudeHeader, "Claude (Max / Pro subscription) header row").toBeDefined();
-        expect(openrouterHeader, "OpenRouter / external header row").toBeDefined();
-        expect(menu.text).toContain("Max/Pro subscription");
-        expect(menu.text).toContain("OpenRouter");
+        expect(externalHeader, "External (billed separately) header row").toBeDefined();
+        expect(backButton, "◂ Back button on the external page").toBeDefined();
 
         // ── 2. sr-* switch ─────────────────────────────────────────────
         const spendBefore = await getLiteLLMSpendForAgent(AGENT);
@@ -146,15 +156,25 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
           from: "bot",
           timeout: 90_000,
         });
+        // The header row now lives on the external page — navigate there first.
+        const mainKb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
+        const extOpen = (mainKb ?? []).flat().find((b) => b.callbackData === "mdl:page:ext");
+        if (!extOpen) {
+          console.log("No External page — agent not LiteLLM-enabled. Skipping.");
+          return;
+        }
+        await sc.driver.pressButton(sc.botUserId, menu.messageId, "mdl:page:ext");
+        await new Promise((r) => setTimeout(r, 2_000));
+        const extMsg = await sc.driver.getMessage(sc.botUserId, menu.messageId);
         const kb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
         const flat = (kb ?? []).flat();
         const headerBtn = flat.find((b) => b.callbackData === "mdl:h");
         if (!headerBtn) {
-          console.log("No header row — agent not LiteLLM-enabled. Skipping.");
+          console.log("No header row on external page — agent not LiteLLM-enabled. Skipping.");
           return;
         }
-        // Pressing the header should NOT change the menu text
-        const textBefore = menu.text;
+        // Pressing the header should NOT change the (external-page) menu text
+        const textBefore = extMsg?.text ?? "";
         await sc.driver.pressButton(sc.botUserId, menu.messageId, "mdl:h");
         await new Promise((r) => setTimeout(r, 3_000));
         const after = await sc.driver.getMessage(sc.botUserId, menu.messageId);