feat: native adaptive thinking for anthropic and bedrock

Add first-class adaptive thinking (Claude Opus 4.7+) alongside the existing
budget thinking. ReasoningConfig gains an Adaptive flag and the ReasoningEffort
enum gains xhigh/max; WithAdaptiveReasoning is the constructor. When adaptive,
the anthropic Messages request and the bedrock Converse additionalModelRequestFields
emit thinking.type=adaptive + a sibling output_config.effort (no token budget) and
omit temperature/top_p, which adaptive models reject. An empty effort defaults to
high. Budget thinking is unchanged. Network-free tests cover the adaptive wire shape
on both providers.

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

Author: sirozha

llms/anthropic/anthropicllm.go

@@ -162,10 +162,23 @@ func generateMessagesContent(ctx context.Context, o *LLM, messages []llms.Messag
 	}
 
 	var thinking *anthropicclient.ThinkingPayload
+	var outputConfig *anthropicclient.OutputConfig
 	if opts.Reasoning.IsEnabled() {
-		thinking = &anthropicclient.ThinkingPayload{
-			Type:   "enabled",
-			Budget: opts.Reasoning.GetTokens(opts.GetMaxTokens()),
+		if opts.Reasoning.Adaptive {
+			effort := opts.Reasoning.Effort
+			if effort == llms.ReasoningNone {
+				effort = llms.ReasoningHigh // the API rejects an empty effort
+			}
+			thinking = &anthropicclient.ThinkingPayload{
+				Type:    "adaptive",
+				Display: "summarized",
+			}
+			outputConfig = &anthropicclient.OutputConfig{Effort: string(effort)}
+		} else {
+			thinking = &anthropicclient.ThinkingPayload{
+				Type:   "enabled",
+				Budget: opts.Reasoning.GetTokens(opts.GetMaxTokens()),
+			}
 		}
 	}
 
@@ -197,9 +210,14 @@ func generateMessagesContent(ctx context.Context, o *LLM, messages []llms.Messag
 		}
 	}
 
-	// Set temperature to 1.0 for thinking models
-	temperature, maxTokens := opts.Temperature, opts.GetMaxTokens()
-	if thinking != nil && thinking.Type == "enabled" && thinking.Budget > 0 {
+	// Budget thinking pins temperature to 1.0; adaptive models reject sampling
+	// params, so omit temperature/top_p entirely for them.
+	temperature, topP, maxTokens := opts.Temperature, opts.TopP, opts.GetMaxTokens()
+	switch {
+	case thinking != nil && thinking.Type == "adaptive":
+		temperature = nil
+		topP = nil
+	case thinking != nil && thinking.Type == "enabled" && thinking.Budget > 0:
 		temperature = getFloatPointer(1.0)
 		maxTokens = max(thinking.Budget*2, maxTokens) // 2x the budget for thinking
 	}
@@ -211,10 +229,11 @@ func generateMessagesContent(ctx context.Context, o *LLM, messages []llms.Messag
 		MaxTokens:     &maxTokens,
 		StopWords:     opts.StopWords,
 		Temperature:   temperature,
-		TopP:          opts.TopP,
+		TopP:          topP,
 		Tools:         tools,
 		ToolChoice:    opts.ToolChoice,
 		Thinking:      thinking,
+		OutputConfig:  outputConfig,
 		BetaHeaders:   betaHeaders,
 		StreamingFunc: opts.StreamingFunc,
 	})

llms/anthropic/internal/anthropicclient/anthropicclient.go

