open-sse 1.0.0

package/handlers/chatCore.js

@@ -0,0 +1,277 @@
+import { detectFormat, getTargetFormat, buildProviderUrl, buildProviderHeaders } from "../services/provider.js";
+import { translateRequest, needsTranslation } from "../translator/index.js";
+import { FORMATS } from "../translator/formats.js";
+import { createSSETransformStreamWithLogger, createPassthroughStreamWithLogger, COLORS } from "../utils/stream.js";
+import { createStreamController, pipeWithDisconnect } from "../utils/streamHandler.js";
+import { refreshTokenByProvider, refreshWithRetry } from "../services/tokenRefresh.js";
+import { createRequestLogger } from "../utils/requestLogger.js";
+import { getModelTargetFormat, PROVIDER_ID_TO_ALIAS } from "../config/providerModels.js";
+import { createErrorResult, parseUpstreamError, formatProviderError } from "../utils/error.js";
+import { handleBypassRequest } from "../utils/bypassHandler.js";
+
+/**
+ * Core chat handler - shared between SSE and Worker
+ * Returns { success, response, status, error } for caller to handle fallback
+ * @param {object} options
+ * @param {object} options.body - Request body
+ * @param {object} options.modelInfo - { provider, model }
+ * @param {object} options.credentials - Provider credentials
+ * @param {object} options.log - Logger instance (optional)
+ * @param {function} options.onCredentialsRefreshed - Callback when credentials are refreshed
+ * @param {function} options.onRequestSuccess - Callback when request succeeds (to clear error status)
+ * @param {function} options.onDisconnect - Callback when client disconnects
+ */
+export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest }) {
+  const { provider, model } = modelInfo;
+
+  const sourceFormat = detectFormat(body);
+
+  // Check for bypass patterns (warmup, skip) - return fake response
+  const bypassResponse = handleBypassRequest(body, model);
+  if (bypassResponse) {
+    return bypassResponse;
+  }
+
+  // Detect source format and get target format
+  // Model-specific targetFormat takes priority over provider default
+
+  const alias = PROVIDER_ID_TO_ALIAS[provider] || provider;
+  const modelTargetFormat = getModelTargetFormat(alias, model);
+  const targetFormat = modelTargetFormat || getTargetFormat(provider);
+  const stream = body.stream !== false;
+
+  // Create request logger for this session: sourceFormat_targetFormat_model
+  const reqLogger = createRequestLogger(sourceFormat, targetFormat, model);
+  
+  // 0. Log client raw request (before any conversion)
+  if (clientRawRequest) {
+    reqLogger.logClientRawRequest(
+      clientRawRequest.endpoint,
+      clientRawRequest.body,
+      clientRawRequest.headers
+    );
+  }
+  
+  // 1. Log raw request from client
+  reqLogger.logRawRequest(body);
+  
+  // 1a. Log format detection info
+  reqLogger.logFormatInfo({
+    sourceFormat,
+    targetFormat,
+    provider,
+    model,
+    stream
+  });
+
+  log?.debug?.("FORMAT", `${sourceFormat} → ${targetFormat} | stream=${stream}`);
+
+  // Translate request
+  let translatedBody = body;
+  translatedBody = translateRequest(sourceFormat, targetFormat, model, body, stream, credentials, provider);
+  
+
+  // Update model in body
+  translatedBody.model = model;
+
+  // Build provider URL and headers
+  const providerUrl = buildProviderUrl(provider, model, stream);
+  const providerHeaders = buildProviderHeaders(provider, credentials, stream, translatedBody);
+
+  // 2. Log converted request to provider
+  reqLogger.logConvertedRequest(providerUrl, providerHeaders, translatedBody);
+
+  const msgCount = translatedBody.messages?.length 
+    || translatedBody.contents?.length 
+    || translatedBody.request?.contents?.length 
+    || 0;
+  log?.debug?.("REQUEST", `${provider.toUpperCase()} | ${model} | ${msgCount} msgs`);
+  
+  // Log headers (mask sensitive values)
+  const safeHeaders = {};
+  for (const [key, value] of Object.entries(providerHeaders)) {
+    if (key.toLowerCase().includes("auth") || key.toLowerCase().includes("key") || key.toLowerCase().includes("token")) {
+      safeHeaders[key] = value ? `${value.slice(0, 10)}...` : "";
+    } else {
+      safeHeaders[key] = value;
+    }
+  }
+  log?.debug?.("HEADERS", JSON.stringify(safeHeaders));
+
+  // Create stream controller for disconnect detection
+  const streamController = createStreamController({ onDisconnect, log, provider, model });
+
+  // Make request to provider with abort signal
+  let providerResponse;
+  try {
+    providerResponse = await fetch(providerUrl, {
+      method: "POST",
+      headers: providerHeaders,
+      body: JSON.stringify(translatedBody),
+      signal: streamController.signal
+    });
+  } catch (error) {
+    if (error.name === "AbortError") {
+      streamController.handleError(error);
+      return createErrorResult(499, "Request aborted");
+    }
+    const errMsg = formatProviderError(error, provider, model);
+    console.log(`${COLORS.red}[ERROR] ${errMsg}${COLORS.reset}`);
+    return createErrorResult(502, errMsg);
+  }
+
+
+  // Handle 401/403 - try token refresh
+  if (providerResponse.status === 401 || providerResponse.status === 403) {
+    let newCredentials = null;
+    
+    // GitHub needs special handling - refresh copilotToken using accessToken
+    if (provider === "github") {
+      const { refreshCopilotToken, refreshGitHubToken } = await import("../services/tokenRefresh.js");
+      
+      // First try refreshing copilotToken using existing accessToken
+      let copilotResult = await refreshCopilotToken(credentials.accessToken, log);
+      
+      // If that fails, refresh GitHub accessToken first, then get new copilotToken
+      if (!copilotResult && credentials.refreshToken) {
+        const githubTokens = await refreshGitHubToken(credentials.refreshToken, log);
+        if (githubTokens?.accessToken) {
+          credentials.accessToken = githubTokens.accessToken;
+          if (githubTokens.refreshToken) {
+            credentials.refreshToken = githubTokens.refreshToken;
+          }
+          copilotResult = await refreshCopilotToken(githubTokens.accessToken, log);
+        }
+      }
+      
+      if (copilotResult?.token) {
+        credentials.copilotToken = copilotResult.token;
+        newCredentials = {
+          accessToken: credentials.accessToken,
+          refreshToken: credentials.refreshToken,
+          providerSpecificData: {
+            ...credentials.providerSpecificData,
+            copilotToken: copilotResult.token,
+            copilotTokenExpiresAt: copilotResult.expiresAt
+          }
+        };
+        log?.info?.("TOKEN", `${provider.toUpperCase()} | copilotToken refreshed`);
+      }
+    } else {
+      newCredentials = await refreshWithRetry(
+        () => refreshTokenByProvider(provider, credentials, log),
+        3,
+        log
+      );
+    }
+
+    if (newCredentials?.accessToken || (provider === "github" && credentials.copilotToken)) {
+      if (newCredentials?.accessToken) {
+        log?.info?.("TOKEN", `${provider.toUpperCase()} | refreshed`);
+        credentials.accessToken = newCredentials.accessToken;
+      }
+      if (newCredentials?.refreshToken) {
+        credentials.refreshToken = newCredentials.refreshToken;
+      }
+      if (newCredentials?.providerSpecificData) {
+        credentials.providerSpecificData = {
+          ...credentials.providerSpecificData,
+          ...newCredentials.providerSpecificData
+        };
+      }
+
+      // Notify caller about refreshed credentials
+      if (onCredentialsRefreshed && newCredentials) {
+        await onCredentialsRefreshed(newCredentials);
+      }
+
+      // Retry with new credentials
+      const newHeaders = buildProviderHeaders(provider, credentials, stream, translatedBody);
+      const retryResponse = await fetch(providerUrl, {
+        method: "POST",
+        headers: newHeaders,
+        body: JSON.stringify(translatedBody),
+        signal: streamController.signal
+      });
+
+      if (retryResponse.ok) {
+        providerResponse = retryResponse;
+      }
+    } else {
+      log?.warn?.("TOKEN", `${provider.toUpperCase()} | refresh failed`);
+    }
+  }
+
+  // Check provider response - return error info for fallback handling
+  if (!providerResponse.ok) {
+    const { statusCode, message } = await parseUpstreamError(providerResponse);
+    const errMsg = formatProviderError(new Error(message), provider, model);
+    console.log(`${COLORS.red}[ERROR] ${errMsg}${COLORS.reset}`);
+    
+    // Log error with full request body for debugging
+    reqLogger.logError(new Error(message), translatedBody);
+
+    return createErrorResult(statusCode, errMsg);
+  }
+
+  // Non-streaming response
+  if (!stream) {
+    const responseBody = await providerResponse.json();
+    
+    // Notify success - caller can clear error status if needed
+    if (onRequestSuccess) {
+      await onRequestSuccess();
+    }
+    
+    return {
+      success: true,
+      response: new Response(JSON.stringify(responseBody), {
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*"
+        }
+      })
+    };
+  }
+
+  // Streaming response
+  
+  // Notify success - caller can clear error status if needed
+  if (onRequestSuccess) {
+    await onRequestSuccess();
+  }
+
+  const responseHeaders = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    "Access-Control-Allow-Origin": "*"
+  };
+
+  // Create transform stream with logger for streaming response
+  let transformStream;
+  if (needsTranslation(targetFormat, sourceFormat)) {
+    transformStream = createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider, reqLogger);
+  } else {
+    transformStream = createPassthroughStreamWithLogger(provider, reqLogger);
+  }
+
+  // Pipe response through transform with disconnect detection
+  const transformedBody = pipeWithDisconnect(providerResponse, transformStream, streamController);
+
+  return {
+    success: true,
+    response: new Response(transformedBody, {
+      headers: responseHeaders
+    })
+  };
+}
+
+/**
+ * Check if token is expired or about to expire
+ */
+export function isTokenExpiringSoon(expiresAt, bufferMs = 5 * 60 * 1000) {
+  if (!expiresAt) return false;
+  const expiresAtMs = new Date(expiresAt).getTime();
+  return expiresAtMs - Date.now() < bufferMs;
+}

