@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/utils/cursorVersionDetector.js

@@ -1,55 +0,0 @@
-import { homedir } from "os";
-import { join } from "path";
-import { createRequire } from "module";
-const CACHE_TTL_MS = 60 * 60 * 1e3;
-const DB_KEY = "cursorupdate.lastUpdatedAndShown.version";
-const FALLBACK_VERSION = "3.9";
-let cachedVersion = null;
-let cachedAt = 0;
-function getCursorDbPath() {
-  if (process.env.CURSOR_STATE_DB_PATH) {
-    return process.env.CURSOR_STATE_DB_PATH;
-  }
-  const home = process.env.HOME || process.env.USERPROFILE || homedir();
-  const platform = process.platform;
-  if (platform === "darwin") {
-    return join(home, "Library/Application Support/Cursor/User/globalStorage/state.vscdb");
-  }
-  if (platform === "win32") {
-    return join(process.env.APPDATA || home, "Cursor/User/globalStorage/state.vscdb");
-  }
-  return join(home, ".config/Cursor/User/globalStorage/state.vscdb");
-}
-function getCursorVersion() {
-  const now = Date.now();
-  if (cachedVersion && now - cachedAt < CACHE_TTL_MS) {
-    return cachedVersion;
-  }
-  try {
-    const esmRequire = createRequire(import.meta.url);
-    const Database = esmRequire("better-sqlite3");
-    const db = new Database(getCursorDbPath(), { readonly: true, fileMustExist: true });
-    try {
-      const row = db.prepare("SELECT value FROM itemTable WHERE key = ?").get(DB_KEY);
-      if (row?.value) {
-        cachedVersion = row.value;
-        cachedAt = now;
-        return cachedVersion;
-      }
-    } finally {
-      db.close();
-    }
-  } catch {
-  }
-  return FALLBACK_VERSION;
-}
-function resetCursorVersionCache() {
-  cachedVersion = null;
-  cachedAt = 0;
-}
-export {
-  FALLBACK_VERSION,
-  getCursorDbPath,
-  getCursorVersion,
-  resetCursorVersionCache
-};

package/open-sse/utils/debugLog.js

@@ -1,14 +0,0 @@
-// Debug logging utility — only active in dev mode (NODE_ENV !== "production")
-// Outputs are tagged with [DBG:tag] for easy grep/filter
-const isDev = process.env.NODE_ENV !== "production";
-
-function ts() {
-  return new Date().toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
-}
-
-export function dbg(tag, msg) {
-  if (!isDev) return;
-  console.log(`[${ts()}] 🐛 [DBG:${tag}] ${msg}`);
-}
-
-export const isDebugEnabled = isDev;

package/open-sse/utils/diagnostics.js

