import test from 'node:test'; import assert from 'node:assert/strict'; import { beginAnalysisSubmission, submissionOutcomeUnknown } from '../src/analysisSubmission.ts'; import { createAnalysisSessionClient } from '../src/agent/sessionClient.ts'; const tick = () => new Promise(resolve => setImmediate(resolve)); const deferred = () => { let resolve, reject; const promise = new Promise((yes, no) => { resolve = yes; reject = no; }); return { promise, resolve, reject }; }; const saved = (id, status, extras = {}) => ({ id, question: 'saved question', status, ...extras }); const page = (id, turns = [], extra = {}) => ({ id, turns, ...extra }); function fixture(t, overrides = {}, initialPages = { 'session-1': page('session-1') }) { const pages = { ...initialPages }; const requests = { starts: [], cancels: [], retries: [], follows: [] }; const transport = { analysisSessions: async () => ({ items: Object.keys(pages).map(id => ({ id })) }), analysisSessionFollow: (id, { signal, onEvent }) => { const end = deferred(); requests.follows.push({ id, emit: onEvent, close: end.resolve }); signal.addEventListener('abort', end.resolve, { once: true }); onEvent({ event: 'snapshot', data: pages[id] || page(id) }); return end.promise; }, createAnalysisSession: async () => ({ session: { id: 'session-1' } }), startAnalysisTurn: async (id, body) => { requests.starts.push({ id, ...body }); const turn = saved('turn-1', 'QUEUED', { sessionId: id, question: body.question }); pages[id] = page(id, [...(pages[id]?.turns || []), turn], { activeTurnId: turn.id }); return { turn }; }, retryAnalysisTurn: async id => { requests.retries.push(id); throw new Error('Unexpected retry'); }, cancelAnalysisTurn: async id => { requests.cancels.push(id); for (const [sessionId, previous] of Object.entries(pages)) { const turns = previous.turns.map(turn => turn.id === id ? { ...turn, status: 'CANCELLED' } : turn); pages[sessionId] = { ...previous, turns, activeTurnId: previous.activeTurnId === id ? '' : previous.activeTurnId }; } return { status: 'CANCELLED', turnId: id }; }, ...overrides, }; const client = createAnalysisSessionClient({ userId: 'submission-fixture', transport }); t.after(client.dispose); return { client, pages, requests, state: client.getSnapshot }; } test('read-only history cannot submit or retry and keeps its saved turn', async t => { const legacy = saved('legacy-turn', 'FAILED', { result: { answer: 'saved answer' } }); const { client, requests, state } = fixture(t, {}, { 'session-1': page('session-1', [legacy], { readOnly: true }) }); await client.openSession('session-1'); assert.equal(await client.submit('new question'), false); assert.equal(await client.retry('legacy-turn'), false); assert.deepEqual(requests.starts, []); assert.deepEqual(requests.retries, []); assert.equal(state().turns[0].result.answer, 'saved answer'); assert.equal(state().busy, false); assert.equal(state().queuedQuestion, ''); }); test('unknown result retries reuse the key only for identical frozen submission', () => { const input = { sessionId: 's', question: 'q', generation: 1, context: { month: 9, year: 2026 } }; const prior = beginAnalysisSubmission(null, input, () => 'first-key'); prior.uncertain = true; prior.inFlight = false; assert.equal(beginAnalysisSubmission(prior, { ...input, context: { year: 2026, month: 9 } }, () => 'new-key'), prior); for (const change of [{ question: 'other' }, { sessionId: 'other' }, { generation: 2 }, { context: { month: 8, year: 2026 } }]) { assert.equal(beginAnalysisSubmission(prior, { ...input, ...change }, () => 'new-key').idempotencyKey, 'new-key'); } }); test('explicit client rejection differs from an unknown network/server outcome', () => { for (const status of [400, 401, 403, 404, 409, 413, 422, 429]) assert.equal(submissionOutcomeUnknown({ status }), false); for (const status of [0, 200, 408, 500, 502, 503]) assert.equal(submissionOutcomeUnknown({ status }), true); assert.equal(submissionOutcomeUnknown(new Error('connection lost')), true); }); test('stop during turn creation is fulfilled once the receipt identifies the turn', async t => { const receipt = deferred(); const { client, pages, requests, state } = fixture(t, { startAnalysisTurn: () => receipt.promise }); await client.openSession('session-1'); const pending = client.submit('q'); await tick(); assert.equal(await client.cancel(), true); assert.deepEqual(requests.cancels, []); const turn = saved('turn-1', 'QUEUED'); pages['session-1'] = page('session-1', [turn], { activeTurnId: 'turn-1' }); receipt.resolve({ turn }); assert.equal(await pending, true); assert.deepEqual(requests.cancels, ['turn-1']); assert.equal(state().turns.at(-1).status, 'CANCELLED'); assert.equal(state().busy, false); }); test('stop before the new session is created prevents a model turn from starting', async t => { const created = deferred(); const { client, requests, state } = fixture(t, { createAnalysisSession: () => created.promise }, {}); const pending = client.submit('q'); assert.equal(await client.cancel(), true); created.resolve({ session: { id: 'new-session' } }); assert.equal(await pending, false); assert.deepEqual(requests.starts, []); assert.deepEqual(state().turns, []); assert.equal(state().pendingQuestion, ''); assert.equal(state().busy, false); }); test('a follow-up waits for the accepted task to settle and then sends once', async t => { const { client, requests, pages, state } = fixture(t); await client.openSession('session-1'); assert.equal(await client.submit('initial question'), true); await tick(); assert.equal(await client.submit('follow-up question'), true); assert.equal(await client.submit('second queued question'), false); assert.equal(state().queuedQuestion, 'follow-up question'); assert.deepEqual(requests.starts.map(request => request.question), ['initial question']); pages['session-1'] = page('session-1', [saved('turn-1', 'COMPLETED', { question: 'initial question' })]); const current = requests.follows.at(-1); current.emit({ id: '1', event: 'completed', data: { turnId: 'turn-1', result: { answer: 'done' } } }); current.close(); await tick(); requests.follows.at(-1).close(); await tick(); assert.deepEqual(requests.starts.map(request => request.question), ['initial question', 'follow-up question']); assert.equal(state().queuedQuestion, ''); }); test('session-list refresh cannot delay following or the stop target', async t => { const list = deferred(); const { client, requests, state } = fixture(t, { analysisSessions: () => list.promise }); await client.openSession('session-1'); assert.equal(await client.submit('q'), true); await tick(); assert.equal(state().sessionsLoading, true); assert.equal(requests.follows.length, 2); assert.equal(state().activeTurnId, 'turn-1'); assert.equal(await client.cancel(), true); assert.deepEqual(requests.cancels, ['turn-1']); list.resolve({ items: [] }); }); test('a lost accepted response retries the same key without archiving a phantom turn', async t => { const bodies = []; const { client, pages, state } = fixture(t, { startAnalysisTurn: async (id, body) => { bodies.push(body); if (bodies.length === 1) throw Object.assign(new Error('service unavailable'), { status: 503 }); const turn = saved('original-turn', 'RUNNING', { question: body.question }); pages[id] = page(id, [turn], { activeTurnId: turn.id }); return { turn }; }, }); await client.openSession('session-1'); assert.equal(await client.submit('q'), false); assert.equal(state().retryQuestion, 'q'); assert.equal(state().error, 'service unavailable'); assert.equal(state().busy, false); assert.equal(state().activeTurnId, ''); assert.deepEqual(state().turns, []); assert.equal(await client.submit(state().retryQuestion), true); assert.equal(bodies.length, 2); assert.equal(bodies[0].idempotencyKey, bodies[1].idempotencyKey); assert.deepEqual(state().turns.map(turn => turn.id), ['original-turn']); }); test('an explicit 400 rejection gives the same editable question a fresh key without showing it as running', async t => { const keys = []; const { client, state } = fixture(t, { startAnalysisTurn: async (_id, body) => { keys.push(body.idempotencyKey); throw Object.assign(new Error('invalid question'), { status: 400 }); }, }); await client.openSession('session-1'); assert.equal(await client.submit('rejected question'), false); assert.equal(state().retryQuestion, 'rejected question'); assert.equal(state().error, 'invalid question'); assert.equal(state().busy, false); assert.deepEqual(state().turns, []); assert.equal(await client.submit(state().retryQuestion), false); assert.notEqual(keys[0], keys[1]); }); test('a pending stop applies only to its original turn after navigation', async t => { const receipt = deferred(); const { client, requests, state } = fixture(t, { startAnalysisTurn: () => receipt.promise }); await client.openSession('session-1'); const pending = client.submit('q'); await tick(); assert.equal(await client.cancel(), true); await client.openSession('session-2'); receipt.resolve({ turn: saved('old-turn', 'RUNNING', { sessionId: 'session-1' }) }); assert.equal(await pending, true); assert.deepEqual(requests.cancels, ['old-turn']); assert.deepEqual(state().turns, []); assert.equal(state().activeTurnId, ''); assert.equal(state().sessionId, 'session-2'); }); test('stop during retry waits for requeue and targets the original saved turn', async t => { const receipt = deferred(); const savedTurn = saved('partial-turn', 'PARTIAL'); const { client, pages, requests, state } = fixture(t, { retryAnalysisTurn: () => receipt.promise }, { 'session-1': page('session-1', [savedTurn, saved('newest-turn', 'COMPLETED')]), }); await client.openSession('session-1'); const pending = client.retry('partial-turn'); assert.equal(await client.cancel(), true); assert.deepEqual(requests.cancels, []); const turn = { ...savedTurn, status: 'QUEUED' }; pages['session-1'] = page('session-1', [turn, saved('newest-turn', 'COMPLETED')], { activeTurnId: 'partial-turn' }); receipt.resolve({ turn }); assert.equal(await pending, true); assert.deepEqual(requests.cancels, ['partial-turn']); assert.equal(state().busy, false); assert.equal(state().turns.find(row => row.id === 'partial-turn').status, 'CANCELLED'); }); test('a late cancellation failure cannot put an error in a newly selected session', async t => { const cancel = deferred(); const { client, state } = fixture(t, { cancelAnalysisTurn: () => cancel.promise }); await client.openSession('session-1'); await client.submit('q'); const stopping = client.cancel(); await client.openSession('other'); cancel.reject(new Error('cancellation response lost')); assert.equal(await stopping, false); assert.equal(state().error, ''); assert.deepEqual(state().turns, []); }); test('repeated stop clicks share one request until the task settles', async t => { const cancellation = deferred(); let count = 0; const { client, pages, state } = fixture(t, { cancelAnalysisTurn: () => { count++; return cancellation.promise; } }); await client.openSession('session-1'); await client.submit('q'); const first = client.cancel(); assert.equal(await client.cancel(), false); assert.equal(count, 1); assert.equal(state().stopping, true); pages['session-1'] = page('session-1', [saved('turn-1', 'CANCELLED')]); cancellation.resolve({ status: 'CANCELLED', turnId: 'turn-1' }); assert.equal(await first, true); assert.equal(state().busy, false); }); test('stopping keeps the queued question available for editing and does not send it', async t => { const { client, requests, state } = fixture(t); await client.openSession('session-1'); await client.submit('initial'); await client.submit('queued follow-up'); await client.cancel(); await tick(); requests.follows.at(-1).close(); await tick(); assert.equal(state().queuedQuestion, 'queued follow-up'); assert.deepEqual(requests.starts.map(request => request.question), ['initial']); assert.equal(client.takeQueued(), 'queued follow-up'); assert.equal(state().queuedQuestion, ''); }); test('a failed stop request allows another explicit stop attempt', async t => { let count = 0; const { client, pages, state } = fixture(t, { cancelAnalysisTurn: async id => { if (++count === 1) throw new Error('offline'); pages['session-1'] = page('session-1', [saved(id, 'CANCELLED')]); return { status: 'CANCELLED', turnId: id }; }, }); await client.openSession('session-1'); await client.submit('initial'); assert.equal(await client.cancel(), false); assert.equal(state().stopping, false); assert.equal(state().busy, true); assert.equal(await client.cancel(), true); assert.equal(count, 2); assert.equal(state().busy, false); }); test('a fresh submission immediately carries waiting status and a clock before acceptance', async t => { const receipt = deferred(); const { client, pages, state } = fixture(t, { startAnalysisTurn: () => receipt.promise }); await client.openSession('session-1'); const pending = client.submit('即时状态'); assert.equal(state().turns.at(-1).status, 'SUBMITTING'); assert.ok(Number.isFinite(Date.parse(state().turns.at(-1)._uiSubmittedAt))); const turn = saved('accepted', 'RUNNING', { question: '即时状态', createdAt: new Date().toISOString() }); pages['session-1'] = page('session-1', [turn], { activeTurnId: turn.id }); receipt.resolve({ turn }); assert.equal(await pending, true); assert.equal(state().turns.at(-1).id, 'accepted'); assert.ok(Number.isFinite(Date.parse(state().turns.at(-1).createdAt))); }); test('retry starts a fresh waiting clock without the old answer or plan clock', async t => { const receipt = deferred(); const old = saved('old', 'PARTIAL', { answer: 'old text', createdAt: '2020-01-01T00:00:00Z', startedAt: '2020-01-01T00:00:01Z', plan: { startedAt: '2020-01-01T00:00:01Z' }, }); const { client, pages, state } = fixture(t, { retryAnalysisTurn: () => receipt.promise }, { 'session-1': page('session-1', [old]), }); await client.openSession('session-1'); const pending = client.retry('old'); const current = state().turns[0]; assert.equal(current.status, 'SUBMITTING'); assert.ok(Number.isFinite(Date.parse(current._uiSubmittedAt))); assert.equal(current.answer, undefined); assert.equal(current.plan, undefined); assert.equal(current.startedAt, undefined); const turn = saved('old', 'QUEUED'); pages['session-1'] = page('session-1', [turn], { activeTurnId: turn.id }); receipt.resolve({ turn }); assert.equal(await pending, true); });