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

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.

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. 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
Anthropic	ProviderAnthropic	v1/messages (Claude-style)	internal/providers/anthropic/client.go
Google (Gemini)	ProviderGoogle	v1beta/models/:modelAction	internal/providers/google/native_client.go
Azure OpenAI	ProviderAzure	Azure-hosted OpenAI-compatible endpoints	internal/providers/azure.go
Amazon Bedrock	ProviderBedrock	Bedrock model-invoke API	internal/providers/provider.go (constant definition)
Fireworks AI	ProviderFireworks	Fireworks OpenAI-compatible API	internal/providers/provider.go
OpenRouter	ProviderOpenRouter	OpenRouter OpenAI-compatible API	internal/providers/provider.go
Together.ai	ProviderTogether	Together OpenAI-compatible endpoints	internal/providers/provider.go
XAI	ProviderXAI	XAI OpenAI-compatible API	internal/providers/provider.go
OpenAI-Compatible (Generic)	ProviderOpenAICompat	Generic OpenAI-style API	internal/providers/openaicompat/client.go
CortexAgents	ProviderCortexAgents	Cortex-based inference service	internal/providers/cortexagents/client.go
Cortex	ProviderCortex	Direct Cortex service	internal/providers/cortex.go

The ProviderBedrock, ProviderFireworks, ProviderOpenRouter, ProviderTogether, and ProviderXAI constants are defined alongside ProviderOpenAI and ProviderAnthropic in 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, the system defines typed string constants for provider identification:

// 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, 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 handles native OpenAI API semantics, while the Anthropic adapter in 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. 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 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 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:

// 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 maps specific model names to their respective providers, handling metadata like pricing tiers and token limits:

// 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:

// 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, 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 normalizes wire formats between the router's OpenAI-compatible frontend and backend provider protocols.
• Catalog system in 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 (e.g., ProviderCustom = "custom"), implement the Provider interface in a new package (e.g., internal/providers/custom/client.go), and register the adapter in cmd/router/main.go using builder.RegisterProvider(). If the new provider offers an OpenAI-compatible API, you can reuse 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, internal/providers/anthropic/client.go, and 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 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, 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.

Which provider constant should I use for Amazon Bedrock models?

Use the ProviderBedrock constant defined in 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 for protocol translation.

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