swayrouter 1.0.0

package/src/utils/proxyFetch.js

@@ -0,0 +1,308 @@
+import http from "node:http";
+import https from "node:https";
+import { Readable } from "node:stream";
+import { MEMORY_CONFIG } from "../config/runtimeConfig.js";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { request as undiciRequest } from "undici/index.js";
+import { normalizeProxyUrl as normalizeProxyUrlShared } from "../lib/network/proxyUrl.js";
+
+const socksAgents = new Map();
+
+function normalizeString(value) {
+  if (value === undefined || value === null) return "";
+  return String(value).trim();
+}
+
+function shouldBypassByNoProxy(targetUrl, noProxyValue) {
+  const noProxy = normalizeString(noProxyValue);
+  if (!noProxy) return false;
+
+  let hostname;
+  try {
+    hostname = new URL(targetUrl).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  const patterns = noProxy
+    .split(",")
+    .map((p) => p.trim().toLowerCase())
+    .filter(Boolean);
+
+  return patterns.some((pattern) => {
+    if (pattern === "*") return true;
+    if (pattern.startsWith("."))
+      return hostname.endsWith(pattern) || hostname === pattern.slice(1);
+    return hostname === pattern || hostname.endsWith(`.${pattern}`);
+  });
+}
+
+function isLoopbackHostname(hostname) {
+  const normalized = String(hostname || "")
+    .replace(/^\[|\]$/g, "")
+    .toLowerCase();
+  return (
+    normalized === "localhost" ||
+    normalized.endsWith(".localhost") ||
+    normalized === "::1" ||
+    normalized.startsWith("127.")
+  );
+}
+
+function isEnvironmentProxyBypassed(targetUrl) {
+  let parsed;
+  try {
+    parsed = new URL(targetUrl);
+  } catch {
+    return false;
+  }
+  if (isLoopbackHostname(parsed.hostname)) return true;
+  return shouldBypassByNoProxy(
+    targetUrl,
+    process.env.NO_PROXY || process.env.no_proxy,
+  );
+}
+
+function getEnvProxyUrl(targetUrl) {
+  if (isEnvironmentProxyBypassed(targetUrl)) return null;
+
+  let parsed;
+  try {
+    parsed = new URL(targetUrl);
+  } catch {
+    return null;
+  }
+
+  if (parsed.protocol === "https:") {
+    return (
+      process.env.HTTPS_PROXY ||
+      process.env.https_proxy ||
+      process.env.ALL_PROXY ||
+      process.env.all_proxy
+    );
+  }
+
+  return (
+    process.env.HTTP_PROXY ||
+    process.env.http_proxy ||
+    process.env.ALL_PROXY ||
+    process.env.all_proxy
+  );
+}
+
+function normalizeProxyUrl(proxyUrl, proxyType) {
+  try {
+    return normalizeProxyUrlShared(proxyUrl, proxyType);
+  } catch {
+    return null;
+  }
+}
+
+function resolveConnectionProxyUrl(targetUrl, proxyOptions) {
+  const enabled =
+    proxyOptions?.enabled === true ||
+    proxyOptions?.connectionProxyEnabled === true;
+  if (!enabled) return null;
+
+  const proxyUrlRaw = normalizeString(
+    proxyOptions?.url ?? proxyOptions?.connectionProxyUrl,
+  );
+  if (!proxyUrlRaw) return null;
+
+  const noProxy = normalizeString(
+    proxyOptions?.noProxy ?? proxyOptions?.connectionNoProxy,
+  );
+  if (noProxy && shouldBypassByNoProxy(targetUrl, noProxy)) return null;
+
+  return normalizeProxyUrl(proxyUrlRaw, proxyOptions?.type);
+}
+
+function isConnectionProxyBypassed(targetUrl, proxyOptions) {
+  const enabled =
+    proxyOptions?.enabled === true ||
+    proxyOptions?.connectionProxyEnabled === true;
+  if (!enabled) return false;
+
+  const proxyUrlRaw = normalizeString(
+    proxyOptions?.url ?? proxyOptions?.connectionProxyUrl,
+  );
+  if (!proxyUrlRaw) return false;
+
+  const noProxy = normalizeString(
+    proxyOptions?.noProxy ?? proxyOptions?.connectionNoProxy,
+  );
+  return Boolean(noProxy && shouldBypassByNoProxy(targetUrl, noProxy));
+}
+
+async function getSocksAgent(proxyUrl) {
+  const normalized = normalizeProxyUrl(proxyUrl);
+  if (!normalized) return null;
+
+  if (!socksAgents.has(normalized)) {
+    if (socksAgents.size >= MEMORY_CONFIG.proxyDispatchersMaxSize) {
+      socksAgents.delete(socksAgents.keys().next().value);
+    }
+    socksAgents.set(normalized, new SocksProxyAgent(normalized));
+  }
+
+  return socksAgents.get(normalized);
+}
+
+function isSocksUrl(value) {
+  try {
+    const protocol = new URL(value).protocol;
+    return protocol === "socks5:" || protocol === "socks5h:";
+  } catch {
+    return false;
+  }
+}
+
+function normalizeRequestHeaders(headers) {
+  if (!headers) return undefined;
+  if (headers instanceof Headers) return Object.fromEntries(headers.entries());
+  return { ...headers };
+}
+
+async function directFetch(url, options = {}) {
+  const response = await undiciRequest(url, {
+    method: options.method || "GET",
+    headers: normalizeRequestHeaders(options.headers),
+    body: options.body ?? undefined,
+    signal: options.signal,
+  });
+  const responseHeaders = new Headers();
+  for (const [key, value] of Object.entries(response.headers || {})) {
+    if (Array.isArray(value))
+      value.forEach((item) => responseHeaders.append(key, String(item)));
+    else if (value !== undefined) responseHeaders.set(key, String(value));
+  }
+  return new Response(Readable.toWeb(response.body), {
+    status: response.statusCode,
+    headers: responseHeaders,
+  });
+}
+
+async function fetchThroughSocks(url, options, proxyUrl) {
+  const target = new URL(url);
+  const transport = target.protocol === "http:" ? http : https;
+  const agent = await getSocksAgent(proxyUrl);
+  return new Promise((resolve, reject) => {
+    const request = transport.request(
+      target,
+      {
+        method: options.method || "GET",
+        headers: options.headers,
+        agent,
+      },
+      (response) => {
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(response.headers)) {
+          if (Array.isArray(value))
+            value.forEach((item) => headers.append(key, String(item)));
+          else if (value !== undefined) headers.set(key, String(value));
+        }
+        resolve(
+          new Response(Readable.toWeb(response), {
+            status: response.statusCode || 0,
+            statusText: response.statusMessage || "",
+            headers,
+          }),
+        );
+      },
+    );
+    request.once("error", reject);
+    if (options.signal) {
+      const abort = () => request.destroy(new Error("Proxy request aborted"));
+      if (options.signal.aborted) abort();
+      else options.signal.addEventListener("abort", abort, { once: true });
+    }
+    if (options.body) request.write(options.body);
+    request.end();
+  });
+}
+
+async function requestViaProxy(url, options, proxyUrl) {
+  if (isSocksUrl(proxyUrl)) return fetchThroughSocks(url, options, proxyUrl);
+  return Bun.fetch(url, { ...options, proxy: proxyUrl });
+}
+
+export async function proxyAwareFetch(url, options = {}, proxyOptions = null) {
+  const targetUrl = typeof url === "string" ? url : url.toString();
+
+  if (
+    proxyOptions?.proxyPoolUnavailable === true &&
+    proxyOptions?.strictProxy === true
+  ) {
+    throw new Error(
+      `[ProxyFetch] Proxy pool unavailable: ${proxyOptions.proxyPoolError || "assigned pool cannot be used"}`,
+    );
+  }
+
+  const relayUrl = normalizeString(
+    proxyOptions?.relayUrl || proxyOptions?.vercelRelayUrl,
+  );
+  if (relayUrl) {
+    const parsed = new URL(targetUrl);
+    const noProxy = normalizeString(
+      proxyOptions?.noProxy ?? proxyOptions?.connectionNoProxy,
+    );
+    if (noProxy && shouldBypassByNoProxy(targetUrl, noProxy)) {
+      return directFetch(url, options);
+    }
+    const relayHeaders = new Headers(options.headers || {});
+    relayHeaders.set("x-relay-target", `${parsed.protocol}//${parsed.host}`);
+    relayHeaders.set("x-relay-path", `${parsed.pathname}${parsed.search}`);
+    const relayToken = normalizeString(proxyOptions?.relayToken);
+    if (relayToken) relayHeaders.set("x-sway-relay-token", relayToken);
+    return Bun.fetch(relayUrl, { ...options, headers: relayHeaders });
+  }
+
+  const connectionProxyBypassed = isConnectionProxyBypassed(
+    targetUrl,
+    proxyOptions,
+  );
+  const connectionProxyUrl = connectionProxyBypassed
+    ? null
+    : resolveConnectionProxyUrl(targetUrl, proxyOptions);
+
+  const environmentProxyBypassed = isEnvironmentProxyBypassed(targetUrl);
+  const envProxyUrl =
+    connectionProxyBypassed || connectionProxyUrl || environmentProxyBypassed
+      ? null
+      : normalizeProxyUrl(getEnvProxyUrl(targetUrl));
+  const proxyUrl = connectionProxyUrl || envProxyUrl;
+
+  if (
+    connectionProxyBypassed ||
+    (!connectionProxyUrl && environmentProxyBypassed)
+  ) {
+    return directFetch(url, options);
+  }
+
+  if (proxyUrl) {
+    try {
+      return await requestViaProxy(url, options, proxyUrl);
+    } catch (proxyError) {
+      if (proxyOptions?.strictProxy === true) {
+        throw new Error(
+          `[ProxyFetch] Proxy required but failed (strictProxy=true): ${proxyError.message}`,
+        );
+      }
+      console.warn(
+        `[ProxyFetch] Proxy failed, falling back to direct: ${proxyError.message}`,
+      );
+      return directFetch(url, options);
+    }
+  }
+
+  return Bun.fetch(url, options);
+}
+
+async function patchedFetch(url, options = {}) {
+  return proxyAwareFetch(url, options, null);
+}
+
+if (globalThis.fetch !== patchedFetch) {
+  globalThis.fetch = patchedFetch;
+}
+
+export default patchedFetch;

