# Which AI Model Providers Are Supported by WorkWeave Router? A Complete Technical Guide

> WorkWeave Router supports 12 AI model providers like OpenAI, Gemini, and Bedrock via a unified architecture. Discover all compatible providers and integrate seamlessly.

- Repository: [Weave/router](https://github.com/workweave/router)
- Tags: how-to-guide
- Published: 2026-08-30

---

**WorkWeave Router supports 12 distinct AI model providers—including OpenAI, Anthropic, Google Gemini, Azure OpenAI, Amazon Bedrock, Fireworks AI, OpenRouter, Together.ai, XAI, and generic OpenAI-compatible endpoints—through a unified adapter architecture defined in [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go).**

The WorkWeave Router acts as a unified entry point for external AI model APIs, treating each provider as a plugin that implements a common interface. This design allows the router to forward requests, translate wire formats, and apply cross-provider features like usage tracking and caching across heterogeneous model backends.

## Complete List of Supported AI Model Providers

The router enumerates supported providers through string constants defined in [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go). Each constant represents a unique adapter implementation residing in its own package under `internal/providers/`.

| Provider | Constant Name | Native API Endpoint | Source File |
|----------|--------------|---------------------|---------------|
| **OpenAI** | `ProviderOpenAI` | `v1/chat/completions` | [`internal/providers/openai/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openai/client.go) |
| **Anthropic** | `ProviderAnthropic` | `v1/messages` (Claude-style) | [`internal/providers/anthropic/client.go`](https://github.com/workweave/router/blob/main/internal/providers/anthropic/client.go) |
| **Google (Gemini)** | `ProviderGoogle` | `v1beta/models/:modelAction` | [`internal/providers/google/native_client.go`](https://github.com/workweave/router/blob/main/internal/providers/google/native_client.go) |
| **Azure OpenAI** | `ProviderAzure` | Azure-hosted OpenAI-compatible endpoints | [`internal/providers/azure.go`](https://github.com/workweave/router/blob/main/internal/providers/azure.go) |
| **Amazon Bedrock** | `ProviderBedrock` | Bedrock model-invoke API | [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go) (constant definition) |
| **Fireworks AI** | `ProviderFireworks` | Fireworks OpenAI-compatible API | [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go) |
| **OpenRouter** | `ProviderOpenRouter` | OpenRouter OpenAI-compatible API | [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go) |
| **Together.ai** | `ProviderTogether` | Together OpenAI-compatible endpoints | [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go) |
| **XAI** | `ProviderXAI` | XAI OpenAI-compatible API | [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go) |
| **OpenAI-Compatible (Generic)** | `ProviderOpenAICompat` | Generic OpenAI-style API | [`internal/providers/openaicompat/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openaicompat/client.go) |
| **CortexAgents** | `ProviderCortexAgents` | Cortex-based inference service | [`internal/providers/cortexagents/client.go`](https://github.com/workweave/router/blob/main/internal/providers/cortexagents/client.go) |
| **Cortex** | `ProviderCortex` | Direct Cortex service | [`internal/providers/cortex.go`](https://github.com/workweave/router/blob/main/internal/providers/cortex.go) |

The `ProviderBedrock`, `ProviderFireworks`, `ProviderOpenRouter`, `ProviderTogether`, and `ProviderXAI` constants are defined alongside `ProviderOpenAI` and `ProviderAnthropic` in [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go), typically around lines 40-86, indicating they are first-class provider identities within the routing system.

## Provider Architecture and Implementation Details

### The Provider Interface and Constant Registry

The router implements an **adapter pattern** where each provider lives in `internal/providers/<name>/` and implements the same `Provider` interface. This keeps the inner-ring packages I/O-free and allows the routing core to treat disparate AI APIs uniformly.

In [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go), the system defines typed string constants for provider identification:

```go
// From internal/providers/provider.go (illustrative structure based on constants at lines 40, 52, 86)
const (
    ProviderOpenAI       = "openai"
    ProviderAnthropic    = "anthropic"
    ProviderGoogle       = "google"
    ProviderBedrock      = "bedrock"
    ProviderFireworks    = "fireworks"
    ProviderOpenRouter   = "openrouter"
    ProviderTogether     = "together"
    ProviderXAI          = "xai"
    ProviderAzure        = "azure"
    ProviderCortex       = "cortex"
    ProviderCortexAgents = "cortexagents"
    ProviderOpenAICompat = "openai_compat"
)

```

These constants are registered in the provider registry during initialization in [`cmd/router/main.go`](https://github.com/workweave/router/blob/main/cmd/router/main.go), where the composition root wires all adapters into the router service.

### Provider-Specific Client Implementations

Each supported provider maintains dedicated client logic for authentication, request formatting, and response parsing. The **OpenAI** adapter in [`internal/providers/openai/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openai/client.go) handles native OpenAI API semantics, while the **Anthropic** adapter in [`internal/providers/anthropic/client.go`](https://github.com/workweave/router/blob/main/internal/providers/anthropic/client.go) manages Claude-specific message formats.

For providers offering OpenAI-compatible endpoints—such as **Bedrock**, **Fireworks**, **OpenRouter**, **Together.ai**, and **XAI**—the router utilizes the generic adapter in [`internal/providers/openaicompat/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openaicompat/client.go). This adapter normalizes the wire protocol while preserving provider-specific metadata like pricing and model capabilities in the catalog.

The **Google (Gemini)** provider uses [`internal/providers/google/native_client.go`](https://github.com/workweave/router/blob/main/internal/providers/google/native_client.go) to interface with Google's native `v1beta/models` API, handling distinct authentication flows and content structures separate from the OpenAI format.

### Translation and Normalization Layer

The [`internal/translate/translate.go`](https://github.com/workweave/router/blob/main/internal/translate/translate.go) package normalizes requests and responses to a common internal representation, then rewrites them for the target provider. When a request arrives for an Anthropic model, the translator converts the OpenAI-style chat completion format to Claude's native message structure, and vice versa for the response.

This layer enables **dynamic provider selection** based on the requested model name, request headers, or cluster-level overrides. The router injects the `x-router-provider` header into responses for observability, allowing clients to verify which backend served their request.

## Configuring and Extending Providers

### Registering Providers in the Router

The following example demonstrates how the composition root registers multiple providers using the constants defined in [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go):

```go
// Example: Registering providers in cmd/router/main.go or similar composition root
package main

import (
    "github.com/workweave/router/internal/providers"
    "github.com/workweave/router/internal/providers/openai"
    "github.com/workweave/router/internal/providers/anthropic"
    "github.com/workweave/router/internal/router"
)

func initializeRouter(builder router.Builder) error {
    // Register OpenAI with its native client
    if err := builder.RegisterProvider(
        providers.ProviderOpenAI,
        openai.NewClient(),
    ); err != nil {
        return err
    }

    // Register Anthropic adapter
    if err := builder.RegisterProvider(
        providers.ProviderAnthropic,
        anthropic.NewClient(),
    ); err != nil {
        return err
    }

    // Register Google Gemini
    if err := builder.RegisterProvider(
        providers.ProviderGoogle,
        providers.NewGoogleClient(),
    ); err != nil {
        return err
    }

    // Generic OpenAI-compatible providers (Bedrock, Fireworks, etc.)
    if err := builder.RegisterProvider(
        providers.ProviderBedrock,
        providers.NewOpenAICompatClient("bedrock"),
    ); err != nil {
        return err
    }

    return nil
}

```

### Mapping Models to Providers via Catalog

The router's catalog system in [`internal/router/catalog/catalog.go`](https://github.com/workweave/router/blob/main/internal/router/catalog/catalog.go) maps specific model names to their respective providers, handling metadata like pricing tiers and token limits:

```go
// Example: Adding model entries to the catalog
package main

import (
    "github.com/workweave/router/internal/providers"
    "github.com/workweave/router/internal/router/catalog"
)

func configureCatalog() {
    // OpenAI GPT-4o entry
    catalog.RegisterModel(catalog.ModelEntry{
        ModelName: "gpt-4o",
        Provider:  providers.ProviderOpenAI,
        Tier:      catalog.TierStandard,
        Pricing: catalog.Pricing{
            Prompt:     0.005,
            Completion: 0.015,
        },
        MaxTokens: 128000,
    })

    // Anthropic Claude entry
    catalog.RegisterModel(catalog.ModelEntry{
        ModelName: "claude-3-5-sonnet-20241022",
        Provider:  providers.ProviderAnthropic,
        Tier:      catalog.TierStandard,
        MaxTokens: 200000,
    })

    // Bedrock-hosted model using Bedrock provider constant
    catalog.RegisterModel(catalog.ModelEntry{
        ModelName: "anthropic.claude-3-sonnet-20240229-v1:0",
        Provider:  providers.ProviderBedrock,
        Tier:      catalog.TierStandard,
    })
}

```

### Client-Side Provider Selection

Clients can invoke the router's unified endpoint while optionally specifying a provider override via headers:

```go
// Example: Calling the router with optional provider override
package main

import (
    "bytes"
    "net/http"
    "strings"
)

func callRouterWithOverride() (*http.Response, error) {
    payload := []byte(`{
        "model": "claude-3-5-sonnet-20241022",
        "messages": [{"role": "user", "content": "Explain the adapter pattern"}],
        "max_tokens": 1024
    }`)

    req, _ := http.NewRequest(
        "POST",
        "https://router.workweave.com/v1/chat/completions",
        bytes.NewReader(payload),
    )
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer "+getAPIToken())

    // Optional: Force specific provider (e.g., for testing or cost optimization)
    // req.Header.Set("x-router-provider", "anthropic")

    return http.DefaultClient.Do(req)
}

```

## Summary

- **WorkWeave Router supports 12+ AI model providers** through typed constants in [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go), including major APIs like OpenAI, Anthropic, Google Gemini, and Azure OpenAI.
- **Provider constants** such as `ProviderOpenAI`, `ProviderAnthropic`, `ProviderBedrock`, and `ProviderFireworks` serve as identifiers for the adapter registry and catalog mappings.
- **Adapter pattern implementation** isolates provider-specific logic in `internal/providers/<provider>/` packages, with specialized handlers for native APIs (OpenAI, Anthropic, Google) and generic OpenAI-compatible adapters (Bedrock, Fireworks, OpenRouter, Together.ai, XAI).
- **Translation layer** in [`internal/translate/translate.go`](https://github.com/workweave/router/blob/main/internal/translate/translate.go) normalizes wire formats between the router's OpenAI-compatible frontend and backend provider protocols.
- **Catalog system** in [`internal/router/catalog/catalog.go`](https://github.com/workweave/router/blob/main/internal/router/catalog/catalog.go) binds model names to providers, enabling dynamic routing based on model identifiers, headers, or configuration overrides.

## Frequently Asked Questions

### How do I add a new AI provider to WorkWeave Router?

Adding a new provider requires three steps: define a new constant in [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go) (e.g., `ProviderCustom = "custom"`), implement the `Provider` interface in a new package (e.g., [`internal/providers/custom/client.go`](https://github.com/workweave/router/blob/main/internal/providers/custom/client.go)), and register the adapter in [`cmd/router/main.go`](https://github.com/workweave/router/blob/main/cmd/router/main.go) using `builder.RegisterProvider()`. If the new provider offers an OpenAI-compatible API, you can reuse [`internal/providers/openaicompat/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openaicompat/client.go) with a custom base URL and authentication configuration.

### What is the difference between OpenAI-compatible and native provider adapters?

**Native adapters** (OpenAI, Anthropic, Google) in [`internal/providers/openai/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openai/client.go), [`internal/providers/anthropic/client.go`](https://github.com/workweave/router/blob/main/internal/providers/anthropic/client.go), and [`internal/providers/google/native_client.go`](https://github.com/workweave/router/blob/main/internal/providers/google/native_client.go) handle provider-specific authentication, request structures, and response parsing. **OpenAI-compatible adapters** used by Bedrock, Fireworks, OpenRouter, Together.ai, and XAI leverage [`internal/providers/openaicompat/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openaicompat/client.go) to translate standard OpenAI requests to the provider's OpenAI-compatible endpoint, reducing code duplication while maintaining distinct provider constants for routing and billing purposes.

### How does the router handle provider selection for incoming requests?

The router selects providers through a hierarchy of resolution: first checking explicit `x-router-provider` headers, then matching the requested `model` name against entries in [`internal/router/catalog/catalog.go`](https://github.com/workweave/router/blob/main/internal/router/catalog/catalog.go), and finally applying cluster-level defaults or load-balancing rules. The selected provider constant (e.g., `ProviderAnthropic`) determines which adapter implementation processes the request through [`internal/translate/translate.go`](https://github.com/workweave/router/blob/main/internal/translate/translate.go).

### Which provider constant should I use for Amazon Bedrock models?

Use the `ProviderBedrock` constant defined in [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go). Although Bedrock offers OpenAI-compatible invocation semantics, the router treats it as a distinct provider identity to enable Bedrock-specific configuration (AWS credential chains, region specification) and accurate cost attribution. The actual HTTP client implementation typically resides in or delegates to [`internal/providers/openaicompat/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openaicompat/client.go) for protocol translation.