@worca/app 1.3.0 → 1.4.0

package/src/core/bridge/semaphore.mjs

@@ -0,0 +1,73 @@
+// src/core/bridge/semaphore.mjs
+// Per-key counting semaphore for the bridge's upstream concurrency cap
+// (model-bridge-design.md §7.4). A request over the cap WAITS in FIFO order;
+// it never fails. The cap is read per acquire so a settings edit applies to
+// the next request without a restart.
+
+export class KeyedSemaphore {
+  constructor() { this.slots = new Map(); }
+
+  _slot(key) {
+    let s = this.slots.get(key);
+    if (!s) { s = { active: 0, queue: [] }; this.slots.set(key, s); }
+    return s;
+  }
+
+  /** Number of requests waiting for `key` right now. */
+  queued(key) { return this._slot(key).queue.length; }
+  /** Number of requests in flight for `key` right now. */
+  active(key) { return this._slot(key).active; }
+
+  /**
+   * Acquire one slot under `key` with `limit` concurrent holders. Resolves to
+   * a release function. `signal` aborts the wait (rejects with AbortError).
+   * @param {string} key
+   * @param {number} limit
+   * @param {{signal?:AbortSignal}} [opts]
+   * @returns {Promise<() => void>}
+   */
+  acquire(key, limit, { signal } = {}) {
+    const s = this._slot(key);
+    const max = Number.isInteger(limit) && limit > 0 ? limit : 1;
+    return new Promise((resolve, reject) => {
+      const grant = () => {
+        s.active += 1;
+        let released = false;
+        resolve(() => {
+          if (released) return;
+          released = true;
+          s.active -= 1;
+          this._drain(key);
+        });
+      };
+      if (s.active < max) { grant(); return; }
+      if (signal && signal.aborted) { reject(abortError()); return; }
+      const entry = { limit: max, grant: null };
+      const onAbort = () => {
+        const i = s.queue.indexOf(entry);
+        if (i !== -1) s.queue.splice(i, 1);
+        reject(abortError());
+      };
+      entry.grant = () => {
+        if (signal) signal.removeEventListener('abort', onAbort);
+        grant();
+      };
+      if (signal) signal.addEventListener('abort', onAbort, { once: true });
+      s.queue.push(entry);
+    });
+  }
+
+  _drain(key) {
+    const s = this._slot(key);
+    while (s.queue.length && s.active < s.queue[0].limit) {
+      const next = s.queue.shift();
+      next.grant();
+    }
+  }
+}
+
+function abortError() {
+  const e = new Error('aborted while waiting for an upstream slot');
+  e.name = 'AbortError';
+  return e;
+}

package/src/core/bridge/server.mjs

