Skip to content

Fully autonomous AI Agents system capable of performing complex penetration testing tasks

feat(bedrock): integrate adaptive thinking mechanism backend (refs #288)

Sergey Kozyrenkoca9283b93e0d
diff --git a/backend/pkg/database/converter/converter.go b/backend/pkg/database/converter/converter.go
index 965a02a4..d0adf25e 100644
--- a/backend/pkg/database/converter/converter.go
+++ b/backend/pkg/database/converter/converter.go
@@ -639,9 +639,13 @@ func ConvertAgentConfigToGqlModel(ac *pconfig.AgentConfig) *model.AgentConfig {
result.PresencePenalty = &ac.PresencePenalty
}
- if ac.Reasoning.Effort != llms.ReasoningNone || ac.Reasoning.MaxTokens != 0 {
+ if !ac.Reasoning.IsZero() {
reasoning := &model.ReasoningConfig{}
+ if ac.Reasoning.Mode != pconfig.ReasoningModeDefault {
+ mode := model.ReasoningMode(ac.Reasoning.Mode)
+ reasoning.Mode = &mode
+ }
if ac.Reasoning.Effort != llms.ReasoningNone {
effort := model.ReasoningEffort(ac.Reasoning.Effort)
reasoning.Effort = &effort
@@ -734,6 +738,9 @@ func ConvertAgentConfigFromGqlModel(ac *model.AgentConfig) *pconfig.AgentConfig
if ac.Reasoning != nil {
reasoning := map[string]any{}
+ if ac.Reasoning.Mode != nil {
+ reasoning["mode"] = pconfig.ReasoningMode(*ac.Reasoning.Mode)
+ }
if ac.Reasoning.Effort != nil {
reasoning["effort"] = llms.ReasoningEffort(*ac.Reasoning.Effort)
}
diff --git a/backend/pkg/graph/generated.go b/backend/pkg/graph/generated.go
index 9d5484d2..088c54b9 100644
--- a/backend/pkg/graph/generated.go
+++ b/backend/pkg/graph/generated.go
@@ -509,6 +509,7 @@ type ComplexityRoot struct {
ReasoningConfig struct {
Effort func(childComplexity int) int
MaxTokens func(childComplexity int) int
+ Mode func(childComplexity int) int
}
Screenshot struct {
@@ -3456,6 +3457,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.ReasoningConfig.MaxTokens(childComplexity), true
+ case "ReasoningConfig.mode":
+ if e.complexity.ReasoningConfig.Mode == nil {
+ break
+ }
+
+ return e.complexity.ReasoningConfig.Mode(childComplexity), true
+
case "Screenshot.createdAt":
if e.complexity.Screenshot.CreatedAt == nil {
break
@@ -9721,6 +9729,8 @@ func (ec *executionContext) fieldContext_AgentConfig_reasoning(_ context.Context
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
+ case "mode":
+ return ec.fieldContext_ReasoningConfig_mode(ctx, field)
case "effort":
return ec.fieldContext_ReasoningConfig_effort(ctx, field)
case "maxTokens":
@@ -25370,6 +25380,47 @@ func (ec *executionContext) fieldContext_Query___schema(_ context.Context, field
return fc, nil
}
+func (ec *executionContext) _ReasoningConfig_mode(ctx context.Context, field graphql.CollectedField, obj *model.ReasoningConfig) (ret graphql.Marshaler) {
+ fc, err := ec.fieldContext_ReasoningConfig_mode(ctx, field)
+ if err != nil {
+ return graphql.Null
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = graphql.Null
+ }
+ }()
+ resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Mode, nil
+ })
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ if resTmp == nil {
+ return graphql.Null
+ }
+ res := resTmp.(*model.ReasoningMode)
+ fc.Result = res
+ return ec.marshalOReasoningMode2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐReasoningMode(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_ReasoningConfig_mode(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "ReasoningConfig",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return nil, errors.New("field of type ReasoningMode does not have child fields")
+ },
+ }
+ return fc, nil
+}
+
func (ec *executionContext) _ReasoningConfig_effort(ctx context.Context, field graphql.CollectedField, obj *model.ReasoningConfig) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_ReasoningConfig_effort(ctx, field)
if err != nil {
@@ -36548,13 +36599,20 @@ func (ec *executionContext) unmarshalInputReasoningConfigInput(ctx context.Conte
asMap[k] = v
}
- fieldsInOrder := [...]string{"effort", "maxTokens"}
+ fieldsInOrder := [...]string{"mode", "effort", "maxTokens"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
+ case "mode":
+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("mode"))
+ data, err := ec.unmarshalOReasoningMode2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐReasoningMode(ctx, v)
+ if err != nil {
+ return it, err
+ }
+ it.Mode = data
case "effort":
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("effort"))
data, err := ec.unmarshalOReasoningEffort2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐReasoningEffort(ctx, v)
@@ -40471,6 +40529,8 @@ func (ec *executionContext) _ReasoningConfig(ctx context.Context, sel ast.Select
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("ReasoningConfig")
+ case "mode":
+ out.Values[i] = ec._ReasoningConfig_mode(ctx, field, obj)
case "effort":
out.Values[i] = ec._ReasoningConfig_effort(ctx, field, obj)
case "maxTokens":
@@ -45189,6 +45249,22 @@ func (ec *executionContext) marshalOReasoningEffort2ᚖpentagiᚋpkgᚋgraphᚋm
return v
}
+func (ec *executionContext) unmarshalOReasoningMode2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐReasoningMode(ctx context.Context, v interface{}) (*model.ReasoningMode, error) {
+ if v == nil {
+ return nil, nil
+ }
+ var res = new(model.ReasoningMode)
+ err := res.UnmarshalGQL(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalOReasoningMode2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐReasoningMode(ctx context.Context, sel ast.SelectionSet, v *model.ReasoningMode) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ return v
+}
+
func (ec *executionContext) marshalOScreenshot2ᚕᚖpentagiᚋpkgᚋgraphᚋmodelᚐScreenshotᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.Screenshot) graphql.Marshaler {
if v == nil {
return graphql.Null
diff --git a/backend/pkg/graph/model/models_gen.go b/backend/pkg/graph/model/models_gen.go
index 8576c5af..5a9e4f23 100644
--- a/backend/pkg/graph/model/models_gen.go
+++ b/backend/pkg/graph/model/models_gen.go
@@ -420,6 +420,7 @@ type Query struct {
}
type ReasoningConfig struct {
+ Mode *ReasoningMode `json:"mode,omitempty"`
Effort *ReasoningEffort `json:"effort,omitempty"`
MaxTokens *int `json:"maxTokens,omitempty"`
}
@@ -1181,12 +1182,16 @@ func (e ProviderType) MarshalGQL(w io.Writer) {
type ReasoningEffort string
const (
+ ReasoningEffortXhigh ReasoningEffort = "xhigh"
+ ReasoningEffortMax ReasoningEffort = "max"
ReasoningEffortHigh ReasoningEffort = "high"
ReasoningEffortMedium ReasoningEffort = "medium"
ReasoningEffortLow ReasoningEffort = "low"
)
var AllReasoningEffort = []ReasoningEffort{
+ ReasoningEffortXhigh,
+ ReasoningEffortMax,
ReasoningEffortHigh,
ReasoningEffortMedium,
ReasoningEffortLow,
@@ -1194,7 +1199,7 @@ var AllReasoningEffort = []ReasoningEffort{
func (e ReasoningEffort) IsValid() bool {
switch e {
- case ReasoningEffortHigh, ReasoningEffortMedium, ReasoningEffortLow:
+ case ReasoningEffortXhigh, ReasoningEffortMax, ReasoningEffortHigh, ReasoningEffortMedium, ReasoningEffortLow:
return true
}
return false
@@ -1221,6 +1226,47 @@ func (e ReasoningEffort) MarshalGQL(w io.Writer) {
fmt.Fprint(w, strconv.Quote(e.String()))
}
+type ReasoningMode string
+
+const (
+ ReasoningModeAdaptive ReasoningMode = "adaptive"
+ ReasoningModeBudget ReasoningMode = "budget"
+)
+
+var AllReasoningMode = []ReasoningMode{
+ ReasoningModeAdaptive,
+ ReasoningModeBudget,
+}
+
+func (e ReasoningMode) IsValid() bool {
+ switch e {
+ case ReasoningModeAdaptive, ReasoningModeBudget:
+ return true
+ }
+ return false
+}
+
+func (e ReasoningMode) String() string {
+ return string(e)
+}
+
+func (e *ReasoningMode) UnmarshalGQL(v interface{}) error {
+ str, ok := v.(string)
+ if !ok {
+ return fmt.Errorf("enums must be strings")
+ }
+
+ *e = ReasoningMode(str)
+ if !e.IsValid() {
+ return fmt.Errorf("%s is not a valid ReasoningMode", str)
+ }
+ return nil
+}
+
+func (e ReasoningMode) MarshalGQL(w io.Writer) {
+ fmt.Fprint(w, strconv.Quote(e.String()))
+}
+
type ResultFormat string
const (
diff --git a/backend/pkg/graph/schema.graphqls b/backend/pkg/graph/schema.graphqls
index f240c330..b1ab2a63 100644
--- a/backend/pkg/graph/schema.graphqls
+++ b/backend/pkg/graph/schema.graphqls
@@ -23,13 +23,21 @@ enum ProviderType {
qwen
}
-# Reasoning effort levels for advanced AI models (OpenAI format)
+# Reasoning effort levels for advanced AI models
enum ReasoningEffort {
+ xhigh
+ max
high
medium
low
}
+# Reasoning control mode for provider-specific thinking APIs
+enum ReasoningMode {
+ adaptive
+ budget
+}
+
# Template types for AI agent prompts and system operations
enum PromptType {
primary_agent
@@ -751,6 +759,7 @@ type ProviderConfig {
# AI model reasoning configuration
type ReasoningConfig {
+ mode: ReasoningMode
effort: ReasoningEffort
maxTokens: Int
}
@@ -800,6 +809,7 @@ type AgentsConfig {
# Input type for ReasoningConfig
input ReasoningConfigInput {
+ mode: ReasoningMode
effort: ReasoningEffort
maxTokens: Int
}
diff --git a/backend/pkg/providers/bedrock/adaptive_thinking.go b/backend/pkg/providers/bedrock/adaptive_thinking.go
new file mode 100644
index 00000000..a8befd64
--- /dev/null
+++ b/backend/pkg/providers/bedrock/adaptive_thinking.go
@@ -0,0 +1,173 @@
+package bedrock
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "strconv"
+
+ "pentagi/pkg/providers/pconfig"
+
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+ "github.com/vxcontrol/langchaingo/llms"
+)
+
+type adaptiveThinkingEffortContextKey struct{}
+
+func withAdaptiveThinkingEffort(ctx context.Context, effort string) context.Context {
+ if effort == "" {
+ effort = string(llms.ReasoningHigh)
+ }
+
+ return context.WithValue(ctx, adaptiveThinkingEffortContextKey{}, effort)
+}
+
+func adaptiveThinkingEffortFromContext(ctx context.Context) (string, bool) {
+ effort, ok := ctx.Value(adaptiveThinkingEffortContextKey{}).(string)
+ return effort, ok && effort != ""
+}
+
+func addAdaptiveThinkingMiddleware(stack *middleware.Stack) error {
+ return stack.Build.Add(middleware.BuildMiddlewareFunc(
+ "PentAGIBedrockAdaptiveThinking",
+ func(ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler) (
+ middleware.BuildOutput,
+ middleware.Metadata,
+ error,
+ ) {
+ effort, ok := adaptiveThinkingEffortFromContext(ctx)
+ if !ok {
+ return next.HandleBuild(ctx, in)
+ }
+
+ req, ok := in.Request.(*smithyhttp.Request)
+ if !ok || req.GetStream() == nil {
+ return next.HandleBuild(ctx, in)
+ }
+
+ body, err := io.ReadAll(req.GetStream())
+ if err != nil {
+ return middleware.BuildOutput{}, middleware.Metadata{}, fmt.Errorf("read Bedrock request body: %w", err)
+ }
+
+ updatedBody, err := rewriteAdaptiveThinkingBody(body, effort)
+ if err != nil {
+ return middleware.BuildOutput{}, middleware.Metadata{}, err
+ }
+
+ updatedReq, err := req.SetStream(bytes.NewReader(updatedBody))
+ if err != nil {
+ return middleware.BuildOutput{}, middleware.Metadata{}, fmt.Errorf("replace Bedrock request body: %w", err)
+ }
+ updatedReq.ContentLength = int64(len(updatedBody))
+ updatedReq.Header.Set("Content-Length", strconv.Itoa(len(updatedBody)))
+ in.Request = updatedReq
+
+ return next.HandleBuild(ctx, in)
+ },
+ ), middleware.After)
+}
+
+func rewriteAdaptiveThinkingBody(body []byte, effort string) ([]byte, error) {
+ // langchaingo currently emits budget-based Anthropic thinking for Bedrock;
+ // Claude adaptive thinking expects thinking.type=adaptive plus output_config.effort.
+ var payload map[string]any
+ if err := json.Unmarshal(body, &payload); err != nil {
+ return nil, fmt.Errorf("decode Bedrock request body: %w", err)
+ }
+
+ fields, ok := payload["additionalModelRequestFields"].(map[string]any)
+ if !ok {
+ return body, nil
+ }
+
+ thinking, ok := fields["thinking"].(map[string]any)
+ if !ok {
+ return body, nil
+ }
+
+ thinking["type"] = "adaptive"
+ delete(thinking, "budget_tokens")
+ fields["output_config"] = map[string]any{
+ "effort": effort,
+ }
+
+ updatedBody, err := json.Marshal(payload)
+ if err != nil {
+ return nil, fmt.Errorf("encode Bedrock request body: %w", err)
+ }
+
+ return updatedBody, nil
+}
+
+func (p *bedrockProvider) prepareCallOptions(
+ ctx context.Context,
+ opt pconfig.ProviderOptionsType,
+ options []llms.CallOption,
+) (context.Context, []llms.CallOption) {
+ reasoning, ok := p.reasoningConfigForType(opt)
+ if !ok || reasoning.EffectiveMode() != pconfig.ReasoningModeAdaptive {
+ return ctx, options
+ }
+
+ effort := string(reasoning.Effort)
+ ctx = withAdaptiveThinkingEffort(ctx, effort)
+ options = append(options, llms.WithReasoning(llms.ReasoningHigh, 0))
+
+ return ctx, options
+}
+
+func (p *bedrockProvider) reasoningConfigForType(opt pconfig.ProviderOptionsType) (pconfig.ReasoningConfig, bool) {
+ agentConfig := p.agentConfigForType(opt)
+ if agentConfig == nil || agentConfig.Reasoning.IsZero() {
+ return pconfig.ReasoningConfig{}, false
+ }
+
+ return agentConfig.Reasoning, true
+}
+
+func (p *bedrockProvider) agentConfigForType(opt pconfig.ProviderOptionsType) *pconfig.AgentConfig {
+ if p == nil || p.providerConfig == nil {
+ return nil
+ }
+
+ switch opt {
+ case pconfig.OptionsTypeSimple:
+ return p.providerConfig.Simple
+ case pconfig.OptionsTypeSimpleJSON:
+ if p.providerConfig.SimpleJSON != nil {
+ return p.providerConfig.SimpleJSON
+ }
+ return p.providerConfig.Simple
+ case pconfig.OptionsTypePrimaryAgent:
+ return p.providerConfig.PrimaryAgent
+ case pconfig.OptionsTypeAssistant:
+ if p.providerConfig.Assistant != nil {
+ return p.providerConfig.Assistant
+ }
+ return p.providerConfig.PrimaryAgent
+ case pconfig.OptionsTypeGenerator:
+ return p.providerConfig.Generator
+ case pconfig.OptionsTypeRefiner:
+ return p.providerConfig.Refiner
+ case pconfig.OptionsTypeAdviser:
+ return p.providerConfig.Adviser
+ case pconfig.OptionsTypeReflector:
+ return p.providerConfig.Reflector
+ case pconfig.OptionsTypeSearcher:
+ return p.providerConfig.Searcher
+ case pconfig.OptionsTypeEnricher:
+ return p.providerConfig.Enricher
+ case pconfig.OptionsTypeCoder:
+ return p.providerConfig.Coder
+ case pconfig.OptionsTypeInstaller:
+ return p.providerConfig.Installer
+ case pconfig.OptionsTypePentester:
+ return p.providerConfig.Pentester
+ default:
+ return nil
+ }
+}
diff --git a/backend/pkg/providers/bedrock/adaptive_thinking_test.go b/backend/pkg/providers/bedrock/adaptive_thinking_test.go
new file mode 100644
index 00000000..2bbbd4e1
--- /dev/null
+++ b/backend/pkg/providers/bedrock/adaptive_thinking_test.go
@@ -0,0 +1,46 @@
+package bedrock
+
+import (
+ "encoding/json"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestRewriteAdaptiveThinkingBody(t *testing.T) {
+ body := []byte(`{
+ "additionalModelRequestFields": {
+ "thinking": {
+ "type": "enabled",
+ "budget_tokens": 4096
+ }
+ },
+ "inferenceConfig": {
+ "maxTokens": 16384
+ }
+ }`)
+
+ updatedBody, err := rewriteAdaptiveThinkingBody(body, "xhigh")
+ require.NoError(t, err)
+
+ var payload map[string]any
+ require.NoError(t, json.Unmarshal(updatedBody, &payload))
+
+ fields := payload["additionalModelRequestFields"].(map[string]any)
+ thinking := fields["thinking"].(map[string]any)
+ outputConfig := fields["output_config"].(map[string]any)
+
+ assert.Equal(t, "adaptive", thinking["type"])
+ assert.NotContains(t, thinking, "budget_tokens")
+ assert.Equal(t, "xhigh", outputConfig["effort"])
+ assert.Equal(t, map[string]any{"maxTokens": float64(16384)}, payload["inferenceConfig"])
+}
+
+func TestRewriteAdaptiveThinkingBodyWithoutThinking(t *testing.T) {
+ body := []byte(`{"inferenceConfig":{"maxTokens":1024}}`)
+
+ updatedBody, err := rewriteAdaptiveThinkingBody(body, "high")
+ require.NoError(t, err)
+ assert.JSONEq(t, string(body), string(updatedBody))
+}
diff --git a/backend/pkg/providers/bedrock/bedrock.go b/backend/pkg/providers/bedrock/bedrock.go
index ab300bad..3bc8b3b7 100644
--- a/backend/pkg/providers/bedrock/bedrock.go
+++ b/backend/pkg/providers/bedrock/bedrock.go
@@ -20,6 +20,7 @@ import (
"github.com/aws/aws-sdk-go-v2/credentials"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
smithybearer "github.com/aws/smithy-go/auth/bearer"
+ "github.com/aws/smithy-go/middleware"
"github.com/invopop/jsonschema"
"github.com/vxcontrol/langchaingo/llms"
"github.com/vxcontrol/langchaingo/llms/bedrock"
@@ -134,6 +135,9 @@ func New(
) (provider.Provider, error) {
opts := []func(*bconfig.LoadOptions) error{
bconfig.WithRegion(cfg.BedrockRegion),
+ bconfig.WithAPIOptions([]func(*middleware.Stack) error{
+ addAdaptiveThinkingMiddleware,
+ }),
}
// Choose authentication strategy based on configuration
@@ -245,9 +249,10 @@ func (p *bedrockProvider) Call(
opt pconfig.ProviderOptionsType,
prompt string,
) (string, error) {
+ ctx, options := p.prepareCallOptions(ctx, opt, p.providerConfig.GetOptionsForType(opt))
+
return provider.WrapGenerateFromSinglePrompt(
- ctx, p, opt, p.llm, prompt,
- p.providerConfig.GetOptionsForType(opt)...,
+ ctx, p, opt, p.llm, prompt, options...,
)
}
@@ -273,10 +278,11 @@ func (p *bedrockProvider) CallEx(
// Clean tools from $schema field
tools = cleanToolSchemas(tools)
- // Build final options: streaming + config + cleaned tools LAST (to override any dirty tools from config)
+ // Put cleaned tools after config to override any dirty tools restored from config.
options := []llms.CallOption{llms.WithStreamingFunc(streamCb)}
options = append(options, configOptions...)
options = append(options, llms.WithTools(tools))
+ ctx, options = p.prepareCallOptions(ctx, opt, options)
return provider.WrapGenerateContent(ctx, p, opt, p.llm.GenerateContent, chain, options...)
}
@@ -299,8 +305,9 @@ func (p *bedrockProvider) CallWithTools(
configOptions := p.providerConfig.GetOptionsForType(opt)
- // Build final options: config + streaming + cleaned tools LAST (to override any dirty tools from config)
+ // Put cleaned tools after config to override any dirty tools restored from config.
options := append(configOptions, llms.WithStreamingFunc(streamCb), llms.WithTools(tools))
+ ctx, options = p.prepareCallOptions(ctx, opt, options)
return provider.WrapGenerateContent(ctx, p, opt, p.llm.GenerateContent, chain, options...)
}
diff --git a/backend/pkg/providers/bedrock/config.yml b/backend/pkg/providers/bedrock/config.yml
index dc877e50..9848cc4c 100644
--- a/backend/pkg/providers/bedrock/config.yml
+++ b/backend/pkg/providers/bedrock/config.yml
@@ -83,7 +83,8 @@ adviser:
n: 1
max_tokens: 16384
reasoning:
- max_tokens: 4096
+ mode: adaptive
+ effort: high
price:
input: 5.0
output: 25.0
diff --git a/backend/pkg/providers/bedrock/models.yml b/backend/pkg/providers/bedrock/models.yml
index 20f3c706..b656f95e 100644
--- a/backend/pkg/providers/bedrock/models.yml
+++ b/backend/pkg/providers/bedrock/models.yml
@@ -39,6 +39,17 @@
input: 0.035
output: 0.14
+# Anthropic Claude 4.7 Series - Latest Opus generation with adaptive thinking
+- name: us.anthropic.claude-opus-4-7
+ description: Most capable Opus model for advanced software engineering, long-running agentic tasks, professional work, and rigorous security analysis with adaptive thinking
+ thinking: true
+ release_date: 2026-04-16
+ price:
+ input: 5.0
+ output: 25.0
+ cache_read: 0.5
+ cache_write: 6.25
+
# Anthropic Claude 4.6 Series - Latest generation with world-class coding and agentic capabilities
- name: us.anthropic.claude-opus-4-6-v1
description: World's best model for coding, enterprise agents, and professional work with industry-leading reliability for agentic workflows and security analysis
diff --git a/backend/pkg/providers/pconfig/config.go b/backend/pkg/providers/pconfig/config.go
index eaf4e0a0..8c9754b7 100644
--- a/backend/pkg/providers/pconfig/config.go
+++ b/backend/pkg/providers/pconfig/config.go
@@ -185,11 +185,36 @@ type PriceInfo struct {
CacheWrite float64 `json:"cache_write,omitempty" yaml:"cache_write,omitempty"`
}
+type ReasoningMode string
+
+const (
+ ReasoningModeDefault ReasoningMode = ""
+ ReasoningModeAdaptive ReasoningMode = "adaptive"
+ ReasoningModeBudget ReasoningMode = "budget"
+)
+
type ReasoningConfig struct {
+ Mode ReasoningMode `json:"mode,omitempty" yaml:"mode,omitempty"`
Effort llms.ReasoningEffort `json:"effort,omitempty" yaml:"effort,omitempty"`
MaxTokens int `json:"max_tokens,omitempty" yaml:"max_tokens,omitempty"`
}
+func (rc ReasoningConfig) IsZero() bool {
+ return rc.Mode == ReasoningModeDefault &&
+ rc.Effort == llms.ReasoningNone &&
+ rc.MaxTokens == 0
+}
+
+func (rc ReasoningConfig) EffectiveMode() ReasoningMode {
+ if rc.Mode != ReasoningModeDefault {
+ return rc.Mode
+ }
+ if rc.MaxTokens != 0 && (rc.Effort == llms.ReasoningNone || rc.Effort == llms.ReasoningEffort("none")) {
+ return ReasoningModeBudget
+ }
+ return ReasoningModeDefault
+}
+
// AgentConfig represents the configuration for a single agent
type AgentConfig struct {
Model string `json:"model,omitempty" yaml:"model,omitempty"`
@@ -572,14 +597,21 @@ func (ac *AgentConfig) BuildOptions() []llms.CallOption {
if _, ok := ac.raw["response_mime_type"]; ok && ac.ResponseMIMEType != "" {
options = append(options, llms.WithResponseMIMEType(ac.ResponseMIMEType))
}
- if _, ok := ac.raw["reasoning"]; ok && (ac.Reasoning.Effort != llms.ReasoningNone || ac.Reasoning.MaxTokens != 0) {
- switch ac.Reasoning.Effort {
- case llms.ReasoningLow, llms.ReasoningMedium, llms.ReasoningHigh:
- options = append(options, llms.WithReasoning(ac.Reasoning.Effort, 0))
- default:
+ if _, ok := ac.raw["reasoning"]; ok && !ac.Reasoning.IsZero() {
+ switch ac.Reasoning.EffectiveMode() {
+ case ReasoningModeAdaptive:
+ // Adaptive thinking is applied per-call by the provider that supports it
+ // (Bedrock rewrites the Converse body in prepareCallOptions); no generic
+ // CallOption is emitted here.
+ case ReasoningModeBudget:
if ac.Reasoning.MaxTokens > 0 && ac.Reasoning.MaxTokens <= 32000 {
options = append(options, llms.WithReasoning(llms.ReasoningNone, ac.Reasoning.MaxTokens))
}
+ default:
+ switch ac.Reasoning.Effort {
+ case llms.ReasoningLow, llms.ReasoningMedium, llms.ReasoningHigh:
+ options = append(options, llms.WithReasoning(ac.Reasoning.Effort, 0))
+ }
}
}
if _, ok := ac.raw["extra_body"]; ok && ac.ExtraBody != nil {
@@ -643,7 +675,7 @@ func (ac *AgentConfig) marshalMap() map[string]any {
if ac.ResponseMIMEType != "" {
output["response_mime_type"] = ac.ResponseMIMEType
}
- if ac.Reasoning.Effort != llms.ReasoningNone || ac.Reasoning.MaxTokens != 0 {
+ if !ac.Reasoning.IsZero() {
output["reasoning"] = ac.Reasoning
}
if ac.Price != nil {
diff --git a/backend/pkg/providers/pconfig/config_test.go b/backend/pkg/providers/pconfig/config_test.go
index e899de7b..8d0fbff1 100644
--- a/backend/pkg/providers/pconfig/config_test.go
+++ b/backend/pkg/providers/pconfig/config_test.go
@@ -47,6 +47,14 @@ func TestReasoningConfig_UnmarshalJSON(t *testing.T) {
MaxTokens: 2000,
},
},
+ {
+ name: "with adaptive mode",
+ json: `{"mode": "adaptive", "effort": "xhigh"}`,
+ want: ReasoningConfig{
+ Mode: ReasoningModeAdaptive,
+ Effort: llms.ReasoningEffort("xhigh"),
+ },
+ },
{
name: "invalid json",
json: "{invalid}",
@@ -65,6 +73,7 @@ func TestReasoningConfig_UnmarshalJSON(t *testing.T) {
}
require.NoError(t, err)
+ assert.Equal(t, tt.want.Mode, got.Mode)
assert.Equal(t, tt.want.Effort, got.Effort)
assert.Equal(t, tt.want.MaxTokens, got.MaxTokens)
})
@@ -108,6 +117,17 @@ max_tokens: 2000
MaxTokens: 2000,
},
},
+ {
+ name: "with adaptive mode",
+ yaml: `
+mode: adaptive
+effort: xhigh
+`,
+ want: ReasoningConfig{
+ Mode: ReasoningModeAdaptive,
+ Effort: llms.ReasoningEffort("xhigh"),
+ },
+ },
{
name: "invalid yaml",
yaml: "invalid: [yaml",
@@ -126,6 +146,7 @@ max_tokens: 2000
}
require.NoError(t, err)
+ assert.Equal(t, tt.want.Mode, got.Mode)
assert.Equal(t, tt.want.Effort, got.Effort)
assert.Equal(t, tt.want.MaxTokens, got.MaxTokens)
})
@@ -923,6 +944,28 @@ func TestAgentConfig_BuildOptions(t *testing.T) {
}`,
wantLen: 3, // model, temperature, reasoning (max_tokens is set)
},
+ {
+ name: "with adaptive reasoning mode",
+ format: "json",
+ config: `{
+ "model": "test-model",
+ "temperature": 0.7,
+ "reasoning": {
+ "mode": "adaptive",
+ "effort": "xhigh"
+ }
+ }`,
+ wantLen: 2, // model, temperature; adaptive reasoning is applied per-call by the provider, not here
+ checkOptions: func(t *testing.T, options []llms.CallOption) {
+ var opts llms.CallOptions
+ for _, option := range options {
+ option(&opts)
+ }
+
+ assert.Nil(t, opts.Metadata)
+ assert.Nil(t, opts.Reasoning)
+ },
+ },
{
name: "with invalid reasoning tokens over limit",
format: "json",
diff --git a/frontend/graphql-schema.graphql b/frontend/graphql-schema.graphql
index 5cf78c8b..b0373faa 100644
--- a/frontend/graphql-schema.graphql
+++ b/frontend/graphql-schema.graphql
@@ -315,6 +315,7 @@ fragment agentConfigFragment on AgentConfig {
frequencyPenalty
presencePenalty
reasoning {
+ mode
effort
maxTokens
}