93 lines
7.7 KiB
JavaScript
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);
|
|
});
|