swayrouter 1.0.0

package/src/transformer/streamToJsonConverter.js

@@ -0,0 +1,87 @@
+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 };
+
+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);
+      }
+    }
+
+    if (buffer.trim()) {
+      processSSEMessage(buffer, state);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  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/src/translator/canonical.js

@@ -0,0 +1,81 @@
+import { FORMATS } from "./formats.js";
+import { getCapabilitiesForModel } from "../providers/capabilities.js";
+import { detectClientFormat } from "./detection.js";
+
+const FEATURE_KEYS = ["tools", "reasoning", "images", "audio", "video", "cache", "usage"];
+
+function clone(value) {
+  if (value == null || typeof value !== "object") return value;
+  return structuredClone(value);
+}
+
+function hasImages(body) {
+  return Array.isArray(body?.messages) && body.messages.some((message) =>
+    Array.isArray(message?.content) && message.content.some((part) =>
+      part?.type === "image_url" || part?.type === "image" || part?.source?.type === "base64",
+    ),
+  );
+}
+
+function hasAudio(body) {
+  return Array.isArray(body?.messages) && body.messages.some((message) =>
+    Array.isArray(message?.content) && message.content.some((part) =>
+      part?.type === "audio" || part?.type === "input_audio" || part?.type === "audio_url",
+    ),
+  );
+}
+
+function hasVideo(body) {
+  return Array.isArray(body?.messages) && body.messages.some((message) =>
+    Array.isArray(message?.content) && message.content.some((part) => part?.type === "video"),
+  );
+}
+
+export function inferFeatureIntent(body = {}) {
+  return {
+    tools: Array.isArray(body.tools) && body.tools.length > 0,
+    reasoning: body.reasoning !== undefined || body.reasoning_effort !== undefined || body.thinking !== undefined,
+    images: hasImages(body),
+    audio: hasAudio(body),
+    video: hasVideo(body),
+    cache: Boolean(body.prompt_cache_options || body.prompt_cache_breakpoint || body.cache_control),
+    usage: body.stream_options?.include_usage === true,
+  };
+}
+
+export function normalizeTranslationRequest({ body = {}, sourceFormat = FORMATS.OPENAI, model = "", provider = "", headers = {}, path = "" } = {}) {
+  const detected = detectClientFormat(headers, body, { path });
+  const features = inferFeatureIntent(body);
+  return {
+    body: clone(body),
+    sourceFormat,
+    model,
+    provider,
+    client: detected.id,
+    clientFormat: detected.format,
+    features,
+    metadata: { path, detectedSignals: detected.signals, detectionConfidence: detected.confidence },
+  };
+}
+
+export function resolveTranslationSurface({ provider = "", model = "", clientFormat = FORMATS.OPENAI, targetFormat = null, capabilityOverride = null } = {}) {
+  const caps = getCapabilitiesForModel(provider, model, capabilityOverride);
+  const wireFormat = targetFormat || provider || FORMATS.OPENAI;
+  const surface = wireFormat === FORMATS.CLAUDE ? FORMATS.CLAUDE
+    : wireFormat === FORMATS.GEMINI || wireFormat === FORMATS.VERTEX ? FORMATS.GEMINI
+      : wireFormat === FORMATS.OPENAI_RESPONSES ? FORMATS.OPENAI_RESPONSES
+        : FORMATS.OPENAI;
+  return { clientFormat, wireFormat: surface, capabilities: caps };
+}
+
+export function unsupportedFeatures(features = {}, capabilities = {}) {
+  return FEATURE_KEYS.filter((key) => {
+    if (!features[key]) return false;
+    if (key === "images") return capabilities.vision !== true;
+    if (key === "audio") return capabilities.audioInput !== true;
+    if (key === "video") return capabilities.videoInput !== true;
+    if (key === "reasoning") return capabilities.reasoning !== true;
+    if (key === "tools") return capabilities.tools === false;
+    return false;
+  });
+}

package/src/translator/concerns/chunk.js

@@ -0,0 +1,9 @@
+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/src/translator/concerns/compatFallback.js

@@ -0,0 +1,147 @@
+const CACHE_MAX_KEYS = 512;
+const CACHE_TTL_MS = 30 * 60 * 1000;
+
+if (!global._swayCompatFallback) {
+  global._swayCompatFallback = {
+
+    rejected: new Map(),
+  };
+}
+const REJECTED = global._swayCompatFallback.rejected;
+
+function cacheKey(provider, model) {
+  return `${provider || "?"}:${model || "?"}`;
+}
+
+export function rememberRejectedParam(provider, model, fieldPath) {
+  if (!fieldPath) return;
+  const key = cacheKey(provider, model);
+  let entry = REJECTED.get(key);
+  const now = Date.now();
+  if (!entry || entry.expireAt <= now) {
+
+    if (REJECTED.size >= CACHE_MAX_KEYS) {
+      const eldest = REJECTED.keys().next().value;
+      if (eldest !== undefined) REJECTED.delete(eldest);
+    }
+    entry = { paths: new Set(), expireAt: now + CACHE_TTL_MS };
+    REJECTED.set(key, entry);
+  }
+  entry.paths.add(fieldPath);
+
+  entry.expireAt = now + CACHE_TTL_MS;
+}
+
+export function stripKnownRejected(payload, provider, model) {
+  if (!payload || typeof payload !== "object") return [];
+  const key = cacheKey(provider, model);
+  const entry = REJECTED.get(key);
+  if (!entry) return [];
+  const now = Date.now();
+  if (entry.expireAt <= now) {
+    REJECTED.delete(key);
+    return [];
+  }
+  const stripped = [];
+  for (const path of entry.paths) {
+    if (removeCompatibilityProjection(payload, path)) stripped.push(path);
+  }
+  return stripped;
+}
+
+export function isOptionalProjectionPath(value) {
+  const path = normalizeFieldPath(value);
+  if (!path) return false;
+  if (path === "prompt_cache_options" || path === "prompt_cache_breakpoint") return true;
+  if (path.startsWith("prompt_cache_options.")) return true;
+  if (path === "reasoning" || path === "reasoning_effort" || path === "thinking") return true;
+  if (/^reasoning\.(?:effort|max_tokens|summary|exclude|enabled|mode)$/.test(path)) return true;
+  if (path === "output_config" || path === "output_config.effort") return true;
+  return (
+    path === "response_format" ||
+    path === "parallel_tool_calls" ||
+    path === "tool_choice" ||
+    path === "stream_options"
+  );
+}
+
+export function removeCompatibilityProjection(payload, fieldPath) {
+  const path = normalizeFieldPath(fieldPath);
+  if (!path || !isOptionalProjectionPath(path)) return false;
+  if (path === "prompt_cache_options") {
+    const had = _deleteTop(payload, "prompt_cache_options");
+    const nested =
+      _removeNested(payload.input, "prompt_cache_breakpoint") ||
+      _removeNested(payload.messages, "prompt_cache_breakpoint");
+    return had || nested;
+  }
+  if (path.startsWith("prompt_cache_options.")) {
+    return _removeNested(payload.prompt_cache_options, path.slice("prompt_cache_options.".length));
+  }
+  if (path === "prompt_cache_breakpoint") {
+    return (
+      _removeNested(payload.input, "prompt_cache_breakpoint") ||
+      _removeNested(payload.messages, "prompt_cache_breakpoint")
+    );
+  }
+  if (path === "reasoning") return _deleteTop(payload, "reasoning");
+  if (path.startsWith("reasoning.")) return _removeNested(payload.reasoning, path.slice("reasoning.".length));
+  if (path === "reasoning_effort" || path === "thinking") return _deleteTop(payload, path);
+  if (path === "output_config") return _deleteTop(payload, "output_config");
+  if (path.startsWith("output_config.")) return _removeNested(payload.output_config, path.slice("output_config.".length));
+  if (path === "response_format" || path === "parallel_tool_calls" || path === "tool_choice" || path === "stream_options") {
+    return _deleteTop(payload, path);
+  }
+  return false;
+}
+
+export function applyRejectedParam(payload, provider, model, fieldPath) {
+  const retryable = isOptionalProjectionPath(fieldPath);
+  if (!retryable) return { removed: false, retryable: false };
+  rememberRejectedParam(provider, model, normalizeFieldPath(fieldPath));
+  const removed = removeCompatibilityProjection(payload, fieldPath);
+  return { removed, retryable: true };
+}
+
+function normalizeFieldPath(value) {
+  return String(value ?? "").trim().toLowerCase().replace(/^["'`]|["'`]$/g, "");
+}
+
+function _isRecord(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v);
+}
+
+function _deleteTop(payload, field) {
+  if (_isRecord(payload) && Object.prototype.hasOwnProperty.call(payload, field)) {
+    delete payload[field];
+    return true;
+  }
+  return false;
+}
+
+function _removeNested(value, field) {
+  let removed = false;
+  if (Array.isArray(value)) {
+    for (const item of value) removed = _removeNested(item, field) || removed;
+    return removed;
+  }
+  if (!_isRecord(value)) return false;
+  if (Object.prototype.hasOwnProperty.call(value, field)) {
+    delete value[field];
+    removed = true;
+  }
+  for (const child of Object.values(value)) removed = _removeNested(child, field) || removed;
+  return removed;
+}
+
+export function __resetCompatFallbackForTests() {
+  REJECTED.clear();
+}
+
+export function _peekRejected(provider, model) {
+  const key = cacheKey(provider, model);
+  const entry = REJECTED.get(key);
+  if (!entry) return undefined;
+  if (entry.expireAt <= Date.now()) return undefined;
+  return new Set(entry.paths);
+}

package/src/translator/concerns/finishReason.js

@@ -0,0 +1,59 @@
+import { OPENAI_FINISH, CLAUDE_STOP, GEMINI_FINISH } from "../schema/finishReasons.js";
+
+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;
+  }
+}
+
+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/src/translator/concerns/image.js

