51 lines
3.9 KiB
JavaScript
51 lines
3.9 KiB
JavaScript
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);
|
|
}
|
|
});
|