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(reasoning): add three-state On/Off/Default reasoning control
Sergey Kozyrenko2853c9754993
diff --git a/backend/pkg/database/converter/converter.go b/backend/pkg/database/converter/converter.goindex 4c1eecfc..7153833b 100644--- a/backend/pkg/database/converter/converter.go+++ b/backend/pkg/database/converter/converter.go@@ -12,6 +12,7 @@ import ("pentagi/pkg/tools""github.com/vxcontrol/langchaingo/llms"+ "github.com/vxcontrol/langchaingo/llms/reasoning")func ConvertFlows(flows []database.Flow, containers []database.Container) []*model.Flow {@@ -537,7 +538,7 @@ func ConvertFlowTemplates(templates []database.FlowTemplate) []*model.FlowTemplareturn result}-func ConvertModels(models pconfig.ModelsConfig) []*model.ModelConfig {+func ConvertModels(models pconfig.ModelsConfig, rp reasoning.Provider) []*model.ModelConfig {gmodels := make([]*model.ModelConfig, 0, len(models))for _, m := range models {modelConfig := &model.ModelConfig{@@ -562,16 +563,33 @@ func ConvertModels(models pconfig.ModelsConfig) []*model.ModelConfig {if m.Thinking != nil {modelConfig.Thinking = m.Thinking}- if m.Reasoning != nil {- reasoning := &model.ModelReasoningInfo{}- if m.Reasoning.Mode != pconfig.ModelReasoningNone {- mode := convertModelReasoningMode(m.Reasoning.Mode)- reasoning.Mode = &mode+ // Surface reasoning capability for any thinking-capable model, not only+ // those with an explicit reasoning block: models like Gemini declare+ // thinking:true with no reasoning section, yet Off (thinkingBudget:0) is+ // meaningful and supported.+ if m.Reasoning != nil || (m.Thinking != nil && *m.Thinking) {+ reasoningInfo := &model.ModelReasoningInfo{}+ if m.Reasoning != nil {+ if m.Reasoning.Mode != pconfig.ModelReasoningNone {+ mode := convertModelReasoningMode(m.Reasoning.Mode)+ reasoningInfo.Mode = &mode+ }+ for _, effort := range m.Reasoning.Efforts {+ reasoningInfo.Efforts = append(reasoningInfo.Efforts, model.ReasoningEffort(effort))+ }}- for _, effort := range m.Reasoning.Efforts {- reasoning.Efforts = append(reasoning.Efforts, model.ReasoningEffort(effort))- }- modelConfig.Reasoning = reasoning+ // Capability is derived from the langchaingo reasoning tables (single+ // source of truth). cannotDisable reports whether Off would take no+ // effect — either the API rejects it, or the disable wire is omitted on+ // a model that is NOT off by default (an unclassified default-on model+ // where Off is a silent no-op) — so the UI only offers Off when it works.+ support := llms.ReasoningSupportFor(m.Name, rp)+ supported := support.Supported+ cannotDisable := !offEffective(reasoning.ResolveOff(m.Name, rp), support.DefaultOn)+ reasoningInfo.Supported = &supported+ reasoningInfo.CannotDisable = &cannotDisable+ reasoningInfo.DefaultOn = support.DefaultOn+ modelConfig.Reasoning = reasoningInfo}gmodels = append(gmodels, modelConfig)@@ -580,6 +598,21 @@ func ConvertModels(models pconfig.ModelsConfig) []*model.ModelConfig {return gmodels}+// offEffective reports whether turning reasoning Off actually disables thinking:+// a real disable wire always does; an omitted wire only does when the model is+// known to be off by default. A silent no-op (unclassified default-on model) or an+// API rejection (OffUnsupported) does not, so the UI must not offer Off there.+func offEffective(off reasoning.OffWire, defaultOn *bool) bool {+ switch off {+ case reasoning.OffDisableClaude, reasoning.OffZeroBudget, reasoning.OffEffortNone:+ return true+ case reasoning.OffOmit:+ return defaultOn != nil && !*defaultOn+ default: // OffUnsupported+ return false+ }+}+// Bridges the one spelling difference between the pconfig and GraphQL reasoning// enums: adaptive-only (hyphen) vs adaptive_only (underscore).func convertModelReasoningMode(m pconfig.ModelReasoningMode) model.ModelReasoningMode {diff --git a/backend/pkg/database/converter/converter_test.go b/backend/pkg/database/converter/converter_test.goindex 2392a1c3..88617227 100644--- a/backend/pkg/database/converter/converter_test.go+++ b/backend/pkg/database/converter/converter_test.go@@ -9,6 +9,7 @@ import ("github.com/stretchr/testify/assert""github.com/stretchr/testify/require""github.com/vxcontrol/langchaingo/llms"+ "github.com/vxcontrol/langchaingo/llms/reasoning")func TestIsAgentTool(t *testing.T) {@@ -76,7 +77,7 @@ func TestConvertModelsReasoning(t *testing.T) {}byName := make(map[string]*model.ModelConfig)- for _, m := range ConvertModels(models) {+ for _, m := range ConvertModels(models, reasoning.ProviderUnknown) {byName[m.Name] = m}@@ -92,3 +93,83 @@ func TestConvertModelsReasoning(t *testing.T) {assert.Nil(t, byName["none"].Reasoning, "model without a reasoning descriptor maps to nil")}++func TestConvertModels_OffCapability(t *testing.T) {+ tr := func(b bool) *bool { return &b }+ models := pconfig.ModelsConfig{+ // Gemini: thinking:true, no reasoning block -> capability still surfaced,+ // Off effective via thinkingBudget:0.+ {Name: "gemini-2.5-flash", Thinking: tr(true)},+ // Unclassified OpenAI-family reasoning model: Off is a silent no-op (OffOmit,+ // default-on unknown) -> cannotDisable must be true so the UI hides Off.+ {Name: "glm-5.2", Reasoning: &pconfig.ModelReasoningInfo{Mode: pconfig.ModelReasoningBudget}},+ // Adaptive-only but off by default: Off works by omission -> disablable.+ {Name: "claude-opus-4-8", Reasoning: &pconfig.ModelReasoningInfo{Mode: pconfig.ModelReasoningAdaptiveOnly}},+ // Always-on Claude: Off is rejected (OffUnsupported) -> not disablable.+ {Name: "claude-fable-5", Reasoning: &pconfig.ModelReasoningInfo{Mode: pconfig.ModelReasoningAdaptiveOnly}},+ // Plain non-thinking model: no reasoning capability at all.+ {Name: "gpt-4.1"},+ }++ byProvider := map[string]reasoning.Provider{+ "gemini-2.5-flash": reasoning.ProviderGoogleAI,+ "glm-5.2": reasoning.ProviderOpenAI,+ "claude-opus-4-8": reasoning.ProviderAnthropic,+ "claude-fable-5": reasoning.ProviderAnthropic,+ "gpt-4.1": reasoning.ProviderOpenAI,+ }++ get := func(name string) *model.ModelReasoningInfo {+ for _, mc := range ConvertModels(pconfig.ModelsConfig{lookup(models, name)}, byProvider[name]) {+ if mc.Name == name {+ return mc.Reasoning+ }+ }+ return nil+ }++ // Gemini: capability present, Off effective.+ gem := get("gemini-2.5-flash")+ require.NotNil(t, gem, "thinking-capable model must surface reasoning capability")+ require.NotNil(t, gem.CannotDisable)+ assert.False(t, *gem.CannotDisable, "Gemini Off works via thinkingBudget:0")++ // glm-5.2: Off is a no-op -> cannotDisable true (UI hides Off).+ glm := get("glm-5.2")+ require.NotNil(t, glm)+ require.NotNil(t, glm.CannotDisable)+ assert.True(t, *glm.CannotDisable, "unclassified default-on model: Off is a no-op, must hide it")++ // opus-4-8: off by default -> disablable.+ opus := get("claude-opus-4-8")+ require.NotNil(t, opus.CannotDisable)+ assert.False(t, *opus.CannotDisable, "off-by-default model: Off works by omission")++ // fable-5: always on -> not disablable.+ fable := get("claude-fable-5")+ require.NotNil(t, fable.CannotDisable)+ assert.True(t, *fable.CannotDisable, "always-on model rejects Off")++ // non-thinking model: no capability.+ assert.Nil(t, get("gpt-4.1"), "non-thinking model has no reasoning capability")+}++func lookup(ms pconfig.ModelsConfig, name string) pconfig.ModelConfig {+ for _, m := range ms {+ if m.Name == name {+ return m+ }+ }+ return pconfig.ModelConfig{}+}++func TestOffEffective(t *testing.T) {+ tr := func(b bool) *bool { return &b }+ assert.True(t, offEffective(reasoning.OffDisableClaude, nil))+ assert.True(t, offEffective(reasoning.OffZeroBudget, nil))+ assert.True(t, offEffective(reasoning.OffEffortNone, nil))+ assert.True(t, offEffective(reasoning.OffOmit, tr(false)), "off-by-default: omit disables")+ assert.False(t, offEffective(reasoning.OffOmit, tr(true)), "default-on + omit = no-op")+ assert.False(t, offEffective(reasoning.OffOmit, nil), "unknown default + omit = assume no-op")+ assert.False(t, offEffective(reasoning.OffUnsupported, nil), "rejected")+}diff --git a/backend/pkg/graph/generated.go b/backend/pkg/graph/generated.goindex 1ee82c35..cacfa2b1 100644--- a/backend/pkg/graph/generated.go+++ b/backend/pkg/graph/generated.go@@ -341,8 +341,11 @@ type ComplexityRoot struct {}ModelReasoningInfo struct {- Efforts func(childComplexity int) int- Mode func(childComplexity int) int+ CannotDisable func(childComplexity int) int+ DefaultOn func(childComplexity int) int+ Efforts func(childComplexity int) int+ Mode func(childComplexity int) int+ Supported func(childComplexity int) int}ModelUsageStats struct {@@ -2242,6 +2245,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.ModelPrice.Output(childComplexity), true+ case "ModelReasoningInfo.cannotDisable":+ if e.complexity.ModelReasoningInfo.CannotDisable == nil {+ break+ }++ return e.complexity.ModelReasoningInfo.CannotDisable(childComplexity), true++ case "ModelReasoningInfo.defaultOn":+ if e.complexity.ModelReasoningInfo.DefaultOn == nil {+ break+ }++ return e.complexity.ModelReasoningInfo.DefaultOn(childComplexity), true+case "ModelReasoningInfo.efforts":if e.complexity.ModelReasoningInfo.Efforts == nil {break@@ -2256,6 +2273,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.ModelReasoningInfo.Mode(childComplexity), true+ case "ModelReasoningInfo.supported":+ if e.complexity.ModelReasoningInfo.Supported == nil {+ break+ }++ return e.complexity.ModelReasoningInfo.Supported(childComplexity), true+case "ModelUsageStats.model":if e.complexity.ModelUsageStats.Model == nil {break@@ -17550,6 +17574,12 @@ func (ec *executionContext) fieldContext_ModelConfig_reasoning(_ context.Contextreturn ec.fieldContext_ModelReasoningInfo_mode(ctx, field)case "efforts":return ec.fieldContext_ModelReasoningInfo_efforts(ctx, field)+ case "supported":+ return ec.fieldContext_ModelReasoningInfo_supported(ctx, field)+ case "cannotDisable":+ return ec.fieldContext_ModelReasoningInfo_cannotDisable(ctx, field)+ case "defaultOn":+ return ec.fieldContext_ModelReasoningInfo_defaultOn(ctx, field)}return nil, fmt.Errorf("no field named %q was found under type ModelReasoningInfo", field.Name)},@@ -17866,6 +17896,129 @@ func (ec *executionContext) fieldContext_ModelReasoningInfo_efforts(_ context.Coreturn fc, nil}+func (ec *executionContext) _ModelReasoningInfo_supported(ctx context.Context, field graphql.CollectedField, obj *model.ModelReasoningInfo) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_ModelReasoningInfo_supported(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.Supported, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ return graphql.Null+ }+ res := resTmp.(*bool)+ fc.Result = res+ return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_ModelReasoningInfo_supported(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "ModelReasoningInfo",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Boolean does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _ModelReasoningInfo_cannotDisable(ctx context.Context, field graphql.CollectedField, obj *model.ModelReasoningInfo) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_ModelReasoningInfo_cannotDisable(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.CannotDisable, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ return graphql.Null+ }+ res := resTmp.(*bool)+ fc.Result = res+ return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_ModelReasoningInfo_cannotDisable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "ModelReasoningInfo",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Boolean does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _ModelReasoningInfo_defaultOn(ctx context.Context, field graphql.CollectedField, obj *model.ModelReasoningInfo) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_ModelReasoningInfo_defaultOn(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.DefaultOn, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ return graphql.Null+ }+ res := resTmp.(*bool)+ fc.Result = res+ return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_ModelReasoningInfo_defaultOn(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "ModelReasoningInfo",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ return nil, errors.New("field of type Boolean does not have child fields")+ },+ }+ return fc, nil+}+func (ec *executionContext) _ModelUsageStats_model(ctx context.Context, field graphql.CollectedField, obj *model.ModelUsageStats) (ret graphql.Marshaler) {fc, err := ec.fieldContext_ModelUsageStats_model(ctx, field)if err != nil {@@ -39088,6 +39241,12 @@ func (ec *executionContext) _ModelReasoningInfo(ctx context.Context, sel ast.Selout.Values[i] = ec._ModelReasoningInfo_mode(ctx, field, obj)case "efforts":out.Values[i] = ec._ModelReasoningInfo_efforts(ctx, field, obj)+ case "supported":+ out.Values[i] = ec._ModelReasoningInfo_supported(ctx, field, obj)+ case "cannotDisable":+ out.Values[i] = ec._ModelReasoningInfo_cannotDisable(ctx, field, obj)+ case "defaultOn":+ out.Values[i] = ec._ModelReasoningInfo_defaultOn(ctx, field, obj)default:panic("unknown field " + strconv.Quote(field.Name))}diff --git a/backend/pkg/graph/model/models_gen.go b/backend/pkg/graph/model/models_gen.goindex 78a63195..b1acc8b0 100644--- a/backend/pkg/graph/model/models_gen.go+++ b/backend/pkg/graph/model/models_gen.go@@ -329,8 +329,11 @@ type ModelPrice struct {}type ModelReasoningInfo struct {- Mode *ModelReasoningMode `json:"mode,omitempty"`- Efforts []ReasoningEffort `json:"efforts,omitempty"`+ Mode *ModelReasoningMode `json:"mode,omitempty"`+ Efforts []ReasoningEffort `json:"efforts,omitempty"`+ Supported *bool `json:"supported,omitempty"`+ CannotDisable *bool `json:"cannotDisable,omitempty"`+ DefaultOn *bool `json:"defaultOn,omitempty"`}type ModelUsageStats struct {@@ -1285,16 +1288,18 @@ type ReasoningMode stringconst (ReasoningModeAdaptive ReasoningMode = "adaptive"ReasoningModeBudget ReasoningMode = "budget"+ ReasoningModeOff ReasoningMode = "off")var AllReasoningMode = []ReasoningMode{ReasoningModeAdaptive,ReasoningModeBudget,+ ReasoningModeOff,}func (e ReasoningMode) IsValid() bool {switch e {- case ReasoningModeAdaptive, ReasoningModeBudget:+ case ReasoningModeAdaptive, ReasoningModeBudget, ReasoningModeOff:return true}return falsediff --git a/backend/pkg/graph/schema.graphqls b/backend/pkg/graph/schema.graphqlsindex 2e2c4fe9..9f8f2f96 100644--- a/backend/pkg/graph/schema.graphqls+++ b/backend/pkg/graph/schema.graphqls@@ -33,10 +33,13 @@ enum ReasoningEffort {low}-# Reasoning control mode for provider-specific thinking APIs+# Reasoning control mode for provider-specific thinking APIs. "off" explicitly+# disables thinking (distinct from an absent mode, which defers to the model+# default — models like Gemini 2.5 / Claude Fable 5 think by default).enum ReasoningMode {adaptivebudget+ off}# A model's reasoning capability — distinct from the per-agent ReasoningMode@@ -48,10 +51,17 @@ enum ModelReasoningMode {}# Declares how a model supports extended thinking so the UI can offer a valid-# mode/effort without hardcoding model names.+# mode/effort/on-off without hardcoding model names. The capability fields are+# derived from the langchaingo reasoning tables. An absent reasoning object means+# the model is not thinking-capable (no reasoning controls); cannotDisable=true+# hides the off option (the disable would error or be a no-op); defaultOn=true+# means the model thinks unless explicitly turned off.type ModelReasoningInfo {mode: ModelReasoningModeefforts: [ReasoningEffort!]+ supported: Boolean+ cannotDisable: Boolean+ defaultOn: Boolean}# Template types for AI agent prompts and system operationsdiff --git a/backend/pkg/graph/schema.resolvers.go b/backend/pkg/graph/schema.resolvers.goindex 4c832070..360b6a56 100644--- a/backend/pkg/graph/schema.resolvers.go+++ b/backend/pkg/graph/schema.resolvers.go@@ -2124,22 +2124,22 @@ func (r *queryResolver) SettingsProviders(ctx context.Context) (*model.Providerscase provider.ProviderOpenAI:config.Default.Openai = mpcfgif models, err := openai.DefaultModels(); err == nil {- config.Models.Openai = converter.ConvertModels(models)+ config.Models.Openai = converter.ConvertModels(models, prvtype.ReasoningProvider())}case provider.ProviderAnthropic:config.Default.Anthropic = mpcfgif models, err := anthropic.DefaultModels(); err == nil {- config.Models.Anthropic = converter.ConvertModels(models)+ config.Models.Anthropic = converter.ConvertModels(models, prvtype.ReasoningProvider())}case provider.ProviderGemini:config.Default.Gemini = mpcfgif models, err := gemini.DefaultModels(); err == nil {- config.Models.Gemini = converter.ConvertModels(models)+ config.Models.Gemini = converter.ConvertModels(models, prvtype.ReasoningProvider())}case provider.ProviderBedrock:config.Default.Bedrock = mpcfgif models, err := bedrock.DefaultModels(r.Config); err == nil {- config.Models.Bedrock = converter.ConvertModels(models)+ config.Models.Bedrock = converter.ConvertModels(models, prvtype.ReasoningProvider())} else {// A bad BEDROCK_MODELS_PATH otherwise yields an empty model list with no signal.r.Logger.WithError(err).Warn("failed to load bedrock models")@@ -2151,27 +2151,27 @@ func (r *queryResolver) SettingsProviders(ctx context.Context) (*model.Providerscase provider.ProviderDeepSeek:config.Default.Deepseek = mpcfgif models, err := deepseek.DefaultModels(); err == nil {- config.Models.Deepseek = converter.ConvertModels(models)+ config.Models.Deepseek = converter.ConvertModels(models, prvtype.ReasoningProvider())}case provider.ProviderGLM:config.Default.Glm = mpcfgif models, err := glm.DefaultModels(); err == nil {- config.Models.Glm = converter.ConvertModels(models)+ config.Models.Glm = converter.ConvertModels(models, prvtype.ReasoningProvider())}case provider.ProviderKimi:config.Default.Kimi = mpcfgif models, err := kimi.DefaultModels(); err == nil {- config.Models.Kimi = converter.ConvertModels(models)+ config.Models.Kimi = converter.ConvertModels(models, prvtype.ReasoningProvider())}case provider.ProviderQwen:config.Default.Qwen = mpcfgif models, err := qwen.DefaultModels(); err == nil {- config.Models.Qwen = converter.ConvertModels(models)+ config.Models.Qwen = converter.ConvertModels(models, prvtype.ReasoningProvider())}case provider.ProviderMiniMax:config.Default.Minimax = mpcfgif models, err := minimax.DefaultModels(); err == nil {- config.Models.Minimax = converter.ConvertModels(models)+ config.Models.Minimax = converter.ConvertModels(models, prvtype.ReasoningProvider())}}}@@ -2190,12 +2190,12 @@ func (r *queryResolver) SettingsProviders(ctx context.Context) (*model.Providerscase provider.ProviderOllama:config.Enabled.Ollama = trueif p, ok := defaultProviders[provider.DefaultProviderNameOllama]; ok {- config.Models.Ollama = converter.ConvertModels(p.GetModels())+ config.Models.Ollama = converter.ConvertModels(p.GetModels(), prvtype.ReasoningProvider())}case provider.ProviderCustom:config.Enabled.Custom = trueif p, ok := defaultProviders[provider.DefaultProviderNameCustom]; ok {- config.Models.Custom = converter.ConvertModels(p.GetModels())+ config.Models.Custom = converter.ConvertModels(p.GetModels(), prvtype.ReasoningProvider())}case provider.ProviderDeepSeek:config.Enabled.Deepseek = truediff --git a/backend/pkg/providers/pconfig/config.go b/backend/pkg/providers/pconfig/config.goindex ddb27975..f68a3213 100644--- a/backend/pkg/providers/pconfig/config.go+++ b/backend/pkg/providers/pconfig/config.go@@ -212,6 +212,10 @@ const (ReasoningModeDefault ReasoningMode = ""ReasoningModeAdaptive ReasoningMode = "adaptive"ReasoningModeBudget ReasoningMode = "budget"+ // ReasoningModeOff explicitly disables thinking. It is distinct from Default:+ // Default defers to the model (models like Gemini 2.5 / Claude Fable 5 think+ // by default), while Off forces the provider's disable wire via langchaingo.+ ReasoningModeOff ReasoningMode = "off")type ReasoningConfig struct {@@ -715,6 +719,8 @@ func (ac *AgentConfig) BuildOptions() []llms.CallOption {}if _, ok := ac.raw["reasoning"]; ok && !ac.Reasoning.IsZero() {switch ac.Reasoning.EffectiveMode() {+ case ReasoningModeOff:+ options = append(options, llms.WithReasoningDisabled())case ReasoningModeAdaptive:// Adaptive thinking is applied per-call by PrepareAdaptiveCallOptions// (it appends llms.WithAdaptiveReasoning); no CallOption is emitted here.@@ -997,6 +1003,12 @@ func (pc *ProviderConfig) reasoningConfigForType(opt ProviderOptionsType) (Reaso// thinking: the agent selected adaptive mode, or the model only supports adaptive// (e.g. Opus 4.7/4.8, where budget thinking returns a 400).func (pc *ProviderConfig) UsesAdaptiveThinking(models ModelsConfig, opt ProviderOptionsType) bool {+ // An explicit off wins over the adaptive-only auto-adaptive below: the caller+ // disabled thinking, so no adaptive CallOption may be appended (the disable is+ // emitted in BuildOptions instead).+ if reasoning, ok := pc.reasoningConfigForType(opt); ok && reasoning.EffectiveMode() == ReasoningModeOff {+ return false+ }if pc.modelReasoningMode(models, opt) == ModelReasoningAdaptiveOnly {return true}diff --git a/backend/pkg/providers/pconfig/config_test.go b/backend/pkg/providers/pconfig/config_test.goindex 94d1f4c0..2f25b85a 100644--- a/backend/pkg/providers/pconfig/config_test.go+++ b/backend/pkg/providers/pconfig/config_test.go@@ -29,6 +29,8 @@ func TestProviderConfig_UsesAdaptiveThinking(t *testing.T) {adaptiveOnly, &AgentConfig{Model: "opus-4-8"}, true},{"adaptive-only model overrides an agent budget choice",adaptiveOnly, &AgentConfig{Model: "opus-4-8", Reasoning: ReasoningConfig{Mode: ReasoningModeBudget, MaxTokens: 4096}}, true},+ {"explicit off wins over the adaptive-only auto-adaptive",+ adaptiveOnly, &AgentConfig{Model: "opus-4-8", Reasoning: ReasoningConfig{Mode: ReasoningModeOff}}, false},{"agent selects adaptive on an adaptive-capable model",adaptiveCapable, &AgentConfig{Model: "opus-4-6", Reasoning: ReasoningConfig{Mode: ReasoningModeAdaptive}}, true},{"agent selects budget on an adaptive-capable model",diff --git a/backend/pkg/providers/pconfig/reasoning_off_test.go b/backend/pkg/providers/pconfig/reasoning_off_test.gonew file mode 100644index 00000000..58928fab--- /dev/null+++ b/backend/pkg/providers/pconfig/reasoning_off_test.go@@ -0,0 +1,39 @@+package pconfig++import (+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+ "github.com/vxcontrol/langchaingo/llms"+ "gopkg.in/yaml.v3"+)++// An explicit off mode must emit llms.WithReasoningDisabled() so the langchaingo+// adapter sends the provider's disable wire.+func TestProviderConfig_EmitsDisableOnOffMode(t *testing.T) {+ var ac AgentConfig+ require.NoError(t, yaml.Unmarshal([]byte("model: gpt-5.5\nreasoning:\n mode: \"off\"\n"), &ac))++ require.Equal(t, ReasoningModeOff, ac.Reasoning.Mode)+ require.False(t, ac.Reasoning.IsZero(), "off must be non-zero so BuildOptions emits it")+ require.Equal(t, ReasoningModeOff, ac.Reasoning.EffectiveMode())++ pc := &ProviderConfig{Simple: &ac}+ var applied llms.CallOptions+ for _, opt := range pc.GetOptionsForType(OptionsTypeSimple) {+ opt(&applied)+ }++ require.NotNil(t, applied.Reasoning, "off must emit a reasoning option")+ assert.True(t, applied.Reasoning.IsDisabled(), "off must disable reasoning on the call options")+}++// gopkg.in/yaml.v3 follows YAML 1.2 core (only true/false are booleans), so an+// unquoted off in a user-authored provider YAML parses as the string mode, not a+// boolean. This guards the user-editable config path against the YAML 1.1 off gotcha.+func TestReasoningConfig_UnquotedOffParsesAsMode(t *testing.T) {+ var ac AgentConfig+ require.NoError(t, yaml.Unmarshal([]byte("model: gpt-5.5\nreasoning:\n mode: off\n"), &ac))+ assert.Equal(t, ReasoningModeOff, ac.Reasoning.Mode)+}diff --git a/backend/pkg/providers/provider/provider.go b/backend/pkg/providers/provider/provider.goindex 5b2c762d..5e89bb83 100644--- a/backend/pkg/providers/provider/provider.go+++ b/backend/pkg/providers/provider/provider.go@@ -10,6 +10,7 @@ import ("pentagi/pkg/templates""github.com/vxcontrol/langchaingo/llms"+ "github.com/vxcontrol/langchaingo/llms/reasoning""github.com/vxcontrol/langchaingo/llms/streaming")@@ -19,6 +20,24 @@ func (p ProviderType) String() string {return string(p)}+// ReasoningProvider maps the provider type to the langchaingo reasoning.Provider+// consumed by capability introspection (llms.ReasoningSupportFor) and the disable+// resolver. OpenAI-compatible providers all speak the OpenAI reasoning wire.+func (p ProviderType) ReasoningProvider() reasoning.Provider {+ switch p {+ case ProviderAnthropic:+ return reasoning.ProviderAnthropic+ case ProviderBedrock:+ return reasoning.ProviderBedrock+ case ProviderGemini:+ return reasoning.ProviderGoogleAI+ case ProviderOpenAI, ProviderDeepSeek, ProviderGLM, ProviderKimi, ProviderQwen, ProviderMiniMax, ProviderCustom:+ return reasoning.ProviderOpenAI+ default: // ProviderOllama and anything unrecognized+ return reasoning.ProviderUnknown+ }+}+const (ProviderOpenAI ProviderType = "openai"ProviderAnthropic ProviderType = "anthropic"