@@ -134,17 +134,18 @@ func (c *Client) CreateCompletion(ctx context.Context, r *CompletionRequest) (*C
 }
 
 type MessageRequest struct {
-	Model       string           `json:"model"`
-	Messages    []ChatMessage    `json:"messages"`
-	System      any              `json:"system,omitempty"` // Can be string or []Content for caching
-	Temperature *float64         `json:"temperature,omitempty"`
-	MaxTokens   *int             `json:"max_tokens,omitempty"`
-	TopP        *float64         `json:"top_p,omitempty"`
-	Tools       []Tool           `json:"tools,omitempty"`
-	ToolChoice  any              `json:"tool_choice,omitempty"`
-	StopWords   []string         `json:"stop_sequences,omitempty"`
-	Stream      bool             `json:"stream,omitempty"`
-	Thinking    *ThinkingPayload `json:"thinking,omitempty"`
+	Model        string           `json:"model"`
+	Messages     []ChatMessage    `json:"messages"`
+	System       any              `json:"system,omitempty"` // Can be string or []Content for caching
+	Temperature  *float64         `json:"temperature,omitempty"`
+	MaxTokens    *int             `json:"max_tokens,omitempty"`
+	TopP         *float64         `json:"top_p,omitempty"`
+	Tools        []Tool           `json:"tools,omitempty"`
+	ToolChoice   any              `json:"tool_choice,omitempty"`
+	StopWords    []string         `json:"stop_sequences,omitempty"`
+	Stream       bool             `json:"stream,omitempty"`
+	Thinking     *ThinkingPayload `json:"thinking,omitempty"`
+	OutputConfig *OutputConfig    `json:"output_config,omitempty"`
 
 	// BetaHeaders are additional beta feature headers to include
 	BetaHeaders   []string           `json:"-"`
@@ -166,6 +167,7 @@ func (c *Client) CreateMessage(ctx context.Context, r *MessageRequest) (*Message
 		Stream:        r.Stream,
 		StreamingFunc: r.StreamingFunc,
 		Thinking:      r.Thinking,
+		OutputConfig:  r.OutputConfig,
 	}, r.BetaHeaders)
 	if err != nil {
 		return nil, err

llms/anthropic/internal/anthropicclient/messages.go

@@ -66,6 +66,15 @@ type ChatMessage struct {
 type ThinkingPayload struct {
 	Type   string `json:"type"`
 	Budget int    `json:"budget_tokens,omitempty"`
+	// Display controls reasoning visibility for adaptive thinking; "summarized"
+	// keeps reasoning text (Opus 4.7+ otherwise default it to "omitted").
+	Display string `json:"display,omitempty"`
+}
+
+// OutputConfig carries the adaptive-thinking effort. It is a top-level sibling of
+// "thinking" in the Messages request body.
+type OutputConfig struct {
+	Effort string `json:"effort,omitempty"`
 }
 
 type messagePayload struct {
@@ -80,7 +89,8 @@ type messagePayload struct {
 	Tools       []Tool        `json:"tools,omitempty"`
 	ToolChoice  any           `json:"tool_choice,omitempty"`
 
-	Thinking *ThinkingPayload `json:"thinking,omitempty"`
+	Thinking     *ThinkingPayload `json:"thinking,omitempty"`
+	OutputConfig *OutputConfig    `json:"output_config,omitempty"`
 
 	StreamingFunc streaming.Callback `json:"-"`
 }

llms/anthropic/internal/anthropicclient/messages_test.go

@@ -2,13 +2,45 @@ package anthropicclient
 
 import (
 	"context"
+	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
+func TestMessagePayload_AdaptiveThinkingSerialization(t *testing.T) {
+	t.Parallel()
+
+	// Temperature/TopP left nil — adaptive models reject sampling params.
+	payload := &messagePayload{
+		Model:        "claude-opus-4-6",
+		Thinking:     &ThinkingPayload{Type: "adaptive", Display: "summarized"},
+		OutputConfig: &OutputConfig{Effort: "high"},
+	}
+
+	raw, err := json.Marshal(payload)
+	require.NoError(t, err)
+
+	var got map[string]any
+	require.NoError(t, json.Unmarshal(raw, &got))
+
+	thinking, _ := got["thinking"].(map[string]any)
+	require.Equal(t, "adaptive", thinking["type"])
+	require.Equal(t, "summarized", thinking["display"])
+	_, hasBudget := thinking["budget_tokens"]
+	require.False(t, hasBudget, "adaptive thinking must not carry a token budget")
+
+	outputConfig, _ := got["output_config"].(map[string]any)
+	require.Equal(t, "high", outputConfig["effort"])
+
+	_, hasTemp := got["temperature"]
+	require.False(t, hasTemp, "adaptive must omit temperature")
+	_, hasTopP := got["top_p"]
+	require.False(t, hasTopP, "adaptive must omit top_p")
+}
+
 func Test_parseStreamingMessageResponse_withEmptyInput(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()

llms/bedrock/internal/bedrockclient/bedrockclient_converse.go

@@ -66,10 +66,20 @@ type ConverseInput struct {
 type converseThinkingPayload struct {
 	Type         string `json:"type" document:"type"`
 	BudgetTokens int    `json:"budget_tokens,omitempty" document:"budget_tokens,omitempty"`
+	// Display keeps adaptive reasoning text visible ("summarized"); Opus 4.7+
+	// otherwise default it to "omitted".
+	Display string `json:"display,omitempty" document:"display,omitempty"`
+}
+
+// converseOutputConfig carries the adaptive-thinking effort. It is a sibling of
+// "thinking" inside additionalModelRequestFields.
+type converseOutputConfig struct {
+	Effort string `json:"effort,omitempty" document:"effort,omitempty"`
 }
 
 type converseAdditionalModelRequestFields struct {
-	Thinking *converseThinkingPayload `json:"thinking,omitempty" document:"thinking,omitempty"`
+	Thinking     *converseThinkingPayload `json:"thinking,omitempty" document:"thinking,omitempty"`
+	OutputConfig *converseOutputConfig    `json:"output_config,omitempty" document:"output_config,omitempty"`
 }
 
 // buildConverseInput converts our input to AWS Converse format
@@ -132,15 +142,30 @@ func (c *ConverseClient) buildConverseInput(input *ConverseInput) (*bedrockrunti
 	// Add additional model fields
 	if input.ReasoningConfig != nil && c.supportsReasoning(input.ModelID) {
 		additionalModelFields := converseAdditionalModelRequestFields{}
-		maxTokens := 0 // Use 0 to let it use default maxTokens
-		if input.MaxTokens != nil {
-			maxTokens = *input.MaxTokens
-		}
-		tokens := input.ReasoningConfig.GetTokens(maxTokens)
-		if tokens > 0 {
+		if input.ReasoningConfig.Adaptive {
+			effort := input.ReasoningConfig.Effort
+			if effort == llms.ReasoningNone {
+				effort = llms.ReasoningHigh // the API rejects an empty effort
+			}
 			additionalModelFields.Thinking = &converseThinkingPayload{
-				Type:         "enabled",
-				BudgetTokens: tokens,
+				Type:    "adaptive",
+				Display: "summarized",
+			}
+			additionalModelFields.OutputConfig = &converseOutputConfig{Effort: string(effort)}
+			// Adaptive models reject sampling params.
+			inferenceConfig.Temperature = nil
+			inferenceConfig.TopP = nil
+		} else {
+			maxTokens := 0 // Use 0 to let it use default maxTokens
+			if input.MaxTokens != nil {
+				maxTokens = *input.MaxTokens
+			}
+			tokens := input.ReasoningConfig.GetTokens(maxTokens)
+			if tokens > 0 {
+				additionalModelFields.Thinking = &converseThinkingPayload{
+					Type:         "enabled",
+					BudgetTokens: tokens,
+				}
 			}
 		}
 		if additionalModelFields.Thinking != nil {

llms/bedrock/internal/bedrockclient/bedrockclient_converse_test.go

@@ -2,6 +2,7 @@ package bedrockclient
 
 import (
 	"context"
+	"encoding/json"
 	"testing"
 
 	"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
@@ -271,6 +272,60 @@ func TestConverseClient_InferenceConfiguration(t *testing.T) {
 	mockClient.AssertExpectations(t)
 }
 
+func TestConverseClient_AdaptiveReasoning(t *testing.T) {
+	mockClient := &MockBedrockRuntimeClient{}
+	client := NewConverseClient(mockClient)
+
+	var capturedInput *bedrockruntime.ConverseInput
+	mockClient.On("Converse", mock.Anything, mock.MatchedBy(func(input *bedrockruntime.ConverseInput) bool {
+		capturedInput = input
+		return true
+	}), mock.Anything).Return(&bedrockruntime.ConverseOutput{
+		Output: &types.ConverseOutputMemberMessage{
+			Value: types.Message{
+				Role:    types.ConversationRoleAssistant,
+				Content: []types.ContentBlock{&types.ContentBlockMemberText{Value: "ok"}},
+			},
+		},
+	}, nil)
+
+	input := &ConverseInput{
+		ModelID:         "anthropic.claude-opus-4-6-v1:0",
+		Messages:        []Message{{Role: llms.ChatMessageTypeHuman, Content: "Hello", Type: "text"}},
+		MaxTokens:       ptr(2000),
+		Temperature:     ptr(0.8),
+		TopP:            ptr(0.9),
+		ReasoningConfig: &llms.ReasoningConfig{Effort: llms.ReasoningHigh, Adaptive: true},
+	}
+
+	_, err := client.CreateCompletionConverse(t.Context(), input)
+	assert.NoError(t, err)
+
+	// Adaptive models reject sampling params — temperature/top_p must be omitted.
+	assert.Nil(t, capturedInput.InferenceConfig.Temperature)
+	assert.Nil(t, capturedInput.InferenceConfig.TopP)
+	assert.Equal(t, int32(2000), *capturedInput.InferenceConfig.MaxTokens)
+
+	if !assert.NotNil(t, capturedInput.AdditionalModelRequestFields) {
+		return
+	}
+	raw, err := capturedInput.AdditionalModelRequestFields.MarshalSmithyDocument()
+	assert.NoError(t, err)
+	var fields map[string]any
+	assert.NoError(t, json.Unmarshal(raw, &fields))
+
+	thinking, _ := fields["thinking"].(map[string]any)
+	assert.Equal(t, "adaptive", thinking["type"])
+	assert.Equal(t, "summarized", thinking["display"])
+	_, hasBudget := thinking["budget_tokens"]
+	assert.False(t, hasBudget, "adaptive thinking must not carry a token budget")
+
+	outputConfig, _ := fields["output_config"].(map[string]any)
+	assert.Equal(t, "high", outputConfig["effort"])
+
+	mockClient.AssertExpectations(t)
+}
+
 func TestConverseClient_EmptyResponse(t *testing.T) {
 	mockClient := &MockBedrockRuntimeClient{}
 	client := NewConverseClient(mockClient)

llms/options.go

@@ -34,12 +34,22 @@ const (
 	ReasoningMedium ReasoningEffort = "medium"
 	ReasoningLow    ReasoningEffort = "low"
 	ReasoningNone   ReasoningEffort = ""
+	// ReasoningXHigh and ReasoningMax are adaptive-thinking efforts (Claude Opus 4.7+).
+	// They are valid only with adaptive reasoning, not the budget-token path
+	// (GetTokens treats them as invalid).
+	ReasoningXHigh ReasoningEffort = "xhigh"
+	ReasoningMax   ReasoningEffort = "max"
 )
 
 // ReasoningConfig is a set of options for reasoning.
 type ReasoningConfig struct {
 	Effort ReasoningEffort `json:"effort"`
 	Tokens int             `json:"tokens"`
+	// Adaptive selects adaptive thinking (Claude Opus 4.7+): the request carries
+	// thinking.type=adaptive plus output_config.effort instead of a token budget,
+	// and the provider omits sampling params (temperature/top_p) that adaptive
+	// models reject. Effort sets the level; Tokens is ignored.
+	Adaptive bool `json:"adaptive,omitempty"`
 }
 
 // IsEnabled returns true if reasoning is enabled based on the effort and tokens.
@@ -48,6 +58,10 @@ func (r *ReasoningConfig) IsEnabled() bool {
 		return false
 	}
 
+	if r.Adaptive {
+		return true
+	}
+
 	if r.Effort == ReasoningNone && r.Tokens == 0 {
 		return false
 	}
@@ -616,6 +630,19 @@ func WithReasoning(effort ReasoningEffort, tokens int) CallOption {
 	}
 }
 
+// WithAdaptiveReasoning enables adaptive thinking (Claude Opus 4.7+): the model
+// decides how much to think and effort sets the level (low/medium/high/xhigh/max).
+// Unlike WithReasoning there is no token budget, and the provider omits sampling
+// params (temperature/top_p) that adaptive models reject.
+func WithAdaptiveReasoning(effort ReasoningEffort) CallOption {
+	return func(o *CallOptions) {
+		o.Reasoning = &ReasoningConfig{
+			Effort:   effort,
+			Adaptive: true,
+		}
+	}
+}
+
 // WithFunctionCallBehavior will add an option to set the behavior to use when calling functions.
 // Deprecated: Use WithToolChoice instead.
 func WithFunctionCallBehavior(behavior FunctionCallBehavior) CallOption {