@worca/app 1.5.0 → 1.6.0-rc.1

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

@@ -120,6 +120,37 @@ export function mapEffort(requested, capabilities = {}) {
   return atOrBelow.length ? atOrBelow[atOrBelow.length - 1] : levels[0];
 }
 
+/**
+ * The signature on a thinking block the CHAT translator emits. Chat
+ * completions returns reasoning as plain text with nothing to replay, but a
+ * thinking block needs a signature the CLI can carry back; this one tells the
+ * request side the block is ours and is dropped quietly on the next turn.
+ */
+export const CHAT_REASONING_SIGNATURE = 'worca.rsn.chat.v1';
+
+/**
+ * The reasoning text in a chat/completions delta or message: OpenRouter's
+ * `reasoning` (with `reasoning_details` beside it — the same text, so it is
+ * read only when `reasoning` is absent), vLLM / DeepSeek's
+ * `reasoning_content`. Encrypted details carry no text and are skipped.
+ * @returns {string}
+ */
+export function chatReasoningText(m) {
+  if (!m || typeof m !== 'object') return '';
+  if (typeof m.reasoning === 'string' && m.reasoning) return m.reasoning;
+  if (typeof m.reasoning_content === 'string' && m.reasoning_content) return m.reasoning_content;
+  if (Array.isArray(m.reasoning_details)) {
+    let s = '';
+    for (const d of m.reasoning_details) {
+      if (!d || typeof d !== 'object') continue;
+      if (d.type === 'reasoning.text' && typeof d.text === 'string') s += d.text;
+      else if (d.type === 'reasoning.summary' && typeof d.summary === 'string') s += d.summary;
+    }
+    return s;
+  }
+  return '';
+}
+
 const MARKER_PREFIX = 'worca.rsn.v1.';
 
 /**

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

@@ -12,7 +12,7 @@
 
 import {
   SERVER_TOOL_RE, budgetToReasoningEffort, textOf, imageUrl, flattenToolResult,
-  referencedToolNames, requestedEffort, mapEffort,
+  referencedToolNames, requestedEffort, mapEffort, CHAT_REASONING_SIGNATURE,
 } from './common.mjs';
 
 export { SERVER_TOOL_RE, budgetToReasoningEffort };
@@ -99,6 +99,9 @@ export function toChatRequest(body, { upstreamModel, capabilities = {} } = {}) {
             type: 'function',
             function: { name: String(b.name || ''), arguments: JSON.stringify(b.input ?? {}) },
           });
+        } else if (b.type === 'thinking' && b.signature === CHAT_REASONING_SIGNATURE) {
+          // Our own reasoning echoed back: chat completions takes no reasoning
+          // input, and this is the expected case, not a degradation to report.
         } else if (b.type === 'thinking' || b.type === 'redacted_thinking') warn('thinking');
         else warn(b.type);
       }

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

@@ -3,6 +3,7 @@
 // local count_tokens estimate (model-bridge-design.md §5.4 buffered path, §5.9).
 
 import { mapStopReason, mapUsage, newMessageId, newToolUseId, parsesAsJson, truncatedToolNote } from './stream.mjs';
+import { CHAT_REASONING_SIGNATURE, chatReasoningText } from './common.mjs';
 
 /**
  * @param {object} completion  the upstream JSON body
@@ -12,6 +13,8 @@ export function toMessagesResponse(completion, { model } = {}) {
   const choice = completion && Array.isArray(completion.choices) ? completion.choices[0] : null;
   const msg = (choice && choice.message) || {};
   const content = [];
+  const reasoning = chatReasoningText(msg);
+  if (reasoning) content.push({ type: 'thinking', thinking: reasoning, signature: CHAT_REASONING_SIGNATURE });
   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;

package/src/core/bridge/translate/schema-keywords.mjs

@@ -0,0 +1,75 @@
+// src/core/bridge/translate/schema-keywords.mjs
+// Some OpenAI-compatible upstreams compile tool parameter schemas into a decoding
+// grammar that knows only part of JSON Schema, and refuse the whole request over
+// one validation keyword (OpenRouter's ModelRun on qwen3.8-27b:free: `tool
+// "ListAgents" parameter schema: parameter "channel": unsupported schema keyword
+// "maxLength"`). The CLI's own tools carry such keywords and worca cannot edit
+// them, so the bridge learns the keyword from the refusal, drops it from every
+// tool schema, and retries. Validation keywords only narrow what the model may
+// send; the CLI still validates every tool call against the full schema.
+
+/** The keyword an upstream names when it refuses a tool schema; null otherwise. */
+const UNSUPPORTED_KEYWORD_RE = /unsupported (?:json )?schema keyword[:\s]+["'`]?([A-Za-z$][\w$-]*)/i;
+export function unsupportedSchemaKeyword(message) {
+  const m = UNSUPPORTED_KEYWORD_RE.exec(String(message ?? ''));
+  return m ? m[1] : null;
+}
+
+// Where sub-schemas live. A `properties` / `$defs` map holds schemas under
+// arbitrary names, so a property NAMED like a keyword is never dropped.
+const SCHEMA_MAPS = ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas'];
+const SCHEMA_ONE = ['items', 'additionalProperties', 'additionalItems', 'contains', 'not', 'if', 'then', 'else', 'propertyNames', 'unevaluatedProperties', 'unevaluatedItems'];
+const SCHEMA_LIST = ['anyOf', 'oneOf', 'allOf', 'prefixItems'];
+
+/** A copy of `schema` without the `drop` keywords, at every depth. */
+export function dropSchemaKeywords(schema, drop) {
+  if (Array.isArray(schema)) return schema.map((s) => dropSchemaKeywords(s, drop));
+  if (!schema || typeof schema !== 'object') return schema;
+  const out = {};
+  for (const [k, v] of Object.entries(schema)) {
+    if (drop.has(k)) continue;
+    if (SCHEMA_MAPS.includes(k) && v && typeof v === 'object' && !Array.isArray(v)) {
+      out[k] = Object.fromEntries(Object.entries(v).map(([name, s]) => [name, dropSchemaKeywords(s, drop)]));
+    } else if (SCHEMA_ONE.includes(k) || SCHEMA_LIST.includes(k)) {
+      out[k] = dropSchemaKeywords(v, drop);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+// A refusal about one tool's schema that no keyword drop can fix (the CLI's
+// Workflow tool takes `args` as any JSON value: "more than one JSON reading of
+// the same emitted value"). The bridge leaves that tool out for the model.
+const REFUSED_TOOL_RE = /\btool ["'`]([^"'`]+)["'`] parameter schema\b/i;
+/** The tool a grammar refusal names; null otherwise. */
+export function refusedToolName(message) {
+  const m = REFUSED_TOOL_RE.exec(String(message ?? ''));
+  return m ? m[1] : null;
+}
+
+/** A translated request body without the `names` tools (chat and Responses shapes). Never mutates `body`. */
+export function withoutTools(body, names) {
+  if (!body || !Array.isArray(body.tools) || !names || !names.size) return body;
+  const toolName = (t) => (t && t.function ? t.function.name : t && t.name);
+  return { ...body, tools: body.tools.filter((t) => !names.has(toolName(t))) };
+}
+
+/**
+ * A translated request body with `drop` removed from every tool's parameter
+ * schema: chat/completions (`tools[].function.parameters`) and the Responses API
+ * (`tools[].parameters`). Never mutates `body`; a body without tools, or an
+ * empty `drop`, comes back as is.
+ */
+export function withToolSchemaKeywordsDropped(body, drop) {
+  if (!body || !Array.isArray(body.tools) || !drop || !drop.size) return body;
+  const tools = body.tools.map((t) => {
+    if (t && t.function && t.function.parameters) {
+      return { ...t, function: { ...t.function, parameters: dropSchemaKeywords(t.function.parameters, drop) } };
+    }
+    if (t && t.parameters) return { ...t, parameters: dropSchemaKeywords(t.parameters, drop) };
+    return t;
+  });
+  return { ...body, tools };
+}

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

@@ -12,6 +12,7 @@
 // cost of a tool block appearing a moment later than its first delta.
 
 import { randomBytes } from 'node:crypto';
+import { CHAT_REASONING_SIGNATURE, chatReasoningText } from './common.mjs';
 
 /** finish_reason -> stop_reason (§5.5). */
 export function mapStopReason(finish, { emitted = false } = {}) {
@@ -25,6 +26,9 @@ export function mapStopReason(finish, { emitted = false } = {}) {
   }
 }
 
+/** The overloaded_error a turn with no visible output becomes (ChatStreamTranslator#finish). */
+export const EMPTY_TURN_MESSAGE = 'upstream returned no output (no text or tool call) — an upstream glitch; retrying';
+
 /** chat/completions usage -> Anthropic usage (§5.8). */
 export function mapUsage(usage) {
   const u = usage && typeof usage === 'object' ? usage : {};
@@ -60,12 +64,15 @@ export class ChatStreamTranslator {
     this.started = false;
     this.nextIndex = 0;
     this.textIndex = null;          // open text block index, or null
+    this.thinkIndex = null;         // open thinking block index, or null
     this.tools = new Map();         // tool_calls index -> {id, name, args, order}
     this.toolOrder = [];
     this.flushedTools = 0;          // how many of toolOrder have been emitted
     this.finishReason = null;
     this.usage = null;
+    this.costUsd = null;            // the upstream's own USD cost (OpenRouter usage.cost), when reported
     this.emittedAny = false;
+    this.sawText = false;           // any visible text (thinking is not visible output)
     this.contentFilter = false;
   }
 
@@ -92,6 +99,17 @@ export class ChatStreamTranslator {
     return [{ event: 'content_block_stop', data: { type: 'content_block_stop', index: i } }];
   }
 
+  /** Close the open thinking block, signing it as ours (common.mjs#CHAT_REASONING_SIGNATURE). */
+  _closeThinking() {
+    if (this.thinkIndex === null) return [];
+    const index = this.thinkIndex;
+    this.thinkIndex = null;
+    return [
+      { event: 'content_block_delta', data: { type: 'content_block_delta', index, delta: { type: 'signature_delta', signature: CHAT_REASONING_SIGNATURE } } },
+      { event: 'content_block_stop', data: { type: 'content_block_stop', index } },
+    ];
+  }
+
   /** Emit every buffered tool call not yet emitted (in first-seen order). */
   _flushTools(upTo = this.toolOrder.length) {
     const out = [];
@@ -119,12 +137,31 @@ export class ChatStreamTranslator {
       out.push({ event: 'error', data: { type: 'error', error: { type: 'api_error', message: `upstream stream error: ${msg}` } } });
       return out;
     }
-    if (chunk.usage && typeof chunk.usage === 'object') this.usage = chunk.usage;
+    if (chunk.usage && typeof chunk.usage === 'object') {
+      this.usage = chunk.usage;
+      const cost = Number(chunk.usage.cost);
+      if (chunk.usage.cost != null && Number.isFinite(cost) && cost >= 0) this.costUsd = cost;
+    }
     const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : null;
     if (!choice) return out;
     const delta = choice.delta || {};
 
+    // Reasoning streams first on a reasoning model; one live thinking block per
+    // contiguous run, closed before any text or tool block starts.
+    const reasoning = chatReasoningText(delta);
+    if (reasoning) {
+      if (this.thinkIndex === null) {
+        out.push(...this._closeText());
+        if (this.toolOrder.length > this.flushedTools) out.push(...this._flushTools());
+        this.thinkIndex = this.nextIndex++;
+        out.push({ event: 'content_block_start', data: { type: 'content_block_start', index: this.thinkIndex, content_block: { type: 'thinking', thinking: '', signature: '' } } });
+      }
+      out.push({ event: 'content_block_delta', data: { type: 'content_block_delta', index: this.thinkIndex, delta: { type: 'thinking_delta', thinking: reasoning } } });
+      this.emittedAny = true;
+    }
+
     if (typeof delta.content === 'string' && delta.content.length) {
+      out.push(...this._closeThinking());
       // Text after tool calls: the tools are complete — flush them first.
       if (this.toolOrder.length > this.flushedTools) { out.push(...this._closeText(), ...this._flushTools()); }
       if (this.textIndex === null) {
@@ -133,6 +170,7 @@ export class ChatStreamTranslator {
       }
       out.push({ event: 'content_block_delta', data: { type: 'content_block_delta', index: this.textIndex, delta: { type: 'text_delta', text: delta.content } } });
       this.emittedAny = true;
+      this.sawText = true;
     }
 
     if (Array.isArray(delta.tool_calls)) {
@@ -142,7 +180,7 @@ export class ChatStreamTranslator {
         let t = this.tools.get(key);
         if (!t) {
           // A new tool call: text before it is complete; earlier tool calls are complete.
-          out.push(...this._closeText());
+          out.push(...this._closeThinking(), ...this._closeText());
           out.push(...this._flushTools());
           t = { id: tc.id || newToolUseId(), name: '', args: '' };
           this.tools.set(key, t);
@@ -164,6 +202,7 @@ export class ChatStreamTranslator {
   /** End of stream: close blocks, emit message_delta + message_stop. */
   finish() {
     const out = this._start();
+    out.push(...this._closeThinking());
     // Cut off mid tool call (finish_reason `length` — the output cap, or on a
     // small local model the context window filling up): the last call's
     // arguments are unterminated JSON. Forwarded, the CLI rejects it as an
@@ -192,8 +231,15 @@ export class ChatStreamTranslator {
     out.push(...this._closeText());
     const hadTools = this.toolOrder.length > 0;
     let stop = mapStopReason(this.finishReason, { emitted: this.emittedAny });
-    if (stop === null) {
-      out.push({ event: 'error', data: { type: 'error', error: { type: 'api_error', message: 'upstream stream ended without content or finish_reason' } } });
+    // No text and no tool call — nothing at all, or reasoning only — on a turn
+    // that ended normally or not at all: an upstream glitch (OpenRouter's free
+    // Nvidia endpoint does it intermittently). Forwarded as an empty turn the CLI
+    // nudges "no visible output" and exits with no cause; as overloaded_error it
+    // retries with backoff, and a run that still fails names the reason. A length
+    // cut and a content filter keep their stop reasons: those are the model's.
+    const visible = hadTools || this.sawText;
+    if (stop === null || (!visible && (this.finishReason === 'stop' || this.finishReason == null))) {
+      out.push({ event: 'error', data: { type: 'error', error: { type: 'overloaded_error', message: EMPTY_TURN_MESSAGE } } });
       return out;
     }
     if (hadTools && stop === 'end_turn') stop = 'tool_use';

package/src/core/bridge/upstream.mjs

@@ -12,13 +12,29 @@ import { ResponsesStreamTranslator, toMessagesResponseFromResponses } from './tr
 import { mapUpstreamError, mapNetworkError, bridgeErrors, anthropicError, isFailedResponseOverflow, PAYLOAD_CEILING_BYTES } from './errors.mjs';
 import { copilotToken, invalidateCopilotToken, copilotApiHost, copilotHeaders, bodyHasImage, requestInitiator } from './providers/copilot.mjs';
 import { upstreamSettings, providerReadiness } from './registry.mjs';
+import { brokerEnabled, slotBaseUrl } from '../broker-client.mjs';
+import { routeBridgedUpstream } from '../broker-routing.mjs';
 import { KeyedSemaphore } from './semaphore.mjs';
-import { recordBridgeCall, recordBridgeError } from './telemetry.mjs';
+import { recordBridgeCall, recordBridgeError, recordBridgeCost } from './telemetry.mjs';
+import { isOpenRouter, adaptOpenRouterChatBody, OPENROUTER_HEADERS } from './openrouter.mjs';
+import { isOpenRouterFree, keyAccount } from '../openrouter-free.mjs';
+import { unsupportedSchemaKeyword, withToolSchemaKeywordsDropped, refusedToolName, withoutTools } from './translate/schema-keywords.mjs';
 
 export const semaphore = new KeyedSemaphore();
 const PING_INTERVAL_MS = 15_000;
 const warned = new Set();
 
+// What an upstream model's tool grammar refused (translate/schema-keywords.mjs):
+// schema keywords to drop, and whole tools no drop can fix. Learned per provider
+// + base URL + upstream model for the life of the process, so only the first
+// request after a boot pays each refusal round trip.
+const schemaDrops = new Map();   // key -> { keywords:Set<string>, tools:Set<string> }
+const MAX_SCHEMA_RETRIES = 6;
+export function _resetSchemaKeywordDrops() { schemaDrops.clear(); }
+function applySchemaDrops(body, d) {
+  return d ? withoutTools(withToolSchemaKeywordsDropped(body, d.keywords), d.tools) : body;
+}
+
 /** Once-per-process warning (dropped fields, queue notices). */
 function warnOnce(key, line, log) {
   if (warned.has(key)) return;
@@ -32,6 +48,19 @@ export function _resetBridgeWarnings() { warned.clear(); }
  * @returns {Promise<{url:string, headers:object, provider:string, retryAuth?:() => Promise<object>}>}
  */
 async function prepareUpstream(us, body, { fetch: f, requestHeaders }) {
+  // Credential broker: the request goes to <broker>/p/<slot>… with the spawn's token; the
+  // broker adds the person's key (or runs the Copilot exchange). us.baseUrl keeps the real
+  // provider URL: dialect decisions (OpenRouter's body and headers) still key on it.
+  if (us.brokerToken && us.provider === 'copilot') {
+    const initiator = requestInitiator(body);
+    const path = us.api === 'anthropic' ? '/v1/messages' : us.api === 'openai-responses' ? '/responses' : '/chat/completions';
+    const headers = { ...copilotHeaders(us.brokerToken, { vision: bodyHasImage(body), initiator }), ...us.headers };
+    if (us.api === 'anthropic') {
+      headers['anthropic-version'] = requestHeaders['anthropic-version'] || '2023-06-01';
+      if (requestHeaders['anthropic-beta']) headers['anthropic-beta'] = requestHeaders['anthropic-beta'];
+    }
+    return { url: `${us.brokerBase}${path}`, headers, provider: 'copilot', initiator };
+  }
   if (us.provider === 'copilot') {
     const initiator = requestInitiator(body);
     const vision = bodyHasImage(body);
@@ -51,11 +80,11 @@ async function prepareUpstream(us, body, { fetch: f, requestHeaders }) {
   }
   const initiator = requestInitiator(body);
   if (us.api === 'anthropic') {
-    const base = (us.baseUrl || 'https://api.anthropic.com').replace(/\/+$/, '');
+    const base = (us.brokerBase || us.baseUrl || 'https://api.anthropic.com').replace(/\/+$/, '');
     const url = /\/v1$/.test(base) ? `${base}/messages` : `${base}/v1/messages`;
     const headers = {
       'content-type': 'application/json',
-      'x-api-key': us.apiKey,
+      'x-api-key': us.brokerToken || us.apiKey,
       'anthropic-version': requestHeaders['anthropic-version'] || '2023-06-01',
       ...(requestHeaders['anthropic-beta'] ? { 'anthropic-beta': requestHeaders['anthropic-beta'] } : {}),
       ...us.headers,
@@ -63,9 +92,15 @@ async function prepareUpstream(us, body, { fetch: f, requestHeaders }) {
     return { url, headers, provider: us.provider, initiator };
   }
   const base = (us.baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '');
+  const key = us.brokerToken || us.apiKey;
   return {
-    url: `${base}/${us.api === 'openai-responses' ? 'responses' : 'chat/completions'}`,
-    headers: { 'content-type': 'application/json', ...(us.apiKey ? { authorization: `Bearer ${us.apiKey}` } : {}), ...us.headers },
+    url: `${(us.brokerBase || base).replace(/\/+$/, '')}/${us.api === 'openai-responses' ? 'responses' : 'chat/completions'}`,
+    headers: {
+      'content-type': 'application/json',
+      ...(key ? { authorization: `Bearer ${key}` } : {}),
+      ...(isOpenRouter(base) ? OPENROUTER_HEADERS : {}),   // an entry's own headers still win
+      ...us.headers,
+    },
     provider: us.provider,
     initiator,
   };
@@ -83,7 +118,7 @@ async function prepareUpstream(us, body, { fetch: f, requestHeaders }) {
  * @param {(line:string)=>void} [args.log]
  * @param {object} reply  { status(code, headers), write(chunk), end(), json(status, obj, headers?) }
  */
-export async function handleMessages({ entry, body, requestHeaders = {}, tag = '', signal, fetch: f = globalThis.fetch, log }, reply) {
+export async function handleMessages({ entry, body, requestHeaders = {}, tag = '', signal, fetch: f = globalThis.fetch, log, brokerToken = null }, reply) {
   const upstream = entry.upstream;
   const ready = providerReadiness(upstream);
   if (!ready.ok) {
@@ -92,6 +127,31 @@ export async function handleMessages({ entry, body, requestHeaders = {}, tag = '
     return reply.json(e.status, e.body);
   }
   const us = upstreamSettings(upstream);
+  // Credential broker: route through the model's slot with the spawn's token.
+  if (brokerEnabled()) {
+    const route = routeBridgedUpstream(upstream);
+    if (route.error) {
+      const e = anthropicError(403, 'permission_error', `worca-broker: ${route.error}`);
+      recordBridgeError({ tag, catalogId: entry.id, provider: us.provider, status: e.status, message: e.body.error.message });
+      return reply.json(e.status, e.body);
+    }
+    if (!route.keyless) {
+      if (!brokerToken) {
+        const e = anthropicError(403, 'authentication_error', 'worca-broker: this spawn has no broker token');
+        recordBridgeError({ tag, catalogId: entry.id, provider: us.provider, status: e.status, message: e.body.error.message });
+        return reply.json(e.status, e.body);
+      }
+      us.brokerToken = brokerToken;
+      us.brokerBase = `${slotBaseUrl(route.slot)}${route.prefix || ''}`;
+      us.apiKey = '';
+      us.githubToken = null;
+    }
+  }
+
+  // An OpenRouter `:free` model: every call spends one of the day's free requests of the
+  // key it goes out with (openrouter-free.mjs). Through the broker that key is unknown here.
+  const free = isOpenRouterFree(us);
+  const account = free && !us.brokerToken ? keyAccount(us.apiKey) : null;
 
   // Body → upstream body.
   let outBody;
@@ -111,9 +171,11 @@ export async function handleMessages({ entry, body, requestHeaders = {}, tag = '
         : `${w} has no ${responses ? 'Responses API' : 'chat/completions'} equivalent — dropped`;
       warnOnce(`${entry.id}:${w}`, `[worca] bridge: model ${JSON.stringify(entry.id)}: ${line}`, log);
     }
-    outBody = t.body;
+    outBody = !responses && isOpenRouter(us.baseUrl) ? adaptOpenRouterChatBody(t.body, us) : t.body;
   }
-  const payload = JSON.stringify(outBody);
+  const dropKey = `${us.provider}|${us.baseUrl || ''}|${us.model}`;
+  if (us.api !== 'anthropic') outBody = applySchemaDrops(outBody, schemaDrops.get(dropKey));
+  let payload = JSON.stringify(outBody);
   if (Buffer.byteLength(payload) > PAYLOAD_CEILING_BYTES) {
     const e = bridgeErrors.tooLarge();
     return reply.json(e.status, e.body);
@@ -142,7 +204,7 @@ export async function handleMessages({ entry, body, requestHeaders = {}, tag = '
       recordBridgeError({ tag, catalogId: entry.id, provider: us.provider, status: e.status, message: e.body.error.message });
       return reply.json(e.status, e.body);
     }
-    recordBridgeCall({ tag, catalogId: entry.id, provider: us.provider, api: us.api, initiator: prep.initiator });
+    recordBridgeCall({ tag, catalogId: entry.id, provider: us.provider, api: us.api, initiator: prep.initiator, free, account });
 
     const doFetch = (p) => f(p.url, { method: 'POST', headers: p.headers, body: payload, signal });
     let res;
@@ -152,6 +214,28 @@ export async function handleMessages({ entry, body, requestHeaders = {}, tag = '
         const again = await prep.retryAuth();
         res = await doFetch(again);
       }
+      // A tool schema the upstream's grammar cannot take: drop the keyword it
+      // names from every tool schema — or, when no keyword is named, leave that
+      // one tool out — remember it for this model, and retry. Once per new
+      // keyword / tool, so a refusal that survives the fix is answered, not looped.
+      for (let i = 0; i < MAX_SCHEMA_RETRIES && res.status === 400 && us.api !== 'anthropic' && Array.isArray(outBody.tools) && outBody.tools.length; i++) {
+        const text = await res.clone().text().catch(() => '');
+        const msg = mapUpstreamError(400, text, { provider: us.provider }).body.error.message;
+        const kw = unsupportedSchemaKeyword(msg);
+        const tool = kw ? null : refusedToolName(msg);
+        const d = schemaDrops.get(dropKey) || { keywords: new Set(), tools: new Set() };
+        if (kw && !d.keywords.has(kw)) {
+          d.keywords.add(kw);
+          warnOnce(`schema-kw:${dropKey}:${kw}`, `[worca] bridge: ${us.provider} model ${JSON.stringify(us.model)} refuses the tool-schema keyword "${kw}" — dropping it from tool schemas`, log);
+        } else if (tool && !d.tools.has(tool)) {
+          d.tools.add(tool);
+          warnOnce(`schema-tool:${dropKey}:${tool}`, `[worca] bridge: ${us.provider} model ${JSON.stringify(us.model)} cannot take the schema of tool "${tool}" — leaving it out of this model's requests`, log);
+        } else break;
+        schemaDrops.set(dropKey, d);
+        outBody = applySchemaDrops(outBody, d);
+        payload = JSON.stringify(outBody);
+        res = await doFetch(prep);
+      }
     } catch (err) {
       if (signal && signal.aborted) return reply.end();
       const e = mapNetworkError(err, { provider: us.provider });
@@ -162,7 +246,7 @@ export async function handleMessages({ entry, body, requestHeaders = {}, tag = '
     if (!res.ok) {
       const text = await res.text().catch(() => '');
       const e = mapUpstreamError(res.status, text, { provider: us.provider, retryAfter: res.headers.get('retry-after') });
-      recordBridgeError({ tag, catalogId: entry.id, provider: us.provider, status: res.status, message: e.body.error.message });
+      recordBridgeError({ tag, catalogId: entry.id, provider: us.provider, status: res.status, message: e.body.error.message, account });
       if (log) log(`[worca] bridge: ${us.provider} answered ${res.status} for ${JSON.stringify(entry.id)}: ${e.body.error.message}`);
       return reply.json(e.status, e.body, e.headers);
     }
@@ -188,6 +272,7 @@ export async function handleMessages({ entry, body, requestHeaders = {}, tag = '
         recordBridgeError({ tag, catalogId: entry.id, provider: us.provider, status: 200, message: e.body.error.message });
         return reply.json(e.status, e.body);
       }
+      if (us.api === 'openai-chat') recordBridgeCost({ tag, costUsd: j && j.usage ? j.usage.cost : undefined });
       return reply.json(200, us.api === 'openai-responses'
         ? toMessagesResponseFromResponses(j, { model: entry.id, upstreamModel: us.model })
         : toMessagesResponse(j, { model: entry.id }));
@@ -197,14 +282,13 @@ export async function handleMessages({ entry, body, requestHeaders = {}, tag = '
     const translator = us.api === 'openai-responses'
       ? new ResponsesStreamTranslator({ model: entry.id, upstreamModel: us.model })
       : new ChatStreamTranslator({ model: entry.id });
-    // A Responses stream can fail mid-flight (response.failed / error): book it
-    // like an upstream refusal, so the Test button can name the reason. The
-    // chat stream's events pass through untouched.
+    // A stream can fail mid-flight (a Responses response.failed / error, a chat
+    // stream cut short or ending with no output): book it like an upstream
+    // refusal, so the Test button — and a run whose CLI exits without an API
+    // Error line (claude-runner's bridge-failure fallback) — can name the reason.
     const booked = (events) => {
-      if (us.api === 'openai-responses') {
-        for (const e of events) {
-          if (e.event === 'error') recordBridgeError({ tag, catalogId: entry.id, provider: us.provider, status: 200, message: e.data.error.message });
-        }
+      for (const e of events) {
+        if (e.event === 'error') recordBridgeError({ tag, catalogId: entry.id, provider: us.provider, status: 200, message: e.data.error.message });
       }
       return events;
     };
@@ -226,6 +310,7 @@ export async function handleMessages({ entry, body, requestHeaders = {}, tag = '
         for (const obj of parser.end()) reply.write(serializeSse(booked(translator.push(obj))));
       }
       reply.write(serializeSse(booked(translator.finish())));
+      if (translator.costUsd != null) recordBridgeCost({ tag, costUsd: translator.costUsd });
     } finally {
       clearInterval(ping);
     }

package/src/core/broker-boot.mjs

@@ -0,0 +1,57 @@
+// src/core/broker-boot.mjs
+// The server's boot check for the credential broker (plans/credential-broker-design.html
+// §6.7): configuration, the credential guard (K1), then the broker itself. Returns the
+// problems instead of exiting, so ui/server.mjs prints them and exits 78 in one place.
+import { brokerConfig, connectBroker } from './broker-client.mjs';
+import { findLocalCredentials, credentialFiles, guardMessage } from './broker-guard.mjs';
+import { listGlobalModels, readSettings } from './settings.mjs';
+import { listPluginModels } from './plugin-models.mjs';
+
+/**
+ * @param {{env?:object, shared?:boolean, log?:Function, waitMs?:number}} o
+ *   shared: several people sign in (Cloudflare Access or a trusted identity header)
+ * @returns {Promise<{on:boolean, fatal:string[], warnings:string[], info?:object}>}
+ */
+export async function checkBrokerAtBoot({ env = process.env, shared = false, log = console.log, waitMs = 60_000 } = {}) {
+  const c = brokerConfig(env);
+  if (!c) {
+    const warnings = [];
+    const fatal = [];
+    if (shared) {
+      const msg = 'several people sign in to this worca, but the credential broker is off: everyone shares the model key in worca\'s environment, and agents can read it. See docs/credential-broker.md.';
+      if (/^(1|true|yes|on)$/i.test(String(env.WORCA_BROKER_REQUIRED || ''))) fatal.push(`${msg} (WORCA_BROKER_REQUIRED is set)`);
+      else warnings.push(msg);
+    }
+    return { on: false, fatal, warnings };
+  }
+  if (c.error) return { on: true, fatal: [c.error], warnings: [] };
+
+  // The broker first: its slots say which remote endpoints are reachable through it.
+  let info;
+  try {
+    info = await connectBroker({ waitMs, log });
+  } catch (err) {
+    return { on: true, fatal: [`${err.message}. Is the broker running at ${c.url}, and does WORCA_BROKER_SECRET match on both sides?`], warnings: [] };
+  }
+
+  let models = [];
+  let providers = {};
+  try { models = [...listGlobalModels(), ...listPluginModels()]; } catch { /* unreadable settings: nothing to check */ }
+  try { providers = readSettings().providers || {}; } catch { /* same */ }
+  const findings = findLocalCredentials({
+    env,
+    files: credentialFiles([env.HOME, env.WORCA_AGENT_HOME]),
+    models,
+    providers,
+    brokerUrl: c.url,
+    slotOrigins: (info.slots || []).filter((s) => s.auth !== 'copilot' && s.auth !== 'github-user').map((s) => s.upstream),
+  });
+  if (findings.length) return { on: true, fatal: [guardMessage(findings, info.publicUrl)], warnings: [] };
+  const warnings = [];
+  const asPerson = String(env.WORCA_GH_AS_PERSON || '').trim().toLowerCase();
+  if (asPerson && !['prefer', 'required', 'off', '0'].includes(asPerson)) warnings.push(`WORCA_GH_AS_PERSON must be prefer or required (got ${JSON.stringify(asPerson)}); pushes use worca's own GitHub credential`);
+  if ((asPerson === 'prefer' || asPerson === 'required') && !(info.slots || []).some((s) => s.auth === 'github-user')) {
+    warnings.push(`WORCA_GH_AS_PERSON=${asPerson}, but the broker has no GitHub slot (set WORCA_BROKER_GITHUB_CLIENT_ID on it)${asPerson === 'required' ? ': every push will fail' : ''}`);
+  }
+  return { on: true, fatal: [], warnings, info };
+}