@amir83nasr/10router 0.1.0

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

@@ -0,0 +1,158 @@
+// Build a base64 data URI from mime + base64 payload
+export function encodeDataUri(mimeType, base64) {
+  return `data:${mimeType};base64,${base64}`;
+}
+
+// Parse a base64 data URI → { mimeType, base64 }, or null if not a data URI.
+// [\s\S] tolerates newlines inside the base64 payload.
+const DATA_URI_RE = /^data:([^;]+);base64,([\s\S]+)$/;
+export function parseDataUri(url) {
+  if (typeof url !== "string") return null;
+  const m = url.match(DATA_URI_RE);
+  return m ? { mimeType: m[1], base64: m[2] } : null;
+}
+
+import { lookup } from "node:dns/promises";
+import { Agent } from "undici";
+import {
+  MAX_IMAGE_BYTES,
+  FETCH_TIMEOUT_MS,
+  IMAGE_SIGNATURES,
+  BLOCKED_HOSTS,
+} from "../../config/mediaConfig.js";
+
+// True if an IPv4/IPv6 address is private/reserved (SSRF target).
+function isPrivateIp(ip) {
+  if (!ip) return true;
+  // IPv6 loopback / unique-local / link-local
+  if (ip === "::1" || ip.startsWith("fc") || ip.startsWith("fd") || ip.startsWith("fe80"))
+    return true;
+  // IPv4-mapped IPv6 (::ffff:a.b.c.d) -> extract tail
+  const v4 = ip.includes(".") ? ip.split(":").pop() : ip;
+  const parts = v4.split(".").map((n) => Number.parseInt(n, 10));
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n)))
+    return ip.includes(":") ? false : true;
+  const [a, b] = parts;
+  if (a === 10 || a === 127 || a === 0) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 169 && b === 254) return true; // link-local + cloud metadata
+  if (a === 100 && b >= 64 && b <= 127) return true; // CGNAT
+  return false;
+}
+
+// Resolve host once and return only public IPs (SSRF guard).
+// Rejects if any resolved record is private/reserved (defeats multi-A tricks).
+async function resolvePinnedIps(hostname) {
+  if (!hostname || BLOCKED_HOSTS.has(hostname.toLowerCase())) return null;
+  try {
+    const records = await lookup(hostname, { all: true });
+    if (!records.length || records.some((r) => isPrivateIp(r.address))) return null;
+    return records;
+  } catch {
+    return null;
+  }
+}
+
+// Verify buffer magic bytes match a known image signature; return its mime or null.
+function detectImageMime(buf) {
+  for (const { sig, offset, mime, verifyWebp } of IMAGE_SIGNATURES) {
+    if (buf.length < offset + sig.length) continue;
+    let match = true;
+    for (let i = 0; i < sig.length; i++) {
+      if (buf[offset + i] !== sig[i]) {
+        match = false;
+        break;
+      }
+    }
+    if (!match) continue;
+    // WEBP: RIFF....WEBP — bytes 8..11 must be "WEBP".
+    if (
+      verifyWebp &&
+      !(
+        buf.length >= 12 &&
+        buf[8] === 0x57 &&
+        buf[9] === 0x45 &&
+        buf[10] === 0x42 &&
+        buf[11] === 0x50
+      )
+    )
+      continue;
+    return mime;
+  }
+  return null;
+}
+
+/**
+ * Fetch a remote image URL and return it as a base64 data URI.
+ * Hardened against SSRF (private/metadata IPs), memory DoS (size cap),
+ * and disguised non-image payloads (magic-byte verification).
+ * Returns null on any failure or rejection.
+ *
+ * @param {string} imageUrl - HTTP(S) URL of the image
+ * @param {object} options - { signal, timeoutMs, maxBytes }
+ * @returns {Promise<{url: string, mimeType: string}|null>}
+ */
+export async function fetchImageAsBase64(imageUrl, options = {}) {
+  const { signal, timeoutMs = FETCH_TIMEOUT_MS, maxBytes = MAX_IMAGE_BYTES } = options;
+  if (!imageUrl || (!imageUrl.startsWith("http://") && !imageUrl.startsWith("https://"))) {
+    return null;
+  }
+
+  let url;
+  try {
+    url = new URL(imageUrl);
+  } catch {
+    return null;
+  }
+  const pinnedIps = await resolvePinnedIps(url.hostname);
+  if (!pinnedIps) return null;
+
+  const controller = new AbortController();
+  const timeout = signal ? null : setTimeout(() => controller.abort(), timeoutMs);
+  const fetchSignal = signal || controller.signal;
+
+  // Pin connect to the validated IP so no second DNS resolution can rebind (TOCTOU fix).
+  const dispatcher = new Agent({
+    connect: {
+      lookup: (_h, _o, cb) =>
+        cb(null, [{ address: pinnedIps[0].address, family: pinnedIps[0].family }]),
+    },
+  });
+
+  try {
+    // redirect:"manual" prevents a public URL redirecting to a private one (SSRF bypass).
+    const response = await fetch(imageUrl, { signal: fetchSignal, redirect: "manual", dispatcher });
+    if (!response.ok || !response.body) return null;
+
+    // Stream-read with a hard byte cap to avoid loading huge payloads into memory.
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.length;
+      if (total > maxBytes) {
+        try {
+          await reader.cancel();
+        } catch {
+          /* ignore */
+        }
+        return null;
+      }
+      chunks.push(value);
+    }
+
+    const buf = Buffer.concat(chunks.map((c) => Buffer.from(c)));
+    const mimeType = detectImageMime(buf);
+    if (!mimeType) return null; // not a recognized image — reject disguised payloads
+
+    return { url: `data:${mimeType};base64,${buf.toString("base64")}`, mimeType };
+  } catch {
+    return null;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    dispatcher.close().catch(() => {});
+  }
+}

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

