swayrouter 1.0.0

package/src/translator/response/openai-to-claude.js

@@ -0,0 +1,231 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { ROLE, CLAUDE_BLOCK, MODEL_FALLBACK } from "../schema/index.js";
+import { fromOpenAIFinish } from "../concerns/finishReason.js";
+import { extractReasoningText } from "../concerns/reasoning.js";
+
+function sanitizeToolArgs(toolName, argsJson) {
+  try {
+    const args = JSON.parse(argsJson);
+    if (toolName === "Read") sanitizeReadArgs(args);
+    return JSON.stringify(args);
+  } catch {
+    return argsJson;
+  }
+}
+
+function sanitizeReadArgs(args) {
+  if (typeof args.limit === "string" && /^\d+$/.test(args.limit)) args.limit = Number(args.limit);
+  if (typeof args.offset === "string" && /^-?\d+$/.test(args.offset)) args.offset = Number(args.offset);
+
+  if (typeof args.limit === "number") {
+    if (args.limit > 2000) args.limit = 2000;
+    if (args.limit < 1) delete args.limit;
+  }
+  if (typeof args.offset === "number" && args.offset < 0) args.offset = 0;
+
+  if ("pages" in args && !isValidPdfPagesArg(args.file_path, args.pages)) {
+    delete args.pages;
+  }
+}
+
+function isValidPdfPagesArg(filePath, pages) {
+  return typeof filePath === "string" &&
+    filePath.toLowerCase().endsWith(".pdf") &&
+    typeof pages === "string" &&
+    /^\d+(?:-\d+)?$/.test(pages);
+}
+
+function stopThinkingBlock(state, results) {
+  if (!state.thinkingBlockStarted) return;
+  results.push({
+    type: "content_block_stop",
+    index: state.thinkingBlockIndex
+  });
+  state.thinkingBlockStarted = false;
+}
+
+function stopTextBlock(state, results) {
+  if (!state.textBlockStarted || state.textBlockClosed) return;
+  state.textBlockClosed = true;
+  results.push({
+    type: "content_block_stop",
+    index: state.textBlockIndex
+  });
+  state.textBlockStarted = false;
+}
+
+export function openaiToClaudeResponse(chunk, state) {
+  if (!chunk || !chunk.choices?.[0]) return null;
+
+  const results = [];
+  const choice = chunk.choices[0];
+  const delta = choice.delta;
+
+  if (chunk.usage && typeof chunk.usage === "object") {
+    const promptTokens = typeof chunk.usage.prompt_tokens === "number" ? chunk.usage.prompt_tokens : 0;
+    const outputTokens = typeof chunk.usage.completion_tokens === "number" ? chunk.usage.completion_tokens : 0;
+
+    const cachedTokens = chunk.usage.prompt_tokens_details?.cached_tokens;
+    const cacheCreationTokens = chunk.usage.prompt_tokens_details?.cache_creation_tokens;
+    const cacheReadTokens = typeof cachedTokens === "number" ? cachedTokens : 0;
+    const cacheCreateTokens = typeof cacheCreationTokens === "number" ? cacheCreationTokens : 0;
+
+    const inputTokens = promptTokens - cacheReadTokens - cacheCreateTokens;
+
+    state.usage = {
+      input_tokens: inputTokens,
+      output_tokens: outputTokens
+    };
+
+    if (cacheReadTokens > 0) {
+      state.usage.cache_read_input_tokens = cacheReadTokens;
+    }
+
+    if (cacheCreateTokens > 0) {
+      state.usage.cache_creation_input_tokens = cacheCreateTokens;
+    }
+
+  }
+
+  if (!state.messageStartSent) {
+    state.messageStartSent = true;
+    state.messageId = chunk.id?.replace("chatcmpl-", "") || `msg_${Date.now()}`;
+    if (!state.messageId || state.messageId === "chat" || state.messageId.length < 8) {
+      state.messageId = chunk.extend_fields?.requestId ||
+        chunk.extend_fields?.traceId ||
+        `msg_${Date.now()}`;
+    }
+    state.model = chunk.model || MODEL_FALLBACK;
+    state.nextBlockIndex = 0;
+    results.push({
+      type: "message_start",
+      message: {
+        id: state.messageId,
+        type: "message",
+        role: ROLE.ASSISTANT,
+        model: state.model,
+        content: [],
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 }
+      }
+    });
+  }
+
+  const reasoningContent = extractReasoningText(delta);
+  if (reasoningContent) {
+    stopTextBlock(state, results);
+
+    if (!state.thinkingBlockStarted) {
+      state.thinkingBlockIndex = state.nextBlockIndex++;
+      state.thinkingBlockStarted = true;
+      results.push({
+        type: "content_block_start",
+        index: state.thinkingBlockIndex,
+        content_block: { type: CLAUDE_BLOCK.THINKING, thinking: "" }
+      });
+    }
+
+    results.push({
+      type: "content_block_delta",
+      index: state.thinkingBlockIndex,
+      delta: { type: "thinking_delta", thinking: reasoningContent }
+    });
+  }
+
+  if (delta?.content) {
+    stopThinkingBlock(state, results);
+
+    if (!state.textBlockStarted) {
+      state.textBlockIndex = state.nextBlockIndex++;
+      state.textBlockStarted = true;
+      state.textBlockClosed = false;
+      results.push({
+        type: "content_block_start",
+        index: state.textBlockIndex,
+        content_block: { type: CLAUDE_BLOCK.TEXT, text: "" }
+      });
+    }
+
+    results.push({
+      type: "content_block_delta",
+      index: state.textBlockIndex,
+      delta: { type: "text_delta", text: delta.content }
+    });
+  }
+
+  if (delta?.tool_calls) {
+    for (const tc of delta.tool_calls) {
+      const idx = tc.index ?? 0;
+
+      if (tc.id && !state.toolCalls.has(idx)) {
+        stopThinkingBlock(state, results);
+        stopTextBlock(state, results);
+
+        const toolBlockIndex = state.nextBlockIndex++;
+        state.toolCalls.set(idx, { id: tc.id, name: tc.function?.name || "", blockIndex: toolBlockIndex });
+
+        const toolName = tc.function?.name || "";
+
+        results.push({
+          type: "content_block_start",
+          index: toolBlockIndex,
+          content_block: {
+            type: CLAUDE_BLOCK.TOOL_USE,
+            id: tc.id,
+            name: toolName,
+            input: {}
+          }
+        });
+      }
+
+      if (tc.function?.arguments) {
+        const toolInfo = state.toolCalls.get(idx);
+        if (toolInfo) {
+
+          if (!state.toolArgBuffers) state.toolArgBuffers = new Map();
+          state.toolArgBuffers.set(idx, (state.toolArgBuffers.get(idx) || "") + tc.function.arguments);
+        }
+      }
+    }
+  }
+
+  if (choice.finish_reason) {
+    stopThinkingBlock(state, results);
+    stopTextBlock(state, results);
+
+    for (const [idx, toolInfo] of state.toolCalls) {
+
+      const buffered = state.toolArgBuffers?.get(idx);
+      if (buffered) {
+        const sanitized = sanitizeToolArgs(toolInfo.name, buffered);
+        results.push({
+          type: "content_block_delta",
+          index: toolInfo.blockIndex,
+          delta: { type: "input_json_delta", partial_json: sanitized }
+        });
+      }
+      results.push({
+        type: "content_block_stop",
+        index: toolInfo.blockIndex
+      });
+    }
+
+    state.finishReason = choice.finish_reason;
+
+    const finalUsage = state.usage || { input_tokens: 0, output_tokens: 0 };
+    results.push({
+      type: "message_delta",
+      delta: { stop_reason: convertFinishReason(choice.finish_reason) },
+      usage: finalUsage
+    });
+    results.push({ type: "message_stop" });
+  }
+
+  return results.length > 0 ? results : null;
+}
+
+const convertFinishReason = (reason) => fromOpenAIFinish(reason, "claude");
+
+register(FORMATS.OPENAI, FORMATS.CLAUDE, null, openaiToClaudeResponse);

