swayrouter 1.0.0

package/src/translator/concerns/prefetch.js

@@ -0,0 +1,86 @@
+import { FORMATS } from "../formats.js";
+import { fetchImageAsBase64, parseDataUri } from "./image.js";
+
+const TARGETS_NEED_BASE64 = new Set([
+  FORMATS.GEMINI, FORMATS.GEMINI_CLI, FORMATS.VERTEX,
+  FORMATS.ANTIGRAVITY, FORMATS.OLLAMA, FORMATS.KIRO,
+]);
+
+function isRemoteUrl(url) {
+  return typeof url === "string" && (url.startsWith("http://") || url.startsWith("https://"));
+}
+
+function collectImageRefs(body, sourceFormat) {
+  const refs = [];
+  const pushOpenAI = (messages) => {
+    for (const msg of messages || []) {
+      if (!Array.isArray(msg.content)) continue;
+      for (const block of msg.content) {
+        if (block?.type === "image_url") {
+          const url = typeof block.image_url === "string" ? block.image_url : block.image_url?.url;
+          if (isRemoteUrl(url)) refs.push({ get: () => url, set: (v) => {
+            if (typeof block.image_url === "string") block.image_url = v; else block.image_url.url = v;
+          } });
+        }
+      }
+    }
+  };
+  const pushGemini = (contents) => {
+    for (const c of contents || []) {
+      for (const p of c.parts || []) {
+        const uri = p?.fileData?.fileUri;
+        if (isRemoteUrl(uri)) refs.push({ get: () => uri, part: p });
+      }
+    }
+  };
+
+  switch (sourceFormat) {
+    case FORMATS.OPENAI:
+    case FORMATS.OLLAMA:
+    case FORMATS.KIRO:
+    case FORMATS.CURSOR:
+    case FORMATS.COMMANDCODE:
+      pushOpenAI(body.messages);
+      break;
+    case FORMATS.CLAUDE:
+      for (const msg of body.messages || []) {
+        if (!Array.isArray(msg.content)) continue;
+        for (const block of msg.content) {
+          if (block?.type === "image" && block.source?.type === "url" && isRemoteUrl(block.source.url)) {
+            refs.push({ get: () => block.source.url, claudeBlock: block });
+          }
+        }
+      }
+      break;
+    case FORMATS.GEMINI:
+    case FORMATS.GEMINI_CLI:
+    case FORMATS.VERTEX:
+      pushGemini(body.contents);
+      break;
+    case FORMATS.ANTIGRAVITY:
+      pushGemini(body?.request?.contents);
+      break;
+    default:
+      pushOpenAI(body.messages);
+  }
+  return refs;
+}
+
+export async function prefetchRemoteImages(body, sourceFormat, targetFormat, options = {}) {
+  if (!body || !TARGETS_NEED_BASE64.has(targetFormat)) return 0;
+  const refs = collectImageRefs(body, sourceFormat);
+  if (!refs.length) return 0;
+
+  let converted = 0;
+  for (const ref of refs) {
+    const url = ref.get();
+    if (parseDataUri(url)) continue;
+    const fetched = await fetchImageAsBase64(url, options);
+    if (!fetched) continue;
+    if (ref.set) ref.set(fetched.url);
+    else if (ref.part) { delete ref.part.fileData; ref.part.inlineData = { mimeType: fetched.mimeType, data: fetched.url.split(",")[1] }; }
+    else if (ref.claudeBlock) ref.claudeBlock.source = { type: "base64", media_type: fetched.mimeType, data: fetched.url.split(",")[1] };
+    converted++;
+  }
+  return converted;
+}

package/src/translator/concerns/reasoning.js

