82 lines
7.6 KiB
JavaScript
82 lines
7.6 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import net from 'node:net';
|
|
import { fixture, compatibleFixture, completion, until } from './helpers.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { NetworkDiagnostics } from '../src/core/models/network-diagnostics.mjs';
|
|
import { ModelTransport } from '../src/core/models/transport.mjs';
|
|
import { readModelStream } from '../src/core/models/model-stream.mjs';
|
|
|
|
const sse = value => 'data: ' + (typeof value === 'string' ? value : JSON.stringify(value)) + '\n\n';
|
|
const open = { executionMode: 'unrestricted', capacityMode: 'passthrough' };
|
|
|
|
test('open Chat SSE retains twenty complete tools while malformed indexes remain invalid', async () => {
|
|
const calls = Array.from({ length: 20 }, (_, index) => ({ index, id: 'owned-' + index, type: 'function', function: { name: 'inspect_project', arguments: '{}' } }));
|
|
const frame = tool_calls => sse({ choices: [{ index: 0, delta: { tool_calls }, finish_reason: 'tool_calls' }] }) + sse('[DONE]');
|
|
const tools = [{ type: 'function', function: { name: 'inspect_project', parameters: { type: 'object', properties: {} } } }];
|
|
const response = value => new Response(value, { headers: { 'content-type': 'text/event-stream' } });
|
|
const result = await readModelStream(response(frame(calls)), { ...open, protocol: 'chat-completions' }, undefined, undefined, tools);
|
|
assert.equal(result.value.choices[0].message.tool_calls.length, 20);
|
|
assert.deepEqual(result.value.choices[0].message.tool_calls.map(row => row.id), calls.map(row => row.id));
|
|
await assert.rejects(readModelStream(response(frame([{ ...calls[0], index: -1 }])), open, undefined, undefined, tools), /索引/);
|
|
await assert.rejects(readModelStream(response(frame(calls)), { executionMode: 'restricted' }, undefined, undefined, tools), /索引|数量/);
|
|
});
|
|
|
|
test('open Messages SSE preserves 129 ordered content blocks beyond the former 128-block ceiling', async () => {
|
|
const blocks = Array.from({ length: 129 }, (_, index) => ({ type: 'text', text: 'original-' + index + '\n' }));
|
|
const bytes = sse({ type: 'message_start', message: { type: 'message', id: 'owned-blocks', role: 'assistant', content: [], stop_reason: null, usage: { input_tokens: 3 } } })
|
|
+ blocks.map((content_block, index) => sse({ type: 'content_block_start', index, content_block }) + sse({ type: 'content_block_stop', index })).join('')
|
|
+ sse({ type: 'message_delta', delta: { stop_reason: 'end_turn' }, usage: { output_tokens: 129 } }) + sse({ type: 'message_stop' });
|
|
const response = () => new Response(bytes, { headers: { 'content-type': 'text/event-stream' } });
|
|
const result = await readModelStream(response(), { ...open, protocol: 'anthropic-messages' });
|
|
assert.deepEqual(result.value.content, blocks); assert.equal(result.evidence.bytes, Buffer.byteLength(bytes));
|
|
await assert.rejects(readModelStream(response(), { protocol: 'anthropic-messages', executionMode: 'restricted' }), /内容块/);
|
|
});
|
|
|
|
test('open catalog accepts a 4MB-plus upstream reply, long model IDs, small declared capacities and 121 automatic members without clipping', async t => {
|
|
const f = fixture(t, { modernDefaults: true }), id = 'owned-' + 'model'.repeat(55);
|
|
const entries = Array.from({ length: 121 }, (_, index) => ({ id: index ? 'owned-' + index : id,
|
|
context_length: 128, max_output_tokens: 8, lifecycle: index === 120 ? 'retired' : 'active',
|
|
capabilities: { text: true, tools: true }, supported_parameters: index ? [] : Array.from({ length: 95 }, (_, n) => 'parameter_' + n) }));
|
|
const reply = { data: entries, upstream_note: 'x'.repeat(4 * 1024 * 1024 + 1) };
|
|
const server = await compatibleFixture(t, (url, body) => url.endsWith('/models') ? reply : { ...completion([], 'Owned complete response'), model: body.model });
|
|
const provider = new Provider(), hub = provider.modelHub(f.store);
|
|
f.onCleanup(() => provider.abortRequests());
|
|
const source = hub.upsert({ name: 'Owned large catalog', model: 'source', baseUrl: server.baseUrl, requiresKey: false });
|
|
const preview = await hub.modelCatalog().fetch({ id: source.id, revision: source.revision });
|
|
assert.equal(preview.entries.length, 121); assert.equal(preview.entries[0].id, id); assert.equal(preview.entries[0].parameters.length, 95);
|
|
assert.deepEqual(preview.limits, { connections: null, poolMembers: null, catalog: null });
|
|
const result = hub.modelCatalog().apply({ previewId: preview.id, models: entries.map(row => row.id), routing: 'auto' });
|
|
assert.equal(result.added.length, 121); assert.equal(hub.state.pools[0].members.length, 121);
|
|
const connection = hub.connection(result.added[0]);
|
|
assert.equal(connection.model, id); assert.equal(connection.contextLimit, 128); assert.equal(connection.maxOutputTokens, 8);
|
|
hub.select({ type: 'connection', id: connection.id });
|
|
await provider.complete(hub.prepare(f.store.config), [{ role: 'user', content: 'Reply only.' }], null, undefined, undefined, null, []);
|
|
assert.equal(server.requests.length, 2); assert.equal(server.requests[1].input.model, id);
|
|
for (const key of ['max_tokens', 'max_output_tokens', 'max_completion_tokens']) assert.equal(Object.hasOwn(server.requests[1].input, key), false);
|
|
});
|
|
|
|
test('open network diagnostics keep all DNS addresses and history, and unlimited stalled TLS remains explicitly cancellable', async t => {
|
|
const f = fixture(t, { modernDefaults: true }), sockets = new Set();
|
|
const server = net.createServer(socket => { sockets.add(socket); socket.on('close', () => sockets.delete(socket)); socket.on('data', () => {}); });
|
|
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
|
|
f.onCleanup(async () => { for (const socket of sockets) socket.destroy(); await new Promise(resolve => server.close(resolve)); });
|
|
const provider = new Provider({ transport: new ModelTransport({ environment: {} }) }), hub = provider.modelHub(f.store);
|
|
const manager = hub.networkChecks = new NetworkDiagnostics(hub, { lookup: (_name, _options, done) => done(null, Array.from({ length: 40 }, () => ({ address: '127.0.0.1', family: 4 }))) });
|
|
f.onCleanup(() => provider.abortRequests());
|
|
const connection = hub.upsert({ name: 'Owned unlimited TCP', model: 'unused', baseUrl: 'http://owned-open.invalid:' + server.address().port + '/v1', requiresKey: false });
|
|
let started = manager.start({ id: connection.id, revision: connection.revision }); await manager.active.get(started.job.id).promise;
|
|
const first = manager.view().jobs[0]; assert.equal(first.status, 'passed'); assert.equal(first.budgetMs, 0); assert.equal(first.stageTimeoutMs, 0);
|
|
assert.equal(first.stages.dns.addresses.length, 40); assert.equal(manager.view().retained, null);
|
|
manager.jobs = Array.from({ length: 35 }, (_, index) => ({ ...first, id: 'owned-history-' + index })); manager.save();
|
|
const stalled = hub.upsert({ name: 'Owned stalled TLS', model: 'unused', baseUrl: 'https://127.0.0.1:' + server.address().port + '/v1', requiresKey: false });
|
|
started = manager.start({ id: stalled.id, revision: stalled.revision });
|
|
await until(() => manager.jobs.at(-1).trials.some(row => row.stage === 'tls'), 15000);
|
|
t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: Date.now() }); t.mock.timers.tick(120001);
|
|
assert.equal(manager.jobs.at(-1).status, 'running'); assert.equal(manager.active.get(started.job.id).controller.signal.aborted, false);
|
|
t.mock.timers.reset();
|
|
const stopped = await manager.stop(started.job.id, {}); assert.equal(stopped.job.status, 'cancelled');
|
|
assert.equal(manager.jobs.length, 36); assert.equal(manager.jobs[0].id, 'owned-history-0'); assert.equal(manager.active.size, 0);
|
|
assert.equal(hub.attempts.length, 0); assert.equal(stopped.job.httpRequests, 0); assert.equal(stopped.job.modelRequests, 0);
|
|
});
|