@semalt-ai/code 1.8.5 → 1.20.0

package/test/status-bar-driver.test.js

@@ -0,0 +1,93 @@
+'use strict';
+
+// Status bar ↔ single driver coordination (Output Refactor — Phase 3).
+//
+// The status bar wires the clock and spinner as two SUBSCRIBERS of one driver
+// (lib/ui/anim.js). These tests assert the coordination contract through the
+// real FullStatusBar: one coordinated repaint per tick (no flicker), the driver
+// runs while animating even when idle-paused (so a running tool's spinner keeps
+// moving), and it stops when fully idle (preserving the 5404bd0 scroll fix).
+
+const { test, mock } = require('node:test');
+const assert = require('node:assert');
+
+const { FullStatusBar } = require('../lib/ui/status-bar');
+const { TICKS_PER_SECOND, BASE_INTERVAL_MS } = require('../lib/ui/anim');
+
+const layout = { cols: 200 };
+
+// ---------------------------------------------------------------------------
+// No flicker: a frame where BOTH the clock and the spinner want a repaint
+// still produces exactly ONE repaint (one writer frame, not two competing).
+// ---------------------------------------------------------------------------
+
+test('a frame firing both clock and spinner yields a single repaint', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+    bar.update('tool', 'running');   // animating → spinner wants every tick
+
+    // Advance to exactly the 1 Hz boundary (frame === TICKS_PER_SECOND), where
+    // the clock subscriber ALSO wants a repaint. The two coalesce into one.
+    redraws = 0;
+    mock.timers.tick(BASE_INTERVAL_MS * TICKS_PER_SECOND);
+    // One repaint per base tick (spinner), and the clock-boundary tick did not
+    // double up: exactly TICKS_PER_SECOND repaints over the second, not more.
+    assert.strictEqual(redraws, TICKS_PER_SECOND, 'one coordinated repaint per tick, no doubling at the 1s boundary');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// While animating, idle-pause keeps the driver running (spinner must move) but
+// silences the clock contribution — so there's no extra 1 Hz scroll-fighting
+// tick beyond the spinner's own repaints.
+// ---------------------------------------------------------------------------
+
+test('paused-but-animating keeps the spinner running', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+    bar.update('tool', 'running');   // animating
+    bar.pause();                     // input went idle (agent working)
+
+    redraws = 0;
+    mock.timers.tick(BASE_INTERVAL_MS * 5);
+    // Driver still runs (spinner) — 5 base ticks → 5 repaints.
+    assert.strictEqual(redraws, 5, 'spinner keeps repainting while paused-but-animating');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Returning to idle while paused stops the driver outright (idle = no anim).
+// ---------------------------------------------------------------------------
+
+test('idle + paused stops the driver (no periodic repaint → scroll works)', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+    bar.update('tool', 'running');
+    bar.pause();
+    // Tool finished → back to idle while still paused.
+    bar.update('idle');   // update() un-pauses + restarts driver...
+    bar.pause();          // ...and the field is still idle → re-pause stops it.
+
+    redraws = 0;
+    mock.timers.tick(BASE_INTERVAL_MS * 50);
+    assert.strictEqual(redraws, 0, 'no periodic repaint when idle + paused');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});

package/test/status-bar-pause.test.js

@@ -0,0 +1,164 @@
+'use strict';
+
+// Status bar pause/resume — the idle-scroll fix.
+//
+// THE BUG: when the user is idle, the status bar's once-per-second clock tick
+// kept redrawing the live region, snapping the terminal viewport back to the
+// bottom and defeating scroll-up. `pause()` was *meant* to stop that, but it
+// only set a `_paused` flag that the redraw path (`_notify`) ignored — both
+// branches called `_onChange()` identically, so the guard was a no-op and the
+// clock kept firing.
+//
+// THE FIX: pause()/resume() now start/stop the periodic clock `setInterval`
+// itself. pause() clears the timer (no more idle redraws → scroll sticks);
+// resume() recreates it and does a one-shot repaint (viewport returns to the
+// prompt). Event-driven redraws (update/updateMetrics/setCost/spinner) are
+// untouched — only the periodic tick is paused.
+//
+// These tests drive the clock via node:test mock timers so we can advance time
+// deterministically and count the redraws the tick produces.
+
+const { test, mock } = require('node:test');
+const assert = require('node:assert');
+
+const { FullStatusBar } = require('../lib/ui/status-bar');
+
+const layout = { cols: 200 };
+
+// ---------------------------------------------------------------------------
+// pause() stops the periodic redraw (the regression this fix is about)
+// ---------------------------------------------------------------------------
+
+test('pause() stops the once-per-second clock redraw', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+
+    // Baseline: the clock ticks while active.
+    mock.timers.tick(3000);
+    assert.ok(redraws >= 3, 'clock fires ~once/sec before pause');
+
+    redraws = 0;
+    bar.pause();
+    // Advancing several seconds must produce NO redraws from the tick.
+    mock.timers.tick(5000);
+    assert.strictEqual(redraws, 0, 'no periodic redraw while paused');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Paired positive: resume() restarts the tick + does a one-shot repaint
+// ---------------------------------------------------------------------------
+
+test('resume() restarts the clock and repaints once', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+    bar.pause();
+    mock.timers.tick(5000);
+
+    redraws = 0;
+    bar.resume();
+    // resume() performs its one-shot repaint immediately so the viewport
+    // returns to the input prompt.
+    assert.strictEqual(redraws, 1, 'resume() repaints once synchronously');
+
+    // ...and the periodic tick is running again.
+    redraws = 0;
+    mock.timers.tick(3000);
+    assert.ok(redraws >= 3, 'clock tick resumes after resume()');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Event-driven redraws are NOT suppressed while paused
+// ---------------------------------------------------------------------------
+
+test('event-driven redraws (update/updateMetrics/setCost) still paint while paused', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+    bar.pause();
+    mock.timers.tick(5000);
+    assert.strictEqual(redraws, 0, 'tick suppressed while paused');
+
+    // An explicit update() still paints — only the periodic tick is paused.
+    redraws = 0;
+    bar.update('thinking', 'Working');
+    assert.ok(redraws >= 1, 'update() still repaints during pause');
+
+    // updateMetrics / setCost also still paint.
+    redraws = 0;
+    bar.updateMetrics({ contextTokens: 123 });
+    assert.ok(redraws >= 1, 'updateMetrics() still repaints');
+
+    redraws = 0;
+    bar.setCost('$0.01');
+    assert.ok(redraws >= 1, 'setCost() still repaints');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// No double timers across pause/resume cycles
+// ---------------------------------------------------------------------------
+
+test('repeated pause()/resume() cycles do not stack setInterval timers', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+
+    // Several cycles — a leaked/stacked timer would multiply the redraws/sec.
+    bar.pause(); bar.resume();
+    bar.pause(); bar.resume();
+    bar.pause(); bar.resume();
+
+    // resume()'s one-shot repaints already happened; measure only the tick.
+    redraws = 0;
+    mock.timers.tick(1000);
+    assert.strictEqual(redraws, 1, 'exactly one clock timer fires per second');
+
+    // Redundant resume() must not add a second timer either.
+    bar.resume();
+    redraws = 0;
+    mock.timers.tick(1000);
+    assert.strictEqual(redraws, 1, 'redundant resume() does not stack a timer');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// destroy() stops the clock (no redraw after teardown)
+// ---------------------------------------------------------------------------
+
+test('destroy() stops the clock', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+    bar.destroy();
+    redraws = 0;
+    mock.timers.tick(5000);
+    assert.strictEqual(redraws, 0, 'no redraw after destroy()');
+  } finally {
+    mock.timers.reset();
+  }
+});

package/test/status-bar-resync.test.js

@@ -0,0 +1,188 @@
+'use strict';
+
+// Status-bar clock re-sync after startup — the await-ordering race fix.
+//
+// THE BUG (uncovered by the 5404bd0 idle-scroll fix): two correct-in-isolation
+// mechanisms race during startup.
+//
+//   Fact A — statusBar.update('idle') unconditionally restarts the clock
+//     (the "not-paused ⇒ clock-running" invariant).
+//   Fact B — the input field's idle→pause is a ONE-SHOT setTimeout(0): on the
+//     first event-loop yield the field goes idle, emits 'idle', and the wiring
+//     (`field.on('idle', () => sb.pause())`) stops the clock. It fires once; no
+//     further 'idle' is emitted until an active→idle transition.
+//
+//   No-await start: update('idle') runs synchronously, THEN the loop yields and
+//   the one-shot _goIdle fires last → pause() → clock stopped. ✓
+//   Resume / MCP start: an `await` (dashboardGetChat / mcpManager.connectAll)
+//   yields mid-startup, so the one-shot _goIdle fires EARLY (clock stopped),
+//   then the await resolves and update('idle') restarts the clock. The field is
+//   already idle, so no active→idle transition ever re-fires pause() → clock
+//   runs forever → the 1 Hz redraw snaps the viewport down → scroll defeated. ✗
+//
+// THE FIX (chat.js, right after the startup update('idle')):
+//     if (inputField.isIdle()) statusBar.pause();
+// It re-syncs the clock to the field's REAL idle state. These tests model the
+// exact startup wiring (create-ui.js:196-197) with the real FullStatusBar and
+// InputField, driving the field's idle state to reproduce both orderings.
+
+const { test, mock } = require('node:test');
+const assert = require('node:assert');
+
+const { FullStatusBar } = require('../lib/ui/status-bar');
+const { InputField } = require('../lib/ui/input-field');
+
+const layout = { cols: 200 };
+
+// Build a real status bar + input field wired exactly like create-ui.js, plus
+// the one-line convergence re-sync the fix adds. Returns helpers to drive the
+// orderings and to count clock redraws.
+function harness() {
+  let redraws = 0;
+  const bar = new FullStatusBar(layout, () => { redraws++; });
+  const field = new InputField(layout, { /* chatHistory stub */ }, () => {});
+  // create-ui.js:196-197 — the live wiring under test.
+  field.on('idle', () => bar.pause());
+  field.on('active', () => bar.resume());
+
+  // The startup sequence at chat.js: the final update('idle') followed by the
+  // re-sync convergence step (the fix).
+  const startupResync = () => {
+    bar.update('idle');
+    if (field.isIdle()) bar.pause();
+  };
+
+  return {
+    bar,
+    field,
+    startupResync,
+    redrawsSince(fn) { redraws = 0; fn(); return redraws; },
+    cleanup() {
+      // _goActive arms a real setTimeout(0); clear any dangling one.
+      if (field._idleTimer) { clearTimeout(field._idleTimer); field._idleTimer = null; }
+      bar.destroy();
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Resume / await-ordering: the one-shot _goIdle fires BEFORE the re-sync → the
+// re-sync must leave the clock STOPPED (the regression).
+// ---------------------------------------------------------------------------
+
+test('await-ordering (resume): re-sync stops the clock the update restarted', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  const h = harness();
+  try {
+    // An await yielded mid-startup → the one-shot _goIdle already fired.
+    h.field._goIdle();
+    assert.ok(h.field.isIdle(), 'field is idle after the early _goIdle');
+
+    // WITHOUT the re-sync, update('idle') alone leaves the clock running —
+    // this is exactly the bug. (Measure only the periodic tick, not update()'s
+    // own synchronous repaint.)
+    h.bar.update('idle');
+    const bugTicks = h.redrawsSince(() => mock.timers.tick(3000));
+    assert.ok(bugTicks >= 3, 'update(idle) alone restarts the clock (the bug)');
+
+    // WITH the re-sync: field is already idle → pause() → clock stopped.
+    h.startupResync();
+    const fixedTicks = h.redrawsSince(() => mock.timers.tick(5000));
+    assert.strictEqual(fixedTicks, 0, 're-sync stops the clock when field is idle');
+  } finally {
+    h.cleanup();
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Normal no-await start: field is NOT yet idle at the re-sync point → no
+// premature pause; the existing flow (timer fires later → pause) still ends
+// clock-stopped. (Paired positive — the fix doesn't break the working path.)
+// ---------------------------------------------------------------------------
+
+test('no-await start: re-sync is a no-op, existing idle→pause still stops the clock', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  const h = harness();
+  try {
+    // The one-shot _goIdle has NOT fired yet at the re-sync point.
+    assert.ok(!h.field.isIdle(), 'field not yet idle at re-sync');
+
+    // Re-sync runs: isIdle() false → no premature pause → clock keeps running.
+    h.startupResync();
+    const afterResync = h.redrawsSince(() => mock.timers.tick(3000));
+    assert.ok(afterResync >= 3, 'no premature pause on the no-await path');
+
+    // The one-shot _goIdle fires AFTER startup (as it always did) → pause().
+    const afterIdle = h.redrawsSince(() => { h.field._goIdle(); mock.timers.tick(5000); });
+    assert.strictEqual(afterIdle, 0, 'the later idle still stops the clock');
+  } finally {
+    h.cleanup();
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// MCP-start equivalence: the fix is keyed on the field's idle state, not on
+// WHICH await yielded, so a startup await from MCP connectAll converges the
+// same way as --resume. Same ordering → same stopped end state.
+// ---------------------------------------------------------------------------
+
+test('await-ordering (MCP start): re-sync also stops the clock', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  const h = harness();
+  try {
+    // mcpManager.connectAll() yielded the loop → one-shot _goIdle fired early.
+    h.field._goIdle();
+    h.startupResync();
+    const ticks = h.redrawsSince(() => mock.timers.tick(5000));
+    assert.strictEqual(ticks, 0, 'MCP-start await-ordering ends with the clock stopped');
+  } finally {
+    h.cleanup();
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Type-after-resume: an active transition restarts the clock (resume()) and a
+// subsequent idle re-pauses — the normal cycle is intact post-fix.
+// ---------------------------------------------------------------------------
+
+test('type-after-resume: active restarts the clock, idle re-pauses', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  const h = harness();
+  try {
+    // Reach the post-resume stopped state.
+    h.field._goIdle();
+    h.startupResync();
+    assert.strictEqual(h.redrawsSince(() => mock.timers.tick(3000)), 0, 'stopped after resume');
+
+    // User types → active → resume() → clock runs again.
+    const afterActive = h.redrawsSince(() => { h.field._goActive(); mock.timers.tick(3000); });
+    assert.ok(afterActive >= 3, 'typing (active) restarts the clock');
+
+    // User stops → idle → pause() → clock stops again.
+    const afterIdle = h.redrawsSince(() => { h.field._goIdle(); mock.timers.tick(5000); });
+    assert.strictEqual(afterIdle, 0, 'going idle re-pauses the clock');
+  } finally {
+    h.cleanup();
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// isIdle() reflects the real _goIdle/_goActive transitions.
+// ---------------------------------------------------------------------------
+
+test('isIdle() reads the true idle state across transitions', () => {
+  const h = harness();
+  try {
+    assert.strictEqual(h.field.isIdle(), false, 'starts not-idle');
+    h.field._goIdle();
+    assert.strictEqual(h.field.isIdle(), true, 'true after _goIdle');
+    h.field._goActive();
+    assert.strictEqual(h.field.isIdle(), false, 'false after _goActive');
+  } finally {
+    h.cleanup();
+  }
+});

package/test/stream-parser.test.js

@@ -0,0 +1,171 @@
+'use strict';
+
+// Characterization tests for the streaming SSE parser (Task 1.1).
+// There is no standalone `StreamParser` class — the parser is inline in
+// chatStream's `res.on('data')` handler — so it is characterized end-to-end by
+// driving chatStream against a local fake SSE server (test/harness/sse-server).
+
+const { test, before, after } = require('node:test');
+const assert = require('node:assert');
+
+const { createApiClient } = require('../lib/api');
+const ui = require('../lib/ui');
+const { startSseServer, sse, DONE } = require('./harness/sse-server');
+
+// Force the API key to come from env so resolveApiKey never shells out to a
+// keychain during tests.
+let prevKey;
+before(() => {
+  prevKey = process.env.SEMALT_API_KEY;
+  process.env.SEMALT_API_KEY = 'test-key';
+});
+after(() => {
+  if (prevKey === undefined) delete process.env.SEMALT_API_KEY;
+  else process.env.SEMALT_API_KEY = prevKey;
+});
+
+// Build an api client whose api_base points at the given server.
+function clientFor(base) {
+  const config = {
+    api_base: base,
+    api_key: 'test-key',
+    default_model: 'test-model',
+    temperature: 0.5,
+    request_timeout_ms: 5000,
+    stream: true,
+  };
+  return createApiClient({ getConfig: () => config, saveConfig: () => {}, ui });
+}
+
+// Run a scripted SSE response through chatStream and return the result.
+async function run(chunks, opts = {}) {
+  const srv = await startSseServer({ chunks });
+  try {
+    const api = clientFor(srv.base);
+    const tokens = [];
+    const res = await api.chatStream(
+      [{ role: 'user', content: 'hi' }],
+      { silent: true, onToken: (t) => tokens.push(t), ...opts },
+    );
+    return { res, tokens };
+  } finally {
+    await srv.close();
+  }
+}
+
+test('clean single-turn content stream assembles full text + provider usage', async () => {
+  const { res, tokens } = await run([
+    sse({ choices: [{ delta: { content: 'Hello' } }] }),
+    sse({ choices: [{ delta: { content: ', world' } }] }),
+    sse({ choices: [{ finish_reason: 'stop', delta: {} }] }),
+    sse({ usage: { prompt_tokens: 10, completion_tokens: 3 } }),
+    DONE,
+  ]);
+  assert.strictEqual(res.content, 'Hello, world');
+  assert.strictEqual(res.finish_reason, 'stop');
+  assert.deepStrictEqual(res.toolCalls, []);
+  assert.strictEqual(res.usage_from_provider, true);
+  assert.deepStrictEqual(res.usage, { prompt_tokens: 10, completion_tokens: 3 });
+  assert.deepStrictEqual(tokens, ['Hello', ', world']);
+});
+
+test('a data line split across two chunks is buffered and parsed', async () => {
+  // The first chunk ends mid-JSON; the parser must hold it until the newline.
+  const full = sse({ choices: [{ delta: { content: 'Hi' } }] });
+  const cut = Math.floor(full.length / 2);
+  const { res } = await run([full.slice(0, cut), full.slice(cut), DONE]);
+  assert.strictEqual(res.content, 'Hi');
+});
+
+test('reasoning_content is collected separately from content', async () => {
+  const { res } = await run([
+    sse({ choices: [{ delta: { reasoning_content: 'let me think' } }] }),
+    sse({ choices: [{ delta: { content: 'answer' } }] }),
+    DONE,
+  ]);
+  assert.strictEqual(res.content, 'answer');
+  assert.strictEqual(res.reasoning, 'let me think');
+});
+
+test('onReasoning fires once, before content, when reasoning_content is first seen', async () => {
+  // Live-narration safety signal (a): the UI eager-open gate needs to know the
+  // structured reasoning channel is in use BEFORE the first content token.
+  const order = [];
+  const srv = await startSseServer({ chunks: [
+    sse({ choices: [{ delta: { reasoning_content: 'thinking a' } }] }),
+    sse({ choices: [{ delta: { reasoning_content: ' thinking b' } }] }),
+    sse({ choices: [{ delta: { content: 'answer' } }] }),
+    DONE,
+  ] });
+  try {
+    const api = clientFor(srv.base);
+    await api.chatStream([{ role: 'user', content: 'hi' }], {
+      silent: true,
+      onReasoning: () => order.push('reasoning'),
+      onToken: (t) => order.push(`token:${t}`),
+    });
+  } finally {
+    await srv.close();
+  }
+  // Exactly one onReasoning, and it precedes the first content token.
+  assert.deepStrictEqual(order, ['reasoning', 'token:answer']);
+});
+
+test('native tool_calls deltas accumulate by index into structured calls', async () => {
+  const { res } = await run([
+    sse({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'call_1', type: 'function', function: { name: 'read_file', arguments: '' } }] } }] }),
+    sse({ choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '{"path":' } }] } }] }),
+    sse({ choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '"a.txt"}' } }] } }] }),
+    sse({ choices: [{ finish_reason: 'tool_calls', delta: {} }] }),
+    DONE,
+  ], { nativeTools: true });
+
+  assert.strictEqual(res.tool_calls_count, 1);
+  assert.deepStrictEqual(res.toolCalls, [
+    { id: 'call_1', type: 'function', function: { name: 'read_file', arguments: '{"path":"a.txt"}' } },
+  ]);
+  assert.strictEqual(res.content, '', 'native mode does not serialize XML into content');
+});
+
+test('legacy (nativeTools:false) serializes tool_calls into MiniMax XML in content', async () => {
+  const { res } = await run([
+    sse({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'c1', type: 'function', function: { name: 'read_file', arguments: '{"path":"a.txt"}' } }] } }] }),
+    sse({ choices: [{ finish_reason: 'tool_calls', delta: {} }] }),
+    DONE,
+  ], { nativeTools: false });
+
+  assert.deepStrictEqual(res.toolCalls, [], 'legacy mode reports no structured calls');
+  assert.match(res.content, /<minimax:tool_call>/);
+  // And the round-tripped XML is parseable by extractToolCalls.
+  const { extractToolCalls } = require('../lib/tools');
+  assert.deepStrictEqual(extractToolCalls(res.content), [['read', 'a.txt', null, null, false]]);
+});
+
+test('usage is estimated locally when the provider omits it', async () => {
+  const { res } = await run([
+    sse({ choices: [{ delta: { content: 'no usage line here' } }] }),
+    DONE,
+  ]);
+  assert.strictEqual(res.usage_from_provider, false);
+  assert.strictEqual(typeof res.usage.prompt_tokens, 'number');
+  assert.strictEqual(typeof res.usage.completion_tokens, 'number');
+});
+
+test('a malformed JSON data line is skipped, not fatal', async () => {
+  const { res } = await run([
+    'data: {this is not json}\n',
+    sse({ choices: [{ delta: { content: 'ok' } }] }),
+    DONE,
+  ]);
+  assert.strictEqual(res.content, 'ok');
+});
+
+test('[DONE] terminates the stream and resolves', async () => {
+  const { res } = await run([
+    sse({ choices: [{ delta: { content: 'done-test' } }] }),
+    DONE,
+    // anything after [DONE] is ignored — the parser has already finalized.
+    sse({ choices: [{ delta: { content: 'IGNORED' } }] }),
+  ]);
+  assert.strictEqual(res.content, 'done-test');
+});