@fudrouter/fsrouter 0.6.61 → 0.6.63

package/open-sse/translator/concerns/thinking.js

@@ -0,0 +1,53 @@
+// Concern: reasoning_effort ↔ provider-native thinking config.
+// Central source of truth for level↔budget maps (web-standard values).
+// Provider-specific application lives in thinkingUnified.js; this file is maps-only.
+
+// Discrete effort levels, ordered low→high.
+export const EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"];
+
+// Web-standard level → budget_tokens (Anthropic/Gemini docs).
+export const LEVEL_TO_BUDGET = {
+  none: 0,
+  minimal: 512,
+  low: 1024,
+  medium: 8192,
+  high: 24576,
+  xhigh: 32768,
+  max: 128000,
+};
+
+// Returns budget_tokens for an effort level, or undefined if unknown.
+// 0 means "no thinking"; undefined means "effort not recognized".
+export function effortToBudget(effort) {
+  if (!effort) return undefined;
+  return LEVEL_TO_BUDGET[String(effort).toLowerCase()];
+}
+
+// OpenAI reasoning_effort → Gemini thinkingLevel (gemini-3 enum: minimal|low|medium|high).
+// Gemini 3 cannot fully disable thinking; "none"/"off" map to "minimal".
+export function effortToThinkingLevel(effort) {
+  const e = String(effort).toLowerCase().trim();
+  if (e === "none" || e === "off") return "minimal";
+  if (e === "xhigh" || e === "max") return "high";
+  return e;
+}
+
+// Numeric budget → nearest discrete level (reverse map via thresholds).
+// Returns null when budget <= 0 (no reasoning).
+export function budgetToLevel(budget) {
+  const b = Number(budget);
+  if (!b || b <= 0) return null;
+  if (b <= 768) return "minimal";
+  if (b <= 4096) return "low";
+  if (b <= 16384) return "medium";
+  if (b <= 28672) return "high";
+  return "xhigh";
+}
+
+// Gemini thinkingBudget (numeric) → OpenAI reasoning_effort (antigravity reverse map).
+export function budgetToEffort(budget) {
+  if (!budget || budget <= 0) return null;
+  if (budget <= 2048) return "low";
+  if (budget <= 16384) return "medium";
+  return "high";
+}

package/open-sse/translator/concerns/thinkingUnified.js

