import test from 'node:test'; import assert from 'node:assert/strict'; import { fixture, compatibleFixture, launchWorkbench } from './helpers.mjs'; import { Provider } from '../src/server/provider.mjs'; import { Store } from '../src/server/store.mjs'; import { catalogModel } from '../src/shared/contracts/model-catalog.mjs'; import { completionBody, requestVariants } from '../src/shared/contracts/model-request.mjs'; import { modelSnapshot } from '../src/shared/contracts/execution.mjs'; test('catalog accepts published camel-case capacity without inventing missing maxima', () => { const model = catalogModel({ name: 'owned-model', displayName: 'Owned model', inputTokenLimit: 200000, outputTokenLimit: 128000 }); assert.equal(model.name, 'Owned model'); assert.equal(model.contextLimit, 200000); assert.equal(model.maxOutputTokens, 128000); const missing = catalogModel({ id: 'no-capacity', outputTokenLimit: 0 }); assert.equal(missing.contextLimit, null); assert.equal(missing.maxOutputTokens, null); }); test('refresh updates only selected upstream declarations and future Messages wire, preserving saved credentials and frozen requests', async t => { const f = fixture(t, { modernDefaults: true }); let maximum = 64000; const upstream = await compatibleFixture(t, () => ({ data: ['source', 'child', 'untouched'].map(id => ({ id, max_input_tokens: 200000, max_tokens: maximum, capabilities: { tools: true, thinking: { supported: true }, effort: { high: { supported: true } } } })) })); const provider = new Provider(), hub = provider.modelHub(f.store); const source = hub.upsert({ name: 'Owned source', model: 'source', protocol: 'anthropic-messages', baseUrl: upstream.baseUrl, requiresKey: true, apiKey: 'owned-refresh-key', persistKey: true, maxOutputTokens: 2048 }); const keyObject = provider.credentials.get(source.id), encrypted = structuredClone(f.store.storage.meta('modelCredentials')); const first = await hub.modelCatalog().fetch({ id: source.id, revision: source.revision }); const result = hub.modelCatalog().apply({ previewId: first.id, models: ['source', 'child', 'untouched'] }); assert.deepEqual(result.existing, [source.id]); assert.equal(hub.connection(source.id).upstreamModel.maxOutputTokens, 64000); assert.equal(hub.connection(source.id).revision, source.revision, 'directory facts do not change a credential-bound connection revision'); const child = hub.connection(result.added[0]); hub.setNativeParameters({ id: child.id, revision: child.revision, nativeParameters: { max_tokens: 123456 } }); hub.upsert({ ...hub.connection(child.id), name: 'My chosen name', capabilityDeclarations: { tools: 'unsupported' }, enabled: false }); hub.select({ type: 'connection', id: source.id }); const frozen = hub.prepare(f.store.config), snapshot = modelSnapshot(frozen); const frozenBody = completionBody(frozen, [{ role: 'user', content: 'Owned original request' }], []); const previous = structuredClone(hub.state), childBefore = structuredClone(hub.connection(child.id)); maximum = 256000; const preview = await hub.catalog.fetch({ id: source.id, revision: source.revision }); const refresh = hub.catalog.apply({ previewId: preview.id, models: ['child', 'source'] }); assert.deepEqual(refresh.added, []); assert.deepEqual(refresh.existing, [child.id, source.id]); assert.deepEqual(hub.connection(child.id), { ...childBefore, upstreamModel: { ...preview.entries.find(model => model.id === 'child'), fetchedAt: preview.fetchedAt, endpoint: upstream.baseUrl } }); assert.deepEqual(hub.connection(result.added[1]), previous.connections.find(model => model.id === result.added[1])); assert.equal(provider.credentials.get(source.id), keyObject); assert.equal(hub.credential(hub.connection(source.id)), keyObject); assert.deepEqual(f.store.storage.meta('modelCredentials'), encrypted); assert.equal(hub.vault().status(hub.connection(source.id)).status, 'saved'); assert.equal(hub.connection(source.id).maxOutputTokens, 2048, 'the user declaration remains editable metadata'); assert.deepEqual(modelSnapshot(frozen), snapshot); assert.equal(requestVariants(frozenBody)[0].max_tokens, 64000); assert.equal(requestVariants(completionBody(hub.prepare(f.store.config), [{ role: 'user', content: 'Next request' }], []))[0].max_tokens, 256000); hub.toggle(child.id, true); hub.select({ type: 'connection', id: child.id }); assert.equal(requestVariants(completionBody(hub.prepare(f.store.config), [{ role: 'user', content: 'Explicit output' }], []))[0].max_tokens, 123456); f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close()); const restored = new Provider().modelHub(reopened); assert.equal(restored.connection(source.id).upstreamModel.maxOutputTokens, 256000); assert.equal(restored.status(restored.connection(source.id)).hasKey, true); assert.equal(upstream.requests.length, 2, 'only directory requests were made'); }); test('failed catalog refresh transaction leaves existing metadata, credentials and usable preview intact', async t => { const f = fixture(t, { modernDefaults: true }); const upstream = await compatibleFixture(t, () => ({ data: [{ id: 'owned', max_tokens: 128000 }] })); const provider = new Provider(), hub = provider.modelHub(f.store); const source = hub.upsert({ name: 'Owned', model: 'owned', baseUrl: upstream.baseUrl, apiKey: 'owned-rollback' }); const preview = await hub.modelCatalog().fetch({ id: source.id, revision: source.revision }); const registry = structuredClone(hub.state), key = provider.credentials.get(source.id); const setMeta = f.store.storage.setMeta.bind(f.store.storage); f.store.storage.setMeta = (name, value) => { if (name === 'modelRegistry') throw new Error('owned refresh transaction failed'); return setMeta(name, value); }; try { assert.throws(() => hub.catalog.apply({ previewId: preview.id, models: ['owned'] }), /owned refresh transaction failed/); } finally { f.store.storage.setMeta = setMeta; } assert.deepEqual(hub.state, registry); assert.equal(provider.credentials.get(source.id), key); assert.equal(hub.catalog.previews.has(preview.id), true); hub.catalog.apply({ previewId: preview.id, models: ['owned'] }); assert.equal(hub.connection(source.id).upstreamModel.maxOutputTokens, 128000); }); test('compiled HTTP catalog refresh returns new upstream facts while preserving connection revision and user parameters', async t => { const f = fixture(t, { modernDefaults: true }); f.store.close(); let maximum = 64000; const upstream = await compatibleFixture(t, () => ({ data: [{ id: 'owned-http', max_input_tokens: 200000, max_tokens: maximum }] })); const host = await launchWorkbench(t, f.data); const first = await host.api('/model-center/catalog', { draft: { name: 'Owned HTTP', baseUrl: upstream.baseUrl, protocol: 'anthropic-messages', requiresKey: false } }); const added = await host.api('/model-center/catalog/apply', { previewId: first.id, models: ['owned-http'] }); const before = added.center.connections.find(connection => connection.id === added.added[0]); maximum = 256000; const preview = await host.api('/model-center/catalog', { id: before.id, revision: before.revision }); const result = await host.api('/model-center/catalog/apply', { previewId: preview.id, models: ['owned-http'] }); const after = result.center.connections.find(connection => connection.id === before.id); assert.deepEqual(result.added, []); assert.deepEqual(result.existing, [before.id]); assert.equal(after.upstreamModel.maxOutputTokens, 256000); assert.equal(after.revision, before.revision); assert.equal(after.maxOutputTokens, before.maxOutputTokens); assert.deepEqual(after.nativeParameters, before.nativeParameters); assert.equal(upstream.requests.length, 2); assert.equal(result.center.attempts.length, 0); });