@@ -0,0 +1,184 @@
+// src/core/bridge/server.mjs
+// The in-process loopback bridge (model-bridge-design.md §4.1): an http
+// server on 127.0.0.1 that presents the Anthropic Messages API to the spawned
+// `claude` CLI under /m/<catalogId>/v1/... and forwards each request to the
+// entry's configured upstream. One per worca process (UI server or CLI),
+// started lazily by resolveModelEnv on the first bridged dispatch — or ahead
+// of time by startBridge() at boot — bound to an ephemeral port, unref'd so
+// an idle bridge never keeps the process alive.
+//
+// Auth to the bridge is a per-process random secret handed to the CLI as
+// ANTHROPIC_AUTH_TOKEN: the bridge holds real credentials, and loopback alone
+// would let any local process (or a sub-agent shelling out to curl) borrow
+// them. The secret is never persisted and never logged.
+
+import http from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { findBridgedEntry } from './registry.mjs';
+import { handleMessages } from './upstream.mjs';
+import { estimateInputTokens } from './translate/response.mjs';
+import { bridgeErrors, PAYLOAD_CEILING_BYTES } from './errors.mjs';
+
+let state = null;   // { server, port, secret, listening: Promise<number>, log }
+const ROUTE_RE = /^\/m\/([^/]+)(?:\/r\/([^/]+))?\/v1\/(messages|messages\/count_tokens|models)\/?$/;
+
+/** The bridge's per-process bearer secret (created on first use). */
+export function bridgeSecret() {
+  if (!state) state = createState();
+  return state.secret;
+}
+
+function createState() {
+  return { server: null, port: 0, secret: randomBytes(32).toString('hex'), listening: null, log: null };
+}
+
+/**
+ * Start the bridge if it is not running and resolve once it listens.
+ * @param {{log?:(line:string)=>void, fetch?:typeof fetch}} [opts]
+ * @returns {Promise<{port:number, secret:string}>}
+ */
+export async function startBridge(opts = {}) {
+  ensureBridgeSync(opts);
+  await state.listening;
+  return { port: state.port, secret: state.secret };
+}
+
+/**
+ * The bridge's {port, secret}, starting it on a random loopback port when it
+ * is not running yet. Synchronous by contract (resolveModelEnv is sync): the
+ * server is listening by the time the spawned CLI makes its first request,
+ * and startBridge() at boot is the normal path that makes this a no-op.
+ */
+export function ensureBridgeSync({ log, fetch: f } = {}) {
+  if (!state) state = createState();
+  if (log) state.log = log;
+  if (f) state.fetch = f;
+  if (state.server) return { port: state.port, secret: state.secret };
+  const server = http.createServer((req, res) => handle(req, res).catch((err) => {
+    try { if (!res.headersSent) res.writeHead(500, { 'content-type': 'application/json' }); res.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: `bridge: ${err && err.message ? err.message : String(err)}` } })); } catch { /* gone */ }
+  }));
+  server.keepAliveTimeout = 65_000;
+  server.headersTimeout = 70_000;
+  server.requestTimeout = 0;   // long-running streams
+  state.server = server;
+  state.port = pickPort();
+  state.listening = new Promise((resolve) => {
+    let attempts = 0;
+    const tryListen = () => {
+      server.once('error', (err) => {
+        if (err && err.code === 'EADDRINUSE' && attempts < 10) {
+          attempts += 1;
+          state.port = pickPort();
+          (state.log || console.warn)(`[worca] bridge: port in use, retrying on ${state.port}`);
+          tryListen();
+          return;
+        }
+        (state.log || console.warn)(`[worca] bridge: failed to listen — ${err && err.message}`);
+        state.server = null;
+        resolve(0);
+      });
+      server.listen(state.port, '127.0.0.1', () => {
+        state.port = server.address().port;
+        server.unref();
+        resolve(state.port);
+      });
+    };
+    tryListen();
+  });
+  return { port: state.port, secret: state.secret };
+}
+
+/** A random port in the private range; the listen retry covers a collision. */
+function pickPort() { return 20000 + Math.floor(Math.random() * 40000); }
+
+/** The base URL the CLI gets for a catalog id (optionally tagged with a run's execution id). */
+export function bridgeBaseUrl(catalogId, { tag } = {}) {
+  const { port } = ensureBridgeSync();
+  const t = tag ? `/r/${encodeURIComponent(String(tag))}` : '';
+  return `http://127.0.0.1:${port}/m/${encodeURIComponent(catalogId)}${t}`;
+}
+
+/** Whether the bridge is up (listening or about to). */
+export function bridgeRunning() { return !!(state && state.server); }
+export function bridgePort() { return state ? state.port : 0; }
+
+/** Stop the bridge (tests, shutdown). */
+export async function stopBridge() {
+  if (!state || !state.server) { state = null; return; }
+  const s = state.server;
+  state = null;
+  await new Promise((r) => { try { s.closeAllConnections?.(); } catch { /* n/a */ } s.close(() => r()); });
+}
+
+// ── request handling ─────────────────────────────────────────────────────────
+
+function readBody(req, limit) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', (c) => {
+      size += c.length;
+      if (size > limit) { reject(Object.assign(new Error('too large'), { code: 'TOO_LARGE' })); req.destroy(); return; }
+      chunks.push(c);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    req.on('error', reject);
+  });
+}
+
+function sendJson(res, status, obj, headers) {
+  if (res.headersSent) { res.end(); return; }
+  res.writeHead(status, { 'content-type': 'application/json', ...(headers || {}) });
+  res.end(JSON.stringify(obj));
+}
+
+function authorized(req) {
+  const h = req.headers;
+  const bearer = typeof h.authorization === 'string' && /^bearer\s+/i.test(h.authorization) ? h.authorization.replace(/^bearer\s+/i, '').trim() : '';
+  const key = typeof h['x-api-key'] === 'string' ? h['x-api-key'].trim() : '';
+  return (bearer && bearer === state.secret) || (key && key === state.secret);
+}
+
+async function handle(req, res) {
+  const url = new URL(req.url || '/', 'http://127.0.0.1');
+  const m = ROUTE_RE.exec(url.pathname);
+  if (!m) { const e = bridgeErrors.notFound(); return sendJson(res, e.status, e.body); }
+  if (!authorized(req)) { const e = bridgeErrors.unauthorized(); return sendJson(res, e.status, e.body); }
+  const catalogId = decodeURIComponent(m[1]);
+  const tag = m[2] ? decodeURIComponent(m[2]) : '';
+  const route = m[3];
+  const entry = findBridgedEntry(catalogId);
+  if (!entry) { const e = bridgeErrors.unknownModel(catalogId); return sendJson(res, e.status, e.body); }
+
+  if (route === 'models') {
+    return sendJson(res, 200, { data: [{ id: entry.id, type: 'model', display_name: entry.label, created_at: '2026-01-01T00:00:00Z' }], has_more: false, first_id: entry.id, last_id: entry.id });
+  }
+  if (req.method !== 'POST') { const e = bridgeErrors.notFound(); return sendJson(res, e.status, e.body); }
+
+  let text;
+  try {
+    text = await readBody(req, PAYLOAD_CEILING_BYTES + 1024);
+  } catch (err) {
+    const e = err && err.code === 'TOO_LARGE' ? bridgeErrors.tooLarge() : bridgeErrors.badJson();
+    return sendJson(res, e.status, e.body);
+  }
+  let body;
+  try { body = JSON.parse(text); } catch { const e = bridgeErrors.badJson(); return sendJson(res, e.status, e.body); }
+  if (!body || typeof body !== 'object') { const e = bridgeErrors.badJson(); return sendJson(res, e.status, e.body); }
+
+  if (route === 'messages/count_tokens') {
+    return sendJson(res, 200, { input_tokens: estimateInputTokens(body) });
+  }
+
+  const ctrl = new AbortController();
+  res.on('close', () => { if (!res.writableFinished) ctrl.abort(); });
+  const reply = {
+    status: (code, headers) => { if (!res.headersSent) res.writeHead(code, headers || {}); },
+    write: (chunk) => { if (!res.destroyed) res.write(chunk); },
+    end: () => { if (!res.destroyed) res.end(); },
+    json: (code, obj, headers) => sendJson(res, code, obj, headers),
+  };
+  const headers = {};
+  for (const [k, v] of Object.entries(req.headers)) if (typeof v === 'string') headers[k.toLowerCase()] = v;
+  await handleMessages({ entry, body, requestHeaders: headers, tag, signal: ctrl.signal, fetch: state.fetch, log: state.log }, reply);
+}

