What LLM Providers Are Supported by OmniRoute? Complete Registry Guide

OmniRoute supports over 20 LLM providers including OpenAI, Anthropic, Google Gemini, Azure OpenAI, and local inference engines like Ollama and LLaMA.cpp, all centralized in the REGISTRY map within open-sse/config/providerRegistry.ts.

OmniRoute is an open-source intelligent routing layer designed to unify access to diverse large language model APIs and local inference backends. Understanding what LLM providers are supported by OmniRoute enables developers to configure resilient multi-provider architectures with automatic failover. At release v3.8.51, the platform maintains a comprehensive Provider Registry that defines supported upstream services, authentication methods, and routing capabilities.

Provider Registry Architecture

The canonical source of truth for supported providers resides in open-sse/config/providerRegistry.ts. This file exports a constant REGISTRY map where each key represents a unique provider identifier string (e.g., "openai", "anthropic", "ollama").

Every entry in the registry includes metadata that drives routing decisions, authentication handling, and model discovery. You can retrieve the complete list of supported providers at runtime using the getRegisteredProviders() helper function, which returns an array of all registered provider identifiers.

Complete List of Supported LLM Providers

As of release v3.8.51, OmniRoute officially supports the following provider categories:

Cloud API Providers (API-Key Authentication)

These providers require standard API key headers for authentication:

• openai – OpenAI GPT-4, ChatGPT, and embedding models
• anthropic – Claude family (Claude-3, Claude-2, Claude Instant)
• cohere – Command-R, Command-R-plus, and embedding models
• mistral – Mistral-7B, Mixtral, and OpenMixtral variants
• groq – Groq-hosted Llama-3.1 and Mixtral implementations
• xai – xAI Titan model series
• together – Together.ai hosted models (Llama-2, MPT, and others)
• deepseek – DeepSeek-Chat and DeepSeek-Coder
• openrouter – OpenRouter aggregation service covering many third-party models
• ai21 – Jurassic-2 series models
• alephalpha – Aleph Alpha Luminous models
• fireworks – Fireworks AI hosted models
• perplexity – Perplexity AI chat models

Cloud Providers (OAuth Authentication)

These providers use OAuth flows or service-specific authentication schemes:

• google – Gemini models (Gemini-1.5-Flash, Gemini-1.5-Pro)
• azure – Azure OpenAI Service deployment-specific models
• huggingface – Hugging Face Inference API for any Hub model

AWS Bedrock Integration

OmniRoute supports model access through Amazon Bedrock using OAuth-based credentials:

• anthropic/bedrock – Anthropic models via AWS Bedrock
• google/bedrock – Google models via AWS Bedrock
• azure/bedrock – Azure-hosted Bedrock providers

Local and Self-Hosted Inference

For on-premises or development environments:

• ollama – Ollama server integration for any locally available model
• llama.cpp – LLaMA.cpp static binary integration

Querying Providers at Runtime

Retrieve all supported providers programmatically to build dynamic UIs or validation logic:

import { getRegisteredProviders } from "@omniroute/open-sse/config/providerRegistry";

const providers = getRegisteredProviders();
console.log("Supported providers:", providers);
// Output: ['openai', 'anthropic', 'google', 'ollama', ...]

Checking Provider Authentication Types

Determine whether a provider uses OAuth or API-key authentication using getProviderCategory():

import { getProviderCategory } from "@omniroute/open-sse/config/providerRegistry";

function isOAuth(provider: string): boolean {
  return getProviderCategory(provider) === "oauth";
}

console.log(isOAuth("google"));   // true
console.log(isOAuth("openai"));   // false
console.log(isOAuth("ollama"));   // false

Provider Validation in API Routes

When handling requests, validate providers against the registry before routing:

// src/app/api/v1/providers/[provider]/chat/completions/route.ts
import { getRegistryEntry } from "@omniroute/open-sse/config/providerRegistry";

export async function POST(
  req: Request, 
  { params }: { params: { provider: string } }
) {
  const { provider } = params;
  const entry = getRegistryEntry(provider);
  
  if (!entry) throw new Error(`Unknown provider: ${provider}`);
  
  // Use entry.metadata to build HTTP requests, auth headers, etc.
}

Integration Architecture and Key Files

OmniRoute's provider support extends across several critical system components:

• open-sse/config/providerRegistry.ts – Defines REGISTRY and lookup utilities (getRegisteredProviders, getProviderCategory, getRegistryEntry)

• src/lib/providers/validation/*.ts – Provider-specific validation logic that checks model constraints against registry metadata (e.g., openaiFormat.ts)

• src/app/api/v1/providers/[provider]/chat/completions/route.ts – Dynamic API route that dispatches requests by consulting the registry at runtime

• src/lib/proxyHealth/providerProbeTarget.ts – Health monitoring system that uses getRegisteredProviders() to build probing targets for resilience checking

• src/lib/usage/comboScoringInspector.ts – Combo-routing logic that filters providers based on registry metadata for quota management and scoring

Adding a new LLM provider requires only extending the REGISTRY map in the configuration file—surrounding systems automatically recognize and validate the new entry.

Summary

• OmniRoute maintains a centralized Provider Registry in open-sse/config/providerRegistry.ts that defines all supported LLM providers as of v3.8.51.
• The platform supports 20+ providers ranging from cloud APIs (OpenAI, Anthropic, Google) to local inference (Ollama, LLaMA.cpp) and AWS Bedrock integrations.
• Providers are categorized by authentication type: API-key, OAuth, or Local access.
• Use getRegisteredProviders() to retrieve the full list at runtime for dynamic routing interfaces.
• The registry architecture enables automatic validation, health checking, and failover across all supported providers without code changes to core routing logic.

Frequently Asked Questions

How do I add a custom LLM provider to OmniRoute?

Create a new entry in the REGISTRY map within open-sse/config/providerRegistry.ts. Define the provider ID, authentication category (api-key, oauth, or local), and any provider-specific metadata. Once added, getRegisteredProviders() automatically includes the new provider, and validation utilities in src/lib/providers/validation/ will recognize it for request processing.

What authentication methods does OmniRoute support for LLM providers?

OmniRoute supports three authentication categories as defined in the registry: API-key authentication for most cloud providers (sent via headers), OAuth flows for services like Google Gemini and Azure OpenAI, and Local connections for self-hosted Ollama or LLaMA.cpp instances requiring no remote authentication. Check specific provider requirements using getProviderCategory(providerId).

Does OmniRoute support local LLM inference without cloud dependencies?

Yes. OmniRoute natively supports ollama for Ollama server integration and llama.cpp for direct binary execution. These providers are categorized as "Local" in the registry and do not require API keys, enabling fully offline or on-premises LLM deployments alongside cloud providers.

How does OmniRoute handle routing to unsupported providers?

Requests to providers not present in the REGISTRY map return validation errors before reaching external APIs. The getRegistryEntry() function returns undefined for unknown providers, allowing middleware in routes like src/app/api/v1/providers/[provider]/chat/completions/route.ts to throw descriptive errors and prevent misconfigured requests from consuming resources.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}