zevairouter 1.0.153 → 1.0.155

package/open-sse/handlers/chatCore.js

@@ -1,383 +0,0 @@
-import { setTimeout as delay } from "node:timers/promises";
-import { detectFormat, getTargetFormat } from "../services/provider.js";
-import { translateRequest } from "../translator/index.js";
-import { FORMATS } from "../translator/formats.js";
-import { COLORS } from "../utils/stream.js";
-import { createStreamController, cancelResponseBody } from "../utils/streamHandler.js";
-import { refreshWithRetry } from "../services/tokenRefresh.js";
-import { createRequestLogger } from "../utils/requestLogger.js";
-import { getModelTargetFormat, getModelStrip, getModelUpstreamId, getModelType, PROVIDER_ID_TO_ALIAS } from "../config/providerModels.js";
-import { createErrorResult, parseUpstreamError, formatProviderError } from "../utils/error.js";
-import { HTTP_STATUS } from "../config/runtimeConfig.js";
-import { handleBypassRequest } from "../utils/bypassHandler.js";
-import { trackPendingRequest, appendRequestLog, saveRequestDetail } from "@/lib/usageDb.js";
-import { getEnabledContextFiles } from "@/lib/localDb.js";
-import { getExecutor } from "../executors/index.js";
-import { buildRequestDetail, extractRequestConfig } from "./chatCore/requestDetail.js";
-import { handleForcedSSEToJson } from "./chatCore/sseToJsonHandler.js";
-import { handleNonStreamingResponse } from "./chatCore/nonStreamingHandler.js";
-import { handleStreamingResponse, buildOnStreamComplete } from "./chatCore/streamingHandler.js";
-import { detectClientTool, isNativePassthrough } from "../utils/clientDetector.js";
-import { dedupeTools } from "../utils/toolDeduper.js";
-import { injectCaveman } from "../rtk/caveman.js";
-import { injectPonytail } from "../rtk/ponytail.js";
-import { injectContextFiles } from "../context/injectContext.js";
-import { compressMessages, formatRtkLog } from "../rtk/index.js";
-import { compressWithHeadroom, formatHeadroomSizeLog, isHeadroomPhantomSavings } from "../rtk/headroom.js";
-import { compressWithPxpipe } from "../rtk/pxpipe.js";
-import { applyThinkingFromModelAndSettings, stripThinkingSuffix } from "../utils/thinkingSuffix.js";
-
-/**
- * Core chat handler - shared between SSE and Worker
- * @param {object} options.body - Request body
- * @param {object} options.modelInfo - { provider, model }
- * @param {object} options.credentials - Provider credentials
- * @param {string} options.sourceFormatOverride - Override detected source format (e.g. "openai-responses")
- */
-export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest, connectionId, userAgent, apiKey, ccFilterNaming, rtkEnabled, headroomEnabled, headroomUrl, headroomCompressUserMessages, cavemanEnabled, cavemanLevel, contextInjectionEnabled, ponytailEnabled, ponytailLevel, pxpipeEnabled, pxpipeMinChars, pxpipeTimeoutMs, pxpipeTransform, onPxpipeEvent, sourceFormatOverride, providerThinking, signal }) {
-  const { provider } = modelInfo;
-  const requestStartTime = Date.now();
-
-  const sourceFormat = sourceFormatOverride || detectFormat(body);
-
-  // Check for bypass patterns (warmup, skip, cc naming)
-  const bypassResponse = handleBypassRequest(body, modelInfo.model, userAgent, ccFilterNaming);
-  if (bypassResponse) return bypassResponse;
-
-  // model(high) suffix + per-provider thinking settings → reasoning_effort / thinking
-  const thinkingApplied = applyThinkingFromModelAndSettings(modelInfo.model, body, providerThinking);
-  body = thinkingApplied.body;
-  const model = thinkingApplied.cleanModel;
-  if (thinkingApplied.applied) {
-    log?.debug?.("THINKING", `Applied thinking mode=${thinkingApplied.applied} (model=${modelInfo.model})`);
-  }
-
-  const alias = PROVIDER_ID_TO_ALIAS[provider] || provider;
-  const modelTargetFormat = getModelTargetFormat(alias, model);
-  const targetFormat = modelTargetFormat || getTargetFormat(provider);
-  const stripList = getModelStrip(alias, model);
-  const upstreamModel = stripThinkingSuffix(getModelUpstreamId(alias, model));
-
-  const clientRequestedStreaming = body.stream === true || sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI || sourceFormat === FORMATS.GEMINI_CLI;
-  const providerRequiresStreaming = provider === "openai" || provider === "codex" || provider === "commandcode";
-  let stream = providerRequiresStreaming ? true : (body.stream !== false);
-
-  // DeepSeek-TUI: interactive TUI panel sends stream:true and needs SSE.
-  // Non-interactive mode (-p flag) sends without stream and can't parse SSE.
-  // Only force non-streaming when client didn't explicitly request it.
-  const detectedTool = detectClientTool(clientRawRequest?.headers || {}, body);
-  if (detectedTool === "deepseek-tui" && body.stream !== true) stream = false;
-
-  // Check client Accept header preference for non-streaming requests
-  // This fixes AI SDK compatibility where clients send Accept: application/json
-  const acceptHeader = clientRawRequest?.headers?.accept || "";
-  const clientPrefersJson = acceptHeader.includes("application/json");
-  const clientPrefersSSE = acceptHeader.includes("text/event-stream");
-  if (clientPrefersJson && !clientPrefersSSE && body.stream !== true) {
-    stream = false;
-  }
-
-  const reqLogger = await createRequestLogger(sourceFormat, targetFormat, model);
-  if (clientRawRequest) reqLogger.logClientRawRequest(clientRawRequest.endpoint, clientRawRequest.body, clientRawRequest.headers);
-  reqLogger.logRawRequest(body);
-  log?.debug?.("FORMAT", `${sourceFormat} → ${targetFormat} | stream=${stream}`);
-
-  // Native passthrough: CLI tool and provider are the same ecosystem
-  // Skip all translation/normalization — only model and Bearer are swapped
-  const clientTool = detectClientTool(clientRawRequest?.headers || {}, body);
-  const passthrough = isNativePassthrough(clientTool, provider);
-
-  let translatedBody;
-  let toolNameMap;
-  if (passthrough) {
-    log?.debug?.("PASSTHROUGH", `${clientTool} → ${provider} | native lossless`);
-    translatedBody = { ...body, model: upstreamModel };
-  } else {
-    translatedBody = translateRequest(sourceFormat, targetFormat, upstreamModel, body, stream, credentials, provider, reqLogger, stripList, connectionId, clientTool);
-    if (!translatedBody) {
-      trackPendingRequest(model, provider, connectionId, false, true);
-      return createErrorResult(HTTP_STATUS.BAD_REQUEST, `Failed to translate request for ${sourceFormat} → ${targetFormat}`);
-    }
-    toolNameMap = translatedBody._toolNameMap;
-    delete translatedBody._toolNameMap;
-    translatedBody.model = upstreamModel;
-  }
-
-  // Dedupe duplicate built-in tools when equivalent MCP tools are present (Claude clients only).
-  if (clientTool === "claude" && Array.isArray(translatedBody.tools)) {
-    const { tools: deduped, stripped } = dedupeTools(translatedBody.tools);
-    if (stripped.length > 0) {
-      translatedBody.tools = deduped;
-      log?.debug?.("TOOLDEDUP", `stripped ${stripped.length}: ${stripped.slice(0, 3).join(", ")}${stripped.length > 3 ? "..." : ""}`);
-    }
-  }
-
-  // Token savers: applied at the final body just before dispatch
-  // Covers both passthrough (source shape) and translated (target shape) flows
-  const finalFormat = passthrough ? sourceFormat : targetFormat;
-
-  // TTS models don't support tool messages/function calling
-  if (getModelType(alias, model) === "tts" && translatedBody.messages) {
-    translatedBody.messages = translatedBody.messages.filter(msg => msg.role !== "tool");
-    delete translatedBody.tools;
-  }
-
-  // RTK: compress tool_result content
-  const rtkStats = compressMessages(translatedBody, rtkEnabled);
-  const rtkLine = formatRtkLog(rtkStats);
-  if (rtkLine) console.log(rtkLine);
-
-  // Headroom: optional external proxy compression; fail open if proxy is absent.
-  const headroomDiagnostics = {};
-  const headroomStats = await compressWithHeadroom(translatedBody, {
-    enabled: headroomEnabled,
-    url: headroomUrl,
-    model: upstreamModel,
-    format: finalFormat,
-    compressUserMessages: headroomCompressUserMessages,
-    diagnostics: headroomDiagnostics,
-  });
-  if (headroomStats) {
-    const before = headroomStats.tokens_before || 0;
-    const delta = headroomStats.tokens_saved || 0;
-    const pct = before > 0 ? ((delta / before) * 100).toFixed(1) : "0";
-    log?.debug?.("HEADROOM", `−${delta}tok(${pct}%)`);
-    if (isHeadroomPhantomSavings(headroomStats, headroomDiagnostics)) {
-      log?.warn?.("HEADROOM", `reported token delta, but outbound JSON shrank <5%; provider may bill near-original payload | ${formatHeadroomSizeLog(headroomDiagnostics)}`);
-    }
-  } else if (headroomEnabled) {
-    log?.warn?.("HEADROOM", `skipped: ${headroomDiagnostics.reason || "compression unavailable"}${headroomDiagnostics.endpoint ? ` (${headroomDiagnostics.endpoint})` : ""}`);
-  }
-
-  // Caveman: inject terse-style system prompt
-  if (cavemanEnabled && cavemanLevel) {
-    injectCaveman(translatedBody, finalFormat, cavemanLevel);
-    log?.debug?.("CAVEMAN", `${cavemanLevel} | ${finalFormat}`);
-  }
-
-  // Ponytail: inject lazy-senior-dev coding style
-  if (ponytailEnabled && ponytailLevel) {
-    injectPonytail(translatedBody, finalFormat, ponytailLevel);
-    log?.debug?.("PONYTAIL", `${ponytailLevel} | ${finalFormat}`);
-  }
-
-  // PXPIPE: image bulky context (Claude-format bodies only), last saver before dispatch
-  if (pxpipeEnabled) {
-    const pxpipeResult = await compressWithPxpipe(translatedBody, {
-      enabled: true,
-      format: finalFormat,
-      model: upstreamModel,
-      minChars: pxpipeMinChars,
-      timeoutMs: pxpipeTimeoutMs,
-      transform: pxpipeTransform,
-    });
-    if (pxpipeResult.body) translatedBody = pxpipeResult.body;
-    if (pxpipeResult.summary?.applied) {
-      log?.debug?.("PXPIPE", `${pxpipeResult.summary.imageCount}img | est −${pxpipeResult.summary.savedPct}%`);
-    }
-    try {
-      onPxpipeEvent?.({ provider, model, ...pxpipeResult.summary });
-    } catch {
-      /* stats must not break requests */
-    }
-  }
-
-  // Context injection: prepend user-authored context files (soul.md, agent.md…)
-  if (contextInjectionEnabled) {
-    try {
-      const files = await getEnabledContextFiles();
-      if (files?.length) {
-        const combined = files.map(f => f.content).filter(Boolean).join("\n\n");
-        if (combined) {
-          injectContextFiles(translatedBody, finalFormat, combined);
-          log?.debug?.("CONTEXT", `${files.length} file(s) | ${finalFormat}`);
-        }
-      }
-    } catch (err) {
-      log?.error?.("CONTEXT", `injection failed: ${err.message}`);
-    }
-  }
-
-  const executor = getExecutor(provider);
-  trackPendingRequest(model, provider, connectionId, true);
-  appendRequestLog({ model, provider, connectionId, status: "PENDING" }).catch(() => { });
-
-  const msgCount = translatedBody.messages?.length || translatedBody.input?.length || translatedBody.contents?.length || translatedBody.request?.contents?.length || 0;
-  log?.debug?.("REQUEST", `${provider.toUpperCase()} | ${model} | ${msgCount} msgs`);
-
-  const streamController = createStreamController({
-    onDisconnect: (reason) => {
-      trackPendingRequest(model, provider, connectionId, false);
-      if (onDisconnect) onDisconnect(reason);
-    },
-    onError: () => trackPendingRequest(model, provider, connectionId, false),
-    log, provider, model, signal
-  });
-
-  const proxyOptions = {
-    connectionProxyEnabled: credentials?.providerSpecificData?.connectionProxyEnabled === true,
-    connectionProxyUrl: credentials?.providerSpecificData?.connectionProxyUrl || "",
-    connectionNoProxy: credentials?.providerSpecificData?.connectionNoProxy || "",
-    vercelRelayUrl: credentials?.providerSpecificData?.vercelRelayUrl || "",
-  };
-
-  if (proxyOptions.vercelRelayUrl) {
-    const connectionName = credentials?.connectionName || credentials?.connectionId || "unknown";
-    const poolId = credentials?.providerSpecificData?.connectionProxyPoolId || "none";
-    log?.info?.("PROXY", `${provider.toUpperCase()} | ${model} | conn=${connectionName} | pool=${poolId} | vercel-relay=${proxyOptions.vercelRelayUrl}`);
-  } else if (proxyOptions.connectionProxyEnabled && proxyOptions.connectionProxyUrl) {
-    let maskedProxyUrl = proxyOptions.connectionProxyUrl;
-    try {
-      const parsed = new URL(proxyOptions.connectionProxyUrl);
-      const host = parsed.hostname || "";
-      const port = parsed.port ? `:${parsed.port}` : "";
-      const protocol = parsed.protocol || "http:";
-      maskedProxyUrl = `${protocol}//${host}${port}`;
-    } catch {
-      // Keep raw if URL parsing fails
-    }
-
-    const poolId = credentials?.providerSpecificData?.connectionProxyPoolId || "none";
-    const connectionName = credentials?.connectionName || credentials?.connectionId || "unknown";
-    log?.info?.("PROXY", `${provider.toUpperCase()} | ${model} | conn=${connectionName} | pool=${poolId} | url=${maskedProxyUrl}`);
-  }
-
-  if (proxyOptions.connectionProxyEnabled && proxyOptions.connectionNoProxy) {
-    const connectionName = credentials?.connectionName || credentials?.connectionId || "unknown";
-    log?.debug?.("PROXY", `${provider.toUpperCase()} | ${model} | conn=${connectionName} | no_proxy=${proxyOptions.connectionNoProxy}`);
-  }
-
-  // Execute request with generic retry for transient failures (network errors
-  // and 5xx). 4xx (except 408/429) are never retried — the request itself is bad.
-  // Configurable per-provider via executor.config: { maxRetries, retryBaseMs }.
-  const maxRetries = Number.isFinite(executor.config?.maxRetries) ? executor.config.maxRetries : 2;
-  const retryBaseMs = Number.isFinite(executor.config?.retryBaseMs) ? executor.config.retryBaseMs : 800;
-  const isRetryableStatus = (s) => s === 408 || s === 429 || (s >= 500 && s <= 599);
-  const isRetryableError = (e) => e && e.name !== "AbortError"; // network/DNS/reset, not client abort
-
-  async function executeWithRetry() {
-    let lastErr = null;
-    let lastResult = null;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const result = await executor.execute({ model, body: translatedBody, stream, credentials, signal: streamController.signal, log, proxyOptions });
-        // Success or non-retryable error status → return immediately
-        if (result.response.ok || !isRetryableStatus(result.response.status) || attempt === maxRetries) {
-          return result;
-        }
-        await cancelResponseBody(result.response);
-        const backoff = retryBaseMs * Math.pow(2, attempt);
-        log?.info?.("RETRY", `${provider.toUpperCase()} | ${model} | HTTP ${result.response.status}, retry ${attempt + 1}/${maxRetries} in ${backoff}ms`);
-        await delay(backoff, undefined, { signal: streamController.signal });
-      } catch (e) {
-        lastErr = e;
-        if (!isRetryableError(e) || attempt === maxRetries) throw e;
-        const backoff = retryBaseMs * Math.pow(2, attempt);
-        log?.info?.("RETRY", `${provider.toUpperCase()} | ${model} | ${e.name}, retry ${attempt + 1}/${maxRetries} in ${backoff}ms`);
-        await delay(backoff, undefined, { signal: streamController.signal });
-      }
-    }
-    if (lastResult) return lastResult;
-    throw lastErr || new Error("execute failed");
-  }
-
-  let providerResponse, providerUrl, providerHeaders, finalBody;
-  try {
-    const result = await executeWithRetry();
-    providerResponse = result.response;
-    providerUrl = result.url;
-    providerHeaders = result.headers;
-    finalBody = result.transformedBody;
-    reqLogger.logTargetRequest(providerUrl, providerHeaders, finalBody);
-  } catch (error) {
-    trackPendingRequest(model, provider, connectionId, false, true);
-    appendRequestLog({ model, provider, connectionId, status: `FAILED ${error.name === "AbortError" ? 499 : HTTP_STATUS.BAD_GATEWAY}` }).catch(() => { });
-    saveRequestDetail(buildRequestDetail({
-      provider, model, connectionId,
-      latency: { ttft: 0, total: Date.now() - requestStartTime },
-      tokens: { prompt_tokens: 0, completion_tokens: 0 },
-      request: extractRequestConfig(body, stream),
-      providerRequest: translatedBody || null,
-      response: { error: error.message || String(error), status: error.name === "AbortError" ? 499 : 502, thinking: null },
-      status: "error"
-    })).catch(() => { });
-
-    if (error.name === "AbortError") {
-      streamController.handleError(error);
-      return createErrorResult(499, "Request aborted");
-    }
-    const errMsg = formatProviderError(error, provider, model, HTTP_STATUS.BAD_GATEWAY);
-    console.log(`${COLORS.red}[ERROR] ${errMsg}${COLORS.reset}`);
-    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, errMsg);
-  }
-
-  // Handle 401/403 - try token refresh (skip for noAuth providers)
-  if (!executor.noAuth && (providerResponse.status === HTTP_STATUS.UNAUTHORIZED || providerResponse.status === HTTP_STATUS.FORBIDDEN)) {
-    try {
-      const newCredentials = await refreshWithRetry(() => executor.refreshCredentials(credentials, log, proxyOptions, streamController.signal), 3, log);
-      if (newCredentials?.accessToken || newCredentials?.copilotToken) {
-        log?.info?.("TOKEN", `${provider.toUpperCase()} | refreshed`);
-        Object.assign(credentials, newCredentials);
-        if (onCredentialsRefreshed) {
-          try { await onCredentialsRefreshed(newCredentials); } catch (e) { log?.warn?.("TOKEN", `onCredentialsRefreshed failed: ${e.message}`); }
-        }
-        try {
-          const retryResult = await executor.execute({ model, body: translatedBody, stream, credentials, signal: streamController.signal, log, proxyOptions });
-          if (retryResult.response.ok) { providerResponse = retryResult.response; providerUrl = retryResult.url; }
-        } catch { log?.warn?.("TOKEN", `${provider.toUpperCase()} | retry after refresh failed`); }
-      } else {
-        log?.warn?.("TOKEN", `${provider.toUpperCase()} | refresh failed`);
-      }
-    } catch (e) {
-      log?.warn?.("TOKEN", `${provider.toUpperCase()} | refresh threw: ${e.message}`);
-    }
-  }
-
-  // Provider returned error
-  if (!providerResponse.ok) {
-    streamController.cleanup();
-    trackPendingRequest(model, provider, connectionId, false, true);
-    const { statusCode, message, resetsAtMs } = await parseUpstreamError(providerResponse, executor);
-    appendRequestLog({ model, provider, connectionId, status: `FAILED ${statusCode}` }).catch(() => { });
-    saveRequestDetail(buildRequestDetail({
-      provider, model, connectionId,
-      latency: { ttft: 0, total: Date.now() - requestStartTime },
-      tokens: { prompt_tokens: 0, completion_tokens: 0 },
-      request: extractRequestConfig(body, stream),
-      providerRequest: finalBody || translatedBody || null,
-      response: { error: message, status: statusCode, thinking: null },
-      status: "error"
-    })).catch(() => { });
-
-    const errMsg = formatProviderError(new Error(message), provider, model, statusCode);
-    console.log(`${COLORS.red}[ERROR] ${errMsg}${COLORS.reset}`);
-    reqLogger.logError(new Error(message), finalBody || translatedBody);
-    return createErrorResult(statusCode, errMsg, resetsAtMs);
-  }
-
-  const sharedCtx = { provider, model, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess };
-  const appendLog = (extra) => appendRequestLog({ model, provider, connectionId, ...extra }).catch(() => { });
-  const trackDone = () => trackPendingRequest(model, provider, connectionId, false);
-
-  // Provider forced streaming but client wants JSON
-  if (!clientRequestedStreaming && providerRequiresStreaming) {
-    const result = await handleForcedSSEToJson({ ...sharedCtx, providerResponse, sourceFormat, trackDone, appendLog });
-    if (result) { streamController.handleComplete(); return result; }
-  }
-
-  // True non-streaming response
-  if (!stream) {
-    const result = await handleNonStreamingResponse({ ...sharedCtx, providerResponse, sourceFormat, targetFormat, reqLogger, toolNameMap, trackDone, appendLog });
-    streamController.handleComplete();
-    return result;
-  }
-
-  // Streaming response
-  const { onStreamComplete, streamDetailId } = buildOnStreamComplete({ ...sharedCtx });
-  return handleStreamingResponse({ ...sharedCtx, providerResponse, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, streamController, onStreamComplete, streamDetailId });
-}
-
-export function isTokenExpiringSoon(expiresAt, bufferMs = 5 * 60 * 1000) {
-  if (!expiresAt) return false;
-  return new Date(expiresAt).getTime() - Date.now() < bufferMs;
-}