package/src/utils/reasoningContentInjector.js

@@ -0,0 +1,71 @@
+import { PROVIDERS } from "../config/providers.js";
+
+const PLACEHOLDER = " ";
+
+const providerRuleFor = (provider) => PROVIDERS[provider]?.reasoningInject;
+
+const MODEL_RULES = [
+  { match: m => /^kimi-/i.test(m || ""), scope: "toolCalls" },
+  { match: m => /deepseek/i.test(m || ""), scope: "all" }
+];
+
+const DEEPSEEK_V4_PRO = "deepseek-v4-pro";
+const DEEPSEEK_V4_PRO_ALIASES = {
+  [`${DEEPSEEK_V4_PRO}-max`]: {
+    thinkingType: "enabled",
+    reasoningEffort: "max"
+  },
+  [`${DEEPSEEK_V4_PRO}-none`]: {
+    thinkingType: "disabled",
+    reasoningEffort: null
+  }
+};
+
+function shouldInject(message, scope) {
+  if (message?.role !== "assistant") return false;
+  const rc = message.reasoning_content;
+  if (typeof rc === "string" && rc.length > 0) return false;
+  if (scope === "toolCalls") return Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+  return true;
+}
+
+function applyRule(body, rule) {
+  if (!rule || !body?.messages) return body;
+  const messages = body.messages.map(m =>
+    shouldInject(m, rule.scope) ? { ...m, reasoning_content: PLACEHOLDER } : m
+  );
+  return { ...body, messages };
+}
+
+function applyDeepSeekV4ProAlias({ provider, model, body }) {
+  const alias = DEEPSEEK_V4_PRO_ALIASES[model];
+  if (provider !== "deepseek" || !alias || !body) return body;
+
+  const nextBody = {
+    ...body,
+    model: DEEPSEEK_V4_PRO,
+    extra_body: {
+      ...(body.extra_body || {}),
+      thinking: {
+        ...(body.extra_body?.thinking || {}),
+        type: alias.thinkingType
+      }
+    }
+  };
+
+  if (alias.reasoningEffort) {
+    nextBody.reasoning_effort = alias.reasoningEffort;
+  } else {
+    delete nextBody.reasoning_effort;
+  }
+
+  return nextBody;
+}
+
+export function injectReasoningContent({ provider, model, body }) {
+  const providerRule = providerRuleFor(provider);
+  const modelRule = MODEL_RULES.find(r => r.match(model));
+  const rule = providerRule || modelRule;
+  const nextBody = applyDeepSeekV4ProAlias({ provider, model, body });
+  return applyRule(nextBody, rule);
+}