package/handlers/responsesHandler.js

@@ -0,0 +1,69 @@
+/**
+ * Responses API Handler for Workers
+ * Converts Chat Completions to Codex Responses API format
+ */
+
+import { handleChatCore } from "./chatCore.js";
+import { convertResponsesApiFormat } from "../translator/helpers/responsesApiHelper.js";
+import { createResponsesApiTransformStream } from "../transformer/responsesTransformer.js";
+
+/**
+ * Handle /v1/responses request
+ * @param {object} options
+ * @param {object} options.body - Request body (Responses API format)
+ * @param {object} options.modelInfo - { provider, model }
+ * @param {object} options.credentials - Provider credentials
+ * @param {object} options.log - Logger instance (optional)
+ * @param {function} options.onCredentialsRefreshed - Callback when credentials are refreshed
+ * @param {function} options.onRequestSuccess - Callback when request succeeds
+ * @param {function} options.onDisconnect - Callback when client disconnects
+ * @returns {Promise<{success: boolean, response?: Response, status?: number, error?: string}>}
+ */
+export async function handleResponsesCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect }) {
+  // Convert Responses API format to Chat Completions format
+  const convertedBody = convertResponsesApiFormat(body);
+  
+  // Ensure stream is enabled
+  convertedBody.stream = true;
+
+  // Call chat core handler
+  const result = await handleChatCore({
+    body: convertedBody,
+    modelInfo,
+    credentials,
+    log,
+    onCredentialsRefreshed,
+    onRequestSuccess,
+    onDisconnect
+  });
+
+  if (!result.success || !result.response) {
+    return result;
+  }
+
+  const response = result.response;
+  const contentType = response.headers.get("Content-Type") || "";
+
+  // If not SSE or error, return as-is
+  if (!contentType.includes("text/event-stream") || response.status !== 200) {
+    return result;
+  }
+
+  // Transform SSE stream to Responses API format (no logging in worker)
+  const transformStream = createResponsesApiTransformStream(null);
+  const transformedBody = response.body.pipeThrough(transformStream);
+
+  return {
+    success: true,
+    response: new Response(transformedBody, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "Access-Control-Allow-Origin": "*"
+      }
+    })
+  };
+}
+