package/src/core/bridge/telemetry.mjs

@@ -0,0 +1,53 @@
+// src/core/bridge/telemetry.mjs
+// What the bridge did, for the run surfaces (model-bridge-design.md §7.2,
+// §8.6): a per-tag counter of premium-request-INITIATING calls (a user turn,
+// as opposed to a tool-result continuation the upstream bills as part of the
+// same request) and an event stream the harness can subscribe to. The tag is
+// the run's execution id, threaded through resolveModelEnv → the bridge URL.
+
+import { EventEmitter } from 'node:events';
+
+/** Emits 'call' {tag, catalogId, provider, api, initiator} and 'failure'
+ *  {tag, catalogId, status, message}. (Not 'error': an EventEmitter throws on
+ *  an unlistened 'error' event, and telemetry must never fail a request.) */
+export const bridgeEvents = new EventEmitter();
+bridgeEvents.setMaxListeners(50);
+
+const calls = new Map();   // tag -> { initiated, continued, errors }
+const MAX_TAGS = 5000;
+
+function slot(tag) {
+  const k = tag || '';
+  let s = calls.get(k);
+  if (!s) {
+    if (calls.size >= MAX_TAGS) calls.delete(calls.keys().next().value);
+    s = { initiated: 0, continued: 0, errors: 0 };
+    calls.set(k, s);
+  }
+  return s;
+}
+
+/** Book one upstream call. `initiator` is 'user' | 'agent' (§7.1). */
+export function recordBridgeCall({ tag, catalogId, provider, api, initiator }) {
+  const s = slot(tag);
+  if (initiator === 'agent') s.continued += 1; else s.initiated += 1;
+  bridgeEvents.emit('call', { tag: tag || '', catalogId, provider, api, initiator });
+}
+
+/** Book one failed upstream call. */
+export function recordBridgeError({ tag, catalogId, provider, status, message }) {
+  slot(tag).errors += 1;
+  bridgeEvents.emit('failure', { tag: tag || '', catalogId, provider, status, message });
+}
+
+/** Counters for a tag: {initiated, continued, errors}; zeros when unseen. */
+export function bridgeCallsFor(tag) {
+  const s = calls.get(tag || '');
+  return s ? { ...s } : { initiated: 0, continued: 0, errors: 0 };
+}
+
+/** Forget a tag's counters (a finished run). */
+export function forgetBridgeTag(tag) { calls.delete(tag || ''); }
+
+/** Test hook. */
+export function _resetBridgeTelemetry() { calls.clear(); }

