llms/ollama: send think as top-level field so WithThink works

The think flag was serialized inside the "options" object, but the Ollama
API defines it as a top-level field of the /api/chat and /api/generate
requests. Unknown keys inside "options" are ignored by the server, so
WithThink(true) had no effect. Additionally, omitempty on a plain bool
dropped WithThink(false) entirely, making it impossible to disable
thinking on models (qwen3, deepseek-r1, ...) that reason by default.

Move Think out of Options onto ChatRequest and GenerateRequest as a
*bool, populate it from the WithThink option and the thinking_config
metadata via a resolveThink helper, and update the recorded httprr
fixtures to the corrected wire format.

Fixes #1514

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: yyyCode

llms/ollama/internal/ollamaclient/ollamaclient_test.go

@@ -310,10 +310,10 @@ func TestClient_GenerateChatWithThink(t *testing.T) {
 			},
 		},
 		Stream: false,
+		Think:  boolPtr(true), // Enable reasoning mode (top-level per Ollama API)
 		Options: Options{
 			Temperature: 0.0,
 			NumPredict:  100,
-			Think:       true, // Enable reasoning mode
 		},
 	}
 
@@ -332,28 +332,63 @@ func TestClient_GenerateChatWithThink(t *testing.T) {
 	// This test verifies that the parameter is properly serialized
 }
 
