@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/utils/reasoningFields.js

@@ -1,70 +0,0 @@
-export function asReasoningRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-
-function nonEmptyString(value) {
-  return typeof value === "string" && value.length > 0 ? value : "";
-}
-
-export function extractReasoningDetailsText(value) {
-  const record = asReasoningRecord(value);
-  if (!Array.isArray(record.reasoning_details)) return "";
-  return record.reasoning_details
-    .map((detail) => {
-      const item = asReasoningRecord(detail);
-      return nonEmptyString(item.text) || nonEmptyString(item.content);
-    })
-    .join("");
-}
-
-export function getReadableReasoningValue(value) {
-  const record = asReasoningRecord(value);
-  return nonEmptyString(record.reasoning_content) || nonEmptyString(record.reasoning);
-}
-
-export function getUnsupportedReasoningValue(value) {
-  const record = asReasoningRecord(value);
-  return (
-    nonEmptyString(record.reasoning_text) ||
-    nonEmptyString(record.thinking) ||
-    nonEmptyString(record.thought) ||
-    extractReasoningDetailsText(record)
-  );
-}
-
-export function getAnyReasoningValue(value) {
-  return getReadableReasoningValue(value) || getUnsupportedReasoningValue(value);
-}
-
-export function hasUnsupportedReasoningSignal(value) {
-  const record = asReasoningRecord(value);
-  return Boolean(
-    !getReadableReasoningValue(record) &&
-    (nonEmptyString(record.reasoning_text) ||
-      nonEmptyString(record.thinking) ||
-      nonEmptyString(record.thought) ||
-      (Array.isArray(record.reasoning_details) && record.reasoning_details.length > 0))
-  );
-}
-
-export function hasAnyReasoningSignal(value) {
-  const record = asReasoningRecord(value);
-  return Boolean(
-    getReadableReasoningValue(record) ||
-    nonEmptyString(record.reasoning_text) ||
-    nonEmptyString(record.thinking) ||
-    nonEmptyString(record.thought) ||
-    (Array.isArray(record.reasoning_details) && record.reasoning_details.length > 0)
-  );
-}
-
-export function copyOpenAICompatibleReasoningFields(source, target) {
-  if (source.reasoning_content !== undefined) target.reasoning_content = source.reasoning_content;
-  if (source.reasoning !== undefined) target.reasoning = source.reasoning;
-  if (source.reasoning_text !== undefined) target.reasoning_text = source.reasoning_text;
-  if (Array.isArray(source.reasoning_details)) target.reasoning_details = source.reasoning_details;
-  if (!getReadableReasoningValue(target)) {
-    const mirrored = getUnsupportedReasoningValue(source);
-    if (mirrored) target.reasoning_content = mirrored;
-  }
-}

package/open-sse/utils/requestLogger.js