@@ -0,0 +1,329 @@
+// Unified thinking normalization: extract client intent → apply provider-native format.
+// Config-driven: thinking format/limits come from capabilities.js + registry transport,
+// never hardcoded per-model here. See .docs/thinking/plan.md MATRIX VI-A.
+
+import { getCapabilitiesForModel } from "../../providers/capabilities.js";
+import { PROVIDERS } from "../../providers/index.js";
+import { LEVEL_TO_BUDGET, budgetToLevel, effortToBudget, effortToThinkingLevel } from "./thinking.js";
+
+// Map a target wire-format to its native thinking format (when capability has none).
+const FORMAT_TO_NATIVE = {
+  openai: "openai",
+  "openai-responses": "openai",
+  "openai-response": "openai",
+  codex: "openai",
+  claude: "claude-budget",
+  gemini: "gemini-budget",
+  "gemini-cli": "gemini-budget",
+  vertex: "gemini-budget",
+  antigravity: "gemini-budget",
+  kiro: "kiro",
+};
+
+// Strip a trailing thinking suffix "model(value)" → "model" (no-op when absent).
+export function stripThinkingSuffix(model) {
+  if (typeof model !== "string") return model;
+  const m = model.match(/^(.*)\([^()]+\)\s*$/);
+  return m ? m[1].trim() : model;
+}
+
+// Parse model-name suffix "model(value)" → { cleanModel, override }.
+// value: level name (high) | number (8192) | auto | none. null override when absent.
+export function parseSuffix(model) {
+  if (typeof model !== "string") return { cleanModel: model, override: null };
+  const m = model.match(/^(.*)\(([^()]+)\)\s*$/);
+  if (!m) return { cleanModel: model, override: null };
+  const cleanModel = m[1].trim();
+  const raw = m[2].trim().toLowerCase();
+  if (raw === "none" || raw === "off") return { cleanModel, override: { mode: "none" } };
+  if (raw === "auto") return { cleanModel, override: { mode: "auto" } };
+  if (/^\d+$/.test(raw)) return { cleanModel, override: { mode: "budget", budget: Number(raw) } };
+  if (LEVEL_TO_BUDGET[raw] !== undefined) return { cleanModel, override: { mode: "level", level: raw } };
+  return { cleanModel, override: null };
+}
+
+// Extract unified thinking intent from a request body (post-translation, mixed shapes).
+// Returns { mode, budget?, level? } or null when no thinking intent present.
+export function extractThinking(body) {
+  if (!body || typeof body !== "object") return null;
+
+  // Claude output_config.effort (explicit) — priority over adaptive thinking
+  const oc = body.output_config?.effort;
+  if (typeof oc === "string" && oc) {
+    const e = oc.toLowerCase();
+    if (e === "none" || e === "off") return { mode: "none" };
+    if (e === "auto") return { mode: "auto" };
+    return { mode: "level", level: e };
+  }
+
+  // Claude shape
+  const t = body.thinking;
+  if (t && typeof t === "object") {
+    if (t.type === "disabled") return { mode: "none" };
+    if (t.type === "adaptive" || t.type === "enabled") {
+      const budget = Number(t.budget_tokens);
+      if (Number.isFinite(budget) && budget > 0) return { mode: "budget", budget };
+      return { mode: "auto" };
+    }
+  }
+
+  // OpenAI chat / Responses shape
+  const effort = body.reasoning_effort ?? (typeof body.reasoning === "object" ? body.reasoning?.effort : null);
+  if (typeof effort === "string" && effort) {
+    const e = effort.toLowerCase();
+    if (e === "none" || e === "off") return { mode: "none" };
+    if (e === "auto") return { mode: "auto" };
+    return { mode: "level", level: e };
+  }
+
+  // Gemini shape (top-level, generationConfig, or request envelope)
+  const tc = body.thinkingConfig || body.generationConfig?.thinkingConfig || body.request?.generationConfig?.thinkingConfig;
+  if (tc && typeof tc === "object") {
+    if (typeof tc.thinkingLevel === "string") return { mode: "level", level: tc.thinkingLevel.toLowerCase() };
+    const tb = Number(tc.thinkingBudget);
+    if (Number.isFinite(tb)) {
+      if (tb === 0) return { mode: "none" };
+      if (tb < 0) return { mode: "auto" };
+      return { mode: "budget", budget: tb };
+    }
+  }
+
+  // Qwen shape
+  if (body.enable_thinking === false) return { mode: "none" };
+  if (body.enable_thinking === true) {
+    const tb = Number(body.thinking_budget);
+    if (Number.isFinite(tb) && tb > 0) return { mode: "budget", budget: tb };
+    return { mode: "auto" };
+  }
+
+  return null;
+}
+
+// Capture thinking intent from a body. Alias of extractThinking, named for clarity
+// at the call-site where intent is snapshotted before format translation.
+export const captureThinking = extractThinking;
+
+// Resolve thinking format: provider override > capability > derive(targetFormat).
+function resolveFormat(targetFormat, model, provider) {
+  const providerFmt = provider ? PROVIDERS[provider]?.thinkingFormat : null;
+  if (providerFmt) return providerFmt;
+  const caps = getCapabilitiesForModel(provider, model);
+  if (caps.thinkingFormat) return caps.thinkingFormat;
+  return FORMAT_TO_NATIVE[targetFormat] || "openai";
+}
+
+// Convert unified config to a budget number (for budget-based formats).
+function toBudget(cfg, range) {
+  let budget;
+  if (cfg.mode === "budget") budget = cfg.budget;
+  else if (cfg.mode === "level") budget = effortToBudget(cfg.level);
+  else if (cfg.mode === "auto") return -1;
+  if (!Number.isFinite(budget)) return undefined;
+  if (range) {
+    if (range.min != null && budget < range.min) budget = range.min;
+    if (range.max != null && budget > range.max) budget = range.max;
+  }
+  return budget;
+}
+
+// Convert unified config to a discrete level string.
+function toLevel(cfg) {
+  if (cfg.mode === "level") return cfg.level;
+  if (cfg.mode === "budget") return budgetToLevel(cfg.budget) || "medium";
+  if (cfg.mode === "auto") return "auto";
+  return null;
+}
+
+function toGeminiThinkingLevel(cfg) {
+  const raw = cfg.mode === "auto" ? "high" : (toLevel(cfg) || "high");
+  return effortToThinkingLevel(raw);
+}
+
+function toKimiReasoningEffort(cfg) {
+  const level = toLevel(cfg);
+  if (level === "auto") return "high";
+  if (level === "minimal") return "low";
+  if (level === "xhigh") return "max";
+  if (["low", "medium", "high", "max"].includes(level)) return level;
+  return null;
+}
+
+const GEMINI_LEVEL_OUTPUT_FLOOR = {
+  minimal: 4096,
+  low: 8192,
+  medium: 16384,
+  high: 65535,
+};
+
+function geminiBudgetOutputFloor(budget) {
+  if (budget === -1) return 32768;
+  if (!Number.isFinite(budget)) return 32768;
+  if (budget <= 1024) return 8192;
+  if (budget <= 8192) return 16384;
+  if (budget <= 24576) return 32768;
+  return 65535;
+}
+
+function geminiLevelOutputFloor(level) {
+  return GEMINI_LEVEL_OUTPUT_FLOOR[level] || GEMINI_LEVEL_OUTPUT_FLOOR.high;
+}
+
+// Gemini nests thinkingConfig under generationConfig. gemini-cli / antigravity wrap
+// the whole request in a { request: { generationConfig } } envelope — target the
+// envelope's generationConfig when present, else the top-level one.
+function getGeminiGenerationConfig(body) {
+  if (body.request && typeof body.request === "object") {
+    if (!body.request.generationConfig || typeof body.request.generationConfig !== "object") {
+      body.request.generationConfig = {};
+    }
+    return body.request.generationConfig;
+  }
+  if (!body.generationConfig || typeof body.generationConfig !== "object") {
+    body.generationConfig = {};
+  }
+  return body.generationConfig;
+}
+
+function setGeminiThinking(body, tc) {
+  const gc = getGeminiGenerationConfig(body);
+  gc.thinkingConfig = tc;
+}
+
+function ensureGeminiOutputFloor(body, floor, caps) {
+  const cap = Number.isFinite(caps?.maxOutput) ? caps.maxOutput : floor;
+  const target = Math.min(floor, cap);
+  const gc = getGeminiGenerationConfig(body);
+  const current = Number(gc.maxOutputTokens);
+  if (!Number.isFinite(current) || current < target) {
+    gc.maxOutputTokens = target;
+  }
+}
+
+// Strip every known thinking field from a body (used before re-applying / when unsupported).
+function stripAll(body) {
+  delete body.thinking;
+  delete body.reasoning_effort;
+  delete body.reasoning;
+  delete body.thinkingConfig;
+  delete body.enable_thinking;
+  delete body.thinking_budget;
+  delete body.output_config;
+  if (body.generationConfig) delete body.generationConfig.thinkingConfig;
+  if (body.request?.generationConfig) delete body.request.generationConfig.thinkingConfig;
+}
+
+// Apply unified thinking config to body in the resolved provider-native format.
+function applyFormat(fmt, body, cfg, caps) {
+  const none = cfg.mode === "none";
+  const canDisable = caps.thinkingCanDisable !== false;
+  // Model cannot disable thinking → clamp "none" to minimal effort instead.
+  const eff = none && !canDisable ? { mode: "level", level: "minimal" } : cfg;
+
+  switch (fmt) {
+    case "openai": {
+      if (none && canDisable) { body.reasoning_effort = "none"; break; }
+      const level = toLevel(eff);
+      // OpenAI reasoning_effort enum caps at "xhigh" (no "max"); clamp Claude Code's "max".
+      if (level) body.reasoning_effort = level === "max" ? "xhigh" : level;
+      break;
+    }
+    case "claude-adaptive": {
+      if (none && canDisable) { body.thinking = { type: "disabled" }; break; }
+      const level = toLevel(eff);
+      body.output_config = { effort: level === "xhigh" ? "high" : level };
+      break;
+    }
+    case "claude-budget": {
+      if (none && canDisable) { body.thinking = { type: "disabled" }; break; }
+      const budget = toBudget(eff, caps.thinkingRange);
+      body.thinking = budget === -1 ? { type: "enabled" } : { type: "enabled", budget_tokens: budget || 8192 };
+      break;
+    }
+    case "gemini-level": {
+      const level = none ? "minimal" : toGeminiThinkingLevel(eff);
+      setGeminiThinking(body, { thinkingLevel: level, includeThoughts: level !== "minimal" });
+      ensureGeminiOutputFloor(body, geminiLevelOutputFloor(level), caps);
+      break;
+    }
+    case "gemini-budget": {
+      if (none && canDisable) { setGeminiThinking(body, { thinkingBudget: 0, includeThoughts: false }); break; }
+      const budget = toBudget(eff, caps.thinkingRange);
+      setGeminiThinking(body, { thinkingBudget: budget ?? -1, includeThoughts: true });
+      ensureGeminiOutputFloor(body, geminiBudgetOutputFloor(budget ?? -1), caps);
+      break;
+    }
+    case "zai": {
+      // Z.ai ignores thinking.disabled → must use enable_thinking:false to turn off.
+      if (none && canDisable) { body.enable_thinking = false; delete body.thinking; break; }
+      body.thinking = { type: "enabled" };
+      break;
+    }
+    case "qwen": {
+      if (none && canDisable) { body.enable_thinking = false; break; }
+      body.enable_thinking = true;
+      const budget = toBudget(eff, caps.thinkingRange);
+      if (Number.isFinite(budget) && budget > 0) body.thinking_budget = budget;
+      break;
+    }
+    case "deepseek": {
+      if (none && canDisable) { body.thinking = { type: "disabled" }; break; }
+      body.thinking = { type: "enabled" };
+      // DeepSeek: low/medium→high, xhigh/max→max.
+      const level = toLevel(eff);
+      body.reasoning_effort = level === "xhigh" || level === "max" ? "max" : "high";
+      break;
+    }
+    case "kimi": {
+      if (none && canDisable) { body.thinking = { type: "disabled" }; break; }
+      const effort = toKimiReasoningEffort(eff);
+      if (effort) body.reasoning_effort = effort;
+      break;
+    }
+    case "minimax": {
+      // M3 adaptive; M2.x cannot disable (handled via canDisable clamp).
+      body.thinking = { type: none && canDisable ? "disabled" : "adaptive" };
+      break;
+    }
+    case "hunyuan": {
+      if (none && canDisable) { body.thinking = { type: "disabled" }; break; }
+      const budget = toBudget(eff, caps.thinkingRange);
+      body.thinking = budget === -1 ? { type: "enabled" } : { type: "enabled", budget_tokens: budget || 8192 };
+      break;
+    }
+    case "step": {
+      if (none && canDisable) break;
+      const level = toLevel(eff);
+      if (level) body.reasoning_effort = level === "xhigh" || level === "max" ? "high" : level;
+      break;
+    }
+    case "kiro":
+      // Kiro thinking handled via system-tag injection in openai-to-kiro.js; no body field here.
+      break;
+    default:
+      break;
+  }
+}
+
+// Public entry: normalize thinking for the resolved target format.
+// Mutates and returns body. No-op when model has no reasoning capability.
+// `intent` is a pre-captured config (from captureThinking on the original body);
+// falls back to extracting from the current body when omitted.
+export function applyThinking(targetFormat, model, body, provider = null, intent = undefined) {
+  if (!body || typeof body !== "object") return body;
+
+  const { cleanModel, override } = parseSuffix(model);
+  const cfg = override || intent || extractThinking(body);
+  const caps = getCapabilitiesForModel(provider, cleanModel);
+
+  // Model cannot reason → strip any stray thinking fields.
+  if (!caps.reasoning) {
+    stripAll(body);
+    return body;
+  }
+  if (!cfg) return body;
+
+  const fmt = resolveFormat(targetFormat, cleanModel, provider);
+  stripAll(body);
+  applyFormat(fmt, body, cfg, caps);
+  return body;
+}