package/src/utils/requestLogger.js

@@ -0,0 +1,272 @@
+const isNode = typeof process !== "undefined" && process.versions?.node && typeof window === "undefined";
+
+import { env } from "@/lib/env";
+
+const LOGGING_ENABLED = isNode && env.requestLogsEnabled;
+
+let fs = null;
+let path = null;
+let LOGS_DIR = null;
+
+async function ensureNodeModules() {
+  if (!isNode || !LOGGING_ENABLED || fs) return;
+  try {
+    fs = await import("fs");
+    path = await import("path");
+    LOGS_DIR = path.join(env.dataDir || (typeof process !== "undefined" && process.cwd ? process.cwd() : "."), "logs");
+  } catch {
+
+  }
+}
+
+function formatTimestamp(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const y = date.getFullYear();
+  const m = pad(date.getMonth() + 1);
+  const d = pad(date.getDate());
+  const h = pad(date.getHours());
+  const min = pad(date.getMinutes());
+  const s = pad(date.getSeconds());
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  return `${y}${m}${d}_${h}${min}${s}_${ms}`;
+}
+
+async function createLogSession(sourceFormat, targetFormat, model) {
+  await ensureNodeModules();
+  if (!fs || !LOGS_DIR) return null;
+
+  try {
+    if (!fs.existsSync(LOGS_DIR)) {
+      fs.mkdirSync(LOGS_DIR, { recursive: true });
+    }
+
+    const timestamp = formatTimestamp();
+    const safeModel = (model || "unknown").replace(/[/:]/g, "-");
+    const folderName = `${sourceFormat}_${targetFormat}_${safeModel}_${timestamp}`;
+    const sessionPath = path.join(LOGS_DIR, folderName);
+
+    fs.mkdirSync(sessionPath, { recursive: true });
+
+    return sessionPath;
+  } catch (err) {
+    console.log("[LOG] Failed to create log session:", err.message);
+    return null;
+  }
+}
+
+function writeJsonFile(sessionPath, filename, data) {
+  if (!fs || !sessionPath) return;
+
+  try {
+    const filePath = path.join(sessionPath, filename);
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  } catch (err) {
+    console.log(`[LOG] Failed to write ${filename}:`, err.message);
+  }
+}
+
+const SENSITIVE_KEY_PATTERN = /(authorization|proxy-authorization|api[-_]?key|cookie|set-cookie|token|secret|password|credential|private[-_]?key|signature)/i;
+const MAX_CAPTURE_BYTES = 64 * 1024;
+const MAX_STREAM_LOG_BYTES = 1024 * 1024;
+const MAX_PENDING_STREAM_LOG_BYTES = 256 * 1024;
+
+function redactString(value) {
+  const text = String(value);
+  if (text.length > MAX_CAPTURE_BYTES) return `[redacted:truncated ${text.length} bytes]`;
+  return text;
+}
+
+function redactValue(value, key = "", seen = new WeakSet()) {
+  if (SENSITIVE_KEY_PATTERN.test(key)) return "[REDACTED]";
+  if (typeof value === "string") return redactString(value);
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return "[REDACTED:circular]";
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((item) => redactValue(item, key, seen));
+  const output = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    output[childKey] = redactValue(childValue, childKey, seen);
+  }
+  return output;
+}
+
+function maskSensitiveHeaders(headers) {
+  if (!headers) return {};
+  const plain = typeof headers.entries === "function" ? Object.fromEntries(headers.entries()) : headers;
+  return redactValue(plain);
+}
+
+function redactBody(body) {
+  return redactValue(body);
+}
+
+function createNoOpLogger() {
+  return {
+    sessionPath: null,
+    logClientRawRequest() {},
+    logRawRequest() {},
+    logOpenAIRequest() {},
+    logTargetRequest() {},
+    logProviderResponse() {},
+    appendProviderChunk() {},
+    appendOpenAIChunk() {},
+    logConvertedResponse() {},
+    appendConvertedChunk() {},
+    logError() {}
+  };
+}
+
+export async function createRequestLogger(sourceFormat, targetFormat, model) {
+
+  if (!LOGGING_ENABLED) {
+    return createNoOpLogger();
+  }
+
+  const sessionPath = await createLogSession(sourceFormat, targetFormat, model);
+  const pendingChunks = new Map();
+  const streamBytes = new Map();
+  let pendingBytes = 0;
+  let flushTimer = null;
+  let flushChain = Promise.resolve();
+
+  const flushPendingChunks = () => {
+    flushTimer = null;
+    if (!fs || !sessionPath || pendingChunks.size === 0) return;
+    const batch = [...pendingChunks.entries()];
+    pendingChunks.clear();
+    pendingBytes = 0;
+    flushChain = flushChain.then(async () => {
+      for (const [filename, chunk] of batch) {
+        try {
+          await fs.promises.appendFile(path.join(sessionPath, filename), chunk);
+        } catch {
+          // Request logging must never affect the proxy response.
+        }
+      }
+    }).catch(() => {});
+  };
+
+  const queueStreamChunk = (filename, chunk) => {
+    if (!fs || !sessionPath || chunk == null) return;
+    const text = String(chunk);
+    const currentBytes = streamBytes.get(filename) || 0;
+    const remaining = MAX_STREAM_LOG_BYTES - currentBytes;
+    if (!text || remaining <= 0 || pendingBytes >= MAX_PENDING_STREAM_LOG_BYTES) return;
+    const bounded = text.slice(0, remaining);
+    const byteLength = Buffer.byteLength(bounded, "utf8");
+    if (!byteLength || pendingBytes + byteLength > MAX_PENDING_STREAM_LOG_BYTES) return;
+    streamBytes.set(filename, currentBytes + byteLength);
+    pendingChunks.set(filename, `${pendingChunks.get(filename) || ""}${bounded}`);
+    pendingBytes += byteLength;
+    if (!flushTimer) {
+      flushTimer = setTimeout(flushPendingChunks, 50);
+      flushTimer?.unref?.();
+    }
+  };
+
+  return {
+    get sessionPath() { return sessionPath; },
+
+    logClientRawRequest(endpoint, body, headers = {}) {
+      writeJsonFile(sessionPath, "1_req_client.json", {
+        timestamp: new Date().toISOString(),
+        endpoint,
+        headers: maskSensitiveHeaders(headers),
+        body: redactBody(body)
+      });
+    },
+
+    logRawRequest(body, headers = {}) {
+      writeJsonFile(sessionPath, "2_req_source.json", {
+        timestamp: new Date().toISOString(),
+        headers: maskSensitiveHeaders(headers),
+        body: redactBody(body)
+      });
+    },
+
+    logOpenAIRequest(body) {
+      writeJsonFile(sessionPath, "3_req_openai.json", {
+        timestamp: new Date().toISOString(),
+        body: redactBody(body)
+      });
+    },
+
+    logTargetRequest(url, headers, body) {
+      writeJsonFile(sessionPath, "4_req_target.json", {
+        timestamp: new Date().toISOString(),
+        url,
+        headers: maskSensitiveHeaders(headers),
+        body: redactBody(body)
+      });
+    },
+
+    logProviderResponse(status, statusText, headers, body) {
+      const filename = "5_res_provider.json";
+      writeJsonFile(sessionPath, filename, {
+        timestamp: new Date().toISOString(),
+        status,
+        statusText,
+        headers: maskSensitiveHeaders(headers),
+        body: redactBody(body)
+      });
+    },
+
+    appendProviderChunk(chunk) {
+      queueStreamChunk("5_res_provider.txt", chunk);
+    },
+
+    appendOpenAIChunk(chunk) {
+      queueStreamChunk("6_res_openai.txt", chunk);
+    },
+
+    logConvertedResponse(body) {
+      writeJsonFile(sessionPath, "7_res_client.json", {
+        timestamp: new Date().toISOString(),
+        body: redactBody(body)
+      });
+    },
+
+    appendConvertedChunk(chunk) {
+      queueStreamChunk("7_res_client.txt", chunk);
+    },
+
+    logError(error, requestBody = null) {
+      writeJsonFile(sessionPath, "6_error.json", {
+        timestamp: new Date().toISOString(),
+        error: error?.message || String(error),
+        stack: error?.stack,
+        requestBody: redactBody(requestBody)
+      });
+    }
+  };
+}
+
+export function logRequest() {}
+export function logResponse() {}
+export function logError(provider, { error, url, model, requestBody }) {
+  if (!fs || !LOGS_DIR) return;
+
+  try {
+    if (!fs.existsSync(LOGS_DIR)) {
+      fs.mkdirSync(LOGS_DIR, { recursive: true });
+    }
+
+    const date = new Date().toISOString().split("T")[0];
+    const logPath = path.join(LOGS_DIR, `${provider}-${date}.log`);
+
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      type: "error",
+      provider,
+      model,
+      url,
+      error: error?.message || String(error),
+      stack: error?.stack,
+      requestBody
+    };
+
+    fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
+  } catch (err) {
+    console.log("[LOG] Failed to write error log:", err.message);
+  }
+}

