feat(bedrock): add top_k and extended thinking support for Claude models

go/adk/pkg/agent/agent.go

@@ -285,9 +285,10 @@ func CreateLLM(ctx context.Context, m adk.Model, log logr.Logger) (adkmodel.LLM,
 		}
 		// Use Bedrock Converse API for ALL models (including Anthropic)
 		cfg := &models.BedrockConfig{
-			TransportConfig: transportConfigFromBase(m.BaseModel, nil),
-			Model:           modelName,
-			Region:          region,
+			TransportConfig:              transportConfigFromBase(m.BaseModel, nil),
+			Model:                        modelName,
+			Region:                       region,
+			AdditionalModelRequestFields: m.AdditionalModelRequestFields,
 		}
 		return models.NewBedrockModelWithLogger(ctx, cfg, log)
 

go/adk/pkg/models/bedrock.go

@@ -48,12 +48,12 @@ func sanitizeBedrockToolID(id string, idMap map[string]string, counter *int) str
 // BedrockConfig holds Bedrock configuration for the Converse API
 type BedrockConfig struct {
 	TransportConfig
-	Model       string
-	Region      string
-	MaxTokens   *int
-	Temperature *float64
-	TopP        *float64
-	TopK        *int
+	Model                        string
+	Region                       string
+	MaxTokens                    *int
+	Temperature                  *float64
+	TopP                         *float64
+	AdditionalModelRequestFields map[string]any
 }
 
 // BedrockModel implements model.LLM for Amazon Bedrock using the Converse API.
@@ -158,26 +158,41 @@ func (m *BedrockModel) GenerateContent(ctx context.Context, req *model.LLMReques
 			}
 		}
 
+		// Build model-specific additional fields (Claude top_k, thinking, etc.)
+		additionalFields := m.buildAdditionalModelRequestFields()
+
 		// Set telemetry attributes
 		telemetry.SetLLMRequestAttributes(ctx, modelName, req)
 
 		if stream {
-			m.generateStreaming(ctx, modelName, messages, systemPrompt, inferenceConfig, toolConfig, yield)
+			m.generateStreaming(ctx, modelName, messages, systemPrompt, inferenceConfig, toolConfig, additionalFields, yield)
 		} else {
-			m.generateNonStreaming(ctx, modelName, messages, systemPrompt, inferenceConfig, toolConfig, yield)
+			m.generateNonStreaming(ctx, modelName, messages, systemPrompt, inferenceConfig, toolConfig, additionalFields, yield)
 		}
 	}
 }
 
+// buildAdditionalModelRequestFields returns a document.Interface containing
+// model-specific parameters that are not part of InferenceConfiguration.
+// The raw map is forwarded as-is to the Bedrock Converse API.
+// Returns nil when no extra fields are configured.
+func (m *BedrockModel) buildAdditionalModelRequestFields() document.Interface {
+	if len(m.Config.AdditionalModelRequestFields) == 0 {
+		return nil
+	}
+	return document.NewLazyDocument(m.Config.AdditionalModelRequestFields)
+}
+
 // generateStreaming handles streaming responses from Bedrock ConverseStream.
 // It properly handles both text and tool use content blocks during streaming.