package/src/translator/schema/blocks.js

@@ -0,0 +1,40 @@
+export const OPENAI_BLOCK = {
+  TEXT: "text",
+  IMAGE_URL: "image_url",
+  IMAGE: "image",
+  INPUT_AUDIO: "input_audio",
+  AUDIO_URL: "audio_url",
+  FILE: "file",
+  FUNCTION: "function",
+};
+
+export const CLAUDE_BLOCK = {
+  TEXT: "text",
+  IMAGE: "image",
+  DOCUMENT: "document",
+  TOOL_USE: "tool_use",
+  TOOL_RESULT: "tool_result",
+  THINKING: "thinking",
+  REDACTED_THINKING: "redacted_thinking",
+};
+
+export const RESPONSES_ITEM = {
+  MESSAGE: "message",
+  FUNCTION_CALL: "function_call",
+  FUNCTION_CALL_OUTPUT: "function_call_output",
+  CUSTOM_TOOL_CALL: "custom_tool_call",
+  CUSTOM_TOOL_CALL_OUTPUT: "custom_tool_call_output",
+  ADDITIONAL_TOOLS: "additional_tools",
+  REASONING: "reasoning",
+  OUTPUT_TEXT: "output_text",
+  INPUT_TEXT: "input_text",
+  INPUT_IMAGE: "input_image",
+  SUMMARY_TEXT: "summary_text",
+};
+
+export const VALID_OPENAI_CONTENT_TYPES = [
+  OPENAI_BLOCK.TEXT, OPENAI_BLOCK.IMAGE_URL, OPENAI_BLOCK.IMAGE, OPENAI_BLOCK.INPUT_AUDIO, OPENAI_BLOCK.AUDIO_URL, OPENAI_BLOCK.FILE,
+];
+export const VALID_OPENAI_MESSAGE_TYPES = [
+  OPENAI_BLOCK.TEXT, OPENAI_BLOCK.IMAGE_URL, OPENAI_BLOCK.IMAGE, "tool_calls", CLAUDE_BLOCK.TOOL_RESULT,
+];

