feat: add OpenAI to Anthropic translator

internal/endpointspec/endpointspec.go

@@ -170,6 +170,8 @@ func (ChatCompletionsEndpointSpec) GetTranslator(schema filterapi.VersionedAPISc
 		return translator.NewChatCompletionOpenAIToGCPVertexAITranslator(modelNameOverride), nil
 	case filterapi.APISchemaGCPAnthropic:
 		return translator.NewChatCompletionOpenAIToGCPAnthropicTranslator(schema.Version, modelNameOverride), nil
+	case filterapi.APISchemaAnthropic:
+		return translator.NewChatCompletionOpenAIToAnthropicTranslator(schema.AnthropicPrefix(), modelNameOverride), nil
 	default:
 		return nil, fmt.Errorf("unsupported API schema: backend=%s", schema)
 	}

internal/endpointspec/endpointspec_test.go

@@ -89,6 +89,7 @@ func TestChatCompletionsEndpointSpec_GetTranslator(t *testing.T) {
 		{Name: filterapi.APISchemaAzureOpenAI, Version: "2024-02-01"},
 		{Name: filterapi.APISchemaGCPVertexAI},
 		{Name: filterapi.APISchemaGCPAnthropic, Version: "2024-05-01"},
+		{Name: filterapi.APISchemaAnthropic, Prefix: "v1"},
 	}
 
 	for _, schema := range supported {

internal/translator/anthropic_helper.go

@@ -681,13 +681,13 @@ func mapReasoningEffortToOutputConfigEffort(reasonEffort openai.ReasoningEffort)
 	}
 }
 