@@ -1,143 +0,0 @@
-import { sanitizeErrorMessage } from "./error.ts";
-const REASON_MESSAGES = {
-  empty: "no content produced",
-  stall: "stream stalled (no data within the stall window)",
-  abort: "stream aborted",
-  client_closed: "client closed the connection",
-  no_terminal: "stream closed without a terminal event",
-  parse_fail: "failed to parse upstream stream",
-  empty_choices: "response had no usable choices/output",
-  empty_stream: "upstream stream carried no content"
-};
-function describeReason(reason) {
-  if (!reason) return "empty response";
-  return REASON_MESSAGES[reason] ?? reason;
-}
-function reportMalformed200(opts) {
-  const {
-    mode,
-    provider,
-    model,
-    connectionId,
-    reason,
-    recvBytes,
-    recvLines,
-    emitted,
-    events,
-    ttftMs,
-    elapsedMs
-  } = opts;
-  const evtStr = events && typeof events === "object" ? `[${Object.entries(events).map(([k, v]) => `${k}=${v}`).join(",")}]` : "[]";
-  console.log(
-    `[MALFORMED-200] mode=${mode || "?"} provider=${provider || "?"} model=${model || "?"} conn=${connectionId || "-"} reason=${reason || "empty"} recvBytes=${recvBytes ?? -1} recvLines=${recvLines ?? -1} emitted=${emitted ?? -1} events=${evtStr} ttft=${ttftMs ?? -1}ms dur=${elapsedMs ?? -1}ms`
-  );
-}
-function synthOpenAIErrorChunk(opts) {
-  const { provider, model, reason } = opts;
-  const reasonText = sanitizeErrorMessage(describeReason(reason));
-  const providerPart = sanitizeErrorMessage(provider ?? "?");
-  const safeMessage = sanitizeErrorMessage(
-    `[${providerPart}] returned an empty response (${reasonText}). Likely quota exhaustion, an overloaded upstream, or a proxy/gateway intercepting the stream.`
-  );
-  const body = {
-    id: `chatcmpl-empty-${Date.now()}`,
-    object: "chat.completion.chunk",
-    created: Math.floor(Date.now() / 1e3),
-    model: sanitizeErrorMessage(model ?? "unknown"),
-    choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
-    error: {
-      message: safeMessage,
-      type: "upstream_empty_response"
-    }
-  };
-  return `data: ${JSON.stringify(body)}
-
-`;
-}
-function synthResponsesFailure(reason) {
-  const safeMessage = sanitizeErrorMessage(
-    `stream closed before response.completed (${describeReason(reason)})`
-  );
-  const event = {
-    type: "response.failed",
-    response: {
-      id: null,
-      status: "failed",
-      error: {
-        type: "stream_error",
-        code: "stream_disconnected",
-        message: safeMessage
-      }
-    }
-  };
-  return `event: response.failed
-data: ${JSON.stringify(event)}
-
-`;
-}
-function detectMalformedNonStream(resp) {
-  if (!resp || typeof resp !== "object") return "empty_choices";
-  const body = resp;
-  if (body.object === "response") {
-    const output = body.output;
-    const hasOutput = Array.isArray(output) && output.some((item) => {
-      if (!item || typeof item !== "object") return false;
-      const it = item;
-      if (it.type === "message") {
-        return Array.isArray(it.content) && it.content.some((c) => {
-          const part = c;
-          return typeof part?.text === "string" && part.text.length > 0;
-        });
-      }
-      return Boolean(it.type);
-    });
-    if (!hasOutput) return "empty_choices";
-    const status = typeof body.status === "string" ? body.status : "";
-    if (status && !["completed", "done"].includes(status)) return "no_terminal";
-    return null;
-  }
-  if (body.type === "message" && Array.isArray(body.content)) {
-    const hasOutput = body.content.some((block) => {
-      if (block === null || typeof block !== "object") return false;
-      const b = block;
-      if (b.type === "text" && typeof b.text === "string" && b.text.length > 0 && b.text !== "(empty response)") {
-        return true;
-      }
-      if (b.type === "thinking" && (typeof b.thinking === "string" && b.thinking.length > 0 || typeof b.signature === "string" && b.signature.length > 0)) {
-        return true;
-      }
-      if (b.type === "redacted_thinking") return true;
-      if (b.type === "tool_use" && typeof b.id === "string" && b.id.length > 0) {
-        return true;
-      }
-      return false;
-    });
-    return hasOutput ? null : "empty_choices";
-  }
-  const choices = body.choices;
-  if (!Array.isArray(choices) || choices.length === 0) return "empty_choices";
-  const anyHasOutput = choices.some((choice) => {
-    const c = choice;
-    const msg = c?.message;
-    if (typeof msg?.content === "string" && msg.content.length > 0) return true;
-    if (Array.isArray(msg?.content) && msg.content.some((block) => {
-      const b = block;
-      return !!b && typeof b === "object" && b.type === "text" && typeof b.text === "string" && b.text.length > 0;
-    }))
-      return true;
-    if (Array.isArray(msg?.tool_calls) && msg.tool_calls.length > 0) return true;
-    if (typeof msg?.reasoning_content === "string" && msg.reasoning_content.length > 0)
-      return true;
-    return false;
-  });
-  if (!anyHasOutput) return "empty_choices";
-  return null;
-}
-const __test = { describeReason };
-export {
-  __test,
-  detectMalformedNonStream,
-  reportMalformed200,
-  synthOpenAIErrorChunk,
-  synthResponsesFailure
-};

package/open-sse/utils/error.js

