Skip to content

Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors

22.4 KB
Raw Blame
import { getEmbeddingProvider } from "@omniroute/open-sse/config/embeddingRegistry.ts";
import { getRegistryEntry } from "@omniroute/open-sse/config/providerRegistry.ts";
import {
  isClaudeCodeCompatibleProvider,
  isAnthropicCompatibleProvider,
  isLocalProvider,
  isOpenAICompatibleProvider,
  isSelfHostedChatProvider,
  providerAllowsOptionalApiKey,
  resolveProviderId,
  WEB_COOKIE_PROVIDERS,
} from "@/shared/constants/providers";
import { MODAL_DEFAULT_VALIDATION_MODEL_ID } from "@/shared/constants/modal";
import { validateImageProviderApiKey } from "@/lib/providers/imageValidation";
import { usesCcWireImage } from "@omniroute/open-sse/services/ccWireImageBuiltins.ts";
import {
  isAlibabaRegionalProvider,
  resolveAlibabaProviderBaseUrl,
} from "@/shared/constants/alibabaProviderRegions";
import { buildProviderHeaders, buildProviderUrl } from "@omniroute/open-sse/services/provider.ts";

import {
  OPENAI_LIKE_FORMATS,
  GEMINI_LIKE_FORMATS,
  normalizeBaseUrl,
  addModelsSuffix,
  resolveBaseUrl,
} from "./validation/urlHelpers";
import { toValidationErrorResult } from "./validation/transport";
import {
  validateDeepSeekWebProvider,
  validateGrokWebProvider,
  validatePerplexityWebProvider,
  validateBlackboxWebProvider,
  validateKimiWebProvider,
} from "./validation/webProvidersA";
import {
  validateMuseSparkWebProvider,
  validateAdaptaWebProvider,
  validateTinyCmsWebProvider,
  validateClaudeWebProvider,
  validateGeminiWebProvider,
  validateCopilotM365WebProvider,
  validateCopilotWebProvider,
  validateT3WebProvider,
  validateJulesProvider,
  validateDevinCloudAgentProvider,
  validateInnerAiProvider,
  validateNotionWebProvider,
  validateSyntxProvider,
} from "./validation/webProvidersB";
import {
  validateHerokuProvider,
  validateDatabricksProvider,
  validateDataRobotProvider,
  validateSnowflakeProvider,
  validateGigachatProvider,
  validateAzureOpenAIProvider,
  validateAzureAiProvider,
  validateWatsonxProvider,
  validateOciProvider,
  validateSapProvider,
} from "./validation/cloudProviders";
import {
  validateDeepgramProvider,
  validateAssemblyAIProvider,
  validateRevAiProvider,
  validateSonioxProvider,
  validateElevenLabsProvider,
  validateInworldProvider,
  validateKieProvider,
  validateAwsPollyProvider,
  validateBailianCodingPlanProvider,
  validateQwenCloudTokenPlanProvider,
  validateRekaProvider,
  validateMaritalkProvider,
  validateNlpCloudProvider,
  validateOneMinAiProvider,
  validateRunwayProvider,
  validateNousResearchProvider,
  validatePoeProvider,
} from "./validation/audioMiscProviders";
import { validateTypesafeProvider } from "./validation/typesafe";
import { validateZaiWebProvider } from "./validation/zaiWeb";
import { validateSearchProvider, SEARCH_VALIDATOR_CONFIGS } from "./validation/searchProviders";
import {
  validateClarifaiProvider,
  validateEmbeddingApiProvider,
  validateJinaFoundationProvider,
  validateRerankApiProvider,
} from "./validation/embeddingProviders";
import {
  validateBedrockProvider,
  validateOpenAILikeProvider,
  validateCommandCodeProvider,
  validateGeminiLikeProvider,
  validateHuggingFaceProvider,
  validateOpenAICompatibleProvider,
} from "./validation/openaiFormat";
import {
  validateAnthropicLikeProvider,
  validateAnthropicCompatibleProvider,
  validateClaudeCodeCompatibleProvider,
} from "./validation/anthropicFormat";
import {
  validateWebCookieProvider,
  bytezValidationResultFromStatus,
  validateBytezProvider,
} from "./validation/webCookie";
import { validateAiHordeProvider } from "./validation/aihorde";
import { validateDifyProvider } from "./validation/dify";
import { validateZyloApiProvider } from "./validation/zylo";
import { validateInceptionProvider } from "./validation/inception";
import { validateAdobeFireflyProvider } from "./validation/adobeFirefly";
import {
  validateV0VercelProvider,
  validateAuggieProvider,
  validateCursorApiProvider,
  validateQoderProvider,
  validateKiroProvider,
  validateGitlabProvider,
  validateVertexProvider,
  validateVertexPartnerProvider,
  validateLongcatProvider,
  validateNvidiaProvider,
  validateZaiProvider,
  validateXiaomiMimoProvider,
  validateXiaomiMimoTokenPlanProvider,
  buildGitlawbValidators,
} from "./validation/specialtyInline";
// validateCommandCodeProvider + validateClaudeCodeCompatibleProvider have external importers
// (provider-nodes/validate route + tests) — re-export to preserve the historical public surface.
export { validateCommandCodeProvider, validateClaudeCodeCompatibleProvider };

