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); });