@@ -1,164 +0,0 @@
-import { ERROR_TYPES, DEFAULT_ERROR_MESSAGES } from "../config/errorConfig.js";
-
-/**
- * Build OpenAI-compatible error response body
- * @param {number} statusCode - HTTP status code
- * @param {string} message - Error message
- * @returns {object} Error response object
- */
-export function buildErrorBody(statusCode, message) {
-  const errorInfo = ERROR_TYPES[statusCode] || 
-    (statusCode >= 500 
-      ? { type: "server_error", code: "internal_server_error" }
-      : { type: "invalid_request_error", code: "" });
-
-  return {
-    error: {
-      message: message || DEFAULT_ERROR_MESSAGES[statusCode] || "An error occurred",
-      type: errorInfo.type,
-      code: errorInfo.code
-    }
-  };
-}
-
-/**
- * Create error Response object (for non-streaming)
- * @param {number} statusCode - HTTP status code
- * @param {string} message - Error message
- * @returns {Response} HTTP Response object
- */
-export function errorResponse(statusCode, message) {
-  return new Response(JSON.stringify(buildErrorBody(statusCode, message)), {
-    status: statusCode,
-    headers: {
-      "Content-Type": "application/json",
-      "Access-Control-Allow-Origin": "*"
-    }
-  });
-}
-
-/**
- * Write error to SSE stream (for streaming)
- * @param {WritableStreamDefaultWriter} writer - Stream writer
- * @param {number} statusCode - HTTP status code
- * @param {string} message - Error message
- */
-export async function writeStreamError(writer, statusCode, message) {
-  const errorBody = buildErrorBody(statusCode, message);
-  const encoder = new TextEncoder();
-  await writer.write(encoder.encode(`data: ${JSON.stringify(errorBody)}\n\n`));
-}
-
-/**
- * Parse upstream provider error response
- * @param {Response} response - Fetch response from provider
- * @param {object} [executor] - Optional executor with parseError() override for provider-specific parsing
- * @returns {Promise<{statusCode: number, message: string, resetsAtMs?: number}>}
- */
-export async function parseUpstreamError(response, executor = null) {
-  let bodyText = "";
-  try {
-    bodyText = await response.text();
-  } catch {
-    bodyText = "";
-  }
-
-  // Let executor-specific parser extract provider-specific fields (e.g. codex resetsAtMs)
-  if (executor && typeof executor.parseError === "function") {
-    try {
-      const parsed = executor.parseError(response, bodyText);
-      if (parsed && typeof parsed === "object") {
-        const msg = parsed.message || DEFAULT_ERROR_MESSAGES[response.status] || `Upstream error: ${response.status}`;
-        return { statusCode: parsed.status || response.status, message: msg, resetsAtMs: parsed.resetsAtMs };
-      }
-    } catch { /* fall through to default parsing */ }
-  }
-
-  let message = "";
-  try {
-    const json = JSON.parse(bodyText);
-    message = json.error?.message || json.message || json.error || bodyText;
-  } catch {
-    message = bodyText;
-  }
-
-  const messageStr = typeof message === "string" ? message : JSON.stringify(message);
-  const finalMessage = messageStr || DEFAULT_ERROR_MESSAGES[response.status] || `Upstream error: ${response.status}`;
-
-  return { statusCode: response.status, message: finalMessage };
-}
-
-/**
- * Create error result for chatCore handler
- * @param {number} statusCode - HTTP status code
- * @param {string} message - Error message
- * @param {number} [resetsAtMs] - Optional precise cooldown expiry (ms epoch) for provider-specific quota errors
- * @returns {{ success: false, status: number, error: string, response: Response, resetsAtMs?: number }}
- */
-export function createErrorResult(statusCode, message, resetsAtMs) {
-  return {
-    success: false,
-    status: statusCode,
-    error: message,
-    resetsAtMs,
-    response: errorResponse(statusCode, message)
-  };
-}
-
-/**
- * Create unavailable response when all accounts are rate limited
- * @param {number} statusCode - Original error status code
- * @param {string} message - Error message (without retry info)
- * @param {string} retryAfter - ISO timestamp when earliest account becomes available
- * @param {string} retryAfterHuman - Human-readable retry info e.g. "reset after 30s"
- * @returns {Response}
- */
-export function unavailableResponse(statusCode, message, retryAfter, retryAfterHuman) {
-  const retryAfterSec = Math.max(Math.ceil((new Date(retryAfter).getTime() - Date.now()) / 1000), 1);
-  const msg = `${message} (${retryAfterHuman})`;
-  return new Response(
-    JSON.stringify({ error: { message: msg } }),
-    {
-      status: statusCode,
-      headers: {
-        "Content-Type": "application/json",
-        "Retry-After": String(retryAfterSec)
-      }
-    }
-  );
-}
-
-/**
- * Format provider error with context
- * @param {Error} error - Original error
- * @param {string} provider - Provider name
- * @param {string} model - Model name
- * @param {number|string} statusCode - HTTP status code or error code
- * @returns {string} Formatted error message
- */
-export function formatProviderError(error, provider, model, statusCode) {
-  const code = statusCode || error.code || "FETCH_FAILED";
-  const message = error.message || "Unknown error";
-  // Expose low-level cause (e.g. UND_ERR_SOCKET, ECONNRESET, ETIMEDOUT) for diagnosing fetch failures
-  const causeCode = error.cause?.code;
-  const causeMsg = error.cause?.message;
-  const causeStr = causeCode || causeMsg ? ` (cause: ${[causeCode, causeMsg].filter(Boolean).join(": ")})` : "";
-  return `[${code}]: ${message}${causeStr}`;
-}
-
-
-/**
- * Safely escape HTML characters from error strings to prevent XSS in clients that poorly render error JSON.
- * Note: Only intended for string values. Non-string inputs will be returned as-is or cast to strings based on usage.
- * @param {string} message The raw error message
- * @returns {string} The HTML-escaped error message
- */
-export function sanitizeErrorMessage(message) {
-  if (typeof message !== 'string') return String(message);
-  return message
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#39;');
-}