@@ -1,260 +0,0 @@
-// Check if running in Node.js environment (has fs module)
-const isNode = typeof process !== "undefined" && process.versions?.node && typeof window === "undefined";
-
-// Check if logging is enabled via environment variable (default: false)
-const LOGGING_ENABLED = typeof process !== "undefined" && process.env?.ENABLE_REQUEST_LOGS === 'true';
-
-let fs = null;
-let path = null;
-let LOGS_DIR = null;
-
-// Lazy load Node.js modules (avoid top-level await)
-async function ensureNodeModules() {
-  if (!isNode || !LOGGING_ENABLED || fs) return;
-  try {
-    fs = await import("fs");
-    path = await import("path");
-    LOGS_DIR = path.join(typeof process !== "undefined" && process.cwd ? process.cwd() : ".", "logs");
-  } catch {
-    // Running in non-Node environment (Worker, Browser, etc.)
-  }
-}
-
-// Format timestamp for folder name: 20251228_143045_123
-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}`;
-}
-
-// Create log session folder: {sourceFormat}_{targetFormat}_{model}_{timestamp}
-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;
-  }
-}
-
-// Write JSON file
-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);
-  }
-}
-
-// Mask sensitive data in headers (DISABLED - keep full token for testing)
-function maskSensitiveHeaders(headers) {
-  if (!headers) return {};
-  return { ...headers };
-  
-  // Old masking code (disabled):
-  // const masked = { ...headers };
-  // const sensitiveKeys = ["authorization", "x-api-key", "cookie", "token"];
-  // 
-  // for (const key of Object.keys(masked)) {
-  //   const lowerKey = key.toLowerCase();
-  //   if (sensitiveKeys.some(sk => lowerKey.includes(sk))) {
-  //     const value = masked[key];
-  //     if (value && value.length > 20) {
-  //       masked[key] = value.slice(0, 10) + "..." + value.slice(-5);
-  //     }
-  //   }
-  // }
-  // return masked;
-}
-
-// No-op logger when logging is disabled
-function createNoOpLogger() {
-  return {
-    sessionPath: null,
-    logClientRawRequest() {},
-    logRawRequest() {},
-    logOpenAIRequest() {},
-    logTargetRequest() {},
-    logProviderResponse() {},
-    appendProviderChunk() {},
-    appendOpenAIChunk() {},
-    logConvertedResponse() {},
-    appendConvertedChunk() {},
-    logError() {}
-  };
-}
-
-/**
- * Create a new log session and return logger functions
- * @param {string} sourceFormat - Source format from client (claude, openai, etc.)
- * @param {string} targetFormat - Target format to provider (antigravity, gemini-cli, etc.)
- * @param {string} model - Model name
- * @returns {Promise<object>} Promise that resolves to logger object with methods to log each stage
- */
-export async function createRequestLogger(sourceFormat, targetFormat, model) {
-  // Return no-op logger if logging is disabled
-  if (!LOGGING_ENABLED) {
-    return createNoOpLogger();
-  }
-  
-  // Wait for session to be created before returning logger
-  const sessionPath = await createLogSession(sourceFormat, targetFormat, model);
-  
-  return {
-    get sessionPath() { return sessionPath; },
-    
-    // 1. Log client raw request (before any conversion)
-    logClientRawRequest(endpoint, body, headers = {}) {
-      writeJsonFile(sessionPath, "1_req_client.json", {
-        timestamp: new Date().toISOString(),
-        endpoint,
-        headers: maskSensitiveHeaders(headers),
-        body
-      });
-    },
-    
-    // 2. Log raw request from client (after initial conversion like responsesApi)
-    logRawRequest(body, headers = {}) {
-      writeJsonFile(sessionPath, "2_req_source.json", {
-        timestamp: new Date().toISOString(),
-        headers: maskSensitiveHeaders(headers),
-        body
-      });
-    },
-    
-    // 3. Log OpenAI intermediate format (source → openai)
-    logOpenAIRequest(body) {
-      writeJsonFile(sessionPath, "3_req_openai.json", {
-        timestamp: new Date().toISOString(),
-        body
-      });
-    },
-    
-    // 4. Log target format request (openai → target)
-    logTargetRequest(url, headers, body) {
-      writeJsonFile(sessionPath, "4_req_target.json", {
-        timestamp: new Date().toISOString(),
-        url,
-        headers: maskSensitiveHeaders(headers),
-        body
-      });
-    },
-    
-    // 5. Log provider response (for non-streaming or error)
-    logProviderResponse(status, statusText, headers, body) {
-      const filename = "5_res_provider.json";
-      writeJsonFile(sessionPath, filename, {
-        timestamp: new Date().toISOString(),
-        status,
-        statusText,
-        headers: headers ? (typeof headers.entries === "function" ? Object.fromEntries(headers.entries()) : headers) : {},
-        body
-      });
-    },
-    
-    // 5. Append streaming chunk to provider response
-    appendProviderChunk(chunk) {
-      if (!fs || !sessionPath) return;
-      try {
-        const filePath = path.join(sessionPath, "5_res_provider.txt");
-        fs.appendFileSync(filePath, chunk);
-      } catch (err) {
-        // Ignore append errors
-      }
-    },
-    
-    // 6. Append OpenAI intermediate chunks (target → openai)
-    appendOpenAIChunk(chunk) {
-      if (!fs || !sessionPath) return;
-      try {
-        const filePath = path.join(sessionPath, "6_res_openai.txt");
-        fs.appendFileSync(filePath, chunk);
-      } catch (err) {
-        // Ignore append errors
-      }
-    },
-    
-    // 7. Log converted response to client (for non-streaming)
-    logConvertedResponse(body) {
-      writeJsonFile(sessionPath, "7_res_client.json", {
-        timestamp: new Date().toISOString(),
-        body
-      });
-    },
-    
-    // 7. Append streaming chunk to converted response
-    appendConvertedChunk(chunk) {
-      if (!fs || !sessionPath) return;
-      try {
-        const filePath = path.join(sessionPath, "7_res_client.txt");
-        fs.appendFileSync(filePath, chunk);
-      } catch (err) {
-        // Ignore append errors
-      }
-    },
-    
-    // 6. Log error
-    logError(error, requestBody = null) {
-      writeJsonFile(sessionPath, "6_error.json", {
-        timestamp: new Date().toISOString(),
-        error: error?.message || String(error),
-        stack: error?.stack,
-        requestBody
-      });
-    }
-  };
-}
-
-// Legacy functions for backward compatibility
-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/open-sse/utils/responsesInputNormalization.js

@@ -1,92 +0,0 @@
-function textPartTypeForRole(role) {
-  return role === "assistant" ? "output_text" : "input_text";
-}
-
-function normalizeCodexMessageContentPart(part, role) {
-  if (typeof part === "string") return { type: textPartTypeForRole(role), text: part };
-  if (!part || typeof part !== "object" || Array.isArray(part)) return part;
-
-  const record = { ...part };
-  if (record.type === "text") record.type = textPartTypeForRole(role);
-  return record;
-}
-
-function buildCodexMessageContent(item, role) {
-  if (Array.isArray(item.content)) {
-    return item.content.map((part) => normalizeCodexMessageContentPart(part, role));
-  }
-  if (typeof item.content === "string") {
-    return [{ type: textPartTypeForRole(role), text: item.content }];
-  }
-  if (typeof item.text === "string") {
-    return [{ type: textPartTypeForRole(role), text: item.text }];
-  }
-  return [];
-}
-
-function normalizeCodexResponsesInputItem(itemValue) {
-  if (typeof itemValue === "string") {
-    return { type: "message", role: "user", content: [{ type: "input_text", text: itemValue }] };
-  }
-
-  if (!itemValue || typeof itemValue !== "object" || Array.isArray(itemValue)) return itemValue;
-
-  const item = { ...itemValue };
-  const role = typeof item.role === "string" ? item.role : "user";
-  const type = typeof item.type === "string" ? item.type : "";
-
-  if (!type && item.content === undefined && typeof item.text === "string") {
-    return { type: "message", role, content: [{ type: textPartTypeForRole(role), text: item.text }] };
-  }
-
-  if (!type && role) item.type = "message";
-  if (item.type === "message" || (!type && item.content !== undefined)) {
-    item.role = role;
-    item.content = buildCodexMessageContent(item, role);
-    item.type = "message";
-  }
-
-  return item;
-}
-
-export function normalizeCodexResponsesInput(body) {
-  if (Array.isArray(body.input)) {
-    body.input = body.input.map(normalizeCodexResponsesInputItem);
-    return;
-  }
-
-  // undefined → leave as-is; null → empty list (not [null], which would surface a bogus
-  // item downstream); anything else → wrap the single item.
-  if (body.input === undefined) return;
-  body.input = body.input === null ? [] : [normalizeCodexResponsesInputItem(body.input)];
-}
-
-function normalizeResponsesInputItemForChat(value) {
-  if (typeof value === "string") {
-    return { type: "message", role: "user", content: [{ type: "input_text", text: value }] };
-  }
-
-  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-
-  const item = { ...value };
-  const hasType = typeof item.type === "string" && item.type.length > 0;
-  const hasRole = typeof item.role === "string" && item.role.length > 0;
-  if (hasType || hasRole) {
-    if (!hasType && hasRole) item.type = "message";
-    return item;
-  }
-
-  if (typeof item.text === "string") {
-    return { type: "message", role: "user", content: [{ type: "input_text", text: item.text }] };
-  }
-
-  if (item.content !== undefined) return { type: "message", role: "user", content: item.content };
-  return item;
-}
-
-export function normalizeResponsesInputForChat(input) {
-  // == null matches both undefined and null (neither is a spec-valid input) → empty list.
-  if (input == null) return [];
-  if (Array.isArray(input)) return input.map(normalizeResponsesInputItemForChat);
-  return [normalizeResponsesInputItemForChat(input)];
-}

package/open-sse/utils/responsesStatePolicy.js

@@ -1,52 +0,0 @@
-import { isOpenAIResponsesStoreEnabled } from '../../../dist/lib/providers/requestDefaults.js';
-import {
-  DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE,
-  RESPONSES_PREVIOUS_RESPONSE_ID_MODES
-} from '../../dist/shared/constants/responsesPreviousResponseId.js';
-import { FORMATS } from "../translator/formats.ts";
-const MODE_SET = new Set(RESPONSES_PREVIOUS_RESPONSE_ID_MODES);
-function toRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function normalizeResponsesPreviousResponseIdMode(value) {
-  if (typeof value === "string" && MODE_SET.has(value)) {
-    return value;
-  }
-  return DEFAULT_RESPONSES_PREVIOUS_RESPONSE_ID_MODE;
-}
-function shouldStripPreviousResponseId({
-  mode,
-  sourceFormat,
-  targetFormat,
-  credentials
-}) {
-  const normalizedMode = normalizeResponsesPreviousResponseIdMode(mode);
-  if (normalizedMode === "preserve") return false;
-  if (normalizedMode === "strip") return true;
-  const isResponsesSource = sourceFormat === FORMATS.OPENAI_RESPONSES;
-  const isResponsesTarget = targetFormat === FORMATS.OPENAI_RESPONSES;
-  if (!isResponsesSource && !isResponsesTarget) return false;
-  const providerSpecificData = toRecord(toRecord(credentials).providerSpecificData);
-  return !isOpenAIResponsesStoreEnabled(providerSpecificData);
-}
-function applyResponsesPreviousResponseIdPolicy(body, options) {
-  const mode = normalizeResponsesPreviousResponseIdMode(options.mode);
-  if (!body || typeof body !== "object" || Array.isArray(body)) {
-    return { body, stripped: false, mode };
-  }
-  const record = body;
-  if (!Object.hasOwn(record, "previous_response_id")) {
-    return { body, stripped: false, mode };
-  }
-  if (!shouldStripPreviousResponseId({ ...options, mode })) {
-    return { body, stripped: false, mode };
-  }
-  const next = { ...record };
-  delete next.previous_response_id;
-  return { body: next, stripped: true, mode };
-}
-export {
-  applyResponsesPreviousResponseIdPolicy,
-  normalizeResponsesPreviousResponseIdMode,
-  shouldStripPreviousResponseId
-};

package/open-sse/utils/responsesStreamHelpers.js

@@ -1,49 +0,0 @@
-// Helpers for OpenAI Responses API streaming termination + event framing
-import { FORMATS } from "../translator/formats.js";
-import { formatSSE } from "./streamHelpers.js";
-
-// Responses API events that signal the stream has reached a terminal state
-const OPENAI_RESPONSES_TERMINAL_EVENTS = new Set([
-  "response.completed",
-  "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();
-
-// Encoded response.failed + [DONE] payload for aborted/stalled Responses passthrough streams
-export function buildAbortedResponsesTerminalBytes() {
-  return sharedEncoder.encode(`${formatIncompleteOpenAIResponsesStreamFailure()}data: [DONE]\n\n`);
-}
-
-// Synthesize a response.failed event for streams that close without a terminal event
-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);
-}