// isRetryableProxyTarget + isSecurityBlockError now live in ./validation/transport. Re-export them
// here to preserve the historical public surface (tests + route handlers import them via this module).
export { isRetryableProxyTarget, isSecurityBlockError } from "./validation/transport";

// validateWebCookieProvider + bytezValidationResultFromStatus have external importers (tests +
// the web-cookie fallback suites) — re-export to preserve the historical public surface.
export { validateWebCookieProvider, bytezValidationResultFromStatus };

// validateWebCookieProvider, bytezValidationResultFromStatus, validateBytezProvider, and
// validateKiroApiKeyRuntimeProbe now live in ./validation/webCookie and ./validation/kiro.
// They are re-exported above to preserve the historical public surface.

export async function validateFreebuffProvider({ apiKey }: { apiKey: string }) {
  if (!apiKey) {
    return { valid: false, error: "Freebuff Auth Token required", unsupported: false };
  }
  try {
    const res = await fetch("https://www.codebuff.com/api/v1/freebuff/session", {
      method: "POST",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
        "User-Agent": "codebuff/0.1.0 (darwin-arm64)",
        "x-freebuff-model": "deepseek/deepseek-v4-flash",
      },
      body: JSON.stringify({}),
      signal: AbortSignal.timeout(15000),
    });

    if (res.ok || res.status === 409) {
      return { valid: true, error: null };
    }
    if (res.status === 401 || res.status === 403) {
      return { valid: false, error: "Invalid or expired Freebuff Auth Token", unsupported: false };
    }
    const errText = await res.text().catch(() => "");
    return {
      valid: false,
      error: `Freebuff validation returned ${res.status}: ${errText.slice(0, 100)}`,
      unsupported: false,
    };
  } catch (err: unknown) {
    const msg = err instanceof Error ? err.message : String(err);
    return { valid: false, error: `Freebuff validation network error: ${msg}`, unsupported: false };
  }
}