package/open-sse/handlers/embeddingProviders/_base.js

@@ -1,4 +0,0 @@
-// Shared embedding helpers
-export function bearerAuth(creds) {
-  return { "Authorization": `Bearer ${creds.apiKey || creds.accessToken}` };
-}

package/open-sse/handlers/embeddingProviders/gemini.js

@@ -1,57 +0,0 @@
-// Google Gemini embeddings — embedContent / batchEmbedContents
-const BASE = "https://generativelanguage.googleapis.com/v1beta";
-
-function modelPath(model) {
-  return model.startsWith("models/") ? model : `models/${model}`;
-}
-
-const gemini = {
-  buildUrl: (model, creds, { input } = {}) => {
-    const apiKey = creds.apiKey || creds.accessToken;
-    const path = modelPath(model);
-    const op = Array.isArray(input) ? "batchEmbedContents" : "embedContent";
-    return `${BASE}/${path}:${op}?key=${encodeURIComponent(apiKey)}`;
-  },
-  buildHeaders: () => ({ "Content-Type": "application/json" }),
-  buildBody: (model, { input, dimensions }) => {
-    const m = modelPath(model);
-    const outputDimensionality = Number(dimensions);
-    const hasOutputDimensionality = Number.isFinite(outputDimensionality) && outputDimensionality > 0;
-    if (Array.isArray(input)) {
-      return {
-        requests: input.map((text) => ({
-          model: m,
-          content: { parts: [{ text: String(text) }] },
-          ...(hasOutputDimensionality ? { outputDimensionality } : {}),
-        })),
-      };
-    }
-    return {
-      model: m,
-      content: { parts: [{ text: String(input) }] },
-      ...(hasOutputDimensionality ? { outputDimensionality } : {}),
-    };
-  },
-  normalize: (responseBody, model) => {
-    if (responseBody.object === "list" && Array.isArray(responseBody.data)) return responseBody;
-    let items = [];
-    if (Array.isArray(responseBody.embeddings)) {
-      items = responseBody.embeddings.map((emb, idx) => ({
-        object: "embedding",
-        index: idx,
-        embedding: emb.values || [],
-      }));
-    } else if (responseBody.embedding?.values) {
-      items = [{ object: "embedding", index: 0, embedding: responseBody.embedding.values }];
-    }
-    return {
-      object: "list",
-      data: items,
-      model,
-      usage: { prompt_tokens: 0, total_tokens: 0 },
-    };
-  },
-};
-
-
-export default gemini;