-// buildAnthropicParams is a helper function that translates an OpenAI request
-// into the parameter struct required by the Anthropic SDK.
+// buildAnthropicParams translates an OpenAI request into Anthropic SDK parameters.
+// It leaves Model unset because cloud providers identify the model in the request path.
 // The apiSchema parameter indicates the backend API schema (e.g., "AWSAnthropic", "GCPAnthropic").
 func buildAnthropicParams(openAIReq *openai.ChatCompletionRequest, apiSchema string, modelNameOverride internalapi.ModelNameOverride) (params *anthropic.MessageNewParams, err error) {
 	// 1. Handle simple parameters.
 	// max_tokens is required by the Anthropic API but optional in the OpenAI API.
-	// If not set, pass 0 and let the Anthropic API reject the request.
+	// If not set, preserve the zero value for the provider to interpret.
 	var maxTokensVal int64
 	if maxTokens := cmp.Or(openAIReq.MaxCompletionTokens, openAIReq.MaxTokens); maxTokens != nil {
 		maxTokensVal = *maxTokens
@@ -811,15 +811,17 @@ type streamingToolCall struct {
 // anthropicStreamParser manages the stateful translation of an Anthropic SSE stream
 // to an OpenAI-compatible SSE stream.
 type anthropicStreamParser struct {
-	buffer          bytes.Buffer
-	activeMessageID string
-	activeToolCalls map[int64]*streamingToolCall
-	toolIndex       int64
-	tokenUsage      metrics.TokenUsage
-	stopReason      anthropic.StopReason
-	requestModel    internalapi.RequestModel
-	sentFirstChunk  bool
-	created         openai.JSONUNIXTime
+	buffer           bytes.Buffer
+	activeMessageID  string
+	activeToolCalls  map[int64]*streamingToolCall
+	toolIndex        int64
+	tokenUsage       metrics.TokenUsage
+	stopReason       anthropic.StopReason
+	requestModel     internalapi.RequestModel
+	responseModel    internalapi.ResponseModel
+	useResponseModel bool
+	sentFirstChunk   bool
+	created          openai.JSONUNIXTime
 }
 
 // newAnthropicStreamParser creates a new parser for a streaming request.
@@ -832,6 +834,13 @@ func newAnthropicStreamParser(requestModel string) *anthropicStreamParser {
 	}
 }
 
+func (p *anthropicStreamParser) model() string {
+	if p.useResponseModel && p.responseModel != "" {
+		return p.responseModel
+	}
+	return p.requestModel
+}
+
 func (p *anthropicStreamParser) writeChunk(eventBlock []byte, buf *[]byte) error {
 	chunk, err := p.parseAndHandleEvent(eventBlock)
 	if err != nil {
@@ -914,7 +923,7 @@ func (p *anthropicStreamParser) Process(body io.Reader, endOfStream bool, span t
 ) {
 	newBody = make([]byte, 0)
 	_ = span // TODO: add support for streaming chunks in tracing.
-	responseModel = p.requestModel
+	responseModel = p.model()
 	if _, err = p.buffer.ReadFrom(body); err != nil {
 		err = fmt.Errorf("failed to read from stream body: %w", err)
 		return
@@ -968,7 +977,7 @@ func (p *anthropicStreamParser) Process(body io.Reader, endOfStream bool, span t
 					ReasoningTokens: int(reasoningTokens),
 				},
 			},
-			Model: p.requestModel,
+			Model: p.model(),
 		}
 
 		// Add active tool calls to the final chunk.
@@ -1006,6 +1015,7 @@ func (p *anthropicStreamParser) Process(body io.Reader, endOfStream bool, span t
 		newBody = append(newBody, '\n', '\n')
 	}
 	tokenUsage = p.tokenUsage
+	responseModel = p.model()
 	return
 }
 
@@ -1040,6 +1050,7 @@ func (p *anthropicStreamParser) handleAnthropicStreamEvent(eventType []byte, dat
 			return nil, fmt.Errorf("unmarshal message_start: %w", err)
 		}
 		p.activeMessageID = event.Message.ID
+		p.responseModel = event.Message.Model
 		p.created = openai.JSONUNIXTime(time.Now())
 		u := event.Message.Usage
 		usage := metrics.ExtractTokenUsageFromExplicitCaching(
@@ -1251,7 +1262,7 @@ func (p *anthropicStreamParser) constructOpenAIChatCompletionChunk(delta openai.
 				FinishReason: finishReason,
 			},
 		},
-		Model: p.requestModel,
+		Model: p.model(),
 	}
 }
 

internal/translator/openai_anthropic.go

@@ -0,0 +1,95 @@
+// Copyright Envoy AI Gateway Authors
+// SPDX-License-Identifier: Apache-2.0
+// The full text of the Apache license is available in the LICENSE file at
+// the root of the repo.
+
+package translator
+
+import (
+	"io"
+	"path"
+	"strconv"
+	"strings"
+
+	"github.com/tidwall/sjson"
+
+	"github.com/envoyproxy/ai-gateway/internal/apischema/openai"
+	"github.com/envoyproxy/ai-gateway/internal/internalapi"
+	"github.com/envoyproxy/ai-gateway/internal/json"
+)
+
+const (
+	anthropicBackendError      = "AnthropicBackendError"
+	anthropicDefaultVersion    = "2023-06-01"
+	anthropicVersionHeaderName = "anthropic-version"
+)
+
+// NewChatCompletionOpenAIToAnthropicTranslator implements [Factory] for direct Anthropic translation.
+func NewChatCompletionOpenAIToAnthropicTranslator(prefix string, modelNameOverride internalapi.ModelNameOverride) OpenAIChatCompletionTranslator {
+	return &openAIToAnthropicTranslatorV1ChatCompletion{
+		openAIToGCPAnthropicTranslatorV1ChatCompletion: openAIToGCPAnthropicTranslatorV1ChatCompletion{
+			modelNameOverride: modelNameOverride,
+		},
+		path: path.Join("/", prefix, "messages"),
+	}
+}
+
+// openAIToAnthropicTranslatorV1ChatCompletion reuses the GCP Anthropic
+// response translation; direct Anthropic only differs in request construction.
+type openAIToAnthropicTranslatorV1ChatCompletion struct {
+	openAIToGCPAnthropicTranslatorV1ChatCompletion
+	path string
+}
+
+// RequestBody implements [OpenAIChatCompletionTranslator.RequestBody].
+func (o *openAIToAnthropicTranslatorV1ChatCompletion) RequestBody(_ []byte, openAIReq *openai.ChatCompletionRequest, _ bool) (
+	newHeaders []internalapi.Header, newBody []byte, err error,
+) {
+	params, err := buildAnthropicParams(openAIReq, "Anthropic", o.modelNameOverride)
+	if err != nil {
+		return
+	}
+
+	o.requestModel = openAIReq.Model
+	if o.modelNameOverride != "" {
+		o.requestModel = o.modelNameOverride
+	}
+	params.Model = o.requestModel
+
+	newBody, err = json.Marshal(params)
+	if err != nil {
+		return
+	}
+	if openAIReq.Stream {
+		newBody, err = sjson.SetBytes(newBody, "stream", true)
+		if err != nil {
+			return
+		}
+		o.streamParser = newAnthropicStreamParser(o.requestModel)
+		o.streamParser.useResponseModel = true
+	}
+
+	newHeaders = []internalapi.Header{
+		{pathHeaderName, o.path},
+		{anthropicVersionHeaderName, anthropicDefaultVersion},
+		{contentLengthHeaderName, strconv.Itoa(len(newBody))},
+	}
+	return
+}
+
+// ResponseError uses the GCP Anthropic error envelope with a direct-provider fallback type.
+func (o *openAIToAnthropicTranslatorV1ChatCompletion) ResponseError(respHeaders map[string]string, body io.Reader) (
+	newHeaders []internalapi.Header, newBody []byte, err error,
+) {
+	newHeaders, newBody, err = o.openAIToGCPAnthropicTranslatorV1ChatCompletion.ResponseError(respHeaders, body)
+	if err == nil && !strings.Contains(respHeaders[contentTypeHeaderName], jsonContentType) {
+		newBody, err = sjson.SetBytes(newBody, "error.type", anthropicBackendError)
+		if err == nil {
+			newHeaders = []internalapi.Header{
+				{contentTypeHeaderName, jsonContentType},
+				{contentLengthHeaderName, strconv.Itoa(len(newBody))},
+			}
+		}
+	}
+	return
+}

internal/translator/openai_anthropic_test.go

@@ -0,0 +1,90 @@
+// Copyright Envoy AI Gateway Authors
+// SPDX-License-Identifier: Apache-2.0
+// The full text of the Apache license is available in the LICENSE file at
+// the root of the repo.
+
+package translator
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/tidwall/gjson"
+	"k8s.io/utils/ptr"
+
+	"github.com/envoyproxy/ai-gateway/internal/apischema/openai"
+	"github.com/envoyproxy/ai-gateway/internal/internalapi"
+)
+
+func TestOpenAIToAnthropicTranslator_RequestBody(t *testing.T) {
+	req := &openai.ChatCompletionRequest{
+		Model:     "claude-requested",
+		MaxTokens: ptr.To(int64(100)),
+		Messages: []openai.ChatCompletionMessageParamUnion{{
+			OfUser: &openai.ChatCompletionUserMessageParam{
+				Role:    openai.ChatMessageRoleUser,
+				Content: openai.StringOrUserRoleContentUnion{Value: "Hello"},
+			},
+		}},
+	}
+
+	tr := NewChatCompletionOpenAIToAnthropicTranslator("gateway/v1", "claude-override")
+	headers, body, err := tr.RequestBody(nil, req, false)
+	require.NoError(t, err)
+	require.Contains(t, headers, internalapi.Header{pathHeaderName, "/gateway/v1/messages"})
+	require.Contains(t, headers, internalapi.Header{anthropicVersionHeaderName, anthropicDefaultVersion})
+	require.Equal(t, "claude-override", gjson.GetBytes(body, "model").String())
+	require.False(t, gjson.GetBytes(body, anthropicVersionKey).Exists())
+
+	req.Stream = true
+	_, body, err = tr.RequestBody(nil, req, false)
+	require.NoError(t, err)
+	require.True(t, gjson.GetBytes(body, "stream").Bool())
+}
+
+func TestOpenAIToAnthropicTranslator_UsesResponseModel(t *testing.T) {
+	req := &openai.ChatCompletionRequest{
+		Model:     "claude-requested",
+		MaxTokens: ptr.To(int64(100)),
+		Messages: []openai.ChatCompletionMessageParamUnion{{
+			OfUser: &openai.ChatCompletionUserMessageParam{
+				Role:    openai.ChatMessageRoleUser,
+				Content: openai.StringOrUserRoleContentUnion{Value: "Hello"},
+			},
+		}},
+	}
+
+	tr := NewChatCompletionOpenAIToAnthropicTranslator("v1", "")
+	_, _, err := tr.RequestBody(nil, req, false)
+	require.NoError(t, err)
+
+	response := `{"id":"msg_1","type":"message","role":"assistant","model":"claude-executed","content":[{"type":"text","text":"Hi"}],"stop_reason":"end_turn","usage":{"input_tokens":1,"output_tokens":1}}`
+	_, body, _, model, err := tr.ResponseBody(nil, bytes.NewBufferString(response), true, nil)
+	require.NoError(t, err)
+	require.Equal(t, "claude-executed", model)
+	require.Equal(t, "claude-executed", gjson.GetBytes(body, "model").String())
+}
+
+func TestOpenAIToAnthropicTranslator_StreamUsesResponseModel(t *testing.T) {
+	req := &openai.ChatCompletionRequest{
+		Model:     "claude-requested",
+		Stream:    true,
+		MaxTokens: ptr.To(int64(100)),
+	}
+	tr := NewChatCompletionOpenAIToAnthropicTranslator("v1", "")
+	_, _, err := tr.RequestBody(nil, req, false)
+	require.NoError(t, err)
+
+	event := "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-executed\",\"content\":[],\"usage\":{\"input_tokens\":1,\"output_tokens\":0}}}\n\n"
+	_, _, _, model, err := tr.ResponseBody(nil, bytes.NewBufferString(event), false, nil)
+	require.NoError(t, err)
+	require.Equal(t, "claude-executed", model)
+}
+
+func TestOpenAIToAnthropicTranslator_RawError(t *testing.T) {
+	tr := NewChatCompletionOpenAIToAnthropicTranslator("v1", "")
+	_, body, err := tr.ResponseError(map[string]string{statusHeaderName: "503"}, bytes.NewBufferString("unavailable"))
+	require.NoError(t, err)
+	require.Equal(t, anthropicBackendError, gjson.GetBytes(body, "error.type").String())
+}