@@ -0,0 +1,9 @@
+// Safe JSON.parse: non-string passthrough; on parse error return caller-chosen `fallback`.
+export function safeParseJSON(str, fallback) {
+  if (typeof str !== "string") return str;
+  try {
+    return JSON.parse(str);
+  } catch {
+    return fallback;
+  }
+}

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

@@ -0,0 +1,8 @@
+import { OPENAI_BLOCK } from "../schema/index.js";
+
+// Collapse an OpenAI content-part array: text-only parts join into a plain
+// string, otherwise the array is returned as-is.
+export function collapseTextParts(parts) {
+  if (parts.every((p) => p.type === OPENAI_BLOCK.TEXT)) return parts.map((p) => p.text).join("\n");
+  return parts;
+}

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

@@ -0,0 +1,182 @@
+// Strip multimodal content blocks a model cannot read, BEFORE translation.
+// Driven by getCapabilitiesForModel: vision/audioInput/pdf. Replaces removed
+// media with a short text placeholder so messages never become empty.
+import { FORMATS } from "../formats.js";
+
+// Placeholder text inserted where a media block was removed.
+// Current turn: explain the active model can't read what the user just sent.
+const PLACEHOLDER_CURRENT = {
+  vision: "[image omitted: model has no vision support]",
+  audioInput: "[audio omitted: model has no audio support]",
+  pdf: "[file omitted: model has no document support]",
+};
+// Earlier turns: neutral (a combo may route to a different model each turn).
+const PLACEHOLDER_PREV = {
+  vision: "[Previous image omitted from context.]",
+  audioInput: "[Previous audio omitted from context.]",
+  pdf: "[Previous file omitted from context.]",
+};
+const ph = (cap, isLast) => (isLast ? PLACEHOLDER_CURRENT : PLACEHOLDER_PREV)[cap];
+
+// Map gemini inlineData/fileData mime prefix -> capability it requires.
+function capForMime(mime) {
+  if (typeof mime !== "string") return null;
+  if (mime.startsWith("image/")) return "vision";
+  if (mime.startsWith("audio/")) return "audioInput";
+  if (mime === "application/pdf") return "pdf";
+  return null;
+}
+
+// OpenAI chat content block -> required capability (null = plain text/other, keep).
+function capForOpenAIBlock(block) {
+  const t = block?.type;
+  if (t === "image_url" || t === "image") return "vision";
+  if (t === "input_audio" || t === "audio_url") return "audioInput";
+  if (t === "file") return "pdf";
+  return null;
+}
+
+// Claude content block -> required capability.
+function capForClaudeBlock(block) {
+  const t = block?.type;
+  if (t === "image") return "vision";
+  if (t === "document") return "pdf";
+  return null;
+}
+
+// Filter an array of content blocks; drop unsupported, inject one placeholder per kind.
+// isLast = block belongs to the current user turn (picks the explanatory placeholder).
+function filterBlocks(blocks, capOf, caps, removed, isLast) {
+  const out = [];
+  for (const block of blocks) {
+    const cap = capOf(block);
+    if (cap && caps[cap] === false) {
+      removed.add(cap);
+      continue;
+    }
+    out.push(block);
+  }
+  for (const cap of removed) out.push({ type: "text", text: ph(cap, isLast) });
+  return out;
+}
+
+// OpenAI / OpenAI-compatible chat messages[].content[].
+function stripOpenAI(body, caps) {
+  if (!Array.isArray(body.messages)) return;
+  const last = body.messages.length - 1;
+  body.messages.forEach((msg, i) => {
+    if (caps.vision === false) {
+      if (Array.isArray(msg.images)) delete msg.images;
+      if (Array.isArray(msg.experimental_attachments)) {
+        msg.experimental_attachments = msg.experimental_attachments.filter(
+          (a) =>
+            !(
+              a?.contentType?.startsWith("image/") ||
+              (typeof a?.url === "string" && a.url.startsWith("data:image/"))
+            ),
+        );
+      }
+      if (Array.isArray(msg.attachments)) {
+        msg.attachments = msg.attachments.filter(
+          (a) =>
+            !(
+              a?.contentType?.startsWith("image/") ||
+              (typeof a?.url === "string" && a.url.startsWith("data:image/"))
+            ),
+        );
+      }
+    }
+    if (!Array.isArray(msg.content)) return;
+    const removed = new Set();
+    msg.content = filterBlocks(msg.content, capForOpenAIBlock, caps, removed, i === last);
+  });
+}
+
+// Claude messages[].content[].
+function stripClaude(body, caps) {
+  if (!Array.isArray(body.messages)) return;
+  const last = body.messages.length - 1;
+  body.messages.forEach((msg, i) => {
+    if (!Array.isArray(msg.content)) return;
+    const removed = new Set();
+    msg.content = filterBlocks(msg.content, capForClaudeBlock, caps, removed, i === last);
+  });
+}
+
+// OpenAI Responses input[].content[] (input_image / input_file).
+function stripResponses(body, caps) {
+  if (!Array.isArray(body.input)) return;
+  const last = body.input.length - 1;
+  body.input.forEach((item, i) => {
+    if (!Array.isArray(item.content)) return;
+    const removed = new Set();
+    item.content = item.content.filter((b) => {
+      const cap = b?.type === "input_image" ? "vision" : b?.type === "input_file" ? "pdf" : null;
+      if (cap && caps[cap] === false) {
+        removed.add(cap);
+        return false;
+      }
+      return true;
+    });
+    for (const cap of removed) item.content.push({ type: "input_text", text: ph(cap, i === last) });
+  });
+}
+
+// Gemini contents[].parts[] (inlineData / fileData by mime).
+function stripGeminiParts(contents, caps) {
+  if (!Array.isArray(contents)) return;
+  const last = contents.length - 1;
+  contents.forEach((c, i) => {
+    if (!Array.isArray(c.parts)) return;
+    const removed = new Set();
+    c.parts = c.parts.filter((p) => {
+      const mime = p?.inlineData?.mimeType || p?.fileData?.mimeType;
+      const cap = capForMime(mime);
+      if (cap && caps[cap] === false) {
+        removed.add(cap);
+        return false;
+      }
+      return true;
+    });
+    for (const cap of removed) c.parts.push({ text: ph(cap, i === last) });
+  });
+}
+
+/**
+ * Remove media blocks the model can't read, in-place on the source-format body.
+ * @param {object} body - request body (source format)
+ * @param {string} sourceFormat - one of FORMATS
+ * @param {object} caps - capabilities from getCapabilitiesForModel
+ * @returns {boolean} true if anything was stripped-eligible (cap false for some modality)
+ */
+export function stripUnsupportedModalities(body, sourceFormat, caps) {
+  if (!body || !caps) return false;
+  // Fast exit: model supports everything we'd strip.
+  if (caps.vision !== false && caps.audioInput !== false && caps.pdf !== false) return false;
+
+  switch (sourceFormat) {
+    case FORMATS.OPENAI:
+    case FORMATS.OLLAMA:
+    case FORMATS.CURSOR:
+    case FORMATS.COMMANDCODE:
+      stripOpenAI(body, caps);
+      break;
+    case FORMATS.CLAUDE:
+      stripClaude(body, caps);
+      break;
+    case FORMATS.OPENAI_RESPONSES:
+    case FORMATS.OPENAI_RESPONSE:
+    case FORMATS.CODEX:
+      stripResponses(body, caps);
+      break;
+    case FORMATS.GEMINI:
+      stripGeminiParts(body.contents, caps);
+      break;
+    case FORMATS.ANTIGRAVITY:
+      stripGeminiParts(body?.request?.contents, caps);
+      break;
+    default:
+      stripOpenAI(body, caps);
+  }
+  return true;
+}

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

