npm - onbuzz - Versions diffs - 4.1.0 → 4.2.0 - Mend

onbuzz 4.1.0 → 4.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (967) hide show

package/src/interfaces/webServer.js CHANGED Viewed

@@ -192,13 +192,19 @@ const SCHEDULER_VIEWER_HTML = `<!doctype html>
     // (finish_reason, has tool calls, has reasoning, model).
     const chip = '<span class="chip ' + cls + '" title="first at ' + esc(new Date(e.firstAt).toISOString()) + '">' + e.count + 'x / ' + fmtMs(elapsedMs) + '</span>';
     if (!lastSample) return chip;
+    // NB: the newline in .join below is double-escaped on purpose. This
+    // whole block is inside a JS template literal (SCHEDULER_VIEWER_HTML),
+    // so a single-escaped newline sequence would be processed at server
+    // load time, yielding a literal newline inside a single-quoted string
+    // in the served JS — which the browser rejects. Same trick in
+    // fmtModeCell below.
     const sampleDetail = samples.map(s =>
       s.at + ': content=' + s.contentType + '(' + s.contentLength + ') ' +
       'tools=' + (s.hasToolCalls ? s.toolCallCount : 0) + ' ' +
       'reasoning=' + (s.hasReasoning ? 'yes' : 'no') + ' ' +
       'finish=' + (s.finishReason || '—') + ' ' +
       'model=' + (s.model || '—')
-    ).join('\n');
+    ).join('\\n');
     return chip +
       '<div class="tasks-line" title="' + esc(sampleDetail) + '">' +
         esc(lastSample.hint || '(empty response — cause unknown)') +
@@ -223,10 +229,13 @@ const SCHEDULER_VIEWER_HTML = `<!doctype html>
     const last = history[history.length - 1];
     const age = Date.now() - new Date(last.at).getTime();
     // Build a title tooltip with the last ~5 transitions as a plain-text list.
+    // See note above (chipEmpty): double-escape in the .join is intentional
+    // — the outer template literal would otherwise process a single-escape
+    // newline into a real newline at load time.
     const historyTip = history.slice(-5).reverse().map(t => {
       const ageT = Date.now() - new Date(t.at).getTime();
       return fmtMs(ageT) + ' ago: ' + t.from + ' → ' + t.to + ' — ' + t.humanReason;
-    }).join('\n');
+    }).join('\\n');
     const direction = last.from + ' → ' + last.to;
     return current +
       '<div class="tasks-line" title="' + esc(historyTip) + '">' +
@@ -2694,6 +2703,137 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       }
     });
