import test from 'node:test'; import assert from 'node:assert/strict'; import { fixture } from './helpers.mjs'; import { Provider } from '../src/server/provider.mjs'; import { Store } from '../src/server/store.mjs'; import { capabilityView, capabilityRejections } from '../src/shared/contracts/model-capabilities.mjs'; const input = { name: 'Owned Responses', model: 'owned-model', protocol: 'responses', baseUrl: 'http://127.0.0.1:12345/v1', requiresKey: false }; test('schema1 connections remain readable without inventing observed capabilities or migrating original state', t => { const f = fixture(t), provider = new Provider(); const original = { schema: 1, revision: 4, selected: { type: 'connection', id: 'owned-old' }, pools: [], imports: {}, connections: [{ ...input, protocol: 'chat-completions', id: 'owned-old', revision: 1, enabled: true }] }; f.store.storage.setMeta('modelRegistry', original); const hub = provider.modelHub(f.store), old = hub.view().connections.find(item => item.id === 'owned-old'); assert.equal(old.capabilities.tools, 'protocol_declared'); assert.equal(old.capabilities.streaming, 'unknown'); assert.equal(old.capabilities.vision, 'unknown'); assert.equal(old.capabilities.audio, 'unknown'); assert.deepEqual(f.store.storage.meta('modelRegistry'), original); }); test('protocol, unsupported capabilities and stream choice persist; client claims cannot forge verified evidence', t => { const f = fixture(t), provider = new Provider(), hub = provider.modelHub(f.store); const connection = hub.upsert({ ...input, streaming: true, apiKey: 'owned-volatile', capabilityDeclarations: { tools: 'unsupported', streaming: 'supported' }, capabilityEvidence: { results: { tools: 'verified' } } }); assert.equal(connection.protocol, 'responses'); assert.equal(connection.capabilities.tools, 'unsupported'); assert.equal(connection.capabilityEvidence, undefined); assert.equal(connection.capabilities.streaming, 'protocol_declared'); assert.equal(JSON.stringify(f.store.storage.meta('modelRegistry')).includes('owned-volatile'), false); assert.throws(() => hub.upsert({ ...input, protocol: 'unknown' }), /协议/); f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close()); const restored = new Provider().modelHub(reopened).connection(connection.id); assert.equal(restored.streaming, true); assert.equal(restored.capabilityDeclarations.tools, 'unsupported'); assert.equal(restored.protocol, 'responses'); }); test('ability evidence belongs to exact connection and credential revision; unknown and unsupported reject required routing', () => { const connection = { ...input, id: 'owned', revision: 3, capabilityDeclarations: { text: 'supported', tools: 'unknown', streaming: 'unsupported' }, capabilityEvidence: { connectionRevision: 3, credentialRevision: 7, results: { tools: 'verified', text: 'verified' } } }; assert.equal(capabilityView(connection, 7).tools, 'verified'); assert.equal(capabilityView(connection, 8).tools, 'unknown'); assert.deepEqual(capabilityRejections(connection, ['text', 'tools', 'streaming'], 7).map(item => item.capability), ['streaming']); assert.deepEqual(capabilityRejections({ ...connection, revision: 4 }, ['text', 'tools'], 7).map(item => item.capability), ['tools']); }); test('invalid declarations and inconsistent stream settings reject before registry, revision and credentials mutate', t => { const f = fixture(t), provider = new Provider(), hub = provider.modelHub(f.store), connection = hub.upsert(input); const before = structuredClone(hub.state); for (const change of [{ capabilityDeclarations: { tools: 'verified' } }, { capabilityDeclarations: { invented: 'supported' } }, { streaming: true }, { streaming: 'yes' }]) { assert.throws(() => hub.upsert({ ...connection, ...change, apiKey: 'owned-should-not-save' })); assert.deepEqual(hub.state, before); assert.equal(provider.credentials.has(connection.id), false); } });