switchroom 0.16.23 → 0.16.24

package/telegram-plugin/tests/streaming-e2e.test.ts

@@ -72,10 +72,9 @@ function setup(opts: { progressCardActive?: boolean } = {}): Fixture {
     ? { activeDraftStreams: map, suppressPtyPreview: suppress }
     : { activeDraftStreams: map }
 
-  const pty = createPtyPartialHandler(ptyState, {
-    bot,
-    renderText: (t) => `<i>${t}</i>`, // PTY preview: italic
-  })
+  // #2669: PTY previews are raw terminal output sent LITERALLY (plain
+  // sendMessage). The handler no longer takes a renderText.
+  const pty = createPtyPartialHandler(ptyState, { bot })
 
   const callStreamReply = (args: {
     chat_id: string
@@ -85,13 +84,13 @@ function setup(opts: { progressCardActive?: boolean } = {}): Fixture {
   }) =>
     handleStreamReply(args, srState, {
       bot,
-      markdownToHtml: (t) => `<b>${t}</b>`, // stream_reply: bold
-      escapeMarkdownV2: (t) => t,
       repairEscapedWhitespace: (t) => t,
       assertAllowedChat: () => {},
       resolveThreadId: () => undefined,
       disableLinkPreview: true,
-      defaultFormat: 'html',
+      // Anything other than the literal 'text' is the rich-markdown path —
+      // stream_reply ships the RAW markdown via sendRichMessage (#2669).
+      defaultFormat: 'markdown',
       logStreamingEvent: () => {},
       historyEnabled: false,
       recordOutbound: () => {},
@@ -129,12 +128,14 @@ describe('streaming e2e smoke', () => {
     f.pty.onPartial('drafting…')
     await microtaskFlush()
 
+    // PTY preview → literal plain sendMessage with the raw terminal text.
     expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
     expect(f.bot.api.sendMessage.mock.calls[0][0]).toBe('42')
-    expect(f.bot.api.sendMessage.mock.calls[0][1]).toBe('<i>drafting…</i>')
+    expect(f.bot.api.sendMessage.mock.calls[0][1]).toBe('drafting…')
 
-    // Model calls stream_reply with canonical text. Throttle window not
-    // open yet, so drive timers before awaiting.
+    // Model calls stream_reply with canonical text. It REUSES the PTY-created
+    // (literalText) stream for this chat+thread, so the edit also takes the
+    // literal path (plain string, not a rich { markdown } wrapper).
     vi.advanceTimersByTime(1000)
     await microtaskFlush()
     const p1 = f.fireStreamReply({ chat_id: '42', text: 'final answer' })
@@ -145,7 +146,7 @@ describe('streaming e2e smoke', () => {
     expect(r1.messageId).toBe(500)
     expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
     expect(f.bot.api.editMessageText).toHaveBeenCalledTimes(1)
-    expect(f.bot.api.editMessageText.mock.calls[0][2]).toBe('<b>final answer</b>')
+    expect(f.bot.api.editMessageText.mock.calls[0][2]).toBe('final answer')
 
     // done=true with same text → stream.finalize() resolves immediately
     // (pendingText is null since the edit already landed).
@@ -185,7 +186,8 @@ describe('streaming e2e smoke', () => {
     await microtaskFlush()
     await pdone
 
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    // No PTY partial fired → stream_reply created a fresh RICH stream.
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
     const editIds = f.bot.api.editMessageText.mock.calls.map(c => c[1])
     expect(new Set(editIds).size).toBe(1)
     expect(f.map.has('1:_')).toBe(false)
@@ -203,7 +205,7 @@ describe('streaming e2e smoke', () => {
     await microtaskFlush()
 
     expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
-    expect(f.bot.api.sendMessage.mock.calls[0][1]).toBe('<i>early text</i>')
+    expect(f.bot.api.sendMessage.mock.calls[0][1]).toBe('early text')
     expect(f.ptyState.pendingPtyPartial).toBeNull()
   })
 
@@ -214,15 +216,18 @@ describe('streaming e2e smoke', () => {
     const p1 = f.fireStreamReply({ chat_id: '1', text: 'stream_reply first' })
     await microtaskFlush()
     await p1
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    // stream_reply created a fresh RICH stream (no PTY partial preceded it).
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
 
     vi.advanceTimersByTime(1000)
     await microtaskFlush()
     const action = f.pty.onPartial('stream_reply first — more')
     await microtaskFlush()
 
+    // The PTY partial reuses the existing stream → an edit, not a new send.
     expect(action).toBe('update-existing')
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
+    expect(f.bot.api.sendMessage).not.toHaveBeenCalled()
     expect(f.bot.api.editMessageText).toHaveBeenCalledTimes(1)
     expect(f.map.size).toBe(1)
   })
@@ -240,8 +245,8 @@ describe('streaming e2e smoke', () => {
     await microtaskFlush()
     await pB
 
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(2)
-    const chats = f.bot.api.sendMessage.mock.calls.map(c => c[0]).sort()
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(2)
+    const chats = f.bot.api.sendRichMessage.mock.calls.map(c => c[0]).sort()
     expect(chats).toEqual(['A', 'B'])
 
     vi.advanceTimersByTime(1000)
@@ -278,8 +283,8 @@ describe('streaming e2e smoke', () => {
     const r = await pending
 
     expect(r.status).toBe('updated')
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
-    expect(f.bot.api.sendMessage.mock.calls[0][1]).toBe('<b>looking into this…</b>')
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
+    expect(f.bot.api.sendRichMessage.mock.calls[0][1]).toEqual({ markdown: 'looking into this…' })
     // PTY slot is claimed because the model is now the answer-lane
     // surface owner — late PTY partials defer to the model's stream
     // rather than racing it. (Same suppression pattern as before;
@@ -296,9 +301,9 @@ describe('streaming e2e smoke', () => {
     const r = await pdone
 
     expect(r.status).toBe('finalized')
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
-    expect(f.bot.api.sendMessage.mock.calls[0][0]).toBe('1')
-    expect(f.bot.api.sendMessage.mock.calls[0][1]).toBe('<b>THE ANSWER</b>')
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
+    expect(f.bot.api.sendRichMessage.mock.calls[0][0]).toBe('1')
+    expect(f.bot.api.sendRichMessage.mock.calls[0][1]).toEqual({ markdown: 'THE ANSWER' })
     expect(f.map.has('1:_')).toBe(false)
   })
 
@@ -310,8 +315,8 @@ describe('streaming e2e smoke', () => {
     await microtaskFlush()
     await p1
 
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
-    expect(f.bot.api.sendMessage.mock.calls[0][1]).toBe('<b>thinking…</b>')
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
+    expect(f.bot.api.sendRichMessage.mock.calls[0][1]).toEqual({ markdown: 'thinking…' })
 
     vi.advanceTimersByTime(1000)
     await microtaskFlush()
@@ -320,7 +325,7 @@ describe('streaming e2e smoke', () => {
     await pdone
 
     // First call sent the message; second call edits it (no second send).
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
     expect(f.bot.api.editMessageText).toHaveBeenCalled()
   })
 
@@ -340,8 +345,8 @@ describe('streaming e2e smoke', () => {
     const r = await p
 
     expect(r.status).toBe('updated')
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
-    expect(f.bot.api.sendMessage.mock.calls[0][1]).toBe('<b>Plan → Run → Done</b>')
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
+    expect(f.bot.api.sendRichMessage.mock.calls[0][1]).toEqual({ markdown: 'Plan → Run → Done' })
     expect(f.map.has('1:_:progress')).toBe(true)
   })
 
@@ -353,8 +358,8 @@ describe('streaming e2e smoke', () => {
     await microtaskFlush()
     await p1
 
-    expect(f.bot.api.sendMessage).toHaveBeenCalledTimes(1)
-    expect(f.bot.api.sendMessage.mock.calls[0][1]).toBe('<b>chunk 1</b>')
+    expect(f.bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
+    expect(f.bot.api.sendRichMessage.mock.calls[0][1]).toEqual({ markdown: 'chunk 1' })
 
     vi.advanceTimersByTime(1000)
     await microtaskFlush()
@@ -381,7 +386,7 @@ describe('streaming e2e smoke', () => {
     await pdone
 
     const lastEdit = f.bot.api.editMessageText.mock.calls.at(-1)
-    expect(lastEdit?.[2]).toBe('<b>THE ACTUAL ANSWER</b>')
+    expect(lastEdit?.[2]).toEqual({ markdown: 'THE ACTUAL ANSWER' })
     expect(f.map.has('1:_')).toBe(false)
   })
 })

package/telegram-plugin/tests/streaming-orchestration.test.ts

@@ -37,7 +37,8 @@ function modelStreamReply(params: {
   text: string
   done?: boolean
   throttleMs?: number
-  parseMode?: 'HTML' | 'MarkdownV2'
+  /** Literal plain-text stream (no rich-markdown parser). Default: rich. */
+  literalText?: boolean
 }): { stream: DraftStreamHandle; settled: Promise<void> } {
   const key = streamKey(params.chatId, params.threadId)
   let stream = params.map.get(key)
@@ -46,7 +47,7 @@ function modelStreamReply(params: {
       bot: params.bot,
       chatId: params.chatId,
       threadId: params.threadId,
-      parseMode: params.parseMode,
+      literalText: params.literalText,
       throttleMs: params.throttleMs ?? 600,
     })
     params.map.set(key, stream)
@@ -79,7 +80,7 @@ describe('streaming orchestration — activeDraftStreams map', () => {
 
     expect(a).toBe(b)
     expect(map.size).toBe(1)
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
     expect(bot.api.editMessageText).toHaveBeenCalledTimes(1)
   })
 
@@ -96,7 +97,7 @@ describe('streaming orchestration — activeDraftStreams map', () => {
     await microtaskFlush()
 
     expect(first).not.toBe(second)
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(2)
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(2)
     expect(second.getMessageId()).toBe(501)
   })
 
@@ -108,8 +109,8 @@ describe('streaming orchestration — activeDraftStreams map', () => {
     await microtaskFlush()
 
     expect(map.size).toBe(2)
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(2)
-    const chatIds = bot.api.sendMessage.mock.calls.map(c => c[0]).sort()
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(2)
+    const chatIds = bot.api.sendRichMessage.mock.calls.map(c => c[0]).sort()
     expect(chatIds).toEqual(['1', '2'])
   })
 
@@ -121,32 +122,32 @@ describe('streaming orchestration — activeDraftStreams map', () => {
     await microtaskFlush()
 
     expect(map.size).toBe(2)
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(2)
-    const threads = bot.api.sendMessage.mock.calls.map(c => c[2]?.message_thread_id).sort()
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(2)
+    const threads = bot.api.sendRichMessage.mock.calls.map(c => c[2]?.message_thread_id).sort()
     expect(threads).toEqual([10, 20])
   })
 
   it('pty preview → stream_reply handoff: second call edits the PTY message in place', async () => {
     const map = new Map<string, DraftStreamHandle>()
 
-    const ptyStream = createStreamController({ bot, chatId: '1', parseMode: 'HTML', throttleMs: 600 })
+    const ptyStream = createStreamController({ bot, chatId: '1', throttleMs: 600 })
     map.set('1:_', ptyStream)
-    void ptyStream.update('<i>drafting…</i>')
+    void ptyStream.update('_drafting…_')
     await microtaskFlush()
 
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
     const previewId = ptyStream.getMessageId()
     expect(previewId).toBe(500)
 
     vi.advanceTimersByTime(600)
     await microtaskFlush()
     const { settled } = modelStreamReply({
-      bot, map, chatId: '1', parseMode: 'HTML', text: 'final answer', done: true,
+      bot, map, chatId: '1', text: 'final answer', done: true,
     })
     await microtaskFlush()
     await settled
 
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
     expect(bot.api.editMessageText).toHaveBeenCalled()
     expect(bot.api.editMessageText.mock.calls[0][1]).toBe(previewId)
     expect(map.has('1:_')).toBe(false)
@@ -165,10 +166,10 @@ describe('streaming orchestration — activeDraftStreams map', () => {
     }
     await microtaskFlush()
 
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1)
-    expect(bot.api.sendMessage.mock.calls[0][1]).toBe('one')
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
+    expect((bot.api.sendRichMessage.mock.calls[0][1] as { markdown: string }).markdown).toBe('one')
     expect(bot.api.editMessageText).toHaveBeenCalledTimes(1)
-    expect(bot.api.editMessageText.mock.calls[0][2]).toBe('four')
+    expect((bot.api.editMessageText.mock.calls[0][2] as { markdown: string }).markdown).toBe('four')
 
     // No further work scheduled; advancing timers should be a no-op.
     vi.advanceTimersByTime(5000)
@@ -188,7 +189,7 @@ describe('streaming orchestration — activeDraftStreams map', () => {
     await settled
 
     expect(bot.api.editMessageText).toHaveBeenCalledTimes(1)
-    expect(bot.api.editMessageText.mock.calls[0][2]).toBe('final answer')
+    expect((bot.api.editMessageText.mock.calls[0][2] as { markdown: string }).markdown).toBe('final answer')
     expect(map.size).toBe(0)
   })
 
@@ -197,7 +198,7 @@ describe('streaming orchestration — activeDraftStreams map', () => {
     // messageId=null. A subsequent update() triggers a fresh send on the
     // same stream object — this is what makes a momentary network blip
     // recoverable without the caller needing to evict-and-recreate.
-    bot.api.sendMessage
+    bot.api.sendRichMessage
       .mockImplementationOnce(async () => { throw new Error('network down') })
       .mockImplementationOnce(async () => ({ message_id: 777 }))
 
@@ -206,14 +207,14 @@ describe('streaming orchestration — activeDraftStreams map', () => {
     await microtaskFlush()
 
     expect(stream.getMessageId()).toBeNull()
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
 
     // Caller issues next snapshot — should retry send, not try to edit null.
     vi.advanceTimersByTime(1000)
     modelStreamReply({ bot, map, chatId: '1', text: 'second try' })
     await microtaskFlush()
 
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(2)
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(2)
     expect(bot.api.editMessageText).not.toHaveBeenCalled()
     expect(stream.getMessageId()).toBe(777)
   })
@@ -249,7 +250,9 @@ function modelPtyPartial(params: {
       bot: params.bot,
       chatId: params.chatId,
       threadId: params.threadId,
-      parseMode: 'HTML',
+      // PTY-tail previews ship as literal plain text (#2669) — the raw
+      // TUI capture is not markdown.
+      literalText: true,
       throttleMs: params.throttleMs ?? 600,
     })
     params.map.set(key, stream)
@@ -404,8 +407,6 @@ function makeActivityDeps(
 ): StreamReplyDeps {
   return {
     bot,
-    markdownToHtml: (t) => t,
-    escapeMarkdownV2: (t) => t,
     repairEscapedWhitespace: (t) => t,
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
@@ -706,7 +707,7 @@ describe('PTY activity-lane wiring (onActivity → stream_reply lane="activity")
     const deps = makeActivityDeps(bot)
 
     await handleStreamReply(
-      { chat_id: '1', text: '⚙️ Working…', lane: 'progress', format: 'html' },
+      { chat_id: '1', text: '⚙️ Working…', lane: 'progress', format: 'markdown' },
       state, deps,
     )
     await microtaskFlush()
@@ -726,12 +727,12 @@ describe('PTY activity-lane wiring (onActivity → stream_reply lane="activity")
 
     // Turn 1: progress card lives at some messageId.
     await handleStreamReply(
-      { chat_id: '1', text: '⚙️ Working… (turn 1)', lane: 'progress', format: 'html' },
+      { chat_id: '1', text: '⚙️ Working… (turn 1)', lane: 'progress', format: 'markdown' },
       state, deps,
     )
     await microtaskFlush()
     const firstProgressId = state.activeDraftStreams.get('1:_:progress')!.getMessageId()
-    const sendsBefore = bot.api.sendMessage.mock.calls.length
+    const sendsBefore = bot.api.sendRichMessage.mock.calls.length
 
     // turn_end closes the progress lane.
     await modelCloseProgressLane(state, '1', undefined)
@@ -741,7 +742,7 @@ describe('PTY activity-lane wiring (onActivity → stream_reply lane="activity")
     // edit the previous one — this is what prevents the shrink-flicker
     // described in the bug report.
     await handleStreamReply(
-      { chat_id: '1', text: '⚙️ Working… (turn 2)', lane: 'progress', format: 'html' },
+      { chat_id: '1', text: '⚙️ Working… (turn 2)', lane: 'progress', format: 'markdown' },
       state, deps,
     )
     await microtaskFlush()
@@ -749,6 +750,6 @@ describe('PTY activity-lane wiring (onActivity → stream_reply lane="activity")
     expect(state.activeDraftStreams.has('1:_:progress')).toBe(true)
     const secondProgressId = state.activeDraftStreams.get('1:_:progress')!.getMessageId()
     expect(secondProgressId).not.toBe(firstProgressId)
-    expect(bot.api.sendMessage.mock.calls.length).toBe(sendsBefore + 1)
+    expect(bot.api.sendRichMessage.mock.calls.length).toBe(sendsBefore + 1)
   })
 })