nubos-pilot 1.2.4 → 1.3.1

package/lib/runtime/preflight.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+const { NubosPilotError } = require('../core.cjs');
+const { _hostOf } = require('./providers/openai-compat.cjs');
+
+const DEFAULT_PREFLIGHT_TIMEOUT_MS = 10000;
+
+function _isLocal(baseUrl) {
+  return /^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])/i.test(baseUrl || '');
+}
+
+async function preflight({ baseUrl, apiKeyEnv, model, fetchImpl, env, timeoutMs }) {
+  const out = { ok: false, reachable: false, modelPresent: false, models: [], hint: null, host: 'provider' };
+  if (typeof baseUrl !== 'string' || !baseUrl) {
+    out.hint = 'provider has no base_url';
+    return out;
+  }
+  const f = fetchImpl || globalThis.fetch;
+  const e = env || process.env;
+  const url = baseUrl.replace(/\/+$/, '') + '/models';
+  out.host = _hostOf(url);
+
+  const headers = {};
+  if (apiKeyEnv && e[apiKeyEnv]) headers.authorization = 'Bearer ' + e[apiKeyEnv];
+
+  let res;
+  try {
+    res = await f(url, { method: 'GET', headers, signal: AbortSignal.timeout(timeoutMs || DEFAULT_PREFLIGHT_TIMEOUT_MS) });
+  } catch {
+    out.hint = 'cannot reach ' + out.host
+      + (_isLocal(baseUrl) ? ' — is the model server running? (e.g. `ollama serve`)' : ' — check base_url / network');
+    return out;
+  }
+  if (!res.ok) {
+    out.hint = out.host + ' returned HTTP ' + res.status + ' for /models';
+    return out;
+  }
+  out.reachable = true;
+
+  let json = null;
+  try { json = await res.json(); } catch {}
+  const data = json && Array.isArray(json.data) ? json.data : [];
+  out.models = data.map((m) => m && m.id).filter((id) => typeof id === 'string');
+
+  out.modelPresent = !model || out.models.includes(model);
+  if (!out.modelPresent) {
+    out.hint = 'model "' + model + '" not available on ' + out.host
+      + (_isLocal(baseUrl) ? ' — run: ollama pull ' + model : ' — check the model name / your access');
+    return out;
+  }
+
+  out.ok = true;
+  return out;
+}
+
+async function assertPreflight(args) {
+  const r = await preflight(args);
+  if (!r.ok) {
+    throw new NubosPilotError(
+      'preflight-failed',
+      r.hint || ('preflight failed for ' + r.host),
+      { host: r.host, reachable: r.reachable, modelPresent: r.modelPresent, model: args && args.model },
+    );
+  }
+  return r;
+}
+
+module.exports = { preflight, assertPreflight, _isLocal, DEFAULT_PREFLIGHT_TIMEOUT_MS };

package/lib/runtime/preflight.test.cjs

