dsh-better-chat/tests/live-turn.test.ts

290 lines
16 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { test } from 'vitest';
import assert from 'node:assert/strict';
import type { AssistantChatData, ChatConversationViewNode } from '@deepseek-ai/dsh-client-ui-chat/client';
import type { AssistantBlock, TurnLocation } from '@deepseek-ai/dsh-client-ui-conversation/client';
import { assistantSegments, processExpanded } from '../src/client/projection.ts';
import type { TurnBoundary } from '../src/client/projection.ts';
import { planProcessSeams, presentLiveTurn, segmentLiveTurn } from '../src/client/live-turn.ts';
import type { LiveStep } from '../src/client/live-turn.ts';
import { readerFlow } from '../src/client/tool-activity.ts';
const open: TurnBoundary = { status: 'open', reason: null, latestStep: 4, closingStep: null };
const completed: TurnBoundary = { status: 'closed', reason: 'completed', latestStep: 4, closingStep: 4 };
function reasoning(id: string, text = `思考 ${id}`): LiveStep {
return { kind: 'reasoning', key: id, nodeKey: id, start: 0, blocks: [{ kind: 'reasoning', text }], step: Number(id.replace(/\D/g, '') || 0) };
}
function body(id: string, text = `输出 ${id}`): LiveStep {
return { kind: 'body', key: id, nodeKey: id, start: 1, blocks: [{ kind: 'text', text }], step: 0 };
}
function tool(id: string): LiveStep {
return { kind: 'tool', key: id, entry: { kind: 'tool', key: id, callId: id, step: 0, order: 0, draft: { kind: 'tool-call', callId: id, name: 'bash', argsRaw: '{}' } } };
}
function user(id: string): LiveStep {
return { kind: 'user', key: id, nodeKey: id };
}
function other(id: string): LiveStep {
return { kind: 'other', key: id, nodeKey: id };
}
function kinds(items: ReturnType<typeof presentLiveTurn>) {
return items.map(item => item.kind === 'fold' ? ['fold', item.summary, item.steps.map(step => step.key)] : [item.kind, item.key]);
}
test('narration is never folded; earlier process runs collapse even across narration', () => {
const beforeSecondReasoning = presentLiveTurn([reasoning('1'), body('2')], open);
assert.deepEqual(kinds(beforeSecondReasoning), [['open', '1'], ['open', '2']]);
// The first reasoning run folds in place before the narration; the narration
// itself stays open, and the latest reasoning stays open.
const afterSecondReasoning = presentLiveTurn([reasoning('1'), body('2'), reasoning('3')], open);
assert.deepEqual(kinds(afterSecondReasoning), [
['fold', '思考×1', ['1']],
['open', '2'],
['open', '3'],
]);
const mixed = presentLiveTurn([reasoning('1'), tool('2'), body('3'), reasoning('4'), tool('5'), reasoning('6')], open);
assert.deepEqual(kinds(mixed), [
['fold', '思考×1 · 工具×1', ['1', '2']],
['open', '3'],
['fold', '思考×1 · 工具×1', ['4', '5']],
['open', '6'],
]);
assert.equal(mixed.some(item => item.kind === 'fold' && item.steps.some(step => step.kind === 'body')), false);
for (const item of mixed) {
if (item.kind === 'fold') assert.equal(item.summary.includes('输出'), false);
}
});
test('a second reasoning folds the foldable run before it, never narration', () => {
const first = presentLiveTurn([reasoning('1'), tool('2')], open);
assert.deepEqual(kinds(first), [['open', '1'], ['open', '2']]);
const second = presentLiveTurn([reasoning('1'), tool('2'), reasoning('3')], open);
assert.deepEqual(kinds(second), [['fold', '思考×1 · 工具×1', ['1', '2']], ['open', '3']]);
if (second[0]?.kind !== 'fold') throw new Error('missing fold');
if (second[0].steps[0]?.kind !== 'reasoning') throw new Error('folded reasoning missing');
assert.equal(second[0].steps[0].blocks[0]?.kind === 'reasoning' && second[0].steps[0].blocks[0].text, '思考 1');
assert.equal(second[0].summary.includes('思考 1'), false);
const grown = presentLiveTurn([reasoning('1'), tool('2'), reasoning('3'), tool('4'), reasoning('5')], open);
if (grown[0]?.kind !== 'fold') throw new Error('missing grown fold');
assert.deepEqual(grown[0].steps.map(step => step.key), ['1', '2', '3', '4']);
assert.deepEqual(grown.filter(item => item.kind === 'open').map(item => item.key), ['5']);
assert.equal(grown[0].summary, '思考×2 · 工具×2');
const narrationBetween = presentLiveTurn([reasoning('1'), body('2'), reasoning('3'), tool('4'), reasoning('5')], open);
assert.deepEqual(kinds(narrationBetween), [
['fold', '思考×1', ['1']],
['open', '2'],
['fold', '思考×1 · 工具×1', ['3', '4']],
['open', '5'],
]);
});
test('fold presentation keeps prior step keys so the reader can collapse the same process fragments in place', () => {
const chain = [reasoning('1'), tool('2')];
const before = presentLiveTurn(chain, open);
assert.deepEqual(before.map(item => item.key), ['1', '2']);
const second = presentLiveTurn([...chain, reasoning('3')], open);
assert.equal(second[0]?.kind, 'fold');
if (second[0]?.kind !== 'fold') throw new Error('missing fold');
assert.equal(second[0].key, 'live-fold:1');
assert.deepEqual(second[0].steps.map(step => step.key), before.map(item => item.key));
assert.deepEqual(second.filter(item => item.kind === 'open').map(item => item.key), ['3']);
const third = presentLiveTurn([...chain, reasoning('3'), tool('4'), reasoning('5')], open);
if (third[0]?.kind !== 'fold') throw new Error('missing grown fold');
assert.equal(third[0].key, 'live-fold:1');
assert.deepEqual(third[0].steps.map(step => step.key), ['1', '2', '3', '4']);
});
test('presentLiveTurn keeps one fold box per foldable run and never hides narration', () => {
const items = presentLiveTurn([reasoning('1'), tool('2'), reasoning('3'), tool('4'), reasoning('5')], open);
const folds = items.filter(item => item.kind === 'fold');
assert.equal(folds.length, 1);
if (folds[0]?.kind !== 'fold') throw new Error('missing fold');
assert.equal(folds[0].steps.length, 4);
assert.deepEqual(items.filter(item => item.kind === 'open').map(item => item.key), ['5']);
const withNarration = presentLiveTurn([reasoning('1'), tool('2'), body('3'), reasoning('4'), tool('5'), reasoning('6')], open);
const narratedFolds = withNarration.filter(item => item.kind === 'fold');
assert.equal(narratedFolds.length, 2);
assert.deepEqual(withNarration.filter(item => item.kind === 'open').map(item => item.key), ['3', '6']);
assert.deepEqual(narratedFolds.map(fold => fold.kind === 'fold' ? fold.steps.map(step => step.key) : []), [['1', '2'], ['4', '5']]);
for (const fold of narratedFolds) {
if (fold.kind !== 'fold') continue;
assert.equal(fold.steps.some(step => step.kind === 'body'), false);
}
});
test('mid-turn user insert resets the chain; narration stays open across the reset', () => {
const before = presentLiveTurn([reasoning('1'), body('2'), tool('3'), user('insert'), body('4'), tool('5')], open);
assert.deepEqual(kinds(before), [
['open', '1'], ['open', '2'], ['open', '3'],
['user', 'insert'],
['open', '4'], ['open', '5'],
]);
const after = presentLiveTurn([reasoning('1'), body('2'), tool('3'), user('insert'), body('4'), tool('5'), reasoning('6')], open);
assert.deepEqual(kinds(after), [
['open', '1'], ['open', '2'], ['open', '3'],
['user', 'insert'],
['open', '4'],
['fold', '工具×1', ['5']],
['open', '6'],
]);
const folds = after.filter(item => item.kind === 'fold');
assert.equal(folds.length, 1);
if (folds[0]?.kind !== 'fold') throw new Error('missing insert fold');
assert.ok(!folds[0].steps.some(step => ['1', '2', '3', '4', 'insert'].includes(step.key)));
});
test('every prior process run folds in its own place; narration stays open between runs', () => {
const items = presentLiveTurn([
reasoning('1'), tool('2'), reasoning('3'),
body('4'),
tool('5'), reasoning('6'), tool('7'), reasoning('8'),
], open);
const folds = items.filter(item => item.kind === 'fold');
assert.equal(folds.length, 2);
if (folds[0]?.kind !== 'fold' || folds[1]?.kind !== 'fold') throw new Error('expected one box per run');
assert.deepEqual(folds[0].steps.map(step => step.key), ['1', '2', '3']);
assert.deepEqual(folds[1].steps.map(step => step.key), ['5', '6', '7']);
assert.equal(folds[0].summary, '思考×2 · 工具×1');
assert.equal(folds[1].summary, '思考×1 · 工具×2');
assert.deepEqual(items.filter(item => item.kind === 'open').map(item => item.key), ['4', '8']);
});
test('successful turn close disables live fold so the existing final-answer rules still apply', () => {
const items = presentLiveTurn([reasoning('1'), body('2'), tool('3'), reasoning('4'), body('final')], completed);
assert.equal(items.some(item => item.kind === 'fold'), false);
assert.deepEqual(items.map(item => item.kind), ['open', 'open', 'open', 'open', 'open']);
assert.equal(processExpanded(undefined, completed), false);
assert.equal(processExpanded(undefined, { ...completed, reason: 'error' }), true);
assert.equal(processExpanded(undefined, { ...completed, reason: 'interrupted' }), true);
assert.equal(processExpanded(undefined, { ...completed, reason: 'blocked' }), true);
assert.equal(processExpanded(undefined, { status: 'unknown', reason: null, latestStep: -1, closingStep: null }), true);
});
test('error, interrupt, approval-blocked and unknown terminals do not live-fold away the transcript', () => {
const steps = [reasoning('1'), body('2'), tool('3'), reasoning('4')];
for (const reason of ['error', 'interrupted', 'aborted', 'blocked', 'max-tokens', 'future-terminal']) {
const items = presentLiveTurn(steps, { status: 'closed', reason, latestStep: 4, closingStep: 4 });
assert.equal(items.some(item => item.kind === 'fold'), false, reason);
assert.equal(processExpanded(undefined, { status: 'closed', reason, latestStep: 4, closingStep: 4 }), true, reason);
}
assert.equal(presentLiveTurn(steps, { status: 'unknown', reason: null, latestStep: -1, closingStep: null }).some(item => item.kind === 'fold'), false);
});
test('segmentation uses existing assistantSegments and tool boundaries and does not invent empty reasoning', () => {
const think: AssistantBlock = { kind: 'reasoning', text: '第一段思考' };
const moreThink: AssistantBlock = { kind: 'reasoning', text: '同一思考步骤' };
const text: AssistantBlock = { kind: 'text', text: '中途说明' };
const call: AssistantBlock = { kind: 'tool-call', callId: 'c1', name: 'bash', argsRaw: '{"command":"ls"}' };
const empty: AssistantBlock = { kind: 'reasoning', text: ' ' };
assert.deepEqual(assistantSegments([think, moreThink, text, call, empty]).map(part => [part.kind, part.start]), [
['reasoning', 0], ['body', 2], ['reasoning', 4],
]);
const data: AssistantChatData = { status: 'running', turn: 1, step: 0, blocks: [think, moreThink, text, call], time: 1 };
const node = {
key: 'a', id: 'a', kind: 'assistant-step', target: 'chat', data, anchorSeq: 10, visibility: 'visible',
location: { kind: 'step', step: { step: 0 } },
} as unknown as ChatConversationViewNode;
const turn = { turn: 1, steps: [{ step: 0, start: { seq: 10 }, data: { get: () => data } }] } as unknown as TurnLocation;
const flow = readerFlow({ key: 'turn:1', turn: 1, keys: ['a'] }, turn, key => key === 'a' ? node : undefined);
const steps = segmentLiveTurn(flow, key => key === 'a' ? node : undefined);
assert.deepEqual(steps.map(step => step.kind), ['reasoning', 'body', 'tool']);
assert.equal(steps[0]?.kind === 'reasoning' && steps[0].blocks.length, 2);
if (steps[0]?.kind !== 'reasoning') throw new Error('missing reasoning');
assert.equal(steps[0].blocks[0], think);
assert.equal(steps[0].blocks[1], moreThink);
const blankData: AssistantChatData = { ...data, blocks: [empty, text] };
const blank = { ...node, data: blankData } as unknown as ChatConversationViewNode;
const blankTurn = { turn: 1, steps: [{ step: 0, start: { seq: 10 }, data: { get: () => blankData } }] } as unknown as TurnLocation;
const blankFlow = readerFlow({ key: 'turn:1', turn: 1, keys: ['a'] }, blankTurn, () => blank);
assert.deepEqual(segmentLiveTurn(blankFlow, () => blank).map(step => step.kind), ['body']);
});
test('steering in the flow is a chain reset, same as a mid-turn user message', () => {
const think: AssistantBlock = { kind: 'reasoning', text: '先想' };
const text: AssistantBlock = { kind: 'text', text: '先说' };
const later: AssistantBlock = { kind: 'reasoning', text: '插入后再想' };
const first: AssistantChatData = { status: 'settled', turn: 1, step: 0, blocks: [think, text], time: 1 };
const second: AssistantChatData = { status: 'running', turn: 1, step: 1, blocks: [later], time: 2 };
const assistant = (key: string, seq: number, data: AssistantChatData) => ({
key, id: key, kind: 'assistant-step', target: 'chat', data, anchorSeq: seq, visibility: 'visible',
location: { kind: 'step', step: { step: data.step } },
}) as unknown as ChatConversationViewNode;
const steer = {
key: 'steer', id: 'steer', kind: 'steering', target: 'chat', data: { content: [{ type: 'text', text: '请改方向' }] },
anchorSeq: 15, visibility: 'visible', location: { kind: 'turn', turn: { turn: 1 } },
} as unknown as ChatConversationViewNode;
const nodes = new Map<string, ChatConversationViewNode>([
['a', assistant('a', 10, first)],
['steer', steer],
['b', assistant('b', 20, second)],
]);
const flow = readerFlow({ key: 'turn:1', turn: 1, keys: ['a', 'steer', 'b'] }, undefined, key => nodes.get(key));
const items = presentLiveTurn(segmentLiveTurn(flow, key => nodes.get(key)), open);
assert.deepEqual(kinds(items), [
['open', 'a:reasoning:0'], ['open', 'a:body:1'],
['user', 'steer'],
['open', 'b:reasoning:0'],
]);
});
test('disabling auto-fold keeps all steps open as plain streaming steps', () => {
const steps = [reasoning('1'), body('2'), tool('3'), reasoning('4'), tool('5'), reasoning('6')];
const items = presentLiveTurn(steps, open, false);
assert.equal(items.some(item => item.kind === 'fold'), false);
assert.deepEqual(items.map(item => item.key), ['1', '2', '3', '4', '5', '6']);
assert.deepEqual(items.map(item => item.kind), ['open', 'open', 'open', 'open', 'open', 'open']);
});
/** Issue #73: body, then a process run, then another body, then a later reasoning. */
function issue73Steps(): LiveStep[] {
return [
body('body1'),
reasoning('r1'), reasoning('r2'),
tool('t1'), tool('t2'), tool('t3'),
other('rec1'),
body('body2'),
reasoning('rLatest'),
];
}
test('open turn does not seam a run the live fold already summarises (#73)', () => {
const steps = issue73Steps();
const live = presentLiveTurn(steps, open, true);
const folds = live.filter(item => item.kind === 'fold');
assert.equal(folds.length, 1);
if (folds[0]?.kind !== 'fold') throw new Error('missing live fold');
assert.equal(folds[0].summary, '思考×2 · 工具×3 · 记录×1');
assert.deepEqual(folds[0].steps.map(step => step.key), ['r1', 'r2', 't1', 't2', 't3', 'rec1']);
const seams = planProcessSeams(steps, live, false);
assert.equal(seams.before.has('body2'), false);
assert.equal(seams.after.has('body1'), false);
assert.equal(seams.before.size, 0);
assert.equal(seams.after.size, 0);
});
test('closed turn keeps the seam between narration blocks and the previous body spacing (#73)', () => {
const steps = issue73Steps();
const live = presentLiveTurn(steps, completed, true);
assert.equal(live.some(item => item.kind === 'fold'), false);
const seams = planProcessSeams(steps, live, false);
assert.equal(seams.before.get('body2'), '思考×2 · 工具×3 · 记录×1');
assert.equal(seams.after.has('body1'), true);
const expanded = planProcessSeams(steps, live, true);
assert.equal(expanded.before.size, 0);
assert.equal(expanded.after.size, 0);
});