package/open-sse/handlers/embeddingProviders/index.js

@@ -1,23 +0,0 @@
-// Embeddings provider adapter registry
-import createOpenAIEmbeddingAdapter from "./openai.js";
-import gemini from "./gemini.js";
-import openaiCompatNode from "./openaiCompatNode.js";
-
-const OPENAI_COMPAT_PROVIDERS = [
-  "openai", "openrouter", "mistral", "voyage-ai", "fireworks",
-  "together", "nebius", "github", "nvidia", "jina-ai",
-];
-
-const ADAPTERS = {
-  ...Object.fromEntries(OPENAI_COMPAT_PROVIDERS.map((id) => [id, createOpenAIEmbeddingAdapter(id)])),
-  gemini,
-  google_ai_studio: gemini,
-};
-
-export function getEmbeddingAdapter(provider) {
-  if (ADAPTERS[provider]) return ADAPTERS[provider];
-  if (provider?.startsWith?.("openai-compatible-") || provider?.startsWith?.("custom-embedding-")) {
-    return openaiCompatNode;
-  }
-  return null;
-}

package/open-sse/handlers/embeddingProviders/openai.js

@@ -1,39 +0,0 @@
-// OpenAI-compatible embeddings adapter (most providers)
-import { bearerAuth } from "./_base.js";
-
-const ENDPOINTS = {
-  openai: "https://api.openai.com/v1/embeddings",
-  openrouter: "https://openrouter.ai/api/v1/embeddings",
-  mistral: "https://api.mistral.ai/v1/embeddings",
-  "voyage-ai": "https://api.voyageai.com/v1/embeddings",
-  fireworks: "https://api.fireworks.ai/inference/v1/embeddings",
-  together: "https://api.together.xyz/v1/embeddings",
-  nebius: "https://api.tokenfactory.nebius.com/v1/embeddings",
-  github: "https://models.github.ai/inference/embeddings",
-  nvidia: "https://integrate.api.nvidia.com/v1/embeddings",
-  "jina-ai": "https://api.jina.ai/v1/embeddings",
-};
-
-export default function createOpenAIEmbeddingAdapter(providerId) {
-  return {
-    buildUrl: () => ENDPOINTS[providerId],
-    buildHeaders: (creds) => {
-      const headers = { "Content-Type": "application/json", ...bearerAuth(creds) };
-      if (providerId === "openrouter") {
-        headers["HTTP-Referer"] = "https://endpoint-proxy.local";
-        headers["X-Title"] = "Endpoint Proxy";
-      }
-      return headers;
-    },
-    buildBody: (model, { input, encoding_format, dimensions }) => {
-      const body = { model, input };
-      if (encoding_format) body.encoding_format = encoding_format;
-      if (dimensions != null && dimensions !== "") {
-        const dim = Number(dimensions);
-        if (Number.isFinite(dim) && dim > 0) body.dimensions = dim;
-      }
-      return body;
-    },
-    normalize: (responseBody) => responseBody,
-  };
-}