export async function validateProviderApiKey({
  provider,
  apiKey,
  providerSpecificData = {},
  // S-01 (#15159): forwarded to specialty validators that can reach a local spawn
  // (currently only the devin cloud-agent CLI fallback). Remote-reachable routes
  // pass `false` for non-loopback callers; direct/internal callers keep the
  // permissive default. See validateDevinCloudAgentProvider for the rationale.
  allowLocalSpawn = true,
}: any) {
  provider = typeof provider === "string" ? resolveProviderId(provider) : provider;
  const requiresApiKey = !providerAllowsOptionalApiKey(provider);
  const isLocal = isLocalProvider(provider);

  if (!provider || (requiresApiKey && !apiKey)) {
    return { valid: false, error: "Provider and API key required", unsupported: false };
  }

  if (isOpenAICompatibleProvider(provider)) {
    try {
      return await validateOpenAICompatibleProvider({ apiKey, providerSpecificData });
    } catch (error: any) {
      return toValidationErrorResult(error);
    }
  }

  if (isAnthropicCompatibleProvider(provider)) {
    try {
      if (isClaudeCodeCompatibleProvider(provider)) {
        return await validateClaudeCodeCompatibleProvider({ apiKey, providerSpecificData });
      }
      return await validateAnthropicCompatibleProvider({
        apiKey,
        providerSpecificData,
        isLocal,
      });
    } catch (error: any) {
      return toValidationErrorResult(error);
    }
  }

  // buildOpengatewayValidator + buildGitlawbValidators now live in ./validation/specialtyInline
  // (god-file decomposition). The host still owns the SPECIALTY_VALIDATORS map below; only the
  // validator bodies were extracted as leaf functions taking `isLocal` where the original
  // closure captured it.

  // ── Specialty provider validation ──
  const SPECIALTY_VALIDATORS = {
    "v0-vercel": ({ apiKey, providerSpecificData }: any) =>
      validateV0VercelProvider({ apiKey, providerSpecificData, isLocal }),
    jules: validateJulesProvider,
    // "devin" is the Cognition cloud-agent provider (distinct from the "devin-cli"
    // LLM/ACP provider, which is already registered in providerRegistry). Wired here
    // for parity with the "jules" cloud-agent entry above — see #6142.
    // S-01 (#15159): wrapped so the local CLI-spawn fallback receives allowLocalSpawn;
    // a bare reference would silently drop the flag and let a remote caller spawn.
    devin: ({ apiKey, allowLocalSpawn }: any) =>
      validateDevinCloudAgentProvider({ apiKey, allowLocalSpawn }),
    auggie: validateAuggieProvider,
    "cursor-api": validateCursorApiProvider,
    aihorde: validateAiHordeProvider,
    // #10522: registered under both the canonical id and the short alias — Firefly
    // connections are commonly stored as "firefly" (same prefix as firefly/<model>
    // routing ids), not the canonical "adobe-firefly" WEB_COOKIE_PROVIDERS key.
    "adobe-firefly": validateAdobeFireflyProvider,
    firefly: validateAdobeFireflyProvider,
    qoder: validateQoderProvider,
    kiro: validateKiroProvider,
    freebuff: validateFreebuffProvider,
    "command-code": validateCommandCodeProvider,
    huggingface: validateHuggingFaceProvider,
    // #11002: Dify serves no OpenAI-compatible route — only POST /v1/chat-messages.
    // The generic OpenAI-like probe 404s on /v1/models and /v1/chat/completions,
    // so every real app key was misreported as "endpoint not supported".
    dify: validateDifyProvider,
    // #5422: auth-only probe — Bytez 404s on every chat model until the account adds it to
    // its catalog, so the generic chat probe can't validate a fresh key.
    bytez: validateBytezProvider,
    // #13828: Zylo serves GET /v1/models WITHOUT authentication — 200 with no Authorization
    // header, and 200 for a bogus key. The generic OpenAI-like probe returns on the first 2xx
    // from that route, so the setup dialog greened any string and the user only discovered the
    // key was rejected when their own model test came back `401 {"error":"Key not found: zk-…"}`.
    // Probe the chat route, which is the one Zylo actually authenticates.
    "zylo-api": validateZyloApiProvider,
    // Registered under the alias too: connections are commonly stored as "zylo" (same prefix as
    // the zylo/<model> routing ids), and the alias must not fall back to the open-catalog probe.
    // Same shape as the adobe-firefly/firefly pair above.
    zylo: validateZyloApiProvider,
    // Inception Labs serves GET /v1/models without authentication (200 for any key), so the
    // generic OpenAI-like probe greened bogus keys. Probe the authenticated chat route instead.
    inception: validateInceptionProvider,
    deepgram: validateDeepgramProvider,
    assemblyai: validateAssemblyAIProvider,
    "rev-ai": validateRevAiProvider,
    soniox: validateSonioxProvider,
    "fal-ai": ({ apiKey, providerSpecificData }: any) =>
      validateImageProviderApiKey({ provider: "fal-ai", apiKey, providerSpecificData }),
    "stability-ai": ({ apiKey, providerSpecificData }: any) =>
      validateImageProviderApiKey({ provider: "stability-ai", apiKey, providerSpecificData }),
    "black-forest-labs": ({ apiKey, providerSpecificData }: any) =>
      validateImageProviderApiKey({ provider: "black-forest-labs", apiKey, providerSpecificData }),
    recraft: ({ apiKey, providerSpecificData }: any) =>
      validateImageProviderApiKey({ provider: "recraft", apiKey, providerSpecificData }),
    topaz: ({ apiKey, providerSpecificData }: any) =>
      validateImageProviderApiKey({ provider: "topaz", apiKey, providerSpecificData }),
    magnific: ({ apiKey, providerSpecificData }: any) =>
      validateImageProviderApiKey({ provider: "magnific", apiKey, providerSpecificData }),
    elevenlabs: validateElevenLabsProvider,
    inworld: validateInworldProvider,
    kie: validateKieProvider,
    "aws-polly": validateAwsPollyProvider,
    "bailian-coding-plan": validateBailianCodingPlanProvider,
    "qwen-cloud-token-plan": validateQwenCloudTokenPlanProvider,
    heroku: validateHerokuProvider,
    databricks: validateDatabricksProvider,
    datarobot: validateDataRobotProvider,
    watsonx: validateWatsonxProvider,
    oci: validateOciProvider,
    sap: validateSapProvider,
    bedrock: validateBedrockProvider,
    modal: ({ apiKey, providerSpecificData }: any) => {
      // Modal is bring-your-own-deploy — it requires a Base URL pointing to the user's
      // OpenAI-compatible Modal app. Without it, validateOpenAILikeProvider would build an
      // empty probe URL and trip parseOutboundUrl with a raw guard error ("Invalid outbound
      // URL: "). Surface an actionable message instead. See #9102.
      const baseUrl = (providerSpecificData?.baseUrl || "").trim();
      if (!baseUrl) {
        return {
          valid: false,
          error:
            "Modal requires a Base URL pointing to your OpenAI-compatible Modal app " +
            "(e.g. https://<workspace>--<app>.modal.run/v1). " +
            'Fill in the "Base URL override" field.',
        };
      }
      return validateOpenAILikeProvider({
        provider: "modal",
        apiKey,
        providerSpecificData,
        baseUrl: normalizeBaseUrl(baseUrl),
        modelId: MODAL_DEFAULT_VALIDATION_MODEL_ID,
        isLocal,
      });
    },
    "nous-research": validateNousResearchProvider,
    poe: validatePoeProvider,
    clarifai: validateClarifaiProvider,
    reka: validateRekaProvider,
    maritalk: validateMaritalkProvider,
    nlpcloud: validateNlpCloudProvider,
    oneminai: validateOneMinAiProvider,
    runwayml: validateRunwayProvider,
    typesafe: ({ apiKey }: any) => validateTypesafeProvider({ apiKey }),
    snowflake: validateSnowflakeProvider,
    gigachat: validateGigachatProvider,
    "deepseek-web": validateDeepSeekWebProvider,
    "zai-web": validateZaiWebProvider,
    "grok-web": validateGrokWebProvider,
    "kimi-web": validateKimiWebProvider,
    "chatgpt-web-codex": (input: {
      apiKey?: string;
      providerSpecificData?: Record<string, unknown>;
    }) =>
      import("./validation/chatgptWebCodex").then((mod) =>
        mod.validateChatGptWebCodexProvider(input)
      ),
    "perplexity-web": validatePerplexityWebProvider,
    "blackbox-web": validateBlackboxWebProvider,
    "muse-spark-web": validateMuseSparkWebProvider,
    "inner-ai": validateInnerAiProvider,
    "adapta-web": validateAdaptaWebProvider,
    "tinycms-web": validateTinyCmsWebProvider,
    "claude-web": validateClaudeWebProvider,
    "gemini-web": validateGeminiWebProvider,
    "notion-web": validateNotionWebProvider,
    "copilot-m365-web": validateCopilotM365WebProvider,
    "copilot-web": validateCopilotWebProvider,
    "t3-web": validateT3WebProvider,
    syntx: validateSyntxProvider,
    stx: validateSyntxProvider,
    "azure-openai": validateAzureOpenAIProvider,
    "azure-ai": validateAzureAiProvider,
    "voyage-ai": ({ apiKey, providerSpecificData }: any) => {
      const embeddingProvider = getEmbeddingProvider("voyage-ai");
      return validateEmbeddingApiProvider({
        apiKey,
        providerSpecificData,
        url: embeddingProvider?.baseUrl,
        modelId: embeddingProvider?.models?.[0]?.id || "voyage-4-lite",
      });
    },
    "jina-ai": ({ apiKey, providerSpecificData }: any) =>
      validateJinaFoundationProvider({ apiKey, providerSpecificData }),
    gitlab: ({ apiKey, providerSpecificData }: any) =>
      validateGitlabProvider({ apiKey, providerSpecificData, isLocal }),
    vertex: validateVertexProvider,
    "vertex-partner": validateVertexPartnerProvider,
    longcat: ({ apiKey, providerSpecificData }: any) =>
      validateLongcatProvider({ apiKey, providerSpecificData, isLocal }),
    nvidia: validateNvidiaProvider,
    zai: validateZaiProvider,
    "xiaomi-mimo": ({ apiKey, providerSpecificData }: any) =>
      validateXiaomiMimoProvider({ apiKey, providerSpecificData, isLocal }),
    "xiaomi-mimo-token-plan": ({ apiKey, providerSpecificData }: any) =>
      validateXiaomiMimoTokenPlanProvider({ apiKey, providerSpecificData, isLocal }),
    // Gitlawb Opengateway — Xiaomi MiMo compatible, same /models endpoint limitation.
    // Bypass /models probe in favor of chat/completions, matching xiaomi-mimo's pattern.
    // Uses a factory to share validation logic across Opengateway provider variants.
    ...buildGitlawbValidators(
      [
        ["gitlawb", "https://opengateway.gitlawb.com/v1/xiaomi-mimo", "mimo-v2.5-pro"],
        ["gitlawb-gmi", "https://opengateway.gitlawb.com/v1/gmi-cloud", "XiaomiMiMo/MiMo-V2.5-Pro"],
      ],
      isLocal
    ),
    // Search providers — use factored validator
    ...Object.fromEntries(
      Object.entries(SEARCH_VALIDATOR_CONFIGS).map(([id, configFn]) => [
        id,
        ({ apiKey, providerSpecificData }: any) => {
          const { url, init } = configFn(apiKey, providerSpecificData);
          return validateSearchProvider(url, init, providerSpecificData, isLocal, id);
        },
      ])
    ),
  };

  if (SPECIALTY_VALIDATORS[provider]) {
    try {
      return await SPECIALTY_VALIDATORS[provider]({
        apiKey,
        providerSpecificData,
        allowLocalSpawn,
      });
    } catch (error: any) {
      return toValidationErrorResult(error);
    }
  }

  // Web-cookie providers WITHOUT a dedicated specialty validator above fall back to the generic
  // session-ping check (AUTH_007 SESSION_EXPIRED on 401/403). Providers that DO have a rich
  // per-provider validator (grok-web, perplexity-web, claude-web, etc.) are handled by
  // SPECIALTY_VALIDATORS first and must not be shadowed by this generic probe (issue: the
  // #4023 dispatch was placed too early and intercepted every web-cookie provider).
  const canonicalProvider = resolveProviderId(provider);
  if (WEB_COOKIE_PROVIDERS[canonicalProvider]) {
    try {
      return await validateWebCookieProvider({
        provider: canonicalProvider,
        apiKey,
        providerSpecificData,
      });
    } catch (error: any) {
      return toValidationErrorResult(error);
    }
  }

  const entry = getRegistryEntry(provider);
  if (!entry) {
    if (isSelfHostedChatProvider(provider)) {
      return await validateOpenAILikeProvider({
        provider,
        apiKey,
        baseUrl: resolveBaseUrl(null, providerSpecificData),
        providerSpecificData,
        modelId: "local-model",
        modelsUrl: addModelsSuffix(providerSpecificData?.baseUrl || ""),
        isLocal,
      });
    }
    return { valid: false, error: "Provider validation not supported", unsupported: true };
  }

  const modelId = entry.models?.[0]?.id || null;
  // (#532) Use testKeyBaseUrl if defined — some providers validate keys on a different endpoint
  // than where requests are sent (e.g. opencode-go validates on zen/v1, not zen/go/v1)
  const validationEntry = entry.testKeyBaseUrl
    ? { ...entry, baseUrl: entry.testKeyBaseUrl }
    : entry;
  const usesAlibabaRegionalEndpoint = isAlibabaRegionalProvider(provider);
  const baseUrl = usesAlibabaRegionalEndpoint
    ? resolveAlibabaProviderBaseUrl(provider, providerSpecificData, validationEntry.baseUrl)
    : resolveBaseUrl(validationEntry, providerSpecificData);

  try {
    if (OPENAI_LIKE_FORMATS.has(entry.format)) {
      return await validateOpenAILikeProvider({
        apiKey,
        baseUrl,
        headers: entry.headers || {},
        providerSpecificData,
        modelId,
        modelsUrl: usesAlibabaRegionalEndpoint ? "" : entry.testKeyModelsUrl || entry.modelsUrl,
        isLocal,
      });
    }

    if (entry.format === "claude") {
      // Built-in CC-wire-image providers (e.g. agentrouter, #6056/#6255) gate
      // their WAF on the dynamic Claude-Code fingerprint (User-Agent,
      // `?beta=true` chat path, anthropic-beta/x-app/X-Stainless-* headers).
      // The real chat-request path already routes through
      // buildProviderUrl/buildProviderHeaders for this; the validation probe
      // must use the SAME wire image or a genuinely valid key gets 403'd as
      // "unauthorized client detected" (#6377).
      if (usesCcWireImage(provider)) {
        const requestBaseUrl = buildProviderUrl(provider, modelId, true, { baseUrl });
        const requestHeaders = buildProviderHeaders(provider, { apiKey }, true);

        return await validateAnthropicLikeProvider({
          apiKey,
          baseUrl: requestBaseUrl,
          modelId,
          headers: requestHeaders,
          providerSpecificData,
          isLocal,
        });
      }

      const requestBaseUrl = `${baseUrl}${entry.urlSuffix || ""}`;
      const requestHeaders = {
        ...(entry.headers || {}),
      };

      if ((entry.authHeader || "").toLowerCase() === "x-api-key") {
        requestHeaders["x-api-key"] = apiKey;
      } else {
        requestHeaders["Authorization"] = `Bearer ${apiKey}`;
      }

      return await validateAnthropicLikeProvider({
        apiKey,
        baseUrl: requestBaseUrl,
        modelId,
        headers: requestHeaders,
        providerSpecificData,
        isLocal,
      });
    }

    if (GEMINI_LIKE_FORMATS.has(entry.format)) {
      return await validateGeminiLikeProvider({
        apiKey,
        baseUrl,
        providerSpecificData,
        authType: entry.authType,
        isLocal,
      });
    }

    if (entry.format === "antigravity") {
      const expiresAt =
        providerSpecificData?.tokenExpiresAt ||
        providerSpecificData?.expiresAt ||
        providerSpecificData?.expiry_date ||
        providerSpecificData?.expiryDate;
      const expiryMs =
        typeof expiresAt === "number"
          ? expiresAt
          : typeof expiresAt === "string" && expiresAt.trim()
            ? Date.parse(expiresAt)
            : Number.NaN;

      if (Number.isFinite(expiryMs) && expiryMs > 0 && expiryMs < Date.now()) {
        return {
          valid: false,
          error: "Antigravity OAuth token has expired. Re-import or refresh the CLI login.",
          unsupported: false,
        };
      }

      return { valid: true, error: null, unsupported: false };
    }

    return { valid: false, error: "Provider validation not supported", unsupported: true };
  } catch (error: any) {
    return toValidationErrorResult(error);
  }
}