@mobius-os/mobius 0.2.2

package/src/lib/entry-view.ts

@@ -0,0 +1,351 @@
+/**
+ * jsonl entry → renderable view.
+ *
+ * The pure helpers (assistantResponseText / assistantEntryText / entryUserText
+ * and the "hidden noise" predicates) are copied from the mobius web frontend's
+ * frontend/src/components/viewer/entry-classify.ts. The frontend's full
+ * entry-extract.ts (diff/plan machinery) is far heavier than a chat TUI needs,
+ * so instead we project each entry into a small EntryView union that the
+ * Transcript renders — handling BOTH the Claude SDK entry shape (type:
+ * 'user'|'assistant'|'system', message.content[]) and both Codex SDK shapes
+ * (function_call/function_call_output and custom_tool_call/custom_tool_call_output).
+ */
+import type { AnyEntry } from '../types.js'
+
+export type EntryView =
+  | { kind: 'skip' }
+  | { kind: 'user'; text: string }
+  | { kind: 'assistant'; text: string }
+  | { kind: 'reasoning'; text: string }
+  | { kind: 'tool_call'; toolName: string; summary: string }
+  | { kind: 'tool_result'; summary: string; isError: boolean }
+  | { kind: 'system'; text: string }
+  | { kind: 'error'; text: string }
+
+// ── copied verbatim from frontend entry-classify.ts ──────────────────────────
+export function assistantResponseText(content: any): string {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content
+    .map((b: any) => {
+      if (!b || typeof b !== 'object') return ''
+      if (typeof b.text !== 'string') return ''
+      return b.type === 'text' || b.type === 'output_text' ? b.text : ''
+    })
+    .filter(Boolean)
+    .join('\n')
+}
+
+export function assistantEntryText(entry: AnyEntry): string {
+  if (entry?.type === 'assistant') return assistantResponseText(entry?.message?.content)
+  if (entry?.type === 'response_item' && entry?.payload?.type === 'message' && entry?.payload?.role === 'assistant') {
+    return assistantResponseText(entry?.payload?.content)
+  }
+  return ''
+}
+
+function entryUserText(entry: AnyEntry): string {
+  if (entry?.type === 'response_item' && entry?.payload?.type === 'message' && entry?.payload?.role === 'user') {
+    const c = entry?.payload?.content
+    if (typeof c === 'string') return c
+    if (Array.isArray(c)) return c.map((b: any) => (typeof b === 'string' ? b : (b?.text ?? b?.input_text ?? ''))).filter(Boolean).join('\n')
+    return ''
+  }
+  if (entry?.type === 'user') {
+    const c = entry?.message?.content
+    if (typeof c === 'string') return c
+    if (Array.isArray(c)) return c.map((b: any) => (typeof b === 'string' ? b : (b?.text ?? ''))).filter(Boolean).join('\n')
+    return ''
+  }
+  return ''
+}
+
+const ENV_CONTEXT_RE = /<environment_context\b[^>]*>[\s\S]*?<\/environment_context>/gi
+
+// Noise entries that carry no conversational value (system injections / metadata).
+export function isHiddenNoise(entry: AnyEntry): boolean {
+  if (entry?.type === 'event_msg' && (entry?.payload?.type === 'token_count' || entry?.payload?.type === 'context_compacted')) return true
+  if (entry?.type === 'session_meta') return true
+  if (entry?.type === 'system' && entry?.subtype === 'turn_duration') return true
+  if (entry?.type === 'attachment' && (entry?.attachment?.type === 'skill_listing' || entry?.attachment?.type === 'agent_listing_delta')) return true
+  // pure <environment_context> injection
+  const t = entryUserText(entry)
+  if (t) {
+    const stripped = t.replace(ENV_CONTEXT_RE, '')
+    if (stripped.trim().length === 0 && stripped !== t) return true
+  }
+  return false
+}
+
+// ── TUI-side projection ──────────────────────────────────────────────────────
+function truncate(s: string, n: number): string {
+  const one = s.replace(/\s+/g, ' ').trim()
+  return one.length > n ? one.slice(0, n - 1) + '…' : one
+}
+
+/** Build a one-line summary of a tool call from its name + input. */
+export function summarizeToolInput(name: string, input: any): string {
+  if (!input || typeof input !== 'object') return ''
+  const cmd = (s?: string) => truncate(s ?? '', 120)
+  switch (name) {
+    case 'Bash':
+    case 'shell':
+    case 'bash':
+    case 'exec':
+    case 'exec_command':
+    case 'shell_command':
+    case 'run_terminal_cmd':
+      return cmd(input.cmd ?? input.command ?? input.script)
+    case 'Read':
+    case 'read_file':
+      return input.file_path ?? input.path ?? ''
+    case 'Write':
+    case 'write_file':
+    case 'create_file':
+      return input.file_path ?? input.path ?? ''
+    case 'Edit':
+    case 'StrReplace':
+    case 'edit_file':
+    case 'update_plan':
+      return input.file_path ?? input.path ?? ''
+    case 'Glob':
+    case 'list_files':
+      return input.pattern ?? input.path ?? ''
+    case 'Grep':
+    case 'grep':
+    case 'search_file_content':
+      return input.pattern ?? input.query ?? ''
+    case 'Task':
+    case 'launch_subagent':
+      return input.description ?? ''
+    case 'WebFetch':
+    case 'web_fetch':
+      return input.url ?? input.prompt ?? ''
+    case 'WebSearch':
+    case 'web_search':
+      return input.query ?? ''
+    case 'TodoWrite':
+    case 'update_plan_plan':
+      return ''
+    default: {
+      const keys = Object.keys(input)
+      if (keys.length === 0) return ''
+      const k = keys[0]
+      return truncate(`${k}: ${typeof input[k] === 'string' ? input[k] : JSON.stringify(input[k])}`, 100)
+    }
+  }
+}
+
+/** Extract readable text + error flag from a tool_result block content. */
+function extractToolResult(content: any): { text: string; isError: boolean } {
+  const isError = !!content?.is_error
+  let body = content?.content
+  if (typeof body === 'string') return { text: body, isError }
+  if (Array.isArray(body)) {
+    const t = body
+      .map((b: any) => (typeof b === 'string' ? b : (b?.text ?? '')))
+      .filter(Boolean)
+      .join('\n')
+    return { text: t, isError }
+  }
+  if (typeof body === 'object' && body) {
+    return { text: body.text ?? body.output ?? JSON.stringify(body), isError }
+  }
+  return { text: '', isError }
+}
+
+const TOOL_LABEL: Record<string, string> = {
+  Bash: '运行命令', bash: '运行命令', shell: '运行命令', exec: '运行命令',
+  exec_command: '运行命令', shell_command: '运行命令', run_terminal_cmd: '运行命令',
+  write_stdin: '输入命令',
+  Read: '读取文件', read_file: '读取文件',
+  Write: '写入文件', write_file: '写入文件', create_file: '创建文件',
+  Edit: '编辑文件', StrReplace: '编辑文件', edit_file: '编辑文件', apply_patch: '编辑文件',
+  Glob: '搜索文件', list_files: '列出文件',
+  Grep: '搜索内容', grep: '搜索内容', search_file_content: '搜索内容',
+  Task: '子任务', launch_subagent: '子任务',
+  WebFetch: '抓取网页', web_fetch: '抓取网页',
+  WebSearch: '网络搜索', web_search: '网络搜索',
+  TodoWrite: '更新计划', update_plan: '更新计划',
+}
+
+// Mirrors the web viewer (header-summary.ts): encrypted reasoning gets a fixed
+// label; otherwise show the summary text if any.
+const ENCRYPTED_REASONING_LABEL = 'Reasoning (闭源模型的推理过程被加密，无法解码)'
+
+function reasoningSummaryText(p: any): string {
+  const s = p?.summary
+  if (Array.isArray(s)) return s.map((x: any) => (typeof x === 'string' ? x : (x?.text ?? ''))).filter(Boolean).join('\n')
+  if (typeof s === 'string') return s
+  return ''
+}
+
+/**
+ * Newer Codex versions wrap tool calls in a custom `exec` transport. Its
+ * payload.input is JavaScript such as:
+ *
+ *   const r = await tools.exec_command({ cmd: "rg -n ...", workdir: "/repo" })
+ *
+ * Extract the nested tool name and its object argument so the TUI can render
+ * the same command summary as the web viewer. JSON is the common case; the
+ * small quoted-field fallback also handles JavaScript object keys and strings.
+ */
+function parseCustomToolCall(raw: any): { name: string; input: Record<string, any> } | null {
+  if (typeof raw !== 'string') return null
+  // Prefer the first tools.<name>(...) invocation. A custom wrapper may call
+  // Promise.all(...) or another helper before it, which is transport code and
+  // must not become the displayed tool name.
+  const call = /tools\.([A-Za-z_$][\w$]*)\s*\(/g.exec(raw)
+    || /\b(exec_command|write_stdin|apply_patch)\s*\(/g.exec(raw)
+  if (!call) return null
+  const objectStart = raw.indexOf('{', call.index + call[0].length)
+  if (objectStart < 0) return { name: call[1], input: {} }
+
+  let quote = ''
+  let escaped = false
+  let depth = 0
+  let objectEnd = -1
+  for (let index = objectStart; index < raw.length; index++) {
+    const ch = raw[index]
+    if (quote) {
+      if (escaped) escaped = false
+      else if (ch === '\\') escaped = true
+      else if (ch === quote) quote = ''
+      continue
+    }
+    if (ch === '"' || ch === "'" || ch === '`') { quote = ch; continue }
+    if (ch === '{') depth++
+    else if (ch === '}' && --depth === 0) { objectEnd = index; break }
+  }
+  if (objectEnd < 0) return { name: call[1], input: {} }
+
+  const source = raw.slice(objectStart, objectEnd + 1)
+  try {
+    const parsed = JSON.parse(source)
+    if (parsed && typeof parsed === 'object') return { name: call[1], input: parsed }
+  } catch { /* JavaScript object syntax falls through to quoted-field parsing. */ }
+
+  const input: Record<string, any> = {}
+  const patterns = [
+    /(?:^|[,{])\s*(cmd|command|script|workdir|cwd|path|file_path|query|pattern)\s*:\s*"((?:\\.|[^"\\])*)"/g,
+    /(?:^|[,{])\s*(cmd|command|script|workdir|cwd|path|file_path|query|pattern)\s*:\s*'((?:\\.|[^'\\])*)'/g,
+  ]
+  for (const pattern of patterns) {
+    let field: RegExpExecArray | null
+    while ((field = pattern.exec(source))) {
+      try { input[field[1]] = JSON.parse(`"${field[2].replace(/"/g, '\\"')}"`) }
+      catch { input[field[1]] = field[2].replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t').replace(/\\([\\"'])/g, '$1') }
+    }
+  }
+  return { name: call[1], input }
+}
+
+/** Project one entry into zero or more renderable views. */
+export function viewsForEntry(entry: AnyEntry): EntryView[] {
+  if (!entry || typeof entry !== 'object') return [{ kind: 'skip' }]
+  if (isHiddenNoise(entry)) return [{ kind: 'skip' }]
+  const type = entry.type
+
+  // ── Claude SDK shapes ───────────────────────────────────────────────────
+  if (type === 'assistant') {
+    const content = entry.message?.content
+    if (!Array.isArray(content)) {
+      const text = assistantResponseText(content)
+      return text ? [{ kind: 'assistant', text }] : [{ kind: 'skip' }]
+    }
+    const out: EntryView[] = []
+    const textParts: string[] = []
+    const thinkingParts: string[] = []
+    let hasThinking = false
+    for (const b of content) {
+      if (!b) continue
+      if (b.type === 'text' || b.type === 'output_text') {
+        if (b.text) textParts.push(b.text)
+      } else if (b.type === 'tool_use') {
+        if (textParts.length) { out.push({ kind: 'assistant', text: textParts.join('\n') }); textParts.length = 0 }
+        out.push({ kind: 'tool_call', toolName: b.name, summary: summarizeToolInput(b.name, b.input) })
+      } else if (b.type === 'thinking') {
+        // model reasoning — shown like the web viewer (encrypted/empty thinking → fallback label)
+        hasThinking = true
+        if (typeof b.thinking === 'string' && b.thinking) thinkingParts.push(b.thinking)
+      }
+    }
+    if (textParts.length) out.push({ kind: 'assistant', text: textParts.join('\n') })
+    if (thinkingParts.length) out.push({ kind: 'reasoning', text: thinkingParts.join('\n').trim() })
+    else if (hasThinking) out.push({ kind: 'reasoning', text: '思考内容被隐藏' })
+    return out.length ? out : [{ kind: 'skip' }]
+  }
+
+  if (type === 'user') {
+    const content = entry.message?.content
+    // tool_result wrapper (assistant's tool output fed back)
+    if (Array.isArray(content) && content.some((b: any) => b?.type === 'tool_result')) {
+      const out: EntryView[] = []
+      for (const b of content) {
+        if (b?.type === 'tool_result') {
+          const { text, isError } = extractToolResult(b)
+          out.push({ kind: 'tool_result', summary: truncate(text, 160), isError })
+        }
+      }
+      return out
+    }
+    const text = entryUserText(entry)
+    return text ? [{ kind: 'user', text }] : [{ kind: 'skip' }]
+  }
+
+  if (type === 'system') {
+    const subtype = entry.subtype
+    if (subtype === 'init') return [{ kind: 'skip' }]
+    const text = entry.content || entry.message?.content || subtype
+    return text ? [{ kind: 'system', text: truncate(typeof text === 'string' ? text : JSON.stringify(text), 160) }] : [{ kind: 'skip' }]
+  }
+
+  // ── Codex SDK shapes (response_item) ────────────────────────────────────
+  if (type === 'response_item') {
+    const p = entry.payload
+    if (!p) return [{ kind: 'skip' }]
+    if (p.type === 'message') {
+      const text = assistantResponseText(p.content)
+      if (!text) return [{ kind: 'skip' }]
+      return [{ kind: p.role === 'user' ? 'user' : 'assistant', text }]
+    }
+    if (p.type === 'reasoning') {
+      const enc = p.encrypted_content
+      const text = typeof enc === 'string' && enc.length > 0
+        ? ENCRYPTED_REASONING_LABEL
+        : (reasoningSummaryText(p) || 'reasoning')
+      return [{ kind: 'reasoning', text }]
+    }
+    if (p.type === 'function_call') {
+      let name = p.name || 'tool'
+      let input: any = p.arguments
+      if (typeof input === 'string') { try { input = JSON.parse(input) } catch { /* keep string */ } }
+      return [{ kind: 'tool_call', toolName: name, summary: summarizeToolInput(name, input) }]
+    }
+    if (p.type === 'custom_tool_call') {
+      const nested = parseCustomToolCall(p.input)
+      const name = nested?.name || p.name || 'tool'
+      const input = nested?.input
+        || (p.input && typeof p.input === 'object' ? p.input : null)
+        || (typeof p.input === 'string' && ['exec', 'exec_command', 'shell', 'bash'].includes(name) ? { command: p.input } : {})
+      return [{ kind: 'tool_call', toolName: name, summary: summarizeToolInput(name, input) }]
+    }
+    if (p.type === 'function_call_output' || p.type === 'custom_tool_call_output') {
+      const { text } = extractToolResult({ content: p.output, is_error: false })
+      return [{ kind: 'tool_result', summary: truncate(text, 160), isError: false }]
+    }
+    return [{ kind: 'skip' }]
+  }
+
+  if (type === 'event_msg') {
+    const ptype = entry.payload?.type
+    if (ptype === 'error') return [{ kind: 'error', text: truncate(entry.payload?.message || '错误', 200) }]
+    return [{ kind: 'skip' }]
+  }
+
+  return [{ kind: 'skip' }]
+}
+
+export function toolLabel(name: string): string {
+  return TOOL_LABEL[name] ?? name
+}

