Files
Agent-Workbench/tests/model-capabilities.test.mjs
2026-10-31 21:56:41 +08:00

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