85 lines
6.9 KiB
JavaScript
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);
|
|
});
|