package/src/main.tsx

@@ -0,0 +1,13 @@
+/**
+ * Mobius terminal entry point.
+ *
+ * Run:  npx tsx src/main.tsx   (or `npm start`)
+ *
+ * exitOnCtrlC is disabled — the composer interprets Ctrl+C itself (stop the
+ * current generation while busy; quit when idle). Use /quit to exit explicitly.
+ */
+import React from 'react'
+import { render } from 'ink'
+import { App } from './App.js'
+
+render(React.createElement(App), { exitOnCtrlC: false })

package/src/markdown.ts

@@ -0,0 +1,160 @@
+/**
+ * Terminal markdown renderer.
+ *
+ * The web frontend renders markdown with react-markdown + remark-gfm +
+ * rehype-highlight (the message content is a plain markdown string). In the
+ * terminal we instead parse the same markdown with `marked`'s lexer and render
+ * the token tree to ANSI via `chalk` (prose) and `cli-highlight` (fenced code).
+ * The resulting ANSI string is fed to an Ink <Text>; Ink strips ANSI only for
+ * layout measurement and passes the codes through to the terminal.
+ */
+import chalk from 'chalk'
+import { highlight, supportsLanguage } from 'cli-highlight'
+import { lexer, type Token, type Tokens } from 'marked'
+
+export interface RenderedMarkdownLine {
+  text: string
+  code: boolean
+}
+
+/**
+ * Highlight a fenced code block the same way Codex does: foreground syntax
+ * colors only, no language badge, border, fence characters, or background.
+ * Unknown and unlabelled languages stay plain instead of being guessed as bash.
+ */
+function renderCode(code: string, lang?: string): string {
+  const trimmed = code.replace(/\n$/, '')
+  const language = lang?.split(/[\s,]/, 1)[0]?.trim()
+  if (!language || !supportsLanguage(language)) return trimmed
+  try {
+    return highlight(trimmed, { language, ignoreIllegals: true })
+  } catch {
+    return trimmed
+  }
+}
+
+function renderInline(tokens: Token[] | undefined): string {
+  if (!tokens || tokens.length === 0) return ''
+  return tokens.map((t) => renderInlineOne(t)).join('')
+}
+
+function renderInlineOne(t: Token): string {
+  // marked inline tokens carry their own nested `.tokens`.
+  const anyT = t as any
+  switch (t.type) {
+    case 'text':
+      return anyT.tokens ? renderInline(anyT.tokens) : escapeAnsiReset(anyT.text)
+    case 'strong':
+      return chalk.bold(renderInline(anyT.tokens))
+    case 'em':
+      return chalk.italic(renderInline(anyT.tokens))
+    case 'del':
+      return chalk.dim.strikethrough(renderInline(anyT.tokens))
+    case 'codespan':
+      return chalk.cyanBright(anyT.text)
+    case 'link': {
+      const label = renderInline(anyT.tokens) || anyT.href
+      return anyT.href && label !== anyT.href ? `${chalk.cyan(label)} (${chalk.dim.underline(anyT.href)})` : chalk.cyan(label)
+    }
+    case 'image':
+      return chalk.magentaBright(`[图片: ${anyT.href || anyT.text}]`)
+    case 'br':
+      return '\n'
+    case 'escape':
+    case 'html':
+      return anyT.text ?? ''
+    default:
+      return anyT.text ?? renderInline(anyT.tokens)
+  }
+}
+
+/** Prevent a stray embedded reset from truncating the surrounding style span. */
+function escapeAnsiReset(s: string): string {
+  return s
+}
+
+function renderTable(t: Tokens.Table): string {
+  const cell = (toks: any) => renderInline(toks?.tokens ?? [{ type: 'text', text: toks?.text ?? '' }])
+  const header = t.header.map((h) => cell(h)).join(' | ')
+  const rows = t.rows.map((r) => r.map((c) => cell(c)).join(' | ')).join('\n')
+  return chalk.bold(header) + '\n' + chalk.dim('-'.repeat(Math.min(header.length, 80))) + '\n' + rows
+}
+
+/** Render markdown into visual lines so code can opt out of terminal wrapping. */
+export function renderMarkdownLines(md: string): RenderedMarkdownLine[] {
+  if (!md) return []
+  const tokens = lexer(md, { gfm: true, breaks: false })
+  const out: RenderedMarkdownLine[] = []
+  for (const t of tokens) {
+    const isCode = t.type === 'code'
+    const rendered = isCode
+      ? renderCode((t as any).text, (t as any).lang)
+      : renderBlock(t)
+    for (const text of rendered.split('\n')) out.push({ text, code: isCode })
+  }
+
+  // Collapse repeated prose separators while preserving blank lines that are
+  // part of source code. Remove only non-code padding at the outer edges.
+  const normalized: RenderedMarkdownLine[] = []
+  for (const line of out) {
+    const previous = normalized.at(-1)
+    if (!line.code && line.text === '' && previous && !previous.code && previous.text === '') continue
+    normalized.push(line)
+  }
+  while (normalized[0] && !normalized[0].code && normalized[0].text === '') normalized.shift()
+  while (normalized.at(-1) && !normalized.at(-1)?.code && normalized.at(-1)?.text === '') normalized.pop()
+  return normalized
+}
+
+/** Backward-compatible string projection used by non-Ink callers and tests. */
+export function renderMarkdown(md: string): string {
+  return renderMarkdownLines(md).map(line => line.text).join('\n')
+}
+
+function renderBlock(t: Token): string {
+  const anyT = t as any
+  switch (t.type) {
+    case 'heading': {
+      const inner = renderInline(anyT.tokens)
+      return anyT.depth <= 2 ? chalk.bold.cyanBright(inner) : chalk.bold(inner)
+    }
+    case 'paragraph':
+      return renderInline(anyT.tokens)
+    case 'code': {
+      return renderCode(anyT.text, anyT.lang)
+    }
+    case 'blockquote': {
+      const inner = (anyT.tokens as Token[]).map(renderBlock).join('\n')
+      return inner.split('\n').map((l) => chalk.dim('│ ' + l)).join('\n')
+    }
+    case 'list': {
+      const items: string[] = (anyT.items as Token[]).map((it: any, i: number) => {
+        const marker = anyT.ordered ? `${(anyT.start ?? 1) + i}. ` : '• '
+        const body = renderListItemBody(it)
+        return body.split('\n').map((l, idx) => (idx === 0 ? chalk.cyan(marker) + l : '  ' + l)).join('\n')
+      })
+      return items.join('\n')
+    }
+    case 'hr':
+      return chalk.dim('─'.repeat(40))
+    case 'table':
+      return renderTable(t as Tokens.Table)
+    case 'space':
+      return ''
+    case 'html':
+      return chalk.dim(anyT.text ?? '')
+    default:
+      return anyT.text ?? renderInline(anyT.tokens)
+  }
+}
+
+function renderListItemBody(item: any): string {
+  // list_item token: nested block tokens (paragraph, list, text…)
+  if (item.tokens && item.tokens.length) {
+    return (item.tokens as Token[])
+      .map((tok) => (tok.type === 'text' ? renderInline((tok as any).tokens) : renderBlock(tok)))
+      .filter(Boolean)
+      .join('\n')
+  }
+  return item.text ?? ''
+}

