Skip to content

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

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.go
index 266cf391..2392a1c3 100644
--- a/backend/pkg/database/converter/converter_test.go
+++ b/backend/pkg/database/converter/converter_test.go
@@ -2,6 +2,13 @@ package converter
import (
"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.go
index 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 bedrock
import (
+ "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.go
index 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())
+}