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
test(bedrock,pconfig,converter): cover adaptive-thinking backstop + reasoning (refs #288)
Sergey Kozyrenko001566c11a51
diff --git a/backend/pkg/database/converter/converter_test.go b/backend/pkg/database/converter/converter_test.goindex 266cf391..2392a1c3 100644--- a/backend/pkg/database/converter/converter_test.go+++ b/backend/pkg/database/converter/converter_test.go@@ -2,6 +2,13 @@ package converterimport ("testing"++ "pentagi/pkg/graph/model"+ "pentagi/pkg/providers/pconfig"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+ "github.com/vxcontrol/langchaingo/llms")func TestIsAgentTool(t *testing.T) {@@ -56,3 +63,32 @@ func TestIsAgentTool(t *testing.T) {})}}++func TestConvertModelsReasoning(t *testing.T) {+ models := pconfig.ModelsConfig{+ {Name: "ao", Reasoning: &pconfig.ModelReasoningInfo{+ Mode: pconfig.ModelReasoningAdaptiveOnly,+ Efforts: []llms.ReasoningEffort{llms.ReasoningLow, llms.ReasoningEffort("xhigh")},+ }},+ {Name: "ad", Reasoning: &pconfig.ModelReasoningInfo{Mode: pconfig.ModelReasoningAdaptive}},+ {Name: "bd", Reasoning: &pconfig.ModelReasoningInfo{Mode: pconfig.ModelReasoningBudget}},+ {Name: "none"},+ }++ byName := make(map[string]*model.ModelConfig)+ for _, m := range ConvertModels(models) {+ byName[m.Name] = m+ }++ require.NotNil(t, byName["ao"].Reasoning)+ require.NotNil(t, byName["ao"].Reasoning.Mode)+ assert.Equal(t, model.ModelReasoningModeAdaptiveOnly, *byName["ao"].Reasoning.Mode, "hyphenated pconfig value must map to the GraphQL underscore enum")+ assert.Equal(t, []model.ReasoningEffort{model.ReasoningEffort("low"), model.ReasoningEffort("xhigh")}, byName["ao"].Reasoning.Efforts)++ require.NotNil(t, byName["ad"].Reasoning.Mode)+ assert.Equal(t, model.ModelReasoningModeAdaptive, *byName["ad"].Reasoning.Mode)+ require.NotNil(t, byName["bd"].Reasoning.Mode)+ assert.Equal(t, model.ModelReasoningModeBudget, *byName["bd"].Reasoning.Mode)++ assert.Nil(t, byName["none"].Reasoning, "model without a reasoning descriptor maps to nil")+}diff --git a/backend/pkg/providers/bedrock/adaptive_thinking_test.go b/backend/pkg/providers/bedrock/adaptive_thinking_test.goindex e3ac7ab1..2908d833 100644--- a/backend/pkg/providers/bedrock/adaptive_thinking_test.go+++ b/backend/pkg/providers/bedrock/adaptive_thinking_test.go@@ -1,11 +1,16 @@package bedrockimport (+ "context""encoding/json""testing"+ "pentagi/pkg/config"+ "pentagi/pkg/providers/pconfig"+"github.com/stretchr/testify/assert""github.com/stretchr/testify/require"+ "github.com/vxcontrol/langchaingo/llms")func TestRewriteAdaptiveThinkingBody(t *testing.T) {@@ -70,3 +75,45 @@ func TestRewriteAdaptiveThinkingBodyStripsSamplingAndSetsDisplay(t *testing.T) {// Opus 4.7+ reject sampling params; only maxTokens must survive in inferenceConfig.assert.Equal(t, map[string]any{"maxTokens": float64(16384)}, payload["inferenceConfig"])}++// TestBackstopForcesAdaptiveForAdaptiveOnlyModel verifies that an adaptive-only+// model (from models.yml) forces adaptive thinking via prepareCallOptions even+// when the agent config carries no reasoning block.+func TestBackstopForcesAdaptiveForAdaptiveOnlyModel(t *testing.T) {+ models, err := DefaultModels(&config.Config{})+ require.NoError(t, err)++ pc, err := BuildProviderConfig([]byte("simple:\n model: us.anthropic.claude-opus-4-8\n temperature: 1.0\n n: 1\n max_tokens: 4000\n"))+ require.NoError(t, err)++ p := &bedrockProvider{providerConfig: pc, models: models}++ assert.Equal(t, pconfig.ModelReasoningAdaptiveOnly, p.modelReasoningMode(pconfig.OptionsTypeSimple))+ assert.True(t, p.usesAdaptiveThinking(pconfig.OptionsTypeSimple),+ "adaptive-only model must force adaptive even without an agent reasoning block")++ ctx, options := p.prepareCallOptions(context.Background(), pconfig.OptionsTypeSimple, nil)+ effort, ok := adaptiveThinkingEffortFromContext(ctx)+ assert.True(t, ok, "effort must be installed in context for the middleware")+ assert.Equal(t, string(llms.ReasoningHigh), effort)+ assert.NotEmpty(t, options, "WithReasoning must be appended so langchaingo emits a thinking block")+}++func TestBackstopLeavesNonReasoningModelUntouched(t *testing.T) {+ models, err := DefaultModels(&config.Config{})+ require.NoError(t, err)++ // gpt-oss has no adaptive-only descriptor; with no agent reasoning block it must not force adaptive.+ pc, err := BuildProviderConfig([]byte("simple:\n model: openai.gpt-oss-120b-1:0\n temperature: 0.5\n n: 1\n max_tokens: 4000\n"))+ require.NoError(t, err)++ p := &bedrockProvider{providerConfig: pc, models: models}++ assert.NotEqual(t, pconfig.ModelReasoningAdaptiveOnly, p.modelReasoningMode(pconfig.OptionsTypeSimple))+ assert.False(t, p.usesAdaptiveThinking(pconfig.OptionsTypeSimple))++ ctx, options := p.prepareCallOptions(context.Background(), pconfig.OptionsTypeSimple, nil)+ _, ok := adaptiveThinkingEffortFromContext(ctx)+ assert.False(t, ok, "no adaptive effort should be set for a non-adaptive model")+ assert.Empty(t, options)+}diff --git a/backend/pkg/providers/pconfig/config_test.go b/backend/pkg/providers/pconfig/config_test.goindex 1f9a53a9..4b119afe 100644--- a/backend/pkg/providers/pconfig/config_test.go+++ b/backend/pkg/providers/pconfig/config_test.go@@ -1929,3 +1929,30 @@ func TestModelConfigReasoningCapability(t *testing.T) {require.NotNil(t, back.Reasoning, "reasoning must survive JSON round-trip")assert.Equal(t, ModelReasoningAdaptiveOnly, back.Reasoning.Mode)}++func TestReasoningConfig_EffectiveMode(t *testing.T) {+ tests := []struct {+ name string+ rc ReasoningConfig+ want ReasoningMode+ }{+ {"empty -> default", ReasoningConfig{}, ReasoningModeDefault},+ {"explicit adaptive", ReasoningConfig{Mode: ReasoningModeAdaptive}, ReasoningModeAdaptive},+ {"explicit budget", ReasoningConfig{Mode: ReasoningModeBudget}, ReasoningModeBudget},+ {"effort only, no mode/tokens -> default", ReasoningConfig{Effort: llms.ReasoningHigh}, ReasoningModeDefault},+ {"max_tokens, no effort -> budget", ReasoningConfig{MaxTokens: 5000}, ReasoningModeBudget},+ {"max_tokens + none effort -> budget", ReasoningConfig{Effort: llms.ReasoningNone, MaxTokens: 5000}, ReasoningModeBudget},+ }+ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ assert.Equal(t, tt.want, tt.rc.EffectiveMode())+ })+ }+}++func TestReasoningConfig_IsZero(t *testing.T) {+ assert.True(t, ReasoningConfig{}.IsZero())+ assert.False(t, ReasoningConfig{Mode: ReasoningModeAdaptive}.IsZero())+ assert.False(t, ReasoningConfig{Effort: llms.ReasoningLow}.IsZero())+ assert.False(t, ReasoningConfig{MaxTokens: 1}.IsZero())+}