osai-agent 4.0.0

package/src/parser/markdown.js

@@ -0,0 +1,505 @@
+// =============================================================================
+// OS AI Agent — Markdown Renderer v4.0
+// =============================================================================
+// Two modes:
+//   renderMarkdown(text)        — full buffered render (après réception complète)
+//   StreamMarkdown              — classe stateful pour le streaming token-by-token
+// =============================================================================
+
+import chalk from 'chalk';
+
+// ─── Tokyo Night color tokens ─────────────────────────────────
+const C = {
+  text:    '#c0caf5',
+  bright:  '#e2e8f0',
+  blue:    '#7aa2f7',
+  cyan:    '#7dcfff',
+  teal:    '#2dd4bf',
+  green:   '#9ece6a',
+  emerald: '#34d399',
+  amber:   '#e0af68',
+  red:     '#f7768e',
+  soft:    '#9aa5ce',
+  subtle:  '#565f89',
+  dim:     '#414868',
+  muted:   '#3b3f52',
+  surface: '#1a1b26',
+  border:  '#2a2e3f',
+};
+
+const ELLIPSIS = '…';
+const FORCE_ASCII_TABLES =
+  process.env.OSAI_TABLE_ASCII === '1' ||
+  process.env.NO_UNICODE_TABLES === '1' ||
+  (process.env.TERM || '').toLowerCase() === 'dumb';
+
+// ─── Tool names (for stripping tool JSON from output) ────────
+const ALL_TOOLS = 'LOCAL_CMD|SSH_CMD|READ_FILE|WRITE_FILE|EDIT_FILE|APPEND_FILE|DELETE_FILE|LIST_DIR|SEARCH_FILE|CREATE_DIR|TREE_VIEW|RUN_SCRIPT|MOVE_FILE|COPY_FILE|FILE_INFO|FETCH_URL|WEB_SEARCH|TODO_ADD|TODO_COMPLETE|TODO_UPDATE|TODO_LIST|TODO_CLEAR|POWERSHELL|GLOB|GREP|GIT|DIAG_POST_EDIT|ASK_USER|PLAN_MODE|SKILL_LIST|LOAD_SKILL|CREATE_SKILL|TASK';
+
+const stripAnsi = (str) => (str || '')
+  .replace(/\x1b\[[0-9;]*m/g, '')
+  .replace(/\x1b\]8;;[^\x1b]*\x1b\\/g, '')
+  .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+
+const visibleLen = (str) => stripAnsi(str).length;
+
+export const stripToolJSON = (text) => {
+  if (!text) return '';
+  return text
+    .replace(new RegExp(`\\{[^{}]*"tool"\\s*:\\s*"(?:${ALL_TOOLS})"[^{}]*\\}`, 'g'), '')
+    .replace(new RegExp(`\\{[\\s\\S]*?"tool"\\s*:\\s*"(?:${ALL_TOOLS})"[\\s\\S]*?\\}`, 'g'), '')
+    .replace(/```(?:json)?\s*\{[\s\S]*?"tool"[\s\S]*?\}\s*```/g, '')
+    .replace(/\[TOOL_RESULT\][\s\S]*?(?=\n\n|\n[A-Z\u00C0-\u024F]|$)/g, '')
+    .replace(/\[DONE\]/gi, '').replace(/\[INCOMPLETE\]/gi, '').replace(/\[BLOCKED\]/gi, '')
+    .replace(/\[TOOL_CALL\]\s*/g, '')
+    .replace(/THE TOOL\s*CALL[\s\S]*?(?=\n\n|$)/gi, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+};
+
+export const stripToolXML = (text) => {
+  if (!text) return '';
+  return text
+    .replace(/<tool\b[^>]*>[\s\S]*?<\/tool\s*>/g, '')
+    .replace(/<tool\b[^>]*\/>/g, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+};
+
+// ─── Inline style renderer ────────────────────────────────────
+export const renderInline = (text) => {
+  // Strip any raw ANSI escape sequences the LLM may have included in its output
+  const clean = text.replace(/\x1b\[[0-9;]*[mA-Za-z]/g, '').replace(/\x1b\][^\x1b]*\x1b\\/g, '');
+  return clean
+    .replace(/\*\*\*([^*]+)\*\*\*/g, (_, t) => chalk.bold.italic.hex(C.bright)(t))
+    .replace(/\*\*([^*]+)\*\*/g,     (_, t) => chalk.bold.hex(C.bright)(t))
+    .replace(/\*([^*\n]+)\*/g,       (_, t) => chalk.italic.hex(C.soft)(t))
+    .replace(/`([^`\n]+)`/g,         (_, t) => chalk.bgHex(C.surface).hex(C.cyan)(` ${t} `))
+    .replace(/~~([^~]+)~~/g,         (_, t) => chalk.strikethrough.hex(C.subtle)(t))
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) =>
+      chalk.underline.hex(C.blue)(label) + chalk.hex(C.dim)(` (${url})`)
+    );
+};
+
+const splitTableRow = (row) => {
+  const s = String(row || '').trim();
+  if (!s.includes('|')) return [s];
+  const src = s.startsWith('|') ? s.slice(1) : s;
+  const body = src.endsWith('|') ? src.slice(0, -1) : src;
+  return body.split('|').map(c => c.trim());
+};
+
+const isMarkdownTableLine = (line) => {
+  const t = String(line || '').trim();
+  if (!t.includes('|')) return false;
+  const cells = splitTableRow(t);
+  return cells.length >= 2;
+};
+
+const isTableSeparatorLine = (line) => {
+  const cells = splitTableRow(line).filter(c => c.length > 0);
+  if (!cells.length) return false;
+  return cells.every(c => /^:?\s*-{3,}\s*:?$/.test(c));
+};
+
+const padAnsi = (text, width) => {
+  const pad = Math.max(0, width - visibleLen(text));
+  return text + ' '.repeat(pad);
+};
+
+const renderTableRows = (rows, maxWidth = 96) => {
+  if (!rows || !rows.length) return [];
+  const parsed = rows.map(r => splitTableRow(r));
+  const nonSep = parsed.filter((_, idx) => !isTableSeparatorLine(rows[idx]));
+  if (!nonSep.length) return [];
+
+  const colCount = Math.max(...nonSep.map(r => r.length));
+  const normalized = parsed.map(r => {
+    const out = r.slice(0, colCount);
+    while (out.length < colCount) out.push('');
+    return out;
+  });
+
+  const useUnicode = !FORCE_ASCII_TABLES;
+  const colSep = useUnicode ? ' │ ' : ' | ';
+  const rowSep = useUnicode ? '─┼─' : '-+-';
+  const rowFill = useUnicode ? '─' : '-';
+  const maxColWidth = Math.max(8, Math.floor((Math.max(60, maxWidth) - (colCount - 1) * colSep.length - 2) / colCount));
+  const widths = Array.from({ length: colCount }, () => 3);
+  for (const r of normalized) {
+    for (let i = 0; i < colCount; i++) {
+      const len = visibleLen(stripAnsi(renderInline(r[i] || '')));
+      widths[i] = Math.min(maxColWidth, Math.max(widths[i], len));
+    }
+  }
+
+  const widthBudget = Math.max(24, maxWidth - 2);
+  const totalWidth = () => widths.reduce((a, b) => a + b, 0) + (colCount - 1) * colSep.length + 2;
+  const minColWidth = 3;
+  while (totalWidth() > widthBudget) {
+    let idx = -1;
+    let best = -1;
+    for (let i = 0; i < widths.length; i++) {
+      if (widths[i] > minColWidth && widths[i] > best) { best = widths[i]; idx = i; }
+    }
+    if (idx < 0) break;
+    widths[idx] -= 1;
+  }
+
+  const fitCell = (raw, width) => {
+    const plain = stripAnsi(renderInline(raw || ''));
+    if (plain.length <= width) return plain;
+    if (width <= 1) return plain.slice(0, width);
+    return plain.slice(0, width - 1) + ELLIPSIS;
+  };
+
+  const out = [];
+  let sawHeader = false;
+  for (let rowIdx = 0; rowIdx < normalized.length; rowIdx++) {
+    const raw = rows[rowIdx];
+    if (isTableSeparatorLine(raw)) {
+      const sep = widths.map(w => rowFill.repeat(Math.max(3, w))).join(chalk.hex(C.border)(rowSep));
+      out.push(chalk.hex(C.border)('  ' + sep));
+      sawHeader = true;
+      continue;
+    }
+
+    const r = normalized[rowIdx];
+    const cells = r.map((cell, i) => {
+      const fitted = fitCell(cell || '', widths[i]);
+      const styled = !sawHeader && rowIdx === 0 ? chalk.bold.hex(C.cyan)(fitted) : chalk.hex(C.text)(fitted);
+      return padAnsi(styled, widths[i]);
+    });
+    out.push('  ' + cells.join(chalk.hex(C.border)(colSep)));
+  }
+
+  return out;
+};
+
+// ─── Syntax highlighter ───────────────────────────────────────
+const KEYWORDS_JS  = /\b(import|export|from|const|let|var|function|async|await|return|if|else|for|while|class|extends|new|try|catch|finally|throw|typeof|instanceof|null|undefined|true|false|void|switch|case|break|continue|default|of|in|do|yield|get|set|static|super)\b/g;
+const KEYWORDS_SH  = /\b(echo|sudo|apt|npm|pip|git|cd|ls|mkdir|rm|mv|cp|chmod|chown|systemctl|service|grep|awk|sed|cat|tail|head|curl|wget|ssh|scp|export|source|alias|if|then|fi|else|for|do|done|while|case|esac)\b/g;
+const KEYWORDS_PY  = /\b(def|class|import|from|as|return|if|elif|else|for|while|try|except|finally|with|lambda|yield|pass|break|continue|not|and|or|in|is|None|True|False|print|len|range)\b/g;
+
+export const highlightCode = (code, lang = '') => {
+  const l = lang.toLowerCase();
+  return code.split('\n').map(line => {
+    let out = line
+      // Strings
+      .replace(/("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g,
+        (_, s) => chalk.hex(C.green)(s))
+      // Numbers
+      .replace(/\b(\d+\.?\d*)\b/g, (_, n) => chalk.hex(C.amber)(n))
+      // Comments
+      .replace(/(\/\/.*|#.*)$/, (_, c) => chalk.hex(C.subtle)(c))
+      .replace(/(\/\*[\s\S]*?\*\/)/, (_, c) => chalk.hex(C.subtle)(c));
+
+    if (l === 'py' || l === 'python') {
+      out = out.replace(KEYWORDS_PY, (_, kw) => chalk.hex(C.blue)(kw));
+    } else if (l === 'sh' || l === 'bash' || l === 'shell' || l === 'zsh') {
+      out = out.replace(KEYWORDS_SH, (_, kw) => chalk.hex(C.cyan)(kw));
+    } else {
+      // JS/TS/JSX/TSX/JSON/default
+      out = out.replace(KEYWORDS_JS, (_, kw) => chalk.hex(C.blue)(kw));
+      out = out.replace(KEYWORDS_SH, (_, kw) => chalk.hex(C.cyan)(kw));
+    }
+    return out;
+  }).join('\n');
+};
+
+// ─── Full buffered markdown renderer ─────────────────────────
+export const renderMarkdown = (text) => {
+  // Strip raw ANSI sequences the LLM may have embedded in its output
+  const deAnsi = (text || '').replace(/\x1b\[[0-9;]*[mA-Za-z]/g, '').replace(/\x1b\][^\x1b]*\x1b\\/g, '');
+  const normalizedStructure = deAnsi
+    // ---### + optional text → big white dot divider (must precede HR+heading fusion)
+    .replace(/(^|\n)\s*-{3,}\s*#{3}\s*([^\n]*)/g, '$1__BIGDOT__$2')
+    // Fix fused horizontal-rule + heading, e.g. "---## Title" -> "## Title"
+    .replace(/(^|\n)\s*(?:-{3,}|\*{3,}|_{3,})\s*(#{1,4})\s*/g, '$1$2 ')
+    // Fix collapsed headings without space, e.g. "###Title" -> "### Title"
+    .replace(/(^|\n)(#{1,4})([^#\s\n])/g, '$1$2 $3');
+  const clean = stripToolXML(stripToolJSON(normalizedStructure));
+  if (!clean) return '';
+
+  const lines = clean.split('\n');
+  const output = [];
+  let inCode = false, codeLang = '', codeLines = [];
+  let inTable = false, tableRows = [];
+  const w = Math.min(process.stdout.columns || 96, 100);
+
+  const flushTable = () => {
+    if (!tableRows.length) return;
+    output.push(...renderTableRows(tableRows, w));
+    output.push('');
+    tableRows = []; inTable = false;
+  };
+
+  for (const rawLine of lines) {
+    // Code block toggle
+    const codeMatch = rawLine.match(/^```(\w*)/);
+    if (codeMatch) {
+      if (!inCode) {
+        inCode = true; codeLang = codeMatch[1] || ''; codeLines = [];
+        const label = codeLang ? chalk.bgHex(C.border).hex(C.cyan)(` ${codeLang} `) : '';
+        output.push(chalk.hex(C.border)('  ╭─') + (label || chalk.hex(C.border)('─')));
+      } else {
+        const highlighted = highlightCode(codeLines.join('\n'), codeLang);
+        for (const cl of highlighted.split('\n'))
+          output.push(chalk.hex(C.border)('  │ ') + cl);
+        output.push(chalk.hex(C.border)('  ╰────'));
+        inCode = false; codeLines = []; codeLang = '';
+      }
+      continue;
+    }
+    if (inCode) { codeLines.push(rawLine); continue; }
+
+    // Table
+    if (isMarkdownTableLine(rawLine)) {
+      inTable = true; tableRows.push(rawLine.trim()); continue;
+    } else if (inTable) flushTable();
+
+    // Big white dot divider: ---### [optional text]
+    const bigDot = rawLine.match(/(?:^\s*-{3,}\s*#{3}|^__BIGDOT__)\s*(.*)/);
+    if (bigDot) {
+      const text = bigDot[1].trim();
+      output.push('');
+      output.push(chalk.bold.hex(C.bright)('  ●') + (text ? ' ' + chalk.hex(C.bright)(renderInline(text)) : ''));
+      continue;
+    }
+
+    // Headings
+    const h1 = rawLine.match(/^# ?(.+)/);
+    if (h1) { output.push(''); output.push(chalk.bold.hex(C.blue)('  ━━ ') + chalk.bold.hex(C.bright)(renderInline(h1[1]))); output.push(chalk.hex(C.border)('  ' + '─'.repeat(Math.min(w - 4, 58)))); continue; }
+    const h2 = rawLine.match(/^## ?(.+)/);
+    if (h2) { output.push(''); output.push(chalk.bold.hex(C.cyan)('  ◆ ') + chalk.bold.hex(C.text)(renderInline(h2[1]))); continue; }
+    const h3 = rawLine.match(/^### ?(.+)/);
+    if (h3) { output.push(''); output.push(chalk.bold.hex(C.teal)('  ● ') + chalk.bold.hex(C.soft)(renderInline(h3[1]))); continue; }
+    const h4 = rawLine.match(/^#### ?(.+)/);
+    if (h4) { output.push(chalk.hex(C.subtle)('  › ') + chalk.italic.hex(C.soft)(renderInline(h4[1]))); continue; }
+
+    // HR
+    if (rawLine.match(/^[-*_]{3,}\s*$/)) { output.push(chalk.hex(C.border)('  ' + '─'.repeat(Math.min(w - 4, 60)))); continue; }
+
+    // Blockquote
+    const bq = rawLine.match(/^>\s*(.*)/);
+    if (bq) { output.push(chalk.hex(C.border)('  ┃ ') + chalk.italic.hex(C.soft)(renderInline(bq[1]))); continue; }
+
+    // Lists
+    const num = rawLine.match(/^(\s*)(\d+)\.\s+(.*)/);
+    if (num) { const [, ind, n, c] = num; const lv = Math.floor(ind.length / 2); output.push('  '.repeat(lv + 1) + chalk.hex(C.blue)(n + '.') + ' ' + renderInline(c)); continue; }
+    const ul = rawLine.match(/^(\s*)[-*•]\s+(.*)/);
+    if (ul) { const [, ind, c] = ul; const lv = Math.floor(ind.length / 2); const b = lv === 0 ? chalk.hex(C.emerald)('•') : lv === 1 ? chalk.hex(C.cyan)('◦') : chalk.hex(C.subtle)('▸'); output.push('  '.repeat(lv + 1) + b + ' ' + renderInline(c)); continue; }
+
+    // Empty line
+    if (!rawLine.trim()) { output.push(''); continue; }
+
+    // Normal text
+    output.push('  ' + renderInline(rawLine));
+  }
+
+  if (inTable) flushTable();
+  if (inCode && codeLines.length > 0) {
+    for (const cl of codeLines) output.push(chalk.hex(C.border)('  │ ') + chalk.hex(C.text)(cl));
+    output.push(chalk.hex(C.border)('  ╰────'));
+  }
+
+  return output.join('\n');
+};
+
+// ─── StreamMarkdown — stateful streaming renderer ─────────────
+// Usage:
+//   const sm = new StreamMarkdown();
+//   sm.push(chunk)   → returns string to print immediately
+//   sm.flush()       → returns remaining buffered content
+//   sm.reset()       → clears state for next message
+//
+// Handles:
+//   - Code blocks accumulate until closing ``` then render fully
+//   - Bold/italic rendered when markers are complete (no half-markers)
+//   - Headings, lists, blockquotes rendered line-by-line
+//   - Tool JSON swallowed silently
+
+export class StreamMarkdown {
+  constructor() { this.reset(); }
+
+  reset() {
+    this._buf        = '';   // incomplete current line buffer
+    this._inCode     = false;
+    this._codeLang   = '';
+    this._codeLines  = [];
+    this._codeHeader = '';   // the ╭─ line printed when code starts
+    this._jsonBuf    = '';
+    this._inJson     = false;
+    this._jsonDepth  = 0;
+    this._xmlToolBuf = '';
+    this._inXmlTool  = false;
+    this._inTable    = false;
+    this._tableRows  = [];
+  }
+
+  push(chunk) {
+    // Swallow tool JSON silently
+    let out = '';
+    // Normalize "###Title" → "### Title" and "##Title" → "## Title" before buffering
+    const normalized = chunk
+      // ---### + optional text → big white dot divider (must precede HR+heading fusion)
+      .replace(/(^|\n)\s*-{3,}\s*#{3}\s*([^\n]*)/g, '$1__BIGDOT__$2')
+      // Fix fused HR + heading in stream chunks: "---## Title" -> "## Title"
+      .replace(/(^|\n)\s*(?:-{3,}|\*{3,}|_{3,})\s*(#{1,4})\s*/g, '$1$2 ')
+      // Fix collapsed heading spacing
+      .replace(/(^|\n)(#{1,4})([^#\s\n])/g, '$1$2 $3');
+    this._buf += normalized;
+
+    // Process complete lines
+    const lines = this._buf.split('\n');
+    this._buf = lines.pop() ?? '';
+
+    for (const line of lines) out += this._processLine(line + '\n');
+    return out;
+  }
+
+  flush() {
+    let out = '';
+    if (this._buf.trim() && this._inTable && isMarkdownTableLine(this._buf)) {
+      this._tableRows.push(this._buf.trim());
+      this._buf = '';
+    }
+    if (this._inTable && this._tableRows.length) {
+      out += this._flushTable();
+    }
+    if (this._inCode && this._buf) {
+      this._codeLines.push(this._buf);
+      this._buf = '';
+    }
+    if (this._inCode && this._codeLines.length) {
+      // Close unclosed code block
+      const highlighted = highlightCode(this._codeLines.join('\n'), this._codeLang);
+      for (const cl of highlighted.split('\n'))
+        out += chalk.hex(C.border)('  │ ') + cl + '\n';
+      out += chalk.hex(C.border)('  ╰────') + '\n';
+    } else if (this._buf.trim()) {
+      out += this._renderLine(this._buf);
+    }
+    this.reset();
+    return out;
+  }
+
+  _processLine(line) {
+    const raw = line.replace(/\n$/, '');
+
+    if (this._inTable && !isMarkdownTableLine(raw)) {
+      const rendered = this._flushTable();
+      if (!raw.trim()) return rendered;
+      return rendered + this._renderLine(raw) + '\n';
+    }
+
+    // Tool JSON detection — swallow silently
+    if (this._inJson) {
+      this._jsonBuf += raw;
+      this._jsonDepth += (raw.match(/{/g)||[]).length - (raw.match(/}/g)||[]).length;
+      if (this._jsonDepth <= 0) { this._inJson = false; this._jsonBuf = ''; }
+      return '';
+    }
+    if (raw.trim().match(/^\{"tool"\s*:/)) {
+      this._inJson = true;
+      this._jsonBuf = raw;
+      this._jsonDepth = (raw.match(/{/g)||[]).length - (raw.match(/}/g)||[]).length;
+      if (this._jsonDepth <= 0) { this._inJson = false; this._jsonBuf = ''; }
+      return '';
+    }
+
+    // Tool XML detection — swallow silently
+    if (this._inXmlTool) {
+      this._xmlToolBuf += raw;
+      if (raw.includes('/>') || raw.includes('</tool>')) { this._inXmlTool = false; this._xmlToolBuf = ''; }
+      return '';
+    }
+    if (raw.trim().startsWith('<tool') && (raw.includes('/>') || raw.includes('</tool>'))) {
+      return '';
+    }
+    if (raw.trim().startsWith('<tool')) {
+      this._inXmlTool = true;
+      this._xmlToolBuf = raw;
+      return '';
+    }
+    // Strip completion signals
+    if (/^\s*\[(DONE|INCOMPLETE|BLOCKED|TOOL_CALL|TOOL_RESULT)\]/.test(raw)) return '';
+
+    // Code block
+    const codeMatch = raw.match(/^```(\w*)/);
+    if (codeMatch) {
+      if (!this._inCode) {
+        this._inCode = true; this._codeLang = codeMatch[1] || ''; this._codeLines = [];
+        const label = this._codeLang ? chalk.bgHex(C.border).hex(C.cyan)(` ${this._codeLang} `) : '';
+        return chalk.hex(C.border)('  ╭─') + (label || chalk.hex(C.border)('─')) + '\n';
+      } else {
+        const highlighted = highlightCode(this._codeLines.join('\n'), this._codeLang);
+        let out = '';
+        for (const cl of highlighted.split('\n')) out += chalk.hex(C.border)('  │ ') + cl + '\n';
+        out += chalk.hex(C.border)('  ╰────') + '\n';
+        this._inCode = false; this._codeLines = []; this._codeLang = '';
+        return out;
+      }
+    }
+    if (this._inCode) { this._codeLines.push(raw); return ''; }
+
+    if (isMarkdownTableLine(raw)) {
+      this._inTable = true;
+      this._tableRows.push(raw.trim());
+      return '';
+    }
+
+    return this._renderLine(raw) + '\n';
+  }
+
+  _flushTable() {
+    if (!this._tableRows.length) {
+      this._inTable = false;
+      return '';
+    }
+    const w = Math.min(process.stdout.columns || 96, 100);
+    const lines = renderTableRows(this._tableRows, w);
+    this._tableRows = [];
+    this._inTable = false;
+    return lines.length ? lines.join('\n') + '\n' : '';
+  }
+
+  _renderLine(line) {
+    if (!line.trim()) return '';
+
+    // Big white dot divider: ---### [optional text]
+    const bigDot = line.match(/(?:^\s*-{3,}\s*#{3}|^__BIGDOT__)\s*(.*)/);
+    if (bigDot) {
+      const text = bigDot[1].trim();
+      return '\n' + chalk.bold.hex(C.bright)('  ●') + (text ? ' ' + chalk.hex(C.bright)(renderInline(text)) : '') + '\n';
+    }
+
+    // Headings — support both "## Title" and "##Title" (no space)
+    const h1 = line.match(/^# ?(.+)/); if (h1) return '\n' + chalk.bold.hex(C.blue)('  ━━ ') + chalk.bold.hex(C.bright)(renderInline(h1[1])) + '\n' + chalk.hex(C.border)('  ' + '─'.repeat(56));
+    const h2 = line.match(/^## ?(.+)/); if (h2) return '\n' + chalk.bold.hex(C.cyan)('  ◆ ') + chalk.bold(renderInline(h2[1]));
+    const h3 = line.match(/^### ?(.+)/); if (h3) return '\n' + chalk.bold.hex(C.teal)('  ● ') + chalk.hex(C.soft)(renderInline(h3[1]));
+    const h4 = line.match(/^#### ?(.+)/); if (h4) return chalk.hex(C.subtle)('  › ') + chalk.italic.hex(C.soft)(renderInline(h4[1]));
+
+    // HR
+    if (line.match(/^[-*_]{3,}\s*$/)) return chalk.hex(C.border)('  ' + '─'.repeat(56));
+
+    // Blockquote
+    const bq = line.match(/^>\s*(.*)/); if (bq) return chalk.hex(C.border)('  ┃ ') + chalk.italic.hex(C.soft)(renderInline(bq[1]));
+
+    // Lists
+    const num = line.match(/^(\s*)(\d+)\.\s+(.*)/);
+    if (num) { const [, ind, n, c] = num; const lv = Math.floor(ind.length / 2); return '  '.repeat(lv + 1) + chalk.hex(C.blue)(n + '.') + ' ' + renderInline(c); }
+    const ul = line.match(/^(\s*)[-*•]\s+(.*)/);
+    if (ul) { const [, ind, c] = ul; const lv = Math.floor(ind.length / 2); const b = lv === 0 ? chalk.hex(C.emerald)('•') : lv === 1 ? chalk.hex(C.cyan)('◦') : chalk.hex(C.subtle)('▸'); return '  '.repeat(lv + 1) + b + ' ' + renderInline(c); }
+
+    return '  ' + renderInline(line);
+  }
+}
+
+// ─── Legacy export (kept for compatibility) ───────────────────
+export const renderMarkdownChunk = (chunk) => {
+  try {
+    const sm = new StreamMarkdown();
+    return sm.push(chunk) + sm.flush();
+  } catch { return chunk; }
+};

package/src/parser/stream.js

@@ -0,0 +1,96 @@
+import { EventEmitter } from 'events';
+
+/**
+ * StreamParser — parses the raw SSE text stream from the server.
+ *
+ * Emits:
+ *   'tool_call'      — a complete JSON tool call object
+ *   'markdown_chunk' — a string of markdown/text to render
+ */
+export class StreamParser extends EventEmitter {
+  constructor() {
+    super();
+    this.buffer = '';
+    this.jsonBuffer = '';
+    this.inJsonBlock = false;
+    this.braceDepth = 0;
+  }
+
+  process(chunk) {
+    this.buffer += chunk;
+    this._parseBuffer();
+  }
+
+  _parseBuffer() {
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+    for (const line of lines) this._processLine(line);
+  }
+
+  _processLine(line) {
+    const trimmed = line.trim();
+
+    // Detect start of a JSON tool-call block
+    if (!this.inJsonBlock && trimmed.startsWith('{"tool"')) {
+      this.inJsonBlock = true;
+      this.jsonBuffer = trimmed;
+      this.braceDepth =
+        (trimmed.match(/{/g) || []).length - (trimmed.match(/}/g) || []).length;
+      if (this.braceDepth <= 0) {
+        this._tryFlushJson();
+      }
+      return;
+    }
+
+    if (this.inJsonBlock) {
+      this.jsonBuffer += ' ' + trimmed;
+      this.braceDepth +=
+        (trimmed.match(/{/g) || []).length - (trimmed.match(/}/g) || []).length;
+      if (this.braceDepth <= 0) {
+        this._tryFlushJson();
+      }
+      return;
+    }
+
+    // Regular markdown text
+    if (line) this.emit('markdown_chunk', line + '\n');
+  }
+
+  _tryFlushJson() {
+    try {
+      const toolCall = JSON.parse(this.jsonBuffer);
+      // Accept ANY object with a "tool" key — no hardcoded list
+      if (toolCall.tool) {
+        this.emit('tool_call', toolCall);
+      } else {
+        this.emit('markdown_chunk', this.jsonBuffer + '\n');
+      }
+    } catch {
+      this.emit('markdown_chunk', this.jsonBuffer + '\n');
+    } finally {
+      this.inJsonBlock = false;
+      this.jsonBuffer = '';
+      this.braceDepth = 0;
+    }
+  }
+
+  flush() {
+    if (this.inJsonBlock && this.jsonBuffer) {
+      this.emit('markdown_chunk', this.jsonBuffer);
+      this.jsonBuffer = '';
+      this.inJsonBlock = false;
+      this.braceDepth = 0;
+    }
+    if (this.buffer) {
+      this.emit('markdown_chunk', this.buffer);
+      this.buffer = '';
+    }
+  }
+
+  reset() {
+    this.buffer = '';
+    this.jsonBuffer = '';
+    this.inJsonBlock = false;
+    this.braceDepth = 0;
+  }
+}