feat: breaking changes with llms.CallOptions and improve test coverage

- Removed deprecated RedactedThinkingContent from search index and adjusted related tests to enhance clarity.
- Updated CountTokens test to reflect correct expected token count.
- Refactored marshaling tests to streamline reasoning content handling, removing unnecessary redacted content checks.
- Modified CallOptions struct to use pointers for optional fields, improving memory efficiency and consistency.
- Enhanced test cases for CallOptions to validate new pointer-based logic and default values.
- Updated Anthropic client to utilize new CallOptions methods for better encapsulation and maintainability.

Author: asdek

docs/static/search-index.json

@@ -11625,35 +11625,6 @@
       "anthropicclient"
     ]
   },
-  {
-    "title": "RedactedThinkingContent",
-    "url": "https://pkg.go.dev/github.com/vxcontrol/langchaingo/llms/anthropic/internal/anthropicclient#RedactedThinkingContent",
-    "content": "",
-    "type": "type",
-    "package": "anthropicclient",
-    "signature": "type RedactedThinkingContent",
-    "external": true,
-    "keywords": [
-      "type",
-      "RedactedThinkingContent",
-      "anthropicclient"
-    ]
-  },
-  {
-    "title": "RedactedThinkingContent.GetType",
-    "url": "https://pkg.go.dev/github.com/vxcontrol/langchaingo/llms/anthropic/internal/anthropicclient#RedactedThinkingContent.GetType",
-    "content": "",
-    "type": "method",
-    "package": "anthropicclient",
-    "signature": "GetType()",
-    "external": true,
-    "keywords": [
-      "method",
-      "GetType",
-      "RedactedThinkingContent",
-      "anthropicclient"
-    ]
-  },
   {
     "title": "TextContent",
     "url": "https://pkg.go.dev/github.com/vxcontrol/langchaingo/llms/anthropic/internal/anthropicclient#TextContent",

llms/anthropic/anthropic_test.go

@@ -272,6 +272,7 @@ func TestAnthropic_GenerateContentWithToolAndStreaming(t *testing.T) {
 		content,
 		llms.WithStreamingFunc(streamingFunc),
 		llms.WithTools(availableTools),
+		llms.WithTemperature(0.5),
 	)
 	require.NoError(t, err)
 

llms/anthropic/anthropic_thinking_test.go

@@ -434,66 +434,3 @@ func TestAnthropic_InterleavedThinkingMultipleBlocks(t *testing.T) {
 		}
 	}
 }
-
-// TestAnthropic_RedactedThinking tests redacted thinking handling
-func TestAnthropic_RedactedThinking(t *testing.T) {
-	t.Parallel()
-
-	llm := newHTTPRRClient(t, anthropic.WithModel("claude-3-7-sonnet-latest"))
-
-	// Use magic string to trigger redacted thinking
-	magicString := "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB"
-
-	messages := []llms.MessageContent{
-		{
-			Role: llms.ChatMessageTypeHuman,
-			Parts: []llms.ContentPart{
-				llms.TextPart(magicString),
-			},
-		},
-	}
-
-	// Request with thinking enabled
-	resp, err := llm.GenerateContent(t.Context(), messages,
-		llms.WithReasoning(llms.ReasoningHigh, 10000),
-		llms.WithMaxTokens(16000),
-		llms.WithTemperature(1.0),
-	)
-	require.NoError(t, err)
-
-	choice := resp.Choices[0]
-	assert.NotNil(t, choice.Reasoning)
-
-	// Check if redacted content is present
-	if choice.Reasoning != nil && len(choice.Reasoning.RedactedContent) > 0 {
-		t.Logf("Found redacted thinking content: %d bytes", len(choice.Reasoning.RedactedContent))
-		assert.NotEmpty(t, choice.Reasoning.RedactedContent)
-
-		// ROUNDTRIP: Send response back with redacted content preserved
-		messages = append(messages,
-			llms.MessageContent{
-				Role: llms.ChatMessageTypeAI,
-				Parts: []llms.ContentPart{
-					llms.TextPartWithReasoning(choice.Content, choice.Reasoning),
-				},
-			},
-			llms.MessageContent{
-				Role: llms.ChatMessageTypeHuman,
-				Parts: []llms.ContentPart{
-					llms.TextPart("Continue the conversation"),
-				},
-			},
-		)
-
-		// This should work - API should decrypt and use redacted content
-		resp2, err := llm.GenerateContent(t.Context(), messages,
-			llms.WithReasoning(llms.ReasoningHigh, 10000),
-			llms.WithMaxTokens(16000),
-			llms.WithTemperature(1.0),
-		)
-		require.NoError(t, err, "API should accept redacted thinking in roundtrip")
-		assert.NotEmpty(t, resp2.Choices[0].Content)
-	} else {
-		assert.Fail(t, "No redacted thinking in response")
-	}
-}

llms/anthropic/anthropicllm.go