package/src/core/bridge/translate/request.mjs

@@ -0,0 +1,252 @@
+// src/core/bridge/translate/request.mjs
+// Anthropic Messages API request -> OpenAI chat/completions request
+// (model-bridge-design.md §5.1–§5.3). Pure: no I/O, no globals. Every field
+// the CLI sends that has no equivalent is DROPPED and named in `warnings`;
+// anything that cannot be expressed at all (a server tool, tools on a model
+// without tool calls) is a hard `error` — the bridge answers 400 with it, so a
+// run fails with the fix instruction instead of silently running degraded.
+//
+// Scope is what Claude Code actually sends. Reference implementations for the
+// edge cases: ericc-ch/copilot-api, voidsteed/copilot-proxy-api (both MIT).
+
+/** Anthropic server-side tool types — no chat/completions equivalent (§5.3). */
+export const SERVER_TOOL_RE = /^(web_search|web_fetch|computer|text_editor|bash|code_execution|memory)(_\d{8})?$/;
+
+/** Efforts (CLI `--effort` -> `output_config.effort`) -> OpenAI reasoning_effort. */
+const EFFORT_TO_REASONING = { low: 'low', medium: 'medium', high: 'high', xhigh: 'high', max: 'high' };
+
+/** Thinking budget bands -> reasoning_effort (§5.1). */
+export function budgetToReasoningEffort(budget) {
+  const n = Number(budget);
+  if (!Number.isFinite(n) || n <= 0) return 'medium';
+  if (n < 4000) return 'low';
+  if (n < 16000) return 'medium';
+  return 'high';
+}
+
+/** Text of a block list (text blocks only), joined with blank lines. */
+function textOf(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
+    .map((b) => b.text)
+    .join('\n\n');
+}
+
+/** An Anthropic image block -> chat/completions image_url part (data URI). */
+function imagePart(block) {
+  const src = block.source || {};
+  if (src.type === 'base64' && src.media_type && src.data) {
+    return { type: 'image_url', image_url: { url: `data:${src.media_type};base64,${src.data}` } };
+  }
+  if (src.type === 'url' && typeof src.url === 'string') {
+    return { type: 'image_url', image_url: { url: src.url } };
+  }
+  return null;
+}
+
+/**
+ * Build chat/completions content from Anthropic user-side blocks. Returns
+ * `{ parts, warnings }` where parts is a string when it is text-only.
+ */
+function userParts(blocks, caps, warn) {
+  const parts = [];
+  for (const b of blocks) {
+    if (!b || typeof b !== 'object') continue;
+    if (b.type === 'text') {
+      if (typeof b.text === 'string' && b.text) parts.push({ type: 'text', text: b.text });
+    } else if (b.type === 'image') {
+      if (caps.vision === false) {
+        warn('image');
+        parts.push({ type: 'text', text: '[image omitted: model has no vision]' });
+      } else {
+        const p = imagePart(b);
+        if (p) parts.push(p); else warn('image');
+      }
+    } else if (b.type === 'document') {
+      warn('document');
+      parts.push({ type: 'text', text: '[document omitted: not supported by this model]' });
+    } else {
+      warn(b.type);
+    }
+  }
+  return parts;
+}
+
+/** Collapse a parts array to a string when it is text-only (most compatible). */
+function compact(parts) {
+  if (!parts.length) return '';
+  if (parts.every((p) => p.type === 'text')) return parts.map((p) => p.text).join('\n\n');
+  return parts;
+}
+
+/** Flatten a tool_result's content to text; images come back separately (§5.2). */
+function toolResultContent(content, caps, warn) {
+  if (typeof content === 'string') return { text: content, images: [] };
+  if (!Array.isArray(content)) return { text: content == null ? '' : String(content), images: [] };
+  const texts = [];
+  const images = [];
+  for (const b of content) {
+    if (!b || typeof b !== 'object') continue;
+    if (b.type === 'text' && typeof b.text === 'string') texts.push(b.text);
+    // ToolSearch's result: the named tool is now in `tools` on this request.
+    else if (b.type === 'tool_reference') texts.push(`Tool loaded: ${b.tool_name || b.name || 'unknown'}`);
+    else if (b.type === 'image') {
+      if (caps.vision === false) { warn('image'); texts.push('[image omitted: model has no vision]'); }
+      else { const p = imagePart(b); if (p) images.push(p); else warn('image'); }
+    } else warn(b.type);
+  }
+  return { text: texts.join('\n\n'), images };
+}
+
+/**
+ * Translate one Messages API request body.
+ * @param {object} body  the Anthropic request as the CLI sent it
+ * @param {{upstreamModel:string, capabilities?:{toolCalls?:boolean, vision?:boolean, reasoning?:boolean, maxOutputTokens?:number}}} opts
+ * @returns {{body?:object, warnings:string[], error?:{type:string,message:string}}}
+ */
+export function toChatRequest(body, { upstreamModel, capabilities = {} } = {}) {
+  const caps = capabilities || {};
+  const warnings = [];
+  const seen = new Set();
+  const warn = (what) => { if (what && !seen.has(what)) { seen.add(what); warnings.push(what); } };
+  const fail = (message) => ({ warnings, error: { type: 'invalid_request_error', message } });
+
+  if (!body || typeof body !== 'object') return fail('request body must be an object');
+
+  const messages = [];
+
+  // ── system ──
+  const system = textOf(body.system);
+  if (system) messages.push({ role: 'system', content: system });
+  if (Array.isArray(body.system) && body.system.some((b) => b && b.cache_control)) warn('cache_control');
+
+  // ── messages ──
+  const src = Array.isArray(body.messages) ? body.messages : [];
+  for (const m of src) {
+    if (!m || typeof m !== 'object') continue;
+    const blocks = typeof m.content === 'string' ? [{ type: 'text', text: m.content }] : (Array.isArray(m.content) ? m.content : []);
+    if (blocks.some((b) => b && b.cache_control)) warn('cache_control');
+
+    if (m.role === 'assistant') {
+      const texts = [];
+      const toolCalls = [];
+      for (const b of blocks) {
+        if (!b || typeof b !== 'object') continue;
+        if (b.type === 'text') { if (typeof b.text === 'string' && b.text) texts.push(b.text); }
+        else if (b.type === 'tool_use') {
+          toolCalls.push({
+            id: String(b.id || ''),
+            type: 'function',
+            function: { name: String(b.name || ''), arguments: JSON.stringify(b.input ?? {}) },
+          });
+        } else if (b.type === 'thinking' || b.type === 'redacted_thinking') warn('thinking');
+        else warn(b.type);
+      }
+      if (!texts.length && !toolCalls.length) continue; // thinking-only turn: removed (§5.2)
+      const msg = { role: 'assistant', content: texts.length ? texts.join('\n\n') : null };
+      if (toolCalls.length) msg.tool_calls = toolCalls;
+      messages.push(msg);
+      continue;
+    }
+
+    // user: tool results first (they must directly follow the assistant turn),
+    // then the remaining blocks as one user message.
+    const results = blocks.filter((b) => b && b.type === 'tool_result');
+    const rest = blocks.filter((b) => b && b.type !== 'tool_result');
+    const relocated = [];
+    for (const r of results) {
+      const { text, images } = toolResultContent(r.content, caps, warn);
+      messages.push({ role: 'tool', tool_call_id: String(r.tool_use_id || ''), content: text || (r.is_error ? 'error' : '') });
+      relocated.push(...images);
+    }
+    const parts = userParts(rest, caps, warn);
+    parts.push(...relocated);
+    if (parts.length) {
+      const prev = messages[messages.length - 1];
+      const content = compact(parts);
+      if (prev && prev.role === 'user' && typeof prev.content === 'string' && typeof content === 'string') {
+        prev.content = `${prev.content}\n\n${content}`; // adjacent after a dropped assistant turn
+      } else {
+        messages.push({ role: 'user', content });
+      }
+    }
+  }
+
+  // ── tools ──
+  const referenced = new Set();
+  for (const m of src) {
+    if (!m || !Array.isArray(m.content)) continue;
+    for (const b of m.content) {
+      if (!b || b.type !== 'tool_result' || !Array.isArray(b.content)) continue;
+      for (const r of b.content) if (r && r.type === 'tool_reference' && r.tool_name) referenced.add(String(r.tool_name));
+    }
+  }
+  let tools;
+  if (Array.isArray(body.tools) && body.tools.length) {
+    if (caps.toolCalls === false) return fail(`model ${upstreamModel} does not support tool calls`);
+    tools = [];
+    for (const t of body.tools) {
+      if (!t || typeof t !== 'object') continue;
+      // Tool search: a deferred tool is sent only once a ToolSearch result has
+      // referenced it (the Anthropic API expands tool_reference blocks against
+      // these definitions server-side; chat/completions has no such step).
+      if (t.defer_loading === true && !referenced.has(String(t.name || ''))) continue;
+      if (t.type && t.type !== 'custom' && SERVER_TOOL_RE.test(String(t.type))) {
+        return fail(`tool ${JSON.stringify(t.name || t.type)} is an Anthropic server tool and cannot run through ${upstreamModel} (openai-chat bridge)`);
+      }
+      const fn = { name: String(t.name || ''), parameters: t.input_schema && typeof t.input_schema === 'object' ? t.input_schema : { type: 'object', properties: {} } };
+      if (typeof t.description === 'string' && t.description) fn.description = t.description;
+      tools.push({ type: 'function', function: fn });
+    }
+    if (!tools.length) tools = undefined;
+  }
+
+  // ── tool_choice ──
+  let toolChoice;
+  let parallel;
+  const tc = body.tool_choice;
+  if (tc && typeof tc === 'object') {
+    if (tc.type === 'auto') toolChoice = 'auto';
+    else if (tc.type === 'any') toolChoice = 'required';
+    else if (tc.type === 'none') toolChoice = 'none';
+    else if (tc.type === 'tool' && tc.name) toolChoice = { type: 'function', function: { name: String(tc.name) } };
+    if (tc.disable_parallel_tool_use === true) parallel = false;
+  }
+
+  // ── sampling / limits ──
+  const reasoning = caps.reasoning === true;
+  const out = { model: upstreamModel, messages };
+  if (tools) out.tools = tools;
+  if (toolChoice !== undefined && tools) out.tool_choice = toolChoice;
+  if (parallel === false && tools) out.parallel_tool_calls = false;
+
+  let maxTokens = Number(body.max_tokens);
+  if (Number.isFinite(maxTokens) && maxTokens > 0) {
+    const cap = Number(caps.maxOutputTokens);
+    if (Number.isFinite(cap) && cap > 0 && maxTokens > cap) { maxTokens = cap; warn('max_tokens clamped'); }
+    if (reasoning) out.max_completion_tokens = maxTokens; else out.max_tokens = maxTokens;
+  }
+  if (typeof body.temperature === 'number') { if (reasoning) warn('temperature'); else out.temperature = body.temperature; }
+  if (typeof body.top_p === 'number') { if (reasoning) warn('top_p'); else out.top_p = body.top_p; }
+  if (body.top_k !== undefined) warn('top_k');
+  if (Array.isArray(body.stop_sequences) && body.stop_sequences.length) out.stop = body.stop_sequences.slice(0, 4);
+  if (body.metadata !== undefined) warn('metadata');
+
+  // ── reasoning ──
+  let effort;
+  if (body.thinking && typeof body.thinking === 'object' && body.thinking.type === 'enabled') {
+    effort = budgetToReasoningEffort(body.thinking.budget_tokens);
+  }
+  const oc = body.output_config;
+  if (oc && typeof oc === 'object' && typeof oc.effort === 'string' && EFFORT_TO_REASONING[oc.effort]) {
+    effort = EFFORT_TO_REASONING[oc.effort];
+  }
+  if (effort) { if (reasoning) out.reasoning_effort = effort; else warn('thinking'); }
+
+  // ── stream ──
+  if (body.stream === true) { out.stream = true; out.stream_options = { include_usage: true }; }
+
+  return { body: out, warnings };
+}