@@ -0,0 +1,18 @@
+import { ROLE } from "../schema/index.js";
+
+export function reasoningDelta(text, withRole = false) {
+  return withRole
+    ? { role: ROLE.ASSISTANT, reasoning_content: text }
+    : { reasoning_content: text };
+}
+
+export function extractReasoningText(delta) {
+  if (!delta || typeof delta !== "object") return "";
+  if (typeof delta.reasoning_content === "string" && delta.reasoning_content) return delta.reasoning_content;
+  if (typeof delta.reasoning === "string" && delta.reasoning) return delta.reasoning;
+  const details = delta.reasoning_details;
+  if (Array.isArray(details)) {
+    return details.map((d) => (typeof d === "string" ? d : d?.text || d?.content || "")).join("");
+  }
+  return "";
+}

package/src/translator/concerns/thinking.js

@@ -0,0 +1,40 @@
+export const EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"];
+
+export const LEVEL_TO_BUDGET = {
+  none: 0,
+  minimal: 512,
+  low: 1024,
+  medium: 8192,
+  high: 24576,
+  xhigh: 32768,
+  max: 128000,
+};
+
+export function effortToBudget(effort) {
+  if (!effort) return undefined;
+  return LEVEL_TO_BUDGET[String(effort).toLowerCase()];
+}
+
+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;
+}
+
+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";
+}
+
+export function budgetToEffort(budget) {
+  if (!budget || budget <= 0) return null;
+  if (budget <= 2048) return "low";
+  if (budget <= 16384) return "medium";
+  return "high";
+}

package/src/translator/concerns/thinkingUnified.js