package/open-sse/translator/concerns/toolCall.js

@@ -0,0 +1,153 @@
+// Tool call helper functions for translator
+
+// Anthropic tool_use.id must match: ^[a-zA-Z0-9_-]+$
+const TOOL_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+
+// Fallback streaming tool_call id when provider omits one (index optional)
+export function fallbackToolCallId(index) {
+  return index === undefined ? `call_${Date.now()}` : `call_${index}_${Date.now()}`;
+}
+
+// Generate deterministic tool call ID from position + tool name (cache-friendly)
+export function generateToolCallId(msgIndex = 0, tcIndex = 0, toolName = "") {
+  const name = toolName ? `_${toolName.replace(/[^a-zA-Z0-9_-]/g, "")}` : "";
+  return `call_msg${msgIndex}_tc${tcIndex}${name}`;
+}
+
+// Sanitize ID to match Anthropic pattern: keep only alphanumeric, underscore, hyphen
+function sanitizeToolId(id) {
+  if (!id || typeof id !== "string") return null;
+  const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "");
+  return sanitized.length > 0 ? sanitized : null;
+}
+
+// Ensure all tool_calls have valid id field and arguments is string (some providers require it)
+export function ensureToolCallIds(body) {
+  if (!body.messages || !Array.isArray(body.messages)) return body;
+
+  for (let i = 0; i < body.messages.length; i++) {
+    const msg = body.messages[i];
+    if (msg.role === "assistant" && msg.tool_calls && Array.isArray(msg.tool_calls)) {
+      for (let j = 0; j < msg.tool_calls.length; j++) {
+        const tc = msg.tool_calls[j];
+        // Validate or regenerate ID for Anthropic compatibility
+        if (!tc.id || !TOOL_ID_PATTERN.test(tc.id)) {
+          const sanitized = sanitizeToolId(tc.id);
+          tc.id = sanitized || generateToolCallId(i, j, tc.function?.name);
+        }
+        if (!tc.type) {
+          tc.type = "function";
+        }
+        // Ensure arguments is JSON string, not object
+        if (tc.function?.arguments && typeof tc.function.arguments !== "string") {
+          tc.function.arguments = JSON.stringify(tc.function.arguments);
+        }
+      }
+    }
+
+    // Validate tool_call_id in tool messages (role: "tool")
+    if (msg.role === "tool" && msg.tool_call_id && !TOOL_ID_PATTERN.test(msg.tool_call_id)) {
+      const sanitized = sanitizeToolId(msg.tool_call_id);
+      msg.tool_call_id = sanitized || generateToolCallId(i, 0);
+    }
+
+    // Also validate tool_use blocks in content (Claude format)
+    if (Array.isArray(msg.content)) {
+      for (let k = 0; k < msg.content.length; k++) {
+        const block = msg.content[k];
+        if (block.type === "tool_use" && block.id && !TOOL_ID_PATTERN.test(block.id)) {
+          const sanitized = sanitizeToolId(block.id);
+          block.id = sanitized || generateToolCallId(i, k, block.name);
+        }
+        // Validate tool_use_id in tool_result blocks
+        if (block.type === "tool_result" && block.tool_use_id && !TOOL_ID_PATTERN.test(block.tool_use_id)) {
+          const sanitized = sanitizeToolId(block.tool_use_id);
+          block.tool_use_id = sanitized || generateToolCallId(i, k);
+        }
+      }
+    }
+  }
+
+  return body;
+}
+
+// Get tool_call ids from assistant message (OpenAI format: tool_calls, Claude format: tool_use in content)
+export function getToolCallIds(msg) {
+  if (msg.role !== "assistant") return [];
+
+  const ids = [];
+
+  // OpenAI format: tool_calls array
+  if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+    for (const tc of msg.tool_calls) {
+      if (tc.id) ids.push(tc.id);
+    }
+  }
+
+  // Claude format: tool_use blocks in content
+  if (Array.isArray(msg.content)) {
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id) {
+        ids.push(block.id);
+      }
+    }
+  }
+
+  return ids;
+}
+
+// Check if user message has tool_result for given ids (OpenAI format: role=tool, Claude format: tool_result in content)
+export function hasToolResults(msg, toolCallIds) {
+  if (!msg || !toolCallIds.length) return false;
+
+  // OpenAI format: role = "tool" with tool_call_id
+  if (msg.role === "tool" && msg.tool_call_id) {
+    return toolCallIds.includes(msg.tool_call_id);
+  }
+
+  // Claude format: tool_result blocks in user message content
+  if (msg.role === "user" && Array.isArray(msg.content)) {
+    for (const block of msg.content) {
+      if (block.type === "tool_result" && toolCallIds.includes(block.tool_use_id)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+// Fix missing tool responses - insert empty tool_result if assistant has tool_use but next message has no tool_result
+export function fixMissingToolResponses(body) {
+  if (!body.messages || !Array.isArray(body.messages)) return body;
+
+  const newMessages = [];
+
+  for (let i = 0; i < body.messages.length; i++) {
+    const msg = body.messages[i];
+    const nextMsg = body.messages[i + 1];
+
+    newMessages.push(msg);
+
+    // Check if this is assistant with tool_calls/tool_use
+    const toolCallIds = getToolCallIds(msg);
+    if (toolCallIds.length === 0) continue;
+
+    // Check if next message has tool_result
+    if (nextMsg && !hasToolResults(nextMsg, toolCallIds)) {
+      // Insert tool responses for each tool_call
+      for (const id of toolCallIds) {
+        // OpenAI format: role = "tool"
+        newMessages.push({
+          role: "tool",
+          tool_call_id: id,
+          content: ""
+        });
+      }
+    }
+  }
+
+  body.messages = newMessages;
+  return body;
+}
+

package/open-sse/translator/concerns/usage.js

@@ -0,0 +1,69 @@
+// Build OpenAI usage object. Caller computes prompt/completion/total (provider math).
+// Optional details added only when > 0 (matches existing claude/gemini/codex behavior).
+export function buildUsage({ promptTokens, completionTokens, totalTokens, cachedTokens = 0, cacheCreationTokens = 0, reasoningTokens = 0 }) {
+  const usage = { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: totalTokens };
+  if (cachedTokens > 0 || cacheCreationTokens > 0) {
+    usage.prompt_tokens_details = {};
+    if (cachedTokens > 0) usage.prompt_tokens_details.cached_tokens = cachedTokens;
+    if (cacheCreationTokens > 0) usage.prompt_tokens_details.cache_creation_tokens = cacheCreationTokens;
+  }
+  if (reasoningTokens > 0) {
+    usage.completion_tokens_details = { reasoning_tokens: reasoningTokens };
+  }
+  return usage;
+}
+
+const n = (v) => (typeof v === "number" ? v : 0);
+
+// Per-provider raw token field-map + math. Returns buildUsage() args (NOT the usage object).
+// Keeps each provider's exact semantics: claude/gemini fold cache+reasoning, others don't.
+const USAGE_EXTRACTORS = {
+  claude(raw) {
+    const input = n(raw.input_tokens), output = n(raw.output_tokens);
+    const cacheRead = n(raw.cache_read_input_tokens), cacheCreate = n(raw.cache_creation_input_tokens);
+    const prompt = input + cacheRead + cacheCreate;
+    return { promptTokens: prompt, completionTokens: output, totalTokens: prompt + output, cachedTokens: cacheRead, cacheCreationTokens: cacheCreate };
+  },
+  gemini(raw) {
+    const cached = n(raw.cachedContentTokenCount);
+    const prompt = n(raw.promptTokenCount);
+    const thoughts = n(raw.thoughtsTokenCount);
+    const total = n(raw.totalTokenCount);
+    let candidates = n(raw.candidatesTokenCount);
+    // Fallback: derive candidates from total when upstream omits it
+    if (candidates === 0 && total > 0) {
+      candidates = total - prompt - thoughts;
+      if (candidates < 0) candidates = 0;
+    }
+    return { promptTokens: prompt, completionTokens: candidates + thoughts, totalTokens: total, cachedTokens: cached, reasoningTokens: thoughts };
+  },
+  kiro(raw) {
+    const input = n(raw.inputTokens), output = n(raw.outputTokens);
+    // ponytail: Amazon Q (Kiro upstream) does not expose cache fields today,
+    // but pass through any cache_read/cache_creation/cached_tokens if the
+    // event shape grows them later so cost tracking keeps working without
+    // a second pass.
+    const cached = n(raw.cache_read_input_tokens) || n(raw.cachedTokens) || n(raw.cached_tokens);
+    const cacheCreation = n(raw.cache_creation_input_tokens);
+    const out = { promptTokens: input, completionTokens: output, totalTokens: input + output };
+    if (cached > 0) out.cachedTokens = cached;
+    if (cacheCreation > 0) out.cacheCreationTokens = cacheCreation;
+    return out;
+  },
+  ollama(raw) {
+    const input = n(raw.prompt_eval_count), output = n(raw.eval_count);
+    return { promptTokens: input, completionTokens: output, totalTokens: input + output };
+  },
+  commandcode(raw) {
+    const input = n(raw.inputTokens), output = n(raw.outputTokens);
+    const total = typeof raw.totalTokens === "number" ? raw.totalTokens : input + output;
+    return { promptTokens: input, completionTokens: output, totalTokens: total };
+  },
+};
+
+// Convert provider-native usage object → OpenAI usage. Returns null if no extractor/raw.
+export function toOpenAIUsage(raw, kind) {
+  const extract = USAGE_EXTRACTORS[kind];
+  if (!extract || !raw || typeof raw !== "object") return null;
+  return buildUsage(extract(raw));
+}