Files
Agent-Workbench/tests/read-budget.test.mjs
T

93 lines
7.7 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { randomUUID, createHash } from 'node:crypto';
import { artifactPage, recordArtifactRead, clearReadStreak } from '../src/core/context/read-budget.mjs';
import { Runtime } from '../src/server/runtime.mjs';
import { Provider } from '../src/server/provider.mjs';
import { Store } from '../src/server/store.mjs';
import { fixture, compatibleFixture, call, completion, until, assertToolPairs } from './helpers.mjs';
const sha = text => createHash('sha256').update(text, 'utf8').digest('hex');
const bytes = (page, id) => Buffer.byteLength(JSON.stringify({ role: 'tool', tool_call_id: id, content: JSON.stringify(page) }), 'utf8');
test('budgeted artifact pages count escaped protocol bytes and reconstruct original multilingual JSON without losing characters', () => {
const text = JSON.stringify({ source: '原文🙂\r\n"\\'.repeat(4000) }), artifact = { id: randomUUID(), sha256: sha(text), kind: 'tool-result' };
let offset = 0, reconstructed = '', pages = 0;
while (offset < text.length) {
const page = artifactPage(artifact, text, { offset, limit: 16000 }, { maximumMessageBytes: 7000, callId: 'literal-read' });
assert.ok(bytes(page, 'literal-read') <= 7000); assert.ok(page.next_offset > offset); assert.equal(page.offset, offset);
assert.equal(page.content, text.slice(offset, page.next_offset)); assert.equal(page.truncated, page.next_offset < text.length);
assert.ok(!/[\uD800-\uDBFF]$/.test(page.content)); reconstructed += page.content; offset = page.next_offset; pages++;
}
assert.ok(pages > 5); assert.equal(reconstructed, text); assert.equal(sha(reconstructed), artifact.sha256);
const unicode = artifactPage({ ...artifact, sha256: sha('🙂雪') }, '🙂雪', { offset: 1, limit: 1 }, { maximumMessageBytes: 1200 });
assert.equal(unicode.offset, 0); assert.equal(unicode.content, '🙂'); assert.equal(unicode.next_offset, 2);
});
test('known artifact coverage detects semantic repeats despite changing limits, and advancing pages or direct evidence restore progress', () => {
const task = {}, text = 'Immutable engineering evidence\n'.repeat(30), artifact = { id: randomUUID(), kind: 'check-log', sha256: sha(text) };
const page = artifactPage(artifact, text, { offset: 0, limit: 200 }, { maximumMessageBytes: 2000 });
recordArtifactRead(task, artifact, page, 'first');
for (const limit of [100, 150, 180]) recordArtifactRead(task, artifact,
artifactPage(artifact, text, { offset: 0, limit }, { maximumMessageBytes: 2000 }), 'repeat-' + limit);
assert.equal(task.readProgress.pause, true); assert.equal(task.readProgress.repeated, 3);
recordArtifactRead(task, artifact, artifactPage(artifact, text, { offset: 200, limit: 200 }, { maximumMessageBytes: 2000 }), 'next');
assert.equal(task.readProgress.pause, false); assert.deepEqual(task.readProgress.reads[0].ranges, [[0, 400]]);
for (let index = 0; index < 6; index++) recordArtifactRead(task, { ...artifact, id: randomUUID(), kind: 'context-history-index' }, page, 'index-' + index);
assert.equal(task.readProgress.pause, true); clearReadStreak(task);
assert.equal(task.readProgress.pause, false); assert.equal(task.readProgress.reads[0].identity, artifact.id + ':' + artifact.sha256);
});
test('actual large artifact reads are present in the next bounded HTTP request and next_offset progresses without redoing tools', async t => {
const f = fixture(t), original = JSON.stringify({ log: '真实证据🙂\n"\\'.repeat(2200) });
const artifact = f.store.artifactStore.write(f.session, null, original, { kind: 'check-log' });
f.store.core.artifact.set(artifact.id, artifact); f.store.save(f.session);
let requests = 0, observedPages = [];
const model = await compatibleFixture(t, (route, body) => {
if (!route.endsWith('/chat/completions')) return { body: {} };
requests++;
const received = body.messages.filter(value => value.role === 'tool').map(value => JSON.parse(value.content)).filter(value => value.artifact_id === artifact.id);
if (requests > 1) {
const page = received.at(-1); assert.ok(page, 'Newest actual result must be sent, not archived before the model sees it');
assert.ok(page.budget_limited); assert.ok(page.next_offset > page.offset); assert.equal(page.content, original.slice(page.offset, page.next_offset));
observedPages.push(page);
if (requests === 4) return { body: completion([], '已根据三段实际结果完成读取验收。') };
return { body: completion([call('page-' + requests, 'read_artifact', { artifact_id: artifact.id, offset: page.next_offset, limit: 16000 })]) };
}
return { body: completion([call('page-first', 'read_artifact', { artifact_id: artifact.id, limit: 16000 })]) };
});
f.store.saveConfig({ mode: 'compatible', baseUrl: model.baseUrl, model: 'page-budget-fixture', maxSteps: 8 });
const runtime = new Runtime(f.store, new Provider()); runtime.start(f.session.id, '读取保存的原工件,分段取得真实依据,不执行命令或修改文件。');
await until(() => !runtime.isActive(f.session.id), 20000);
assert.equal(f.session.status, 'completed', JSON.stringify({ failure: f.session.failure, requests, pages: observedPages.map(value => ({ offset: value.offset, next: value.next_offset, budget: value.maximum_message_bytes })) })); assert.equal(requests, 4); assert.equal(observedPages.length, 3);
assert.equal(observedPages[1].offset, observedPages[0].next_offset); assert.equal(observedPages[2].offset, observedPages[1].next_offset);
assert.equal(f.store.artifactStore.read(artifact), original); assertToolPairs(f.session.providerMessages);
const plans = [...f.store.core.context_plan.values()];
for (const page of observedPages) assert.ok(plans.some(plan => plan.status === 'completed' && plan.retainedGroups.length > 0));
});
test('a real repeated artifact loop pauses the same Task after recorded results, survives reload and only resumes explicitly', async t => {
const f = fixture(t), artifact = f.store.artifactStore.write(f.session, null, 'Known complete evidence', { kind: 'check-log' });
f.store.core.artifact.set(artifact.id, artifact); f.store.save(f.session);
let requests = 0, resume = false;
const model = await compatibleFixture(t, () => {
requests++;
return { body: resume ? completion([], '使用已保存内容完成核对。')
: completion([call('repeat-read-' + requests, 'read_artifact', { artifact_id: artifact.id, limit: 16000 })]) };
});
f.store.saveConfig({ mode: 'compatible', baseUrl: model.baseUrl, model: 'repeat-loop-fixture', maxSteps: 12 });
const runtime = new Runtime(f.store, new Provider()); runtime.start(f.session.id, '使用不可变证据完成当前任务。');
await until(() => !runtime.isActive(f.session.id), 20000);
const taskId = f.session.taskId;
assert.equal(f.session.status, 'paused'); assert.equal(f.store.core.run.get(f.session.runId).stopReason, 'no_progress');
assert.equal(requests, 4); assert.equal([...f.store.core.tool.values()].filter(value => value.state === 'completed').length, 4);
assertToolPairs(f.session.providerMessages); f.store.close();
const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
const saved = reopened.session(f.session.id); assert.equal(saved.taskId, taskId); assert.equal(requests, 4);
assert.equal(reopened.core.task.get(taskId).readProgress.pause, true); assertToolPairs(saved.providerMessages);
resume = true; const resumed = new Runtime(reopened, new Provider()); resumed.start(saved.id, '', true);
await until(() => !resumed.isActive(saved.id), 20000);
assert.equal(saved.status, 'completed'); assert.equal(saved.taskId, taskId); assert.equal(requests, 5);
assert.equal([...reopened.core.tool.values()].length, 4); assert.equal(reopened.core.task.get(taskId).readProgress.pause, false);
});