156 lines
14 KiB
JavaScript
156 lines
14 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createHash } from 'node:crypto';
|
|
import { fixture, compatibleFixture } from './helpers.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { Store } from '../src/server/store.mjs';
|
|
import { modelSnapshot } from '../src/shared/contracts/execution.mjs';
|
|
import { resolveModelSpecification } from '../src/shared/contracts/official-model-registry.mjs';
|
|
|
|
const providerFor = f => {
|
|
// This constructor-free fixture never reads an environment model Key.
|
|
const provider = Object.assign(Object.create(Provider.prototype), { apiKey: '' });
|
|
return { provider, hub: provider.modelHub(f.store) };
|
|
};
|
|
const draft = server => ({ name: '自有兼容目录', protocol: 'chat-completions', baseUrl: server.baseUrl, requiresKey: false });
|
|
const sha = value => createHash('sha256').update(value).digest('hex');
|
|
|
|
test('pageToken cursors, empty intermediate pages and all vendor fields survive selection with exact redacted JSON hashes', async t => {
|
|
const f = fixture(t, { modernDefaults: true });
|
|
const token = 'owned +/中文?', raw = { id: 'gpt-6.1-sol', provider: 'owned', vendor_extension: { opaque: ['keep', { nested: true }], api_key: 'owned-do-not-export' } };
|
|
const server = await compatibleFixture(t, url => url.includes('pageToken=second') ? { models: [{ id: 'gpt-6.1-terra' }] }
|
|
: url.includes('pageToken=') ? { models: [], nextPageToken: 'second' } : { models: [raw], nextPageToken: token });
|
|
const { hub } = providerFor(f), preview = await hub.modelCatalog().fetch({ draft: draft(server) });
|
|
assert.equal(server.requests.length, 3);
|
|
assert.equal(server.requests[1].url, '/v1/models?pageToken=' + encodeURIComponent(token));
|
|
assert.equal(server.requests[2].url, '/v1/models?pageToken=second');
|
|
const expected = structuredClone(raw); expected.vendor_extension.api_key = '[redacted]';
|
|
const item = preview.entries[0];
|
|
assert.deepEqual(item.rawItem, expected); assert.equal(item.rawSha256, sha(JSON.stringify(expected)));
|
|
assert.equal(item.rawBytes, Buffer.byteLength(JSON.stringify(expected))); assert.equal(item.rawRepresentation, 'parsed-redacted-item-json-v1');
|
|
const result = hub.modelCatalog().apply({ previewId: preview.id, models: preview.entries.map(value => value.id), routing: 'manual', defaultModel: 'gpt-6.1-sol' });
|
|
const connection = hub.connection(result.added[0]);
|
|
assert.equal(connection.maxOutputTokens, 128000); assert.equal(connection.contextLimit, 1050000);
|
|
assert.equal(connection.upstreamModel.rawSha256, item.rawSha256); assert.deepEqual(connection.upstreamModel.rawItem, expected);
|
|
assert.equal(hub.status(connection).capabilities.tools, 'unsupported');
|
|
assert.equal(connection.capabilityDeclarationSources.tools, 'protocol');
|
|
assert.equal(hub.attempts.length, 0);
|
|
assert.equal(JSON.stringify(hub.view()).includes('owned-do-not-export'), false);
|
|
});
|
|
|
|
test('repeated pagination tokens and unknown-field duplicate conflicts fail clearly without partial saves or retries', async t => {
|
|
const f = fixture(t, { modernDefaults: true }), { hub } = providerFor(f);
|
|
let mode = 'repeat';
|
|
const server = await compatibleFixture(t, url => mode === 'repeat' ? { data: [{ id: 'owned' }], nextPageToken: 'unchanged' }
|
|
: url.includes('pageToken=') ? { data: [{ id: 'owned', vendor_field: 'second' }] } : { data: [{ id: 'owned', vendor_field: 'first' }], nextPageToken: 'next' });
|
|
await assert.rejects(hub.modelCatalog().fetch({ draft: draft(server) }), /相同游标/);
|
|
assert.equal(server.requests.length, 2); assert.equal(hub.modelCatalog().previews.size, 0);
|
|
mode = 'conflict';
|
|
await assert.rejects(hub.modelCatalog().fetch({ draft: draft(server) }), /冲突定义/);
|
|
assert.equal(server.requests.length, 4); assert.equal(hub.state.connections.length, 0); assert.equal(hub.attempts.length, 0);
|
|
});
|
|
|
|
test('refresh changes only current upstream facts, while prepared specification, native settings, original metadata and credential objects remain', async t => {
|
|
const f = fixture(t, { modernDefaults: true }); let output = 96000;
|
|
const server = await compatibleFixture(t, () => ({ data: [{ id: 'claude-opus-5-5', max_output_tokens: output, capabilities: { text: true, tools: true } }] }));
|
|
const { provider, hub } = providerFor(f);
|
|
const source = hub.upsert({ ...draft(server), model: 'claude-opus-5-5', protocol: 'anthropic-messages', requiresKey: true,
|
|
apiKey: 'owned-registry-refresh-only', persistKey: true, nativeParameters: { thinking: { type: 'adaptive', display: 'summarized' }, output_config: { effort: 'max' } }, parameterProfile: 'auto' });
|
|
let preview = await hub.modelCatalog().fetch({ id: source.id, revision: source.revision });
|
|
hub.modelCatalog().apply({ previewId: preview.id, models: [source.model], routing: 'manual', defaultModel: source.model });
|
|
const connection = hub.connection(source.id), credential = provider.credentials.get(source.id), block = structuredClone(hub.vault().state);
|
|
const prepared = hub.prepare(f.store.config), snapshot = modelSnapshot(prepared), original = structuredClone(snapshot);
|
|
assert.equal(snapshot.routing.members[0].modelSpecificationFrozen, true);
|
|
assert.equal(snapshot.modelSpecification.fields.maxOutputTokens.value, 96000);
|
|
assert.equal(snapshot.modelSpecification.fields.maxOutputTokens.conflict, true);
|
|
output = 64000; preview = await hub.modelCatalog().fetch({ id: source.id, revision: connection.revision });
|
|
hub.modelCatalog().apply({ previewId: preview.id, models: [source.model], routing: 'keep' });
|
|
assert.equal(connection.upstreamModel.maxOutputTokens, 64000); assert.deepEqual(snapshot, original);
|
|
assert.equal(resolveModelSpecification(prepared.modelRouting.members[0]).fields.maxOutputTokens.value, 96000);
|
|
assert.equal(hub.prepare(f.store.config).modelSpecification.fields.maxOutputTokens.value, 64000);
|
|
assert.equal(provider.credentials.get(source.id), credential); assert.deepEqual(hub.vault().state, block);
|
|
assert.deepEqual(connection.nativeParameters, source.nativeParameters); assert.equal(connection.revision, source.revision);
|
|
});
|
|
|
|
test('native and explicit model-override edits persist through restart without re-encrypting the existing synthetic credential', t => {
|
|
const f = fixture(t, { modernDefaults: true }), { provider, hub } = providerFor(f);
|
|
const source = hub.upsert({ name: '自有存储恢复', model: 'claude-opus-5-5', protocol: 'anthropic-messages', baseUrl: 'http://127.0.0.1:1',
|
|
apiKey: 'owned-registry-persistence-only', persistKey: true, nativeParameters: { thinking: { type: 'adaptive' } }, parameterProfile: 'auto' });
|
|
const credential = provider.credentials.get(source.id), cipher = structuredClone(hub.vault().state);
|
|
hub.vault().protect = () => { throw Error('Existing Key must never be re-encrypted by a parameter edit'); };
|
|
const overrides = { maxOutputTokens: 96000, efforts: ['low', 'custom'], modes: ['adaptive'], note: 'owned proxy declaration' };
|
|
const native = { thinking: { type: 'adaptive', display: 'summarized' }, output_config: { effort: 'custom', vendor_field: { preserved: true } } };
|
|
hub.setNativeParameters({ id: source.id, revision: source.revision, nativeParameters: native, parameterProfile: 'auto', modelOverrides: overrides });
|
|
const edited = hub.connection(source.id);
|
|
assert.equal(edited.credentialBindingRevision, source.credentialBindingRevision); assert.ok(edited.revision > source.revision);
|
|
assert.equal(provider.credentials.get(source.id), credential); assert.deepEqual(hub.vault().state, cipher); assert.equal(hub.vault().status(edited).status, 'saved');
|
|
assert.deepEqual(edited.nativeParameters, native); assert.deepEqual(edited.modelOverrides, overrides);
|
|
f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
|
|
const freshProvider = Object.assign(Object.create(Provider.prototype), { apiKey: '' }), freshHub = freshProvider.modelHub(reopened), restored = freshHub.connection(source.id);
|
|
assert.deepEqual(restored.modelOverrides, overrides); assert.deepEqual(restored.nativeParameters, native);
|
|
assert.equal(freshHub.credential(restored).key, 'owned-registry-persistence-only'); assert.equal(freshHub.vault().status(restored).status, 'saved');
|
|
assert.deepEqual(freshHub.vault().state, cipher);
|
|
});
|
|
|
|
test('credential endpoint, model, auth and new-Key changes still invalidate the original encrypted binding even if reverted', t => {
|
|
const f = fixture(t, { modernDefaults: true }), { hub } = providerFor(f);
|
|
const source = hub.upsert({ name: 'owned identity', model: 'owned', protocol: 'anthropic-messages', baseUrl: 'http://127.0.0.1:1', apiKey: 'owned-binding', persistKey: true });
|
|
const cipher = structuredClone(hub.vault().state);
|
|
for (const update of [{ baseUrl: 'http://127.0.0.1:2' }, { model: 'other' }, { messagesAuth: 'bearer' }, { apiKey: 'owned-volatile-replacement' }]) {
|
|
let connection = hub.connection(source.id);
|
|
connection = hub.upsert({ ...connection, ...update });
|
|
assert.equal(hub.vault().status(connection).status, 'source_changed');
|
|
connection = hub.upsert({ ...connection, baseUrl: source.baseUrl, model: source.model, messagesAuth: 'api-key' });
|
|
assert.equal(hub.vault().status(connection).status, 'source_changed');
|
|
assert.deepEqual(hub.vault().state, cipher);
|
|
}
|
|
});
|
|
|
|
test('invalid override or transaction failure leaves every prior parameter, credential and registry row exact', t => {
|
|
const f = fixture(t, { modernDefaults: true }), { provider, hub } = providerFor(f);
|
|
const source = hub.upsert({ name: 'owned atomic', model: 'owned', baseUrl: 'http://127.0.0.1:1/v1', apiKey: 'owned-atomic-only', persistKey: true });
|
|
const state = structuredClone(hub.state), native = { id: source.id, revision: source.revision, nativeParameters: { reasoning_effort: 'max' } };
|
|
const credential = provider.credentials.get(source.id), cipher = structuredClone(hub.vault().state), rows = f.store.storage.database.prepare('SELECT * FROM metadata ORDER BY key').all();
|
|
assert.throws(() => hub.setNativeParameters({ ...native, modelOverrides: { capabilities: { tools: 'verified' } } }), { status: 400 });
|
|
f.store.storage.faultInjector = point => { if (point === 'before_commit') throw Error('owned registry commit failure'); };
|
|
assert.throws(() => hub.setNativeParameters({ ...native, modelOverrides: { maxOutputTokens: 96000 } }), /owned registry commit failure/);
|
|
f.store.storage.faultInjector = null;
|
|
assert.deepEqual(hub.state, state); assert.equal(provider.credentials.get(source.id), credential); assert.deepEqual(hub.vault().state, cipher);
|
|
assert.deepEqual(f.store.storage.database.prepare('SELECT * FROM metadata ORDER BY key').all(), rows);
|
|
});
|
|
|
|
test('editing a catalog-sourced capability marks the new value as a user declaration despite inherited source labels', t => {
|
|
const f = fixture(t, { modernDefaults: true }), { hub } = providerFor(f);
|
|
const original = hub.upsert({ name: 'owned declaration', model: 'gpt-6.1-sol', protocol: 'responses', baseUrl: 'http://127.0.0.1:1/v1', requiresKey: false,
|
|
capabilityDeclarations: { tools: 'supported' }, capabilityDeclarationSources: { tools: 'upstream_catalog' } });
|
|
hub.connection(original.id).upstreamModel = { id: original.model, capabilityDeclarations: { tools: 'supported' } };
|
|
const changed = hub.upsert({ ...hub.connection(original.id), capabilityDeclarations: { ...original.capabilityDeclarations, tools: 'unsupported' } });
|
|
assert.equal(changed.capabilityDeclarationSources.tools, 'user'); assert.equal(changed.capabilities.tools, 'unsupported');
|
|
assert.equal(changed.modelSpecification.fields['capabilities.tools'].kind, 'connection_declaration');
|
|
});
|
|
|
|
test('actual owned HTTP sends exact native parameters and optional DeepSeek output omission; original upstream errors are retained once', async t => {
|
|
const f = fixture(t, { modernDefaults: true }), inputs = []; let failed = false;
|
|
const server = await compatibleFixture(t, (url, body) => {
|
|
inputs.push(body);
|
|
if (failed) return { status: 400, body: { error: { type: 'owned_parameter_error', message: 'owned unchanged upstream body' } } };
|
|
return { body: { id: 'owned-message', type: 'message', role: 'assistant', model: body.model, content: [{ type: 'text', text: 'owned answer' }], stop_reason: 'end_turn', usage: { input_tokens: 7, output_tokens: 3 } } };
|
|
});
|
|
const { provider, hub } = providerFor(f);
|
|
const source = hub.upsert({ name: 'owned DeepSeek HTTP', model: 'deepseek-flash', baseUrl: server.baseUrl, protocol: 'anthropic-messages', requiresKey: false,
|
|
nativeParameters: { thinking: { type: 'adaptive' }, output_config: { effort: 'max', vendor_field: { keep: true } } }, modelOverrides: { maxOutputTokens: 9000, note: 'owned display reference only' } });
|
|
hub.select({ type: 'connection', id: source.id });
|
|
const config = hub.prepare(f.store.config), original = structuredClone(config), input = [{ role: 'user', content: 'ORIGINAL ' + 'retain '.repeat(18000) + ' END' }];
|
|
await provider.complete(config, input, null, undefined, undefined, null, []);
|
|
assert.equal(inputs.length, 1); assert.equal(Object.hasOwn(inputs[0], 'max_tokens'), false);
|
|
assert.equal(inputs[0].messages[0].content[0].text, input[0].content); assert.deepEqual(inputs[0].output_config, source.nativeParameters.output_config);
|
|
assert.equal(Object.hasOwn(inputs[0], 'modelOverrides'), false); assert.equal(Object.hasOwn(inputs[0], 'modelSpecification'), false);
|
|
failed = true;
|
|
await assert.rejects(provider.complete(config, input, null, undefined, undefined, null, []), cause => {
|
|
assert.equal(cause.diagnostic.httpStatus, 400); assert.equal(cause.diagnostic.origin, 'upstream'); assert.equal(cause.diagnostic.retryDecision, 'passthrough');
|
|
assert.match(cause.diagnostic.upstream.rawPreview, /owned unchanged upstream body/); return true;
|
|
});
|
|
assert.equal(inputs.length, 2); assert.deepEqual(config, original); assert.equal(hub.attempts.length, 2);
|
|
t.after(() => provider.abortRequests());
|
|
});
|