@@ -0,0 +1,80 @@
+import { getCapabilitiesForModel } from "../../providers/capabilities.js";
+
+// Strip request params a given provider/model rejects upstream (e.g. HTTP 400).
+// Config-driven: add a rule instead of scattering `delete body.x` across executors.
+
+// Each rule: optional provider, regex match on model, list of params to drop.
+// A param is removed only when it is present (!== undefined).
+const STRIP_RULES = [
+  // All Claude models: temperature deprecated/rejected upstream (Anthropic 400). #1748
+  { match: /claude/i, drop: ["temperature"] },
+  // GitHub Copilot gpt-5.4: temperature unsupported.
+  { provider: "github", match: /gpt-5\.4/i, drop: ["temperature"] },
+  // GitHub Copilot Claude (except opus/sonnet 4.6): thinking + reasoning_effort rejected. #713
+  {
+    provider: "github",
+    match: (m) => /claude/i.test(m) && !/claude.*(opus|sonnet).*4\.6/i.test(m),
+    drop: ["thinking", "reasoning_effort"],
+  },
+  // MiMo Desktop Preview models (account-service route): content must be plain string,
+  // rejects OpenAI content-part array. Cloud models keep their parts (mimo-v2-omni is multi-modal).
+  { provider: "xiaomi-mimo", match: /preview/i, flattenContent: true },
+  { provider: "volcengine-ark", match: /glm-5/i, clampToModelMaxOutput: true },
+  // VolcEngine Ark caps the Kimi family at max_tokens <= 32768, but the model's
+  // advertised ceiling is far higher (Kimi-K2.7-Code resolves to maxOutput 262144),
+  // so clampToModelMaxOutput alone leaves it uncapped and the request 400s with
+  // "integer above maximum value, expected <= 32768". Pin an explicit endpoint cap;
+  // min() with the model ceiling still applies if a variant's own limit is lower.
+  { provider: "volcengine-ark", match: /kimi/i, maxOutputCap: 32768, clampToModelMaxOutput: true },
+];
+
+// Test a rule's match (regex or predicate) against the model id.
+function matches(rule, model) {
+  if (!rule.match) return true;
+  return typeof rule.match === "function" ? rule.match(model) : rule.match.test(model);
+}
+
+function clampNumber(body, key, ceiling) {
+  if (typeof body[key] === "number" && Number.isFinite(body[key]) && body[key] > ceiling) {
+    body[key] = ceiling;
+  }
+}
+
+// Remove unsupported params from body in place; returns body.
+export function stripUnsupportedParams(provider, model, body) {
+  if (!model || !body || typeof body !== "object") return body;
+  for (const rule of STRIP_RULES) {
+    if (rule.provider && rule.provider !== provider) continue;
+    if (!matches(rule, model)) continue;
+    for (const key of rule.drop || []) {
+      if (body[key] !== undefined) delete body[key];
+    }
+    // CF Workers AI oneOf root schema only accepts content as plain string (#1926)
+    if (rule.flattenContent && Array.isArray(body.messages)) {
+      for (const msg of body.messages) {
+        if (msg && Array.isArray(msg.content)) {
+          msg.content = msg.content
+            .map((b) => (b?.type === "text" && typeof b.text === "string" ? b.text : ""))
+            .join("");
+        }
+      }
+    }
+    if (rule.clampToModelMaxOutput || Number.isFinite(rule.maxOutputCap)) {
+      const modelCeiling = getCapabilitiesForModel(provider, model).maxOutput;
+      const candidates = [];
+      if (rule.clampToModelMaxOutput && Number.isFinite(modelCeiling) && modelCeiling > 0) {
+        candidates.push(modelCeiling);
+      }
+      if (Number.isFinite(rule.maxOutputCap) && rule.maxOutputCap > 0) {
+        candidates.push(rule.maxOutputCap);
+      }
+      if (candidates.length > 0) {
+        const ceiling = Math.min(...candidates);
+        clampNumber(body, "max_tokens", ceiling);
+        clampNumber(body, "max_completion_tokens", ceiling);
+        clampNumber(body, "max_output_tokens", ceiling);
+      }
+    }
+  }
+  return body;
+}

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