package/src/utils/responsesStreamHelpers.js

@@ -0,0 +1,46 @@
+import { FORMATS } from "../translator/formats.js";
+import { formatSSE } from "./streamHelpers.js";
+
+const OPENAI_RESPONSES_TERMINAL_EVENTS = new Set([
+  "response.completed",
+  "response.done",
+  "response.failed",
+  "error"
+]);
+
+export function getOpenAIResponsesEventName(eventName, chunk) {
+  if (eventName) return eventName;
+  if (chunk && typeof chunk.type === "string") return chunk.type;
+  return null;
+}
+
+export function isOpenAIResponsesTerminalEvent(eventName, chunk) {
+  const type = getOpenAIResponsesEventName(eventName, chunk);
+  if (OPENAI_RESPONSES_TERMINAL_EVENTS.has(type)) return true;
+  const status = chunk?.response?.status;
+  return status === "completed" || status === "failed";
+}
+
+const sharedEncoder = new TextEncoder();
+
+export function buildAbortedResponsesTerminalBytes() {
+  return sharedEncoder.encode(`${formatIncompleteOpenAIResponsesStreamFailure()}data: [DONE]\n\n`);
+}
+
+export function formatIncompleteOpenAIResponsesStreamFailure() {
+  return formatSSE({
+    event: "response.failed",
+    data: {
+      type: "response.failed",
+      response: {
+        id: `resp_${Date.now()}`,
+        status: "failed",
+        error: {
+          type: "stream_error",
+          code: "stream_disconnected",
+          message: "stream closed before response.completed"
+        }
+      }
+    }
+  }, FORMATS.OPENAI_RESPONSES);
+}