nubos-pilot 1.2.4 → 1.3.0

package/lib/runtime/dispatch.test.cjs

@@ -0,0 +1,193 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { dispatchOffHost, _parseTools } = require('./dispatch.cjs');
+
+const _dirs = [];
+function _root() {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'np-dispatch-')));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  _dirs.push(root);
+  return root;
+}
+afterEach(() => { while (_dirs.length) { try { fs.rmSync(_dirs.pop(), { recursive: true, force: true }); } catch {} } });
+
+const NOW = () => '2026-06-16T00:00:00.000Z';
+
+function _deps(over) {
+  return Object.assign({
+    resolve: () => ({ kind: 'openai-compat', provider: 'ollama', model: 'qwen2.5-coder:32b', baseUrl: 'http://localhost:11434/v1', apiKeyEnv: null, tier: 'sonnet' }),
+    preflight: async () => ({ ok: true }),
+    loadSource: () => ({ frontmatter: { name: 'np-executor', tier: 'sonnet', tools: 'Read, Write, Bash, Grep' }, body: 'You are the executor.' }),
+    runLoop: async () => ({ content: 'done', stopped: 'final', iterations: 2, toolLog: [{ name: 'Read', ok: true }] }),
+    now: NOW,
+  }, over || {});
+}
+
+test('DSP-1: happy path returns the envelope and records a metrics row', async () => {
+  const cwd = _root();
+  const out = await dispatchOffHost({ agent: 'np-architect', task: 'do it', cwd, deps: _deps() });
+  assert.equal(out.provider, 'ollama');
+  assert.equal(out.model, 'qwen2.5-coder:32b');
+  assert.equal(out.content, 'done');
+  assert.equal(out.stopped, 'final');
+  assert.equal(out.metrics_recorded, true);
+  const meta = fs.readFileSync(path.join(cwd, '.nubos-pilot', 'metrics', 'meta.jsonl'), 'utf-8');
+  const rec = JSON.parse(meta.trim().split('\n').pop());
+  assert.equal(rec.runtime, 'ollama');
+  assert.equal(rec.resolved_model, 'qwen2.5-coder:32b');
+  assert.equal(rec.status, 'ok');
+});
+
+test('DSP-2: a native-kind agent is refused (dispatch-not-offhost)', async () => {
+  const cwd = _root();
+  const deps = _deps({ resolve: () => ({ kind: 'native', provider: 'claude', model: null, tier: 'opus' }) });
+  await assert.rejects(
+    dispatchOffHost({ agent: 'np-planner', task: 't', cwd, deps }),
+    (e) => e.code === 'dispatch-not-offhost',
+  );
+});
+
+test('DSP-3: Bash is excluded by default; opt-in (inside a worktree) includes it', async () => {
+  const cwd = _root();
+  let seen = null;
+  const deps = _deps({
+    isInWorktree: () => true,
+    runLoop: async ({ toolset }) => { seen = toolset.names.slice(); return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; },
+  });
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps });
+  assert.deepEqual(seen, ['Read', 'Write', 'Grep']);
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps, allowBash: true });
+  assert.deepEqual(seen, ['Read', 'Write', 'Bash', 'Grep']);
+});
+
+test('DSP-3b: readOnly restricts the toolset to read tools', async () => {
+  const cwd = _root();
+  let seen = null;
+  const deps = _deps({ runLoop: async ({ toolset }) => { seen = toolset.names.slice(); return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; } });
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps, readOnly: true });
+  assert.deepEqual(seen, ['Read', 'Grep']);
+});
+
+test('DSP-4: a loop error records an error metrics row and rethrows the loop code', async () => {
+  const cwd = _root();
+  const { NubosPilotError } = require('../core.cjs');
+  const deps = _deps({ runLoop: async () => { throw new NubosPilotError('provider-http-error', 'HTTP 500', {}); } });
+  await assert.rejects(dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps }), (e) => e.code === 'provider-http-error');
+  const rec = JSON.parse(fs.readFileSync(path.join(cwd, '.nubos-pilot', 'metrics', 'meta.jsonl'), 'utf-8').trim().split('\n').pop());
+  assert.equal(rec.status, 'error');
+});
+
+test('DSP-5: preflight runs before the loop and a failure aborts before any tool call', async () => {
+  const cwd = _root();
+  let looped = false;
+  const { NubosPilotError } = require('../core.cjs');
+  const deps = _deps({
+    preflight: async () => { throw new NubosPilotError('preflight-failed', 'unreachable', {}); },
+    runLoop: async () => { looped = true; return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; },
+  });
+  await assert.rejects(dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps }), (e) => e.code === 'preflight-failed');
+  assert.equal(looped, false);
+});
+
+test('DSP-6: missing agent throws dispatch-no-agent', async () => {
+  await assert.rejects(dispatchOffHost({ task: 't', deps: _deps() }), (e) => e.code === 'dispatch-no-agent');
+});
+
+test('DSP-8: a Rule-9-audited agent without a task context is refused off-host', async () => {
+  const cwd = _root();
+  await assert.rejects(
+    dispatchOffHost({ agent: 'np-executor', task: 't', cwd, deps: _deps() }),
+    (e) => e.code === 'offhost-audited-agent-unsupported',
+  );
+  await assert.rejects(
+    dispatchOffHost({ agent: 'np-researcher', task: 't', cwd, deps: _deps() }),
+    (e) => e.code === 'offhost-audited-agent-unsupported',
+  );
+});
+
+test('DSP-9: an audited agent WITH a valid --task-id is allowed; Rule-9 audit rides the envelope', async () => {
+  const cwd = _root();
+  let seen = null;
+  const deps = _deps({ runLoop: async ({ toolset }) => { seen = toolset.names.slice(); return { content: 'x', stopped: 'final', iterations: 1, toolLog: [{ name: 'knowledge-search', ok: true }] }; } });
+  const out = await dispatchOffHost({ agent: 'np-executor', task: 't', cwd, deps, taskId: 'M001-S001-T0001' });
+  assert.ok(seen.includes('knowledge-search'), 'knowledge-search must be injected for an audited agent');
+  assert.ok(out.rule9 && typeof out.rule9 === 'object', 'audit result must ride the envelope');
+});
+
+test('DSP-9b: with recorded search evidence the Rule-9 audit passes', async () => {
+  const cwd = _root();
+  const taskId = 'M001-S001-T0002';
+  require('../nubosloop-audit.cjs').recordSearchEvidence(taskId, 'auth', cwd);
+  const deps = _deps({ runLoop: async () => ({ content: 'x', stopped: 'final', iterations: 1, toolLog: [{ name: 'knowledge-search', ok: true }] }) });
+  const out = await dispatchOffHost({ agent: 'np-executor', task: 't', cwd, deps, taskId });
+  assert.equal(out.rule9.ok, true);
+  assert.equal(out.rule9.violation, null);
+});
+
+test('DSP-12: skipAudit defers Rule-9 to the orchestrator (rule9 not run by dispatch)', async () => {
+  const cwd = _root();
+  const deps = _deps({ runLoop: async () => ({ content: 'x', stopped: 'final', iterations: 1, toolLog: [{ name: 'knowledge-search', ok: true }] }) });
+  const out = await dispatchOffHost({ agent: 'np-executor', task: 't', cwd, deps, taskId: 'M001-S001-T0003', skipAudit: true });
+  assert.equal(out.rule9, null, 'dispatch must not audit when skipAudit is set');
+});
+
+test('DSP-10: --allow-bash outside a worktree is refused (offhost-bash-requires-sandbox)', async () => {
+  const cwd = _root();
+  const deps = _deps({ isInWorktree: () => false });
+  await assert.rejects(
+    dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps, allowBash: true }),
+    (e) => e.code === 'offhost-bash-requires-sandbox',
+  );
+});
+
+test('DSP-11: --allow-bash inside a worktree includes Bash in the toolset', async () => {
+  const cwd = _root();
+  let seen = null;
+  const deps = _deps({
+    isInWorktree: () => true,
+    runLoop: async ({ toolset }) => { seen = toolset.names.slice(); return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; },
+  });
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps, allowBash: true });
+  assert.ok(seen.includes('Bash'), 'Bash must be available inside a worktree');
+});
+
+test('DSP-13: outputSchema lints the result and rides the envelope (null when unset)', async () => {
+  const cwd = _root();
+  const out1 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: _deps() });
+  assert.equal(out1.output_lint, null, 'no schema ⇒ no lint');
+  const out2 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: _deps(), outputSchema: 'researcher-output' });
+  assert.ok(out2.output_lint && out2.output_lint.schema === 'researcher-output', 'lint result rides the envelope');
+  assert.equal(typeof out2.output_lint.ok, 'boolean');
+});
+
+test('DSP-14: capability flags zero tool-calls despite an advertised toolset (tool-calling unsupported signal)', async () => {
+  const cwd = _root();
+  // model made no tool calls but tools were advertised → not ok, mutating true (Write/Bash in toolset)
+  const noTools = _deps({ runLoop: async () => ({ content: 'just text', stopped: 'final', iterations: 1, toolLog: [] }) });
+  const out1 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: noTools });
+  assert.equal(out1.capability.ok, false);
+  assert.equal(out1.capability.toolCalls, 0);
+  assert.ok(out1.capability.toolsAdvertised > 0);
+  assert.equal(out1.capability.mutating, true);
+
+  // model used a tool → ok
+  const usedTool = _deps({ runLoop: async () => ({ content: 'x', stopped: 'final', iterations: 2, toolLog: [{ name: 'Read', ok: true }] }) });
+  const out2 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: usedTool });
+  assert.equal(out2.capability.ok, true);
+
+  // read-only emitter with no tool calls → not ok but mutating false (softer hint)
+  const ro = _deps({ runLoop: async () => ({ content: 'x', stopped: 'final', iterations: 1, toolLog: [] }) });
+  const out3 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: ro, readOnly: true });
+  assert.equal(out3.capability.ok, false);
+  assert.equal(out3.capability.mutating, false);
+});
+
+test('DSP-7: _parseTools accepts a comma string or an array', () => {
+  assert.deepEqual(_parseTools('Read, Write , Bash'), ['Read', 'Write', 'Bash']);
+  assert.deepEqual(_parseTools(['Read', 'Grep']), ['Read', 'Grep']);
+  assert.deepEqual(_parseTools(undefined), []);
+});

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,102 @@
+'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, 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';
+  }
+
+  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,103 @@
+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-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);
+});