@fudrouter/fsrouter 0.6.62 → 0.6.63

package/open-sse/utils/reasoningFields.js

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

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

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

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

@@ -0,0 +1,49 @@
+// 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);
+}