Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(deepseek): validate and normalize thinking effort (#21852)

adws0c129858fb5c
diff --git a/internal/entity/models/deepseek.go b/internal/entity/models/deepseek.go
index 58e326af2b..945cc5eae2 100644
--- a/internal/entity/models/deepseek.go
+++ b/internal/entity/models/deepseek.go
@@ -99,36 +99,8 @@ func (d *DeepSeekModel) ChatWithMessages(ctx context.Context, modelName string,
}
reqBody := buildRequestBody(chatModelConfig, modelName, messages, false)
- if chatModelConfig != nil && chatModelConfig.Thinking != nil && *chatModelConfig.Thinking {
- var thinkingFlag string
- effort := "high"
- if chatModelConfig.Effort != nil {
- effort = *chatModelConfig.Effort
- }
- switch effort {
- case "none":
- thinkingFlag = "disabled"
- case "low":
- thinkingFlag = "disabled"
- case "medium":
- thinkingFlag = "disabled"
- case "high":
- thinkingFlag = "enabled"
- reqBody["reasoning_effort"] = "high"
- case "default":
- thinkingFlag = "enabled"
- reqBody["reasoning_effort"] = "high"
- case "max":
- thinkingFlag = "enabled"
- reqBody["reasoning_effort"] = "max"
- }
- reqBody["thinking"] = map[string]interface{}{
- "type": thinkingFlag,
- }
- } else {
- reqBody["thinking"] = map[string]interface{}{
- "type": "disabled",
- }
+ if err := applyDeepSeekThinkingConfig(reqBody, chatModelConfig); err != nil {
+ return nil, err
}
body, err := d.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)
@@ -155,38 +127,8 @@ func (d *DeepSeekModel) ChatStreamlyWithSender(ctx context.Context, modelName st
}
reqBody := buildRequestBody(chatModelConfig, modelName, messages, true)
- if chatModelConfig != nil && chatModelConfig.Thinking != nil && *chatModelConfig.Thinking {
- var thinkingFlag string
- effort := "high"
- if chatModelConfig.Effort != nil {
- effort = *chatModelConfig.Effort
- }
- switch effort {
- case "none":
- thinkingFlag = "disabled"
- case "low":
- thinkingFlag = "disabled"
- case "medium":
- thinkingFlag = "disabled"
- case "high":
- thinkingFlag = "enabled"
- reqBody["reasoning_effort"] = "high"
- case "default":
- thinkingFlag = "enabled"
- reqBody["reasoning_effort"] = "high"
- case "max":
- thinkingFlag = "enabled"
- reqBody["reasoning_effort"] = "max"
- default:
- return fmt.Errorf("invalid effort level")
- }
- reqBody["thinking"] = map[string]interface{}{
- "type": thinkingFlag,
- }
- } else {
- reqBody["thinking"] = map[string]interface{}{
- "type": "disabled",
- }
+ if err := applyDeepSeekThinkingConfig(reqBody, chatModelConfig); err != nil {
+ return err
}
// Request token usage in streaming response. DeepSeek only includes
@@ -198,6 +140,34 @@ func (d *DeepSeekModel) ChatStreamlyWithSender(ctx context.Context, modelName st
})
}
+func applyDeepSeekThinkingConfig(reqBody map[string]any, config *ChatConfig) error {
+ reqBody["thinking"] = map[string]any{"type": "disabled"}
+ if config == nil || config.Thinking == nil || !*config.Thinking {
+ return nil
+ }
+
+ effort := "high"
+ if config.Effort != nil {
+ effort = *config.Effort
+ }
+ switch effort {
+ case "none":
+ return nil
+ case "minimal", "low":
+ effort = "low"
+ case "medium", "high", "xhigh", "default":
+ effort = "high"
+ case "max", "ultra":
+ effort = "max"
+ default:
+ return fmt.Errorf("invalid effort level %q for DeepSeek", effort)
+ }
+
+ reqBody["thinking"] = map[string]any{"type": "enabled"}
+ reqBody["reasoning_effort"] = effort
+ return nil
+}
+
// Embed embeds a list of texts into embeddings
func (d *DeepSeekModel) Embed(ctx context.Context, modelName *string, request EmbedRequest, apiConfig *APIConfig, embeddingConfig *EmbeddingConfig, modelUsage *common.ModelUsage) ([]EmbeddingData, error) {
return nil, fmt.Errorf("%s, no such method", d.Name())
diff --git a/internal/entity/models/deepseek_test.go b/internal/entity/models/deepseek_test.go
index 34617cfbcf..5ef55d9235 100644
--- a/internal/entity/models/deepseek_test.go
+++ b/internal/entity/models/deepseek_test.go
@@ -2,8 +2,10 @@ package models
import (
"encoding/json"
+ "fmt"
"net/http"
"net/http/httptest"
+ "strings"
"testing"
)
@@ -167,3 +169,102 @@ func TestDeepSeekChatWithMessagesForwardsToolHistory(t *testing.T) {
t.Fatalf("tool_call_id=%#v, want call-1", toolMsg["tool_call_id"])
}
}
+
+func TestDeepSeekThinkingEffortPayload(t *testing.T) {
+ thinkingConfig := func(effort string) *ChatConfig {
+ return &ChatConfig{Thinking: boolPointer(true), Effort: &effort}
+ }
+ unsetThinkingConfig := thinkingConfig("low")
+ unsetThinkingConfig.Thinking = nil
+ disabledConfig := thinkingConfig("unknown")
+ disabledConfig.Thinking = boolPointer(false)
+ cases := []struct {
+ name string
+ config *ChatConfig
+ wantThinking string
+ wantEffort string
+ wantError bool
+ }{
+ {name: "nil config", wantThinking: "disabled"},
+ {name: "thinking unset", config: unsetThinkingConfig, wantThinking: "disabled"},
+ {name: "thinking disabled", config: &ChatConfig{Thinking: boolPointer(false)}, wantThinking: "disabled"},
+ {name: "disabled ignores effort", config: disabledConfig, wantThinking: "disabled"},
+ {name: "effort unset", config: &ChatConfig{Thinking: boolPointer(true)}, wantThinking: "enabled", wantEffort: "high"},
+ {name: "default", config: thinkingConfig("default"), wantThinking: "enabled", wantEffort: "high"},
+ {name: "none", config: thinkingConfig("none"), wantThinking: "disabled"},
+ {name: "minimal", config: thinkingConfig("minimal"), wantThinking: "enabled", wantEffort: "low"},
+ {name: "low", config: thinkingConfig("low"), wantThinking: "enabled", wantEffort: "low"},
+ {name: "medium", config: thinkingConfig("medium"), wantThinking: "enabled", wantEffort: "high"},
+ {name: "high", config: thinkingConfig("high"), wantThinking: "enabled", wantEffort: "high"},
+ {name: "xhigh", config: thinkingConfig("xhigh"), wantThinking: "enabled", wantEffort: "high"},
+ {name: "max", config: thinkingConfig("max"), wantThinking: "enabled", wantEffort: "max"},
+ {name: "ultra", config: thinkingConfig("ultra"), wantThinking: "enabled", wantEffort: "max"},
+ {name: "empty effort", config: thinkingConfig(""), wantError: true},
+ {name: "unknown effort", config: thinkingConfig("unknown"), wantError: true},
+ }
+
+ for _, stream := range []bool{false, true} {
+ for _, testCase := range cases {
+ t.Run(fmt.Sprintf("stream=%t/%s", stream, testCase.name), func(t *testing.T) {
+ requests := make(chan map[string]interface{}, 1)
+ server := newThinkingPayloadServer(t, requests)
+ defer server.Close()
+ driver := newDeepSeekForTest(server.URL)
+ driver.baseModel.httpClient = server.Client()
+
+ apiKey := "test-key"
+ apiConfig := &APIConfig{ApiKey: &apiKey}
+ messages := []Message{{Role: "user", Content: "hello"}}
+ var err error
+ if stream {
+ err = driver.ChatStreamlyWithSender(t.Context(), "deepseek-v4-pro", messages, apiConfig, testCase.config, nil, func(*string, *string) error { return nil })
+ } else {
+ var response *ChatResponse
+ response, err = driver.ChatWithMessages(t.Context(), "deepseek-v4-pro", messages, apiConfig, testCase.config, nil)
+ if testCase.wantError && response != nil {
+ t.Errorf("response=%+v, want nil for invalid effort", response)
+ }
+ }
+
+ if testCase.wantError {
+ if err == nil || !strings.Contains(err.Error(), "invalid effort level") {
+ t.Errorf("error=%v, want invalid effort level", err)
+ }
+ if len(requests) != 0 {
+ t.Error("invalid effort sent an HTTP request")
+ }
+ return
+ }
+ if err != nil {
+ t.Fatalf("chat: %v", err)
+ }
+
+ select {
+ case body := <-requests:
+ thinking, ok := body["thinking"].(map[string]interface{})
+ if !ok || thinking["type"] != testCase.wantThinking {
+ t.Errorf("thinking=%v, want type=%s", body["thinking"], testCase.wantThinking)
+ }
+ if testCase.wantEffort == "" {
+ if _, ok := body["reasoning_effort"]; ok {
+ t.Errorf("reasoning_effort=%v, want omitted", body["reasoning_effort"])
+ }
+ } else if body["reasoning_effort"] != testCase.wantEffort {
+ t.Errorf("reasoning_effort=%v, want %s", body["reasoning_effort"], testCase.wantEffort)
+ }
+ if body["stream"] != stream {
+ t.Errorf("stream=%v, want %t", body["stream"], stream)
+ }
+ if stream {
+ options, ok := body["stream_options"].(map[string]interface{})
+ if !ok || options["include_usage"] != true {
+ t.Errorf("stream_options=%v, want include_usage=true", body["stream_options"])
+ }
+ }
+ default:
+ t.Fatal("chat did not send an HTTP request")
+ }
+ })
+ }
+ }
+}