-func (m *BedrockModel) generateStreaming(ctx context.Context, modelId string, messages []types.Message, systemPrompt []types.SystemContentBlock, inferenceConfig *types.InferenceConfiguration, toolConfig *types.ToolConfiguration, yield func(*model.LLMResponse, error) bool) {
+func (m *BedrockModel) generateStreaming(ctx context.Context, modelId string, messages []types.Message, systemPrompt []types.SystemContentBlock, inferenceConfig *types.InferenceConfiguration, toolConfig *types.ToolConfiguration, additionalFields document.Interface, yield func(*model.LLMResponse, error) bool) {
 	output, err := m.Client.ConverseStream(ctx, &bedrockruntime.ConverseStreamInput{
-		ModelId:         aws.String(modelId),
-		Messages:        messages,
-		System:          systemPrompt,
-		InferenceConfig: inferenceConfig,
-		ToolConfig:      toolConfig,
+		ModelId:                      aws.String(modelId),
+		Messages:                     messages,
+		System:                       systemPrompt,
+		InferenceConfig:              inferenceConfig,
+		ToolConfig:                   toolConfig,
+		AdditionalModelRequestFields: additionalFields,
 	})
 
 	if err != nil {
@@ -323,13 +338,14 @@ func (tc *streamingToolCall) parseArgs() map[string]any {
 }
 
 // generateNonStreaming handles non-streaming responses from Bedrock Converse.
-func (m *BedrockModel) generateNonStreaming(ctx context.Context, modelId string, messages []types.Message, systemPrompt []types.SystemContentBlock, inferenceConfig *types.InferenceConfiguration, toolConfig *types.ToolConfiguration, yield func(*model.LLMResponse, error) bool) {
+func (m *BedrockModel) generateNonStreaming(ctx context.Context, modelId string, messages []types.Message, systemPrompt []types.SystemContentBlock, inferenceConfig *types.InferenceConfiguration, toolConfig *types.ToolConfiguration, additionalFields document.Interface, yield func(*model.LLMResponse, error) bool) {
 	output, err := m.Client.Converse(ctx, &bedrockruntime.ConverseInput{
-		ModelId:         aws.String(modelId),
-		Messages:        messages,
-		System:          systemPrompt,
-		InferenceConfig: inferenceConfig,
-		ToolConfig:      toolConfig,
+		ModelId:                      aws.String(modelId),
+		Messages:                     messages,
+		System:                       systemPrompt,
+		InferenceConfig:              inferenceConfig,
+		ToolConfig:                   toolConfig,
+		AdditionalModelRequestFields: additionalFields,
 	})
 
 	if err != nil {

go/api/adk/types.go

@@ -247,6 +247,10 @@ type Bedrock struct {
 	BaseModel
 	// Region is the AWS region where the model is available
 	Region string `json:"region,omitempty"`
+	// AdditionalModelRequestFields passes model-specific parameters to Bedrock's
+	// additionalModelRequestFields in the Converse API. Use this for provider-specific
+	// options outside the standard InferenceConfiguration block.
+	AdditionalModelRequestFields map[string]any `json:"additional_model_request_fields,omitempty"`
 }
 
 func (b *Bedrock) MarshalJSON() ([]byte, error) {

go/api/config/crd/bases/kagent.dev_modelconfigs.yaml

@@ -479,6 +479,14 @@ spec:
               bedrock:
                 description: AWS Bedrock-specific configuration
                 properties:
+                  additionalModelRequestFields:
+                    description: |-
+                      AdditionalModelRequestFields passes model-specific parameters to Bedrock's
+                      additionalModelRequestFields in the Converse API. Use this for provider-specific
+                      options that are not part of the standard InferenceConfiguration block, such as
+                      Claude extended thinking or top_k. Values are forwarded as-is to the API.
+                      Example: {"top_k": 5, "thinking": {"type": "enabled", "budget_tokens": 16000}}
+                    x-kubernetes-preserve-unknown-fields: true
                   region:
                     description: AWS region where the Bedrock model is available (e.g.,
                       us-east-1, us-west-2)

go/api/v1alpha2/modelconfig_types.go

@@ -17,6 +17,7 @@ limitations under the License.
 package v1alpha2
 
 import (
+	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
@@ -243,6 +244,15 @@ type BedrockConfig struct {
 	// AWS region where the Bedrock model is available (e.g., us-east-1, us-west-2)
 	// +required
 	Region string `json:"region"`
+
+	// AdditionalModelRequestFields passes model-specific parameters to Bedrock's
+	// additionalModelRequestFields in the Converse API. Use this for provider-specific
+	// options that are not part of the standard InferenceConfiguration block, such as
+	// Claude extended thinking or top_k. Values are forwarded as-is to the API.
+	// Example: {"top_k": 5, "thinking": {"type": "enabled", "budget_tokens": 16000}}
+	// +optional
+	// +kubebuilder:pruning:PreserveUnknownFields
+	AdditionalModelRequestFields *apiextensionsv1.JSON `json:"additionalModelRequestFields,omitempty"`
 }
 
 // SAPAICoreConfig contains SAP AI Core-specific configuration options.

go/core/internal/controller/translator/agent/adk_api_translator.go

@@ -7,6 +7,7 @@ import (
 	_ "embed"
 	"encoding/binary"
 	"encoding/hex"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"maps"
@@ -683,12 +684,19 @@ func (a *adkApiTranslator) translateModel(ctx context.Context, namespace, modelC
 				}
 			}
 		}
+		var additionalFields map[string]any
+		if model.Spec.Bedrock.AdditionalModelRequestFields != nil {
+			if err := json.Unmarshal(model.Spec.Bedrock.AdditionalModelRequestFields.Raw, &additionalFields); err != nil {
+				return nil, nil, nil, fmt.Errorf("failed to unmarshal bedrock additionalModelRequestFields: %w", err)
+			}
+		}
 		bedrock := &adk.Bedrock{
 			BaseModel: adk.BaseModel{
 				Model:   model.Spec.Model,
 				Headers: model.Spec.DefaultHeaders,
 			},
-			Region: model.Spec.Bedrock.Region,
+			Region:                       model.Spec.Bedrock.Region,
+			AdditionalModelRequestFields: additionalFields,
 		}
 
 		// Populate TLS fields in BaseModel

helm/kagent-crds/templates/kagent.dev_modelconfigs.yaml

@@ -479,6 +479,14 @@ spec:
               bedrock:
                 description: AWS Bedrock-specific configuration
                 properties:
+                  additionalModelRequestFields:
+                    description: |-
+                      AdditionalModelRequestFields passes model-specific parameters to Bedrock's
+                      additionalModelRequestFields in the Converse API. Use this for provider-specific
+                      options that are not part of the standard InferenceConfiguration block, such as
+                      Claude extended thinking or top_k. Values are forwarded as-is to the API.
+                      Example: {"top_k": 5, "thinking": {"type": "enabled", "budget_tokens": 16000}}
+                    x-kubernetes-preserve-unknown-fields: true
                   region:
                     description: AWS region where the Bedrock model is available (e.g.,
                       us-east-1, us-west-2)

python/packages/kagent-adk/src/kagent/adk/models/_bedrock.py

@@ -195,6 +195,7 @@ class KAgentBedrockLlm(BaseLlm):
     """
 
     extra_headers: Optional[dict[str, str]] = None
+    additional_model_request_fields: Optional[dict[str, Any]] = None
     model_config = {"arbitrary_types_allowed": True}
 
     @cached_property
@@ -244,6 +245,9 @@ async def generate_content_async(
         if inference_config:
             kwargs["inferenceConfig"] = inference_config
 
+        if self.additional_model_request_fields:
+            kwargs["additionalModelRequestFields"] = self.additional_model_request_fields
+
         def _run_converse_stream(**kw):
             resp = client.converse_stream(**kw)
             return list(resp.get("stream", []))

python/packages/kagent-adk/src/kagent/adk/types.py

@@ -235,6 +235,10 @@ class Gemini(BaseLLM):
 
 class Bedrock(BaseLLM):
     region: str | None = None
+    # additional_model_request_fields passes model-specific parameters to Bedrock's
+    # additionalModelRequestFields in the Converse API. Use this for provider-specific
+    # options outside the standard InferenceConfiguration block.
+    additional_model_request_fields: dict | None = None
     type: Literal["bedrock"]
 
 
@@ -569,6 +573,7 @@ def _create_llm_from_model_config(model_config: ModelUnion):
         return KAgentBedrockLlm(
             model=model_config.model,
             extra_headers=extra_headers,
+            additional_model_request_fields=model_config.additional_model_request_fields,
         )
     if model_config.type == "sap_ai_core":
         from .models._sap_ai_core import KAgentSAPAICoreLlm