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(graph): expose model reasoning capability via GraphQL (refs #288)
Sergey Kozyrenko31780e526243
diff --git a/backend/pkg/database/converter/converter.go b/backend/pkg/database/converter/converter.goindex d0adf25e..bea920ab 100644--- a/backend/pkg/database/converter/converter.go+++ b/backend/pkg/database/converter/converter.go@@ -562,6 +562,17 @@ 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+ }+ for _, effort := range m.Reasoning.Efforts {+ reasoning.Efforts = append(reasoning.Efforts, model.ReasoningEffort(effort))+ }+ modelConfig.Reasoning = reasoning+ }gmodels = append(gmodels, modelConfig)}@@ -569,6 +580,19 @@ func ConvertModels(models pconfig.ModelsConfig) []*model.ModelConfig {return gmodels}+// convertModelReasoningMode maps a pconfig model reasoning capability to its GraphQL+// enum value (only adaptive-only differs in spelling: hyphen vs underscore).+func convertModelReasoningMode(m pconfig.ModelReasoningMode) model.ModelReasoningMode {+ switch m {+ case pconfig.ModelReasoningAdaptiveOnly:+ return model.ModelReasoningModeAdaptiveOnly+ case pconfig.ModelReasoningAdaptive:+ return model.ModelReasoningModeAdaptive+ default:+ return model.ModelReasoningModeBudget+ }+}+func ConvertProvider(prv database.Provider, cfg *pconfig.ProviderConfig) *model.ProviderConfig {return &model.ProviderConfig{ID: prv.ID,diff --git a/backend/pkg/graph/generated.go b/backend/pkg/graph/generated.goindex 088c54b9..3e07ad1f 100644--- a/backend/pkg/graph/generated.go+++ b/backend/pkg/graph/generated.go@@ -327,6 +327,7 @@ type ComplexityRoot struct {Description func(childComplexity int) intName func(childComplexity int) intPrice func(childComplexity int) int+ Reasoning func(childComplexity int) intReleaseDate func(childComplexity int) intThinking func(childComplexity int) int}@@ -338,6 +339,11 @@ type ComplexityRoot struct {Output func(childComplexity int) int}+ ModelReasoningInfo struct {+ Efforts func(childComplexity int) int+ Mode func(childComplexity int) int+ }+ModelUsageStats struct {Model func(childComplexity int) intProvider func(childComplexity int) int@@ -2177,6 +2183,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.ModelConfig.Price(childComplexity), true+ case "ModelConfig.reasoning":+ if e.complexity.ModelConfig.Reasoning == nil {+ break+ }++ return e.complexity.ModelConfig.Reasoning(childComplexity), true+case "ModelConfig.releaseDate":if e.complexity.ModelConfig.ReleaseDate == nil {break@@ -2219,6 +2232,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity inreturn e.complexity.ModelPrice.Output(childComplexity), true+ case "ModelReasoningInfo.efforts":+ if e.complexity.ModelReasoningInfo.Efforts == nil {+ break+ }++ return e.complexity.ModelReasoningInfo.Efforts(childComplexity), true++ case "ModelReasoningInfo.mode":+ if e.complexity.ModelReasoningInfo.Mode == nil {+ break+ }++ return e.complexity.ModelReasoningInfo.Mode(childComplexity), true+case "ModelUsageStats.model":if e.complexity.ModelUsageStats.Model == nil {break@@ -17404,6 +17431,53 @@ func (ec *executionContext) fieldContext_ModelConfig_thinking(_ context.Context,return fc, nil}+func (ec *executionContext) _ModelConfig_reasoning(ctx context.Context, field graphql.CollectedField, obj *model.ModelConfig) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_ModelConfig_reasoning(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.Reasoning, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ return graphql.Null+ }+ res := resTmp.(*model.ModelReasoningInfo)+ fc.Result = res+ return ec.marshalOModelReasoningInfo2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐModelReasoningInfo(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_ModelConfig_reasoning(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {+ fc = &graphql.FieldContext{+ Object: "ModelConfig",+ Field: field,+ IsMethod: false,+ IsResolver: false,+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {+ switch field.Name {+ case "mode":+ return ec.fieldContext_ModelReasoningInfo_mode(ctx, field)+ case "efforts":+ return ec.fieldContext_ModelReasoningInfo_efforts(ctx, field)+ }+ return nil, fmt.Errorf("no field named %q was found under type ModelReasoningInfo", field.Name)+ },+ }+ return fc, nil+}+func (ec *executionContext) _ModelConfig_price(ctx context.Context, field graphql.CollectedField, obj *model.ModelConfig) (ret graphql.Marshaler) {fc, err := ec.fieldContext_ModelConfig_price(ctx, field)if err != nil {@@ -17631,6 +17705,88 @@ func (ec *executionContext) fieldContext_ModelPrice_cacheWrite(_ context.Contextreturn fc, nil}+func (ec *executionContext) _ModelReasoningInfo_mode(ctx context.Context, field graphql.CollectedField, obj *model.ModelReasoningInfo) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_ModelReasoningInfo_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.ModelReasoningMode)+ fc.Result = res+ return ec.marshalOModelReasoningMode2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐModelReasoningMode(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_ModelReasoningInfo_mode(_ 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 ModelReasoningMode does not have child fields")+ },+ }+ return fc, nil+}++func (ec *executionContext) _ModelReasoningInfo_efforts(ctx context.Context, field graphql.CollectedField, obj *model.ModelReasoningInfo) (ret graphql.Marshaler) {+ fc, err := ec.fieldContext_ModelReasoningInfo_efforts(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.Efforts, nil+ })+ if err != nil {+ ec.Error(ctx, err)+ return graphql.Null+ }+ if resTmp == nil {+ return graphql.Null+ }+ res := resTmp.([]model.ReasoningEffort)+ fc.Result = res+ return ec.marshalOReasoningEffort2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐReasoningEffortᚄ(ctx, field.Selections, res)+}++func (ec *executionContext) fieldContext_ModelReasoningInfo_efforts(_ 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 ReasoningEffort 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 {@@ -21556,6 +21712,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_openai(_ context.Coreturn ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -21612,6 +21770,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_anthropic(_ contextreturn ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -21668,6 +21828,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_gemini(_ context.Coreturn ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -21721,6 +21883,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_bedrock(_ context.Creturn ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -21774,6 +21938,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_ollama(_ context.Coreturn ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -21827,6 +21993,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_custom(_ context.Coreturn ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -21880,6 +22048,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_deepseek(_ context.return ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -21933,6 +22103,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_glm(_ context.Contereturn ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -21986,6 +22158,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_kimi(_ context.Contreturn ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -22039,6 +22213,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_qwen(_ context.Contreturn ec.fieldContext_ModelConfig_releaseDate(ctx, field)case "thinking":return ec.fieldContext_ModelConfig_thinking(ctx, field)+ case "reasoning":+ return ec.fieldContext_ModelConfig_reasoning(ctx, field)case "price":return ec.fieldContext_ModelConfig_price(ctx, field)}@@ -38630,6 +38806,8 @@ func (ec *executionContext) _ModelConfig(ctx context.Context, sel ast.SelectionSout.Values[i] = ec._ModelConfig_releaseDate(ctx, field, obj)case "thinking":out.Values[i] = ec._ModelConfig_thinking(ctx, field, obj)+ case "reasoning":+ out.Values[i] = ec._ModelConfig_reasoning(ctx, field, obj)case "price":out.Values[i] = ec._ModelConfig_price(ctx, field, obj)default:@@ -38709,6 +38887,44 @@ func (ec *executionContext) _ModelPrice(ctx context.Context, sel ast.SelectionSereturn out}+var modelReasoningInfoImplementors = []string{"ModelReasoningInfo"}++func (ec *executionContext) _ModelReasoningInfo(ctx context.Context, sel ast.SelectionSet, obj *model.ModelReasoningInfo) graphql.Marshaler {+ fields := graphql.CollectFields(ec.OperationContext, sel, modelReasoningInfoImplementors)++ out := graphql.NewFieldSet(fields)+ deferred := make(map[string]*graphql.FieldSet)+ for i, field := range fields {+ switch field.Name {+ case "__typename":+ out.Values[i] = graphql.MarshalString("ModelReasoningInfo")+ case "mode":+ out.Values[i] = ec._ModelReasoningInfo_mode(ctx, field, obj)+ case "efforts":+ out.Values[i] = ec._ModelReasoningInfo_efforts(ctx, field, obj)+ default:+ panic("unknown field " + strconv.Quote(field.Name))+ }+ }+ out.Dispatch(ctx)+ if out.Invalids > 0 {+ return graphql.Null+ }++ atomic.AddInt32(&ec.deferred, int32(len(deferred)))++ for label, dfs := range deferred {+ ec.processDeferredGroup(graphql.DeferredGroup{+ Label: label,+ Path: graphql.GetPath(ctx),+ FieldSet: dfs,+ Context: ctx,+ })+ }++ return out+}+var modelUsageStatsImplementors = []string{"ModelUsageStats"}func (ec *executionContext) _ModelUsageStats(ctx context.Context, sel ast.SelectionSet, obj *model.ModelUsageStats) graphql.Marshaler {@@ -43644,6 +43860,16 @@ func (ec *executionContext) marshalNProvidersReadinessStatus2ᚖpentagiᚋpkgᚋreturn ec._ProvidersReadinessStatus(ctx, sel, v)}+func (ec *executionContext) unmarshalNReasoningEffort2pentagiᚋpkgᚋgraphᚋmodelᚐReasoningEffort(ctx context.Context, v interface{}) (model.ReasoningEffort, error) {+ var res model.ReasoningEffort+ err := res.UnmarshalGQL(v)+ return res, graphql.ErrorOnPath(ctx, err)+}++func (ec *executionContext) marshalNReasoningEffort2pentagiᚋpkgᚋgraphᚋmodelᚐReasoningEffort(ctx context.Context, sel ast.SelectionSet, v model.ReasoningEffort) graphql.Marshaler {+ return v+}+func (ec *executionContext) unmarshalNResultFormat2pentagiᚋpkgᚋgraphᚋmodelᚐResultFormat(ctx context.Context, v interface{}) (model.ResultFormat, error) {var res model.ResultFormaterr := res.UnmarshalGQL(v)@@ -45148,6 +45374,29 @@ func (ec *executionContext) unmarshalOModelPriceInput2ᚖpentagiᚋpkgᚋgraphreturn &res, graphql.ErrorOnPath(ctx, err)}+func (ec *executionContext) marshalOModelReasoningInfo2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐModelReasoningInfo(ctx context.Context, sel ast.SelectionSet, v *model.ModelReasoningInfo) graphql.Marshaler {+ if v == nil {+ return graphql.Null+ }+ return ec._ModelReasoningInfo(ctx, sel, v)+}++func (ec *executionContext) unmarshalOModelReasoningMode2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐModelReasoningMode(ctx context.Context, v interface{}) (*model.ModelReasoningMode, error) {+ if v == nil {+ return nil, nil+ }+ var res = new(model.ModelReasoningMode)+ err := res.UnmarshalGQL(v)+ return res, graphql.ErrorOnPath(ctx, err)+}++func (ec *executionContext) marshalOModelReasoningMode2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐModelReasoningMode(ctx context.Context, sel ast.SelectionSet, v *model.ModelReasoningMode) graphql.Marshaler {+ if v == nil {+ return graphql.Null+ }+ return v+}+func (ec *executionContext) unmarshalOPromptValidationErrorType2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐPromptValidationErrorType(ctx context.Context, v interface{}) (*model.PromptValidationErrorType, error) {if v == nil {return nil, nil@@ -45233,6 +45482,73 @@ func (ec *executionContext) unmarshalOReasoningConfigInput2ᚖpentagiᚋpkgᚋgrreturn &res, graphql.ErrorOnPath(ctx, err)}+func (ec *executionContext) unmarshalOReasoningEffort2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐReasoningEffortᚄ(ctx context.Context, v interface{}) ([]model.ReasoningEffort, error) {+ if v == nil {+ return nil, nil+ }+ var vSlice []interface{}+ if v != nil {+ vSlice = graphql.CoerceList(v)+ }+ var err error+ res := make([]model.ReasoningEffort, len(vSlice))+ for i := range vSlice {+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))+ res[i], err = ec.unmarshalNReasoningEffort2pentagiᚋpkgᚋgraphᚋmodelᚐReasoningEffort(ctx, vSlice[i])+ if err != nil {+ return nil, err+ }+ }+ return res, nil+}++func (ec *executionContext) marshalOReasoningEffort2ᚕpentagiᚋpkgᚋgraphᚋmodelᚐReasoningEffortᚄ(ctx context.Context, sel ast.SelectionSet, v []model.ReasoningEffort) graphql.Marshaler {+ if v == nil {+ return graphql.Null+ }+ ret := make(graphql.Array, len(v))+ var wg sync.WaitGroup+ isLen1 := len(v) == 1+ if !isLen1 {+ wg.Add(len(v))+ }+ for i := range v {+ i := i+ fc := &graphql.FieldContext{+ Index: &i,+ Result: &v[i],+ }+ ctx := graphql.WithFieldContext(ctx, fc)+ f := func(i int) {+ defer func() {+ if r := recover(); r != nil {+ ec.Error(ctx, ec.Recover(ctx, r))+ ret = nil+ }+ }()+ if !isLen1 {+ defer wg.Done()+ }+ ret[i] = ec.marshalNReasoningEffort2pentagiᚋpkgᚋgraphᚋmodelᚐReasoningEffort(ctx, sel, v[i])+ }+ if isLen1 {+ f(i)+ } else {+ go f(i)+ }++ }+ wg.Wait()++ for _, e := range ret {+ if e == graphql.Null {+ return graphql.Null+ }+ }++ return ret+}+func (ec *executionContext) unmarshalOReasoningEffort2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐReasoningEffort(ctx context.Context, v interface{}) (*model.ReasoningEffort, error) {if v == nil {return nil, nildiff --git a/backend/pkg/graph/model/models_gen.go b/backend/pkg/graph/model/models_gen.goindex 5a9e4f23..0d4cadce 100644--- a/backend/pkg/graph/model/models_gen.go+++ b/backend/pkg/graph/model/models_gen.go@@ -312,11 +312,12 @@ type ModelAgentsUsageStats struct {}type ModelConfig struct {- Name string `json:"name"`- Description *string `json:"description,omitempty"`- ReleaseDate *time.Time `json:"releaseDate,omitempty"`- Thinking *bool `json:"thinking,omitempty"`- Price *ModelPrice `json:"price,omitempty"`+ Name string `json:"name"`+ Description *string `json:"description,omitempty"`+ ReleaseDate *time.Time `json:"releaseDate,omitempty"`+ Thinking *bool `json:"thinking,omitempty"`+ Reasoning *ModelReasoningInfo `json:"reasoning,omitempty"`+ Price *ModelPrice `json:"price,omitempty"`}type ModelPrice struct {@@ -326,6 +327,11 @@ type ModelPrice struct {CacheWrite float64 `json:"cacheWrite"`}+type ModelReasoningInfo struct {+ Mode *ModelReasoningMode `json:"mode,omitempty"`+ Efforts []ReasoningEffort `json:"efforts,omitempty"`+}+type ModelUsageStats struct {Model string `json:"model"`Provider string `json:"provider"`@@ -958,6 +964,49 @@ func (e MessageLogType) MarshalGQL(w io.Writer) {fmt.Fprint(w, strconv.Quote(e.String()))}+type ModelReasoningMode string++const (+ ModelReasoningModeBudget ModelReasoningMode = "budget"+ ModelReasoningModeAdaptive ModelReasoningMode = "adaptive"+ ModelReasoningModeAdaptiveOnly ModelReasoningMode = "adaptive_only"+)++var AllModelReasoningMode = []ModelReasoningMode{+ ModelReasoningModeBudget,+ ModelReasoningModeAdaptive,+ ModelReasoningModeAdaptiveOnly,+}++func (e ModelReasoningMode) IsValid() bool {+ switch e {+ case ModelReasoningModeBudget, ModelReasoningModeAdaptive, ModelReasoningModeAdaptiveOnly:+ return true+ }+ return false+}++func (e ModelReasoningMode) String() string {+ return string(e)+}++func (e *ModelReasoningMode) UnmarshalGQL(v interface{}) error {+ str, ok := v.(string)+ if !ok {+ return fmt.Errorf("enums must be strings")+ }++ *e = ModelReasoningMode(str)+ if !e.IsValid() {+ return fmt.Errorf("%s is not a valid ModelReasoningMode", str)+ }+ return nil+}++func (e ModelReasoningMode) MarshalGQL(w io.Writer) {+ fmt.Fprint(w, strconv.Quote(e.String()))+}+type PromptType stringconst (diff --git a/backend/pkg/graph/schema.graphqls b/backend/pkg/graph/schema.graphqlsindex b1ab2a63..8ae99b60 100644--- a/backend/pkg/graph/schema.graphqls+++ b/backend/pkg/graph/schema.graphqls@@ -38,6 +38,21 @@ enum ReasoningMode {budget}+# A model's reasoning capability — distinct from the per-agent ReasoningMode+# choice; adaptive_only models reject budget thinking (e.g. Claude Opus 4.7/4.8).+enum ModelReasoningMode {+ budget+ adaptive+ adaptive_only+}++# Declares how a model supports extended thinking so the UI can offer a valid+# mode/effort without hardcoding model names.+type ModelReasoningInfo {+ mode: ModelReasoningMode+ efforts: [ReasoningEffort!]+}+# Template types for AI agent prompts and system operationsenum PromptType {primary_agent@@ -694,6 +709,7 @@ type ModelConfig {description: StringreleaseDate: Timethinking: Boolean+ reasoning: ModelReasoningInfoprice: ModelPrice}