@@ -0,0 +1,319 @@
+import { getCapabilitiesForModel } from "../../providers/capabilities.js";
+import { getThinkingLevels } from "../../providers/thinkingLevels.js";
+import { PROVIDERS } from "../../providers/index.js";
+import { LEVEL_TO_BUDGET, budgetToLevel, effortToBudget, effortToThinkingLevel } from "./thinking.js";
+
+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",
+};
+
+export function stripThinkingSuffix(model) {
+  if (typeof model !== "string") return model;
+  const m = model.match(/^(.*)\([^()]+\)\s*$/);
+  return m ? m[1].trim() : model;
+}
+
+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 (raw === "ultra") return { cleanModel, override: { mode: "level", level: raw } };
+  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 };
+}
+
+export function extractThinking(body) {
+  if (!body || typeof body !== "object") return null;
+
+  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 };
+  }
+
+  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" };
+    }
+  }
+
+  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 };
+  }
+
+  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 };
+    }
+  }
+
+  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;
+}
+
+export const captureThinking = extractThinking;
+
+function resolveFormat(targetFormat, model, provider, capabilityOverride = null) {
+  if (typeof capabilityOverride?.thinkingFormat === "string" && capabilityOverride.thinkingFormat) {
+    return capabilityOverride.thinkingFormat;
+  }
+  const providerFmt = provider ? PROVIDERS[provider]?.thinkingFormat : null;
+  if (providerFmt) return providerFmt;
+  const caps = getCapabilitiesForModel(provider, model, capabilityOverride);
+  if (caps.thinkingFormat) return caps.thinkingFormat;
+  return FORMAT_TO_NATIVE[targetFormat] || "openai";
+}
+
+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;
+}
+
+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 normalizeOpenAILevel(level, supportedLevels) {
+  if (level !== "max" && level !== "ultra") return level;
+  if (supportedLevels?.includes(level)) return level;
+  if (level === "ultra" && supportedLevels?.includes("max")) return "max";
+  return "xhigh";
+}
+
+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;
+}
+
+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;
+  }
+}
+
+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;
+}
+
+function applyFormat(fmt, body, cfg, caps, supportedLevels) {
+  const none = cfg.mode === "none";
+  const canDisable = caps.thinkingCanDisable !== false;
+
+  const eff = none && !canDisable ? { mode: "level", level: "minimal" } : cfg;
+
+  switch (fmt) {
+    case "openai": {
+      if (none && canDisable) { body.reasoning_effort = "none"; break; }
+      if (cfg.mode === "auto") break;
+      const level = toLevel(eff);
+      if (level) body.reasoning_effort = normalizeOpenAILevel(level, supportedLevels);
+      break;
+    }
+    case "claude-adaptive": {
+      if (none && canDisable) { body.thinking = { type: "disabled" }; break; }
+
+      body.thinking = { type: "adaptive" };
+      const level = toLevel(eff);
+      if (level && level !== "auto") {
+        body.output_config = { effort: level === "xhigh" ? "high" : level };
+      }
+      break;
+    }
+    case "claude-budget": {
+      if (none && canDisable) { body.thinking = { type: "disabled" }; break; }
+      if (cfg.mode === "auto") 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": {
+
+      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" };
+
+      const level = toLevel(eff);
+      if (level === "max" || level === "xhigh") body.reasoning_effort = "max";
+      else if (level === "low") body.reasoning_effort = "low";
+      else body.reasoning_effort = "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": {
+
+      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":
+
+      break;
+    default:
+      break;
+  }
+}
+
+export function applyThinking(targetFormat, model, body, provider = null, intent = undefined, capabilityOverride = null) {
+  if (!body || typeof body !== "object") return body;
+
+  const { cleanModel, override } = parseSuffix(model);
+  const cfg = override || intent || extractThinking(body);
+  const caps = getCapabilitiesForModel(provider, cleanModel, capabilityOverride);
+
+  if (!caps.reasoning) {
+    stripAll(body);
+    return body;
+  }
+  if (!cfg) return body;
+
+  const fmt = resolveFormat(targetFormat, cleanModel, provider, capabilityOverride);
+  const supportedLevels = getThinkingLevels(provider, cleanModel, capabilityOverride);
+  stripAll(body);
+  applyFormat(fmt, body, cfg, caps, supportedLevels);
+  return body;
+}

package/src/translator/concerns/toolCall.js

@@ -0,0 +1,134 @@
+const TOOL_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+
+export function fallbackToolCallId(index) {
+  return index === undefined ? `call_${Date.now()}` : `call_${index}_${Date.now()}`;
+}
+
+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}`;
+}
+
+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;
+}
+
+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];
+
+        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";
+        }
+
+        if (tc.function?.arguments && typeof tc.function.arguments !== "string") {
+          tc.function.arguments = JSON.stringify(tc.function.arguments);
+        }
+      }
+    }
+
+    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);
+    }
+
+    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);
+        }
+
+        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;
+}
+
+export function getToolCallIds(msg) {
+  if (msg.role !== "assistant") return [];
+
+  const ids = [];
+
+  if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+    for (const tc of msg.tool_calls) {
+      if (tc.id) ids.push(tc.id);
+    }
+  }
+
+  if (Array.isArray(msg.content)) {
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id) {
+        ids.push(block.id);
+      }
+    }
+  }
+
+  return ids;
+}
+
+export function hasToolResults(msg, toolCallIds) {
+  if (!msg || !toolCallIds.length) return false;
+
+  if (msg.role === "tool" && msg.tool_call_id) {
+    return toolCallIds.includes(msg.tool_call_id);
+  }
+
+  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;
+}
+
+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);
+
+    const toolCallIds = getToolCallIds(msg);
+    if (toolCallIds.length === 0) continue;
+
+    if (nextMsg && !hasToolResults(nextMsg, toolCallIds)) {
+
+      for (const id of toolCallIds) {
+
+        newMessages.push({
+          role: "tool",
+          tool_call_id: id,
+          content: ""
+        });
+      }
+    }
+  }
+
+  body.messages = newMessages;
+  return body;
+}

package/src/translator/concerns/usage.js

@@ -0,0 +1,61 @@
+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);
+
+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);
+
+    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);
+
+    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 };
+  },
+};
+
+export function toOpenAIUsage(raw, kind) {
+  const extract = USAGE_EXTRACTORS[kind];
+  if (!extract || !raw || typeof raw !== "object") return null;
+  return buildUsage(extract(raw));
+}