ds-harness-remote-fast/apps/android/tests/event-reducer.test.ts

631 lines
25 KiB
TypeScript

import { runScenarios, scenarioName } from '../../../scripts/test-scenarios.mjs'
import { describe, expect, it } from 'vitest'
import type { ChatItem, MuxStreamFrame, NativeSessionEvent } from '../src/types'
import { applyMuxFrame, applyMuxFrameToMessages, foldHistory, sessionRunningForMuxFrame } from '../src/state/event-reducer'
let syntheticSeq = 0
function sessionEvent(event: Partial<NativeSessionEvent> & { type: string; data: Record<string, unknown> }): NativeSessionEvent {
const seq = event.seq ?? syntheticSeq
syntheticSeq = Math.max(syntheticSeq, seq + 1)
return {
seq,
time: 1786000000000,
...event,
} as NativeSessionEvent
}
function frame(rpcId: string, payload: { type: string } & Record<string, unknown>): MuxStreamFrame {
return { rpcId, payload: payload as MuxStreamFrame['payload'] }
}
describe('remote mux frame reducer', () => {
it('keeps continued timed questions answerable across turn end and updates the same card', () => {
const id = 'timed-question:s1:c1'
let items = applyMuxFrame([], frame(id, { type: 'question/requested', sessionId: 's1', callId: 'c1',
questionState: 'open', deadline: 123, questions: [{ id: 'q1', question: 'Continue?' }] }))
items = applyMuxFrame(items, frame(id, { type: 'question/requested', sessionId: 's1', callId: 'c1',
questionState: 'continued', questions: [{ id: 'q1', question: 'Continue?' }] }))
items = applyMuxFrame(items, frame('', { type: 'session/event', sessionId: 's1',
event: sessionEvent({ type: 'turn/end', data: {} }) }))
expect(items).toHaveLength(1)
expect(items[0]).toMatchObject({ kind: 'question', callId: 'c1', questionState: 'continued' })
expect(items[0]).not.toHaveProperty('deadline')
expect((items[0] as { outcome?: string }).outcome).toBeUndefined()
items = applyMuxFrame(items, frame('', { type: 'question/resolved', sessionId: 's1', questionRpcId: id, outcome: 'answered' }))
expect(items[0]).toMatchObject({ outcome: 'answered' })
})
it('projects Harness turn lifecycle into the session running state', () => {
const start = frame('', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({ type: 'turn/start', data: {} }),
})
const end = frame('', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({ type: 'turn/end', data: {} }),
})
expect(sessionRunningForMuxFrame(start)).toBe(true)
expect(sessionRunningForMuxFrame(end)).toBe(false)
const step = frame('', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({ type: 'step/start', data: {} }),
})
expect(sessionRunningForMuxFrame(step)).toBeUndefined()
})
it('settles an older stream at turn/start without changing its reply anchor', () => {
const original: ChatItem[] = [{ kind: 'message', id: 'old', sessionId: 's1', role: 'assistant',
text: 'partial', streaming: true, turn: '3', createdAt: 1000, nativeSeq: 10, nativeTime: 1000 }]
const start = sessionEvent({ type: 'turn/start', seq: 20, time: 2000, data: { turn: 4 } })
expect(applyMuxFrame(original, frame('', { type: 'session/event', sessionId: 's1', event: start }))[0])
.toMatchObject({ streaming: false, nativeSeq: 10, nativeTime: 1000, turn: '3' })
})
it('retains turn-end evidence without moving message and tool sequence anchors', async () => {
const rows = [
['completed', 'completed'],
['aborted', 'stopped'],
['interrupted', 'stopped'],
['error', 'failed'],
['blocked', 'failed'],
['max-tokens', 'failed'],
['forked', 'failed'],
] as const
await runScenarios(
rows.map((row, index) => {
const [kind, reason] = row
return {
name: scenarioName(
'retains %s turn-end evidence without moving message and tool sequence anchors',
row,
index,
),
run: () => {
const events = [
sessionEvent({
type: 'assistant/message',
seq: 10,
time: 1000,
data: {
turn: 3,
step: 1,
message: { id: 'reply', content: [{ type: 'text', text: 'Working' }] },
},
}),
sessionEvent({
type: 'tool/call',
seq: 11,
time: 1100,
data: { turn: 3, name: 'bash', callId: 'call', arguments: '{"command":"true"}' },
}),
sessionEvent({
type: 'assistant/message',
seq: 12,
time: 1200,
data: {
turn: 4,
step: 1,
message: { id: 'other', content: [{ type: 'text', text: 'Another turn' }] },
},
}),
]
const original = foldHistory(
events.map((event) => ({ event })),
's1',
)
const end = sessionEvent({
type: 'turn/end',
seq: 13,
time: 1300,
data: { turn: 3, reason: { kind } },
})
const live = applyMuxFrame(
original,
frame('', { type: 'session/event', sessionId: 's1', event: end }),
)
const history = foldHistory(
[...events, end].map((event) => ({ event })),
's1',
)
expect(live).toEqual(history)
expect(live.slice(0, 2).map((item) => item.turnEnd)).toEqual([
{ reason, time: 1300 },
{ reason, time: 1300 },
])
expect(live.map((item) => item.nativeSeq)).toEqual([10, 11, 12])
expect(live.map((item) => item.nativeTime)).toEqual([1000, 1100, 1200])
expect(live[2]).toBe(original[2])
expect(live[1]).toMatchObject({ toolKey: 'bash', state: 'failed' })
},
}
}),
)
})
it('preserves failure evidence when a turn has no non-user activity', async () => {
const prompt = sessionEvent({ type: 'user/message', seq: 1, time: 1001,
data: { turn: 1, message: { id: 'prompt', source: { kind: 'user', rpcId: 'rpc' },
content: [{ type: 'text', text: 'hello' }] } } })
await runScenarios([
{ name: 'failure before any history', events: [], reason: { kind: 'error', error: { message: 'rate limited' } }, failed: true },
{ name: 'failure after the user prompt', events: [prompt], reason: { kind: 'error', error: { message: 'rate limited' } }, failed: true },
{ name: 'failure with hidden context', events: [prompt, sessionEvent({ type: 'developer/message', seq: 2,
data: { turn: 1, message: { id: 'context', content: [{ type: 'text', text: 'context' }] } } })],
reason: { kind: 'error', error: { message: 'rate limited' } }, failed: true },
{ name: 'completion after the user prompt', events: [prompt], reason: { kind: 'completed' }, failed: false },
{ name: 'user stop after the prompt', events: [prompt], reason: { kind: 'aborted' }, failed: false },
{ name: 'legacy end without failure evidence', events: [prompt], reason: undefined, failed: false },
].map(({ name, events, reason, failed }) => ({ name, run: () => {
const end = sessionEvent({ type: 'turn/end', seq: 3, time: 1002, data: { turn: 1, reason } })
const original = foldHistory(events.map(event => ({ event })), 's1', true)
const live = applyMuxFrame(original, frame('', { type: 'session/event', sessionId: 's1', event: end }))
expect(live).toEqual(foldHistory([...events, end].map(event => ({ event })), 's1', true))
const activity = live.filter(item => item.kind !== 'message' || (item.role === 'assistant' && !item.context))
expect(activity).toHaveLength(failed ? 1 : 0)
if (failed) expect(activity[0]).toMatchObject({ kind: 'message', role: 'assistant', turn: '1',
turnEnd: { reason: 'failed', time: 1002, detail: 'rate limited' } })
// Repeated end frames must update the evidence without duplicating a row.
expect(applyMuxFrame(live, frame('', { type: 'session/event', sessionId: 's1', event: end }))).toEqual(live)
if (events.length > 0) expect(live[0]).toMatchObject({ id: 'prompt', nativeSeq: 1, nativeTime: 1001 })
} })))
})
it('preserves assistant text and reasoning through stream finalization', async () => {
await runScenarios([
{
name: 'assembles streaming assistant chunks into a finalized message',
run: () => {
const chunk: MuxStreamFrame = frame('', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({
type: 'assistant/chunk',
data: { turn: 1, step: 1, chunk: { type: 'text-delta', index: 0, text: 'Hello ' } },
}),
})
const chunkTwo: MuxStreamFrame = frame('', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({
type: 'assistant/chunk',
data: { turn: 1, step: 1, chunk: { type: 'text-delta', index: 0, text: 'Android' } },
}),
})
const finalized: MuxStreamFrame = frame('', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({
type: 'assistant/message',
data: {
turn: 1,
step: 1,
message: { id: 'm1', role: 'assistant', content: [{ type: 'text', text: 'Hello Android' }] },
},
}),
})
let items = applyMuxFrame([], chunk)
items = applyMuxFrame(items, chunkTwo)
expect(items).toMatchObject([
{ kind: 'message', role: 'assistant', text: 'Hello Android', streaming: true },
])
items = applyMuxFrame(items, finalized)
expect(items).toEqual([
expect.objectContaining({ kind: 'message', id: 'm1', role: 'assistant', text: 'Hello Android' }),
])
expect(items[0]).not.toHaveProperty('streaming')
},
},
{
name: 'keeps reasoning separate while it streams and after the answer is finalized',
run: () => {
const events = [
sessionEvent({
type: 'assistant/chunk',
data: { turn: 1, step: 1, chunk: { type: 'reasoning-delta', index: 0, text: '先检查' } },
}),
sessionEvent({
type: 'assistant/chunk',
data: { turn: 1, step: 1, chunk: { type: 'reasoning-delta', index: 0, text: '状态。' } },
}),
sessionEvent({
type: 'assistant/chunk',
data: { turn: 1, step: 1, chunk: { type: 'text-delta', index: 0, text: '已完成。' } },
}),
]
let items = foldHistory(
events.map((event) => ({ event })),
's1',
)
expect(items).toEqual([
expect.objectContaining({
kind: 'message',
text: '已完成。',
reasoning: '先检查状态。',
streaming: true,
streamingPhase: 'text',
}),
])
items = applyMuxFrame(
items,
frame('', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({
type: 'assistant/message',
data: {
turn: 1,
step: 1,
message: {
id: 'm-reasoning',
role: 'assistant',
content: [{ type: 'text', text: '已完成。' }],
},
},
}),
}),
)
expect(items).toEqual([
expect.objectContaining({
id: 'm-reasoning',
text: '已完成。',
reasoning: '先检查状态。',
}),
])
expect(items[0]).not.toHaveProperty('streamingPhase')
},
},
{
name: 'keeps visible streamed text when the final assistant event has no text',
run: () => {
const visibleChunk = sessionEvent({
type: 'assistant/chunk',
data: { turn: 1, step: 1, chunk: { type: 'text-delta', index: 0, text: '完成' } },
})
const emptyFinal = sessionEvent({
type: 'assistant/message',
data: {
turn: 1,
step: 1,
message: { id: 'm1', role: 'assistant', content: [{ type: 'tool-call', callId: 'c1' }] },
},
})
expect(foldHistory([{ event: visibleChunk }, { event: emptyFinal }], 's1')).toEqual([
expect.objectContaining({ kind: 'message', id: 'm1', text: '完成' }),
])
},
},
])
}, 15000)
it('adds user messages and tool activities from history events', () => {
const events = [
sessionEvent({
type: 'user/message',
data: { message: { id: 'u1', role: 'user', content: [{ type: 'text', text: 'Check the repo' }], source: { kind: 'user' } } },
}),
sessionEvent({ type: 'tool/call', data: { callId: 'c1', name: 'bash', arguments: '{"command":"git status"}' } }),
]
const items = foldHistory(events.map(event => ({ event })), 's1')
expect(items).toMatchObject([
{ kind: 'message', id: 'u1', role: 'user', text: 'Check the repo' },
{ kind: 'tool', id: 'c1', toolName: 'bash', state: 'running' },
])
})
it('projects safe user image blocks from native history', async () => {
await runScenarios([
{
name: 'keeps image-only user prompts visible in history',
run: () => {
const event = sessionEvent({
type: 'user/message',
data: {
message: {
id: 'u-image',
role: 'user',
content: [{ type: 'image', attachmentId: 'attachment-1', name: 'diagram.png' }],
source: { kind: 'user' },
},
},
})
expect(foldHistory([{ event }], 's1')).toEqual([
expect.objectContaining({
kind: 'message',
id: 'u-image',
role: 'user',
text: '',
images: [{ attachmentId: 'attachment-1', sessionId: 's1', name: 'diagram.png' }],
}),
])
},
},
{
name: 'retains image-only assistant and nested tool results from native history',
run: () => {
const image = { type: 'image', attachment: { attachmentId: 'ai-image', name: 'result.png' } }
const assistant = sessionEvent({ type: 'assistant/message', data: { message: { id: 'ai', content: [image] } } })
const call = sessionEvent({ type: 'tool/call', data: { callId: 'c1', name: 'read_image' } })
const result = sessionEvent({ type: 'tool/result', data: { callId: 'c1', message: {
content: [{ type: 'tool-result', content: [image] }],
} } })
const rows = foldHistory([{ event: assistant }, { event: call }, { event: result }], 's1')
expect(rows).toHaveLength(2)
for (const row of rows) expect(row).toMatchObject({ images: [{ attachmentId: 'ai-image', sessionId: 's1', name: 'result.png' }] })
},
},
{
name: 'renders safe data image blocks from native history',
run: () => {
const event = sessionEvent({
type: 'user/message',
data: {
message: {
id: 'u-data-image',
role: 'user',
content: [
{ type: 'image', url: 'data:image/png;base64,aW1hZ2U=', name: 'screen.png' },
{ type: 'image', url: 'https://example.test/not-allowed.png', name: 'external.png' },
],
source: { kind: 'user' },
},
},
})
expect(foldHistory([{ event }], 's1')).toEqual([
expect.objectContaining({
kind: 'message',
id: 'u-data-image',
role: 'user',
images: [{ uri: 'data:image/png;base64,aW1hZ2U=', name: 'screen.png' }],
}),
])
},
},
])
}, 10000)
it('merges a tool result using message.source.callId and uses native views', () => {
const call = sessionEvent({
type: 'tool/call',
data: { callId: 'c1', name: 'run_code', arguments: '{"code":"long input"}' },
})
const result = sessionEvent({
type: 'tool/result',
data: { message: { source: { callId: 'c1' } }, content: [{ type: 'text', text: 'private output' }] },
})
const items = foldHistory([
{ event: call, view: { for: 'call', view: { title: '运行代码', description: '检查 PowerShell 脚本' } } },
{ event: result, view: { for: 'result', view: { title: '运行代码' } } },
], 's1')
expect(items).toEqual([expect.objectContaining({
kind: 'tool', id: 'c1', toolName: '运行代码', summary: '检查 PowerShell 脚本', state: 'finished',
})])
})
it('reconciles an optimistic user message through the native prompt rpcId', () => {
const optimistic: ChatItem = {
kind: 'message',
id: 'local-1',
sessionId: 's1',
role: 'user',
text: 'Check the repo',
requestRpcId: 'prompt-rpc-1',
createdAt: 1,
}
const echoed = frame('push-1', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({
type: 'user/message',
data: {
message: {
id: 'user-message-1',
role: 'user',
content: [{ type: 'text', text: 'Check the repo' }],
source: { kind: 'user', rpcId: 'prompt-rpc-1' },
},
},
}),
})
expect(applyMuxFrame([optimistic], echoed)).toEqual([
expect.objectContaining({ id: 'user-message-1', text: 'Check the repo' }),
])
})
it('routes aggregated mux frames to their owning session', () => {
const s2Approval = frame('rpc-approval-s2', {
type: 'approval/requested',
sessionId: 's2',
approvalId: 'approval-s2',
toolName: 'bash',
})
const messages = applyMuxFrameToMessages({ s1: [] }, s2Approval)
expect(messages.s1).toEqual([])
expect(messages.s2).toEqual([
expect.objectContaining({ sessionId: 's2', frameRpcId: 'rpc-approval-s2' }),
])
})
it('correlates and settles approval and question requests', async () => {
await runScenarios([
{
name: 'adds and resolves approval requests with the frame rpcId',
run: () => {
const requested: MuxStreamFrame = frame('rpc-approval-1', {
type: 'approval/requested',
sessionId: 's1',
approvalId: 'a1',
toolName: 'bash',
reason: 'Run npm test',
})
const resolved: MuxStreamFrame = frame('', {
type: 'approval/resolved',
sessionId: 's1',
approvalId: 'a1',
outcome: 'allowed-once',
})
let items = applyMuxFrame([], requested)
expect(items).toMatchObject([
{
kind: 'approval',
id: 'approval:a1',
approvalId: 'a1',
frameRpcId: 'rpc-approval-1',
toolName: 'bash',
},
])
items = applyMuxFrame(items, resolved)
expect(items).toMatchObject([{ kind: 'approval', outcome: 'allowed-once' }])
},
},
{
name: 'adds and resolves question requests',
run: () => {
const requested: MuxStreamFrame = frame('rpc-question-1', {
type: 'question/requested',
sessionId: 's1',
questions: [{ id: 'q1', question: 'Continue?', options: [{ label: 'Yes' }, { label: 'No' }] }],
})
const resolved: MuxStreamFrame = frame('', {
type: 'question/resolved',
sessionId: 's1',
questionRpcId: 'rpc-question-1',
outcome: 'answered',
})
let items = applyMuxFrame([], requested)
expect(items).toMatchObject([
{ kind: 'question', frameRpcId: 'rpc-question-1', questions: [{ id: 'q1' }] },
])
items = applyMuxFrame(items, resolved)
expect(items).toMatchObject([{ kind: 'question', outcome: 'answered' }])
},
},
{
name: 'settles approval and question requests when their owning turn ends',
run: () => {
const tool = sessionEvent({
type: 'tool/call',
seq: 10,
data: { turn: 3, name: 'bash', callId: 'call' },
})
const current = foldHistory([{ event: tool }], 's1')
const approval = frame('rpc-approval-2', {
type: 'approval/requested',
sessionId: 's1',
approvalId: 'a2',
toolName: 'bash',
})
const question = frame('rpc-question-2', {
type: 'question/requested',
sessionId: 's1',
questions: [{ id: 'q2', question: 'Continue?' }],
})
const end = frame('', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({
type: 'turn/end',
seq: 13,
data: { turn: 3, reason: { kind: 'aborted' } },
}),
})
const items = applyMuxFrame(applyMuxFrame(applyMuxFrame(current, approval), question), end)
expect(items).toMatchObject([
{ kind: 'tool', state: 'failed' },
{ kind: 'approval', turn: '3', outcome: 'unavailable' },
{ kind: 'question', turn: '3', outcome: 'cancelled' },
])
},
},
{
name: 'attaches background questions and approvals arriving before turn/start or tool/call to the active turn and revives re-emitted cards',
run: () => {
const closedTurn = foldHistory([
{ event: sessionEvent({ type: 'assistant/message', seq: 1, data: { turn: 1, message: { id: 'a1', role: 'assistant', content: [{ type: 'text', text: 'Done' }] } } }) },
{ event: sessionEvent({ type: 'turn/end', seq: 2, data: { turn: 1, reason: { kind: 'completed' } } }) },
], 's1')
const backgroundQuestion = frame('rpc-question-bg', {
type: 'question/requested',
sessionId: 's1',
questions: [{ id: 'q-bg', question: 'Which branch?' }],
})
const backgroundApproval = frame('rpc-approval-bg', {
type: 'approval/requested',
sessionId: 's1',
approvalId: 'app-bg',
toolName: 'bash',
})
const withPending = applyMuxFrame(applyMuxFrame(closedTurn, backgroundQuestion), backgroundApproval)
expect(withPending.find(item => item.kind === 'question')?.turn).toBeUndefined()
expect(withPending.find(item => item.kind === 'question')?.outcome).toBeUndefined()
expect(withPending.find(item => item.kind === 'approval')?.turn).toBeUndefined()
expect(withPending.find(item => item.kind === 'approval')?.outcome).toBeUndefined()
const turnStart = frame('', {
type: 'session/event',
sessionId: 's1',
event: sessionEvent({ type: 'turn/start', seq: 3, data: { turn: 2 } }),
})
const afterStart = applyMuxFrame(withPending, turnStart)
expect(afterStart.find(item => item.kind === 'question')).toMatchObject({
kind: 'question',
turn: '2',
})
expect(afterStart.find(item => item.kind === 'question')?.outcome).toBeUndefined()
expect(afterStart.find(item => item.kind === 'approval')).toMatchObject({
kind: 'approval',
turn: '2',
})
expect(afterStart.find(item => item.kind === 'approval')?.outcome).toBeUndefined()
// If settled prematurely, a re-emitted live request frame revives the card.
const cancelled = applyMuxFrame(afterStart, frame('', {
type: 'question/resolved',
sessionId: 's1',
questionRpcId: 'rpc-question-bg',
outcome: 'cancelled',
}))
expect(cancelled.find(item => item.kind === 'question')?.outcome).toBe('cancelled')
const revived = applyMuxFrame(cancelled, backgroundQuestion)
expect(revived.find(item => item.kind === 'question')?.outcome).toBeUndefined()
},
},
])
}, 15000)
})
describe('image attachment metadata tolerance', () => {
it('reads image metadata from alternate attachment field names', () => {
const event = sessionEvent({
type: 'user/message',
data: {
message: {
id: 'u-meta', role: 'user', source: { kind: 'user' },
content: [{ type: 'image', attachment: {
attachmentId: 'a1', mimeType: 'image/png', byteLength: 79, size: 79,
imageWidth: 4, imageHeight: 2, fileName: 'diagram.png',
} }],
},
},
})
expect(foldHistory([{ event }], 's1')).toEqual([
expect.objectContaining({
kind: 'message', id: 'u-meta', role: 'user',
images: [{
attachmentId: 'a1', sessionId: 's1', name: 'diagram.png',
mediaType: 'image/png', bytes: 79, width: 4, height: 2,
}],
}),
])
})
})