Fully autonomous AI Agents system capable of performing complex penetration testing tasks
Go ai-agentsai-security-toolanthropicautonomous-agentsgolanggptgraphqlmulti-agent-systemoffensive-securityopen-sourceopenaipenetration-testingpenetration-testing-toolsreactsecurity-automationsecurity-testingsecurity-toolsself-hosted
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.goindex 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.AgentConfigif 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.goindex 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) intMaxTokens func(childComplexity int) int+ Mode func(childComplexity int) int}Screenshot struct {@@ -3456,6 +3457,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn 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.ContextIsResolver: 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, fieldreturn 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.ConteasMap[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 = datacase "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.Selectswitch 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ᚋmreturn 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.Nulldiff --git a/backend/pkg/graph/model/models_gen.go b/backend/pkg/graph/model/models_gen.goindex 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 stringconst (+ 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 stringconst (diff --git a/backend/pkg/graph/schema.graphqls b/backend/pkg/graph/schema.graphqlsindex 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 modelsenum ReasoningEffort {+ xhigh+ maxhighmediumlow}+# Reasoning control mode for provider-specific thinking APIs+enum ReasoningMode {+ adaptive+ budget+}+# Template types for AI agent prompts and system operationsenum PromptType {primary_agent@@ -751,6 +759,7 @@ type ProviderConfig {# AI model reasoning configurationtype ReasoningConfig {+ mode: ReasoningModeeffort: ReasoningEffortmaxTokens: Int}@@ -800,6 +809,7 @@ type AgentsConfig {# Input type for ReasoningConfiginput ReasoningConfigInput {+ mode: ReasoningModeeffort: ReasoningEffortmaxTokens: Int}diff --git a/backend/pkg/providers/bedrock/adaptive_thinking.go b/backend/pkg/providers/bedrock/adaptive_thinking.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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 fieldtools = 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.ymlindex dc877e50..9848cc4c 100644--- a/backend/pkg/providers/bedrock/config.yml+++ b/backend/pkg/providers/bedrock/config.yml@@ -83,7 +83,8 @@ adviser:n: 1max_tokens: 16384reasoning:- max_tokens: 4096+ mode: adaptive+ effort: highprice:input: 5.0output: 25.0diff --git a/backend/pkg/providers/bedrock/models.yml b/backend/pkg/providers/bedrock/models.ymlindex 20f3c706..b656f95e 100644--- a/backend/pkg/providers/bedrock/models.yml+++ b/backend/pkg/providers/bedrock/models.yml@@ -39,6 +39,17 @@input: 0.035output: 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-v1description: World's best model for coding, enterprise agents, and professional work with industry-leading reliability for agentic workflows and security analysisdiff --git a/backend/pkg/providers/pconfig/config.go b/backend/pkg/providers/pconfig/config.goindex 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 agenttype 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.goindex 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: 2000MaxTokens: 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.graphqlindex 5cf78c8b..b0373faa 100644--- a/frontend/graphql-schema.graphql+++ b/frontend/graphql-schema.graphql@@ -315,6 +315,7 @@ fragment agentConfigFragment on AgentConfig {frequencyPenaltypresencePenaltyreasoning {+ modeeffortmaxTokens}