@fudrouter/fsrouter 0.6.58 → 0.6.60

package/open-sse/transformer/streamToJsonConverter.js

@@ -1,103 +0,0 @@
-/**
- * Stream-to-JSON Converter
- * Converts Responses API SSE stream to single JSON response
- * Used when client requests non-streaming but provider forces streaming (e.g., Codex)
- */
-
-/**
- * Process a single SSE message and update state accordingly.
- */
-function processSSEMessage(msg, state) {
-  if (!msg.trim()) return;
-
-  const eventMatch = msg.match(/^event:\s*(.+)$/m);
-  const dataMatch = msg.match(/^data:\s*(.+)$/m);
-  if (!eventMatch || !dataMatch) return;
-
-  const eventType = eventMatch[1].trim();
-  const dataStr = dataMatch[1].trim();
-  if (dataStr === "[DONE]") return;
-
-  let parsed;
-  try { parsed = JSON.parse(dataStr); }
-  catch { return; }
-
-  if (eventType === "response.created") {
-    state.responseId = parsed.response?.id || state.responseId;
-    state.created = parsed.response?.created_at || state.created;
-  } else if (eventType === "response.output_item.done") {
-    state.items.set(parsed.output_index ?? 0, parsed.item);
-  } else if (eventType === "response.completed" || eventType === "response.done") {
-    state.status = "completed";
-    if (parsed.response?.usage) {
-      state.usage.input_tokens = parsed.response.usage.input_tokens || 0;
-      state.usage.output_tokens = parsed.response.usage.output_tokens || 0;
-      state.usage.total_tokens = parsed.response.usage.total_tokens || 0;
-    }
-  } else if (eventType === "response.failed") {
-    state.status = "failed";
-  }
-}
-
-const EMPTY_RESPONSE = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
-
-/**
- * Convert Responses API SSE stream to single JSON response
- * @param {ReadableStream} stream - SSE stream from provider
- * @returns {Promise<Object>} Final JSON response in Responses API format
- */
-export async function convertResponsesStreamToJson(stream) {
-  if (!stream || typeof stream.getReader !== "function") {
-    return { id: `resp_${Date.now()}`, object: "response", created_at: Math.floor(Date.now() / 1000), status: "failed", output: [], usage: { ...EMPTY_RESPONSE } };
-  }
-
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-
-  const state = {
-    responseId: "",
-    created: Math.floor(Date.now() / 1000),
-    status: "in_progress",
-    usage: { ...EMPTY_RESPONSE },
-    items: new Map()
-  };
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const messages = buffer.split("\n\n");
-      buffer = messages.pop() || "";
-
-      for (const msg of messages) {
-        processSSEMessage(msg, state);
-      }
-    }
-
-    // Flush remaining buffer (last event may not end with \n\n)
-    if (buffer.trim()) {
-      processSSEMessage(buffer, state);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-
-  // Build output array from accumulated items (ordered by index)
-  const output = [];
-  const maxIndex = state.items.size > 0 ? Math.max(...state.items.keys()) : -1;
-  for (let i = 0; i <= maxIndex; i++) {
-    output.push(state.items.get(i) || { type: "message", content: [], role: "assistant" });
-  }
-
-  return {
-    id: state.responseId || `resp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-    object: "response",
-    created_at: state.created,
-    status: state.status || "completed",
-    output,
-    usage: state.usage
-  };
-}

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

@@ -1,11 +0,0 @@
-// Build OpenAI chat.completion.chunk. Caller supplies id/created/model so each
-// translator keeps its exact id-generation + created semantics (no Date.now here).
-export function buildChunk({ id, created, model }, delta, finishReason = null) {
-  return {
-    id,
-    object: "chat.completion.chunk",
-    created,
-    model,
-    choices: [{ index: 0, delta, finish_reason: finishReason }],
-  };
-}

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

@@ -1,63 +0,0 @@
-// Concern #6: finish_reason / stop_reason mapping.
-// One entry per direction; switch by special format, default handles common providers.
-import { OPENAI_FINISH, CLAUDE_STOP, GEMINI_FINISH } from "../schema/finishReasons.js";
-
-// upstream finish/stop reason → OpenAI finish_reason
-export function toOpenAIFinish(reason, format) {
-  switch (format) {
-    case "claude":
-      switch (reason) {
-        case CLAUDE_STOP.END_TURN: return OPENAI_FINISH.STOP;
-        case CLAUDE_STOP.MAX_TOKENS: return OPENAI_FINISH.LENGTH;
-        case CLAUDE_STOP.TOOL_USE: return OPENAI_FINISH.TOOL_CALLS;
-        case CLAUDE_STOP.STOP_SEQUENCE: return OPENAI_FINISH.STOP;
-        default: return OPENAI_FINISH.STOP;
-      }
-    case "commandcode":
-      switch (reason) {
-        case "stop": return OPENAI_FINISH.STOP;
-        case "length": return OPENAI_FINISH.LENGTH;
-        case "tool-calls":
-        case "tool_use": return OPENAI_FINISH.TOOL_CALLS;
-        case "content-filter": return OPENAI_FINISH.CONTENT_FILTER;
-        case "error": return OPENAI_FINISH.STOP;
-        default: return reason || OPENAI_FINISH.STOP;
-      }
-    case "gemini":
-      switch (String(reason).toUpperCase()) {
-        case GEMINI_FINISH.STOP: return OPENAI_FINISH.STOP;
-        case GEMINI_FINISH.MAX_TOKENS: return OPENAI_FINISH.LENGTH;
-        case GEMINI_FINISH.SAFETY:
-        case GEMINI_FINISH.RECITATION:
-        case GEMINI_FINISH.BLOCKLIST:
-        case GEMINI_FINISH.PROHIBITED_CONTENT: return OPENAI_FINISH.CONTENT_FILTER;
-        default: return OPENAI_FINISH.STOP;
-      }
-    case "kiro":
-    case "ollama":
-      switch (reason) {
-        case "tool_calls":
-        case "tool_use": return OPENAI_FINISH.TOOL_CALLS;
-        case "length":
-        case "max_tokens": return OPENAI_FINISH.LENGTH;
-        default: return OPENAI_FINISH.STOP;
-      }
-    default:
-      return reason || OPENAI_FINISH.STOP;
-  }
-}
-
-// OpenAI finish_reason → upstream stop reason
-export function fromOpenAIFinish(reason, format) {
-  switch (format) {
-    case "claude":
-      switch (reason) {
-        case OPENAI_FINISH.STOP: return CLAUDE_STOP.END_TURN;
-        case OPENAI_FINISH.LENGTH: return CLAUDE_STOP.MAX_TOKENS;
-        case OPENAI_FINISH.TOOL_CALLS: return CLAUDE_STOP.TOOL_USE;
-        default: return CLAUDE_STOP.END_TURN;
-      }
-    default:
-      return reason;
-  }
-}

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

@@ -1,124 +0,0 @@
-// 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

@@ -1,5 +0,0 @@
-// 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

@@ -1,7 +0,0 @@
-import { OPENAI_BLOCK } from "../schema/index.js";
-
-// Collapse an OpenAI content-part array: a lone text part becomes a plain string,
-// otherwise the array is returned as-is. Matches existing translator behavior.
-export function collapseTextParts(parts) {
-  return parts.length === 1 && parts[0].type === OPENAI_BLOCK.TEXT ? parts[0].text : parts;
-}

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

@@ -1,155 +0,0 @@
-// 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 (!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 / gemini-cli 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.KIRO:
-    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:
-    case FORMATS.GEMINI_CLI:
-    case FORMATS.VERTEX:
-      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

@@ -1,75 +0,0 @@
-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 = [
-  // claude-opus-4 series: temperature is deprecated (Anthropic 400). #1748
-  { match: /claude-opus-4/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"] },
-  // Cloudflare Workers AI: content must be plain string, rejects OpenAI content-part array (#1926)
-  { provider: "cloudflare-ai", 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

@@ -1,96 +0,0 @@
-// 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.GEMINI_CLI, FORMATS.VERTEX,
-  FORMATS.ANTIGRAVITY, FORMATS.OLLAMA, FORMATS.KIRO,
-]);
-
-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.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;
-}
-
-/**
- * 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

@@ -1,24 +0,0 @@
-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 "";
-}