package/open-sse/utils/estimateSize.js

@@ -1,33 +0,0 @@
-function estimateSizeFast(value) {
-  let bytes = 0;
-  const stack = [value];
-  const seen = /* @__PURE__ */ new WeakSet();
-  while (stack.length > 0) {
-    const v = stack.pop();
-    if (v === null || v === void 0) continue;
-    if (typeof v === "string") {
-      bytes += v.length;
-      if (bytes > 262144) return bytes;
-    } else if (typeof v === "number") bytes += 8;
-    else if (typeof v === "boolean") bytes += 4;
-    else if (typeof v === "object") {
-      if (seen.has(v)) continue;
-      seen.add(v);
-      if (Array.isArray(v)) {
-        for (let i = 0; i < v.length; i++) stack.push(v[i]);
-      } else {
-        for (const key in v) {
-          if (Object.prototype.hasOwnProperty.call(v, key)) stack.push(v[key]);
-        }
-      }
-    }
-  }
-  return bytes;
-}
-function isSmallEnoughForSemanticCache(value) {
-  return estimateSizeFast(value) <= 256 * 1024;
-}
-export {
-  estimateSizeFast,
-  isSmallEnoughForSemanticCache
-};

package/open-sse/utils/finishReason.js

@@ -1,32 +0,0 @@
-export function normalizeOpenAICompatibleFinishReason(value) {
-  if (typeof value !== "string") return value;
-
-  const normalized = value.toLowerCase();
-  const OPENAI_FINISH_REASONS = new Set([
-    "stop",
-    "length",
-    "tool_calls",
-    "content_filter",
-    "function_call",
-  ]);
-  const SAFETY_FINISH_REASONS = new Set([
-    "safety",
-    "recitation",
-    "blocklist",
-    "prohibited_content",
-    "content_filtered",
-    "policy_violation",
-    "malformed_response",
-  ]);
-
-  if (OPENAI_FINISH_REASONS.has(normalized)) return normalized;
-  if (normalized === "max_tokens") return "length";
-  if (SAFETY_FINISH_REASONS.has(normalized)) return "content_filter";
-
-  return normalized;
-}
-
-export function normalizeOpenAICompatibleFinishReasonString(value, fallback = "stop") {
-  const normalized = normalizeOpenAICompatibleFinishReason(value);
-  return typeof normalized === "string" && normalized ? normalized : fallback;
-}

package/open-sse/utils/flattenToolHistory.js