package/index.js

@@ -0,0 +1,69 @@
+// Config
+export { PROVIDERS, OAUTH_ENDPOINTS, CACHE_TTL, DEFAULT_MAX_TOKENS, CLAUDE_SYSTEM_PROMPT, COOLDOWN_MS, BACKOFF_CONFIG } from "./config/constants.js";
+export { 
+  PROVIDER_MODELS, 
+  getProviderModels,
+  getDefaultModel, 
+  isValidModel,
+  findModelName,
+  getModelTargetFormat,
+  PROVIDER_ID_TO_ALIAS,
+  getModelsByProviderId
+} from "./config/providerModels.js";
+
+// Translator
+export { FORMATS } from "./translator/formats.js";
+export { 
+  register, 
+  translateRequest, 
+  translateResponse, 
+  needsTranslation, 
+  initState, 
+  initTranslators 
+} from "./translator/index.js";
+
+// Services
+export { 
+  detectFormat, 
+  getProviderConfig, 
+  buildProviderUrl, 
+  buildProviderHeaders, 
+  getTargetFormat 
+} from "./services/provider.js";
+
+export { parseModel, resolveModelAliasFromMap, getModelInfoCore } from "./services/model.js";
+
+export {
+  checkFallbackError,
+  isAccountUnavailable,
+  getUnavailableUntil,
+  filterAvailableAccounts
+} from "./services/accountFallback.js";
+
+export {
+  TOKEN_EXPIRY_BUFFER_MS,
+  refreshAccessToken,
+  refreshClaudeOAuthToken,
+  refreshGoogleToken,
+  refreshQwenToken,
+  refreshCodexToken,
+  refreshIflowToken,
+  refreshGitHubToken,
+  refreshCopilotToken,
+  getAccessToken,
+  refreshTokenByProvider
+} from "./services/tokenRefresh.js";
+
+// Handlers
+export { handleChatCore, isTokenExpiringSoon } from "./handlers/chatCore.js";
+export { createStreamController, pipeWithDisconnect, createDisconnectAwareStream } from "./utils/streamHandler.js";
+
+// Utils
+export { errorResponse, formatProviderError } from "./utils/error.js";
+export { 
+  createSSETransformStreamWithLogger, 
+  createPassthroughStreamWithLogger 
+} from "./utils/stream.js";
+
+export { createRequestLogger } from "./utils/requestLogger.js";
+

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "open-sse",
+  "version": "1.0.0",
+  "description": "Universal AI proxy library with SSE streaming support for OpenAI, Claude, Gemini and more",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./*": "./*"
+  },
+  "files": [
+    "index.js",
+    "config/",
+    "handlers/",
+    "services/",
+    "translator/",
+    "utils/"
+  ],
+  "scripts": {
+    "prepublishOnly": "echo '✅ Publishing open-sse...'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/router4.git",
+    "directory": "open-sse"
+  },
+  "keywords": [
+    "ai",
+    "proxy",
+    "sse",
+    "openai",
+    "claude",
+    "gemini",
+    "streaming",
+    "llm",
+    "api"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
+

package/services/accountFallback.js

@@ -0,0 +1,148 @@
+import { COOLDOWN_MS, BACKOFF_CONFIG } from "../config/constants.js";
+
+/**
+ * Calculate exponential backoff cooldown for rate limits (429)
+ * Level 0: 1s, Level 1: 2s, Level 2: 4s... → max 30 min
+ * @param {number} backoffLevel - Current backoff level
+ * @returns {number} Cooldown in milliseconds
+ */
+export function getQuotaCooldown(backoffLevel = 0) {
+  const cooldown = BACKOFF_CONFIG.base * Math.pow(2, backoffLevel);
+  return Math.min(cooldown, BACKOFF_CONFIG.max);
+}
+
+/**
+ * Check if error should trigger account fallback (switch to next account)
+ * @param {number} status - HTTP status code
+ * @param {string} errorText - Error message text
+ * @param {number} backoffLevel - Current backoff level for exponential backoff
+ * @returns {{ shouldFallback: boolean, cooldownMs: number, newBackoffLevel?: number }}
+ */
+export function checkFallbackError(status, errorText, backoffLevel = 0) {
+  // 401 - Authentication error (token expired/invalid)
+  if (status === 401) {
+    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.unauthorized };
+  }
+
+  // 402/403 - Payment required / Forbidden (quota/permission)
+  if (status === 402 || status === 403) {
+    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.paymentRequired };
+  }
+
+  // 404 - Model not found (long cooldown)
+  if (status === 404) {
+    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.notFound };
+  }
+
+  // Check error message FIRST (before status codes) for specific patterns
+  if (errorText) {
+    const lowerError = errorText.toLowerCase();
+    
+    // "Request not allowed" - short cooldown (5s), takes priority over status code
+    if (lowerError.includes("request not allowed")) {
+      return { shouldFallback: true, cooldownMs: COOLDOWN_MS.requestNotAllowed };
+    }
+    
+    // Rate limit keywords - exponential backoff
+    if (
+      lowerError.includes("rate limit") ||
+      lowerError.includes("too many requests") ||
+      lowerError.includes("quota exceeded") ||
+      lowerError.includes("capacity") ||
+      lowerError.includes("overloaded")
+    ) {
+      const newLevel = Math.min(backoffLevel + 1, BACKOFF_CONFIG.maxLevel);
+      return { 
+        shouldFallback: true, 
+        cooldownMs: getQuotaCooldown(backoffLevel),
+        newBackoffLevel: newLevel
+      };
+    }
+  }
+
+  // 429 - Rate limit with exponential backoff
+  if (status === 429) {
+    const newLevel = Math.min(backoffLevel + 1, BACKOFF_CONFIG.maxLevel);
+    return { 
+      shouldFallback: true, 
+      cooldownMs: getQuotaCooldown(backoffLevel),
+      newBackoffLevel: newLevel
+    };
+  }
+
+  // 408/500/502/503/504 - Transient errors (short cooldown)
+  if (status === 408 || status === 500 || status === 502 || status === 503 || status === 504) {
+    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.transient };
+  }
+
+  return { shouldFallback: false, cooldownMs: 0 };
+}
+
+/**
+ * Check if account is currently unavailable (cooldown not expired)
+ */
+export function isAccountUnavailable(unavailableUntil) {
+  if (!unavailableUntil) return false;
+  return new Date(unavailableUntil).getTime() > Date.now();
+}
+
+/**
+ * Calculate unavailable until timestamp
+ */
+export function getUnavailableUntil(cooldownMs) {
+  return new Date(Date.now() + cooldownMs).toISOString();
+}
+
+/**
+ * Filter available accounts (not in cooldown)
+ */
+export function filterAvailableAccounts(accounts, excludeId = null) {
+  const now = Date.now();
+  return accounts.filter(acc => {
+    if (excludeId && acc.id === excludeId) return false;
+    if (acc.rateLimitedUntil) {
+      const until = new Date(acc.rateLimitedUntil).getTime();
+      if (until > now) return false;
+    }
+    return true;
+  });
+}
+
+/**
+ * Reset account state when request succeeds
+ * Clears cooldown and resets backoff level to 0
+ * @param {object} account - Account object
+ * @returns {object} Updated account with reset state
+ */
+export function resetAccountState(account) {
+  if (!account) return account;
+  return {
+    ...account,
+    rateLimitedUntil: null,
+    backoffLevel: 0,
+    lastError: null,
+    status: "active"
+  };
+}
+
+/**
+ * Apply error state to account
+ * @param {object} account - Account object
+ * @param {number} status - HTTP status code
+ * @param {string} errorText - Error message
+ * @returns {object} Updated account with error state
+ */
+export function applyErrorState(account, status, errorText) {
+  if (!account) return account;
+  
+  const backoffLevel = account.backoffLevel || 0;
+  const { cooldownMs, newBackoffLevel } = checkFallbackError(status, errorText, backoffLevel);
+  
+  return {
+    ...account,
+    rateLimitedUntil: cooldownMs > 0 ? getUnavailableUntil(cooldownMs) : null,
+    backoffLevel: newBackoffLevel ?? backoffLevel,
+    lastError: { status, message: errorText, timestamp: new Date().toISOString() },
+    status: "error"
+  };
+}

