631 lines
25 KiB
TypeScript
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,
|
|
}],
|
|
}),
|
|
])
|
|
})
|
|
})
|