+    // Gallery: list generated images across all agent working directories.
+    // Scans each agent's `{workingDirectory}/images/` folder for image files
+    // (the convention set by imageTool.js which always saves under `images/`).
+    // Returns { images: [{ filename, agentId, agentName, projectDir, mtime,
+    // size, url }] } sorted newest-first. Deliberately light on metadata —
+    // prompts/model info aren't persisted as sidecar data today; that would
+    // be a separate feature requiring imageTool to write a .json next to each
+    // output. For now the filename carries the timestamp.
+    this.app.get('/api/images', async (req, res) => {
+      try {
+        if (!this.orchestrator?.agentPool) {
+          return res.json({ success: true, images: [] });
+        }
+        const requestedAgentId = req.query.agentId || null;
+        const agents = await this.orchestrator.agentPool.getAllAgents();
+        const results = [];
+        const seen = new Set(); // dedupe by absolute path
+        const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif']);
+        for (const agent of (agents instanceof Map ? Array.from(agents.values()) : agents)) {
+          if (requestedAgentId && agent.id !== requestedAgentId) continue;
+          const workDir = agent.directoryAccess?.workingDirectory || agent.projectDir;
+          if (!workDir) continue;
+          const imagesDir = path.join(workDir, 'images');
+          let entries;
+          try {
+            entries = await fs.readdir(imagesDir);
+          } catch {
+            continue; // no images/ dir
+          }
+          for (const name of entries) {
+            const ext = path.extname(name).toLowerCase();
+            if (!IMAGE_EXTS.has(ext)) continue;
+            const abs = path.join(imagesDir, name);
+            if (seen.has(abs)) continue;
+            seen.add(abs);
+            let stat;
+            try { stat = await fs.stat(abs); } catch { continue; }
+            if (!stat.isFile()) continue;
+            // Pick a session id for the URL builder — prefer the agent's
+            // current session, otherwise any active session.
+            const anySession = Array.from(this.sessions.values())[0];
+            const sessionId = agent.sessionId || anySession?.sessionId || 'web-session';
+            results.push({
+              filename: name,
+              agentId: agent.id,
+              agentName: agent.name,
+              projectDir: workDir,
+              mtime: stat.mtime.toISOString(),
+              size: stat.size,
+              url: `/api/images/${encodeURIComponent(sessionId)}/${encodeURIComponent(name)}`,
+            });
+          }
+        }
+        results.sort((a, b) => b.mtime.localeCompare(a.mtime));
+        res.json({ success: true, images: results });
+      } catch (error) {
+        this.logger.error('Gallery list failed', { error: error.message });
+        res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({
+          success: false,
+          error: error.message,
+        });
+      }
+    });
+    // Delete a generated image. Identified by (agentId, filename) — we look
+    // up the agent's working directory and unlink the file there. Refuses
+    // path-traversal attempts and only deletes files matching an image
+    // extension from an `images/` folder we expect.
+    this.app.delete('/api/images', async (req, res) => {
+      try {
+        const { agentId, filename } = req.query;
+        if (!agentId || !filename) {
+          return res.status(HTTP_STATUS.BAD_REQUEST).json({
+            success: false,
+            error: 'agentId and filename are required',
+          });
+        }
+        const normalized = path.basename(filename);
+        if (normalized !== filename || filename.includes('..')) {
+          return res.status(HTTP_STATUS.BAD_REQUEST).json({
+            success: false,
+            error: 'Invalid filename',
+          });
+        }
+        const ext = path.extname(normalized).toLowerCase();
+        if (!['.png', '.jpg', '.jpeg', '.webp', '.gif'].includes(ext)) {
+          return res.status(HTTP_STATUS.BAD_REQUEST).json({
+            success: false,
+            error: 'Unsupported file extension for gallery delete',
+          });
+        }
+        if (!this.orchestrator?.agentPool) {
+          return res.status(HTTP_STATUS.SERVICE_UNAVAILABLE).json({
+            success: false,
+            error: 'Agent pool not available',
+          });
+        }
+        const agent = await this.orchestrator.agentPool.getAgent(agentId);
+        if (!agent) {
+          return res.status(HTTP_STATUS.NOT_FOUND).json({
+            success: false,
+            error: 'Agent not found',
+          });
+        }
+        const workDir = agent.directoryAccess?.workingDirectory || agent.projectDir;
+        if (!workDir) {
+          return res.status(HTTP_STATUS.BAD_REQUEST).json({
+            success: false,
+            error: 'Agent has no working directory',
+          });
+        }
+        const target = path.join(workDir, 'images', normalized);
+        await fs.unlink(target);
+        this.logger.info('Gallery image deleted', { agentId, filename: normalized });
+        res.json({ success: true });
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          return res.status(HTTP_STATUS.NOT_FOUND).json({
+            success: false,
+            error: 'Image not found',
+          });
+        }
+        this.logger.error('Gallery delete failed', { error: error.message });
+        res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({
+          success: false,
+          error: error.message,
+        });
+      }
+    });
     // Video serving endpoint for generated videos
     this.app.get('/api/videos/:sessionId/:filename', async (req, res) => {
       try {

package/src/services/__tests__/agentActivityService.test.js CHANGED Viewed

@@ -315,5 +315,88 @@ describe('agentActivityService', () => {
       expect(result.skip).toBe(false);
       expect(result.reason).toBeNull();
     });
+    // Belt-and-suspenders: inbound work always beats delay/pause. The
+    // primary fix lives in agentPool._wakeAgentForMessage — this is the
+    // second line of defence against any path that bypasses it.
+    test('delayed agent with queued user message does NOT skip', () => {
+      const future = new Date(Date.now() + 60_000).toISOString();
+      const agent = makeAgent({
+        delayEndTime: future,
+        messageQueues: { userMessages: [{ content: 'hi' }], interAgentMessages: [], toolResults: [] },
+      });
+      expect(shouldSkipIteration(agent).skip).toBe(false);
+    });
+    test('delayed agent with queued inter-agent message does NOT skip', () => {
+      const future = new Date(Date.now() + 60_000).toISOString();
+      const agent = makeAgent({
+        delayEndTime: future,
+        messageQueues: { userMessages: [], interAgentMessages: [{ content: 'ping' }], toolResults: [] },
+      });
+      expect(shouldSkipIteration(agent).skip).toBe(false);
+    });
+    test('delayed agent with queued tool result does NOT skip', () => {
+      const future = new Date(Date.now() + 60_000).toISOString();
+      const agent = makeAgent({
+        delayEndTime: future,
+        messageQueues: { userMessages: [], interAgentMessages: [], toolResults: [{ toolId: 'x', status: 'completed' }] },
+      });
+      expect(shouldSkipIteration(agent).skip).toBe(false);
+    });
+    test('paused-until agent with queued message does NOT skip', () => {
+      const future = new Date(Date.now() + 60_000).toISOString();
+      const agent = makeAgent({
+        pausedUntil: future,
+        messageQueues: { userMessages: [{ content: 'hi' }], interAgentMessages: [], toolResults: [] },
+      });
+      expect(shouldSkipIteration(agent).skip).toBe(false);
+    });
+  });
+  describe('shouldAgentBeActive — inbound work overrides delay/pause', () => {
+    test('delayed agent with user message → active', () => {
+      const future = new Date(Date.now() + 60_000).toISOString();
+      const agent = makeAgent({
+        delayEndTime: future,
+        messageQueues: { userMessages: [{ content: 'hi' }], interAgentMessages: [], toolResults: [] },
+        taskList: { tasks: [{ status: 'pending' }] },
+      });
+      expect(shouldAgentBeActive(agent).active).toBe(true);
+    });
+    test('delayed agent with inter-agent message → active', () => {
+      const future = new Date(Date.now() + 60_000).toISOString();
+      const agent = makeAgent({
+        delayEndTime: future,
+        messageQueues: { userMessages: [], interAgentMessages: [{ content: 'ping' }], toolResults: [] },
+        taskList: { tasks: [{ status: 'pending' }] },
+      });
+      expect(shouldAgentBeActive(agent).active).toBe(true);
+    });
+    test('pausedUntil agent (status=active) with queued work → active', () => {
+      // Unusual but defensive: status still ACTIVE but pausedUntil set
+      const future = new Date(Date.now() + 60_000).toISOString();
+      const agent = makeAgent({
+        pausedUntil: future,
+        messageQueues: { userMessages: [], interAgentMessages: [{ content: 'ping' }], toolResults: [] },
+        taskList: { tasks: [{ status: 'pending' }] },
+      });
+      expect(shouldAgentBeActive(agent).active).toBe(true);
+    });
+    test('delayed agent WITHOUT queued work → still inactive (delay honoured)', () => {
+      const future = new Date(Date.now() + 60_000).toISOString();
+      const agent = makeAgent({
+        delayEndTime: future,
+        messageQueues: { userMessages: [], interAgentMessages: [], toolResults: [] },
+      });
+      const r = shouldAgentBeActive(agent);
+      expect(r.active).toBe(false);
+      expect(r.reason).toBe('agent-delayed');
+    });
   });
 });