@@ -0,0 +1,62 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { preflight, assertPreflight, _isLocal } = require('./preflight.cjs');
+
+function _res({ ok = true, status = 200, json }) {
+  return { ok, status, json: async () => json };
+}
+
+test('PF-1: reachable + model present ⇒ ok', async () => {
+  const fetchImpl = async () => _res({ json: { data: [{ id: 'qwen2.5-coder:32b' }, { id: 'llama3' }] } });
+  const r = await preflight({ baseUrl: 'http://localhost:11434/v1', model: 'qwen2.5-coder:32b', fetchImpl });
+  assert.equal(r.ok, true);
+  assert.equal(r.reachable, true);
+  assert.equal(r.modelPresent, true);
+  assert.deepEqual(r.models, ['qwen2.5-coder:32b', 'llama3']);
+});
+
+test('PF-2: unreachable server ⇒ not ok with `ollama serve` hint for localhost', async () => {
+  const fetchImpl = async () => { throw new Error('ECONNREFUSED'); };
+  const r = await preflight({ baseUrl: 'http://localhost:11434/v1', model: 'qwen', fetchImpl });
+  assert.equal(r.ok, false);
+  assert.equal(r.reachable, false);
+  assert.match(r.hint, /ollama serve/);
+});
+
+test('PF-3: reachable but model missing ⇒ `ollama pull` hint', async () => {
+  const fetchImpl = async () => _res({ json: { data: [{ id: 'llama3' }] } });
+  const r = await preflight({ baseUrl: 'http://localhost:11434/v1', model: 'qwen3.5', fetchImpl });
+  assert.equal(r.reachable, true);
+  assert.equal(r.modelPresent, false);
+  assert.equal(r.ok, false);
+  assert.match(r.hint, /ollama pull qwen3\.5/);
+});
+
+test('PF-4: remote host missing model gives a non-ollama hint', async () => {
+  const fetchImpl = async () => _res({ json: { data: [{ id: 'gpt-4o' }] } });
+  const r = await preflight({ baseUrl: 'https://api.openai.com/v1', model: 'gpt-9', fetchImpl });
+  assert.equal(r.ok, false);
+  assert.doesNotMatch(r.hint, /ollama/);
+});
+
+test('PF-5: assertPreflight throws preflight-failed when not ok', async () => {
+  const fetchImpl = async () => { throw new Error('down'); };
+  let thrown = null;
+  try { await assertPreflight({ baseUrl: 'http://localhost:11434/v1', model: 'qwen', fetchImpl }); }
+  catch (e) { thrown = e; }
+  assert.equal(thrown && thrown.code, 'preflight-failed');
+});
+
+test('PF-6: _isLocal classifies localhost/127.0.0.1 as local, public host as remote', () => {
+  assert.equal(_isLocal('http://localhost:11434/v1'), true);
+  assert.equal(_isLocal('http://127.0.0.1:11434/v1'), true);
+  assert.equal(_isLocal('https://api.openai.com/v1'), false);
+});
+
+test('PF-7: HTTP 401 on /models ⇒ not reachable-ok, hint names status', async () => {
+  const fetchImpl = async () => _res({ ok: false, status: 401 });
+  const r = await preflight({ baseUrl: 'https://api.openai.com/v1', model: 'gpt-4o', fetchImpl });
+  assert.equal(r.ok, false);
+  assert.match(r.hint, /401/);
+});