package/open-sse/handlers/embeddingProviders/openaiCompatNode.js

@@ -1,16 +0,0 @@
-// Custom node providers (openai-compatible-* / custom-embedding-*) — baseUrl from credentials
-import createOpenAIEmbeddingAdapter from "./openai.js";
-
-const baseAdapter = createOpenAIEmbeddingAdapter("openai");
-
-const openaiCompatNode = {
-  ...baseAdapter,
-  buildUrl: (_model, creds) => {
-    const rawBaseUrl = creds?.providerSpecificData?.baseUrl || "https://api.openai.com/v1";
-    const baseUrl = rawBaseUrl.replace(/\/$/, "").replace(/\/embeddings$/, "");
-    return `${baseUrl}/embeddings`;
-  },
-};
-
-
-export default openaiCompatNode;

package/open-sse/handlers/embeddingsCore.js

@@ -1,126 +0,0 @@
-import { createErrorResult, parseUpstreamError, formatProviderError } from "../utils/error.js";
-import { HTTP_STATUS } from "../config/runtimeConfig.js";
-import { getExecutor } from "../executors/index.js";
-import { refreshWithRetry } from "../services/tokenRefresh.js";
-import { getEmbeddingAdapter } from "./embeddingProviders/index.js";
-
-/**
- * Core embeddings handler — orchestrator only. Provider-specific URL/headers/body/normalize
- * live in `./embeddingProviders/{id}.js`.
- *
- * @returns {Promise<{ success: boolean, response: Response, status?: number, error?: string }>}
- */
-export async function handleEmbeddingsCore({
-  body,
-  modelInfo,
-  credentials,
-  log,
-  onCredentialsRefreshed,
-  onRequestSuccess,
-}) {
-  const { provider, model } = modelInfo;
-
-  // Validate input
-  const input = body.input;
-  if (!input) {
-    return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: input");
-  }
-  if (typeof input !== "string" && !Array.isArray(input)) {
-    return createErrorResult(HTTP_STATUS.BAD_REQUEST, "input must be a string or array of strings");
-  }
-
-  const adapter = getEmbeddingAdapter(provider);
-  if (!adapter) {
-    return createErrorResult(
-      HTTP_STATUS.BAD_REQUEST,
-      `Provider '${provider}' does not support embeddings.`
-    );
-  }
-
-  const ctx = { input };
-  const url = adapter.buildUrl(model, credentials, ctx);
-  const headers = adapter.buildHeaders(credentials, ctx);
-  const requestBody = adapter.buildBody(model, {
-    input,
-    encoding_format: body.encoding_format || "float",
-    dimensions: body.dimensions,
-  });
-
-  log?.debug?.("EMBEDDINGS", `${provider.toUpperCase()} | ${model} | input_type=${Array.isArray(input) ? `array[${input.length}]` : "string"}`);
-
-  let providerResponse;
-  try {
-    providerResponse = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(requestBody),
-    });
-  } catch (error) {
-    const errMsg = formatProviderError(error, provider, model, HTTP_STATUS.BAD_GATEWAY);
-    log?.debug?.("EMBEDDINGS", `Fetch error: ${errMsg}`);
-    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, errMsg);
-  }
-
-  // Handle 401/403 — try token refresh (skip for noAuth providers)
-  const executor = getExecutor(provider);
-  if (
-    !executor?.noAuth &&
-    (providerResponse.status === HTTP_STATUS.UNAUTHORIZED ||
-      providerResponse.status === HTTP_STATUS.FORBIDDEN)
-  ) {
-    const newCredentials = await refreshWithRetry(
-      () => executor.refreshCredentials(credentials, log),
-      3,
-      log
-    );
-
-    if (newCredentials?.accessToken || newCredentials?.apiKey) {
-      log?.info?.("TOKEN", `${provider.toUpperCase()} | refreshed for embeddings`);
-      Object.assign(credentials, newCredentials);
-      if (onCredentialsRefreshed) await onCredentialsRefreshed(newCredentials);
-
-      try {
-        const retryHeaders = adapter.buildHeaders(credentials, ctx);
-        const retryUrl = adapter.buildUrl(model, credentials, ctx);
-        providerResponse = await fetch(retryUrl, {
-          method: "POST",
-          headers: retryHeaders,
-          body: JSON.stringify(requestBody),
-        });
-      } catch {
-        log?.warn?.("TOKEN", `${provider.toUpperCase()} | retry after refresh failed`);
-      }
-    } else {
-      log?.warn?.("TOKEN", `${provider.toUpperCase()} | refresh failed`);
-    }
-  }
-
-  if (!providerResponse.ok) {
-    const { statusCode, message } = await parseUpstreamError(providerResponse);
-    const errMsg = formatProviderError(new Error(message), provider, model, statusCode);
-    log?.debug?.("EMBEDDINGS", `Provider error: ${errMsg}`);
-    return createErrorResult(statusCode, errMsg);
-  }
-
-  let responseBody;
-  try {
-    responseBody = await providerResponse.json();
-  } catch {
-    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, `Invalid JSON response from ${provider}`);
-  }
-
-  if (onRequestSuccess) await onRequestSuccess();
-
-  const normalized = adapter.normalize(responseBody, model);
-  log?.debug?.("EMBEDDINGS", `Success | usage=${JSON.stringify(normalized.usage || {})}`);
-
-  return {
-    success: true,
-    response: new Response(JSON.stringify(normalized), {
-      headers: {
-        "Content-Type": "application/json",
-        "Access-Control-Allow-Origin": "*",
-      },
-    }),
-  };
-}