package/src/core/bridge/translate/response.mjs

@@ -0,0 +1,82 @@
+// src/core/bridge/translate/response.mjs
+// Non-streaming chat/completions response -> Anthropic message object, and the
+// local count_tokens estimate (model-bridge-design.md §5.4 buffered path, §5.9).
+
+import { mapStopReason, mapUsage, newMessageId, newToolUseId, parsesAsJson, truncatedToolNote } from './stream.mjs';
+
+/**
+ * @param {object} completion  the upstream JSON body
+ * @param {{model:string}} opts  catalog id the CLI expects back
+ */
+export function toMessagesResponse(completion, { model } = {}) {
+  const choice = completion && Array.isArray(completion.choices) ? completion.choices[0] : null;
+  const msg = (choice && choice.message) || {};
+  const content = [];
+  if (typeof msg.content === 'string' && msg.content) content.push({ type: 'text', text: msg.content });
+  const calls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+  const finish = choice ? choice.finish_reason : null;
+  let toolUses = 0;
+  for (const tc of calls) {
+    if (!tc || typeof tc !== 'object') continue;
+    const fn = tc.function || {};
+    // Cut off by `length` mid-arguments: not runnable — say so instead (see stream.mjs).
+    if (finish === 'length' && !parsesAsJson(fn.arguments)) {
+      content.push({ type: 'text', text: truncatedToolNote(String(fn.name || 'tool')) });
+      continue;
+    }
+    let input = {};
+    if (typeof fn.arguments === 'string' && fn.arguments.trim()) {
+      try { input = JSON.parse(fn.arguments); } catch { input = { _raw: fn.arguments }; }
+    }
+    content.push({ type: 'tool_use', id: tc.id || newToolUseId(), name: String(fn.name || ''), input });
+    toolUses += 1;
+  }
+  let stop = mapStopReason(finish, { emitted: content.length > 0 }) || 'end_turn';
+  if (toolUses && stop === 'end_turn') stop = 'tool_use';
+  return {
+    id: newMessageId(),
+    type: 'message',
+    role: 'assistant',
+    model: model || 'bridge',
+    content,
+    stop_reason: stop,
+    stop_sequence: null,
+    usage: mapUsage(completion && completion.usage),
+  };
+}
+
+const IMAGE_TOKENS = 1200;
+const TOOL_OVERHEAD = 20;
+
+/**
+ * Local input-token estimate for /v1/messages/count_tokens: ~4 chars per
+ * token over system + messages + serialized tools, plus per-image and
+ * per-tool constants. ±15 % is enough for the CLI's context heuristics.
+ * @param {object} body
+ * @returns {number}
+ */
+export function estimateInputTokens(body) {
+  if (!body || typeof body !== 'object') return 0;
+  let chars = 0;
+  let images = 0;
+  const walk = (content) => {
+    if (typeof content === 'string') { chars += content.length; return; }
+    if (!Array.isArray(content)) return;
+    for (const b of content) {
+      if (!b || typeof b !== 'object') continue;
+      if (b.type === 'image') images += 1;
+      else if (b.type === 'tool_result') walk(b.content);
+      else if (b.type === 'tool_use') chars += JSON.stringify(b.input ?? {}).length + (b.name || '').length;
+      else if (typeof b.text === 'string') chars += b.text.length;
+      else if (typeof b.thinking === 'string') chars += b.thinking.length;
+    }
+  };
+  walk(body.system);
+  for (const m of Array.isArray(body.messages) ? body.messages : []) if (m) walk(m.content);
+  let tools = 0;
+  if (Array.isArray(body.tools)) {
+    tools = body.tools.length;
+    chars += JSON.stringify(body.tools).length;
+  }
+  return Math.ceil(chars / 4) + images * IMAGE_TOKENS + tools * TOOL_OVERHEAD;
+}