@worca/app 1.4.0 → 1.5.0-rc.3

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

@@ -0,0 +1,144 @@
+// src/core/bridge/translate/common.mjs
+// Helpers the two translated wire protocols share — openai-chat
+// (request.mjs) and openai-responses (responses-request.mjs /
+// responses-stream.mjs): text, image and tool_result flattening, the
+// tool-search references, the effort a request asks for and how it maps to
+// the model's own levels, and the reasoning marker the Responses translator
+// round-trips through the thinking blocks the CLI echoes back
+// (2026-09-23-bridge-openai-responses-design.md §7–§8). Pure.
+
+import { Buffer } from 'node:buffer';
+import { REASONING_EFFORT_LEVELS } from '../../model-env.mjs';
+
+/** Anthropic server-side tool types — no OpenAI equivalent (§5.3). */
+export const SERVER_TOOL_RE = /^(web_search|web_fetch|computer|text_editor|bash|code_execution|memory)(_\d{8})?$/;
+
+/** Text of a block list (text blocks only), joined with blank lines. */
+export 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's URL: a data URI for a base64 source, the URL for a url source, else null. */
+export function imageUrl(block) {
+  const src = (block && block.source) || {};
+  if (src.type === 'base64' && src.media_type && src.data) return `data:${src.media_type};base64,${src.data}`;
+  if (src.type === 'url' && typeof src.url === 'string') return src.url;
+  return null;
+}
+
+/**
+ * Flatten a tool_result's content to text; image URLs come back separately
+ * (neither OpenAI protocol takes an image inside a tool output — the
+ * translators relocate them to a following user message, §5.2).
+ * @returns {{text:string, imageUrls:string[]}}
+ */
+export function flattenToolResult(content, caps, warn) {
+  if (typeof content === 'string') return { text: content, imageUrls: [] };
+  if (!Array.isArray(content)) return { text: content == null ? '' : String(content), imageUrls: [] };
+  const texts = [];
+  const imageUrls = [];
+  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 u = imageUrl(b); if (u) imageUrls.push(u); else warn('image'); }
+    } else warn(b.type);
+  }
+  return { text: texts.join('\n\n'), imageUrls };
+}
+
+/**
+ * The deferred tools a ToolSearch result has loaded: the names in
+ * tool_reference blocks. The Anthropic API expands them against the request's
+ * `defer_loading` tools server-side; the OpenAI protocols have no such step, so
+ * the translators send a deferred tool only once it is referenced.
+ */
+export function referencedToolNames(messages) {
+  const referenced = new Set();
+  for (const m of Array.isArray(messages) ? messages : []) {
+    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));
+    }
+  }
+  return referenced;
+}
+
+/** Thinking budget bands -> 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';
+}
+
+const REQUESTABLE_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+
+/**
+ * The effort a Messages request asks for: `output_config.effort` (the CLI's
+ * --effort) wins over an enabled thinking budget's band; `thinking:
+ * {type:'adaptive'}` alone asks for nothing. null when neither is present.
+ */
+export function requestedEffort(body) {
+  if (!body || typeof body !== 'object') return null;
+  let effort = null;
+  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' && REQUESTABLE_EFFORTS.has(oc.effort)) effort = oc.effort;
+  return effort;
+}
+
+/** Requested effort -> upstream effort when the model lists no levels (the chat bridge's original table). */
+const DEFAULT_EFFORT_MAP = { low: 'low', medium: 'medium', high: 'high', xhigh: 'high', max: 'high' };
+
+/**
+ * Map a requested effort onto the upstream's reasoning effort (spec §7.4).
+ * With `capabilities.reasoningEfforts`: the highest listed level at or below
+ * the request, else the lowest listed level above it (`none` is never
+ * chosen). Without a list: DEFAULT_EFFORT_MAP.
+ * @returns {string|null}
+ */
+export function mapEffort(requested, capabilities = {}) {
+  if (!requested) return null;
+  const listed = capabilities && Array.isArray(capabilities.reasoningEfforts) ? capabilities.reasoningEfforts : [];
+  const levels = REASONING_EFFORT_LEVELS.filter((e) => e !== 'none' && listed.includes(e));
+  if (!levels.length) return DEFAULT_EFFORT_MAP[requested] || 'medium';
+  const want = REASONING_EFFORT_LEVELS.indexOf(requested);
+  const atOrBelow = levels.filter((e) => REASONING_EFFORT_LEVELS.indexOf(e) <= want);
+  return atOrBelow.length ? atOrBelow[atOrBelow.length - 1] : levels[0];
+}
+
+const MARKER_PREFIX = 'worca.rsn.v1.';
+
+/**
+ * The reasoning marker: what the Responses translator puts in a thinking
+ * block's `signature` (or a redacted_thinking block's `data`) so the CLI
+ * carries the model's encrypted reasoning to the next request (spec §8).
+ * `<prefix><base64url(upstream model)>.<encrypted_content>`.
+ */
+export function encodeReasoningMarker(upstreamModel, encrypted) {
+  return `${MARKER_PREFIX}${Buffer.from(String(upstreamModel || ''), 'utf8').toString('base64url')}.${encrypted}`;
+}
+
+/** Parse a reasoning marker; null for anything else (a real Claude signature, a truncated value). */
+export function decodeReasoningMarker(s) {
+  if (typeof s !== 'string' || !s.startsWith(MARKER_PREFIX)) return null;
+  const rest = s.slice(MARKER_PREFIX.length);
+  const dot = rest.indexOf('.');
+  if (dot <= 0 || dot === rest.length - 1) return null;
+  const model = Buffer.from(rest.slice(0, dot), 'base64url').toString('utf8');
+  if (!model) return null;
+  return { model, encrypted: rest.slice(dot + 1) };
+}

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

