Files
Agent-Workbench/tests/model-connection-unification.test.mjs

69 lines
5.4 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { fixture, compatibleFixture } from './helpers.mjs';
import { Provider } from '../src/server/provider.mjs';
import { Store } from '../src/server/store.mjs';
test('existing connection uses the common editor contract without switching the selected pool or replacing its credential', t => {
const f = fixture(t, { modernDefaults: true }), provider = new Provider(); provider.setKey('owned-existing-key');
f.store.saveConfig({ mode: 'compatible', baseUrl: 'http://127.0.0.1:12340/v1', model: 'existing-model' });
const hub = provider.modelHub(f.store), original = hub.connection('legacy-default');
assert.equal(original.name, 'existing-model');
const second = hub.upsert({ name: 'Other', model: 'other', baseUrl: 'http://127.0.0.1:12341/v1', requiresKey: false });
const pool = hub.pool({ name: 'Current pool', members: [{ connectionId: second.id }] });
hub.select({ type: 'pool', id: pool.id });
const before = structuredClone(hub.state.selected), revision = hub.connection(original.id).revision;
const saved = hub.upsert({ ...hub.connection(original.id), name: 'My upstream', model: 'updated-model', requiresKey: true, concurrency: 0 });
assert.equal(saved.id, original.id); assert.equal(saved.revision, revision + 1);
assert.equal(saved.name, 'My upstream'); assert.equal(saved.hasKey, true);
assert.equal(provider.apiKey, 'owned-existing-key'); assert.equal(provider.legacyCredentialRevision, undefined);
assert.deepEqual(hub.state.selected, before); assert.equal(f.store.config.model, 'updated-model');
assert.equal(hub.connections().filter(value => value.id === original.id).length, 1);
assert.throws(() => hub.upsert({ ...original, name: 'Stale edit' }), { status: 409 });
assert.equal(JSON.stringify(hub.view()).includes('owned-existing-key'), false);
assert.equal(JSON.stringify(f.store.storage.meta('modelRegistry')).includes('owned-existing-key'), false);
f.store.close();
const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
const restored = new Provider().modelHub(reopened);
assert.equal(restored.connection(original.id).name, 'My upstream');
assert.equal(restored.connection(original.id).concurrency, 0);
assert.deepEqual(restored.state.selected, before);
});
test('existing connection saves protocol, reasoning and identity settings and sends them using its unchanged credential', async t => {
const f = fixture(t, { modernDefaults: true }), provider = new Provider(); provider.setKey('owned-retained-key');
const server = await compatibleFixture(t, () => ({ body: { id: 'owned-response', model: 'owned-response-model', status: 'completed',
output: [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'Complete.' }] }],
usage: { input_tokens: 12, output_tokens: 3, total_tokens: 15 } } }));
f.store.saveConfig({ mode: 'compatible', baseUrl: server.baseUrl, model: 'owned-response-model' });
const hub = provider.modelHub(f.store), saved = hub.upsert({ ...hub.connection('legacy-default'), name: 'Responses service',
protocol: 'responses', requiresKey: true, nativeParameters: { reasoning: { effort: 'high' } }, parameterProfile: 'openai', modelIdentityPolicy: 'require-match' });
assert.equal(hub.selectionView().name, 'Responses service');
const config = provider.prepareConfig(f.store.config, f.store);
assert.equal(config.protocol, 'responses'); assert.equal(config.modelRouting.members[0].modelIdentityPolicy, 'require-match');
const result = await provider.complete(config, [{ role: 'user', content: 'Reply.' }], f.project, undefined, undefined, null, []);
assert.equal(result.message.content, 'Complete.'); assert.equal(server.requests.length, 1);
assert.equal(server.requests[0].url, '/v1/responses');
assert.equal(server.requests[0].headers.authorization, 'Bearer owned-retained-key');
assert.deepEqual(server.requests[0].input.reasoning, { effort: 'high' });
assert.equal(Object.hasOwn(server.requests[0].input, 'max_output_tokens'), false);
assert.equal(hub.toggle(saved.id, false).enabled, false);
assert.throws(() => provider.prepareConfig(f.store.config, f.store), /没有可用模型连接/);
assert.equal(hub.toggle(saved.id, true).enabled, true);
assert.equal(provider.apiKey, 'owned-retained-key');
});
test('failed common-editor save atomically restores existing metadata, configuration and credential', t => {
const f = fixture(t), provider = new Provider(); provider.setKey('owned-before-failure');
f.store.saveConfig({ mode: 'compatible', baseUrl: 'http://127.0.0.1:12340/v1', model: 'before' });
const hub = provider.modelHub(f.store), before = structuredClone({ config: f.store.config, state: hub.state });
const persist = f.store.storage.setMeta.bind(f.store.storage);
f.store.storage.setMeta = (key, value) => { if (key === 'config') throw new Error('owned config commit failure'); return persist(key, value); };
try { assert.throws(() => hub.upsert({ ...hub.connection('legacy-default'), name: 'After', model: 'after', apiKey: 'owned-after-failure' }), /owned config commit failure/); }
finally { f.store.storage.setMeta = persist; }
assert.deepEqual(f.store.config, before.config); assert.deepEqual(hub.state, before.state);
assert.equal(provider.apiKey, 'owned-before-failure'); assert.equal(provider.legacyCredentialRevision, undefined);
assert.equal(f.store.storage.meta('config').model, 'before');
assert.equal(f.store.storage.meta('modelRegistry', null), null);
});