package/src/services/__tests__/aiService.reasoningTokens.test.js ADDED Viewed

@@ -0,0 +1,66 @@
+/**
+ * Tests for _extractReasoningTokens — pulls a reasoning-token count out
+ * of a provider's `usage` block regardless of which schema the provider
+ * chose. Surfaced even for opaque providers (OpenAI o-series) that don't
+ * return reasoning content text — the count alone is useful signal.
+ */
+import { describe, test, expect } from '@jest/globals';
+import { _extractReasoningTokens } from '../aiService.js';
+describe('_extractReasoningTokens', () => {
+  test('returns null for null/undefined/non-object', () => {
+    expect(_extractReasoningTokens(null)).toBeNull();
+    expect(_extractReasoningTokens(undefined)).toBeNull();
+    expect(_extractReasoningTokens('{}')).toBeNull();
+    expect(_extractReasoningTokens(42)).toBeNull();
+  });
+  test('returns null when no reasoning tokens fields present', () => {
+    expect(_extractReasoningTokens({ prompt_tokens: 100, completion_tokens: 50 })).toBeNull();
+  });
+  test('OpenAI shape: completion_tokens_details.reasoning_tokens', () => {
+    const usage = {
+      prompt_tokens: 100,
+      completion_tokens: 200,
+      completion_tokens_details: { reasoning_tokens: 150 },
+    };
+    expect(_extractReasoningTokens(usage)).toBe(150);
+  });
+  test('Flat shape: usage.reasoning_tokens', () => {
+    expect(_extractReasoningTokens({ reasoning_tokens: 512 })).toBe(512);
+  });
+  test('Anthropic-style shape: output_tokens_details.reasoning_tokens', () => {
+    expect(_extractReasoningTokens({
+      output_tokens_details: { reasoning_tokens: 4217 }
+    })).toBe(4217);
+  });
+  test('camelCase variant: completionTokensDetails.reasoningTokens', () => {
+    expect(_extractReasoningTokens({
+      completionTokensDetails: { reasoningTokens: 1024 }
+    })).toBe(1024);
+  });
+  test('preference order — flat reasoning_tokens wins when multiple present', () => {
+    // Not a provider we expect, but defensive: if both are set, the
+    // flattened top-level field is first in the candidate list.
+    expect(_extractReasoningTokens({
+      reasoning_tokens: 100,
+      completion_tokens_details: { reasoning_tokens: 999 },
+    })).toBe(100);
+  });
+  test('zero is a valid count, not null', () => {
+    expect(_extractReasoningTokens({ reasoning_tokens: 0 })).toBe(0);
+  });
+  test('non-finite values are skipped (defensive against NaN/Infinity)', () => {
+    expect(_extractReasoningTokens({ reasoning_tokens: NaN })).toBeNull();
+    expect(_extractReasoningTokens({ reasoning_tokens: Infinity })).toBeNull();
+    expect(_extractReasoningTokens({ reasoning_tokens: 'lots' })).toBeNull();
+  });
+});

