163 lines
15 KiB
JavaScript
163 lines
15 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import http from 'node:http';
|
|
import { fixture, compatibleFixture, completion, call, until, assertToolPairs, launchWorkbench } from './helpers.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { Runtime } from '../src/server/runtime.mjs';
|
|
import { Store } from '../src/server/store.mjs';
|
|
import { ConfigImporter } from '../src/core/models/config-import.mjs';
|
|
import { completionBody, actualRequest, outputReservation, requestMetrics } from '../src/shared/contracts/model-request.mjs';
|
|
import { modelSnapshot } from '../src/shared/contracts/execution.mjs';
|
|
import { nativeParameterSettings } from '../src/shared/contracts/native-parameters.mjs';
|
|
import { modelParameterProfile } from '../src/shared/contracts/model-parameter-profiles.mjs';
|
|
import { normalizeProtocolResponse } from '../src/core/models/protocols.mjs';
|
|
import { readModelStream } from '../src/core/models/model-stream.mjs';
|
|
import { verifyPlanEvidence } from '../src/core/context/request-plan.mjs';
|
|
|
|
const config = { mode: 'compatible', model: 'deepseek-owned', baseUrl: 'http://127.0.0.1:1/v1', protocol: 'chat-completions', maxOutputTokens: 2048 };
|
|
const sse = value => 'data: ' + (typeof value === 'string' ? value : JSON.stringify(value)) + '\n\n';
|
|
const chunk = (delta, finish_reason = null) => sse({ model: config.model, choices: [{ index: 0, delta, finish_reason }] });
|
|
|
|
test('brand and custom-compatible profiles send native reasoning controls per protocol without changing output budgets', () => {
|
|
const cases = [
|
|
{ id: 'chat', protocol: 'chat-completions', parameterProfile: 'openai', nativeParameters: { reasoning_effort: 'max' } },
|
|
{ id: 'deepseek', protocol: 'chat-completions', parameterProfile: 'deepseek', nativeParameters: { thinking: { type: 'enabled' }, reasoning_effort: 'low' } },
|
|
{ id: 'off', protocol: 'chat-completions', parameterProfile: 'deepseek', nativeParameters: { thinking: { type: 'disabled' } } },
|
|
{ id: 'responses', protocol: 'responses', parameterProfile: 'openai', nativeParameters: { reasoning: { effort: 'max' } } },
|
|
{ id: 'messages', protocol: 'anthropic-messages', parameterProfile: 'anthropic', nativeParameters: { thinking: { type: 'adaptive' }, output_config: { effort: 'xhigh' } } },
|
|
].map(value => ({ ...value, model: value.id, baseUrl: config.baseUrl }));
|
|
const plan = completionBody({ ...config, modelRouting: { members: cases } }, [{ role: 'user', content: 'owned' }], []);
|
|
for (const member of cases) {
|
|
const body = actualRequest(plan, member);
|
|
for (const [key, value] of Object.entries(member.nativeParameters)) assert.deepEqual(body[key], value);
|
|
assert.equal(body.parameterProfile, undefined); assert.equal(outputReservation(body), 2048);
|
|
assert.equal(body.model, member.model);
|
|
}
|
|
assert.equal(actualRequest(plan, cases[0]).thinking, undefined); assert.equal(actualRequest(plan, cases[4]).reasoning_effort, undefined);
|
|
const unknown = modelParameterProfile({ ...config, brand: '自定义' });
|
|
assert.equal(unknown.id, 'openai'); assert.equal(unknown.sourceKind, 'compatibility_profile'); assert.equal(unknown.officialSource, null);
|
|
const explicit = modelParameterProfile({ ...config, providerId: 'deepseek' });
|
|
assert.equal(explicit.id, 'deepseek'); assert.equal(explicit.officialSource, null, 'a provider declaration does not invent an exact model specification');
|
|
const official = modelParameterProfile({ ...config, model: 'deepseek-v4-pro' });
|
|
assert.equal(official.id, 'deepseek'); assert.equal(official.sourceKind, 'official_model_spec'); assert.equal(official.officialSource.provider, 'deepseek');
|
|
assert.equal(modelParameterProfile({ ...config, parameterProfile: 'openai' }).id, 'openai');
|
|
for (const [protocol, params, profile] of [
|
|
['chat-completions', { thinking: { type: 'adaptive' } }], ['chat-completions', { thinking: { type: 'enabled', budget_tokens: 1024 } }],
|
|
['anthropic-messages', { output_config: { effort: 'max', format: {} } }], ['anthropic-messages', { output_config: { effort: 'none' } }],
|
|
['responses', { thinking: { type: 'enabled' } }], ['chat-completions', {}, 'anthropic'], ['anthropic-messages', {}, 'openai'],
|
|
]) assert.throws(() => nativeParameterSettings(protocol, params, undefined, profile), cause => cause.status === 400);
|
|
assert.throws(() => completionBody({ ...config, protocol: 'anthropic-messages', maxOutputTokens: 1024, nativeParameters: { thinking: { type: 'enabled', budget_tokens: 1024 } } }, [], []), /小于/);
|
|
});
|
|
|
|
test('opaque Chat reasoning returns only to its original endpoint, model, connection and credential revision; bytes count against the actual request', () => {
|
|
const bound = { ...config, modelConnectionId: 'a', modelCredentialRevision: 2 };
|
|
const raw = completion([call('owned', 'list_files', {})]); raw.choices[0].message.reasoning_content = 'owned opaque state '.repeat(100);
|
|
const received = normalizeProtocolResponse(bound, raw).choices[0].message;
|
|
assert.equal(received.reasoning_content, undefined); assert.equal(raw.choices[0].message.reasoning_content.length, 1900);
|
|
const history = [received, { role: 'tool', tool_call_id: 'owned', content: '{}' }];
|
|
const same = completionBody(bound, history, []); assert.equal(same.messages[0].reasoning_content, raw.choices[0].message.reasoning_content);
|
|
for (const other of [{ baseUrl: 'https://elsewhere.test' }, { model: 'other' }, { modelConnectionId: 'b' }, { modelCredentialRevision: 3 }, { protocol: 'responses' }, { protocol: 'anthropic-messages' }]) {
|
|
const body = completionBody({ ...bound, ...other }, history, []);
|
|
assert.ok(!JSON.stringify(body).includes('owned opaque state'));
|
|
}
|
|
const stripped = completionBody({ ...bound, modelConnectionId: 'b' }, history, []);
|
|
assert.ok(requestMetrics(same).bytes > requestMetrics(stripped).bytes + 1800);
|
|
assert.ok(requestMetrics(same).estimatedInputTokens > requestMetrics(stripped).estimatedInputTokens + 500);
|
|
});
|
|
|
|
test('saved profile changes preserve credential references and old frozen Run settings, including the legacy connection after restart', t => {
|
|
const f = fixture(t), provider = new Provider(); provider.setKey('owned-legacy'); const hub = provider.modelHub(f.store);
|
|
const member = hub.upsert({ ...config, name: 'Owned profile', parameterProfile: 'deepseek', nativeParameters: { thinking: { type: 'enabled' }, reasoning_effort: 'low' }, apiKey: 'owned-profile' });
|
|
hub.select({ type: 'connection', id: member.id }); const prepared = hub.prepare(f.store.config), frozen = modelSnapshot(prepared), original = structuredClone(frozen);
|
|
const credential = provider.credentials.get(member.id), previousSession = JSON.stringify(f.session), pools = JSON.stringify(hub.state.pools);
|
|
hub.setNativeParameters({ id: member.id, revision: member.revision, parameterProfile: 'openai', nativeParameters: { reasoning_effort: 'max' } });
|
|
assert.deepEqual(frozen, original); assert.deepEqual(prepared.nativeParameters, { thinking: { type: 'enabled' }, reasoning_effort: 'low' });
|
|
assert.equal(provider.credentials.get(member.id), credential); assert.equal(JSON.stringify(f.session), previousSession); assert.equal(JSON.stringify(hub.state.pools), pools);
|
|
assert.equal(hub.prepare(f.store.config).parameterProfile, 'openai');
|
|
const legacy = hub.connection('legacy-default'); hub.setNativeParameters({ id: legacy.id, revision: legacy.revision, parameterProfile: 'deepseek', nativeParameters: { thinking: { type: 'disabled' } } });
|
|
assert.equal(provider.apiKey, 'owned-legacy'); f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
|
|
assert.equal(reopened.config.parameterProfile, 'deepseek'); assert.equal(new Provider().modelHub(reopened).connection('legacy-default').parameterProfile, 'deepseek');
|
|
assert.equal(new Provider().modelHub(reopened).connection(member.id).parameterProfile, 'openai');
|
|
});
|
|
|
|
for (const streaming of [false, true]) test('DeepSeek ' + (streaming ? 'SSE' : 'JSON') + ' reasoning survives real HTTP tool rounds and restart without entering visible assistant text', async t => {
|
|
const f = fixture(t), requests = [], rawResponses = [];
|
|
const model = http.createServer(async (req, res) => {
|
|
const parts = []; for await (const part of req) parts.push(part); const body = JSON.parse(Buffer.concat(parts)); requests.push(body);
|
|
const n = requests.length, calls = n < 3 ? [call('owned-call-' + n, 'list_files', { path: '', depth: 1 })] : [];
|
|
const opaque = 'owned opaque step ' + n, answer = n === 3 ? 'Read complete.' : '';
|
|
const result = completion(calls, answer); result.model = config.model; result.choices[0].message.reasoning_content = opaque;
|
|
res.writeHead(200, { 'Content-Type': streaming ? 'text/event-stream' : 'application/json' });
|
|
const raw = streaming ? chunk({ reasoning_content: opaque.slice(0, 7) }) + chunk({ reasoning_content: opaque.slice(7) })
|
|
+ chunk({ ...(answer ? { content: answer } : {}), ...(calls.length ? { tool_calls: calls.map((value, index) => ({ ...value, index })) } : {}) }, calls.length ? 'tool_calls' : 'stop')
|
|
+ sse({ choices: [], usage: result.usage }) + sse('[DONE]') : JSON.stringify(result);
|
|
rawResponses.push(raw); res.end(raw);
|
|
});
|
|
await new Promise(resolve => model.listen(0, '127.0.0.1', resolve));
|
|
t.after(() => new Promise(resolve => { model.closeAllConnections(); model.close(resolve); }));
|
|
const provider = new Provider(), hub = provider.modelHub(f.store), member = hub.upsert({ ...config, baseUrl: 'http://127.0.0.1:' + model.address().port + '/v1',
|
|
name: 'Owned custom proxy', brand: '自定义', parameterProfile: 'deepseek', requiresKey: false, streaming, capabilityDeclarations: { streaming: 'supported' },
|
|
nativeParameters: { thinking: { type: 'enabled' }, reasoning_effort: 'low' } });
|
|
hub.select({ type: 'connection', id: member.id }); const runtime = new Runtime(f.store, provider); t.after(() => runtime.stopAll());
|
|
runtime.start(f.session.id, 'Read the project files.'); await until(() => !runtime.isActive(f.session.id), 15000);
|
|
assert.equal(f.session.status, 'completed', JSON.stringify(f.session.failure)); assert.equal(requests.length, 3);
|
|
for (const [index, body] of requests.entries()) {
|
|
assert.deepEqual(body.thinking, { type: 'enabled' }); assert.equal(body.reasoning_effort, 'low'); assert.equal(body.max_tokens, 2048);
|
|
assert.deepEqual(body.messages.filter(m => m.role === 'assistant').map(m => m.reasoning_content), Array.from({ length: index }, (_, i) => 'owned opaque step ' + (i + 1)));
|
|
}
|
|
assertToolPairs(f.session.providerMessages); assert.equal(f.session.events.filter(e => e.tool === 'list_files' && e.phase === 'completed').length, 2);
|
|
assert.ok(!f.session.messages.some(m => String(m.content).includes('owned opaque')));
|
|
for (const plan of f.store.core.context_plan.values()) assert.doesNotThrow(() => verifyPlanEvidence(f.store, f.session, plan));
|
|
for (const attempt of hub.view().attempts) assert.ok(rawResponses.includes(f.store.artifactStore.read(f.store.owned('artifact', attempt.responseArtifactId, f.session.id))));
|
|
const original = structuredClone(f.session.providerMessages), before = modelSnapshot(hub.prepare(f.store.config));
|
|
assert.equal(before.parameterProfile, 'deepseek'); f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
|
|
assert.deepEqual(reopened.session(f.session.id).providerMessages, original);
|
|
const reopenedHub = new Provider().modelHub(reopened); assert.equal(reopenedHub.connection(member.id).parameterProfile, 'deepseek');
|
|
assert.equal(requests.length, 3);
|
|
});
|
|
|
|
test('malformed or post-terminal Chat reasoning is rejected with the raw stream retained', async () => {
|
|
for (const raw of [chunk({ reasoning_content: {} }) + chunk({ content: 'OK' }, 'stop') + sse('[DONE]'),
|
|
chunk({ content: 'OK' }, 'stop') + chunk({ reasoning_content: 'late' }) + sse('[DONE]')]) {
|
|
const progress = [];
|
|
await assert.rejects(readModelStream(new Response(raw, { headers: { 'Content-Type': 'text/event-stream' } }), config, undefined, e => progress.push(e), []));
|
|
assert.equal(progress.find(e => e.streamCapture).streamCapture.toString(), raw);
|
|
}
|
|
});
|
|
|
|
test('connection import synchronizes profile, native fields and declared abilities without editing the source or manufacturing verification', t => {
|
|
const f = fixture(t), hub = new Provider().modelHub(f.store), importer = new ConfigImporter(hub);
|
|
const filename = path.join(f.root, 'owned-models.json');
|
|
const write = effort => fs.writeFileSync(filename, JSON.stringify({ schema: 1, connections: [{ ...config, id: 'custom', name: 'Owned proxy', brand: '自定义', requiresKey: false,
|
|
parameterProfile: 'deepseek', nativeParameters: { thinking: { type: 'enabled' }, reasoning_effort: effort }, capabilityDeclarations: { streaming: 'supported', vision: 'unsupported' } }] }));
|
|
write('low'); let bytes = fs.readFileSync(filename), preview = importer.preview('workbench-json', filename);
|
|
assert.equal(preview.entries[0].parameterProfile, 'deepseek'); const imported = importer.apply(preview.id, true), member = hub.connection(imported.imported[0]);
|
|
assert.equal(hub.status(member).capabilities.streaming, 'protocol_declared'); assert.equal(hub.status(member).capabilities.vision, 'unsupported');
|
|
assert.deepEqual(fs.readFileSync(filename), bytes);
|
|
write('max'); bytes = fs.readFileSync(filename); preview = importer.preview('workbench-json', filename); importer.apply(preview.id);
|
|
assert.equal(hub.connection(member.id).nativeParameters.reasoning_effort, 'max'); assert.deepEqual(fs.readFileSync(filename), bytes);
|
|
const current = hub.connection(member.id); hub.setNativeParameters({ id: current.id, revision: current.revision, parameterProfile: 'openai', nativeParameters: { reasoning_effort: 'medium' } });
|
|
write('high'); preview = importer.preview('workbench-json', filename); const conflict = importer.apply(preview.id);
|
|
assert.deepEqual(conflict.conflicts, ['Owned proxy']); assert.equal(hub.connection(member.id).nativeParameters.reasoning_effort, 'medium');
|
|
});
|
|
|
|
test('compiled HTTP persists profile and reasoning choices for every protocol and rejects incompatible/stale edits atomically', async t => {
|
|
const f = fixture(t); f.store.close(); const host = await launchWorkbench(t, f.data);
|
|
const cases = [
|
|
['chat-completions', 'deepseek', { thinking: { type: 'enabled' }, reasoning_effort: 'low' }],
|
|
['responses', 'openai', { reasoning: { effort: 'max' } }],
|
|
['anthropic-messages', 'anthropic', { thinking: { type: 'adaptive' }, output_config: { effort: 'high' } }],
|
|
];
|
|
for (const [protocol, parameterProfile, nativeParameters] of cases) {
|
|
const member = await host.api('/model-center/connections', { name: 'Owned ' + protocol, model: 'owned-model', baseUrl: config.baseUrl, protocol, requiresKey: false });
|
|
await host.api('/model-center/native-parameters', { id: member.id, revision: member.revision, parameterProfile, nativeParameters });
|
|
const current = (await host.api('/model-center')).connections.find(c => c.id === member.id);
|
|
assert.equal(current.parameterProfile, parameterProfile); assert.deepEqual(current.nativeParameters, nativeParameters);
|
|
await assert.rejects(host.api('/model-center/native-parameters', { id: member.id, revision: member.revision, parameterProfile, nativeParameters: {} }), cause => cause.status === 409);
|
|
await assert.rejects(host.api('/model-center/native-parameters', { id: member.id, revision: current.revision, parameterProfile: 'invented', nativeParameters: {} }), cause => cause.status === 400);
|
|
assert.deepEqual((await host.api('/model-center')).connections.find(c => c.id === member.id), current);
|
|
}
|
|
});
|