switchroom 0.5.0

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

@@ -0,0 +1,303 @@
+/**
+ * Unit tests for telegram-plugin/model-unavailable.ts.
+ *
+ * Covers the three load-bearing surfaces of issue #394 Fix 2:
+ *   - detectModelUnavailable correctly classifies the common stderr
+ *     shapes Anthropic / Claude Code emit when the model is down
+ *   - the resetAt parser handles the Anthropic-style "resets …" hints
+ *     and ISO timestamps without choking on weird input
+ *   - formatModelUnavailableCard renders a stable HTML card naming
+ *     the three actionable commands (/authfallback, /auth add, /usage)
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  detectModelUnavailable,
+  formatModelUnavailableCard,
+  resolveModelUnavailableFromOperatorEvent,
+  type ModelUnavailableDetection,
+} from '../model-unavailable.js'
+
+// ─── detectModelUnavailable ──────────────────────────────────────────────────
+
+describe('detectModelUnavailable — quota / billing strings', () => {
+  it("classifies Anthropic's 'You're out of extra usage' message", () => {
+    const d = detectModelUnavailable("You're out of extra usage · resets May 3, 11am")
+    expect(d?.kind).toBe('quota_exhausted')
+  })
+
+  it('classifies credit_balance_too_low SDK error', () => {
+    const d = detectModelUnavailable(
+      JSON.stringify({ type: 'credit_balance_too_low', message: 'Your credit balance is too low' }),
+    )
+    expect(d?.kind).toBe('quota_exhausted')
+  })
+
+  it('classifies "usage limit" plain-text errors', () => {
+    expect(detectModelUnavailable('Reached usage limit for the 5h window')?.kind).toBe(
+      'quota_exhausted',
+    )
+  })
+
+  it('classifies "quota exhausted" verbatim', () => {
+    expect(detectModelUnavailable('quota exhausted on slot main')?.kind).toBe('quota_exhausted')
+  })
+})
+
+describe('detectModelUnavailable — overload / 429 / 5xx strings', () => {
+  it('classifies overloaded_error JSON', () => {
+    const d = detectModelUnavailable(
+      JSON.stringify({ type: 'overloaded_error', message: 'Overloaded' }),
+    )
+    expect(d?.kind).toBe('overload')
+  })
+
+  it('classifies a bare HTTP 429 line', () => {
+    expect(detectModelUnavailable('HTTP 429 Too Many Requests')?.kind).toBe('overload')
+  })
+
+  it('classifies rate_limit_error', () => {
+    expect(detectModelUnavailable('rate_limit_error: too many requests')?.kind).toBe('overload')
+  })
+
+  it('classifies HTTP 503 Service Unavailable', () => {
+    expect(detectModelUnavailable('upstream returned 503 Service Unavailable')?.kind).toBe(
+      'overload',
+    )
+  })
+})
+
+describe('detectModelUnavailable — network failures', () => {
+  it('classifies ECONNREFUSED', () => {
+    expect(detectModelUnavailable('connect ECONNREFUSED 1.2.3.4:443')?.kind).toBe('network')
+  })
+
+  it('classifies ETIMEDOUT', () => {
+    expect(detectModelUnavailable('Error: ETIMEDOUT api.anthropic.com:443')?.kind).toBe('network')
+  })
+
+  it('classifies "fetch failed"', () => {
+    expect(detectModelUnavailable('TypeError: fetch failed')?.kind).toBe('network')
+  })
+
+  it('classifies DNS getaddrinfo failures', () => {
+    expect(detectModelUnavailable('getaddrinfo EAI_AGAIN api.anthropic.com')?.kind).toBe('network')
+  })
+})
+
+describe('detectModelUnavailable — non-matches', () => {
+  it('returns null for empty / non-string input', () => {
+    expect(detectModelUnavailable('')).toBeNull()
+    expect(detectModelUnavailable(undefined as unknown as string)).toBeNull()
+  })
+
+  it('returns null for routine assistant chatter', () => {
+    expect(detectModelUnavailable('OK, I will read the file now.')).toBeNull()
+  })
+
+  it('returns null for unrelated errors (auth, malformed JSON)', () => {
+    expect(detectModelUnavailable('authentication_error: invalid bearer token')).toBeNull()
+  })
+
+  it('truncates pathologically long input rather than scanning it all', () => {
+    // 100KB of "A" then a quota signal — detector samples the first 16KB so
+    // this should NOT match. Confirms the slice guard fires.
+    const huge = 'A'.repeat(100_000) + ' out of extra usage'
+    expect(detectModelUnavailable(huge)).toBeNull()
+  })
+})
+
+describe('detectModelUnavailable — reset-time extraction', () => {
+  it('parses "retry after 60 seconds" relative to now', () => {
+    const d = detectModelUnavailable('429 rate_limit_error. Retry after 60 seconds.')
+    expect(d?.kind).toBe('overload')
+    expect(d?.resetAt).toBeInstanceOf(Date)
+  })
+
+  it('parses "resets in 2h 15m" relative to now', () => {
+    const d = detectModelUnavailable("You're out of extra usage. Resets in 2h 15m")
+    expect(d?.kind).toBe('quota_exhausted')
+    expect(d?.resetAt).toBeInstanceOf(Date)
+    // Should be within the next 3 hours
+    const deltaMs = (d?.resetAt as Date).getTime() - Date.now()
+    expect(deltaMs).toBeGreaterThan(60 * 60_000)
+    expect(deltaMs).toBeLessThan(3 * 60 * 60_000)
+  })
+
+  it('parses bare ISO-8601 timestamps embedded in the string', () => {
+    const d = detectModelUnavailable('quota exhausted, retry at 2026-05-03T11:00:00Z')
+    expect(d?.resetAt?.toISOString()).toBe('2026-05-03T11:00:00.000Z')
+  })
+
+  it('omits resetAt when nothing parseable is present', () => {
+    const d = detectModelUnavailable("You're out of extra usage")
+    expect(d?.kind).toBe('quota_exhausted')
+    expect(d?.resetAt).toBeUndefined()
+  })
+
+  it('network failures never carry a resetAt', () => {
+    const d = detectModelUnavailable('ECONNREFUSED — retry after 60 seconds')
+    expect(d?.kind).toBe('network')
+    expect(d?.resetAt).toBeUndefined()
+  })
+})
+
+// ─── formatModelUnavailableCard ──────────────────────────────────────────────
+
+describe('formatModelUnavailableCard — actionable card', () => {
+  const NOW = new Date('2026-05-03T08:00:00Z')
+
+  function detection(
+    kind: 'overload' | 'quota_exhausted' | 'network',
+    resetAt?: Date,
+  ): ModelUnavailableDetection {
+    return resetAt ? { kind, resetAt, raw: 'test' } : { kind, raw: 'test' }
+  }
+
+  it('quota_exhausted with reset → snapshot-stable card', () => {
+    const card = formatModelUnavailableCard(
+      detection('quota_exhausted', new Date('2026-05-03T13:00:00Z')),
+      'gymbro',
+      { now: NOW },
+    )
+    expect(card).toMatchInlineSnapshot(`
+      "⚠️ <b>Model unavailable</b> on agent <b>gymbro</b>
+      Reason: quota exhausted (resets in 5h)
+
+      <b>What to try</b>
+      • <code>/authfallback</code> — switch to the next account slot
+      • <code>/auth add</code> — attach another subscription
+      • <code>/usage</code> — show quota breakdown"
+    `)
+  })
+
+  it('overload without reset omits the parenthetical', () => {
+    const card = formatModelUnavailableCard(detection('overload'), 'clerk', { now: NOW })
+    expect(card).toContain('Reason: model overloaded')
+    expect(card).not.toContain('(resets')
+  })
+
+  it('network never includes a reset window', () => {
+    const card = formatModelUnavailableCard(detection('network'), 'clerk', { now: NOW })
+    expect(card).toContain('Reason: network unreachable')
+    expect(card).not.toContain('(resets')
+  })
+
+  it('always includes the three actionable suggestions', () => {
+    const card = formatModelUnavailableCard(detection('quota_exhausted'), 'gymbro', { now: NOW })
+    expect(card).toContain('<code>/authfallback</code>')
+    expect(card).toContain('<code>/auth add</code>')
+    expect(card).toContain('<code>/usage</code>')
+  })
+
+  it('names the slot in the header when one is supplied', () => {
+    const card = formatModelUnavailableCard(detection('quota_exhausted'), 'gymbro', {
+      slot: 'pro-1',
+      now: NOW,
+    })
+    expect(card).toContain('slot <b>pro-1</b>')
+  })
+
+  it('escapes HTML in agent and slot names', () => {
+    const card = formatModelUnavailableCard(detection('overload'), '<evil>', {
+      slot: '"injected"',
+      now: NOW,
+    })
+    expect(card).toContain('&lt;evil&gt;')
+    expect(card).toContain('&quot;injected&quot;')
+    expect(card).not.toContain('<evil>')
+  })
+})
+
+// ─── resolveModelUnavailableFromOperatorEvent — gateway integration ──────────
+
+describe('resolveModelUnavailableFromOperatorEvent — kind-driven mapping', () => {
+  it('always treats kind=quota-exhausted as model-unavailable, even with empty detail', () => {
+    const d = resolveModelUnavailableFromOperatorEvent({ kind: 'quota-exhausted', detail: '' })
+    expect(d?.kind).toBe('quota_exhausted')
+  })
+
+  it('always treats kind=rate-limited as overload', () => {
+    const d = resolveModelUnavailableFromOperatorEvent({ kind: 'rate-limited', detail: '' })
+    expect(d?.kind).toBe('overload')
+  })
+
+  it('always treats kind=unknown-5xx as overload', () => {
+    const d = resolveModelUnavailableFromOperatorEvent({
+      kind: 'unknown-5xx',
+      detail: 'something went wrong upstream',
+    })
+    expect(d?.kind).toBe('overload')
+  })
+
+  it('preserves the parsed reset hint from the detail when one is present', () => {
+    const d = resolveModelUnavailableFromOperatorEvent({
+      kind: 'quota-exhausted',
+      detail: "You're out of extra usage. Resets in 2h",
+    })
+    expect(d?.resetAt).toBeInstanceOf(Date)
+  })
+})
+
+describe('resolveModelUnavailableFromOperatorEvent — pattern-driven fallback', () => {
+  it('returns null for credentials-expired (auth issue, not model-down)', () => {
+    expect(
+      resolveModelUnavailableFromOperatorEvent({
+        kind: 'credentials-expired',
+        detail: 'OAuth token expired',
+      }),
+    ).toBeNull()
+  })
+
+  it('returns null for agent-crashed', () => {
+    expect(
+      resolveModelUnavailableFromOperatorEvent({
+        kind: 'agent-crashed',
+        detail: 'Process exit code 1',
+      }),
+    ).toBeNull()
+  })
+
+  it('rescues unknown-4xx when its detail carries a quota signal', () => {
+    const d = resolveModelUnavailableFromOperatorEvent({
+      kind: 'unknown-4xx',
+      detail: "You're out of extra usage",
+    })
+    expect(d?.kind).toBe('quota_exhausted')
+  })
+})
+
+// ─── End-to-end: operator-event detail → rendered card text ──────────────────
+
+describe('integration — gateway suppresses raw stderr in favour of the card', () => {
+  it("turns 'You're out of extra usage' into the actionable card, not the raw text", () => {
+    const rawStderr = "You're out of extra usage · resets May 3, 11am"
+    const detected = resolveModelUnavailableFromOperatorEvent({
+      kind: 'quota-exhausted',
+      detail: rawStderr,
+    })
+    expect(detected).not.toBeNull()
+
+    const card = formatModelUnavailableCard(detected as ModelUnavailableDetection, 'gymbro')
+
+    // The actionable card replaces the raw verbatim error.
+    expect(card).toContain('Model unavailable')
+    expect(card).toContain('quota exhausted')
+    expect(card).toContain('/authfallback')
+    expect(card).toContain('/auth add')
+    expect(card).toContain('/usage')
+
+    // And the raw stderr text never appears in the user-facing card.
+    expect(card).not.toContain('out of extra usage')
+    expect(card).not.toContain('May 3, 11am')
+  })
+
+  it('lets non-model events fall through to the default operator-event renderer', () => {
+    expect(
+      resolveModelUnavailableFromOperatorEvent({
+        kind: 'credentials-invalid',
+        detail: 'Invalid API key',
+      }),
+    ).toBeNull()
+  })
+})

package/telegram-plugin/tests/multi-turn-continuity.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Integration tests for multi-turn state isolation.
+ *
+ * Verifies that state carried across turns in the same chat+thread
+ * (activeDraftStreams, activeDraftParseModes, suppressPtyPreview)
+ * resets cleanly when a new turn starts — i.e. the previous turn's
+ * stream handle is finalized/discarded before the next begins.
+ *
+ * This is one of the "per-chat continuity" gaps the plan called out:
+ * previously tested only through the full server.ts orchestration in
+ * production; now we pin down the behaviour at the handler layer.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { handleStreamReply, type StreamReplyDeps, type StreamReplyState } from '../stream-reply-handler.js'
+import type { DraftStreamHandle } from '../draft-stream.js'
+import { markdownToHtml as realMarkdownToHtml } from '../format.js'
+import { createFakeBotApi, type FakeBot } from './fake-bot-api.js'
+
+function makeState(): StreamReplyState {
+  return {
+    activeDraftStreams: new Map<string, DraftStreamHandle>(),
+    activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
+    suppressPtyPreview: new Set<string>(),
+  }
+}
+
+function makeDeps(bot: FakeBot, overrides?: Partial<StreamReplyDeps>): StreamReplyDeps {
+  return {
+    bot: bot as unknown as StreamReplyDeps['bot'],
+    markdownToHtml: (t) => realMarkdownToHtml(t),
+    escapeMarkdownV2: (t) => t,
+    repairEscapedWhitespace: (t) => t,
+    takeHandoffPrefix: () => '',
+    assertAllowedChat: () => {},
+    resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
+    disableLinkPreview: true,
+    defaultFormat: 'html',
+    logStreamingEvent: () => {},
+    endStatusReaction: () => {},
+    historyEnabled: false,
+    recordOutbound: () => {},
+    writeError: () => {},
+    throttleMs: 0,
+    ...overrides,
+  }
+}
+
+describe('multi-turn continuity', () => {
+  let bot: FakeBot
+
+  beforeEach(() => {
+    bot = createFakeBotApi({ startMessageId: 500 })
+  })
+
+  it('done=true clears the stream entry and parse-mode map', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'turn-1', done: true }, state, deps)
+    expect(state.activeDraftStreams.has('c:_')).toBe(false)
+    expect(state.activeDraftParseModes.has('c:_')).toBe(false)
+  })
+
+  it('two sequential turns on the same chat each get their own message', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'first turn', done: true }, state, deps)
+    await handleStreamReply({ chat_id: 'c', text: 'second turn', done: true }, state, deps)
+
+    expect(bot.state.sent).toHaveLength(2)
+    expect(bot.state.sent[0].text).toContain('first turn')
+    expect(bot.state.sent[1].text).toContain('second turn')
+    // Each turn finalised — map is empty.
+    expect(state.activeDraftStreams.size).toBe(0)
+  })
+
+  it('concurrent turns on different chats do not interfere', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    // Interleave chat-A and chat-B streams.
+    await handleStreamReply({ chat_id: 'A', text: 'A.1' }, state, deps)
+    await handleStreamReply({ chat_id: 'B', text: 'B.1' }, state, deps)
+    await handleStreamReply({ chat_id: 'A', text: 'A.2' }, state, deps)
+    await handleStreamReply({ chat_id: 'B', text: 'B.2', done: true }, state, deps)
+    await handleStreamReply({ chat_id: 'A', text: 'A.3', done: true }, state, deps)
+
+    expect(bot.messagesIn('A')).toHaveLength(1)
+    expect(bot.messagesIn('B')).toHaveLength(1)
+    const finalA = bot.messagesIn('A')[0]
+    const finalB = bot.messagesIn('B')[0]
+    expect(bot.textOf(finalA.message_id)).toContain('A.3')
+    expect(bot.textOf(finalB.message_id)).toContain('B.2')
+    expect(state.activeDraftStreams.size).toBe(0)
+  })
+
+  it('concurrent turns on different threads of the same chat stay isolated', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply(
+      { chat_id: 'c', text: 't1', message_thread_id: '1' },
+      state,
+      deps,
+    )
+    await handleStreamReply(
+      { chat_id: 'c', text: 't2', message_thread_id: '2' },
+      state,
+      deps,
+    )
+
+    // Two separate active streams, both under chat 'c' but distinct thread keys.
+    expect(state.activeDraftStreams.size).toBe(2)
+    expect(state.activeDraftStreams.has('c:1')).toBe(true)
+    expect(state.activeDraftStreams.has('c:2')).toBe(true)
+    expect(bot.state.sent).toHaveLength(2)
+    expect(bot.state.sent[0].message_thread_id).toBe(1)
+    expect(bot.state.sent[1].message_thread_id).toBe(2)
+
+    await handleStreamReply(
+      { chat_id: 'c', text: 't1-end', message_thread_id: '1', done: true },
+      state,
+      deps,
+    )
+    expect(state.activeDraftStreams.has('c:1')).toBe(false)
+    expect(state.activeDraftStreams.has('c:2')).toBe(true) // still mid-turn
+  })
+
+  it('suppressPtyPreview claim is lane-less and shared across streams in the same chat', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    // Default-lane call claims lane-less key.
+    await handleStreamReply({ chat_id: 'c', text: 'x' }, state, deps)
+    expect(state.suppressPtyPreview?.has('c:_')).toBe(true)
+
+    // Named-lane call claims the SAME lane-less key (by design —
+    // see comment in stream-reply-handler line 276).
+    await handleStreamReply({ chat_id: 'c', text: 'y', lane: 'activity' }, state, deps)
+    expect(state.suppressPtyPreview?.has('c:_')).toBe(true)
+  })
+
+  it('new turn on same chat reuses the stream until done:true fires', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'one' }, state, deps)
+    const s1 = state.activeDraftStreams.get('c:_')
+    await handleStreamReply({ chat_id: 'c', text: 'two' }, state, deps)
+    const s2 = state.activeDraftStreams.get('c:_')
+
+    expect(s1).toBe(s2)
+    // One message, edited twice.
+    expect(bot.state.sent).toHaveLength(1)
+    expect(bot.textOf(bot.state.sent[0].message_id)).toContain('two')
+  })
+})

package/telegram-plugin/tests/operator-events-history.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Tests for telegram-plugin/operator-events-history.ts — in-memory
+ * per-agent OperatorEvent TTL store used by /status enrichment.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+  recordOperatorEvent,
+  getLastOperatorEvent,
+  clearOperatorEventHistory,
+  formatLastEventLine,
+  EVENT_TTL_MS,
+} from '../operator-events-history.js'
+import type { OperatorEvent } from '../operator-events.js'
+
+function makeEvent(agent: string, kind: OperatorEvent['kind'] = 'credentials-expired'): OperatorEvent {
+  return {
+    kind,
+    agent,
+    detail: `test detail for ${agent}`,
+    suggestedActions: [],
+    firstSeenAt: new Date('2026-04-24T12:00:00Z'),
+  }
+}
+
+describe('operator-events-history', () => {
+  beforeEach(() => {
+    clearOperatorEventHistory()
+  })
+
+  describe('recordOperatorEvent + getLastOperatorEvent', () => {
+    it('stores and retrieves the last event per agent', () => {
+      const ev = makeEvent('gymbro')
+      recordOperatorEvent(ev)
+      expect(getLastOperatorEvent('gymbro')).toEqual(ev)
+    })
+
+    it('returns null for unknown agents', () => {
+      expect(getLastOperatorEvent('unknown')).toBeNull()
+    })
+
+    it('overwrites a previous event for the same agent', () => {
+      recordOperatorEvent(makeEvent('gymbro', 'credentials-expired'))
+      const latest = makeEvent('gymbro', 'rate-limited')
+      recordOperatorEvent(latest)
+      expect(getLastOperatorEvent('gymbro')).toEqual(latest)
+    })
+
+    it('keeps separate slots per agent', () => {
+      const a = makeEvent('gymbro', 'credentials-expired')
+      const b = makeEvent('clerk', 'rate-limited')
+      recordOperatorEvent(a)
+      recordOperatorEvent(b)
+      expect(getLastOperatorEvent('gymbro')).toEqual(a)
+      expect(getLastOperatorEvent('clerk')).toEqual(b)
+    })
+  })
+
+  describe('TTL expiry', () => {
+    it('returns null when the stored event is older than TTL', () => {
+      const now = 1_000_000
+      recordOperatorEvent(makeEvent('gymbro'), now)
+      const future = now + EVENT_TTL_MS + 1
+      expect(getLastOperatorEvent('gymbro', future)).toBeNull()
+    })
+
+    it('returns the event when exactly at TTL boundary', () => {
+      const now = 1_000_000
+      recordOperatorEvent(makeEvent('gymbro'), now)
+      expect(getLastOperatorEvent('gymbro', now + EVENT_TTL_MS)).not.toBeNull()
+    })
+
+    it('evicts expired events from the map on read', () => {
+      const now = 1_000_000
+      recordOperatorEvent(makeEvent('gymbro'), now)
+      const future = now + EVENT_TTL_MS + 1
+      getLastOperatorEvent('gymbro', future) // triggers eviction
+      // Now a fresh read at `now` should still miss (row was evicted)
+      expect(getLastOperatorEvent('gymbro', now)).toBeNull()
+    })
+
+    it('honors a custom TTL', () => {
+      const now = 1_000_000
+      recordOperatorEvent(makeEvent('gymbro'), now)
+      const ttl = 60_000 // 1 min
+      expect(getLastOperatorEvent('gymbro', now + ttl - 1, ttl)).not.toBeNull()
+      expect(getLastOperatorEvent('gymbro', now + ttl + 1, ttl)).toBeNull()
+    })
+  })
+
+  describe('clearOperatorEventHistory', () => {
+    it('drops all stored events', () => {
+      recordOperatorEvent(makeEvent('gymbro'))
+      recordOperatorEvent(makeEvent('clerk'))
+      clearOperatorEventHistory()
+      expect(getLastOperatorEvent('gymbro')).toBeNull()
+      expect(getLastOperatorEvent('clerk')).toBeNull()
+    })
+  })
+
+  describe('formatLastEventLine', () => {
+    it('returns null for agents with no event', () => {
+      expect(formatLastEventLine('unknown')).toBeNull()
+    })
+
+    it('renders a single-line summary for fresh events', () => {
+      recordOperatorEvent(makeEvent('gymbro', 'credentials-expired'))
+      const line = formatLastEventLine('gymbro')
+      expect(line).toContain('credentials-expired')
+    })
+
+    it('includes an age string', () => {
+      recordOperatorEvent(makeEvent('gymbro', 'rate-limited'))
+      const line = formatLastEventLine('gymbro')
+      expect(line).toMatch(/\((\d+[smh]) ago\)/)
+    })
+
+    it('returns null for expired events', () => {
+      const now = 1_000_000
+      recordOperatorEvent(makeEvent('gymbro'), now)
+      const future = now + EVENT_TTL_MS + 1
+      expect(formatLastEventLine('gymbro', future)).toBeNull()
+    })
+  })
+})