# WorkWeave Router AI Model APIs: Complete Provider Support Guide

> Explore WorkWeave Router AI model APIs. Integrate seamlessly with OpenAI, Gemini, Azure, Bedrock and more using our unified adapter architecture. Simplify your AI integrations today.

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

---

**The WorkWeave Router supports 12+ AI model APIs—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 providers, treating each API as a plugin that implements a common interface. This architecture enables the router to forward requests, translate wire formats, and apply cross-provider features like usage tracking and caching regardless of the underlying AI model API.

## Supported AI Model APIs

The router defines provider constants in [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go) (lines 40-86), where each constant represents a distinct AI model API integration. These providers are categorized by their implementation strategy and target infrastructure.

### Major Cloud Providers

**OpenAI** (`ProviderOpenAI`) implements the native OpenAI REST API using `v1/chat/completions` endpoints. The adapter resides in [`internal/providers/openai/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openai/client.go) and handles standard GPT model families including `gpt-4o` and `gpt-4o-mini`.

**Anthropic** (`ProviderAnthropic`) connects to Claude models via the `v1/messages` API. The dedicated adapter in [`internal/providers/anthropic/client.go`](https://github.com/workweave/router/blob/main/internal/providers/anthropic/client.go) manages Anthropic's unique message format and streaming protocols.

**Google (Gemini)** (`ProviderGoogle`) interfaces with Google's Gemini models through the native `v1beta/models/:modelAction` endpoint. The implementation in [`internal/providers/google/native_client.go`](https://github.com/workweave/router/blob/main/internal/providers/google/native_client.go) handles Google's distinct request/response schema separate from OpenAI compatibility layers.

**Azure OpenAI** (`ProviderAzure`) supports Azure-hosted OpenAI deployments via [`internal/providers/azure.go`](https://github.com/workweave/router/blob/main/internal/providers/azure.go), allowing enterprise users to route through private Azure endpoints while maintaining OpenAI API compatibility.

### Specialized Inference Platforms

**Amazon Bedrock** (`ProviderBedrock`), **Fireworks AI** (`ProviderFireworks`), **OpenRouter** (`ProviderOpenRouter`), **Together.ai** (`ProviderTogether`), and **XAI** (`ProviderXAI`) all leverage the generic OpenAI-compatible adapter found in [`internal/providers/openaicompat/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openaicompat/client.go). These providers expose OpenAI-style endpoints but route to specialized inference infrastructure. The router distinguishes these via unique provider constants while reusing the compatibility translation layer.

