188 lines
14 KiB
JavaScript
188 lines
14 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { createHash, randomUUID } from 'node:crypto';
|
|
import { RequestPlanner, historyGroups, verifyPlanEvidence } from '../src/core/context/request-plan.mjs';
|
|
import { workingCandidates } from '../src/core/context/working-set.mjs';
|
|
import { filePage } from '../src/core/context/read-budget.mjs';
|
|
import { requestMetrics } from '../src/shared/contracts/model-request.mjs';
|
|
import { Runtime } from '../src/server/runtime.mjs';
|
|
import { Provider, toolDefinitions } from '../src/server/provider.mjs';
|
|
import { Store } from '../src/server/store.mjs';
|
|
import { CheckRunner } from '../src/core/check-runner.mjs';
|
|
import { createDeliveryProject } from './fixtures/delivery-project.mjs';
|
|
import { fixture, call, completion, compatibleFixture, until, assertToolPairs } from './helpers.mjs';
|
|
|
|
const sha = text => createHash('sha256').update(text, 'utf8').digest('hex');
|
|
const setFrom = messages => messages.filter(message => message.role === 'system').map(message => {
|
|
try { return JSON.parse(message.content.split('\n').at(-1)); } catch { return {}; }
|
|
}).find(value => value.working_set)?.data;
|
|
function setup(t, config = {}) {
|
|
const f = fixture(t);
|
|
f.config = { ...f.store.config, contextLimit: 10000, maxOutputTokens: 1024, ...config };
|
|
f.run = f.store.beginRun(f.session, 'Fix this project, preserve the public API and report actual checks.', false, f.config);
|
|
f.session.providerMessages.push({ role: 'user', content: f.store.core.task.get(f.run.taskId).goal });
|
|
f.planner = new RequestPlanner(f.store);
|
|
f.prepare = () => f.planner.prepare(f.session, f.run, f.config, { system: 'Current project and complete Task requirements.', tools: toolDefinitions });
|
|
return f;
|
|
}
|
|
function group(f, items) {
|
|
const calls = items.map(item => call(randomUUID(), item.tool, item.args));
|
|
const results = [];
|
|
for (const [index, invocation] of calls.entries()) {
|
|
const event = f.store.event(f.session, { kind: 'tool', tool: invocation.function.name, toolCallId: invocation.id,
|
|
runId: f.run.id, phase: 'queued', startedAt: new Date().toISOString(), label: 'Recorded fixture observation' });
|
|
f.store.registerInvocation(f.session, invocation, f.run, event);
|
|
f.store.beginInvocation(f.session, invocation, f.run, event);
|
|
f.store.finishInvocation(f.session, event, items[index].result);
|
|
results.push({ role: 'tool', tool_call_id: invocation.id, content: JSON.stringify(items[index].result) });
|
|
}
|
|
f.session.providerMessages.push({ role: 'assistant', content: '', tool_calls: calls }, ...results);
|
|
f.store.save(f.session);
|
|
return calls;
|
|
}
|
|
const read = (file, content) => ({ tool: 'read_file', args: { path: file },
|
|
result: { path: file, content, sha256: sha(content), start_line: 1, end_line: 2, total_lines: 2, truncated: false } });
|
|
const huge = () => ({ tool: 'query_code', args: { query: 'source' }, result: { results: 'Large mixed metadata '.repeat(16000) } });
|
|
|
|
test('small code and actual failed command stay visible when their original multi-tool group cannot fit', t => {
|
|
const f = setup(t), code = 'export const add = (a, b) => a + b;\n';
|
|
const calls = group(f, [read('src/add.mjs', code), huge(), { tool: 'run_command', args: { command: 'node check.mjs', reason: 'Fixture evidence.' },
|
|
result: { status: 'completed', exit_code: 1, stdout: '1 test failed', stderr: 'Expected add(2, 3) to equal 5' } }]);
|
|
const original = structuredClone(f.session.providerMessages), plan = f.prepare(), set = setFrom(plan.messages);
|
|
assert.ok(set); assert.equal(set.taskId, f.run.taskId); assert.equal(set.entries.find(entry => entry.observation.path === 'src/add.mjs').content, code);
|
|
assert.ok(set.entries.some(entry => entry.observation.exit_code === 1 && entry.content.includes('Expected add')));
|
|
assert.ok(!plan.messages.some(message => message.tool_calls?.some(call => call.id === calls[0].id)));
|
|
assert.deepEqual(f.session.providerMessages, original); assertToolPairs(plan.messages);
|
|
assert.ok(requestMetrics(plan.body).estimatedInputTokens <= plan.record.budget.inputBudget);
|
|
verifyPlanEvidence(f.store, f.session, plan.record);
|
|
const sent = f.store.artifactStore.read(f.store.owned('artifact', plan.record.requestArtifactId, f.session.id));
|
|
assert.equal(sha(sent), plan.record.requestSha256); assert.ok(plan.record.workingSetEntries >= 2);
|
|
});
|
|
|
|
test('mixed group retains six distinct small file observations with exact multilingual text and bounded request bytes', t => {
|
|
const f = setup(t, { contextLimit: 14000 }), files = Array.from({ length: 6 }, (_, index) => read('src/模块-' + index + '.mjs',
|
|
'export const value = "第' + index + '个🙂\\雪";\r\n'));
|
|
group(f, [...files, huge()]);
|
|
const plan = f.prepare(), set = setFrom(plan.messages);
|
|
for (const file of files) {
|
|
const entry = set.entries.find(entry => entry.observation.path === file.args.path);
|
|
assert.ok(entry); assert.equal(entry.content, file.result.content); assert.equal(entry.content_sha256, sha(file.result.content));
|
|
assert.ok(entry.content.isWellFormed()); assert.equal(entry.truncated, false);
|
|
}
|
|
assert.ok(requestMetrics(plan.body).estimatedInputTokens <= plan.record.budget.inputBudget);
|
|
assertToolPairs(plan.messages); verifyPlanEvidence(f.store, f.session, plan.record);
|
|
});
|
|
|
|
test('working observations are bound to the current Task and stop treating a pre-application file revision as current evidence', t => {
|
|
const f = setup(t); group(f, [read('src/old.mjs', 'Previous task bytes\n'), huge()]);
|
|
f.session.status = 'completed'; f.store.finishRun(f.session, f.run);
|
|
f.run = f.store.beginRun(f.session, 'A different Task must use its own observations.', false, f.config);
|
|
f.session.providerMessages.push({ role: 'user', content: 'A different Task must use its own observations.' });
|
|
group(f, [read('src/current.mjs', 'Current task bytes\n'), huge()]);
|
|
const plan = f.prepare(), set = setFrom(plan.messages);
|
|
assert.ok(set.entries.some(entry => entry.observation.path === 'src/current.mjs'));
|
|
assert.ok(!set.entries.some(entry => entry.observation.path === 'src/old.mjs'));
|
|
f.session.changes.push({ id: randomUUID(), taskId: f.run.taskId, path: 'src/current.mjs', status: 'applied',
|
|
sha256: sha('Newly applied revision'), appliedAt: new Date(Date.now() + 1000).toISOString() });
|
|
assert.ok(!workingCandidates(f.store, f.session, f.run, historyGroups(f.session.providerMessages)).some(entry => entry.observation.path === 'src/current.mjs'));
|
|
// A historical sent observation remains valid evidence of what was sent.
|
|
verifyPlanEvidence(f.store, f.session, plan.record);
|
|
});
|
|
|
|
test('a sealed observation rejects changed or missing original result artifacts instead of recreating evidence', t => {
|
|
const f = setup(t); group(f, [read('src/evidence.mjs', 'Exact recorded source\n'), huge()]);
|
|
const plan = f.prepare(), set = setFrom(plan.messages), entry = set.entries[0];
|
|
const artifact = f.store.owned('artifact', entry.source.result_artifact_id, f.session.id), target = path.join(f.data, 'artifacts', artifact.relative);
|
|
fs.writeFileSync(target, 'External corrupted observation');
|
|
assert.throws(() => verifyPlanEvidence(f.store, f.session, plan.record), /工件校验失败/);
|
|
assert.throws(() => f.prepare(), /工件校验失败/); assert.equal(fs.readFileSync(target, 'utf8'), 'External corrupted observation');
|
|
fs.unlinkSync(target); assert.throws(() => f.prepare(), /ENOENT/); assert.equal(fs.existsSync(target), false);
|
|
});
|
|
|
|
test('a real passed-check observation is excluded after a source edit invalidates the check, while its historical sent evidence remains valid', async t => {
|
|
const f = setup(t); createDeliveryProject(f);
|
|
fs.writeFileSync(path.join(f.projectRoot, 'src/add.mjs'), 'export const add = (a, b) => a + b;\n');
|
|
const runner = new CheckRunner(f.store), plan = await runner.plan(f.session), { promise } = await runner.start(f.session, plan.id);
|
|
const job = await promise; assert.equal(job.status, 'passed');
|
|
group(f, [{ tool: 'run_checks', args: { plan_id: plan.id }, result: { status: 'completed', check_status: job.status,
|
|
job_id: job.id, plan_id: plan.id, results: job.results, summary: job.summary, fingerprint: job.fingerprint } }, huge()]);
|
|
const sent = f.prepare(); assert.ok(setFrom(sent.messages).entries.some(entry => entry.observation.job_id === job.id));
|
|
fs.appendFileSync(path.join(f.projectRoot, 'src/add.mjs'), '// Later real source edit.\n');
|
|
await runner.plan(f.session); assert.equal(job.stale, true);
|
|
assert.ok(!workingCandidates(f.store, f.session, f.run, historyGroups(f.session.providerMessages)).some(entry => entry.observation.job_id === job.id));
|
|
verifyPlanEvidence(f.store, f.session, sent.record);
|
|
});
|
|
|
|
test('budgeted file pages reconstruct UTF-8 text including long single lines and surrogate boundaries', () => {
|
|
const text = '首行🙂"\\\r\n' + '超长单行🙂\\"'.repeat(2000) + '\n最后一行🙂';
|
|
const file = { path: '长文件.mjs', content: text, sha256: sha(text), start_line: 21, end_line: 23, total_lines: 23, bom: true, truncated: true };
|
|
let offset = 0, joined = '', count = 0;
|
|
while (offset < text.length) {
|
|
const page = filePage(file, { offset }, { maximumMessageBytes: 2800, callId: 'file-page' });
|
|
assert.ok(Buffer.byteLength(JSON.stringify({ role: 'tool', tool_call_id: 'file-page', content: JSON.stringify(page) })) <= 2800);
|
|
assert.ok(page.next_offset > offset); assert.equal(page.offset, offset); assert.equal(page.content, text.slice(offset, page.next_offset));
|
|
assert.ok(page.content.isWellFormed()); assert.equal(page.sha256, file.sha256); assert.equal(page.range_start_line, 21); assert.equal(page.range_end_line, 23);
|
|
joined += page.content; offset = page.next_offset; count++;
|
|
}
|
|
assert.equal(joined, text); assert.ok(count > 10);
|
|
const unicode = filePage({ ...file, content: '🙂雪' }, { offset: 1, limit: 1 }, { maximumMessageBytes: 1500 });
|
|
assert.equal(unicode.offset, 0); assert.equal(unicode.content, '🙂'); assert.equal(unicode.next_offset, 2);
|
|
});
|
|
|
|
test('actual HTTP multi-tool reads survive an oversized runtime snapshot and the sealed evidence survives reopening', { timeout: 30000 }, async t => {
|
|
const f = fixture(t); fs.mkdirSync(path.join(f.projectRoot, 'src'));
|
|
const code = 'export const actual = "真实模块🙂";\n'; fs.writeFileSync(path.join(f.projectRoot, 'src/actual.mjs'), code);
|
|
let requests = 0;
|
|
const model = await compatibleFixture(t, (_route, body) => {
|
|
requests++; assertToolPairs(body.messages);
|
|
if (requests === 1) {
|
|
const run = f.store.core.run.get(f.session.runId);
|
|
for (let index = 0; index < 160; index++) {
|
|
const artifact = f.store.artifactStore.write(f.session, run, 'Runtime snapshot fixture ' + index, { kind: 'fixture-evidence' });
|
|
f.store.core.artifact.set(artifact.id, artifact);
|
|
}
|
|
f.store.save(f.session);
|
|
return { body: completion([call('mixed-read', 'read_file', { path: 'src/actual.mjs' }), call('mixed-snapshot', 'inspect_session', {})]) };
|
|
}
|
|
const set = setFrom(body.messages);
|
|
assert.ok(set, 'A small result in a large mixed group must be visible in a sealed observation');
|
|
assert.equal(set.entries.find(entry => entry.observation.path === 'src/actual.mjs').content, code);
|
|
return { body: completion([], 'Used the actual source observation to complete this read-only task.') };
|
|
});
|
|
f.store.saveConfig({ mode: 'compatible', baseUrl: model.baseUrl, model: 'working-set-fixture', maxSteps: 6 });
|
|
const runtime = new Runtime(f.store, new Provider()); f.onCleanup(() => runtime.stopAll());
|
|
runtime.start(f.session.id, 'Read src/actual.mjs and the runtime state. Preserve all files.');
|
|
await until(() => !runtime.isActive(f.session.id), 20000);
|
|
assert.equal(f.session.status, 'completed', JSON.stringify(f.session.failure)); assert.equal(requests, 2);
|
|
assert.equal([...f.store.core.tool.values()].length, 2); assert.equal(fs.readFileSync(path.join(f.projectRoot, 'src/actual.mjs'), 'utf8'), code);
|
|
const plan = [...f.store.core.context_plan.values()].at(-1); assert.ok(plan.workingSetEntries);
|
|
verifyPlanEvidence(f.store, f.session, plan); f.store.close();
|
|
const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
|
|
verifyPlanEvidence(reopened, reopened.session(f.session.id), reopened.core.context_plan.get(plan.id));
|
|
assert.equal(requests, 2); assertToolPairs(reopened.session(f.session.id).providerMessages);
|
|
});
|
|
|
|
test('actual HTTP file pagination advances over a long file with each returned page visible in the next request', { timeout: 30000 }, async t => {
|
|
const f = fixture(t), text = ('真实长行🙂"\\' + 'content'.repeat(25) + '\n').repeat(150);
|
|
fs.writeFileSync(path.join(f.projectRoot, 'README.md'), text);
|
|
let joined = '', requests = 0, priorOffset = 0;
|
|
const model = await compatibleFixture(t, (_route, body) => {
|
|
requests++; assertToolPairs(body.messages);
|
|
if (requests === 1) return { body: completion([call('file-first', 'read_file', { path: 'README.md', start_line: 1, end_line: 200 })]) };
|
|
const result = body.messages.filter(message => message.role === 'tool').map(message => JSON.parse(message.content)).findLast(result => result.path === 'README.md');
|
|
assert.ok(result, 'The newest actual budgeted page must be sent'); assert.equal(result.offset, priorOffset);
|
|
assert.equal(result.content, text.slice(result.offset, result.next_offset)); joined += result.content; priorOffset = result.next_offset;
|
|
if (result.next_offset === result.total_characters) return { body: completion([], 'Completed the actual paginated read.') };
|
|
return { body: completion([call('file-next-' + requests, 'read_file', { path: 'README.md', start_line: result.range_start_line,
|
|
end_line: result.range_end_line, offset: result.next_offset })]) };
|
|
});
|
|
f.store.saveConfig({ mode: 'compatible', baseUrl: model.baseUrl, model: 'file-page-fixture', maxSteps: 12 });
|
|
const runtime = new Runtime(f.store, new Provider()); f.onCleanup(() => runtime.stopAll());
|
|
runtime.start(f.session.id, 'Read this long file using actual pages. Preserve its bytes.');
|
|
await until(() => !runtime.isActive(f.session.id), 20000);
|
|
assert.equal(f.session.status, 'completed', JSON.stringify(f.session.failure)); assert.ok(requests > 2); assert.equal(joined, text);
|
|
assert.equal(fs.readFileSync(path.join(f.projectRoot, 'README.md'), 'utf8'), text);
|
|
});
|