@@ -1,68 +0,0 @@
-import { extractTextContent } from "../translator/helpers/geminiHelper.ts";
-const TOOL_CALL_PREFIX = "[Called tools: ";
-const TOOL_RESULT_PREFIX = "[Tool result: ";
-function isMessage(m) {
-  return m != null && typeof m === "object";
-}
-function flattenToolHistory(messages) {
-  const out = [];
-  for (const raw of messages) {
-    if (!isMessage(raw)) continue;
-    const msg = raw;
-    if (msg.role === "tool" || msg.role === "function") {
-      const text = extractTextContent(msg.content) || String(msg.content ?? "");
-      out.push({
-        role: "assistant",
-        content: `${TOOL_RESULT_PREFIX}${text}]`
-      });
-      continue;
-    }
-    if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
-      const { tool_calls, ...rest } = msg;
-      const names = tool_calls.map((c) => c?.function?.name || c?.name || "tool").join(", ");
-      const base = extractTextContent(rest.content) || (typeof rest.content === "string" ? rest.content : "");
-      out.push({
-        ...rest,
-        content: `${base}${base ? "\n" : ""}${TOOL_CALL_PREFIX}${names}]`
-      });
-      continue;
-    }
-    if (Array.isArray(msg.content)) {
-      const blocks = msg.content;
-      const hasToolUse = blocks.some((c) => c?.type === "tool_use");
-      const hasToolResult = blocks.some((c) => c?.type === "tool_result");
-      if (hasToolUse || hasToolResult) {
-        const textParts = [];
-        const toolNames = [];
-        const toolResults = [];
-        for (const block of blocks) {
-          if (block?.type === "text" && typeof block.text === "string") {
-            textParts.push(block.text);
-          } else if (block?.type === "tool_use") {
-            toolNames.push(block.name || "tool");
-          } else if (block?.type === "tool_result") {
-            toolResults.push(
-              extractTextContent(block.content) || String(block.content ?? "")
-            );
-          }
-        }
-        let newContent = textParts.join("\n");
-        if (toolNames.length > 0) {
-          newContent = `${newContent}${newContent ? "\n" : ""}${TOOL_CALL_PREFIX}${toolNames.join(", ")}]`;
-        }
-        if (toolResults.length > 0) {
-          newContent = `${newContent}${newContent ? "\n" : ""}${TOOL_RESULT_PREFIX}${toolResults.join("\n")}]`;
-        }
-        out.push({ ...msg, content: newContent });
-        continue;
-      }
-    }
-    out.push(msg);
-  }
-  return out;
-}
-export {
-  TOOL_CALL_PREFIX,
-  TOOL_RESULT_PREFIX,
-  flattenToolHistory
-};

package/open-sse/utils/headers.js

@@ -1,36 +0,0 @@
-function normalizeHeaders(h) {
-  if (!h) return {};
-  const out = {};
-  try {
-    if (typeof h.forEach === "function") {
-      h.forEach((value, key) => {
-        out[key.toLowerCase()] = value;
-      });
-      return out;
-    }
-  } catch {
-  }
-  try {
-    if (typeof h.entries === "function") {
-      for (const [k, v] of h.entries()) {
-        out[k.toLowerCase()] = String(v);
-      }
-      return out;
-    }
-  } catch {
-  }
-  if (typeof h === "object") {
-    for (const [k, v] of Object.entries(h)) {
-      out[k.toLowerCase()] = String(v ?? "");
-    }
-  }
-  return out;
-}
-function getHeader(h, name) {
-  const plain = normalizeHeaders(h);
-  return plain[name.toLowerCase()] ?? null;
-}
-export {
-  getHeader,
-  normalizeHeaders
-};

package/open-sse/utils/heapPressure.js

@@ -1,35 +0,0 @@
-import v8 from "node:v8";
-function computeHeapPressureThresholdMb(heapSizeLimitMb, override) {
-  const explicit = Number(override);
-  if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
-  const SHED_RATIO = 0.85;
-  const FLOOR_MB = 400;
-  return Math.max(Math.round(heapSizeLimitMb * SHED_RATIO), FLOOR_MB);
-}
-const HEAP_PRESSURE_THRESHOLD_MB = computeHeapPressureThresholdMb(
-  v8.getHeapStatistics().heap_size_limit / (1024 * 1024),
-  process.env.HEAP_PRESSURE_THRESHOLD_MB
-);
-const HEAP_PRESSURE_MESSAGE = "Service temporarily unavailable due to resource pressure. Retry shortly.";
-function checkHeapPressureGuard(heapUsedMb, thresholdMb = HEAP_PRESSURE_THRESHOLD_MB) {
-  if (heapUsedMb <= thresholdMb) return null;
-  console.warn(
-    `[chatCore] heap pressure guard tripped: ${Math.round(heapUsedMb)}MB > ${thresholdMb}MB; returning 503`
-  );
-  return {
-    success: false,
-    status: 503,
-    error: HEAP_PRESSURE_MESSAGE,
-    response: new Response(
-      JSON.stringify({
-        error: { message: HEAP_PRESSURE_MESSAGE, type: "server_error", code: "heap_pressure" }
-      }),
-      { status: 503, headers: { "Content-Type": "application/json", "Retry-After": "5" } }
-    )
-  };
-}
-export {
-  HEAP_PRESSURE_THRESHOLD_MB,
-  checkHeapPressureGuard,
-  computeHeapPressureThresholdMb
-};