package/src/translator/schema/defaults.js

@@ -0,0 +1,3 @@
+export const MODEL_FALLBACK = "unknown";
+
+export const DEFAULT_IMAGE_MIME = "image/png";

package/src/translator/schema/finishReasons.js

@@ -0,0 +1,22 @@
+export const OPENAI_FINISH = {
+  STOP: "stop",
+  LENGTH: "length",
+  TOOL_CALLS: "tool_calls",
+  CONTENT_FILTER: "content_filter",
+};
+
+export const CLAUDE_STOP = {
+  END_TURN: "end_turn",
+  MAX_TOKENS: "max_tokens",
+  TOOL_USE: "tool_use",
+  STOP_SEQUENCE: "stop_sequence",
+};
+
+export const GEMINI_FINISH = {
+  STOP: "STOP",
+  MAX_TOKENS: "MAX_TOKENS",
+  SAFETY: "SAFETY",
+  RECITATION: "RECITATION",
+  BLOCKLIST: "BLOCKLIST",
+  PROHIBITED_CONTENT: "PROHIBITED_CONTENT",
+};

package/src/translator/schema/index.js

@@ -0,0 +1,7 @@
+export { ROLE, GEMINI_ROLE } from "./roles.js";
+export {
+  OPENAI_BLOCK, CLAUDE_BLOCK, RESPONSES_ITEM,
+  VALID_OPENAI_CONTENT_TYPES, VALID_OPENAI_MESSAGE_TYPES,
+} from "./blocks.js";
+export { OPENAI_FINISH, CLAUDE_STOP, GEMINI_FINISH } from "./finishReasons.js";
+export { MODEL_FALLBACK, DEFAULT_IMAGE_MIME } from "./defaults.js";

package/src/translator/schema/roles.js

@@ -0,0 +1,12 @@
+export const ROLE = {
+  USER: "user",
+  ASSISTANT: "assistant",
+  TOOL: "tool",
+  SYSTEM: "system",
+  DEVELOPER: "developer",
+};
+
+export const GEMINI_ROLE = {
+  USER: "user",
+  MODEL: "model",
+};

package/src/transport/requestBoundary.ts

