Files
Agent-Workbench/tests/prefix-stability.test.mjs
2026-11-06 06:21:59 +08:00

85 lines
6.9 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { fixture, compatibleFixture, completion, until, call } from './helpers.mjs';
import { Provider } from '../src/server/provider.mjs';
import { Runtime } from '../src/server/runtime.mjs';
import { RequestPlanner, verifyPlanEvidence } from '../src/core/context/request-plan.mjs';
import { completionBody } from '../src/shared/contracts/model-request.mjs';
import { reportedUsage } from '../src/core/models/protocols.mjs';
import { prefixAudit } from '../src/core/context/prefix-audit.mjs';
test('complete history remains verbatim in passthrough; only an explicitly selected manual capacity can pause it', t => {
const f = fixture(t, { modernDefaults: true }), config = { ...f.store.config, contextLimit: 128000 };
const run = f.store.beginRun(f.session, 'Keep the complete original text.', false, config);
const history = [{ role: 'user', content: 'Keep the original request.' }, { role: 'assistant', content: 'Owned original reference\n'.repeat(3500) }];
f.session.providerMessages.push(...history);
const planner = new RequestPlanner(f.store), plan = planner.prepare(f.session, run, config, { system: 'Stable rules', tools: [], contextTail: 'State A' });
assert.equal(plan.record.archivedGroups, 0); assert.ok(plan.record.estimatedInputTokens > 16000);
assert.deepEqual(plan.body.messages.slice(1, 3), history); assert.equal(plan.record.retainedMessages, history.length);
assert.doesNotThrow(() => verifyPlanEvidence(f.store, f.session, plan.record));
const open = planner.prepare(f.session, run, { ...config, contextLimit: 18000 }, { system: 'Stable rules', tools: [] });
assert.deepEqual(open.body.messages.slice(1), history); assert.equal(open.record.archivedGroups, 0);
assert.equal(Object.hasOwn(open.body, 'max_tokens'), false);
const before = f.store.core.context_plan.size;
assert.throws(() => planner.prepare(f.session, run, { ...config, capacityMode: 'manual', contextLimit: 18000, maxOutputTokens: 2048 }, { system: 'Stable rules', tools: [] }), cause => cause.reason === 'context_limit');
assert.equal(f.store.core.context_plan.size, before); assert.deepEqual(f.session.providerMessages, history);
});
test('runtime keeps fixed rules and original user messages in front of changing state; cache details remain upstream facts', async t => {
const f = fixture(t, { modernDefaults: true });
const server = await compatibleFixture(t, (_url, body) => ({ ...completion(body.messages.some(row => row.role === 'tool') ? [] : [call('owned-read', 'list_files', { path: '' })], 'Read once.'),
usage: { prompt_tokens: 1000, completion_tokens: 20, prompt_tokens_details: { cached_tokens: 700 } } }));
const provider = new Provider(), hub = provider.modelHub(f.store), c = hub.upsert({ name: 'Owned stable', model: 'owned', baseUrl: server.baseUrl, requiresKey: false });
hub.select({ type: 'connection', id: c.id });
const runtime = new Runtime(f.store, provider); f.onCleanup(() => runtime.stopAll());
runtime.start(f.session.id, 'Inspect once, answer only; do not change files.'); await until(() => !runtime.isActive(f.session.id), 15000);
assert.equal(f.session.status, 'completed'); assert.equal(server.requests.length, 2);
const [first, second] = server.requests.map(row => row.input);
assert.deepEqual(first.tools, second.tools); assert.deepEqual(first.messages[0], second.messages[0]);
assert.deepEqual(first.messages[1], second.messages[1]); assert.equal(first.messages.at(-1).role, 'user');
assert.ok(!first.messages[0].content.includes('当前Task文件提案状态'));
const plans = [...f.store.core.context_plan.values()];
for (const plan of plans) assert.doesNotThrow(() => verifyPlanEvidence(f.store, f.session, plan));
assert.ok(plans[1].prefixAudit.variants[0].commonPrefixBytes > Buffer.byteLength(first.messages[0].content));
assert.equal(plans[1].prefixAudit.upstreamCache, 'unknown');
assert.equal(plans[1].actualUsage.prompt_tokens_details.cached_tokens, 700);
const taskId = f.session.taskId;
for (let index = 0; index < 2; index++) {
runtime.start(f.session.id, '继续'); await until(() => !runtime.isActive(f.session.id), 15000);
assert.equal(f.session.taskId, taskId);
}
const continued = [...f.store.core.context_plan.values()];
assert.equal(server.requests.length, 4);
assert.equal(f.session.providerMessages.filter(row => row.role === 'user' && row.content === '继续').length, 2);
for (let index = 2; index < continued.length; index++) {
assert.equal(continued[index].prefixAudit.previousPlanId, continued[index - 1].id);
assert.doesNotThrow(() => verifyPlanEvidence(f.store, f.session, continued[index]));
}
});
test('Messages keeps changing state out of native system blocks and detects tool or route changes', () => {
const cfg = { protocol: 'anthropic-messages', model: 'owned', maxOutputTokens: 32768, baseUrl: 'https://owned.test' };
const history = [{ role: 'system', content: 'Fixed native rules' }, { role: 'user', content: 'Original request' }];
const one = completionBody(cfg, [...history, { role: 'user', content: 'State A' }], []);
const two = completionBody(cfg, [...history, { role: 'assistant', content: 'Observed.' }, { role: 'user', content: 'State B' }], []);
assert.deepEqual(one.system, two.system); assert.equal(two.system.length, 1);
assert.ok(prefixAudit(two, one).variants[0].commonPrefixBytes > 40);
assert.equal(prefixAudit({ ...two, tools: [{ name: 'new-tool' }] }, two).variants[0].reason, 'tool_surface_changed');
assert.equal(prefixAudit({ ...two, model: 'different' }, two).variants[0].commonPrefixBytes, 0);
});
test('Chat, Responses and DeepSeek cache receipts preserve raw counters; missing or impossible counters stay unknown', () => {
for (const [config, raw, expected] of [
[{ protocol: 'chat-completions' }, { prompt_tokens: 1000, completion_tokens: 50, prompt_tokens_details: { cached_tokens: 750 } }, 750],
[{ protocol: 'responses' }, { input_tokens: 1000, output_tokens: 50, input_tokens_details: { cached_tokens: 800 } }, 800],
[{ protocol: 'chat-completions' }, { prompt_tokens: 1000, completion_tokens: 50, prompt_cache_hit_tokens: 900, prompt_cache_miss_tokens: 100 }, 900],
]) {
const usage = reportedUsage(config, { usage: raw });
assert.equal(usage.prompt_tokens_details.cached_tokens, expected); assert.deepEqual(usage.raw, raw); assert.equal(usage.total_tokens, 1050);
}
for (const cached of [undefined, -1, 1001, '900']) assert.equal(reportedUsage({}, { usage: { prompt_tokens: 1000, completion_tokens: 50, prompt_cache_hit_tokens: cached } }).prompt_tokens_details, undefined);
const messages = { protocol: 'anthropic-messages' };
assert.equal(reportedUsage(messages, { usage: { input_tokens: 1000, output_tokens: 50 } }).prompt_tokens_details, undefined);
assert.equal(reportedUsage(messages, { usage: { input_tokens: 1000, output_tokens: 50, cache_read_input_tokens: 0 } }).prompt_tokens_details.cached_tokens, 0);
});