@@ -0,0 +1,105 @@
+export function encodeDataUri(mimeType, base64) {
+  return `data:${mimeType};base64,${base64}`;
+}
+
+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";
+
+function isPrivateIp(ip) {
+  if (!ip) return true;
+
+  if (ip === "::1" || ip.startsWith("fc") || ip.startsWith("fd") || ip.startsWith("fe80")) return true;
+
+  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;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  return false;
+}
+
+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;
+  }
+}
+
+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;
+
+    if (verifyWebp && !(buf.length >= 12 && buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50)) continue;
+    return mime;
+  }
+  return 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;
+
+  const dispatcher = new Agent({
+    connect: { lookup: (_h, _o, cb) => cb(null, [{ address: pinnedIps[0].address, family: pinnedIps[0].family }]) },
+  });
+
+  try {
+
+    const response = await fetch(imageUrl, { signal: fetchSignal, redirect: "manual", dispatcher });
+    if (!response.ok || !response.body) return null;
+
+    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 {              } return null; }
+      chunks.push(value);
+    }
+
+    const buf = Buffer.concat(chunks.map((c) => Buffer.from(c)));
+    const mimeType = detectImageMime(buf);
+    if (!mimeType) return null;
+
+    return { url: `data:${mimeType};base64,${buf.toString("base64")}`, mimeType };
+  } catch {
+    return null;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    dispatcher.close().catch(() => {});
+  }
+}

package/src/translator/concerns/json.js

@@ -0,0 +1,4 @@
+export function safeParseJSON(str, fallback) {
+  if (typeof str !== "string") return str;
+  try { return JSON.parse(str); } catch { return fallback; }
+}