package/src/services/__tests__/aiService.stream.test.js ADDED Viewed

@@ -0,0 +1,301 @@
+/**
+ * CLI ingestion contract test — consumes the exact SSE bytes that
+ * autopilot-backend's `/llm/chat` route emits (locked in backend's
+ * `routes/__tests__/llm.chat.reasoning.test.js`) and asserts that the
+ * resulting response object carries content, reasoning, and reasoning
+ * tokens correctly.
+ *
+ * Why this exists: the feature spans two repos. Per-repo tests prove
+ * each side holds its own assumption. This one proves they share the
+ * SAME wire contract: backend emissions parse correctly on the CLI
+ * side. If either drifts in the future, this tripwire catches it BEFORE
+ * "works in dev, broken in prod."
+ *
+ * The tested function (`_parseSSEResponseStream`) is the real production
+ * parser used by `_makeStreamingAPIRequest` — it's not a test double.
+ * Production and tests share a single implementation, so passing tests
+ * mean passing production.
+ */
+import { describe, test, expect } from '@jest/globals';
+import { _parseSSEResponseStream } from '../aiService.js';
+/**
+ * Build a fake ReadableStream-default-reader over a series of Uint8Array
+ * chunks. Mirrors what `response.body.getReader()` returns in production,
+ * but with caller-controlled bytes.
+ */
+function makeReader(chunks) {
+  let i = 0;
+  return {
+    async read() {
+      if (i >= chunks.length) return { done: true, value: undefined };
+      const value = typeof chunks[i] === 'string'
+        ? new TextEncoder().encode(chunks[i])
+        : chunks[i];
+      i++;
+      return { done: false, value };
+    },
+  };
+}
+/**
+ * Build an SSE frame string. Backend emits these via
+ * `data: ${JSON.stringify(event)}\n\n`.
+ */
+function sse(event) {
+  return `data: ${JSON.stringify(event)}\n\n`;
+}
+// ────────────────────────────────────────────────────────────────────────
+// Backward compat — plain content-only stream
+// ────────────────────────────────────────────────────────────────────────
+describe('_parseSSEResponseStream — backward compat (no reasoning)', () => {
+  test('plain chunk + done stream returns content only, reasoning empty', async () => {
+    const chunks = [
+      sse({ type: 'start', model: 'gpt-4o' }),
+      sse({ type: 'chunk', content: 'Hello ' }),
+      sse({ type: 'chunk', content: 'world.' }),
+      sse({ type: 'done', content: 'Hello world.',
+            usage: { input_tokens: 10, output_tokens: 5, total_tokens: 15 },
+            model: 'gpt-4o', finishReason: 'stop' }),
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks), { fallbackModel: 'gpt-4o' });
+    expect(result.content).toBe('Hello world.');
+    expect(result.reasoning).toBe('');
+    expect(result.reasoningTokens).toBeNull();
+    expect(result.usage).toEqual({ input_tokens: 10, output_tokens: 5, total_tokens: 15 });
+    expect(result.model).toBe('gpt-4o');
+    expect(result.finishReason).toBe('stop');
+  });
+  test('onChunk callback fires per chunk in order', async () => {
+    const chunks = [
+      sse({ type: 'chunk', content: 'a' }),
+      sse({ type: 'chunk', content: 'b' }),
+      sse({ type: 'chunk', content: 'c' }),
+      sse({ type: 'done', usage: null, model: 'x', finishReason: 'stop' }),
+    ];
+    const captured = [];
+    await _parseSSEResponseStream(makeReader(chunks), { onChunk: (c) => captured.push(c) });
+    expect(captured).toEqual(['a', 'b', 'c']);
+  });
+});
+// ────────────────────────────────────────────────────────────────────────
+// Reasoning — full content path (DeepSeek / Kimi / xAI / Claude-thinking)
+// ────────────────────────────────────────────────────────────────────────
+describe('_parseSSEResponseStream — reasoning accumulation', () => {
+  test('interleaved reasoning_chunk + chunk accumulate into separate fields', async () => {
+    const chunks = [
+      sse({ type: 'reasoning_chunk', content: 'Let me think...' }),
+      sse({ type: 'chunk', content: 'Answer: ' }),
+      sse({ type: 'reasoning_chunk', content: ' still checking.' }),
+      sse({ type: 'chunk', content: '42.' }),
+      sse({ type: 'done', content: 'Answer: 42.',
+            usage: {
+              input_tokens: 10, output_tokens: 50, total_tokens: 60,
+              reasoning_tokens: 40,
+            },
+            model: 'DeepSeek-R1-0528', finishReason: 'stop' }),
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.content).toBe('Answer: 42.');
+    expect(result.reasoning).toBe('Let me think... still checking.');
+    expect(result.reasoningTokens).toBe(40);
+    expect(result.model).toBe('DeepSeek-R1-0528');
+  });
+  test('onReasoningChunk callback fires separately from onChunk', async () => {
+    const chunks = [
+      sse({ type: 'reasoning_chunk', content: 'thinking' }),
+      sse({ type: 'chunk', content: 'answer' }),
+      sse({ type: 'done', usage: null, model: 'x', finishReason: 'stop' }),
+    ];
+    const texts = [];
+    const reasons = [];
+    await _parseSSEResponseStream(makeReader(chunks), {
+      onChunk: (c) => texts.push(c),
+      onReasoningChunk: (c) => reasons.push(c),
+    });
+    expect(texts).toEqual(['answer']);
+    expect(reasons).toEqual(['thinking']);
+  });
+  test('backend-batched reasoning on done event is used when no reasoning_chunk events arrived', async () => {
+    const chunks = [
+      sse({ type: 'chunk', content: 'answer' }),
+      sse({ type: 'done', content: 'answer', reasoning: 'batched thinking trace',
+            usage: { input_tokens: 10, output_tokens: 30, reasoning_tokens: 25, total_tokens: 40 },
+            model: 'x', finishReason: 'stop' }),
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.reasoning).toBe('batched thinking trace');
+    expect(result.reasoningTokens).toBe(25);
+  });
+  test('streamed reasoning beats done.reasoning when both present', async () => {
+    // Belt-and-suspenders backends might send both. Prefer the streamed
+    // accumulation (it's what the caller's onReasoningChunk saw).
+    const chunks = [
+      sse({ type: 'reasoning_chunk', content: 'streamed' }),
+      sse({ type: 'chunk', content: 'ok' }),
+      sse({ type: 'done', reasoning: 'batched', usage: null, model: 'x', finishReason: 'stop' }),
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.reasoning).toBe('streamed');
+  });
+});
+// ────────────────────────────────────────────────────────────────────────
+// OpenAI o-series — reasoning_tokens count without content text
+// ────────────────────────────────────────────────────────────────────────
+describe('_parseSSEResponseStream — opaque reasoning (count-only)', () => {
+  test('reasoning_tokens in done.usage but no reasoning_chunk events → reasoning="" + count', async () => {
+    const chunks = [
+      sse({ type: 'chunk', content: 'Final answer.' }),
+      sse({ type: 'done', content: 'Final answer.',
+            usage: {
+              input_tokens: 10, output_tokens: 100, total_tokens: 110,
+              reasoning_tokens: 85,
+            },
+            model: 'o3', finishReason: 'stop' }),
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.reasoning).toBe('');
+    expect(result.reasoningTokens).toBe(85);
+    expect(result.content).toBe('Final answer.');
+  });
+  test('reasoning_tokens in the completion_tokens_details alt shape also extracts', async () => {
+    const chunks = [
+      sse({ type: 'chunk', content: 'answer' }),
+      sse({ type: 'done', usage: {
+        input_tokens: 10, output_tokens: 50, total_tokens: 60,
+        completion_tokens_details: { reasoning_tokens: 40 },
+      }, model: 'x', finishReason: 'stop' }),
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.reasoningTokens).toBe(40);
+  });
+});
+// ────────────────────────────────────────────────────────────────────────
+// Robustness — chunking boundaries, malformed frames, errors
+// ────────────────────────────────────────────────────────────────────────
+describe('_parseSSEResponseStream — robustness', () => {
+  test('SSE frames split across TCP chunks at arbitrary byte positions still parse correctly', async () => {
+    // Assemble one big SSE stream, then slice it at weird positions.
+    const full =
+      sse({ type: 'reasoning_chunk', content: 'Hmm.' }) +
+      sse({ type: 'chunk', content: 'Answer.' }) +
+      sse({ type: 'done', content: 'Answer.',
+            usage: { input_tokens: 5, output_tokens: 5, total_tokens: 10, reasoning_tokens: 3 },
+            model: 'x', finishReason: 'stop' });
+    // Split into 7-byte chunks (nothing magical — small enough to cross event boundaries).
+    const chunks = [];
+    for (let i = 0; i < full.length; i += 7) chunks.push(full.slice(i, i + 7));
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.content).toBe('Answer.');
+    expect(result.reasoning).toBe('Hmm.');
+    expect(result.reasoningTokens).toBe(3);
+  });
+  test('malformed JSON data frames are skipped without crashing', async () => {
+    const chunks = [
+      'data: this-is-not-json\n\n',
+      sse({ type: 'chunk', content: 'real' }),
+      sse({ type: 'done', usage: null, model: 'x', finishReason: 'stop' }),
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.content).toBe('real');
+  });
+  test('[DONE] sentinel is ignored (SSE end-of-stream marker convention)', async () => {
+    const chunks = [
+      sse({ type: 'chunk', content: 'hi' }),
+      sse({ type: 'done', content: 'hi', usage: null, model: 'x', finishReason: 'stop' }),
+      'data: [DONE]\n\n',
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.content).toBe('hi');
+  });
+  test('stream ending without trailing newline still emits the final done event', async () => {
+    // Some proxies drop the terminal \n\n. Verify the trailing-line flush works.
+    const chunks = [
+      'data: {"type":"chunk","content":"x"}\n\n',
+      'data: {"type":"done","content":"x","usage":null,"model":"m","finishReason":"stop"}', // NO \n\n
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.content).toBe('x');
+    expect(result.finishReason).toBe('stop');
+  });
+  test('type:"error" event throws with .code propagated', async () => {
+    const chunks = [
+      sse({ type: 'error', error: 'provider 500', code: 'upstream_500' }),
+    ];
+    await expect(_parseSSEResponseStream(makeReader(chunks))).rejects.toMatchObject({
+      message: 'provider 500',
+      code: 'upstream_500',
+    });
+  });
+  test('stream ends before done → returns accumulated content with no finalData', async () => {
+    const chunks = [
+      sse({ type: 'chunk', content: 'partial' }),
+      // No done event.
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks), { fallbackModel: 'm' });
+    expect(result.content).toBe('partial');
+    expect(result.finishReason).toBe('stop');
+    expect(result.model).toBe('m');
+  });
+  test('unknown event types are silently ignored (forward compat)', async () => {
+    const chunks = [
+      sse({ type: 'start', model: 'x', requestId: 'r1' }), // metadata, no content
+      sse({ type: 'some_new_future_event', data: 'whatever' }),
+      sse({ type: 'chunk', content: 'real' }),
+      sse({ type: 'done', content: 'real', usage: null, model: 'x', finishReason: 'stop' }),
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.content).toBe('real');
+  });
+});
+// ────────────────────────────────────────────────────────────────────────
+// Tool-call bridge output — inline JSON flows through as content
+// ────────────────────────────────────────────────────────────────────────
+describe('_parseSSEResponseStream — tool-call inline JSON passthrough', () => {
+  test('backend-bridged tool_call inline JSON arrives in content verbatim', async () => {
+    // The backend converts native tool_calls to inline JSON blocks and
+    // yields them as regular `chunk` events. Verify the CLI receives
+    // them intact so its TagParser can extract.
+    const inlineBlock = '\n**Calling filesystem** — action: read…\n\n'
+      + '```json\n'
+      + '{\n  "toolId": "filesystem",\n  "parameters": {\n    "action": "read"\n  }\n}\n'
+      + '```\n';
+    const chunks = [
+      sse({ type: 'chunk', content: 'Sure, checking. ' }),
+      sse({ type: 'chunk', content: inlineBlock }),
+      sse({ type: 'done', content: 'Sure, checking. ' + inlineBlock,
+            usage: { input_tokens: 5, output_tokens: 30, total_tokens: 35 },
+            model: 'DeepSeek-R1-0528', finishReason: 'tool_calls' }),
+    ];
+    const result = await _parseSSEResponseStream(makeReader(chunks));
+    expect(result.content).toContain('```json');
+    expect(result.content).toContain('"toolId": "filesystem"');
+    expect(result.content).toContain('"action": "read"');
+    expect(result.finishReason).toBe('tool_calls');
+  });
+});