@@ -8,42 +8,19 @@
 //
 // Scope is what Claude Code actually sends. Reference implementations for the
 // edge cases: ericc-ch/copilot-api, voidsteed/copilot-proxy-api (both MIT).
+// Helpers shared with the Responses translator live in common.mjs.
 
-/** 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})?$/;
+import {
+  SERVER_TOOL_RE, budgetToReasoningEffort, textOf, imageUrl, flattenToolResult,
+  referencedToolNames, requestedEffort, mapEffort,
+} from './common.mjs';
 
-/** Efforts (CLI `--effort` -> `output_config.effort`) -> OpenAI reasoning_effort. */
-const EFFORT_TO_REASONING = { low: 'low', medium: 'medium', high: 'high', xhigh: 'high', max: 'high' };
+export { SERVER_TOOL_RE, budgetToReasoningEffort };
 
-/** 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). */
+/** An Anthropic image block -> chat/completions image_url part (data URI), or null. */
 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;
+  const url = imageUrl(block);
+  return url ? { type: 'image_url', image_url: { url } } : null;
 }
 
 /**
@@ -81,29 +58,10 @@ function compact(parts) {
   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
+ * @param {{upstreamModel:string, capabilities?:{toolCalls?:boolean, vision?:boolean, reasoning?:boolean, maxOutputTokens?:number, reasoningEfforts?:string[]}}} opts
  * @returns {{body?:object, warnings:string[], error?:{type:string,message:string}}}
  */
 export function toChatRequest(body, { upstreamModel, capabilities = {} } = {}) {
@@ -157,9 +115,9 @@ export function toChatRequest(body, { upstreamModel, capabilities = {} } = {}) {
     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);
+      const { text, imageUrls } = flattenToolResult(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);
+      relocated.push(...imageUrls.map((url) => ({ type: 'image_url', image_url: { url } })));
     }
     const parts = userParts(rest, caps, warn);
     parts.push(...relocated);
@@ -175,14 +133,7 @@ export function toChatRequest(body, { upstreamModel, capabilities = {} } = {}) {
   }
 
   // ── 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));
