weichen
099a92022d
Why: Fast and slow channel cards duplicate across panes and completed replies hide process output. Evidence: npm test; npm run build; 12 isolated Playwright scenarios with reload and responsive widths. Impact: Preserve ordered folded process history, load durable run events, and give work cards one detailed pane. Refs: Agent-System-Dev feature/work-companion-visibility UI1 UI2 UI3
231 lines
12 KiB
TypeScript
231 lines
12 KiB
TypeScript
// live 流式投影纯逻辑测试（中栏过程/回复分离）：到达序并段、process 标记时机、
|
|
// 轮次穿插同构、过程区折叠谓词。
|
|
import { describe, it, expect } from 'vitest'
|
|
import {
|
|
applyTextDelta, applyThinkingDelta, applyToolCall, applyToolCallDelta, applyToolResult, applyToolOutput, applyArtifactCreated,
|
|
applyCheck, applyFinalizing,
|
|
hasSettledReply, liveToMessage, livePhaseLabel, showProcessInline, type LiveItem,
|
|
runEventsToTimeline,
|
|
} from '../src/live'
|
|
import type { StreamEvent } from '../src/contracts'
|
|
import type { LiveState } from '../src/store'
|
|
|
|
function live(over: Partial<LiveState> = {}): LiveState {
|
|
return { runId: 'r1', phase: 'thinking', items: [], agentNotes: {}, startedAt: 0, ...over }
|
|
}
|
|
|
|
// 两轮流式事件回放：思考→解说文本→工具→思考→最终回复（与后端事件序一致）。
|
|
function twoTurnItems(): LiveItem[] {
|
|
let items: LiveItem[] = []
|
|
items = applyThinkingDelta(items, '先想想', 0)
|
|
items = applyThinkingDelta(items, '一下', 0)
|
|
items = applyTextDelta(items, 0, '我先更新待办。')
|
|
items = applyToolCall(items, 'update_todos', 'c1')
|
|
items = applyToolResult(items, 'c1', 'ok', '已更新')
|
|
items = applyThinkingDelta(items, '再想想', 0)
|
|
items = applyTextDelta(items, 1, '最终')
|
|
items = applyTextDelta(items, 1, '回复')
|
|
return items
|
|
}
|
|
|
|
describe('applyThinkingDelta / applyTextDelta', () => {
|
|
it('merges thinking deltas into the last thinking segment', () => {
|
|
let items: LiveItem[] = []
|
|
items = applyThinkingDelta(items, '先', 0)
|
|
items = applyThinkingDelta(items, '想想', 0)
|
|
expect(items).toEqual([{ kind: 'thinking', text: '先想想', startedAt: 0, endedAt: 0 }])
|
|
})
|
|
it('opens a new thinking segment after text/tool (turn boundary)', () => {
|
|
let items: LiveItem[] = applyThinkingDelta([], '第一轮思考', 0)
|
|
items = applyTextDelta(items, 0, '解说')
|
|
items = applyThinkingDelta(items, '第二轮思考', 0)
|
|
expect(items).toEqual([
|
|
{ kind: 'thinking', text: '第一轮思考', startedAt: 0, endedAt: 0 },
|
|
{ kind: 'text', index: 0, text: '解说' },
|
|
{ kind: 'thinking', text: '第二轮思考', startedAt: 0, endedAt: 0 },
|
|
])
|
|
})
|
|
it('appends text to the last segment when index matches', () => {
|
|
let items: LiveItem[] = []
|
|
items = applyTextDelta(items, 0, '先查')
|
|
items = applyTextDelta(items, 0, '一下')
|
|
expect(items).toEqual([{ kind: 'text', index: 0, text: '先查一下' }])
|
|
})
|
|
it('opens a new text segment when index advances (new turn)', () => {
|
|
let items: LiveItem[] = applyTextDelta([], 0, '解说')
|
|
items = applyTextDelta(items, 1, '最终')
|
|
items = applyTextDelta(items, 1, '回复')
|
|
expect(items).toEqual([
|
|
{ kind: 'text', index: 0, text: '解说' },
|
|
{ kind: 'text', index: 1, text: '最终回复' },
|
|
])
|
|
})
|
|
it('fills the most recent pending tool call (callId match, tail fallback)', () => {
|
|
let items: LiveItem[] = []
|
|
items = applyToolCall(items, 'a', 'ca')
|
|
items = applyToolCall(items, 'b', 'cb')
|
|
items = applyToolResult(items, 'cb', 'ok', '结果')
|
|
expect(items).toEqual([
|
|
{ kind: 'tool', callId: 'ca', name: 'a', args: '', state: 'running', startedAt: 0, endedAt: 0, output: '' },
|
|
{ kind: 'tool', callId: 'cb', name: 'b', args: '', state: 'done', startedAt: 0, endedAt: 0, output: '', status: 'ok', summary: '结果' },
|
|
])
|
|
items = applyToolResult(items, undefined, 'ok')
|
|
expect(items[0]).toMatchObject({ kind: 'tool', callId: 'ca', name: 'a', state: 'done', status: 'ok' })
|
|
})
|
|
it('walks a tool from composing to running to done, and marks the narration as process', () => {
|
|
let items: LiveItem[] = applyTextDelta([], 0, '我来生成文档。')
|
|
items = applyToolCallDelta(items, 0, '{"script":', 'c1', 'run_python', 1000)
|
|
items = applyToolCallDelta(items, 0, '"print(1)"}', undefined, undefined, 1100)
|
|
const composing = liveToMessage(live({ items }))
|
|
expect(composing.parts[0].process).toBe(true)
|
|
expect(composing.parts[1]).toMatchObject({ type: 'tool_call', toolPhase: 'composing', toolCall: { name: 'run_python', arguments: '{"script":"print(1)"}' } })
|
|
items = applyToolCall(items, 'run_python', 'c1', undefined, 2000)
|
|
items = applyToolOutput(items, 'c1', 'hello\n')
|
|
items = applyToolResult(items, 'c1', 'ok', 'exit=0', 3500)
|
|
const done = liveToMessage(live({ items }))
|
|
expect(done.parts[1]).toMatchObject({ toolPhase: 'done', toolOutput: 'hello\n', toolCall: { durationMs: 1500 } })
|
|
expect(done.parts[2]).toMatchObject({ type: 'tool_result', toolResult: { summary: 'exit=0' } })
|
|
})
|
|
})
|
|
|
|
describe('liveToMessage', () => {
|
|
it('interleaves parts per turn in arrival order, matching persisted parts', () => {
|
|
const msg = liveToMessage(live({ items: twoTurnItems() }))
|
|
expect(msg.parts).toEqual([
|
|
{ type: 'thinking', text: '先想想一下', process: true },
|
|
{ type: 'text', text: '我先更新待办。', process: true },
|
|
{ type: 'tool_call', process: true, toolCall: { id: 'c1', name: 'update_todos' }, toolPhase: 'done' },
|
|
{ type: 'tool_result', process: true, toolCall: { id: 'c1', name: 'update_todos' },
|
|
toolResult: { callId: 'c1', status: 'ok', summary: '已更新' } },
|
|
{ type: 'thinking', text: '再想想', process: true },
|
|
{ type: 'text', text: '最终回复' },
|
|
])
|
|
})
|
|
it('marks the in-flight segment as process the moment its tool call arrives', () => {
|
|
let items: LiveItem[] = []
|
|
items = applyTextDelta(items, 0, '我先查一下')
|
|
const before = liveToMessage(live({ items }))
|
|
expect(before.parts.map(p => p.process)).toEqual([undefined]) // 尚无工具：仍在回复位
|
|
items = applyToolCall(items, 'web_search')
|
|
const after = liveToMessage(live({ items }))
|
|
expect(after.parts.map(p => p.process)).toEqual([true, true]) // tool.call 一到即改标
|
|
})
|
|
it('single final segment without tools carries no process flag', () => {
|
|
let items: LiveItem[] = []
|
|
items = applyTextDelta(items, 0, '直接回答')
|
|
const msg = liveToMessage(live({ items }))
|
|
expect(msg.parts.map(p => p.process)).toEqual([undefined])
|
|
})
|
|
it('tools between segments keep every non-final segment in the process area', () => {
|
|
let items: LiveItem[] = []
|
|
items = applyTextDelta(items, 0, '第一轮')
|
|
items = applyToolCall(items, 'a')
|
|
items = applyToolResult(items, undefined, 'ok')
|
|
items = applyTextDelta(items, 1, '第二轮')
|
|
items = applyToolCall(items, 'b')
|
|
items = applyTextDelta(items, 2, '最终回复')
|
|
const msg = liveToMessage(live({ items }))
|
|
expect(msg.parts.filter(p => p.type === 'text').map(p => p.process)).toEqual([true, true, undefined])
|
|
// 顺序必须与落库穿插序一致：text → tool → text → tool → text。
|
|
expect(msg.parts.map(p => p.type)).toEqual(['text', 'tool_call', 'tool_result', 'text', 'tool_call', 'text'])
|
|
})
|
|
it('thinking and tool parts are always process', () => {
|
|
let items: LiveItem[] = []
|
|
items = applyThinkingDelta(items, '想', 0)
|
|
items = applyTextDelta(items, 0, '答')
|
|
items = applyToolCall(items, 'web_search')
|
|
items = applyToolResult(items, undefined, 'ok', '命中')
|
|
const msg = liveToMessage(live({ items }))
|
|
for (const p of msg.parts.filter(p => p.type !== 'text')) expect(p.process).toBe(true)
|
|
})
|
|
it('does not project deliverable cards while the run is live', () => {
|
|
let items: LiveItem[] = []
|
|
items = applyTextDelta(items, 0, '生成报表。')
|
|
items = applyToolCall(items, 'make_report', 'c1')
|
|
items = applyToolResult(items, 'c1', 'ok')
|
|
items = applyArtifactCreated(items, { artifactId: 'a1', name: 'report.csv', kind: 'csv' })
|
|
items = applyTextDelta(items, 1, '完成。')
|
|
const msg = liveToMessage(live({ items }))
|
|
expect(msg.parts.some(p => p.type === 'artifact_ref')).toBe(false)
|
|
expect(msg.parts.filter(p => p.type === 'text').map(p => p.process)).toEqual([true, undefined])
|
|
})
|
|
it('moves earlier text into the process area once finalizing starts', () => {
|
|
let items: LiveItem[] = applyTextDelta([], 0, '草稿回复')
|
|
items = applyCheck(items, false, '纸张不是 A4')
|
|
items = applyFinalizing(items)
|
|
items = applyTextDelta(items, 1, '纪要已写好。')
|
|
const msg = liveToMessage(live({ phase: 'finalizing', items }))
|
|
expect(msg.parts.map(p => p.type)).toEqual(['text', 'check', 'text'])
|
|
expect(msg.parts.filter(p => p.type === 'text').map(p => p.process)).toEqual([true, undefined])
|
|
expect(msg.parts[1]).toMatchObject({ type: 'check', process: true, check: { passed: false, reason: '纸张不是 A4' } })
|
|
})
|
|
})
|
|
|
|
it('reopens the ordered complete process from persisted run events', () => {
|
|
const output = 'x'.repeat(5000)
|
|
const event = (seq: number, type: StreamEvent['type'], payload: unknown): StreamEvent =>
|
|
({ seq, type, payload, runId: 'r1', conversationId: 'c1', ts: '2026-10-14T10:00:00Z', v: 1 })
|
|
const parts = runEventsToTimeline([
|
|
event(1, 'thinking.delta', { index: 0, text: '先核对' }),
|
|
event(2, 'message.delta', { index: 0, text: '开始读取材料' }),
|
|
event(3, 'tool.call', { callId: 'call1', name: 'fs_read_file', arguments: '{"path":"a.txt"}' }),
|
|
event(4, 'tool.output', { callId: 'call1', text: output }),
|
|
event(5, 'tool.result', { callId: 'call1', status: 'ok', summary: '读取成功' }),
|
|
event(6, 'run.phase', { phase: 'finalizing' }),
|
|
event(7, 'message.delta', { index: 1, text: '最终回复' }),
|
|
])
|
|
expect(parts.map(part => part.type)).toEqual(['thinking', 'text', 'tool_call', 'tool_result'])
|
|
expect((parts[2] as typeof parts[number] & { toolOutput: string }).toolOutput).toBe(output)
|
|
expect(parts.some(part => part.text === '最终回复')).toBe(false)
|
|
})
|
|
|
|
describe('livePhaseLabel', () => {
|
|
it('names the current activity in Chinese', () => {
|
|
let items: LiveItem[] = applyThinkingDelta([], '想', 0)
|
|
expect(livePhaseLabel(live({ items }), 0)).toBe('思考中')
|
|
items = applyToolCallDelta(items, 0, '{}', 'c', 'run_python', 0)
|
|
expect(livePhaseLabel(live({ items }), 0)).toBe('正在编写 run_python')
|
|
items = applyToolCall(items, 'run_python', 'c', undefined, 1000)
|
|
expect(livePhaseLabel(live({ items }), 4000)).toBe('正在运行 run_python · 3 秒')
|
|
items = applyToolResult(items, 'c', 'ok', 'done', 4000)
|
|
items = applyTextDelta(items, 1, '好了')
|
|
expect(livePhaseLabel(live({ items }), 4000)).toBe('回复中')
|
|
expect(livePhaseLabel(live({ items, phase: 'finalizing' }), 4000)).toBe('整理回复中')
|
|
})
|
|
})
|
|
|
|
describe('showProcessInline', () => {
|
|
it('keeps live technical records folded under the default reading preference', () => {
|
|
expect(showProcessInline(live({ phase: 'thinking' }), true)).toBe(false)
|
|
expect(showProcessInline(live({ phase: 'acting' }), true)).toBe(false)
|
|
expect(showProcessInline(live({ phase: 'responding' }), true)).toBe(false)
|
|
})
|
|
it('honors the advanced preference to expose live records', () => {
|
|
expect(showProcessInline(live({ phase: 'acting' }), false)).toBe(true)
|
|
})
|
|
it('records thinking duration from the first delta to the last', () => {
|
|
let items: LiveItem[] = applyThinkingDelta([], '先', 1000)
|
|
items = applyThinkingDelta(items, '想想', 2500)
|
|
const msg = liveToMessage(live({ items }))
|
|
expect(msg.parts[0]).toMatchObject({ type: 'thinking', text: '先想想', durationMs: 1500 })
|
|
})
|
|
it('falls back to the auto-collapse preference when no live run', () => {
|
|
expect(showProcessInline(null, true)).toBe(false)
|
|
expect(showProcessInline(null, false)).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe('hasSettledReply', () => {
|
|
const user = { role: 'user', runId: 'r1' }
|
|
const assistant = { role: 'assistant', runId: 'r1' }
|
|
|
|
it('stays false while only the user message carries the run id', () => {
|
|
expect(hasSettledReply([user], 'r1')).toBe(false)
|
|
expect(hasSettledReply([user, { role: 'assistant', runId: 'other' }], 'r1')).toBe(false)
|
|
})
|
|
|
|
it('turns true once an assistant message for that run is stored', () => {
|
|
expect(hasSettledReply([user, assistant], 'r1')).toBe(true)
|
|
})
|
|
})
|