@fudrouter/fsrouter 0.6.62 → 0.6.63

package/open-sse/utils/cursorVersionDetector.js

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

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

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

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

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

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

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

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

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