**Cortex** and **CortexAgents** implement dedicated adapters in [`internal/providers/cortex.go`](https://github.com/workweave/router/blob/main/internal/providers/cortex.go) and [`internal/providers/cortexagents/client.go`](https://github.com/workweave/router/blob/main/internal/providers/cortexagents/client.go) for Cortex-based inference services, supporting both direct Cortex API access and agent-specific endpoints.

## How the Router Manages Provider Integration

### The Adapter Pattern in internal/providers/

Each AI model API lives in its own package under `internal/providers/<name>/` and implements the shared `Provider` interface. This design keeps the routing core I/O-free and provider-agnostic. For example, [`internal/providers/openai/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openai/client.go) and [`internal/providers/anthropic/client.go`](https://github.com/workweave/router/blob/main/internal/providers/anthropic/client.go) both satisfy the same interface but handle provider-specific authentication, path construction, and error parsing.

The `internal/translate` package normalizes requests to a common internal representation, then rewrites them for the target provider. This allows the router to accept OpenAI-formatted requests while internally translating them to Anthropic's `v1/messages` format or Google's Gemini schema when necessary.

### Dynamic Provider Selection Logic

The router selects providers based on the requested model name, HTTP headers, or cluster-level overrides. When a request arrives, the catalog in [`internal/router/catalog/catalog.go`](https://github.com/workweave/router/blob/main/internal/router/catalog/catalog.go) maps model names (e.g., `gpt-4o`, `claude-3-5-sonnet-20241022`) to their respective provider constants. The router then injects the `x-router-provider` header into responses for observability, allowing clients to track which backend AI model API actually served the request.

Registration occurs in [`cmd/router/main.go`](https://github.com/workweave/router/blob/main/cmd/router/main.go), where the composition root wires all enabled providers:

```go
// Provider registration in the router composition root
func registerProviders(r router.Builder) {
    r.RegisterProvider(providers.ProviderOpenAI, providers.NewOpenAIClient())
    r.RegisterProvider(providers.ProviderAnthropic, providers.NewAnthropicClient())
    r.RegisterProvider(providers.ProviderGoogle, providers.NewGoogleClient())
    r.RegisterProvider(providers.ProviderBedrock, providers.NewOpenAICompatClient("bedrock"))
    r.RegisterProvider(providers.ProviderFireworks, providers.NewOpenAICompatClient("fireworks"))
}

```

## Configuration and Usage Examples

### Client-Side API Calls

Clients interact with the router using standard OpenAI-compatible HTTP requests. The router handles provider selection automatically, though you can override it via headers for testing:

```go
package main

import (
    "bytes"
    "net/http"
)

func callRouter() (*http.Response, error) {
    payload := []byte(`{
        "model": "gpt-4o",
        "messages": [{"role": "user", "content": "Explain the adapter pattern"}]
    }`)
    
    req, _ := http.NewRequest(
        "POST", 
        "https://router.workweave.com/v1/chat/completions", 
        bytes.NewReader(payload),
    )
    req.Header.Set("Content-Type", "application/json")
    
    // Optional: Force specific AI model API provider for testing
    // req.Header.Set("x-router-provider", "anthropic")
    
    return http.DefaultClient.Do(req)
}

```

### Adding Models to the Catalog

New models are registered in [`internal/router/catalog/catalog.go`](https://github.com/workweave/router/blob/main/internal/router/catalog/catalog.go) by mapping them to their respective provider constants:

```go
package catalog

import "github.com/workweave/router/internal/providers"

func init() {
    RegisterModel(ModelEntry{
        ModelName:  "claude-3-5-sonnet-20241022",
        Provider:   providers.ProviderAnthropic,
        Tier:       TierStandard,
        MaxTokens:  200000,
        Pricing: Pricing{
            Prompt:     0.003,
            Completion: 0.015,
        },
    })
}

```

## Summary

- The WorkWeave Router supports **12+ AI model APIs** through constants defined in [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go), including OpenAI, Anthropic, Google, Azure, Bedrock, Fireworks, OpenRouter, Together, XAI, Cortex, and generic OpenAI-compatible endpoints.
- **Provider-specific adapters** live in `internal/providers/<name>/` and implement a unified interface, while the `internal/translate` package handles wire-format conversion between OpenAI, Anthropic, and Google schemas.
- **Amazon Bedrock, Fireworks, OpenRouter, Together.ai, and XAI** reuse the `openaicompat` adapter but maintain distinct provider constants for routing logic and observability.
- Dynamic provider selection occurs via the **catalog** ([`internal/router/catalog/catalog.go`](https://github.com/workweave/router/blob/main/internal/router/catalog/catalog.go)), which maps model names to provider constants and enables cluster-level overrides through the `x-router-provider` header.

## Frequently Asked Questions

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

Create a new package under `internal/providers/<providername>/` implementing the `Provider` interface, then add a constant like `ProviderNewName` to [`internal/providers/provider.go`](https://github.com/workweave/router/blob/main/internal/providers/provider.go). Register the provider in [`cmd/router/main.go`](https://github.com/workweave/router/blob/main/cmd/router/main.go) using `r.RegisterProvider()`, and add supported models to [`internal/router/catalog/catalog.go`](https://github.com/workweave/router/blob/main/internal/router/catalog/catalog.go) with the appropriate pricing and token limits.

### What is the difference between ProviderBedrock and the native OpenAI provider?

`ProviderOpenAI` uses the dedicated [`internal/providers/openai/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openai/client.go) adapter for native OpenAI endpoints, while `ProviderBedrock` uses [`internal/providers/openaicompat/client.go`](https://github.com/workweave/router/blob/main/internal/providers/openaicompat/client.go) to translate requests for Amazon Bedrock's OpenAI-compatible inference endpoints. Both accept similar request formats, but Bedrock uses AWS Signature Version 4 authentication handled within the compatibility layer.

### How does the router handle API format differences between Anthropic and OpenAI?

The `internal/translate` package converts incoming OpenAI-formatted requests to provider-native formats. For Anthropic, it transforms the `messages` array and `model` parameters to match the `v1/messages` schema, then converts the Claude response back to OpenAI's `chat.completion` format before returning to the client.

### Can I force a specific AI model API provider for a request?

Yes. While the router automatically selects providers based on the model name in [`internal/router/catalog/catalog.go`](https://github.com/workweave/router/blob/main/internal/router/catalog/catalog.go), you can override this by setting the `x-router-provider` header to a specific constant value (e.g., `anthropic`, `openai`, `bedrock`). The router will attempt to route to that provider and include the selected provider in the response headers for debugging.