Files
Agent-Workbench/tests/model-request-contract.test.mjs

259 lines
26 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import http from 'node:http';
import { createHash } from 'node:crypto';
import { fixture, compatibleFixture, completion, call } from './helpers.mjs';
import { Provider } from '../src/server/provider.mjs';
import { Store } from '../src/server/store.mjs';
import { Runtime } from '../src/server/runtime.mjs';
import { CredentialVault } from '../src/core/models/credential-vault.mjs';
import { credentialScope } from '../src/core/models/model-catalog.mjs';
import { modelSnapshot } from '../src/shared/contracts/execution.mjs';
import { completionBody } from '../src/shared/contracts/model-request.mjs';
import { prefixAudit } from '../src/core/context/prefix-audit.mjs';
import { verifyPlanEvidence } from '../src/core/context/request-plan.mjs';
import { preparedRequestMetadata, requestContractAudit } from '../src/core/models/request-contract-audit.mjs';
import { defaultMessagesAuth, requestContractSettings, effectiveRequestContract, requestHeaders, REQUEST_CONTRACT_SOURCES } from '../src/shared/contracts/model-request-contract.mjs';
import { modelRequestUrl } from '../src/shared/contracts/model-endpoint.mjs';
import { resolveModelSpecification, matchingUpstreamModel } from '../src/shared/contracts/official-model-registry.mjs';
const sha = bytes => createHash('sha256').update(bytes).digest('hex');
const open = { mode: 'compatible', executionMode: 'unrestricted', capacityMode: 'passthrough', historyPolicy: 'preserve', maxOutputTokens: 128000 };
const messagesResponse = () => ({ id: 'owned-message', type: 'message', role: 'assistant', model: 'claude-opus-5-5', content: [{ type: 'text', text: '完成' }], stop_reason: 'end_turn', usage: { input_tokens: 7, output_tokens: 2 } });
const response = () => ({ id: 'owned-response', status: 'completed', model: 'gpt-6.1-sol', output: [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: '完成' }] }], usage: { input_tokens: 7, output_tokens: 2, total_tokens: 9 } });
function ownedHub(f) {
const provider = Object.assign(Object.create(Provider.prototype), { apiKey: '' }), hub = provider.modelHub(f.store);
f.onCleanup(() => provider.abortRequests());
hub.credentialVault = new CredentialVault(f.store, provider, { protect: bytes => Buffer.concat([Buffer.from('owned-only:'), bytes]), unprotect: bytes => bytes.subarray(11) });
return { provider, hub };
}
test('request defaults cite pinned successful official sources; the region redirect is preserved and rejected', () => {
const manifest = JSON.parse(fs.readFileSync(new URL('./fixtures/model-request-contract/SOURCE.json', import.meta.url)));
assert.equal(manifest.sources.filter(source => source.accepted !== false).length, 11);
const rejected = manifest.sources.find(source => source.id === 'anthropic-migration');
assert.equal(rejected.accepted, false); assert.match(rejected.responseUrl, /app-unavailable-in-region/);
for (const source of manifest.sources) {
const bytes = fs.readFileSync(new URL('./fixtures/model-request-contract/' + source.file, import.meta.url));
assert.equal(sha(bytes), source.sha256, source.id); assert.equal(bytes.length, source.bytes);
}
for (const source of Object.values(REQUEST_CONTRACT_SOURCES)) assert.ok(manifest.sources.some(item => item.accepted !== false && item.sha256 === source.sha256 && item.url === source.url));
});
test('new official defaults, existing connections and compatibility aliases have separate request contracts', () => {
assert.equal(matchingUpstreamModel(), null); assert.equal(resolveModelSpecification().model, '');
const official = { protocol: 'anthropic-messages', baseUrl: 'https://api.anthropic.com', model: 'claude-opus-5-5' };
const fresh = requestContractSettings(undefined, official, { existing: false });
assert.equal(fresh.anthropicVersion, '2026-10-21'); assert.equal(fresh.versionSource, 'official-default');
assert.equal(defaultMessagesAuth(official, { existing: false }), 'bearer');
assert.equal(effectiveRequestContract(official).anthropicVersion, '2023-06-01'); assert.equal(defaultMessagesAuth(official), 'api-key');
const proxy = { ...official, baseUrl: 'https://proxy.invalid', brand: 'Anthropic', providerId: 'anthropic' };
assert.equal(requestContractSettings(undefined, proxy, { existing: false }).anthropicVersion, '2023-06-01');
const deepseek = { ...official, baseUrl: 'https://api.deepseek.com/anthropic' };
const contract = requestContractSettings(undefined, deepseek, { existing: false });
assert.equal(contract.anthropicVersion, null); assert.equal(modelRequestUrl({ ...deepseek, requestContract: contract }), 'https://api.deepseek.com/anthropic/v1/messages');
assert.equal(requestHeaders({ ...deepseek, requestContract: contract }, 'owned-key').has('anthropic-version'), false);
assert.equal(effectiveRequestContract(deepseek).anthropicVersion, '2023-06-01');
});
test('explicit headers override case-insensitively, reference credentials and remove defaults without vendor whitelists or local quotas', () => {
const connection = { protocol: 'anthropic-messages', baseUrl: 'https://proxy.invalid/v1' };
const headers = Object.fromEntries(Array.from({ length: 513 }, (_, index) => ['x-owned-' + index, 'kept-' + index]));
Object.assign(headers, { 'X-Client-Request-Id': 'a'.repeat(800), 'x-owned-long': 'b'.repeat(70 * 1024), Authorization: 'Basic {{credential}}', 'x-api-key': null, 'Content-Type': null,
'anthropic-version': 'future-unknown-version', 'x-any-vendor-option': 'unchanged' });
const contract = requestContractSettings({ anthropicBetas: ['unknown-beta', 'another-beta', 'unknown-beta'], headers }, connection);
const actual = requestHeaders({ ...connection, requestContract: contract }, 'owned-only-key');
assert.equal(actual.get('authorization'), 'Basic owned-only-key'); assert.equal(actual.has('x-api-key'), false); assert.equal(actual.has('content-type'), false);
assert.equal(actual.get('anthropic-version'), 'future-unknown-version'); assert.equal(actual.get('anthropic-beta'), 'unknown-beta,another-beta,unknown-beta');
assert.equal(actual.get('x-owned-long').length, 70 * 1024); assert.equal(actual.get('x-client-request-id').length, 800);
assert.equal(actual.get('x-owned-512'), 'kept-512');
assert.throws(() => requestContractSettings({ headers: { 'bad\nname': 'value' } }, connection), /HTTP/);
assert.throws(() => requestContractSettings({ headers: { Authorization: 'Bearer plaintext-key' } }, connection), /独立 Key/);
assert.throws(() => requestContractSettings({ completionPath: '//other.invalid/messages' }, connection), /同源/);
});
test('mixed pool sends each frozen member version/auth/path/headers and records actual fetch metadata without keys', async t => {
const f = fixture(t, { modernDefaults: true });
const server = await compatibleFixture(t, (url, input) => ({ body: url.startsWith('/owned/messages') ? messagesResponse() : response(), headers: { 'openai-version': '2020-10-01', 'openai-organization': 'org-owned', 'openai-processing-ms': '17', 'x-request-id': 'owned-request' } }));
const { provider, hub } = ownedHub(f);
const first = hub.upsert({ name: '自有 Messages', protocol: 'anthropic-messages', model: 'claude-opus-5-5', baseUrl: server.baseUrl, apiKey: 'owned-first-key',
requestContract: { anthropicVersion: '2026-10-21', anthropicBetas: ['owned-beta'], completionPath: '/owned/messages', headers: { 'anthropic-workspace-id': 'workspace-owned' } } });
const second = hub.upsert({ name: '自有 Responses', protocol: 'responses', model: 'gpt-6.1-sol', baseUrl: server.baseUrl, apiKey: 'owned-second-key',
requestContract: { completionPath: '/owned/responses', headers: { 'OpenAI-Project': 'project-owned' } } });
const pool = hub.pool({ name: '独立成员设置', members: [{ connectionId: first.id }, { connectionId: second.id }], sticky: false });
const prepared = hub.prepare({ ...f.store.config, mode: 'compatible' }, { type: 'pool', id: pool.id }), frozen = modelSnapshot(prepared), before = JSON.stringify(frozen);
for (let index = 0; index < 2; index++) await provider.complete(prepared, [{ role: 'user', content: '单次所属请求' }], null, undefined, undefined, null, []);
assert.equal(server.requests.length, 2);
assert.equal(server.requests[0].url, '/owned/messages'); assert.equal(server.requests[0].headers['anthropic-version'], '2026-10-21');
assert.equal(server.requests[0].headers['x-api-key'], 'owned-first-key'); assert.equal(server.requests[0].headers['openai-project'], undefined);
assert.equal(server.requests[1].url, '/owned/responses'); assert.equal(server.requests[1].headers.authorization, 'Bearer owned-second-key');
assert.equal(server.requests[1].headers['anthropic-version'], undefined); assert.equal(server.requests[1].headers['anthropic-beta'], undefined);
assert.equal(server.requests[1].headers['anthropic-workspace-id'], undefined); assert.equal(server.requests[1].headers['openai-project'], 'project-owned');
for (const attempt of hub.attempts) {
assert.equal(attempt.status, 'completed'); assert.equal(attempt.requestMetadata.bodySha256, attempt.requestSha256);
assert.equal(attempt.requestMetadata.identity.connectionRevision, attempt.connectionRevision);
assert.equal(attempt.requestMetadata.identity.credentialRevision, attempt.credentialRevision);
assert.equal(attempt.upstreamResponse.headers['openai-version'], '2020-10-01');
assert.equal(attempt.upstreamResponse.headers['openai-processing-ms'], '17');
assert.equal(attempt.requestMetadata.upstreamCache, 'unknown'); assert.doesNotMatch(JSON.stringify(attempt), /owned-(?:first|second)-key/);
assert.equal(attempt.requestMetadata.source, 'prepared-fetch-arguments');
}
const changed = hub.upsert({ ...hub.connection(first.id), requestContract: { ...first.requestContract, anthropicVersion: 'future-explicit-version' } });
assert.equal(changed.requestContract.anthropicVersion, 'future-explicit-version'); assert.equal(JSON.stringify(frozen), before);
assert.equal(hub.prepare({ ...f.store.config, mode: 'compatible' }, { type: 'connection', id: first.id }).requestContract.anthropicVersion, 'future-explicit-version');
});
test('new API version errors preserve the user sampling body and response/version diagnostics without automatic edits or replay', async t => {
const f = fixture(t, { modernDefaults: true });
const server = await compatibleFixture(t, () => ({ status: 400, body: { error: { type: 'invalid_request_error', message: 'temperature is removed in 2026-10-21', param: 'temperature' } }, headers: { 'anthropic-version': '2026-10-21', 'x-request-id': 'owned-invalid-version' } }));
const { provider, hub } = ownedHub(f), native = { temperature: 0.7, top_p: 0.8, top_k: 5, output_config: { effort: 'high', vendor: { keep: true } } };
const source = hub.upsert({ name: '自有原错', protocol: 'anthropic-messages', model: 'claude-opus-5-5', baseUrl: server.baseUrl, apiKey: 'owned-error-key', nativeParameters: native,
requestContract: { anthropicVersion: '2026-10-21', anthropicBetas: ['unknown-beta'], headers: { 'x-owned-auth': '{{credential}}' } } });
await assert.rejects(provider.complete(hub.prepare({ ...f.store.config, mode: 'compatible' }, { type: 'connection', id: source.id }), [{ role: 'user', content: '保留参数' }], null, undefined, undefined, null, []), cause => {
assert.equal(cause.diagnostic.httpStatus, 400); assert.match(cause.diagnostic.upstream.rawPreview, /temperature is removed/);
assert.equal(cause.diagnostic.requestMetadata.headers.find(([name]) => name === 'anthropic-version')[1], '2026-10-21');
assert.equal(cause.diagnostic.retryDecision, 'passthrough'); return true;
});
assert.equal(server.requests.length, 1); for (const [name, value] of Object.entries(native)) assert.deepEqual(server.requests[0].input[name], value);
const attempt = hub.attempts[0]; assert.equal(attempt.status, 'failed'); assert.equal(attempt.upstreamResponse.headers['anthropic-version'], '2026-10-21');
assert.doesNotMatch(JSON.stringify(attempt), /owned-error-key/); assert.deepEqual(hub.connection(source.id).nativeParameters, native);
});
test('request observations redact values structurally even when a synthetic credential contains JSON punctuation', async t => {
const f = fixture(t, { modernDefaults: true });
const server = await compatibleFixture(t, () => ({ status: 400, body: { error: { type: 'invalid_request_error', message: 'owned upstream rejection' } } }));
const { provider, hub } = ownedHub(f);
const source = hub.upsert({ name: '自有脱敏边界', protocol: 'chat-completions', model: 'owned-redaction-model', baseUrl: server.baseUrl, apiKey: '{',
nativeParameters: { temperature: 0.7, metadata: { note: '{value}', preserved: [null, false, 9] } } });
const config = hub.prepare({ ...f.store.config, mode: 'compatible' }, { type: 'connection', id: source.id });
await assert.rejects(provider.complete(config, [{ role: 'user', content: '单次请求' }], null, undefined, undefined, null, []), cause => {
assert.equal(cause.diagnostic.httpStatus, 400); assert.equal(cause.diagnostic.origin, 'upstream'); return true;
});
assert.equal(server.requests.length, 1); assert.equal(server.requests[0].input.metadata.note, '{value}');
const observed = hub.attempts[0].requestMetadata;
assert.equal(observed.nonPromptParameters.temperature, 0.7); assert.equal(observed.nonPromptParameters.metadata.note, '[已隐藏]value}');
assert.deepEqual(observed.nonPromptParameters.metadata.preserved, [null, false, 9]);
assert.equal(observed.contract.schemaVersion, 1); assert.equal(observed.bodySha256, hub.attempts[0].requestSha256);
});
test('version/beta/non-auth edits preserve encrypted binding and shared catalog credentials; auth/path changes invalidate without resurrecting old blocks', t => {
const f = fixture(t, { modernDefaults: true }), { provider, hub } = ownedHub(f);
const source = hub.upsert({ name: '自有绑定', model: 'owned-model', protocol: 'chat-completions', baseUrl: 'http://127.0.0.1:1/v1', apiKey: 'owned-contract-key', persistKey: true });
const cipher = f.store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelCredentials'").get().value;
const credential = provider.credentials.get(source.id), scope = credentialScope(hub.connection(source.id));
hub.vault().protect = () => { throw Error('Must not re-encrypt original credential'); };
const harmless = hub.upsert({ ...hub.connection(source.id), requestContract: { ...source.requestContract, anthropicVersion: 'explicit-future', anthropicBetas: ['owned'], headers: { 'OpenAI-Organization': 'org-owned', 'OpenAI-Project': 'project-owned' } } });
assert.equal(harmless.credentialBindingRevision, source.credentialBindingRevision); assert.equal(credentialScope(harmless), scope);
assert.equal(hub.vault().status(harmless).status, 'saved'); assert.equal(provider.credentials.get(source.id), credential);
assert.equal(f.store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelCredentials'").get().value, cipher);
f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
const newProvider = Object.assign(Object.create(Provider.prototype), { apiKey: '' }), restoredHub = newProvider.modelHub(reopened);
f.onCleanup(() => newProvider.abortRequests());
restoredHub.credentialVault = new CredentialVault(reopened, newProvider, { protect: () => { throw Error('Restore cannot encrypt'); }, unprotect: bytes => bytes.subarray(11) });
restoredHub.credentialVault.restore(restoredHub); assert.equal(newProvider.credentials.get(source.id)?.key, 'owned-contract-key');
const restored = restoredHub.connection(source.id);
const edited = restoredHub.upsert({ ...restored, requestContract: { ...restored.requestContract, auth: 'none', headers: { 'x-owned-key': '{{credential}}' }, completionPath: '/changed/chat' } });
assert.equal(restoredHub.vault().status(edited).status, 'source_changed');
const reverted = restoredHub.upsert({ ...edited, requestContract: restored.requestContract });
assert.equal(restoredHub.vault().status(reverted).status, 'source_changed');
assert.equal(reopened.storage.database.prepare("SELECT value FROM metadata WHERE key='modelCredentials'").get().value, cipher);
});
test('catalog uses custom model path/version/headers and inherits its frozen contract without copying credentials', async t => {
const f = fixture(t, { modernDefaults: true }), server = await compatibleFixture(t, () => ({ data: [{ id: 'owned-catalog-a' }, { id: 'owned-catalog-b' }] }));
const { hub } = ownedHub(f);
const source = hub.upsert({ name: '自有目录', model: 'owned-catalog-a', protocol: 'chat-completions', baseUrl: server.baseUrl, apiKey: 'owned-catalog-contract-key',
requestContract: { modelsPath: '/owned/models?group=one', completionPath: '/owned/chat', headers: { 'OpenAI-Project': 'catalog-project' } } });
const preview = await hub.modelCatalog().fetch({ id: source.id, revision: source.revision });
const result = hub.modelCatalog().apply({ previewId: preview.id, models: ['owned-catalog-a', 'owned-catalog-b'], routing: 'keep' });
assert.equal(server.requests.length, 1); assert.equal(server.requests[0].url, '/owned/models?group=one');
assert.equal(server.requests[0].headers['openai-project'], 'catalog-project');
const added = hub.connection(result.added[0]); assert.equal(added.requestContract.modelsPath, '/owned/models?group=one');
assert.equal(added.credentialSource.connectionId, source.id); assert.equal(hub.provider.credentials.has(added.id), false);
assert.equal(hub.credential(added).key, 'owned-catalog-contract-key'); assert.doesNotMatch(JSON.stringify(preview), /owned-catalog-contract-key/);
const original = structuredClone(added.upstreamModel), snapshot = modelSnapshot(hub.prepare({ ...f.store.config, mode: 'compatible' }, { type: 'connection', id: added.id }));
assert.equal(matchingUpstreamModel({ ...added, credentialRevision: 1 }).id, added.model);
const edited = hub.upsert({ ...added, requestContract: { ...added.requestContract, headers: { 'OpenAI-Project': 'other-project' } } });
assert.equal(matchingUpstreamModel({ ...edited, credentialRevision: 1 }), null); assert.deepEqual(edited.upstreamModel, original);
assert.deepEqual(snapshot.routing.members[0].upstreamModel, original);
assert.equal(matchingUpstreamModel({ ...added, credentialRevision: 2 }), null);
});
test('actual Messages SSE and redirect keep their request headers; catalog observations bind the saved source identity', async t => {
const f = fixture(t, { modernDefaults: true }), requests = [], { provider, hub } = ownedHub(f);
const server = http.createServer(async (request, result) => {
const chunks = []; for await (const chunk of request) chunks.push(chunk);
const input = chunks.length ? JSON.parse(Buffer.concat(chunks)) : null;
requests.push({ url: request.url, headers: request.headers, input });
if (request.url === '/owned/redirect') { result.writeHead(302, { Location: '/owned/target' }); result.end(); return; }
if (request.method === 'GET') { result.writeHead(200, { 'Content-Type': 'application/json' }); result.end('{"data":[]}'); return; }
result.writeHead(200, { 'Content-Type': 'text/event-stream', 'anthropic-version': '2026-10-21', 'x-request-id': 'owned-sse' });
const event = (name, value) => result.write('event: ' + name + '\ndata: ' + JSON.stringify({ type: name, ...value }) + '\n\n');
event('message_start', { message: { id: 'owned-sse-message', model: input.model, role: 'assistant', type: 'message', content: [], usage: { input_tokens: 7, output_tokens: 0 } } });
event('content_block_start', { index: 0, content_block: { type: 'text', text: '' } });
event('content_block_delta', { index: 0, delta: { type: 'text_delta', text: '完成' } });
event('content_block_stop', { index: 0 });
event('message_delta', { delta: { stop_reason: 'end_turn', stop_sequence: null }, usage: { output_tokens: 2 } });
event('message_stop', {}); result.end();
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
t.after(() => new Promise(resolve => { server.closeAllConnections(); server.close(resolve); }));
const baseUrl = 'http://127.0.0.1:' + server.address().port + '/v1';
const source = hub.upsert({ name: '自有流式', baseUrl, protocol: 'anthropic-messages', model: 'claude-opus-5-5', streaming: true, apiKey: 'owned-sse-key',
requestContract: { completionPath: '/owned/sse', modelsPath: '/owned/models', anthropicVersion: '2026-10-21', anthropicBetas: ['owned-stream'], headers: { 'anthropic-workspace-id': 'owned-workspace' } } });
const config = hub.prepare({ ...f.store.config, mode: 'compatible' }, { type: 'connection', id: source.id });
const result = await provider.complete(config, [{ role: 'user', content: '流式请求' }], null, undefined, undefined, null, []);
assert.equal(result.message.content, '完成'); assert.equal(requests[0].input.stream, true);
assert.equal(requests[0].headers['anthropic-beta'], 'owned-stream'); assert.equal(requests[0].headers['anthropic-workspace-id'], 'owned-workspace');
assert.equal(hub.attempts[0].requestMetadata.headers.find(([name]) => name === 'anthropic-version')[1], '2026-10-21');
assert.equal(hub.attempts[0].stream.terminal, true);
let catalogMetadata;
await provider.request({ ...f.store.config, ...hub.connection(source.id) }, '/owned/models', undefined, undefined, 'owned-sse-key', value => { catalogMetadata ??= value.requestMetadata; });
assert.equal(catalogMetadata.identity.connectionId, source.id); assert.equal(catalogMetadata.identity.connectionRevision, source.revision);
assert.equal(catalogMetadata.identity.credentialRevision, 1);
await assert.rejects(provider.request({ ...config, requestContract: { ...config.requestContract, completionPath: '/owned/redirect' } }, '/owned/redirect', { model: source.model }, undefined, 'owned-sse-key'), cause => {
assert.equal(cause.diagnostic.httpStatus, 302); assert.equal(cause.diagnostic.redirectMode, 'manual'); return true;
});
assert.equal(requests.length, 3); assert.equal(requests.some(value => value.url === '/owned/target'), false);
});
test('contract fingerprints detect non-prompt/version/state changes independently of original ordered-prefix v1/v2', () => {
const config = { ...open, model: 'gpt-6.1-sol', protocol: 'responses', baseUrl: 'https://api.openai.com/v1', nativeParameters: { temperature: 0.1, prompt_cache_key: 'owned-key', previous_response_id: 'owned-first' } };
const first = completionBody(config, [{ role: 'user', content: '原目标' }], []);
const changed = { ...first, temperature: 0.9, previous_response_id: 'owned-second' };
for (const schemaVersion of [1, 2]) assert.equal(prefixAudit(changed, first, { schemaVersion }).variants[0].reason, 'same_prompt');
const audit = requestContractAudit(changed, config, first, config).variants[0];
assert.equal(audit.source, 'frozen-run-contract'); assert.equal(audit.representation, 'frozen-request-contract-redacted-v1');
assert.equal(audit.reason, 'observed_contract_changed'); assert.deepEqual(audit.changed, ['nonPromptParameters']); assert.equal(audit.upstreamCache, 'unknown');
const appended = { ...first, input: [...first.input, { role: 'user', content: '继续' }] };
assert.equal(requestContractAudit(appended, config, first, config).variants[0].reason, 'same_observed_contract');
const headerConfig = { ...config, requestContract: requestContractSettings({ headers: { 'OpenAI-Project': 'different-project' } }, config) };
assert.ok(requestContractAudit(first, headerConfig, first, config).variants[0].changed.includes('headers'));
assert.equal(preparedRequestMetadata(config, first).bodySha256, sha(JSON.stringify(first)));
const specification = resolveModelSpecification(config), original = JSON.stringify(specification);
const frozen = { ...config, modelSpecification: specification, modelSpecificationFrozen: true };
assert.equal(resolveModelSpecification(frozen).connectionBinding.baseUrl, config.baseUrl);
assert.equal(resolveModelSpecification({ ...frozen, baseUrl: 'https://other.invalid/v1' }).connectionBinding.baseUrl, 'https://other.invalid/v1');
assert.equal(JSON.stringify(specification), original);
const legacy = structuredClone(specification); delete legacy.connectionBinding;
assert.deepEqual(resolveModelSpecification({ ...frozen, baseUrl: 'https://other.invalid/v1', modelSpecification: legacy }), legacy);
});
test('runtime freezes and verifies separate contract observations; later edits cannot rewrite old request artifacts or metadata', async t => {
const f = fixture(t, { modernDefaults: true }); let count = 0;
const server = await compatibleFixture(t, () => ++count === 1 ? completion([call('owned-list', 'list_files', { path: '' })]) : completion([], '完成'));
const provider = Object.assign(Object.create(Provider.prototype), { apiKey: '' }); provider.setKey('owned-runtime-contract-key'); f.onCleanup(() => provider.abortRequests());
f.store.saveConfig({ ...open, baseUrl: server.baseUrl, model: 'owned-runtime-model' });
const runtime = new Runtime(f.store, provider); f.onCleanup(() => runtime.stopAll());
runtime.start(f.session.id, '读取项目一次'); await runtime.active.get(f.session.id).promise;
const plans = [...f.store.core.context_plan.values()]; assert.equal(plans.length, 2);
const original = plans.map(plan => f.store.artifactStore.read(f.store.core.artifact.get(plan.artifactId)));
for (const plan of plans) { assert.equal(plan.requestContractAudit.schemaVersion, 1); assert.doesNotThrow(() => verifyPlanEvidence(f.store, f.session, plan)); }
assert.equal(plans[1].requestContractAudit.variants[0].reason, 'same_observed_contract');
const old = plans[1].requestContractAudit; plans[1].requestContractAudit = { ...old, previousRequestSha256: '0'.repeat(64) };
assert.throws(() => verifyPlanEvidence(f.store, f.session, plans[1]), /封存|对照/); plans[1].requestContractAudit = old;
for (const [index, plan] of plans.entries()) assert.deepEqual(f.store.artifactStore.read(f.store.core.artifact.get(plan.artifactId)), original[index]);
assert.equal(server.requests.length, 2);
});