package/lib/runtime/providers/openai-compat.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+const { NubosPilotError } = require('../../core.cjs');
+
+const DEFAULT_TIMEOUT_MS = 120000;
+
+function _hostOf(url) {
+  try { return new URL(url).host; } catch { return 'provider'; }
+}
+
+function _parse(json) {
+  const choice = json && Array.isArray(json.choices) ? json.choices[0] : null;
+  const msg = (choice && choice.message) ? choice.message : {};
+  const toolCalls = Array.isArray(msg.tool_calls)
+    ? msg.tool_calls.map((tc, i) => ({
+        id: (tc && tc.id) || ('call_' + i),
+        name: tc && tc.function && tc.function.name,
+        arguments: tc && tc.function && tc.function.arguments,
+      }))
+    : [];
+  const usage = (json && json.usage) ? {
+    tokens_in: typeof json.usage.prompt_tokens === 'number' ? json.usage.prompt_tokens : null,
+    tokens_out: typeof json.usage.completion_tokens === 'number' ? json.usage.completion_tokens : null,
+  } : null;
+  return {
+    content: typeof msg.content === 'string' ? msg.content : '',
+    toolCalls,
+    finishReason: (choice && choice.finish_reason) || null,
+    usage,
+    raw: msg,
+  };
+}
+
+async function chat({ baseUrl, apiKeyEnv, model, messages, tools, effort, timeoutMs, fetchImpl, env }) {
+  if (typeof baseUrl !== 'string' || !baseUrl) {
+    throw new NubosPilotError('provider-no-base-url', 'openai-compat chat requires a base_url', {});
+  }
+  if (typeof model !== 'string' || !model) {
+    throw new NubosPilotError('provider-no-model', 'openai-compat chat requires a model', {});
+  }
+  const f = fetchImpl || globalThis.fetch;
+  if (typeof f !== 'function') {
+    throw new NubosPilotError('provider-no-fetch', 'global fetch unavailable (node >=22 required)', {});
+  }
+  const e = env || process.env;
+  const headers = { 'content-type': 'application/json' };
+  if (apiKeyEnv) {
+    const key = e[apiKeyEnv];
+    if (!key) {
+      throw new NubosPilotError(
+        'provider-missing-api-key',
+        'env var ' + apiKeyEnv + ' is empty or unset',
+        { apiKeyEnv },
+      );
+    }
+    headers.authorization = 'Bearer ' + key;
+  }
+
+  const body = { model, messages, stream: false };
+  if (Array.isArray(tools) && tools.length) {
+    body.tools = tools;
+    body.tool_choice = 'auto';
+  }
+  if (typeof effort === 'string' && effort) body.reasoning_effort = effort;
+
+  const url = baseUrl.replace(/\/+$/, '') + '/chat/completions';
+  const host = _hostOf(url);
+
+  let res;
+  try {
+    res = await f(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs || DEFAULT_TIMEOUT_MS),
+    });
+  } catch (err) {
+    throw new NubosPilotError(
+      'provider-request-failed',
+      'request to ' + host + ' failed (' + ((err && (err.code || err.name)) || 'error') + ')',
+      { host, cause: (err && (err.code || err.name)) || 'unknown' },
+    );
+  }
+
+  if (!res.ok) {
+    let snippet = '';
+    try { snippet = (await res.text()).slice(0, 300); } catch {}
+    throw new NubosPilotError(
+      'provider-http-error',
+      host + ' returned HTTP ' + res.status,
+      { host, status: res.status, body: snippet },
+    );
+  }
+
+  let json;
+  try { json = await res.json(); }
+  catch {
+    throw new NubosPilotError('provider-bad-json', host + ' returned a non-JSON body', { host });
+  }
+  return _parse(json);
+}
+
+module.exports = { chat, _parse, _hostOf, DEFAULT_TIMEOUT_MS };

package/lib/runtime/providers/openai-compat.test.cjs