-    }
-  }
+  const referenced = referencedToolNames(src);
   let tools;
   if (Array.isArray(body.tools) && body.tools.length) {
     if (caps.toolCalls === false) return fail(`model ${upstreamModel} does not support tool calls`);
@@ -190,8 +141,7 @@ export function toChatRequest(body, { upstreamModel, capabilities = {} } = {}) {
     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).
+      // referenced it (common.mjs#referencedToolNames).
       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)`);
@@ -235,15 +185,8 @@ export function toChatRequest(body, { upstreamModel, capabilities = {} } = {}) {
   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'); }
+  const effort = requestedEffort(body);
+  if (effort) { if (reasoning) out.reasoning_effort = mapEffort(effort, caps); else warn('thinking'); }
 
   // ── stream ──
   if (body.stream === true) { out.stream = true; out.stream_options = { include_usage: true }; }

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

@@ -0,0 +1,185 @@
+// src/core/bridge/translate/responses-request.mjs
+// Anthropic Messages API request -> OpenAI Responses API request
+// (2026-09-23-bridge-openai-responses-design.md §7). Pure, same contract as
+// toChatRequest: `{body, warnings}` or `{error}`. Stateless by design —
+// `store: false` and the full history as `input` items every turn; the
+// model's encrypted reasoning comes back inside the thinking blocks the CLI
+// echoes (the reasoning marker, common.mjs) and is replayed as `reasoning`
+// items for the SAME upstream model only.
+
+import {
+  SERVER_TOOL_RE, textOf, imageUrl, flattenToolResult, referencedToolNames,
+  requestedEffort, mapEffort, decodeReasoningMarker,
+} from './common.mjs';
+
+/** OpenAI (and Copilot) reject max_output_tokens below this. */
+const MIN_OUTPUT_TOKENS = 16;
+
+/**
+ * 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, reasoningEfforts?:string[]}}} opts
+ * @returns {{body?:object, warnings:string[], error?:{type:string,message:string}}}
+ */
+export function toResponsesRequest(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 input = [];
+  // Append a content part to the trailing message item of `role`, or open a new one.
+  const pushPart = (role, part) => {
+    const last = input[input.length - 1];
+    if (last && last.role === role && Array.isArray(last.content)) last.content.push(part);
+    else input.push({ role, content: [part] });
+  };
+
+  // ── system ──
+  const instructions = textOf(body.system);
+  if (Array.isArray(body.system) && body.system.some((b) => b && b.cache_control)) warn('cache_control');
+
+  // ── messages → input items ──
+  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 === 'system') {
+      // The CLI's mid-conversation system message (beta mid-conversation-system).
+      const text = textOf(blocks);
+      if (text) input.push({ role: 'system', content: [{ type: 'input_text', text }] });
+      continue;
+    }
+
+    if (m.role === 'assistant') {
+      const turnStart = input.length;
+      for (const b of blocks) {
+        if (!b || typeof b !== 'object') continue;
+        if (b.type === 'text') {
+          if (typeof b.text === 'string' && b.text) pushPart('assistant', { type: 'output_text', text: b.text });
+        } else if (b.type === 'tool_use') {
+          input.push({ type: 'function_call', call_id: String(b.id || ''), name: String(b.name || ''), arguments: JSON.stringify(b.input ?? {}) });
+        } else if (b.type === 'thinking' || b.type === 'redacted_thinking') {
+          const mk = decodeReasoningMarker(b.type === 'thinking' ? b.signature : b.data);
+          if (mk && mk.model === upstreamModel) {
+            const text = b.type === 'thinking' && typeof b.thinking === 'string' ? b.thinking : '';
+            input.push({ type: 'reasoning', summary: text ? [{ type: 'summary_text', text }] : [], encrypted_content: mk.encrypted });
+          } else warn('thinking');   // another model's reasoning, or a real Claude signature
+        } else warn(b.type);
+      }
+      // A reasoning item must be followed by the message / call it was produced
+      // with — the upstream rejects one left dangling (a reasoning-only turn:
+      // output spent on reasoning, or cut by a filter). Drop it; the model
+      // re-reasons, as on the chat path, which drops thinking-only turns.
+      while (input.length > turnStart && input[input.length - 1].type === 'reasoning') { input.pop(); warn('thinking'); }
+      continue;
+    }
+
+    // user: tool outputs first (they answer the calls just made), then the
+    // rest of the message, then images relocated out of the tool results.
+    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, imageUrls } = flattenToolResult(r.content, caps, warn);
+      input.push({ type: 'function_call_output', call_id: String(r.tool_use_id || ''), output: text || (r.is_error ? 'error' : '') });
+      relocated.push(...imageUrls);
+    }
+    for (const b of rest) {
+      if (!b || typeof b !== 'object') continue;
+      if (b.type === 'text') {
+        if (typeof b.text === 'string' && b.text) pushPart('user', { type: 'input_text', text: b.text });
+      } else if (b.type === 'image') {
+        if (caps.vision === false) {
+          warn('image');
+          pushPart('user', { type: 'input_text', text: '[image omitted: model has no vision]' });
+        } else {
+          const u = imageUrl(b);
+          if (u) pushPart('user', { type: 'input_image', image_url: u }); else warn('image');
+        }
+      } else if (b.type === 'document') {
+        warn('document');
+        pushPart('user', { type: 'input_text', text: '[document omitted: not supported by this model]' });
+      } else warn(b.type);
+    }
+    for (const u of relocated) pushPart('user', { type: 'input_image', image_url: u });
+  }
+
+  // ── tools ──
+  const referenced = referencedToolNames(src);
+  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;
+      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-responses bridge)`);
+      }
+      const tool = {
+        type: 'function',
+        name: String(t.name || ''),
+        parameters: t.input_schema && typeof t.input_schema === 'object' ? t.input_schema : { type: 'object', properties: {} },
+        strict: false,
+      };
+      if (typeof t.description === 'string' && t.description) tool.description = t.description;
+      tools.push(tool);
+    }
+    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', name: String(tc.name) };
+    if (tc.disable_parallel_tool_use === true) parallel = false;
+  }
+
+  // ── assemble ──
+  const reasoning = caps.reasoning === true;
+  const out = { model: upstreamModel };
+  if (instructions) out.instructions = instructions;
+  out.input = input;
+  if (tools) out.tools = tools;
+  if (toolChoice !== undefined && tools) out.tool_choice = toolChoice;
+  if (parallel === false && tools) out.parallel_tool_calls = false;
+  out.store = 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'); }
+    out.max_output_tokens = Math.max(MIN_OUTPUT_TOKENS, Math.floor(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) warn('stop_sequences');   // Responses has no `stop`
+  if (body.metadata !== undefined) warn('metadata');
+  // context_management (the CLI's thinking-clearing edits) is dropped silently:
+  // it rides every turn and has no upstream equivalent.
+
+  // ── reasoning: always ask for the summary and the encrypted reasoning, so
+  // every reasoning item can be replayed next turn (§8) ──
+  const effort = requestedEffort(body);
+  if (reasoning) {
+    out.reasoning = { summary: 'auto' };
+    if (effort) out.reasoning.effort = mapEffort(effort, caps);
+    out.include = ['reasoning.encrypted_content'];
+  } else if (effort) warn('thinking');
+
+  if (body.stream === true) out.stream = true;
+
+  return { body: out, warnings };
+}