Files
Agent-Workbench/tests/change-set-handoff.test.mjs
2026-11-03 07:58:13 +08:00

72 lines
4.3 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { Runtime } from '../src/server/runtime.mjs';
import { Provider } from '../src/server/provider.mjs';
import { fixture, call, assertToolPairs } from './helpers.mjs';
async function exercise(t, mode) {
const f = fixture(t), provider = new Provider(), runtime = new Runtime(f.store, provider);
f.onCleanup(() => runtime.stopAll());
f.store.saveConfig({ maxSteps: 2 });
let requests = 0, stopped, stopScheduled = false;
provider.complete = async () => {
requests++;
const calls = requests === 1 ? [
call('left', 'propose_file', { path: 'left.mjs', content: 'export const left = 1;\n', reason: 'Left module' }),
call('right', 'propose_file', { path: 'right.mjs', content: 'export const right = 2;\n', reason: 'Right module' }),
] : [call('seal', 'prepare_change_set', { change_ids: mode === 'failed' ? ['missing']
: f.session.changes.slice(0, mode === 'partial' ? 1 : 2).map(change => change.id) }),
...(mode === 'new-proposal' ? [call('third', 'propose_file', { path: 'third.mjs', content: 'export const third = 3;\n', reason: 'Later same-turn proposal' })]
: [call('after-seal', 'inspect_session', {})]),
...(mode === 'later-error' ? [call('bad-read', 'read_file', { path: 'missing.mjs' })] : []),
];
return { message: { role: 'assistant', content: 'Declared model fixture.', tool_calls: calls }, usage: null };
};
f.store.on('update', () => {
if (mode === 'cancelled' && !stopScheduled && f.session.events.some(event => event.toolCallId === 'seal' && event.phase === 'completed')) {
stopScheduled = true; setImmediate(() => { stopped = runtime.stop(f.session.id); });
}
if (mode === 'conflict' && f.session.events.some(event => event.toolCallId === 'after-seal' && event.phase === 'completed')) {
fs.writeFileSync(path.join(f.projectRoot, 'left.mjs'), 'Concurrent owner bytes\n');
}
if (mode === 'unknown') {
const event = f.session.events.find(event => event.toolCallId === 'after-seal' && event.phase === 'completed');
if (event) f.store.core.tool.get(event.invocationId).requiresVerification = true;
}
if (mode === 'tampered') {
const set = [...f.store.core.change_set.values()][0];
if (set) set.fingerprint = '0'.repeat(64);
}
});
runtime.start(f.session.id, 'Create and review two modules; do not apply them automatically.');
await runtime.active.get(f.session.id).promise;
if (mode === 'cancelled') { await new Promise(resolve => setImmediate(resolve)); await stopped; }
const run = f.store.core.run.get(f.session.runId);
assert.equal(requests, 2); assertToolPairs(f.session.providerMessages);
assert.equal([...f.store.core.tool.values()].filter(tool => tool.sessionId === f.session.id).length, mode === 'later-error' ? 5 : 4);
assert.ok(f.session.changes.every(change => change.status === 'pending'));
assert.equal(fs.existsSync(path.join(f.projectRoot, 'right.mjs')), false);
if (mode === 'conflict') assert.equal(fs.readFileSync(path.join(f.projectRoot, 'left.mjs'), 'utf8'), 'Concurrent owner bytes\n');
else assert.equal(fs.existsSync(path.join(f.projectRoot, 'left.mjs')), false);
return { ...f, run };
}
test('complete sealed batch hands off after all tools settle with no next model request', async t => {
for (const mode of ['complete', 'later-error']) await t.test(mode, async t => {
const f = await exercise(t, mode);
assert.equal(f.session.status, 'needs_review'); assert.equal(f.run.stopReason, 'change_set_review');
assert.equal(f.session.events.find(event => event.toolCallId === 'after-seal').phase, 'completed');
if (mode === 'later-error') assert.equal(f.session.events.find(event => event.toolCallId === 'bad-read').phase, 'failed');
});
});
test('partial, changed, failed or cancelled batches cannot claim complete review handoff', async t => {
for (const mode of ['partial', 'new-proposal', 'failed', 'conflict', 'cancelled', 'unknown', 'tampered']) await t.test(mode, async t => {
const f = await exercise(t, mode);
assert.equal(f.session.status, 'paused'); assert.equal(f.run.stopReason, mode === 'cancelled' ? 'cancelled' : 'step_limit');
if (mode !== 'failed' && mode !== 'cancelled') assert.equal([...f.store.core.change_set.values()][0].status, 'prepared');
});
});