fix(llm): map thinking enabled/disabled per provider instead of always sending the Anthropic object

The thinking object ({"type":"enabled"/"disabled"}) was sent
unconditionally; OpenAI rejects unknown top-level parameters with a
400, so thinking: disabled (and enabled) was broken against OpenAI —
same family as the system-field bug fixed earlier in this branch.

The shaping logic now lives in an extracted, directly testable
buildCallParams method:

- Anthropic/DeepSeek (new sendsThinkingObject gate): unchanged,
  thinking object sent as before.
- OpenAI reasoning models (o1/o3/o4, gpt-5 series): enabled maps to
  reasoning_effort "high", disabled to "none" (verified accepted on
  the gpt-5 series); temperature stays omitted per the forbidlist.
- Non-reasoning models (e.g. gpt-4o): no thinking capability exists,
  so both fields are omitted and temperature is honored as configured.

The two existing thinking tests asserted the old unconditional
behavior through an httptest server whose URL is never a recognized
provider; they now exercise buildCallParams directly. New table test
TestBuildCallParams_ThinkingMapping covers all provider/model/thinking
combinations.

Author: jkyberneees

internal/llm/client.go

@@ -68,6 +68,15 @@ func (c *Client) IsAnthropic() bool {
 	return strings.Contains(c.BaseURL, "anthropic")
 }
 
+// sendsThinkingObject reports whether the provider accepts the
+// Anthropic-style "thinking" request object. Anthropic requires it for
+// extended thinking and DeepSeek supports it natively (deepseek-reasoner);
+// other providers (OpenAI and compatibles) reject unknown top-level
+// parameters, so thinking intent must be mapped to reasoning_effort instead.
+func (c *Client) sendsThinkingObject() bool {
+	return c.IsAnthropic() || strings.Contains(c.BaseURL, "deepseek")
+}
+
 // modelForbidsTemperature reports whether the model rejects an explicit
 // temperature parameter. OpenAI reasoning models (o1/o3/o4 families and the
 // gpt-5 series) only accept the default temperature (1); sending any other
@@ -272,12 +281,11 @@ func (c *Client) SimpleCall(ctx context.Context, systemPrompt, userPrompt string
 	return raw.Choices[0].Message.Content, nil
 }
 