site/docs/capabilities/llm-integrations/supported-endpoints.md

@@ -39,6 +39,7 @@ The Envoy AI Gateway acts as a proxy that accepts OpenAI-compatible and Anthropi
 - Azure OpenAI (with automatic translation)
 - GCP VertexAI (with automatic translation)
 - GCP Anthropic (with automatic translation)
+- Anthropic (with automatic translation)
 - Any OpenAI-compatible provider (Groq, Together AI, Mistral, Tetrate Agent Router Service, etc.)
 
 **Example:**

site/docs/capabilities/llm-integrations/supported-providers.md

@@ -30,7 +30,7 @@ Below is a table of currently supported providers and their respective configura
 | [Tetrate Agent Router Service (TARS)](https://router.tetrate.ai/)                                         |                                   `{"name":"OpenAI","prefix":"/v1"}`                                   |                         [API Key]                         |   ✅   |                                                                                                                                                        |
 | [SambaNova](https://docs.sambanova.ai/sambastudio/latest/open-ai-api.html)                                |                                   `{"name":"OpenAI","prefix":"/v1"}`                                   |                         [API Key]                         |   ✅   |                                                                                                                                                        |
 | Self-hosted-models                                                                                        |                                   `{"name":"OpenAI","prefix":"/v1"}`                                   |                            N/A                            |   ⚠️   | Depending on the API schema spoken by self-hosted servers. For example, [vLLM] speaks the OpenAI format. Also, API Key auth can be configured as well. |
-| [Anthropic](https://docs.claude.com/en/home)                                                              |                                         `{"name":"Anthropic"}`                                         |                    [Anthropic API Key]                    |   ✅   | Support only Native Anthropic messages endpoint                                                                                                        |
+| [Anthropic](https://docs.claude.com/en/home)                                                              |                                         `{"name":"Anthropic"}`                                         |                    [Anthropic API Key]                    |   ✅   | Native Anthropic Messages and OpenAI-compatible Chat Completions endpoints                                                                             |
 
 [AIServiceBackend]: api/api.mdx#aiservicebackendspec
 [BackendSecurityPolicy]: api/api.mdx#backendsecuritypolicyspec

site/docs/getting-started/connect-providers/anthropic.md

@@ -68,6 +68,7 @@ See the [Basic Usage](../basic-usage.md) page for instructions.
 curl -H "Content-Type: application/json" \
   -d '{
     "model": "claude-sonnet-4-5",
+    "max_tokens": 1024,
     "messages": [
       {
         "role": "user",