diff --git a/ui/app/workspace/providers/fragments/deploymentsTable.tsx b/ui/app/workspace/providers/fragments/deploymentsTable.tsx
index d87f6881cb6..1121bb56beb 100644
--- a/ui/app/workspace/providers/fragments/deploymentsTable.tsx
+++ b/ui/app/workspace/providers/fragments/deploymentsTable.tsx
@@ -292,6 +292,28 @@ function ReplicateSection({ config, onChange, disabled }: ProviderSectionProps)
);
}
+function UseAnthropicEndpointsToggleSection({ config, onChange, disabled, providerName }: ProviderSectionProps & { providerName: string }) {
+ return (
+
+
+
+
+
+
+ Route chat completions and responses requests through Anthropic-compatible endpoints.
+
+
+
onChange({ use_anthropic_endpoints: checked ? true : undefined })}
+ disabled={disabled}
+ />
+
+
+ );
+}
+
function ProviderSection({ providerName, ...props }: ProviderSectionProps & { providerName: string }) {
switch (providerName) {
case "azure":
@@ -304,6 +326,12 @@ function ProviderSection({ providerName, ...props }: ProviderSectionProps & { pr
return
;
case "replicate":
return
;
+ case "sgl":
+ return
;
+ case "deepseek":
+ return
;
+ case "fireworks":
+ return
;
default:
return null;
}
diff --git a/ui/lib/types/config.ts b/ui/lib/types/config.ts
index cf368bc8f95..ce180e40525 100644
--- a/ui/lib/types/config.ts
+++ b/ui/lib/types/config.ts
@@ -73,6 +73,7 @@ export interface AliasConfig {
inference_profile_arn?: SecretVar;
// Replicate overrides
use_deployments_endpoint?: boolean;
+ use_anthropic_endpoints?: boolean;
}
// AzureKeyConfig matching Go's schemas.AzureKeyConfig
@@ -217,6 +218,7 @@ export interface ModelProviderKey {
weight: number;
enabled?: boolean;
use_for_batch_api?: boolean;
+ use_anthropic_endpoints?: boolean;
aliases?: Record
;
azure_key_config?: AzureKeyConfig;
vertex_key_config?: VertexKeyConfig;
diff --git a/ui/lib/types/schemas.ts b/ui/lib/types/schemas.ts
index 88523d61067..acd0e10d252 100644
--- a/ui/lib/types/schemas.ts
+++ b/ui/lib/types/schemas.ts
@@ -302,6 +302,7 @@ const aliasConfigObjectSchema = z.object({
inference_profile_arn: secretVarSchema.optional(),
// Replicate overrides
use_deployments_endpoint: z.boolean().optional(),
+ use_anthropic_endpoints: z.boolean().optional(),
});
// The Go server emits the legacy string wire shape (`{"my-alias": "model-id"}`)
@@ -348,6 +349,7 @@ export const modelProviderKeySchema = z
ollama_key_config: ollamaKeyConfigSchema.optional(),
sgl_key_config: sglKeyConfigSchema.optional(),
use_for_batch_api: z.boolean().optional(),
+ use_anthropic_endpoints: z.boolean().optional(),
enabled: z.boolean().optional(),
})
.refine(
From e6b494bcbde7597ef5042dd69ff76c6728408622 Mon Sep 17 00:00:00 2001
From: Samyabrata Maji <116789799+sammaji@users.noreply.github.com>
Date: Thu, 9 Jul 2026 16:26:50 +0530
Subject: [PATCH 2/2] fix: use anthropic endpoints in chat completion and
responses in deepseek
---
core/providers/anthropic/chat.go | 7 +
core/providers/anthropic/requestbuilder.go | 1 +
core/providers/anthropic/responses.go | 7 +
core/providers/anthropic/types.go | 17 +-
core/providers/deepseek/deepseek.go | 172 +++++++-
.../deepseek/deepseek_anthropic_test.go | 380 ++++++++++++++++++
core/providers/deepseek/deepseek_test.go | 37 +-
plugins/compat/conversion.go | 38 --
8 files changed, 598 insertions(+), 61 deletions(-)
create mode 100644 core/providers/deepseek/deepseek_anthropic_test.go
diff --git a/core/providers/anthropic/chat.go b/core/providers/anthropic/chat.go
index 4b433ab9345..d67a953d4f2 100644
--- a/core/providers/anthropic/chat.go
+++ b/core/providers/anthropic/chat.go
@@ -582,6 +582,13 @@ func ToAnthropicChatRequest(ctx *schemas.BifrostContext, bifrostReq *schemas.Bif
}
}
+ // DeepSeek rejects a forced tool_choice while thinking is enabled (which is
+ // the default). Force thinking off when tool_choice pins a specific tool.
+ if bifrostReq.Provider == schemas.DeepSeek && anthropicReq.ToolChoice != nil &&
+ anthropicReq.ToolChoice.Type == "tool" {
+ anthropicReq.Thinking = &AnthropicThinking{Type: "disabled"}
+ }
+
// Convert service tier
if bifrostReq.Params.ServiceTier != nil {
mapped := MapBifrostServiceTierToAnthropicRequest(*bifrostReq.Params.ServiceTier)
diff --git a/core/providers/anthropic/requestbuilder.go b/core/providers/anthropic/requestbuilder.go
index 301e4a9706b..ecdabc16bc5 100644
--- a/core/providers/anthropic/requestbuilder.go
+++ b/core/providers/anthropic/requestbuilder.go
@@ -112,6 +112,7 @@ var AnthropicProviderRequestDefaultsMap = map[schemas.ModelProvider]AnthropicPro
schemas.BedrockMantle: {
RemapToolVersions: true,
},
+ schemas.DeepSeek: {},
// Vertex publisher endpoint: model + region in URL, anthropic_version
// required, beta headers in body (not HTTP), cache_control.scope stripped
// at marshal time, tool versions remapped.
diff --git a/core/providers/anthropic/responses.go b/core/providers/anthropic/responses.go
index b7e8b63940e..e717776df20 100644
--- a/core/providers/anthropic/responses.go
+++ b/core/providers/anthropic/responses.go
@@ -3736,6 +3736,13 @@ func ToAnthropicResponsesRequest(ctx *schemas.BifrostContext, bifrostReq *schema
anthropicReq.ToolChoice = anthropicToolChoice
}
}
+
+ // DeepSeek rejects a forced tool_choice while thinking is on. Force thinking
+ // off when tool_choice pins a specific tool.
+ if bifrostReq.Provider == schemas.DeepSeek && anthropicReq.ToolChoice != nil &&
+ anthropicReq.ToolChoice.Type == "tool" {
+ anthropicReq.Thinking = &AnthropicThinking{Type: "disabled"}
+ }
}
if bifrostReq.Input != nil {
diff --git a/core/providers/anthropic/types.go b/core/providers/anthropic/types.go
index 91b8ea897be..0dde2c7f8dd 100644
--- a/core/providers/anthropic/types.go
+++ b/core/providers/anthropic/types.go
@@ -257,6 +257,21 @@ var ProviderFeatures = map[schemas.ModelProvider]ProviderFeatureSupport{
// FastMode, InferenceGeo, AdvisorTool, TaskBudgets — not documented on Az-platform; leave off.
ServiceTier: true,
},
+ schemas.DeepSeek: {
+ WebSearch: true,
+ WebSearchDynamic: true,
+ ContainerBasic: true,
+ ContextManagementField: true,
+ Compaction: true,
+ ContextEditing: true,
+ PromptCachingScope: true,
+ AdvancedToolUse: true,
+ InputExamples: true,
+ EagerInputStreaming: true,
+ StructuredOutputs: true,
+ InterleavedThinking: true,
+ ServiceTier: true,
+ },
}
// ==================== REQUEST TYPES ====================
@@ -1861,4 +1876,4 @@ func parseAnthropicFileTimestamp(timestamp string) int64 {
// AnthropicCountTokensResponse models the payload returned by Anthropic's count tokens endpoint.
type AnthropicCountTokensResponse struct {
InputTokens int `json:"input_tokens"`
-}
\ No newline at end of file
+}
diff --git a/core/providers/deepseek/deepseek.go b/core/providers/deepseek/deepseek.go
index bba9d74e71d..663748b2d59 100644
--- a/core/providers/deepseek/deepseek.go
+++ b/core/providers/deepseek/deepseek.go
@@ -6,6 +6,7 @@ import (
"strings"
"time"
+ "github.com/maximhq/bifrost/core/providers/anthropic"
"github.com/maximhq/bifrost/core/providers/openai"
providerUtils "github.com/maximhq/bifrost/core/providers/utils"
schemas "github.com/maximhq/bifrost/core/schemas"
@@ -60,6 +61,69 @@ func NewDeepSeekProvider(config *schemas.ProviderConfig, logger schemas.Logger)
}, nil
}
+func (provider *DeepSeekProvider) anthropicHeaders(key schemas.Key) map[string]string {
+ headers := map[string]string{}
+ if key.Value.GetValue() != "" {
+ headers["x-api-key"] = key.Value.GetValue()
+ }
+ return headers
+}
+
+// disableThinkingForForcedToolChoice disables thinking when it would otherwise be
+// rejected by DeepSeek's OpenAI-compatible endpoint. This covers two distinct cases:
+//
+// 1. A forced tool_choice ("required"/"any", or the struct form pinning a specific
+// function/custom/allowed_tools call) — DeepSeek rejects a forced tool_choice while
+// thinking is enabled (the default).
+// 2. A conversation that already contains an assistant turn without reasoning_content
+// (e.g. synthetic/injected history, or a turn produced while thinking was off) —
+// DeepSeek requires prior reasoning_content to be replayed once thinking is on, so if
+// any assistant turn is missing it, thinking must stay off for the whole request.
+func disableThinkingForForcedToolChoice(request *schemas.BifrostChatRequest) {
+ if request.Params == nil {
+ return
+ }
+
+ disable := false
+
+ if tc := request.Params.ToolChoice; tc != nil {
+ switch {
+ case tc.ChatToolChoiceStr != nil:
+ switch schemas.ChatToolChoiceType(*tc.ChatToolChoiceStr) {
+ case schemas.ChatToolChoiceTypeRequired, schemas.ChatToolChoiceTypeAny:
+ disable = true
+ }
+ case tc.ChatToolChoiceStruct != nil:
+ switch tc.ChatToolChoiceStruct.Type {
+ case schemas.ChatToolChoiceTypeRequired, schemas.ChatToolChoiceTypeAny,
+ schemas.ChatToolChoiceTypeFunction, schemas.ChatToolChoiceTypeCustom,
+ schemas.ChatToolChoiceTypeAllowedTools:
+ disable = true
+ }
+ }
+ }
+
+ if !disable {
+ for _, msg := range request.Input {
+ if msg.Role != schemas.ChatMessageRoleAssistant {
+ continue
+ }
+ if msg.ChatAssistantMessage == nil || msg.ChatAssistantMessage.Reasoning == nil {
+ disable = true
+ break
+ }
+ }
+ }
+
+ if !disable {
+ return
+ }
+ if request.Params.ExtraParams == nil {
+ request.Params.ExtraParams = make(map[string]any, 1)
+ }
+ request.Params.ExtraParams["thinking"] = map[string]any{"type": "disabled"}
+}
+
// GetProviderKey returns the provider identifier for DeepSeek.
func (provider *DeepSeekProvider) GetProviderKey() schemas.ModelProvider {
return schemas.DeepSeek
@@ -126,9 +190,28 @@ func (provider *DeepSeekProvider) TextCompletionStream(ctx *schemas.BifrostConte
)
}
-// ChatCompletion performs a chat completion request to the DeepSeek API.
+// ChatCompletion performs a chat completion request to DeepSeek's Anthropic-compatible API.
func (provider *DeepSeekProvider) ChatCompletion(ctx *schemas.BifrostContext, key schemas.Key, request *schemas.BifrostChatRequest) (*schemas.BifrostChatResponse, *schemas.BifrostError) {
+ if anthropic.ResolveUseAnthropicEndpoints(ctx, key) {
+ return anthropic.HandleAnthropicChatCompletionRequest(
+ ctx,
+ provider.client,
+ provider.networkConfig.BaseURL+providerUtils.GetPathFromContext(ctx, "/anthropic/v1/messages"),
+ request,
+ anthropic.AnthropicRequestBuildConfig{
+ Provider: schemas.DeepSeek,
+ ShouldSendBackRawRequest: provider.sendBackRawRequest,
+ ShouldSendBackRawResponse: provider.sendBackRawResponse,
+ },
+ provider.anthropicHeaders(key),
+ provider.networkConfig.ExtraHeaders,
+ nil,
+ provider.logger,
+ )
+ }
+
ctx.SetValue(schemas.BifrostContextKeyPassthroughExtraParams, true)
+ disableThinkingForForcedToolChoice(request)
return openai.HandleOpenAIChatCompletionRequest(
ctx,
provider.client,
@@ -146,12 +229,43 @@ func (provider *DeepSeekProvider) ChatCompletion(ctx *schemas.BifrostContext, ke
)
}
-// ChatCompletionStream performs a streaming chat completion request to the DeepSeek API.
+// ChatCompletionStream performs a streaming chat completion request to DeepSeek's Anthropic-compatible API.
// It supports real-time streaming of responses using Server-Sent Events (SSE).
-// Uses DeepSeek's OpenAI-compatible streaming format.
// Returns a channel containing BifrostStreamChunk objects representing the stream or an error if the request fails.
func (provider *DeepSeekProvider) ChatCompletionStream(ctx *schemas.BifrostContext, postHookRunner schemas.PostHookRunner, postHookSpanFinalizer func(context.Context), key schemas.Key, request *schemas.BifrostChatRequest) (chan *schemas.BifrostStreamChunk, *schemas.BifrostError) {
+ if anthropic.ResolveUseAnthropicEndpoints(ctx, key) {
+ jsonData, bifrostErr := anthropic.BuildAnthropicChatRequestBody(ctx, request, anthropic.AnthropicRequestBuildConfig{
+ Provider: schemas.DeepSeek,
+ IsStreaming: true,
+ ShouldSendBackRawRequest: provider.sendBackRawRequest,
+ ShouldSendBackRawResponse: provider.sendBackRawResponse,
+ })
+ if bifrostErr != nil {
+ return nil, bifrostErr
+ }
+
+ return anthropic.HandleAnthropicChatCompletionStreaming(
+ ctx,
+ provider.streamingClient,
+ provider.networkConfig.BaseURL+providerUtils.GetPathFromContext(ctx, "/anthropic/v1/messages"),
+ jsonData,
+ provider.anthropicHeaders(key),
+ provider.networkConfig.ExtraHeaders,
+ provider.networkConfig.StreamIdleTimeoutInSeconds,
+ provider.networkConfig.BetaHeaderOverrides,
+ providerUtils.ShouldSendBackRawRequest(ctx, provider.sendBackRawRequest),
+ providerUtils.ShouldSendBackRawResponse(ctx, provider.sendBackRawResponse),
+ schemas.DeepSeek,
+ postHookRunner,
+ nil,
+ nil,
+ provider.logger,
+ postHookSpanFinalizer,
+ )
+ }
+
ctx.SetValue(schemas.BifrostContextKeyPassthroughExtraParams, true)
+ disableThinkingForForcedToolChoice(request)
return openai.HandleOpenAIChatCompletionStreaming(
ctx,
provider.streamingClient,
@@ -175,7 +289,26 @@ func (provider *DeepSeekProvider) ChatCompletionStream(ctx *schemas.BifrostConte
)
}
+// Responses performs a Responses API request against DeepSeek's Anthropic-compatible endpoint.
func (provider *DeepSeekProvider) Responses(ctx *schemas.BifrostContext, key schemas.Key, request *schemas.BifrostResponsesRequest) (*schemas.BifrostResponsesResponse, *schemas.BifrostError) {
+ if anthropic.ResolveUseAnthropicEndpoints(ctx, key) {
+ return anthropic.HandleAnthropicResponsesRequest(
+ ctx,
+ provider.client,
+ provider.networkConfig.BaseURL+providerUtils.GetPathFromContext(ctx, "/anthropic/v1/messages"),
+ request,
+ anthropic.AnthropicRequestBuildConfig{
+ Provider: schemas.DeepSeek,
+ ShouldSendBackRawRequest: provider.sendBackRawRequest,
+ ShouldSendBackRawResponse: provider.sendBackRawResponse,
+ },
+ provider.anthropicHeaders(key),
+ provider.networkConfig.ExtraHeaders,
+ nil,
+ provider.logger,
+ )
+ }
+
chatResponse, err := provider.ChatCompletion(ctx, key, request.ToChatRequest())
if err != nil {
return nil, err
@@ -186,8 +319,39 @@ func (provider *DeepSeekProvider) Responses(ctx *schemas.BifrostContext, key sch
return response, nil
}
-// ResponsesStream performs a streaming responses request to the DeepSeek API.
+// ResponsesStream performs a streaming Responses API request to DeepSeek's Anthropic-compatible endpoint.
func (provider *DeepSeekProvider) ResponsesStream(ctx *schemas.BifrostContext, postHookRunner schemas.PostHookRunner, postHookSpanFinalizer func(context.Context), key schemas.Key, request *schemas.BifrostResponsesRequest) (chan *schemas.BifrostStreamChunk, *schemas.BifrostError) {
+ if anthropic.ResolveUseAnthropicEndpoints(ctx, key) {
+ jsonData, bifrostErr := anthropic.BuildAnthropicResponsesRequestBody(ctx, request, anthropic.AnthropicRequestBuildConfig{
+ Provider: schemas.DeepSeek,
+ IsStreaming: true,
+ ShouldSendBackRawRequest: provider.sendBackRawRequest,
+ ShouldSendBackRawResponse: provider.sendBackRawResponse,
+ })
+ if bifrostErr != nil {
+ return nil, bifrostErr
+ }
+
+ return anthropic.HandleAnthropicResponsesStream(
+ ctx,
+ provider.streamingClient,
+ provider.networkConfig.BaseURL+providerUtils.GetPathFromContext(ctx, "/anthropic/v1/messages"),
+ jsonData,
+ provider.anthropicHeaders(key),
+ provider.networkConfig.ExtraHeaders,
+ provider.networkConfig.StreamIdleTimeoutInSeconds,
+ provider.networkConfig.BetaHeaderOverrides,
+ providerUtils.ShouldSendBackRawRequest(ctx, provider.sendBackRawRequest),
+ providerUtils.ShouldSendBackRawResponse(ctx, provider.sendBackRawResponse),
+ provider.GetProviderKey(),
+ postHookRunner,
+ nil,
+ nil,
+ provider.logger,
+ postHookSpanFinalizer,
+ )
+ }
+
ctx.SetValue(schemas.BifrostContextKeyIsResponsesToChatCompletionFallback, true)
return provider.ChatCompletionStream(
ctx,
diff --git a/core/providers/deepseek/deepseek_anthropic_test.go b/core/providers/deepseek/deepseek_anthropic_test.go
new file mode 100644
index 00000000000..e256850960c
--- /dev/null
+++ b/core/providers/deepseek/deepseek_anthropic_test.go
@@ -0,0 +1,380 @@
+package deepseek_test
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/maximhq/bifrost/core/internal/llmtests"
+ deepseek "github.com/maximhq/bifrost/core/providers/deepseek"
+ schemas "github.com/maximhq/bifrost/core/schemas"
+)
+
+type testLogger struct{}
+
+func (l testLogger) Debug(string, ...any) {}
+func (l testLogger) Info(string, ...any) {}
+func (l testLogger) Warn(string, ...any) {}
+func (l testLogger) Error(string, ...any) {}
+func (l testLogger) Fatal(string, ...any) {}
+func (l testLogger) SetLevel(schemas.LogLevel) {}
+func (l testLogger) SetOutputType(schemas.LoggerOutputType) {}
+func (l testLogger) LogHTTPRequest(schemas.LogLevel, string) schemas.LogEventBuilder {
+ return schemas.NoopLogEvent
+}
+
+func newTestDeepSeekProvider(baseURL string) (*deepseek.DeepSeekProvider, error) {
+ return deepseek.NewDeepSeekProvider(&schemas.ProviderConfig{
+ NetworkConfig: schemas.NetworkConfig{
+ BaseURL: baseURL,
+ DefaultRequestTimeoutInSeconds: 5,
+ StreamIdleTimeoutInSeconds: 5,
+ MaxConnsPerHost: 1,
+ },
+ ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+ Concurrency: 1,
+ BufferSize: 1,
+ },
+ }, testLogger{})
+}
+
+func newAnthropicResponse() string {
+ return `{"id":"msg_1","type":"message","role":"assistant","model":"deepseek-chat","content":[{"type":"text","text":"hello"}],"stop_reason":"end_turn","usage":{"input_tokens":1,"output_tokens":1}}`
+}
+
+func TestChatCompletion_UsesAnthropicEndpoint(t *testing.T) {
+ t.Parallel()
+
+ var captured map[string]any
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/anthropic/v1/messages" {
+ t.Fatalf("path = %q, want /anthropic/v1/messages", r.URL.Path)
+ }
+ if got := r.Header.Get("x-api-key"); got != "test-api-key" {
+ t.Fatalf("x-api-key = %q, want test-api-key", got)
+ }
+ body, err := io.ReadAll(r.Body)
+ if err != nil {
+ t.Fatalf("read body: %v", err)
+ }
+ if err := json.Unmarshal(body, &captured); err != nil {
+ t.Fatalf("decode body: %v", err)
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ fmt.Fprint(w, newAnthropicResponse())
+ }))
+ defer server.Close()
+
+ provider, err := newTestDeepSeekProvider(server.URL)
+ if err != nil {
+ t.Fatalf("NewDeepSeekProvider: %v", err)
+ }
+
+ ctx := schemas.NewBifrostContext(context.Background(), schemas.NoDeadline)
+ msg := "hello"
+ resp, bifrostErr := provider.ChatCompletion(ctx, schemas.Key{Value: schemas.SecretVar{Val: "test-api-key"}, UseAnthropicEndpoints: new(true)}, &schemas.BifrostChatRequest{
+ Provider: schemas.DeepSeek,
+ Model: "deepseek-v4-flash",
+ Input: []schemas.ChatMessage{{
+ Role: schemas.ChatMessageRoleUser,
+ Content: &schemas.ChatMessageContent{ContentStr: &msg},
+ }},
+ })
+ if bifrostErr != nil {
+ t.Fatalf("ChatCompletion: %v", bifrostErr.Error.Message)
+ }
+ if resp == nil || len(resp.Choices) == 0 {
+ t.Fatalf("expected chat response, got %#v", resp)
+ }
+ if _, ok := captured["messages"]; !ok {
+ t.Fatalf("outbound body missing messages: %#v", captured)
+ }
+}
+
+func TestResponses_UsesAnthropicEndpointAndKeepsWebSearch(t *testing.T) {
+ t.Parallel()
+
+ var captured map[string]any
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/anthropic/v1/messages" {
+ t.Fatalf("path = %q, want /anthropic/v1/messages", r.URL.Path)
+ }
+ if got := r.Header.Get("x-api-key"); got != "test-api-key" {
+ t.Fatalf("x-api-key = %q, want test-api-key", got)
+ }
+
+ body, err := io.ReadAll(r.Body)
+ if err != nil {
+ t.Fatalf("read body: %v", err)
+ }
+ if err := json.Unmarshal(body, &captured); err != nil {
+ t.Fatalf("decode body: %v", err)
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ fmt.Fprint(w, newAnthropicResponse())
+ }))
+ defer server.Close()
+
+ provider, err := newTestDeepSeekProvider(server.URL)
+ if err != nil {
+ t.Fatalf("NewDeepSeekProvider: %v", err)
+ }
+
+ ctx := schemas.NewBifrostContext(context.Background(), schemas.NoDeadline)
+ resp, bifrostErr := provider.Responses(ctx, schemas.Key{Value: schemas.SecretVar{Val: "test-api-key"}, UseAnthropicEndpoints: new(true)}, &schemas.BifrostResponsesRequest{
+ Provider: schemas.DeepSeek,
+ Model: "deepseek-v4-pro",
+ Input: []schemas.ResponsesMessage{{
+ Type: new(schemas.ResponsesMessageTypeMessage),
+ Role: new(schemas.ResponsesInputMessageRoleUser),
+ Content: &schemas.ResponsesMessageContent{
+ ContentStr: new("hello"),
+ },
+ }},
+ Params: &schemas.ResponsesParameters{
+ Tools: []schemas.ResponsesTool{{Type: schemas.ResponsesToolTypeWebSearch}},
+ },
+ })
+ if bifrostErr != nil {
+ t.Fatalf("Responses: %v", bifrostErr.Error.Message)
+ }
+ if resp == nil || len(resp.Output) == 0 {
+ t.Fatalf("expected responses payload, got %#v", resp)
+ }
+ tools, ok := captured["tools"].([]any)
+ if !ok || len(tools) == 0 {
+ t.Fatalf("outbound body missing tools: %#v", captured)
+ }
+ toolJSON, _ := json.Marshal(tools[0])
+ if !json.Valid(toolJSON) || !strings.Contains(string(toolJSON), "web_search") {
+ t.Fatalf("outbound tool body did not preserve web search: %s", toolJSON)
+ }
+}
+
+func TestChatCompletion_DisablesThinkingForForcedToolChoice(t *testing.T) {
+ t.Parallel()
+
+ var captured map[string]any
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ body, err := io.ReadAll(r.Body)
+ if err != nil {
+ t.Fatalf("read body: %v", err)
+ }
+ if err := json.Unmarshal(body, &captured); err != nil {
+ t.Fatalf("decode body: %v", err)
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ fmt.Fprint(w, newAnthropicResponse())
+ }))
+ defer server.Close()
+
+ provider, err := newTestDeepSeekProvider(server.URL)
+ if err != nil {
+ t.Fatalf("NewDeepSeekProvider: %v", err)
+ }
+
+ chatTool := llmtests.GetSampleChatTool(llmtests.SampleToolTypeTime)
+ if chatTool == nil {
+ t.Fatal("GetSampleChatTool returned nil")
+ }
+
+ ctx := schemas.NewBifrostContext(context.Background(), schemas.NoDeadline)
+ msg := "get the current time in UTC"
+ _, bifrostErr := provider.ChatCompletion(ctx, schemas.Key{Value: schemas.SecretVar{Val: "test-api-key"}, UseAnthropicEndpoints: new(true)}, &schemas.BifrostChatRequest{
+ Provider: schemas.DeepSeek,
+ Model: "deepseek-v4-flash",
+ Input: []schemas.ChatMessage{{
+ Role: schemas.ChatMessageRoleUser,
+ Content: &schemas.ChatMessageContent{ContentStr: &msg},
+ }},
+ Params: &schemas.ChatParameters{
+ Tools: []schemas.ChatTool{*chatTool},
+ ToolChoice: &schemas.ChatToolChoice{
+ ChatToolChoiceStruct: &schemas.ChatToolChoiceStruct{
+ Type: schemas.ChatToolChoiceTypeFunction,
+ Function: &schemas.ChatToolChoiceFunction{
+ Name: string(llmtests.SampleToolTypeTime),
+ },
+ },
+ },
+ },
+ })
+ if bifrostErr != nil {
+ t.Fatalf("ChatCompletion: %v", bifrostErr.Error.Message)
+ }
+
+ thinking, ok := captured["thinking"].(map[string]any)
+ if !ok {
+ t.Fatalf("expected thinking block in outbound body, got %#v", captured)
+ }
+ if got := thinking["type"]; got != "disabled" {
+ t.Fatalf("thinking.type = %v, want disabled", got)
+ }
+}
+
+func TestResponses_DisablesThinkingForForcedToolChoice(t *testing.T) {
+ t.Parallel()
+
+ var captured map[string]any
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ body, err := io.ReadAll(r.Body)
+ if err != nil {
+ t.Fatalf("read body: %v", err)
+ }
+ if err := json.Unmarshal(body, &captured); err != nil {
+ t.Fatalf("decode body: %v", err)
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ fmt.Fprint(w, newAnthropicResponse())
+ }))
+ defer server.Close()
+
+ provider, err := newTestDeepSeekProvider(server.URL)
+ if err != nil {
+ t.Fatalf("NewDeepSeekProvider: %v", err)
+ }
+
+ responsesTool := llmtests.GetSampleResponsesTool(llmtests.SampleToolTypeTime)
+ if responsesTool == nil {
+ t.Fatal("GetSampleResponsesTool returned nil")
+ }
+
+ ctx := schemas.NewBifrostContext(context.Background(), schemas.NoDeadline)
+ _, bifrostErr := provider.Responses(ctx, schemas.Key{Value: schemas.SecretVar{Val: "test-api-key"}, UseAnthropicEndpoints: new(true)}, &schemas.BifrostResponsesRequest{
+ Provider: schemas.DeepSeek,
+ Model: "deepseek-v4-pro",
+ Input: []schemas.ResponsesMessage{{
+ Type: new(schemas.ResponsesMessageTypeMessage),
+ Role: new(schemas.ResponsesInputMessageRoleUser),
+ Content: &schemas.ResponsesMessageContent{
+ ContentStr: new("get the current time in UTC"),
+ },
+ }},
+ Params: &schemas.ResponsesParameters{
+ Tools: []schemas.ResponsesTool{*responsesTool},
+ ToolChoice: &schemas.ResponsesToolChoice{
+ ResponsesToolChoiceStruct: &schemas.ResponsesToolChoiceStruct{
+ Type: schemas.ResponsesToolChoiceTypeFunction,
+ Name: new(string(llmtests.SampleToolTypeTime)),
+ },
+ },
+ },
+ })
+ if bifrostErr != nil {
+ t.Fatalf("Responses: %v", bifrostErr.Error.Message)
+ }
+
+ thinking, ok := captured["thinking"].(map[string]any)
+ if !ok {
+ t.Fatalf("expected thinking block in outbound body, got %#v", captured)
+ }
+ if got := thinking["type"]; got != "disabled" {
+ t.Fatalf("thinking.type = %v, want disabled", got)
+ }
+}
+
+func TestChatCompletion_DefaultsToOpenAIEndpoint(t *testing.T) {
+ t.Parallel()
+
+ var capturedPath string
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ capturedPath = r.URL.Path
+ if got := r.Header.Get("Authorization"); got != "Bearer test-api-key" {
+ t.Fatalf("Authorization = %q, want Bearer test-api-key", got)
+ }
+ w.Header().Set("Content-Type", "application/json")
+ fmt.Fprint(w, `{"id":"chatcmpl_1","object":"chat.completion","model":"deepseek-v4-flash","choices":[{"index":0,"message":{"role":"assistant","content":"hello"},"finish_reason":"stop"}],"usage":{"prompt_tokens":1,"completion_tokens":1,"total_tokens":2}}`)
+ }))
+ defer server.Close()
+
+ provider, err := newTestDeepSeekProvider(server.URL)
+ if err != nil {
+ t.Fatalf("NewDeepSeekProvider: %v", err)
+ }
+
+ ctx := schemas.NewBifrostContext(context.Background(), schemas.NoDeadline)
+ msg := "hello"
+ resp, bifrostErr := provider.ChatCompletion(ctx, schemas.Key{Value: schemas.SecretVar{Val: "test-api-key"}}, &schemas.BifrostChatRequest{
+ Provider: schemas.DeepSeek,
+ Model: "deepseek-v4-flash",
+ Input: []schemas.ChatMessage{{
+ Role: schemas.ChatMessageRoleUser,
+ Content: &schemas.ChatMessageContent{ContentStr: &msg},
+ }},
+ })
+ if bifrostErr != nil {
+ t.Fatalf("ChatCompletion: %v", bifrostErr.Error.Message)
+ }
+ if resp == nil || len(resp.Choices) == 0 {
+ t.Fatalf("expected chat response, got %#v", resp)
+ }
+ if capturedPath != "/chat/completions" {
+ t.Fatalf("path = %q, want /chat/completions", capturedPath)
+ }
+}
+
+func TestChatCompletion_OpenAIEndpointDisablesThinkingForRequiredToolChoice(t *testing.T) {
+ t.Parallel()
+
+ var captured map[string]any
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ body, err := io.ReadAll(r.Body)
+ if err != nil {
+ t.Fatalf("read body: %v", err)
+ }
+ if err := json.Unmarshal(body, &captured); err != nil {
+ t.Fatalf("decode body: %v", err)
+ }
+ w.Header().Set("Content-Type", "application/json")
+ fmt.Fprint(w, `{"id":"chatcmpl_1","object":"chat.completion","model":"deepseek-v4-flash","choices":[{"index":0,"message":{"role":"assistant","content":"hello"},"finish_reason":"stop"}],"usage":{"prompt_tokens":1,"completion_tokens":1,"total_tokens":2}}`)
+ }))
+ defer server.Close()
+
+ provider, err := newTestDeepSeekProvider(server.URL)
+ if err != nil {
+ t.Fatalf("NewDeepSeekProvider: %v", err)
+ }
+
+ chatTool := llmtests.GetSampleChatTool(llmtests.SampleToolTypeTime)
+ if chatTool == nil {
+ t.Fatal("GetSampleChatTool returned nil")
+ }
+
+ ctx := schemas.NewBifrostContext(context.Background(), schemas.NoDeadline)
+ msg := "get the current time in UTC"
+ requiredChoice := string(schemas.ChatToolChoiceTypeRequired)
+ _, bifrostErr := provider.ChatCompletion(ctx, schemas.Key{Value: schemas.SecretVar{Val: "test-api-key"}}, &schemas.BifrostChatRequest{
+ Provider: schemas.DeepSeek,
+ Model: "deepseek-v4-flash",
+ Input: []schemas.ChatMessage{{
+ Role: schemas.ChatMessageRoleUser,
+ Content: &schemas.ChatMessageContent{ContentStr: &msg},
+ }},
+ Params: &schemas.ChatParameters{
+ Tools: []schemas.ChatTool{*chatTool},
+ ToolChoice: &schemas.ChatToolChoice{
+ ChatToolChoiceStr: &requiredChoice,
+ },
+ },
+ })
+ if bifrostErr != nil {
+ t.Fatalf("ChatCompletion: %v", bifrostErr.Error.Message)
+ }
+
+ thinking, ok := captured["thinking"].(map[string]any)
+ if !ok {
+ t.Fatalf("expected thinking block in outbound body, got %#v", captured)
+ }
+ if got := thinking["type"]; got != "disabled" {
+ t.Fatalf("thinking.type = %v, want disabled", got)
+ }
+}
diff --git a/core/providers/deepseek/deepseek_test.go b/core/providers/deepseek/deepseek_test.go
index 76d173cbf23..38f07628b4f 100644
--- a/core/providers/deepseek/deepseek_test.go
+++ b/core/providers/deepseek/deepseek_test.go
@@ -34,27 +34,28 @@ func TestDeepseek(t *testing.T) {
EmbeddingModel: "", // DeepSeek doesn't support embedding
ReasoningModel: "deepseek-v4-pro",
Scenarios: llmtests.TestScenarios{
- TextCompletion: true,
- TextCompletionStream: true,
- SimpleChat: true,
- CompletionStream: true,
- MultiTurnConversation: true,
- ToolCalls: true,
- ToolCallsStreaming: true,
- MultipleToolCalls: false,
- End2EndToolCalling: true,
- AutomaticFunctionCall: true,
- ImageURL: false,
- ImageBase64: false,
- MultipleImages: false,
- CompleteEnd2End: true,
- Embedding: false,
- ListModels: true,
- Reasoning: true,
+ TextCompletion: true,
+ TextCompletionStream: true,
+ SimpleChat: true,
+ CompletionStream: true,
+ MultiTurnConversation: true,
+ ToolCalls: true,
+ ToolCallsStreaming: true,
+ MultipleToolCalls: true,
+ MultipleToolCallsStreaming: true,
+ End2EndToolCalling: true,
+ AutomaticFunctionCall: true,
+ ImageURL: false,
+ ImageBase64: false,
+ MultipleImages: false,
+ CompleteEnd2End: true,
+ Embedding: false,
+ ListModels: true,
+ Reasoning: true,
},
}
t.Run("DeepSeekTests", func(t *testing.T) {
llmtests.RunAllComprehensiveTests(t, client, ctx, testConfig)
})
-}
+}
\ No newline at end of file
diff --git a/plugins/compat/conversion.go b/plugins/compat/conversion.go
index 80932405870..7ea01ae03a1 100644
--- a/plugins/compat/conversion.go
+++ b/plugins/compat/conversion.go
@@ -11,45 +11,7 @@ func applyParameterConversion(req *schemas.BifrostRequest) {
}
if req.ResponsesRequest != nil {
flattenNamespaceTools(req.ResponsesRequest)
- disableThinkingWithToolChoiceForResponses(req.ResponsesRequest)
}
- if req.ChatRequest != nil {
- disableThinkingWithToolChoice(req.ChatRequest)
- }
-}
-
-// disableThinkingWithToolChoice disables thinking when tool_choice forces a tool call.
-func disableThinkingWithToolChoice(req *schemas.BifrostChatRequest) {
- if req.Provider != schemas.DeepSeek || req.Params == nil || req.Params.ToolChoice == nil {
- return
- }
- tc := req.Params.ToolChoice
- if tc.ChatToolChoiceStr != nil && *tc.ChatToolChoiceStr == string(schemas.ChatToolChoiceTypeRequired) {
- req.Params.ExtraParams = disableThinking(req.Params.ExtraParams)
- }
-}
-
-// disableThinkingWithToolChoiceForResponses disables thinking when tool_choice forces a tool call.
-func disableThinkingWithToolChoiceForResponses(req *schemas.BifrostResponsesRequest) {
- if req.Provider != schemas.DeepSeek || req.Params == nil || req.Params.ToolChoice == nil {
- return
- }
- tc := req.Params.ToolChoice
- if tc.ResponsesToolChoiceStr != nil && *tc.ResponsesToolChoiceStr == string(schemas.ResponsesToolChoiceTypeRequired) {
- req.Params.ExtraParams = disableThinking(req.Params.ExtraParams)
- }
-}
-
-// disableThinking sets thinking {"type": "disabled"} in extraParams, overwriting
-// any caller-provided value. DeepSeek models run with thinking enabled by default,
-// and thinking mode rejects forced tool_choice — so a forced tool call requires
-// thinking off.
-func disableThinking(extraParams map[string]any) map[string]any {
- if extraParams == nil {
- extraParams = make(map[string]any, 1)
- }
- extraParams["thinking"] = map[string]any{"type": "disabled"}
- return extraParams
}
// flattenNamespaceTools expands namespace scoped tools into a flat list of tools.