@@ -0,0 +1,223 @@
+export function stampClientIp(raw: Request, peerIp: string | null): void {
+  const peer = (peerIp || "").replace(/^::ffff:/, "");
+  const isLoopback = peer === "127.0.0.1" || peer === "::1";
+  const xff = raw.headers.get("x-forwarded-for");
+  const xRealIp = raw.headers.get("x-real-ip");
+  const viaProxy = Boolean(xff || xRealIp);
+
+  let ip = peer;
+  if (isLoopback) {
+    const proxyIp = xRealIp ?? (xff ? String(xff).split(",")[0]?.trim() : "");
+    if (proxyIp) ip = proxyIp;
+  }
+
+  raw.headers.delete("x-swayrouter-real-ip");
+  raw.headers.delete("x-forwarded-for");
+  raw.headers.delete("x-swayrouter-via-proxy");
+  raw.headers.set("x-swayrouter-real-ip", ip);
+  if (viaProxy) raw.headers.set("x-swayrouter-via-proxy", "1");
+}
+
+const KIB = 1024;
+const MIB = 1024 * KIB;
+
+export function getRequestBodyLimitBytes(pathname: string, method = "GET"): number {
+  if (!["POST", "PUT", "PATCH", "DELETE"].includes(String(method).toUpperCase())) return 0;
+  const path = String(pathname || "");
+  if (path === "/api/v1/images/generations" || path === "/v1/images/generations") return 256 * KIB;
+  if (path === "/api/v1/images/edits" || path === "/v1/images/edits") return 10 * MIB;
+  if (
+    path === "/api/v1/chat/completions" ||
+    path === "/v1/chat/completions" ||
+    path === "/api/v1/responses" ||
+    path === "/v1/responses" ||
+    path === "/api/v1/messages" ||
+    path === "/v1/messages" ||
+    path === "/codex" ||
+    path === "/responses"
+  ) return 8 * MIB;
+  if (path === "/api/settings/database" || path === "/api/settings/migrate-9router") return 25 * MIB;
+  return 1 * MIB;
+}
+
+function declaredContentLength(request: Request): number | null {
+  const value = request.headers.get("content-length");
+  if (!value) return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+
+export function estimateRequestBodyBytes(request: Request, maxBytes: number): number {
+  if (maxBytes <= 0 || !request.body) return 0;
+  const declared = declaredContentLength(request);
+  if (declared === null) return maxBytes;
+  if (declared > maxBytes) return 0;
+  return declared;
+}
+
+/**
+ * Assign a small amount of work budget to large bodies. Active request count
+ * alone treats an 8 MiB prompt and a tiny health check as identical, which
+ * lets a burst of large uploads consume the event loop and memory at once.
+ */
+export function estimateRequestWorkUnits(request: Request, maxBytes: number): number {
+  if (maxBytes <= 0 || !request.body) return 1;
+  const declared = declaredContentLength(request);
+  const size = declared === null ? Math.min(maxBytes, 512 * KIB) : declared;
+  if (size <= 256 * KIB) return 1;
+  if (size <= 1 * MIB) return 2;
+  return Math.min(8, 1 + Math.ceil(size / MIB));
+}
+
+export async function readRequestBodyWithLimit(
+  raw: Request,
+  maxBytes: number,
+  timeoutMs = 30_000,
+): Promise<{ request: Request; tooLarge: boolean }> {
+  const declared = declaredContentLength(raw);
+  if (declared !== null && declared > maxBytes) return { request: raw, tooLarge: true };
+  if (!raw.body) return { request: raw, tooLarge: false };
+
+  const reader = raw.body.getReader();
+  const declaredBody = declared === null ? null : new Uint8Array(declared);
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  let abortHandler: (() => void) | null = null;
+  const abortPromise = raw.signal
+    ? new Promise<never>((_, reject) => {
+      abortHandler = () => {
+        const error = new Error("Request body read aborted");
+        (error as Error & { code?: string }).code = "REQUEST_ABORTED";
+        reject(error);
+      };
+      if (raw.signal.aborted) abortHandler();
+      else raw.signal.addEventListener("abort", abortHandler, { once: true });
+    })
+    : null;
+  try {
+    while (true) {
+      let timer: ReturnType<typeof setTimeout> | null = null;
+      const readPromise = reader.read();
+      const timeoutPromise = timeoutMs > 0
+        ? new Promise<never>((_, reject) => {
+          timer = setTimeout(() => {
+            const error = new Error("Request body read timed out");
+            (error as Error & { code?: string }).code = "REQUEST_BODY_TIMEOUT";
+            reject(error);
+          }, timeoutMs);
+        })
+        : null;
+      let result;
+      try {
+        if (timeoutPromise && abortPromise) {
+          result = await Promise.race([readPromise, timeoutPromise, abortPromise]);
+        } else if (timeoutPromise) {
+          result = await Promise.race([readPromise, timeoutPromise]);
+        } else if (abortPromise) {
+          result = await Promise.race([readPromise, abortPromise]);
+        } else {
+          result = await readPromise;
+        }
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+      const { done, value } = result;
+      if (done) break;
+      const chunk = value instanceof Uint8Array ? value : new Uint8Array(value);
+      total += chunk.byteLength;
+      if (total > maxBytes || (declared !== null && total > declared)) {
+        await reader.cancel("request body too large").catch(() => {});
+        return { request: raw, tooLarge: true };
+      }
+      if (declaredBody) declaredBody.set(chunk, total - chunk.byteLength);
+      else chunks.push(chunk);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {});
+    const code = (error as Error & { code?: string })?.code;
+    if (code === "REQUEST_BODY_TIMEOUT" || code === "REQUEST_ABORTED") throw error;
+    throw new Error("Unable to read request body");
+  } finally {
+    if (raw.signal && abortHandler) raw.signal.removeEventListener("abort", abortHandler);
+  }
+
+  const body = declaredBody ?? new Uint8Array(total);
+  if (!declaredBody) {
+    let offset = 0;
+    for (const chunk of chunks) {
+      body.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+  }
+  const bodyView = body.byteLength === total ? body : body.subarray(0, total);
+  return {
+    request: new Request(raw.url, {
+      method: raw.method,
+      headers: raw.headers,
+      body: bodyView.byteLength ? bodyView : undefined,
+      signal: raw.signal,
+    }),
+    tooLarge: false,
+  };
+}
+
+export function downgradeH2c(raw: Request): void {
+  if ((raw.headers.get("upgrade") || "").toLowerCase() !== "h2c") return;
+  raw.headers.delete("upgrade");
+  raw.headers.delete("http2-settings");
+  raw.headers.set("connection", "close");
+}
+
+export function queryCanonicalPath(pathname: string): string {
+  if (pathname === "/v1") return "/api/v1";
+  if (pathname.startsWith("/v1/")) return `/api/v1/${pathname.slice(4)}`;
+  if (pathname === "/codex") return "/api/v1/responses";
+  if (pathname.startsWith("/codex/")) return `/api/v1/responses/${pathname.slice("/codex/".length)}`;
+  if (pathname === "/responses") return "/api/v1/responses";
+  if (pathname.startsWith("/responses/")) return `/api/v1/responses/${pathname.slice("/responses/".length)}`;
+  return pathname;
+}
+
+export function isQueryReadOnlyPath(pathname: string): boolean {
+  const canonical = queryCanonicalPath(pathname);
+  if (!canonical.startsWith("/api/")) return false;
+  return !(
+    canonical.startsWith("/api/v1") ||
+    canonical.startsWith("/api/chat") ||
+    canonical.startsWith("/api/auth") ||
+    canonical.startsWith("/api/cli-tools") ||
+    canonical.startsWith("/api/providers/test") ||
+    canonical.startsWith("/api/providers/validate") ||
+    canonical.startsWith("/api/connections")
+  );
+}
+
+export function normalizeQueryRequest(raw: Request): Request {
+  if (raw.method.toUpperCase() !== "QUERY") return raw;
+  const url = new URL(raw.url);
+  if (!isQueryReadOnlyPath(url.pathname)) return raw;
+  const headers = new Headers(raw.headers);
+  headers.set("x-swayrouter-query-method", "QUERY");
+  return new Request(url.toString(), { method: "GET", headers, signal: raw.signal });
+}
+
+export function rewritePublicAlias(raw: Request): Request {
+  const url = new URL(raw.url);
+  const p = url.pathname;
+  const to = (dest: string) => {
+    url.pathname = dest;
+    const next = new Request(url.toString(), raw);
+    next.headers.set("x-swayrouter-rewritten", dest);
+    return next;
+  };
+
+  if (p.startsWith("/v1/v1/")) return to(`/api/v1/${p.slice("/v1/v1/".length)}`);
+  if (p === "/v1/v1") return to("/api/v1");
+  if (p.startsWith("/codex/")) return to(`/api/v1/responses/${p.slice("/codex/".length)}`);
+  if (p === "/codex") return to("/api/v1/responses");
+  if (p.startsWith("/responses/")) return to(`/api/v1/responses/${p.slice("/responses/".length)}`);
+  if (p === "/responses") return to("/api/v1/responses");
+  if (p.startsWith("/v1/")) return to(`/api/v1/${p.slice("/v1/".length)}`);
+  if (p === "/v1") return to("/api/v1");
+  return raw;
+}