-// Call sends a chat completion request and returns the result.
-// systemBlocks is optional — pass nil for providers that don't support
-// the separate System field (OpenAI, DeepSeek). When non-nil, the system
-// prompt is sent in the "system" field instead of as a system message in
-// the messages array (Anthropic format for prompt caching).
-func (c *Client) Call(ctx context.Context, messages []Message, systemBlocks []SystemBlock, tools []ToolDef) (*CallResult, error) {
+// buildCallParams assembles the request body for a Call, mapping the
+// thinking configuration onto whatever shape the target provider accepts:
+// the Anthropic-style "thinking" object for Anthropic/DeepSeek,
+// reasoning_effort for OpenAI reasoning models, and nothing otherwise.
+func (c *Client) buildCallParams(messages []Message, systemBlocks []SystemBlock, tools []ToolDef) CallParams {
 	body := CallParams{
 		Model:     c.Model,
 		Messages:  messages,
@@ -289,21 +297,39 @@ func (c *Client) Call(ctx context.Context, messages []Message, systemBlocks []Sy
 
 	switch c.Thinking {
 	case "enabled":
-		// Anthropic requires budget_tokens when enabling thinking.
-		// 5000 is a safe default: leaves ample room for the text response
-		// even on models with 8K max output (e.g. Claude Haiku).
-		// DeepSeek silently ignores the field.
-		budget := c.ThinkingBudget
-		if budget <= 0 {
-			budget = 5000
+		if c.sendsThinkingObject() {
+			// Anthropic requires budget_tokens when enabling thinking.
+			// 5000 is a safe default: leaves ample room for the text response
+			// even on models with 8K max output (e.g. Claude Haiku).
+			// DeepSeek silently ignores the field.
+			budget := c.ThinkingBudget
+			if budget <= 0 {
+				budget = 5000
+			}
+			body.Thinking = &ThinkingConfig{Type: "enabled", BudgetTokens: budget}
+			// Anthropic also requires temperature=1 when thinking is enabled.
+			// Force it regardless of the configured temperature to avoid a 400.
+			one := float64(1)
+			body.Temperature = &one
+		} else if modelForbidsTemperature(c.Model) {
+			// OpenAI reasoning models have no "thinking" object; the closest
+			// mapping for enabled extended thinking is maximum effort.
+			// Temperature stays omitted — only the provider default is accepted.
+			body.ReasoningEffort = "high"
+		} else if c.Temperature >= 0 {
+			// Non-reasoning models (e.g. gpt-4o) have no thinking to enable;
+			// just honor the configured temperature.
+			body.Temperature = &c.Temperature
 		}
-		body.Thinking = &ThinkingConfig{Type: "enabled", BudgetTokens: budget}
-		// Anthropic also requires temperature=1 when thinking is enabled.
-		// Force it regardless of the configured temperature to avoid a 400.
-		one := float64(1)
-		body.Temperature = &one
 	case "disabled":
-		body.Thinking = &ThinkingConfig{Type: "disabled"}
+		if c.sendsThinkingObject() {
+			body.Thinking = &ThinkingConfig{Type: "disabled"}
+		} else if modelForbidsTemperature(c.Model) {
+			// OpenAI reasoning models: disabling thinking maps to effort
+			// "none" (accepted on the gpt-5 series). Non-reasoning models
+			// have nothing to disable, so the field is omitted entirely.
+			body.ReasoningEffort = "none"
+		}
 		if c.Temperature >= 0 && !modelForbidsTemperature(c.Model) {
 			body.Temperature = &c.Temperature
 		}
@@ -320,11 +346,22 @@ func (c *Client) Call(ctx context.Context, messages []Message, systemBlocks []Sy
 	// any reasoning_effort other than "none" on /chat/completions — and
 	// their DEFAULT effort is not "none", so merely omitting the field is
 	// not enough. Once that constraint has been learned from a 400 (see
-	// below), pin effort to "none" whenever tools are present.
+	// Call), pin effort to "none" whenever tools are present.
 	if c.forceNoneEffort.Load() && len(tools) > 0 {
 		body.ReasoningEffort = "none"
 	}
 
+	return body
+}
+
+// Call sends a chat completion request and returns the result.
+// systemBlocks is optional — pass nil for providers that don't support
+// the separate System field (OpenAI, DeepSeek). When non-nil, the system
+// prompt is sent in the "system" field instead of as a system message in
+// the messages array (Anthropic format for prompt caching).
+func (c *Client) Call(ctx context.Context, messages []Message, systemBlocks []SystemBlock, tools []ToolDef) (*CallResult, error) {
+	body := c.buildCallParams(messages, systemBlocks, tools)
+
 	reqBytes, err := json.Marshal(body)
 	if err != nil {
 		return nil, fmt.Errorf("llm: marshal request: %w", err)

internal/llm/client_test.go

@@ -409,30 +409,11 @@ func TestClient_Call_HTTPError(t *testing.T) {
 }
 
 func TestClient_Call_WithThinking(t *testing.T) {
-	var receivedBody map[string]any
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		json.NewDecoder(r.Body).Decode(&receivedBody)
-		w.Header().Set("Content-Type", "application/json")
-		w.Write([]byte(`{"choices":[{"message":{"content":"thinking response"}}]}`))
-	}))
-	defer server.Close()
-
-	c := New(server.URL, "sk-test", "deepseek-chat", "enabled", 0, 0)
-	result, err := c.Call(context.Background(), []Message{{Role: "user", Content: "think"}}, nil, nil)
-	if err != nil {
-		t.Fatalf("Call() error: %v", err)
-	}
-	if result.Content != "thinking response" {
-		t.Errorf("Content = %q", result.Content)
-	}
-	// Verify thinking was sent in the request
-	thinking, ok := receivedBody["thinking"]
-	if !ok {
-		t.Error("thinking field not sent in request")
-	}
-	thinkingMap, ok := thinking.(map[string]any)
-	if !ok || thinkingMap["type"] != "enabled" {
-		t.Errorf("thinking = %v, want {type: enabled}", thinking)
+	// DeepSeek supports the Anthropic-style thinking object natively.
+	c := New("https://api.deepseek.com/v1", "sk-test", "deepseek-chat", "enabled", 0, 0)
+	body := c.buildCallParams([]Message{{Role: "user", Content: "think"}}, nil, nil)
+	if body.Thinking == nil || body.Thinking.Type != "enabled" {
+		t.Errorf("thinking = %v, want {type: enabled}", body.Thinking)
 	}
 }
 
@@ -723,29 +704,14 @@ func TestClient_Call_FlashVsProThinkingContrast(t *testing.T) {
 	})
 
 	t.Run("pro_thinking_enabled", func(t *testing.T) {
-		var body map[string]any
-		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			json.NewDecoder(r.Body).Decode(&body)
-			w.Header().Set("Content-Type", "application/json")
-			w.Write([]byte(`{"choices":[{"message":{"content":"ok"}}]}`))
-		}))
-		defer server.Close()
-
-		c := New(server.URL, "sk-test", "deepseek-v4-pro", "enabled", 0, 0)
-		_, err := c.Call(context.Background(), []Message{{Role: "user", Content: "hi"}}, nil, nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-		thinking, ok := body["thinking"]
-		if !ok {
+		// DeepSeek supports the Anthropic-style thinking object natively.
+		c := New("https://api.deepseek.com/v1", "sk-test", "deepseek-v4-pro", "enabled", 0, 0)
+		body := c.buildCallParams([]Message{{Role: "user", Content: "hi"}}, nil, nil)
+		if body.Thinking == nil {
 			t.Fatal("Pro: thinking field should be present")
 		}
-		thinkingMap, ok := thinking.(map[string]any)
-		if !ok {
-			t.Fatal("Pro: thinking should be an object")
-		}
-		if thinkingMap["type"] != "enabled" {
-			t.Errorf("Pro: thinking.type = %v, want 'enabled'", thinkingMap["type"])
+		if body.Thinking.Type != "enabled" {
+			t.Errorf("Pro: thinking.type = %v, want 'enabled'", body.Thinking.Type)
 		}
 	})
 }
@@ -1182,3 +1148,46 @@ func TestCall_LearnsReasoningEffortNoneWithTools(t *testing.T) {
 		}
 	}
 }
+
+// The thinking configuration must be mapped onto the shape each provider
+// accepts: the Anthropic-style "thinking" object for Anthropic/DeepSeek,
+// reasoning_effort for OpenAI reasoning models, and nothing otherwise —
+// OpenAI rejects unknown top-level parameters with a 400.
+func TestBuildCallParams_ThinkingMapping(t *testing.T) {
+	cases := []struct {
+		name         string
+		baseURL      string
+		model        string
+		thinking     string
+		wantThinking string // "" = no thinking object
+		wantEffort   string // "" = no reasoning_effort
+	}{
+		{"deepseek enabled", "https://api.deepseek.com/v1", "deepseek-chat", "enabled", "enabled", ""},
+		{"deepseek disabled", "https://api.deepseek.com/v1", "deepseek-chat", "disabled", "disabled", ""},
+		{"anthropic enabled", "https://api.anthropic.com/v1", "claude-sonnet-4-5", "enabled", "enabled", ""},
+		{"anthropic disabled", "https://api.anthropic.com/v1", "claude-sonnet-4-5", "disabled", "disabled", ""},
+		{"openai reasoning disabled", "https://api.openai.com/v1", "gpt-5-nano", "disabled", "", "none"},
+		{"openai reasoning enabled", "https://api.openai.com/v1", "gpt-5.6-luna", "enabled", "", "high"},
+		{"openai reasoning effort passthrough", "https://api.openai.com/v1", "gpt-5-nano", "medium", "", "medium"},
+		{"openai non-reasoning disabled", "https://api.openai.com/v1", "gpt-4o-mini", "disabled", "", ""},
+		{"openai non-reasoning enabled", "https://api.openai.com/v1", "gpt-4o-mini", "enabled", "", ""},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			c := New(tc.baseURL, "sk-test", tc.model, tc.thinking, 0, 0)
+			body := c.buildCallParams([]Message{{Role: "user", Content: "hi"}}, nil, nil)
+
+			gotThinking := ""
+			if body.Thinking != nil {
+				gotThinking = body.Thinking.Type
+			}
+			if gotThinking != tc.wantThinking {
+				t.Errorf("thinking object = %q, want %q", gotThinking, tc.wantThinking)
+			}
+			if body.ReasoningEffort != tc.wantEffort {
+				t.Errorf("reasoning_effort = %q, want %q", body.ReasoningEffort, tc.wantEffort)
+			}
+		})
+	}
+}