forked from Blendman974/faceclaw
Add OpenAI-compatible assistant provider
This commit is contained in:
1 parent
a5eda29368
commit
77e8a86196
19 files changed
+807
-23
No files matched your search
@@ -0,0 +1,275 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const { loader } = require('./helpers/load-typescript.cjs');
|
||||
const flush = () => new Promise(resolve => setImmediate(resolve));
|
||||
|
||||
function assistant({ apiKey = 'fixture-key', baseUrl = 'https://provider.example/api/v1' } = {}) {
|
||||
const requests = [], calls = [], deltas = [], errors = [], done = [];
|
||||
const registry = {
|
||||
listTools: () => [
|
||||
{ name: 'timer.set', description: 'Set a timer', inputSchema: { type: 'object', properties: { seconds: { type: 'number' } } } },
|
||||
{ name: 'glasses.show_alert', description: 'Show an alert', inputSchema: { type: 'object', properties: { text: { type: 'string' } } } },
|
||||
],
|
||||
callTool: async (name, args) => {
|
||||
calls.push({ name, args });
|
||||
return { ok: true, content: `${name} completed` };
|
||||
},
|
||||
};
|
||||
const load = loader({ global: { isIOS: false, isAndroid: true }, setTimeout, clearTimeout }, {
|
||||
'./sse': { openSseRequest: (url, body, headers, listener) => {
|
||||
const request = { url, body: JSON.parse(body), headers, listener, cancelled: false };
|
||||
requests.push(request);
|
||||
return { cancel: () => { request.cancelled = true; } };
|
||||
} },
|
||||
'../native/llama': { streamLocalQwen: () => assert.fail('unexpected local model'), isLocalModelReady: () => false, LOCAL_MODEL: { id: 'qwen', label: 'Qwen' } },
|
||||
'./bridge-client': { assistantBridge: {} },
|
||||
'./tool-registry': { toolRegistry: registry },
|
||||
'../prompts': {
|
||||
ASSISTANT_SYSTEM_PROMPT_BASE: 'test',
|
||||
buildAssistantSystemPrompt: () => 'glasses system',
|
||||
describeAssistantContext: () => '',
|
||||
},
|
||||
});
|
||||
const { AssistantSession } = load('app/assistant/session.ts');
|
||||
const session = new AssistantSession({ kind: 'direct', llm: {
|
||||
selection: 'openai-compatible', provider: 'openai-compatible', model: 'fixture-model', apiKey, baseUrl,
|
||||
} }, registry);
|
||||
const send = text => session.sendUtterance(text, {}, {
|
||||
onTextDelta: (_delta, full) => deltas.push(full),
|
||||
onToolActivity() {},
|
||||
onError: error => errors.push(error),
|
||||
onTurnDone: result => done.push(result),
|
||||
});
|
||||
const event = (request, value) => request.listener.onLine('data: ' + JSON.stringify(value));
|
||||
const chunk = (request, delta, finishReason = null) => event(request, { choices: [{ index: 0, delta, finish_reason: finishReason }] });
|
||||
const finish = (request, reason = 'stop', close = 'done') => {
|
||||
chunk(request, {}, reason);
|
||||
if (close === 'done') request.listener.onLine('data: [DONE]');
|
||||
else request.listener.onComplete();
|
||||
};
|
||||
return { load, session, send, event, chunk, finish, requests, calls, deltas, errors, done };
|
||||
}
|
||||
|
||||
test('compatible provider sends full history, nested tools, the exact API root and optional auth', () => {
|
||||
const h = assistant();
|
||||
h.send('Remember the blue door');
|
||||
const first = h.requests[0];
|
||||
assert.equal(first.url, 'https://provider.example/api/v1/chat/completions');
|
||||
assert.equal(first.headers.Authorization, 'Bearer fixture-key');
|
||||
assert.equal(first.headers['Content-Type'], 'application/json');
|
||||
assert.equal(first.body.model, 'fixture-model');
|
||||
assert.equal(first.body.stream, true);
|
||||
assert.equal('max_tokens' in first.body, false, 'provider default output limit is preserved');
|
||||
assert.equal('reasoning_effort' in first.body, false, 'custom models default to provider reasoning');
|
||||
assert.deepEqual(first.body.messages.map(m => [m.role, m.content]), [
|
||||
['system', 'glasses system'], ['user', 'Remember the blue door'],
|
||||
]);
|
||||
assert.equal(first.body.tools[0].type, 'function');
|
||||
assert.equal(first.body.tools[0].function.name, 'timer_set');
|
||||
assert.equal(first.body.tools[0].function.parameters.type, 'object');
|
||||
h.chunk(first, { content: 'Remembered.' }); h.finish(first);
|
||||
h.send('What color?');
|
||||
assert.deepEqual(h.requests[1].body.messages.slice(-3).map(m => [m.role, m.content]), [
|
||||
['user', 'Remember the blue door'], ['assistant', 'Remembered.'], ['user', 'What color?'],
|
||||
]);
|
||||
h.session.cancel();
|
||||
|
||||
const noKey = assistant({ apiKey: '' });
|
||||
noKey.send('Private request');
|
||||
assert.equal('Authorization' in noKey.requests[0].headers, false);
|
||||
noKey.session.cancel();
|
||||
});
|
||||
|
||||
test('Venice and Open WebUI roots are preserved; only a complete endpoint suffix is removed', () => {
|
||||
const { normalizeOpenAiCompatibleUrl } = assistant().load('app/native/openai-chat.ts');
|
||||
assert.equal(normalizeOpenAiCompatibleUrl(' https://api.venice.ai/api/v1/ '), 'https://api.venice.ai/api/v1');
|
||||
assert.equal(normalizeOpenAiCompatibleUrl('https://api.venice.ai/api/v1/chat/completions'), 'https://api.venice.ai/api/v1');
|
||||
assert.equal(normalizeOpenAiCompatibleUrl('http://100.64.0.1:3000/api'), 'http://100.64.0.1:3000/api');
|
||||
assert.equal(normalizeOpenAiCompatibleUrl('https://openwebui.example/api/chat/completions/'), 'https://openwebui.example/api');
|
||||
assert.equal(normalizeOpenAiCompatibleUrl('https://provider.example/custom/root'), 'https://provider.example/custom/root');
|
||||
assert.equal(normalizeOpenAiCompatibleUrl('provider.example/v1'), '');
|
||||
assert.equal(normalizeOpenAiCompatibleUrl('https://provider.example/v1?key=secret'), '');
|
||||
assert.equal(normalizeOpenAiCompatibleUrl('https://provider.example/v1#fragment'), '');
|
||||
assert.equal(normalizeOpenAiCompatibleUrl('https://user:secret@provider.example/v1'), '', 'credentials never belong in saved URLs');
|
||||
});
|
||||
|
||||
test('compatible model resolves only with URL and model, and Auto remains unchanged', () => {
|
||||
const { ASSISTANT_MODEL_CHOICES, resolveAssistantModel } = assistant().load('app/assistant/models.ts');
|
||||
assert.equal(ASSISTANT_MODEL_CHOICES.includes('openai-compatible'), true);
|
||||
assert.equal(resolveAssistantModel('openai-compatible', { anthropic: '', openai: '' }), null);
|
||||
assert.equal(resolveAssistantModel('openai-compatible', {
|
||||
anthropic: '', openai: '', openAiCompatibleUrl: 'https://provider.example/api/v1', openAiCompatibleModel: '',
|
||||
}), null);
|
||||
const resolved = resolveAssistantModel('openai-compatible', {
|
||||
anthropic: '', openai: '',
|
||||
openAiCompatibleUrl: ' https://provider.example/api/v1 ',
|
||||
openAiCompatibleKey: ' secret ', openAiCompatibleModel: ' model-id ',
|
||||
});
|
||||
assert.equal(resolved.provider, 'openai-compatible');
|
||||
assert.equal(resolved.model, 'model-id');
|
||||
assert.equal(resolved.apiKey, 'secret');
|
||||
assert.equal(resolved.baseUrl, 'https://provider.example/api/v1');
|
||||
assert.equal(resolved.effort, undefined);
|
||||
assert.equal(resolveAssistantModel('auto', {
|
||||
anthropic: '', openai: '', openAiCompatibleUrl: 'https://provider.example/api/v1', openAiCompatibleModel: 'model-id',
|
||||
}), null, 'Auto never selects a custom provider');
|
||||
});
|
||||
|
||||
test('streamed tool calls execute through Faceclaw, results continue the turn, and history survives follow-up', async () => {
|
||||
const h = assistant();
|
||||
h.send('Set a one-minute timer');
|
||||
const first = h.requests[0];
|
||||
h.chunk(first, { content: 'Setting it now.' });
|
||||
h.chunk(first, {
|
||||
reasoning_content: 'hidden reasoning',
|
||||
reasoning_details: [{ type: 'reasoning.encrypted', data: 'opaque-fixture' }],
|
||||
tool_calls: [{ index: 0, id: 'call-1', type: 'function', function: { name: 'timer_set', arguments: '{"seconds":' } }],
|
||||
});
|
||||
h.chunk(first, { tool_calls: [{ index: 0, function: { arguments: '60}' } }] });
|
||||
h.finish(first, 'tool_calls');
|
||||
await flush();
|
||||
assert.equal(h.calls.length, 1);
|
||||
assert.equal(h.calls[0].name, 'timer.set');
|
||||
assert.equal(h.calls[0].args.seconds, 60);
|
||||
assert.equal(h.requests.length, 2);
|
||||
const second = h.requests[1];
|
||||
const assistantMessage = second.body.messages.find(m => m.role === 'assistant' && m.tool_calls);
|
||||
assert.equal(assistantMessage.content, 'Setting it now.');
|
||||
assert.equal(assistantMessage.tool_calls[0].id, 'call-1');
|
||||
assert.equal(assistantMessage.tool_calls[0].function.name, 'timer_set');
|
||||
assert.equal(assistantMessage.tool_calls[0].function.arguments, '{"seconds":60}');
|
||||
assert.equal(assistantMessage.reasoning_details[0].data, 'opaque-fixture');
|
||||
const toolMessage = second.body.messages.find(m => m.role === 'tool');
|
||||
assert.equal(toolMessage.tool_call_id, 'call-1');
|
||||
assert.equal(toolMessage.content, 'timer.set completed');
|
||||
assert.equal(JSON.stringify(second.body).includes('hidden reasoning'), false);
|
||||
h.chunk(second, { content: 'Your timer is running.' });
|
||||
h.finish(second, 'stop', 'close');
|
||||
assert.equal(h.session.isTurnActive(), false);
|
||||
assert.equal(h.done.length, 1);
|
||||
assert.deepEqual(h.errors, []);
|
||||
assert.equal(h.deltas.includes('hidden reasoning'), false);
|
||||
h.send('What did you set?');
|
||||
assert.match(JSON.stringify(h.requests[2].body), /Your timer is running/);
|
||||
h.session.cancel();
|
||||
assert.equal(h.requests[2].cancelled, true);
|
||||
});
|
||||
|
||||
test('changing the API endpoint preserves visible history but drops provider-specific state', () => {
|
||||
const h = assistant();
|
||||
const original = h.session.config;
|
||||
const config = (baseUrl) => ({ kind: 'direct', llm: {
|
||||
selection: 'openai-compatible', provider: 'openai-compatible', model: 'fixture-model', apiKey: 'fixture-key', baseUrl,
|
||||
} });
|
||||
h.session.sendUtterance('Remember the blue door', {}, {
|
||||
onTextDelta() {}, onToolActivity() {}, onError: error => assert.fail(error), onTurnDone() {},
|
||||
});
|
||||
const first = h.requests[0];
|
||||
h.chunk(first, { reasoning_details: [{ type: 'opaque', data: 'server-one-only' }], content: 'Remembered.' });
|
||||
h.finish(first);
|
||||
const history = JSON.parse(JSON.stringify(h.session.history()));
|
||||
assert.equal(JSON.stringify(history).includes('server-one-only'), true);
|
||||
h.session.configure(config('https://provider-two.example/api/v1'));
|
||||
h.send('What color?');
|
||||
const second = h.requests[1];
|
||||
assert.equal(second.url, 'https://provider-two.example/api/v1/chat/completions');
|
||||
assert.equal(JSON.stringify(second.body).includes('server-one-only'), false);
|
||||
assert.equal(JSON.stringify(second.body).includes('Remember the blue door'), true);
|
||||
h.session.cancel();
|
||||
const restored = new h.session.constructor(config('https://provider-two.example/api/v1'), undefined, history);
|
||||
restored.sendUtterance('What color?', {}, {
|
||||
onTextDelta() {}, onToolActivity() {}, onError: error => assert.fail(error), onTurnDone() {},
|
||||
});
|
||||
assert.equal(JSON.stringify(h.requests.at(-1).body).includes('server-one-only'), false);
|
||||
restored.cancel();
|
||||
});
|
||||
|
||||
test('multiple interleaved tool calls are reassembled independently and all results are returned', async () => {
|
||||
const h = assistant();
|
||||
h.send('Set a timer and show an alert');
|
||||
const first = h.requests[0];
|
||||
h.chunk(first, { tool_calls: [
|
||||
{ index: 0, id: 'timer-id', function: { name: 'timer_set', arguments: '{"sec' } },
|
||||
{ index: 1, id: 'alert-id', function: { name: 'glasses_show_alert', arguments: '{"text":' } },
|
||||
] });
|
||||
h.chunk(first, { tool_calls: [
|
||||
{ index: 0, function: { arguments: 'onds":30}' } },
|
||||
{ index: 1, function: { arguments: '"Done"}' } },
|
||||
] });
|
||||
h.finish(first, 'tool_calls');
|
||||
await flush();
|
||||
// Values produced inside the VM have a different Object prototype.
|
||||
assert.equal(JSON.stringify(h.calls.map(c => [c.name, c.args])), JSON.stringify([
|
||||
['timer.set', { seconds: 30 }], ['glasses.show_alert', { text: 'Done' }],
|
||||
]));
|
||||
const second = h.requests[1];
|
||||
const tools = second.body.messages.filter(m => m.role === 'tool');
|
||||
assert.equal(JSON.stringify(tools.map(m => [m.tool_call_id, m.content])), JSON.stringify([
|
||||
['timer-id', 'timer.set completed'], ['alert-id', 'glasses.show_alert completed'],
|
||||
]));
|
||||
h.chunk(second, { content: 'Both actions completed.' });
|
||||
h.finish(second);
|
||||
assert.equal(h.session.isTurnActive(), false);
|
||||
assert.deepEqual(h.errors, []);
|
||||
});
|
||||
|
||||
test('content-only streams work with [DONE], while empty and in-band error streams fail clearly', () => {
|
||||
const h = assistant();
|
||||
h.send('Hello');
|
||||
h.chunk(h.requests[0], { role: 'assistant' });
|
||||
h.chunk(h.requests[0], { reasoning_content: 'not for the lenses' });
|
||||
h.chunk(h.requests[0], { content: 'Hello ' });
|
||||
h.chunk(h.requests[0], { content: 'there' });
|
||||
h.requests[0].listener.onLine('data: [DONE]');
|
||||
assert.equal(h.done[0].stopReason, 'end_turn');
|
||||
assert.equal(h.session.transcript.at(-1).text, 'Hello there');
|
||||
|
||||
h.send('Empty'); h.finish(h.requests[1]);
|
||||
assert.match(h.errors.at(-1), /without a reply/);
|
||||
h.send('Failure');
|
||||
h.event(h.requests[2], { error: { message: 'model overloaded' } });
|
||||
assert.match(h.errors.at(-1), /model overloaded/);
|
||||
});
|
||||
|
||||
test('HTTP errors, malformed tool JSON and premature EOF never execute incomplete tools', async () => {
|
||||
const h = assistant();
|
||||
h.send('Unauthorized');
|
||||
h.requests[0].listener.onHttpError(401, '{"error":{"message":"bad key"}}');
|
||||
assert.match(h.errors.at(-1), /invalid API key/);
|
||||
assert.equal(h.session.isTurnActive(), false);
|
||||
|
||||
h.send('Malformed');
|
||||
h.chunk(h.requests[1], { tool_calls: [{ index: 0, id: 'bad', function: { name: 'timer_set', arguments: '{broken' } }] });
|
||||
h.finish(h.requests[1], 'tool_calls');
|
||||
await flush();
|
||||
assert.match(h.errors.at(-1), /malformed tool arguments/);
|
||||
assert.equal(h.calls.length, 0);
|
||||
|
||||
h.send('Truncated');
|
||||
h.chunk(h.requests[2], { tool_calls: [{ index: 0, id: 'partial', function: { name: 'timer_set', arguments: '{"seconds":60}' } }] });
|
||||
h.requests[2].listener.onComplete();
|
||||
await flush();
|
||||
assert.match(h.errors.at(-1), /before the response completed/);
|
||||
assert.equal(h.calls.length, 0);
|
||||
|
||||
h.send('Length limited');
|
||||
h.chunk(h.requests[3], { tool_calls: [{ index: 0, id: 'partial', function: { name: 'timer_set', arguments: '{"seconds":60}' } }] });
|
||||
h.finish(h.requests[3], 'length');
|
||||
await flush();
|
||||
assert.match(h.errors.at(-1), /before its tool calls completed/);
|
||||
assert.equal(h.calls.length, 0);
|
||||
});
|
||||
|
||||
test('cancellation suppresses late deltas and tool side effects', async () => {
|
||||
const h = assistant();
|
||||
h.send('Cancel this');
|
||||
const request = h.requests[0];
|
||||
h.session.cancel();
|
||||
h.chunk(request, { content: 'late text', tool_calls: [{ index: 0, id: 'late', function: { name: 'timer_set', arguments: '{}' } }] });
|
||||
h.finish(request, 'tool_calls');
|
||||
await flush();
|
||||
assert.equal(h.calls.length, 0);
|
||||
assert.equal(h.deltas.length, 0);
|
||||
assert.equal(h.done.length, 0);
|
||||
assert.equal(request.cancelled, true);
|
||||
});
|
||||
@@ -0,0 +1,85 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const { loader } = require('./helpers/load-typescript.cjs');
|
||||
|
||||
function sharedEnv() {
|
||||
const compatible = [], unexpected = [];
|
||||
const llama = {
|
||||
streamLocalQwen: () => unexpected.push('local'),
|
||||
isLocalModelReady: () => false,
|
||||
LOCAL_MODEL: { id: 'qwen', label: 'Qwen' },
|
||||
};
|
||||
const settings = {
|
||||
anthropicApiKeySetting: { get: () => '' },
|
||||
assistantModelSetting: { get: () => 'openai-compatible' },
|
||||
assistantOpenAiCompatibleUrlSetting: { get: () => 'https://provider.example/api/v1' },
|
||||
assistantOpenAiCompatibleKeySetting: { get: () => 'compatible-key' },
|
||||
assistantOpenAiCompatibleModelSetting: { get: () => 'compatible-model' },
|
||||
openAiApiKeySetting: { get: () => '' },
|
||||
};
|
||||
const fail = provider => () => { unexpected.push(provider); };
|
||||
const load = loader({ global: { isIOS: false, isAndroid: true } }, {
|
||||
'../../native/anthropic': { streamAnthropicMessage: fail('anthropic') },
|
||||
'../../native/openai': { streamOpenAiResponse: fail('openai') },
|
||||
'../../native/llama': llama,
|
||||
'../native/llama': llama,
|
||||
'../../native/openai-chat': {
|
||||
streamOpenAiCompatibleChat: options => {
|
||||
compatible.push(options);
|
||||
return { cancel() {} };
|
||||
},
|
||||
},
|
||||
'../../ui/dashboard-settings': settings,
|
||||
'../../prompts': {
|
||||
CALCULATOR_REWRITE_SYSTEM_PROMPT: 'calculator system',
|
||||
buildCalculatorRewriteUserMessage: spoken => `rewrite: ${spoken}`,
|
||||
TRANSLATE_SYSTEM_PROMPT: 'translate system',
|
||||
buildTranslateUserMessage: speech => `translate: ${speech}`,
|
||||
},
|
||||
});
|
||||
return { load, compatible, unexpected };
|
||||
}
|
||||
|
||||
test('Calculator uses the configured compatible provider and preserves its small output cap', async () => {
|
||||
const env = sharedEnv();
|
||||
const { rewriteSpokenProblem } = env.load('app/apps/calculator/calculator-llm.ts');
|
||||
const result = rewriteSpokenProblem('one plus one');
|
||||
assert.equal(env.compatible.length, 1);
|
||||
assert.deepEqual(env.unexpected, []);
|
||||
const options = env.compatible[0];
|
||||
assert.equal(options.baseUrl, 'https://provider.example/api/v1');
|
||||
assert.equal(options.apiKey, 'compatible-key');
|
||||
assert.equal(options.model, 'compatible-model');
|
||||
assert.equal(options.maxTokens, 200);
|
||||
assert.equal(options.messages[0].content, 'rewrite: one plus one');
|
||||
options.onDone({ text: '1 + 1', content: [], stopReason: 'end_turn' });
|
||||
assert.equal(await result, '1 + 1');
|
||||
});
|
||||
|
||||
test('Translate resolves and streams through the compatible provider without changing its cancellation contract', () => {
|
||||
const env = sharedEnv();
|
||||
const { resolveTranslationModel, streamTranslation } = env.load('app/apps/translate/translate-llm.ts');
|
||||
const model = resolveTranslationModel();
|
||||
assert.equal(model.provider, 'openai-compatible');
|
||||
assert.equal(model.baseUrl, 'https://provider.example/api/v1');
|
||||
const progress = [], answers = [], errors = [];
|
||||
const handle = streamTranslation(model, {
|
||||
speech: 'Hola', context: [], language: 'Spanish',
|
||||
onProgress: text => progress.push(text),
|
||||
onDone: text => answers.push(text),
|
||||
onError: error => errors.push(error),
|
||||
});
|
||||
assert.equal(typeof handle.cancel, 'function');
|
||||
assert.equal(env.compatible.length, 1);
|
||||
assert.deepEqual(env.unexpected, []);
|
||||
const options = env.compatible[0];
|
||||
assert.equal(options.baseUrl, 'https://provider.example/api/v1');
|
||||
assert.equal(options.model, 'compatible-model');
|
||||
assert.equal(options.maxTokens, 1024);
|
||||
assert.equal(options.messages[0].content, 'translate: Hola');
|
||||
options.onTextDelta('Hello', '<english>Hello</english>');
|
||||
options.onDone({ text: '<english>Hello</english>', content: [], stopReason: 'end_turn' });
|
||||
assert.deepEqual(progress, ['Hello']);
|
||||
assert.deepEqual(answers, ['Hello']);
|
||||
assert.deepEqual(errors, []);
|
||||
});
|
||||
Reference in new issue
Block a user