dsh-better-chat/tests/text-transform.test.ts

273 lines
10 KiB
TypeScript

import assert from 'node:assert/strict';
import { test } from 'vitest';
import { StreamBuffer } from '../src/client/stream-buffer.js';
import {
activeTextTransform,
createTextTransformRegistry,
displayStreaming,
installTextTransformRegistry,
nextDisplayCursor,
originalAnswerText,
readDisplayText,
readerBlockOwner,
type DisplayTextRequest,
} from '../src/client/text-transform.js';
import type { ReaderBlockOwner } from '../src/client/types.js';
import { WordTimeline } from '../src/client/word-timeline.js';
const reasoning = (text: string, streaming = true, blockKey = 'block-1'): DisplayTextRequest => ({
text, streaming, blockKey, kind: 'reasoning', source: 'assistant',
});
test('no transformer leaves the source text and the streaming flag untouched', () => {
const registry = createTextTransformRegistry();
const request = reasoning('Hello world', true);
const shown = readDisplayText(registry, request);
assert.equal(shown.text, request.text);
assert.equal(shown.final, false);
assert.equal(shown.motionRevision, 0);
assert.equal(shown.transformRevision, 0);
assert.equal(readDisplayText(undefined, request).text, 'Hello world');
assert.equal(displayStreaming(true, shown, false), true);
assert.equal(displayStreaming(false, { final: true }, false), false);
assert.equal(registry.has('reasoning'), false);
assert.equal(registry.has('body'), false);
});
test('a sync transformer rewrites the display string and leaves the block alone', () => {
const registry = createTextTransformRegistry();
const source = 'Hello';
const block = { kind: 'text' as const, text: source };
registry.register('body', {
read: request => ({ text: request.text.toUpperCase(), final: !request.streaming }),
});
const streaming = readDisplayText(registry, { text: source, streaming: true, blockKey: 'a', kind: 'body', source: 'assistant' });
const settled = readDisplayText(registry, { text: source, streaming: false, blockKey: 'a', kind: 'body', source: 'assistant' });
assert.equal(streaming.text, 'HELLO');
assert.equal(streaming.final, false);
assert.equal(displayStreaming(true, streaming, true), true);
assert.equal(settled.text, 'HELLO');
assert.equal(settled.final, true);
assert.equal(displayStreaming(false, settled, true), false);
assert.equal(source, 'Hello');
assert.equal(block.text, 'Hello');
assert.equal(originalAnswerText([block, { kind: 'reasoning', text: 'secret thought' }]), 'Hello');
});
test('an async append bumps the transform revision without restarting the reveal', () => {
const registry = createTextTransformRegistry();
let shown = 'Hello';
const listeners = new Set<() => void>();
registry.register('reasoning', {
read: () => ({ text: shown, final: false }),
subscribe(listener) {
listeners.add(listener);
return () => { listeners.delete(listener); };
},
});
const request = reasoning('thinking starts', true);
const first = registry.read(request);
assert.equal(first.text, 'Hello');
assert.equal(first.transformRevision, 0);
assert.equal(first.motionRevision, 0);
const buffer = new StreamBuffer('');
const timeline = new WordTimeline();
timeline.begin('', true, 0, 0);
const paint = (text: string, now: number) => {
buffer.update(text, now, { finished: false });
buffer.advance(now + 120);
timeline.begin(buffer.visible, true, buffer.revision, now + 120);
};
paint(first.text, 100);
assert.equal(buffer.revision, 0);
assert.ok(buffer.visible.length > 0);
const generation = timeline.generation;
const prefixBorn = timeline.bornAt(0);
const visible = buffer.visible;
assert.notEqual(prefixBorn, null);
shown = 'Hello there';
for (const listener of listeners) listener();
const second = registry.read(request);
assert.equal(second.text, 'Hello there');
assert.equal(second.motionRevision, first.motionRevision);
assert.equal(second.transformRevision, first.transformRevision + 1);
paint(second.text, 400);
assert.equal(buffer.revision, 0);
assert.ok(buffer.visible.startsWith(visible));
assert.ok(buffer.visible.length > visible.length);
assert.equal(timeline.generation, generation);
assert.equal(timeline.bornAt(0), prefixBorn);
// The transform counter is a different clock. Feeding it to the timeline
// settles the paragraph; the reader does not do that.
const trap = new WordTimeline();
trap.begin('', true, 0, 0);
trap.begin(visible, true, first.motionRevision, 220);
const trapGeneration = trap.generation;
trap.begin(second.text, true, second.transformRevision, 520);
assert.notEqual(trap.generation, trapGeneration);
});
test('a replaced translation settles on the new string instead of replaying from empty', () => {
const registry = createTextTransformRegistry();
let shown = 'Hello there';
registry.register('reasoning', {
read: () => ({ text: shown, final: false }),
});
const request = reasoning('source', true);
const first = registry.read(request);
const buffer = new StreamBuffer('');
buffer.update(first.text, 100);
buffer.advance(220);
assert.equal(buffer.visible, 'Hello there');
const timeline = new WordTimeline();
timeline.begin('', true, buffer.revision, 0);
timeline.begin(buffer.visible, true, buffer.revision, 220);
const generation = timeline.generation;
shown = '你好世界';
const second = registry.read(request);
assert.equal(second.motionRevision, first.motionRevision + 1);
assert.ok(second.transformRevision > first.transformRevision);
buffer.update(second.text, 400);
assert.equal(buffer.visible, '你好世界');
assert.notEqual(buffer.visible, '');
assert.equal(buffer.revision, 1);
timeline.begin(buffer.visible, true, buffer.revision, 400);
assert.notEqual(timeline.generation, generation);
assert.equal(timeline.bornAt(0), null);
});
test('the block owner carries presentation, holdFormatting, and liveText', () => {
const block = { kind: 'reasoning' as const, text: 'original' };
const owner = readerBlockOwner(block as ReaderBlockOwner['block'], true, 'assistant', {
startedAt: 42, interrupted: false, liveText: true,
}, false);
assert.equal(owner.block, block);
assert.equal(owner.streaming, true);
assert.equal(owner.source, 'assistant');
assert.deepEqual(owner.presentation, { startedAt: 42, interrupted: false, liveText: true });
assert.equal(owner.holdFormatting, false);
assert.equal(owner.liveText, true);
assert.equal(owner.block.text, 'original');
const bare: ReaderBlockOwner = { block: owner.block, streaming: false, source: 'user' };
assert.equal(bare.presentation, undefined);
assert.equal(bare.holdFormatting, undefined);
assert.equal(bare.liveText, undefined);
});
test('unregistering restores the original text and the install pointer nests', () => {
const registry = createTextTransformRegistry();
const dispose = registry.register(['reasoning', 'body'], {
read: request => request.text.toUpperCase(),
});
assert.equal(registry.has('reasoning'), true);
assert.equal(registry.has('body'), true);
assert.equal(readDisplayText(registry, reasoning('Ab')).text, 'AB');
dispose();
assert.equal(registry.has('reasoning'), false);
assert.equal(readDisplayText(registry, reasoning('Ab')).text, 'Ab');
const outer = createTextTransformRegistry();
const restoreOuter = installTextTransformRegistry(outer);
try {
assert.equal(activeTextTransform(), outer);
const inner = createTextTransformRegistry();
const restoreInner = installTextTransformRegistry(inner);
try {
assert.equal(activeTextTransform(), inner);
} finally {
restoreInner();
}
assert.equal(activeTextTransform(), outer);
} finally {
restoreOuter();
}
assert.equal(activeTextTransform(), undefined);
});
test('a transformer notify reaches reader subscribers, and release drops the cursor', () => {
const registry = createTextTransformRegistry();
let shown = 'Hello';
let notify = () => {};
registry.register('reasoning', {
read: () => ({ text: shown, final: false }),
subscribe(listener) {
notify = listener;
return () => {};
},
});
let seen = 0;
const stop = registry.subscribe('reasoning', () => { seen += 1; });
const first = registry.read(reasoning('source'));
assert.equal(first.text, 'Hello');
assert.equal(first.transformRevision, 0);
shown = 'Hello there';
notify();
assert.equal(seen, 1);
const next = registry.read(reasoning('source'));
assert.equal(next.text, 'Hello there');
assert.equal(next.motionRevision, 0);
assert.equal(next.transformRevision, 1);
stop();
registry.release('reasoning', 'block-1');
shown = 'Hello there friend';
const restarted = registry.read(reasoning('source'));
assert.equal(restarted.transformRevision, 0);
assert.equal(restarted.motionRevision, 0);
});
test('an extending display string keeps the motion revision', () => {
const first = nextDisplayCursor(undefined, { text: 'Hello', final: false });
const second = nextDisplayCursor(first, { text: 'Hello world', final: false });
const same = nextDisplayCursor(second, { text: 'Hello world', final: false });
assert.equal(second.motionRevision, first.motionRevision);
assert.equal(second.transformRevision, 1);
assert.equal(same, second);
});
test('a throwing transformer falls back to the original text and recovers without a remount', () => {
const registry = createTextTransformRegistry();
let broken = true;
let notify = () => {};
const warn = console.warn;
console.warn = () => {};
try {
registry.register('reasoning', {
subscribe(listener) { notify = listener; return () => {}; },
read(request) {
if (broken) throw new Error('engine down');
return { text: request.text.toUpperCase(), final: !request.streaming };
},
});
const first = registry.read(reasoning('hello', true));
assert.equal(first.text, 'hello');
assert.equal(first.final, false);
broken = false;
notify();
const recovered = registry.read(reasoning('hello', true));
assert.equal(recovered.text, 'HELLO');
} finally {
console.warn = warn;
}
});
test('a transformer whose subscribe throws still registers and reads', () => {
const registry = createTextTransformRegistry();
const warn = console.warn;
console.warn = () => {};
try {
const off = registry.register('body', {
subscribe() { throw new Error('no events'); },
read(request) { return request.text.toUpperCase(); },
});
assert.equal(registry.read({ text: 'ok', streaming: false, blockKey: 'b', kind: 'body', source: 'assistant' }).text, 'OK');
off();
assert.equal(registry.has('body'), false);
} finally {
console.warn = warn;
}
});