package/src/sse.ts

@@ -0,0 +1,126 @@
+/**
+ * Server-Sent Events client for GET /api/sessions/:id/events.
+ *
+ * Node has no native EventSource, so we drive the same endpoint with a streaming
+ * `fetch` and parse SSE frames ourselves (the same approach the web frontend's
+ * search modal falls back to when EventSource can't carry the Authorization
+ * header). The token rides in a `?token=` query param.
+ *
+ * Frame grammar: blocks separated by a blank line; within a block, `event:` sets
+ * the name and one or more `data:` lines (joined with \n) carry the JSON payload.
+ * Lines starting with `:` are keepalive comments and are ignored.
+ */
+import type { AnyEntry } from './types.js'
+
+export interface SseHandlers {
+  onOpen?: () => void
+  onSubscribed?: (session: any) => void
+  onHistoryEntries?: (entries: AnyEntry[], done: boolean) => void
+  onEntry?: (entry: AnyEntry) => void
+  onTyping?: (active: boolean) => void
+  onError?: (message: string, category?: string) => void
+  onClose?: () => void
+}
+
+export class SseConnection {
+  private controller: AbortController | null = null
+  private closed = false
+
+  constructor(private url: string, private handlers: SseHandlers) {}
+
+  isClosed(): boolean { return this.closed }
+
+  async start(): Promise<void> {
+    this.controller = new AbortController()
+    try {
+      const res = await fetch(this.url, {
+        method: 'GET',
+        headers: { Accept: 'text/event-stream' },
+        signal: this.controller.signal,
+      })
+      if (!res.ok || !res.body) {
+        this.handlers.onError?.(`SSE 连接失败 (HTTP ${res.status})`)
+        this.handlers.onClose?.()
+        return
+      }
+      this.handlers.onOpen?.()
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder('utf-8')
+      let buffer = ''
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        const { value, done } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+        // Complete frames are separated by a blank line.
+        const frames = buffer.split(/\r?\n\r?\n/)
+        buffer = frames.pop() ?? ''
+        for (const frame of frames) this.handleFrame(frame)
+      }
+      // flush any trailing frame
+      if (buffer.trim()) this.handleFrame(buffer)
+    } catch (e: any) {
+      // AbortError = we closed it ourselves; "terminated" / socket-closed codes =
+      // the server (or a reverse proxy's idle timeout) dropped the stream mid-read.
+      // Both are expected for a long-lived SSE connection, not user-facing errors —
+      // the recursive status poll in useChat remains the source of truth, so we
+      // stay silent instead of flashing a misleading "SSE 读取错误: terminated".
+      const msg = e?.message ?? String(e)
+      const expectedClose =
+        e?.name === 'AbortError' ||
+        msg === 'terminated' ||
+        e?.code === 'UND_ERR_SOCKET' || e?.code === 'UND_ERR_CLOSED' ||
+        e?.code === 'ECONNRESET' || e?.code === 'EPIPE'
+      if (!expectedClose) this.handlers.onError?.(`SSE 读取错误: ${msg}`)
+    } finally {
+      this.closed = true
+      this.handlers.onClose?.()
+    }
+  }
+
+  close(): void {
+    this.closed = true
+    try { this.controller?.abort() } catch { /* ignore */ }
+  }
+
+  private handleFrame(frame: string): void {
+    let eventName = 'message'
+    const dataLines: string[] = []
+    for (const line of frame.split(/\r?\n/)) {
+      if (!line || line.startsWith(':')) continue // blank / keepalive comment
+      if (line.startsWith('event:')) {
+        eventName = line.slice(6).trim()
+      } else if (line.startsWith('data:')) {
+        dataLines.push(line.slice(5).replace(/^\s/, ''))
+      }
+    }
+    if (dataLines.length === 0) return
+    const raw = dataLines.join('\n')
+    let payload: any
+    try { payload = JSON.parse(raw) } catch { return }
+    this.dispatch(eventName, payload)
+  }
+
+  private dispatch(eventName: string, p: any): void {
+    const ev = p?.event ?? eventName
+    switch (ev) {
+      case 'subscribed': this.handlers.onSubscribed?.(p.session); break
+      case 'jsonl_history':
+        this.handlers.onHistoryEntries?.(p.entries ?? [], !!p.done)
+        break
+      case 'jsonl_entry':
+        this.handlers.onEntry?.(p.entry)
+        break
+      case 'typing':
+        this.handlers.onTyping?.(!!p.active)
+        break
+      case 'error':
+      case 'server_error':
+        this.handlers.onError?.(p.message ?? p.error ?? '未知错误', p.category)
+        break
+      default:
+        // history / jsonl_meta / message / stream / etc. — currently unused by the TUI.
+        break
+    }
+  }
+}