@@ -0,0 +1,111 @@
+// Pre-fetch remote image URLs into base64 BEFORE translation, for target
+// formats whose upstream providers cannot fetch remote URLs themselves
+// (they require inline base64). Runs on the source-format body.
+import { FORMATS } from "../formats.js";
+import { fetchImageAsBase64, parseDataUri } from "./image.js";
+
+// Targets that require inline base64 images (cannot accept remote URLs).
+const TARGETS_NEED_BASE64 = new Set([
+  FORMATS.GEMINI,
+  FORMATS.ANTIGRAVITY,
+  FORMATS.OLLAMA,
+  FORMATS.COMMANDCODE,
+]);
+
+function isRemoteUrl(url) {
+  return typeof url === "string" && (url.startsWith("http://") || url.startsWith("https://"));
+}
+
+// Collect {get,set} accessors for every remote image URL in a source body.
+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.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:
+      pushGemini(body.contents);
+      break;
+    case FORMATS.ANTIGRAVITY:
+      pushGemini(body?.request?.contents);
+      break;
+    default:
+      pushOpenAI(body.messages);
+  }
+  return refs;
+}
+
+/**
+ * Replace remote image URLs with base64 data when the target needs inline data.
+ * No-op when target accepts remote URLs (e.g. openai, claude) or body has none.
+ * @returns {Promise<number>} count of images converted
+ */
+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; // already inline
+    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/open-sse/translator/concerns/reasoning.js

@@ -0,0 +1,23 @@
+import { ROLE } from "../schema/index.js";
+
+// Build OpenAI delta carrying reasoning_content (optional leading assistant role)
+export function reasoningDelta(text, withRole = false) {
+  return withRole ? { role: ROLE.ASSISTANT, reasoning_content: text } : { reasoning_content: text };
+}
+
+// Extract reasoning text from a streamed OpenAI-compatible delta across vendor shapes:
+//   - reasoning_content (GLM, Qwen, DeepSeek, Kimi, Step, Hunyuan)
+//   - reasoning (some compat layers)
+//   - reasoning_details[] (MiniMax reasoning_split=true): [{ text|content }]
+// Returns concatenated reasoning string, or "" when none.
+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/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";
+}