package/services/combo.js

@@ -0,0 +1,69 @@
+/**
+ * Shared combo (model combo) handling with fallback support
+ */
+
+/**
+ * Get combo models from combos data
+ * @param {string} modelStr - Model string to check
+ * @param {Array|Object} combosData - Array of combos or object with combos
+ * @returns {string[]|null} Array of models or null if not a combo
+ */
+export function getComboModelsFromData(modelStr, combosData) {
+  // Don't check if it's in provider/model format
+  if (modelStr.includes("/")) return null;
+  
+  // Handle both array and object formats
+  const combos = Array.isArray(combosData) ? combosData : (combosData?.combos || []);
+  
+  const combo = combos.find(c => c.name === modelStr);
+  if (combo && combo.models && combo.models.length > 0) {
+    return combo.models;
+  }
+  return null;
+}
+
+/**
+ * Handle combo chat with fallback
+ * @param {Object} options
+ * @param {Object} options.body - Request body
+ * @param {string[]} options.models - Array of model strings to try
+ * @param {Function} options.handleSingleModel - Function to handle single model: (body, modelStr) => Promise<Response>
+ * @param {Object} options.log - Logger object
+ * @returns {Promise<Response>}
+ */
+export async function handleComboChat({ body, models, handleSingleModel, log }) {
+  let lastError = null;
+
+  for (let i = 0; i < models.length; i++) {
+    const modelStr = models[i];
+    log.info("COMBO", `Trying model ${i + 1}/${models.length}: ${modelStr}`);
+
+    const result = await handleSingleModel(body, modelStr);
+    
+    // Success (2xx) - return response
+    if (result.ok) {
+      return result;
+    }
+
+    // 401 unauthorized - return immediately (auth error)
+    if (result.status === 401) {
+      return result;
+    }
+
+    // 4xx/5xx - try next model
+    lastError = `${modelStr}: ${result.statusText || result.status}`;
+    log.warn("COMBO", `Model failed, trying next`, { model: modelStr, status: result.status });
+  }
+
+  log.warn("COMBO", "All models failed");
+  
+  // Return 503 with last error
+  return new Response(
+    JSON.stringify({ error: lastError || "All combo models unavailable" }),
+    { 
+      status: 503, 
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+}
+