101 lines
8.1 KiB
JavaScript
101 lines
8.1 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { randomUUID } from 'node:crypto';
|
|
import { fixture, compatibleFixture, completion, call } from './helpers.mjs';
|
|
import { Provider, toolDefinitions } from '../src/server/provider.mjs';
|
|
import { Runtime } from '../src/server/runtime.mjs';
|
|
import { Store } from '../src/server/store.mjs';
|
|
import { RequestPlanner, verifyPlanEvidence } from '../src/core/context/request-plan.mjs';
|
|
import { completionBody, requestVariants } from '../src/shared/contracts/model-request.mjs';
|
|
import { prefixAudit } from '../src/core/context/prefix-audit.mjs';
|
|
import { observeToolSurface, verifyToolSurface } from '../src/core/context/tool-surface.mjs';
|
|
|
|
test('protocol-adapted tool definitions, semantic changes and raw prompt bytes are independent of diagnostic metadata', () => {
|
|
const tools = toolDefinitions.slice(0, 2), groups = [{ name: 'core', definitions: tools, assembled: true }];
|
|
const surface = observeToolSurface(groups, tools);
|
|
for (const protocol of ['chat-completions', 'responses', 'anthropic-messages']) {
|
|
const config = { protocol, model: 'owned', maxOutputTokens: 32768, capacityMode: 'passthrough' };
|
|
const first = completionBody(config, [{ role: 'system', content: '稳定规则🙂' }, { role: 'user', content: '原目标' }], tools);
|
|
const second = completionBody(config, [{ role: 'system', content: '稳定规则🙂' }, { role: 'user', content: '原目标' }, { role: 'assistant', content: '原结果' }, { role: 'user', content: '继续' }], tools);
|
|
const original = JSON.stringify(second), audit = prefixAudit(second, first, { schemaVersion: 2 }).variants[0];
|
|
assert.doesNotThrow(() => verifyToolSurface(surface, requestVariants(second)));
|
|
assert.equal(audit.tools.length, tools.length); assert.ok(audit.tools.every(value => value.bytes > 0 && /^[a-f0-9]{64}$/.test(value.schemaSha256)));
|
|
assert.equal(audit.firstChange.kind, 'added'); assert.match(audit.firstChange.path, /^(?:messages|input)\[/);
|
|
assert.ok(audit.commonPrefixBytes > 40); assert.equal(audit.blocks[0].path, 'model'); assert.equal(audit.blocks[1].path, 'tools');
|
|
const changed = prefixAudit({ ...second, tools: [] }, first, { schemaVersion: 2 }).variants[0];
|
|
assert.equal(changed.firstChange.path, 'tools'); assert.equal(changed.reason, 'tool_surface_changed');
|
|
assert.equal(JSON.stringify(second), original); assert.doesNotMatch(original, /generation|schemaSha256|requestObservation/);
|
|
}
|
|
});
|
|
|
|
test('actual runtime observes new browser resources, missing resources and distinct repeated user instances; old configuration stays frozen', async t => {
|
|
const f = fixture(t); let firstRound = true;
|
|
const server = await compatibleFixture(t, () => {
|
|
if (firstRound) {
|
|
firstRound = false;
|
|
const tabId = randomUUID();
|
|
f.store.core.browsing_tab.set(tabId, { id: tabId, projectId: f.project.id, sessionId: f.session.id, taskId: f.session.taskId,
|
|
runId: f.session.runId, createdAt: new Date().toISOString(), status: 'open', revision: 1,
|
|
windowId: 'owned-window', profileId: 'owned-profile', origins: [], url: 'http://127.0.0.1/', grantRevision: 'owned-grant' });
|
|
return completion([call('one-list', 'list_files', { path: '' })]);
|
|
}
|
|
return completion([], '所属读取已完成。');
|
|
});
|
|
const provider = new Provider(); provider.setKey('owned-test-key');
|
|
f.store.saveConfig({ mode: 'compatible', baseUrl: server.baseUrl, model: 'owned', contextLimit: 64000 });
|
|
const runtime = new Runtime(f.store, provider); f.onCleanup(() => runtime.stopAll());
|
|
const run = async content => { runtime.start(f.session.id, content); await runtime.active.get(f.session.id).promise; };
|
|
await run('只读取一次目录然后回答,不修改文件,不执行工程检查。');
|
|
const plans = [...f.store.core.context_plan.values()]; assert.equal(plans.length, 2, JSON.stringify(f.session.lastFailure));
|
|
const [one, two] = plans.map(plan => plan.requestObservation.toolSurface);
|
|
assert.equal(one.entries.find(tool => tool.name === 'observe_browser_tab').reason, 'missing_current_resource');
|
|
assert.equal(two.entries.find(tool => tool.name === 'observe_browser_tab').reason, 'visible');
|
|
assert.notEqual(one.generation, two.generation);
|
|
assert.equal(plans[1].prefixAudit.variants[0].firstChange.path, 'tools');
|
|
assert.equal(one.entries.find(tool => tool.name === 'read_registered_skill').reason, 'missing_current_resource');
|
|
const oldArtifact = f.store.artifactStore.read(f.store.core.artifact.get(plans[0].artifactId));
|
|
f.store.saveConfig({ model: 'owned-new-setting' });
|
|
await run('继续'); await run('继续');
|
|
const all = [...f.store.core.context_plan.values()];
|
|
const instances = all.at(-1).requestObservation.userMessageInstances.filter(value => value.origin === 'user');
|
|
assert.equal(instances.length, 3); assert.notEqual(instances[1].id, instances[2].id); assert.equal(instances[1].sha256, instances[2].sha256);
|
|
assert.equal(all.at(-1).prefixAudit.previousPlanId, all.at(-2).id);
|
|
assert.equal(f.store.artifactStore.read(f.store.core.artifact.get(plans[0].artifactId)), oldArtifact);
|
|
for (const plan of all) assert.doesNotThrow(() => verifyPlanEvidence(f.store, f.session, plan));
|
|
assert.equal(server.requests.length, 4);
|
|
});
|
|
|
|
test('diagnostic request history and prefix predecessor remain separate from the main path across restart', async t => {
|
|
const f = fixture(t, { modernDefaults: true });
|
|
const server = await compatibleFixture(t, () => completion([], '原事实答复。'));
|
|
const provider = new Provider(), hub = provider.modelHub(f.store);
|
|
const connection = hub.upsert({ name: 'Owned', model: 'owned', baseUrl: server.baseUrl, requiresKey: false }); hub.select({ type: 'connection', id: connection.id });
|
|
const runtime = new Runtime(f.store, provider); f.onCleanup(() => runtime.stopAll());
|
|
const run = async content => { runtime.start(f.session.id, content); await runtime.active.get(f.session.id).promise; };
|
|
await run('读取原项目说明并回答;不修改文件,不执行检查。');
|
|
const main = structuredClone(f.session.providerMessages), first = [...f.store.core.context_plan.values()].at(-1);
|
|
await run('前面的错误是怎么回事?');
|
|
const diagnostic = [...f.store.core.context_plan.values()].at(-1);
|
|
assert.equal(diagnostic.requestObservation.path.kind, 'diagnostic'); assert.equal(diagnostic.prefixAudit.previousPlanId, null);
|
|
assert.deepEqual(f.session.providerMessages, main);
|
|
await run('继续');
|
|
const last = [...f.store.core.context_plan.values()].at(-1);
|
|
assert.equal(last.prefixAudit.previousPlanId, first.id); assert.equal(last.requestObservation.path.kind, 'main');
|
|
assert.doesNotMatch(JSON.stringify(server.requests.at(-1).input), /前面的错误是怎么回事/);
|
|
for (const plan of f.store.core.context_plan.values()) assert.doesNotThrow(() => verifyPlanEvidence(f.store, f.session, plan));
|
|
f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
|
|
for (const plan of reopened.core.context_plan.values()) assert.doesNotThrow(() => verifyPlanEvidence(reopened, reopened.session(f.session.id), plan));
|
|
});
|
|
|
|
test('legacy v1 evidence still verifies without adding new observations or changing old artifacts', t => {
|
|
const f = fixture(t), run = f.store.beginRun(f.session, 'Original finite-budget sample.', false, f.store.config);
|
|
f.session.providerMessages.push({ role: 'user', content: 'Original finite-budget sample.' });
|
|
const planner = new RequestPlanner(f.store), { body, record } = planner.prepare(f.session, run, f.store.config, { system: 'Original rules', tools: [] });
|
|
record.prefixAudit = { ...prefixAudit(body), previousPlanId: null, previousRequestSha256: null }; delete record.requestObservation;
|
|
record.artifactId = planner.artifact(f.session, run, record, 'context-plan').id;
|
|
const original = f.store.artifactStore.read(f.store.core.artifact.get(record.artifactId));
|
|
assert.doesNotThrow(() => verifyPlanEvidence(f.store, f.session, record));
|
|
assert.equal(record.prefixAudit.schemaVersion, 1); assert.equal(record.requestObservation, undefined);
|
|
assert.equal(f.store.artifactStore.read(f.store.core.artifact.get(record.artifactId)), original);
|
|
});
|