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