@@ -0,0 +1,112 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { chat, _parse } = require('./openai-compat.cjs');
+
+function _res({ ok = true, status = 200, json, text }) {
+  return {
+    ok, status,
+    json: async () => json,
+    text: async () => (text != null ? text : JSON.stringify(json || {})),
+  };
+}
+
+test('OAC-1: _parse extracts content + tool_calls from an OpenAI-shaped response', () => {
+  const out = _parse({
+    choices: [{
+      finish_reason: 'tool_calls',
+      message: {
+        role: 'assistant', content: 'thinking',
+        tool_calls: [{ id: 'c1', function: { name: 'Read', arguments: '{"path":"a.txt"}' } }],
+      },
+    }],
+  });
+  assert.equal(out.content, 'thinking');
+  assert.equal(out.finishReason, 'tool_calls');
+  assert.deepEqual(out.toolCalls, [{ id: 'c1', name: 'Read', arguments: '{"path":"a.txt"}' }]);
+});
+
+test('OAC-2: _parse on a content-only response yields empty toolCalls', () => {
+  const out = _parse({ choices: [{ finish_reason: 'stop', message: { content: 'done' } }] });
+  assert.equal(out.content, 'done');
+  assert.deepEqual(out.toolCalls, []);
+});
+
+test('OAC-3: chat POSTs to <base>/chat/completions with model + tools and parses the reply', async () => {
+  let captured = null;
+  const fetchImpl = async (url, opts) => {
+    captured = { url, opts };
+    return _res({ json: { choices: [{ message: { content: 'hi' } }] } });
+  };
+  const out = await chat({
+    baseUrl: 'http://localhost:11434/v1', model: 'qwen', messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'Read' } }], fetchImpl,
+  });
+  assert.equal(captured.url, 'http://localhost:11434/v1/chat/completions');
+  const body = JSON.parse(captured.opts.body);
+  assert.equal(body.model, 'qwen');
+  assert.equal(body.tool_choice, 'auto');
+  assert.equal(out.content, 'hi');
+});
+
+test('OAC-3b: chat forwards effort as reasoning_effort only when set', async () => {
+  let captured = null;
+  const fetchImpl = async (_url, opts) => { captured = JSON.parse(opts.body); return _res({ json: { choices: [{ message: { content: 'ok' } }] } }); };
+  await chat({ baseUrl: 'http://x/v1', model: 'm', messages: [{ role: 'user', content: 'x' }], effort: 'low', fetchImpl });
+  assert.equal(captured.reasoning_effort, 'low', 'a set effort reaches the request body');
+  await chat({ baseUrl: 'http://x/v1', model: 'm', messages: [{ role: 'user', content: 'x' }], fetchImpl });
+  assert.ok(!('reasoning_effort' in captured), 'absent effort is never sent (providers without support unaffected)');
+});
+
+test('OAC-4: api_key_env adds a bearer header; missing key throws provider-missing-api-key', async () => {
+  let auth = null;
+  const fetchImpl = async (_url, opts) => { auth = opts.headers.authorization; return _res({ json: { choices: [{ message: { content: 'ok' } }] } }); };
+  await chat({ baseUrl: 'https://api.x.ai/v1', model: 'grok-2', messages: [], apiKeyEnv: 'XAI_KEY', env: { XAI_KEY: 'sk-123' }, fetchImpl });
+  assert.equal(auth, 'Bearer sk-123');
+
+  let thrown = null;
+  try { await chat({ baseUrl: 'https://api.x.ai/v1', model: 'grok-2', messages: [], apiKeyEnv: 'XAI_KEY', env: {}, fetchImpl }); }
+  catch (e) { thrown = e; }
+  assert.equal(thrown && thrown.code, 'provider-missing-api-key');
+});
+
+test('OAC-5: non-2xx throws provider-http-error carrying status + host (not full url)', async () => {
+  const fetchImpl = async () => _res({ ok: false, status: 500, text: 'boom' });
+  let thrown = null;
+  try { await chat({ baseUrl: 'http://localhost:11434/v1', model: 'qwen', messages: [], fetchImpl }); }
+  catch (e) { thrown = e; }
+  assert.equal(thrown.code, 'provider-http-error');
+  assert.equal(thrown.details.status, 500);
+  assert.equal(thrown.details.host, 'localhost:11434');
+});
+
+test('OAC-6: network failure throws provider-request-failed with host only', async () => {
+  const fetchImpl = async () => { const e = new Error('refused'); e.code = 'ECONNREFUSED'; throw e; };
+  let thrown = null;
+  try { await chat({ baseUrl: 'http://localhost:11434/v1', model: 'qwen', messages: [], fetchImpl }); }
+  catch (e) { thrown = e; }
+  assert.equal(thrown.code, 'provider-request-failed');
+  assert.equal(thrown.details.host, 'localhost:11434');
+});
+
+test('OAC-7: missing base_url / model throw before any fetch', async () => {
+  let a = null; try { await chat({ model: 'm', messages: [] }); } catch (e) { a = e; }
+  assert.equal(a.code, 'provider-no-base-url');
+  let b = null; try { await chat({ baseUrl: 'http://x/v1', messages: [] }); } catch (e) { b = e; }
+  assert.equal(b.code, 'provider-no-model');
+});
+
+test('OAC-8: _parse synthesizes a stable id when the provider omits tool_calls[].id', () => {
+  const out = _parse({ choices: [{ message: { tool_calls: [
+    { function: { name: 'Read', arguments: '{}' } },
+    { function: { name: 'Grep', arguments: '{}' } },
+  ] } }] });
+  assert.deepEqual(out.toolCalls.map((t) => t.id), ['call_0', 'call_1']);
+});
+
+test('OAC-9: _parse captures token usage when present', () => {
+  const out = _parse({ choices: [{ message: { content: 'x' } }], usage: { prompt_tokens: 12, completion_tokens: 5 } });
+  assert.deepEqual(out.usage, { tokens_in: 12, tokens_out: 5 });
+  const none = _parse({ choices: [{ message: { content: 'x' } }] });
+  assert.equal(none.usage, null);
+});