@@ -130,12 +130,12 @@ func generateCompletionsContent(ctx context.Context, o *LLM, messages []llms.Mes
 	}
 	prompt := fmt.Sprintf("\n\nHuman: %s\n\nAssistant:", partText.Text)
 	result, err := o.client.CreateCompletion(ctx, &anthropicclient.CompletionRequest{
-		Model:         opts.Model,
+		Model:         opts.GetModel(),
 		Prompt:        prompt,
-		MaxTokens:     opts.MaxTokens,
-		StopWords:     opts.StopWords,
-		Temperature:   opts.Temperature,
-		TopP:          opts.TopP,
+		MaxTokens:     opts.GetMaxTokens(),
+		StopWords:     opts.GetStopWords(),
+		Temperature:   opts.GetTemperature(),
+		TopP:          opts.GetTopP(),
 		StreamingFunc: opts.StreamingFunc,
 	})
 	if err != nil {
@@ -165,7 +165,7 @@ func generateMessagesContent(ctx context.Context, o *LLM, messages []llms.Messag
 	if opts.Reasoning.IsEnabled() {
 		thinking = &anthropicclient.ThinkingPayload{
 			Type:   "enabled",
-			Budget: opts.Reasoning.GetTokens(opts.MaxTokens),
+			Budget: opts.Reasoning.GetTokens(opts.GetMaxTokens()),
 		}
 	}
 
@@ -198,16 +198,17 @@ func generateMessagesContent(ctx context.Context, o *LLM, messages []llms.Messag
 	}
 
 	// Set temperature to 1.0 for thinking models
-	temperature := opts.Temperature
+	temperature, maxTokens := opts.Temperature, opts.GetMaxTokens()
 	if thinking != nil && thinking.Type == "enabled" && thinking.Budget > 0 {
-		temperature = 1.0
+		temperature = getFloatPointer(1.0)
+		maxTokens = max(thinking.Budget*2, maxTokens) // 2x the budget for thinking
 	}
 
 	result, err := o.client.CreateMessage(ctx, &anthropicclient.MessageRequest{
-		Model:         opts.Model,
+		Model:         opts.GetModel(),
 		Messages:      chatMessages,
 		System:        system,
-		MaxTokens:     opts.MaxTokens,
+		MaxTokens:     &maxTokens,
 		StopWords:     opts.StopWords,
 		Temperature:   temperature,
 		TopP:          opts.TopP,
@@ -232,11 +233,10 @@ func processAnthropicResponse(result *anthropicclient.MessageResponsePayload) (*
 		return nil, ErrEmptyResponse
 	}
 
-	// Extract ALL thinking content, signature, and redacted content
+	// Extract ALL thinking content, signature
 	// According to Anthropic docs, there's ONE thinking block per response
 	var reasoningContent strings.Builder
 	var signature []byte
-	var redactedContent []byte
 
 	for _, content := range result.Content {
 		switch cv := content.(type) {
@@ -245,21 +245,15 @@ func processAnthropicResponse(result *anthropicclient.MessageResponsePayload) (*
 			if len(cv.Signature) > 0 {
 				signature = []byte(cv.Signature)
 			}
-		case *anthropicclient.RedactedThinkingContent:
-			// Redacted content is encrypted and must be preserved for roundtrip
-			if len(cv.Data) > 0 {
-				redactedContent = []byte(cv.Data)
-			}
 		}
 	}
 
 	// Create reasoning object
 	var contentReasoning *reasoning.ContentReasoning
-	if reasoningContent.Len() > 0 || len(signature) > 0 || len(redactedContent) > 0 {
+	if reasoningContent.Len() > 0 || len(signature) > 0 {
 		contentReasoning = &reasoning.ContentReasoning{
-			Content:         reasoningContent.String(),
-			Signature:       signature,
-			RedactedContent: redactedContent,
+			Content:   reasoningContent.String(),
+			Signature: signature,
 		}
 	}
 
@@ -694,7 +688,7 @@ func handleAIMessage(msg llms.MessageContent) (anthropicclient.ChatMessage, erro
 	for _, part := range msg.Parts {
 		switch p := part.(type) {
 		case llms.TextContent:
-			// If reasoning is present, add blocks in order: thinking → redacted_thinking → text
+			// If reasoning is present, add blocks in order: thinking → text
 			if p.Reasoning != nil {
 				// Add thinking block if present
 				if len(p.Reasoning.Content) > 0 || len(p.Reasoning.Signature) > 0 {
@@ -707,15 +701,6 @@ func handleAIMessage(msg llms.MessageContent) (anthropicclient.ChatMessage, erro
 					}
 					message.Content = append(message.Content, thinkingBlock)
 				}
-
-				// Add redacted thinking block if present (after thinking)
-				if len(p.Reasoning.RedactedContent) > 0 {
-					redactedBlock := &anthropicclient.RedactedThinkingContent{
-						Type: "redacted_thinking",
-						Data: string(p.Reasoning.RedactedContent),
-					}
-					message.Content = append(message.Content, redactedBlock)
-				}
 			}
 
 			// Add text content only if not empty
@@ -807,3 +792,7 @@ func appendIfMissing(slice []string, val string) []string {
 	}
 	return append(slice, val)
 }
+
+func getFloatPointer(f float64) *float64 {
+	return &f
+}

llms/anthropic/internal/anthropicclient/anthropicclient.go

@@ -137,9 +137,9 @@ 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"`
-	MaxTokens   int              `json:"max_tokens,omitempty"`
-	TopP        float64          `json:"top_p,omitempty"`
+	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"`

llms/anthropic/internal/anthropicclient/anthropicclient_test.go

@@ -40,7 +40,7 @@ func TestClient_CreateMessage(t *testing.T) {
 				},
 			},
 		},
-		MaxTokens: 100,
+		MaxTokens: getIntPointer(100),
 	}
 
 	resp, err := client.CreateMessage(ctx, req)
@@ -80,7 +80,7 @@ func TestClient_CreateMessageStream(t *testing.T) {
 				},
 			},
 		},
-		MaxTokens: 100,
+		MaxTokens: getIntPointer(100),
 		Stream:    true,
 		StreamingFunc: func(_ context.Context, chunk streaming.Chunk) error {
 			switch chunk.Type {
@@ -132,7 +132,7 @@ func TestClient_WithAnthropicBetaHeader(t *testing.T) {
 				},
 			},
 		},
-		MaxTokens: 100,
+		MaxTokens: getIntPointer(100),
 		Tools: []Tool{
 			{
 				Name:        "get_weather",

llms/anthropic/internal/anthropicclient/messages.go

@@ -42,14 +42,13 @@ var (
 	ErrInvalidFieldType           = fmt.Errorf("invalid field type")
 )
 
-// For correct using thinking and redacted thinking events, use this guide:
+// For correct using thinking events, use this guide:
 // https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking
 // In this implementation, we don't send the thinking block to the server.
 const (
-	EventTypeText             = "text"
-	EventTypeToolUse          = "tool_use"
-	EventTypeThinking         = "thinking"
-	EventTypeRedactedThinking = "redacted_thinking"
+	EventTypeText     = "text"
+	EventTypeToolUse  = "tool_use"
+	EventTypeThinking = "thinking"
 )
 
 const (
@@ -73,11 +72,11 @@ type messagePayload struct {
 	Model       string        `json:"model"`
 	Messages    []ChatMessage `json:"messages"`
 	System      any           `json:"system,omitempty"`
-	MaxTokens   int           `json:"max_tokens,omitempty"`
+	MaxTokens   *int          `json:"max_tokens,omitempty"`
 	StopWords   []string      `json:"stop_sequences,omitempty"`
 	Stream      bool          `json:"stream,omitempty"`
-	Temperature float64       `json:"temperature"`
-	TopP        float64       `json:"top_p,omitempty"`
+	Temperature *float64      `json:"temperature,omitempty"`
+	TopP        *float64      `json:"top_p,omitempty"`
 	Tools       []Tool        `json:"tools,omitempty"`
 	ToolChoice  any           `json:"tool_choice,omitempty"`
 
@@ -151,15 +150,6 @@ func (tc ThinkingContent) GetType() string {
 	return tc.Type
 }
 
-type RedactedThinkingContent struct {
-	Type string `json:"type"`
-	Data string `json:"data"`
-}
-
-func (rthc RedactedThinkingContent) GetType() string {
-	return rthc.Type
-}
-
 type ToolUseContent struct {
 	Type         string                 `json:"type"`
 	ID           string                 `json:"id"`
@@ -278,21 +268,15 @@ func parseContentBlock(raw []byte) (Content, error) {
 			return nil, err
 		}
 		return thc, nil
-	case EventTypeRedactedThinking:
-		rthc := &RedactedThinkingContent{}
-		if err := json.Unmarshal(raw, rthc); err != nil {
-			return nil, err
-		}
-		return rthc, nil
 	default:
 		return nil, fmt.Errorf("unknown content type: %s\n%v", typeStruct.Type, string(raw)) //nolint:err113
 	}
 }
 
 func (c *Client) setMessageDefaults(payload *messagePayload) {
 	// Set defaults
-	if payload.MaxTokens == 0 {
-		payload.MaxTokens = 2048
+	if payload.MaxTokens == nil || *payload.MaxTokens == 0 {
+		payload.MaxTokens = getIntPointer(2048)
 	}
 
 	if len(payload.StopWords) == 0 {
@@ -566,11 +550,6 @@ func handleContentBlockStartEvent(event map[string]interface{}, response Message
 				Thinking:  getString(cb, "thinking"),
 				Signature: getString(cb, "signature"),
 			})
-		case EventTypeRedactedThinking:
-			response.Content = append(response.Content, &RedactedThinkingContent{
-				Type: eventType,
-				Data: getString(cb, "data"),
-			})
 		default:
 			return response, fmt.Errorf("unknown content block type: %s", eventType)
 		}
@@ -796,3 +775,7 @@ func getMap(m map[string]interface{}, key string) map[string]interface{} {
 	}
 	return value
 }
+
+func getIntPointer(i int) *int {
+	return &i
+}