-func TestOptionsJSONMarshalWithThink(t *testing.T) {
-	// Test that the think parameter is properly marshaled to JSON
-	opts := Options{
-		Temperature: 0.5,
-		Think:       true,
-	}
+func TestChatRequestJSONMarshalWithThink(t *testing.T) {
+	// The Ollama API defines "think" as a top-level field of the chat request,
+	// not as part of "options". See https://github.com/tmc/langchaingo/issues/1514.
+	t.Run("think true is top-level", func(t *testing.T) {
+		req := ChatRequest{
+			Model: "qwen3",
+			Think: boolPtr(true),
+			Options: Options{
+				Temperature: 0.5,
+			},
+		}
 
-	data, err := json.Marshal(opts)
-	require.NoError(t, err)
+		data, err := json.Marshal(req)
+		require.NoError(t, err)
 
-	// Check that the JSON contains the think field
-	var result map[string]interface{}
-	err = json.Unmarshal(data, &result)
-	require.NoError(t, err)
+		var result map[string]any
+		require.NoError(t, json.Unmarshal(data, &result))
+
+		think, exists := result["think"]
+		assert.True(t, exists, "think field should exist at the top level")
+		assert.Equal(t, true, think, "think field should be true")
+
+		// think must not leak into the nested options object.
+		opts, ok := result["options"].(map[string]any)
+		require.True(t, ok, "options object should be present")
+		_, thinkInOptions := opts["think"]
+		assert.False(t, thinkInOptions, "think must not be nested inside options")
+	})
+
+	t.Run("think false is preserved", func(t *testing.T) {
+		// A plain bool with omitempty would drop false; the pointer keeps it so
+		// callers can explicitly disable thinking on models that think by default.
+		req := ChatRequest{Model: "qwen3", Think: boolPtr(false)}
 
-	// Verify think field exists and is true
-	think, exists := result["think"]
-	assert.True(t, exists, "think field should exist in JSON")
-	assert.Equal(t, true, think, "think field should be true")
+		data, err := json.Marshal(req)
+		require.NoError(t, err)
 
-	// Verify temperature field for completeness
-	temp, exists := result["temperature"]
-	assert.True(t, exists, "temperature field should exist in JSON")
-	assert.Equal(t, float64(0.5), temp, "temperature should be 0.5")
+		var result map[string]any
+		require.NoError(t, json.Unmarshal(data, &result))
+
+		think, exists := result["think"]
+		assert.True(t, exists, "explicit false think field should be preserved")
+		assert.Equal(t, false, think, "think field should be false")
+	})
+
+	t.Run("think unset is omitted", func(t *testing.T) {
+		req := ChatRequest{Model: "qwen3"}
+
+		data, err := json.Marshal(req)
+		require.NoError(t, err)
+
+		var result map[string]any
+		require.NoError(t, json.Unmarshal(data, &result))
+
+		_, exists := result["think"]
+		assert.False(t, exists, "unset think field should be omitted")
+	})
 }
+
+func boolPtr(b bool) *bool { return &b }

llms/ollama/internal/ollamaclient/testdata/TestClient_GenerateChatWithThink.httprr

@@ -34,6 +34,10 @@ type GenerateRequest struct {
 	Context   []int  `json:"context,omitempty"`
 	Stream    *bool  `json:"stream"`
 	KeepAlive string `json:"keep_alive,omitempty"`
+	// Think enables reasoning mode (Ollama 0.9.0+). It is a top-level field per
+	// the Ollama API, not part of Options. A nil pointer omits the field, so an
+	// explicit false (disable thinking) is distinguishable from "unset".
+	Think *bool `json:"think,omitempty"`
 
 	Options Options `json:"options"`
 }
@@ -52,6 +56,10 @@ type ChatRequest struct {
 	Stream    bool       `json:"stream,omitempty"`
 	Format    string     `json:"format"`
 	KeepAlive string     `json:"keep_alive,omitempty"`
+	// Think enables reasoning mode (Ollama 0.9.0+). It is a top-level field per
+	// the Ollama API, not part of Options. A nil pointer omits the field, so an
+	// explicit false (disable thinking) is distinguishable from "unset".
+	Think *bool `json:"think,omitempty"`
 
 	Options Options `json:"options"`
 }
@@ -167,7 +175,6 @@ type Options struct {
 	MirostatEta      float32 `json:"mirostat_eta,omitempty"`
 	TopP             float32 `json:"top_p,omitempty"`
 	PenalizeNewline  bool    `json:"penalize_newline,omitempty"`
-	Think            bool    `json:"think,omitempty"` // Ollama 0.9.0+ reasoning mode
 }
 
 type PullRequest struct {

llms/ollama/internal/ollamaclient/types.go

@@ -146,21 +146,18 @@ func (o *LLM) GenerateContent(ctx context.Context, messages []llms.MessageConten
 	// Get our ollamaOptions from llms.CallOptions
 	ollamaOptions := makeOllamaOptionsFromOptions(o.options.ollamaOptions, opts)
 
-	// Handle thinking mode if specified via metadata
-	if opts.Metadata != nil {
-		if config, ok := opts.Metadata["thinking_config"].(*llms.ThinkingConfig); ok {
-			if config.Mode != llms.ThinkingModeNone && o.SupportsReasoning() {
-				// Enable thinking for models that support it
-				ollamaOptions.Think = true
-			}
-		}
-	}
+	// Resolve the reasoning-mode flag. It is sent as a top-level field per the
+	// Ollama API (not inside options), and uses a pointer so an explicit false
+	// (disable thinking) is distinguishable from "unset".
+	think := resolveThink(o.options.think, opts)
+
 	req := &ollamaclient.ChatRequest{
 		Model:    model,
 		Format:   format,
 		Messages: chatMsgs,
 		Options:  ollamaOptions,
 		Stream:   opts.StreamingFunc != nil,
+		Think:    think,
 	}
 
 	keepAlive := o.options.keepAlive
@@ -231,7 +228,7 @@ func (o *LLM) GenerateContent(ctx context.Context, messages []llms.MessageConten
 
 	// Note: Ollama may include thinking in the main content when Think mode is enabled
 	// Future versions may provide separate thinking content
-	if ollamaOptions.Think && o.SupportsReasoning() {
+	if think != nil && *think && o.SupportsReasoning() {
 		genInfo["ThinkingEnabled"] = true
 	}
 
@@ -319,17 +316,21 @@ func makeOllamaOptionsFromOptions(ollamaOptions ollamaclient.Options, opts llms.
 	ollamaOptions.FrequencyPenalty = float32(opts.FrequencyPenalty)
 	ollamaOptions.PresencePenalty = float32(opts.PresencePenalty)
 
-	// Extract thinking configuration for models that support it
+	return ollamaOptions
+}
+
+// resolveThink determines the value of the top-level Ollama "think" field.
+// Per-call thinking configuration (via WithThinkingMode / the "thinking_config"
+// metadata) takes precedence over the client-level WithThink option. A nil
+// result omits the field entirely, leaving the server default in place.
+func resolveThink(clientThink *bool, opts llms.CallOptions) *bool {
 	if opts.Metadata != nil {
 		if config, ok := opts.Metadata["thinking_config"].(*llms.ThinkingConfig); ok {
-			// Enable thinking mode if not explicitly disabled
-			if config.Mode != llms.ThinkingModeNone {
-				ollamaOptions.Think = true
-			}
+			think := config.Mode != llms.ThinkingModeNone
+			return &think
 		}
 	}
-
-	return ollamaOptions
+	return clientThink
 }
 
 // pullModelIfNeeded pulls the model if it's not already available.

llms/ollama/ollamallm.go

@@ -20,6 +20,9 @@ type options struct {
 	keepAlive           string
 	pullModel           bool
 	pullTimeout         time.Duration
+	// think is the reasoning-mode flag sent as a top-level field to the Ollama
+	// API. A nil pointer leaves it unset so an explicit false is distinguishable.
+	think *bool
 }
 
 type Option func(*options)
@@ -268,11 +271,14 @@ func WithPredictPenalizeNewline(val bool) Option {
 	}
 }
 
-// WithThink enables reasoning mode for models that support it (Ollama 0.9.0+).
-// When enabled, the model will show its internal reasoning process.
+// WithThink enables or disables reasoning mode for models that support it
+// (Ollama 0.9.0+). When enabled, the model will show its internal reasoning
+// process. Passing false explicitly disables thinking for models (such as
+// qwen3 or deepseek-r1) that think by default. The flag is sent as a top-level
+// field to the Ollama API.
 func WithThink(val bool) Option {
 	return func(opts *options) {
-		opts.ollamaOptions.Think = val
+		opts.think = &val
 	}
 }