Skip to content

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

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.go
index 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.go
index 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) int
Name func(childComplexity int) int
Price func(childComplexity int) int
+ Reasoning func(childComplexity int) int
ReleaseDate func(childComplexity int) int
Thinking 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) int
Provider func(childComplexity int) int
@@ -2177,6 +2183,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return 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 in
return 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.Context
return 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.Co
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)
}
@@ -21612,6 +21770,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_anthropic(_ 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)
}
@@ -21668,6 +21828,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_gemini(_ context.Co
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)
}
@@ -21721,6 +21883,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_bedrock(_ context.C
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)
}
@@ -21774,6 +21938,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_ollama(_ context.Co
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)
}
@@ -21827,6 +21993,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_custom(_ context.Co
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)
}
@@ -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.Conte
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)
}
@@ -21986,6 +22158,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_kimi(_ context.Cont
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)
}
@@ -22039,6 +22213,8 @@ func (ec *executionContext) fieldContext_ProvidersModelsList_qwen(_ context.Cont
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)
}
@@ -38630,6 +38806,8 @@ func (ec *executionContext) _ModelConfig(ctx context.Context, sel ast.SelectionS
out.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.SelectionSe
return 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.ResultFormat
err := res.UnmarshalGQL(v)
@@ -45148,6 +45374,29 @@ func (ec *executionContext) unmarshalOModelPriceInput2ᚖpentagiᚋpkgᚋgraph
return &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ᚋgr
return &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, nil
diff --git a/backend/pkg/graph/model/models_gen.go b/backend/pkg/graph/model/models_gen.go
index 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 string
const (
diff --git a/backend/pkg/graph/schema.graphqls b/backend/pkg/graph/schema.graphqls
index 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 operations
enum PromptType {
primary_agent
@@ -694,6 +709,7 @@ type ModelConfig {
description: String
releaseDate: Time
thinking: Boolean
+ reasoning: ModelReasoningInfo
price: ModelPrice
}