Skip to content

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

refactor(providers): table-driven provider registry

Sergey Kozyrenko28036f652ce5
diff --git a/backend/pkg/providers/provider/provider.go b/backend/pkg/providers/provider/provider.go
index b80b4aef..5b2c762d 100644
--- a/backend/pkg/providers/provider/provider.go
+++ b/backend/pkg/providers/provider/provider.go
@@ -33,6 +33,22 @@ const (
ProviderMiniMax ProviderType = "minimax"
)
+// AllProviderTypes enumerates every supported provider type; keep it in sync with
+// the consts above. The API-layer type whitelist validates against it.
+var AllProviderTypes = ProvidersListTypes{
+ ProviderOpenAI,
+ ProviderAnthropic,
+ ProviderGemini,
+ ProviderBedrock,
+ ProviderOllama,
+ ProviderCustom,
+ ProviderDeepSeek,
+ ProviderGLM,
+ ProviderKimi,
+ ProviderQwen,
+ ProviderMiniMax,
+}
+
type ProviderName string
func (p ProviderName) String() string {
diff --git a/backend/pkg/providers/providers.go b/backend/pkg/providers/providers.go
index e7691f19..d83cf5e0 100644
--- a/backend/pkg/providers/providers.go
+++ b/backend/pkg/providers/providers.go
@@ -19,20 +19,9 @@ import (
"pentagi/pkg/docker"
"pentagi/pkg/graphiti"
obs "pentagi/pkg/observability"
- "pentagi/pkg/providers/anthropic"
- "pentagi/pkg/providers/bedrock"
- "pentagi/pkg/providers/custom"
- "pentagi/pkg/providers/deepseek"
"pentagi/pkg/providers/embeddings"
- "pentagi/pkg/providers/gemini"
- "pentagi/pkg/providers/glm"
- "pentagi/pkg/providers/kimi"
- "pentagi/pkg/providers/minimax"
- "pentagi/pkg/providers/ollama"
- "pentagi/pkg/providers/openai"
"pentagi/pkg/providers/pconfig"
"pentagi/pkg/providers/provider"
- "pentagi/pkg/providers/qwen"
"pentagi/pkg/providers/tester"
"pentagi/pkg/templates"
"pentagi/pkg/tools"
@@ -176,172 +165,26 @@ func NewProviderController(
providers := make(provider.Providers)
defaultConfigs := make(provider.ProvidersConfig)
- if config, err := openai.DefaultProviderConfig(); err != nil {
- return nil, fmt.Errorf("failed to create openai provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderOpenAI] = config
- }
-
- if config, err := anthropic.DefaultProviderConfig(); err != nil {
- return nil, fmt.Errorf("failed to create anthropic provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderAnthropic] = config
- }
-
- if config, err := gemini.DefaultProviderConfig(); err != nil {
- return nil, fmt.Errorf("failed to create gemini provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderGemini] = config
- }
-
- if config, err := bedrock.DefaultProviderConfig(cfg); err != nil {
- return nil, fmt.Errorf("failed to create bedrock provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderBedrock] = config
- }
-
- if config, err := ollama.DefaultProviderConfig(cfg); err != nil {
- return nil, fmt.Errorf("failed to create ollama provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderOllama] = config
- }
-
- if config, err := custom.DefaultProviderConfig(cfg); err != nil {
- return nil, fmt.Errorf("failed to create custom provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderCustom] = config
- }
-
- if config, err := deepseek.DefaultProviderConfig(); err != nil {
- return nil, fmt.Errorf("failed to create deepseek provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderDeepSeek] = config
- }
-
- if config, err := glm.DefaultProviderConfig(); err != nil {
- return nil, fmt.Errorf("failed to create glm provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderGLM] = config
- }
-
- if config, err := kimi.DefaultProviderConfig(); err != nil {
- return nil, fmt.Errorf("failed to create kimi provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderKimi] = config
- }
-
- if config, err := qwen.DefaultProviderConfig(); err != nil {
- return nil, fmt.Errorf("failed to create qwen provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderQwen] = config
- }
-
- if config, err := minimax.DefaultProviderConfig(); err != nil {
- return nil, fmt.Errorf("failed to create minimax provider config: %w", err)
- } else {
- defaultConfigs[provider.ProviderMiniMax] = config
- }
-
- if cfg.OpenAIKey != "" {
- p, err := openai.New(cfg, provider.DefaultProviderNameOpenAI, defaultConfigs[provider.ProviderOpenAI])
- if err != nil {
- return nil, fmt.Errorf("failed to create openai provider: %w", err)
- }
-
- providers[provider.DefaultProviderNameOpenAI] = p
- }
-
- if cfg.AnthropicAPIKey != "" {
- p, err := anthropic.New(cfg, provider.DefaultProviderNameAnthropic, defaultConfigs[provider.ProviderAnthropic])
- if err != nil {
- return nil, fmt.Errorf("failed to create anthropic provider: %w", err)
- }
-
- providers[provider.DefaultProviderNameAnthropic] = p
- }
-
- if cfg.GeminiAPIKey != "" {
- p, err := gemini.New(cfg, provider.DefaultProviderNameGemini, defaultConfigs[provider.ProviderGemini])
- if err != nil {
- return nil, fmt.Errorf("failed to create gemini provider: %w", err)
- }
-
- providers[provider.DefaultProviderNameGemini] = p
- }
-
- // Bedrock supports three authentication strategies:
- // 1. Default AWS SDK auth (BedrockDefaultAuth=true)
- // 2. Bearer token (BedrockBearerToken set)
- // 3. Static credentials (BedrockAccessKey + BedrockSecretKey)
- if cfg.BedrockDefaultAuth || cfg.BedrockBearerToken != "" ||
- (cfg.BedrockAccessKey != "" && cfg.BedrockSecretKey != "") {
- p, err := bedrock.New(cfg, provider.DefaultProviderNameBedrock, defaultConfigs[provider.ProviderBedrock])
- if err != nil {
- return nil, fmt.Errorf("failed to create bedrock provider: %w", err)
- }
- providers[provider.DefaultProviderNameBedrock] = p
- }
-
- if cfg.OllamaServerURL != "" {
- p, err := ollama.New(cfg, provider.DefaultProviderNameOllama, defaultConfigs[provider.ProviderOllama])
- if err != nil {
- return nil, fmt.Errorf("failed to create ollama provider: %w", err)
- }
- providers[provider.DefaultProviderNameOllama] = p
- }
-
- if cfg.LLMServerURL != "" && (cfg.LLMServerModel != "" || cfg.LLMServerConfig != "") {
- p, err := custom.New(cfg, provider.DefaultProviderNameCustom, defaultConfigs[provider.ProviderCustom])
- if err != nil {
- return nil, fmt.Errorf("failed to create custom provider: %w", err)
- }
-
- providers[provider.DefaultProviderNameCustom] = p
- }
-
- if cfg.DeepSeekAPIKey != "" {
- p, err := deepseek.New(cfg, provider.DefaultProviderNameDeepSeek, defaultConfigs[provider.ProviderDeepSeek])
- if err != nil {
- return nil, fmt.Errorf("failed to create deepseek provider: %w", err)
- }
-
- providers[provider.DefaultProviderNameDeepSeek] = p
- }
-
- if cfg.GLMAPIKey != "" {
- p, err := glm.New(cfg, provider.DefaultProviderNameGLM, defaultConfigs[provider.ProviderGLM])
+ for _, e := range providerRegistry {
+ config, err := e.NewConfig(cfg)
if err != nil {
- return nil, fmt.Errorf("failed to create glm provider: %w", err)
+ return nil, fmt.Errorf("failed to create %s provider config: %w", e.Type, err)
}
- providers[provider.DefaultProviderNameGLM] = p
+ defaultConfigs[e.Type] = config
}
- if cfg.KimiAPIKey != "" {
- p, err := kimi.New(cfg, provider.DefaultProviderNameKimi, defaultConfigs[provider.ProviderKimi])
- if err != nil {
- return nil, fmt.Errorf("failed to create kimi provider: %w", err)
+ for _, e := range providerRegistry {
+ if !e.Enabled(cfg) {
+ continue
}
- providers[provider.DefaultProviderNameKimi] = p
- }
-
- if cfg.QwenAPIKey != "" {
- p, err := qwen.New(cfg, provider.DefaultProviderNameQwen, defaultConfigs[provider.ProviderQwen])
+ p, err := e.New(cfg, e.Name, defaultConfigs[e.Type])
if err != nil {
- return nil, fmt.Errorf("failed to create qwen provider: %w", err)
+ return nil, fmt.Errorf("failed to create %s provider: %w", e.Type, err)
}
- providers[provider.DefaultProviderNameQwen] = p
- }
-
- if cfg.MiniMaxAPIKey != "" {
- p, err := minimax.New(cfg, provider.DefaultProviderNameMiniMax, defaultConfigs[provider.ProviderMiniMax])
- if err != nil {
- return nil, fmt.Errorf("failed to create minimax provider: %w", err)
- }
-
- providers[provider.DefaultProviderNameMiniMax] = p
+ providers[e.Name] = p
}
summarizerAgent := csum.NewSummarizer(csum.SummarizerConfig{
@@ -729,32 +572,7 @@ func (pc *providerController) GetProvider(
}
// Fall back to built-in default providers
- switch prvname {
- case provider.DefaultProviderNameOpenAI:
- return pc.Providers.Get(provider.DefaultProviderNameOpenAI)
- case provider.DefaultProviderNameAnthropic:
- return pc.Providers.Get(provider.DefaultProviderNameAnthropic)
- case provider.DefaultProviderNameGemini:
- return pc.Providers.Get(provider.DefaultProviderNameGemini)
- case provider.DefaultProviderNameBedrock:
- return pc.Providers.Get(provider.DefaultProviderNameBedrock)
- case provider.DefaultProviderNameOllama:
- return pc.Providers.Get(provider.DefaultProviderNameOllama)
- case provider.DefaultProviderNameCustom:
- return pc.Providers.Get(provider.DefaultProviderNameCustom)
- case provider.DefaultProviderNameDeepSeek:
- return pc.Providers.Get(provider.DefaultProviderNameDeepSeek)
- case provider.DefaultProviderNameGLM:
- return pc.Providers.Get(provider.DefaultProviderNameGLM)
- case provider.DefaultProviderNameKimi:
- return pc.Providers.Get(provider.DefaultProviderNameKimi)
- case provider.DefaultProviderNameQwen:
- return pc.Providers.Get(provider.DefaultProviderNameQwen)
- case provider.DefaultProviderNameMiniMax:
- return pc.Providers.Get(provider.DefaultProviderNameMiniMax)
- }
-
- return nil, fmt.Errorf("provider '%s' not found", prvname)
+ return pc.Providers.Get(prvname)
}
func (pc *providerController) GetProviders(
@@ -797,76 +615,17 @@ func (pc *providerController) NewProvider(prv database.Provider) (provider.Provi
return nil, fmt.Errorf("provider type '%s' is not available", prv.Type)
}
- switch providerType {
- case provider.ProviderOpenAI:
- openaiConfig, err := openai.BuildProviderConfig(prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build openai provider config: %w", err)
- }
- return openai.New(pc.cfg, providerName, openaiConfig)
- case provider.ProviderAnthropic:
- anthropicConfig, err := anthropic.BuildProviderConfig(prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build anthropic provider config: %w", err)
- }
- return anthropic.New(pc.cfg, providerName, anthropicConfig)
- case provider.ProviderGemini:
- geminiConfig, err := gemini.BuildProviderConfig(prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build gemini provider config: %w", err)
- }
- return gemini.New(pc.cfg, providerName, geminiConfig)
- case provider.ProviderBedrock:
- bedrockConfig, err := bedrock.BuildProviderConfig(prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build bedrock provider config: %w", err)
- }
- return bedrock.New(pc.cfg, providerName, bedrockConfig)
- case provider.ProviderOllama:
- ollamaConfig, err := ollama.BuildProviderConfig(pc.cfg, prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build ollama provider config: %w", err)
- }
- return ollama.New(pc.cfg, providerName, ollamaConfig)
- case provider.ProviderCustom:
- customConfig, err := custom.BuildProviderConfig(pc.cfg, prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build custom provider config: %w", err)
- }
- return custom.New(pc.cfg, providerName, customConfig)
- case provider.ProviderDeepSeek:
- deepseekConfig, err := deepseek.BuildProviderConfig(prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build deepseek provider config: %w", err)
- }
- return deepseek.New(pc.cfg, providerName, deepseekConfig)
- case provider.ProviderGLM:
- glmConfig, err := glm.BuildProviderConfig(prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build glm provider config: %w", err)
- }
- return glm.New(pc.cfg, providerName, glmConfig)
- case provider.ProviderKimi:
- kimiConfig, err := kimi.BuildProviderConfig(prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build kimi provider config: %w", err)
- }
- return kimi.New(pc.cfg, providerName, kimiConfig)
- case provider.ProviderQwen:
- qwenConfig, err := qwen.BuildProviderConfig(prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build qwen provider config: %w", err)
- }
- return qwen.New(pc.cfg, providerName, qwenConfig)
- case provider.ProviderMiniMax:
- minimaxConfig, err := minimax.BuildProviderConfig(prv.Config)
- if err != nil {
- return nil, fmt.Errorf("failed to build minimax provider config: %w", err)
- }
- return minimax.New(pc.cfg, providerName, minimaxConfig)
- default:
+ e, ok := entryForType(providerType)
+ if !ok {
return nil, fmt.Errorf("unknown provider type: %s", prv.Type)
}
+
+ config, err := e.BuildConfig(pc.cfg, prv.Config)
+ if err != nil {
+ return nil, fmt.Errorf("failed to build %s provider config: %w", providerType, err)
+ }
+
+ return e.New(pc.cfg, providerName, config)
}
func (pc *providerController) CreateProvider(
@@ -1189,32 +948,12 @@ func (pc *providerController) buildProviderFromConfig(
prvname provider.ProviderName,
config *pconfig.ProviderConfig,
) (provider.Provider, error) {
- switch prvtype {
- case provider.ProviderOpenAI:
- return openai.New(pc.cfg, prvname, config)
- case provider.ProviderAnthropic:
- return anthropic.New(pc.cfg, prvname, config)
- case provider.ProviderCustom:
- return custom.New(pc.cfg, prvname, config)
- case provider.ProviderGemini:
- return gemini.New(pc.cfg, prvname, config)
- case provider.ProviderBedrock:
- return bedrock.New(pc.cfg, prvname, config)
- case provider.ProviderOllama:
- return ollama.New(pc.cfg, prvname, config)
- case provider.ProviderDeepSeek:
- return deepseek.New(pc.cfg, prvname, config)
- case provider.ProviderGLM:
- return glm.New(pc.cfg, prvname, config)
- case provider.ProviderKimi:
- return kimi.New(pc.cfg, prvname, config)
- case provider.ProviderQwen:
- return qwen.New(pc.cfg, prvname, config)
- case provider.ProviderMiniMax:
- return minimax.New(pc.cfg, prvname, config)
- default:
+ e, ok := entryForType(prvtype)
+ if !ok {
return nil, fmt.Errorf("unknown provider type: %s", prvtype)
}
+
+ return e.New(pc.cfg, prvname, config)
}
func newAtomicInt64(seed int64) *atomic.Int64 {
diff --git a/backend/pkg/providers/registry.go b/backend/pkg/providers/registry.go
new file mode 100644
index 00000000..828f35ef
--- /dev/null
+++ b/backend/pkg/providers/registry.go
@@ -0,0 +1,150 @@
+package providers
+
+import (
+ "pentagi/pkg/config"
+ "pentagi/pkg/providers/anthropic"
+ "pentagi/pkg/providers/bedrock"
+ "pentagi/pkg/providers/custom"
+ "pentagi/pkg/providers/deepseek"
+ "pentagi/pkg/providers/gemini"
+ "pentagi/pkg/providers/glm"
+ "pentagi/pkg/providers/kimi"
+ "pentagi/pkg/providers/minimax"
+ "pentagi/pkg/providers/ollama"
+ "pentagi/pkg/providers/openai"
+ "pentagi/pkg/providers/pconfig"
+ "pentagi/pkg/providers/provider"
+ "pentagi/pkg/providers/qwen"
+)
+
+// registryEntry describes how to construct one provider type. It absorbs the
+// small per-provider variance — which constructors take *config.Config and the
+// credential gating — so the controller can wire every provider in one loop.
+type registryEntry struct {
+ Type provider.ProviderType
+ Name provider.ProviderName
+ Enabled func(*config.Config) bool
+ NewConfig func(*config.Config) (*pconfig.ProviderConfig, error)
+ New func(*config.Config, provider.ProviderName, *pconfig.ProviderConfig) (provider.Provider, error)
+ BuildConfig func(*config.Config, []byte) (*pconfig.ProviderConfig, error)
+}
+
+// ignoreConfig adapts a no-argument default-config loader to the registry signature.
+func ignoreConfig(
+ fn func() (*pconfig.ProviderConfig, error),
+) func(*config.Config) (*pconfig.ProviderConfig, error) {
+ return func(*config.Config) (*pconfig.ProviderConfig, error) { return fn() }
+}
+
+// fromData adapts a []byte-only config builder to the registry signature.
+func fromData(
+ fn func([]byte) (*pconfig.ProviderConfig, error),
+) func(*config.Config, []byte) (*pconfig.ProviderConfig, error) {
+ return func(_ *config.Config, data []byte) (*pconfig.ProviderConfig, error) { return fn(data) }
+}
+
+var providerRegistry = []registryEntry{
+ {
+ Type: provider.ProviderOpenAI,
+ Name: provider.DefaultProviderNameOpenAI,
+ Enabled: func(c *config.Config) bool { return c.OpenAIKey != "" },
+ NewConfig: ignoreConfig(openai.DefaultProviderConfig),
+ New: openai.New,
+ BuildConfig: fromData(openai.BuildProviderConfig),
+ },
+ {
+ Type: provider.ProviderAnthropic,
+ Name: provider.DefaultProviderNameAnthropic,
+ Enabled: func(c *config.Config) bool { return c.AnthropicAPIKey != "" },
+ NewConfig: ignoreConfig(anthropic.DefaultProviderConfig),
+ New: anthropic.New,
+ BuildConfig: fromData(anthropic.BuildProviderConfig),
+ },
+ {
+ Type: provider.ProviderGemini,
+ Name: provider.DefaultProviderNameGemini,
+ Enabled: func(c *config.Config) bool { return c.GeminiAPIKey != "" },
+ NewConfig: ignoreConfig(gemini.DefaultProviderConfig),
+ New: gemini.New,
+ BuildConfig: fromData(gemini.BuildProviderConfig),
+ },
+ {
+ Type: provider.ProviderBedrock,
+ Name: provider.DefaultProviderNameBedrock,
+ // Bedrock accepts default AWS SDK auth, a bearer token, or static credentials.
+ Enabled: func(c *config.Config) bool {
+ return c.BedrockDefaultAuth || c.BedrockBearerToken != "" ||
+ (c.BedrockAccessKey != "" && c.BedrockSecretKey != "")
+ },
+ NewConfig: bedrock.DefaultProviderConfig,
+ New: bedrock.New,
+ BuildConfig: fromData(bedrock.BuildProviderConfig),
+ },
+ {
+ Type: provider.ProviderOllama,
+ Name: provider.DefaultProviderNameOllama,
+ Enabled: func(c *config.Config) bool { return c.OllamaServerURL != "" },
+ NewConfig: ollama.DefaultProviderConfig,
+ New: ollama.New,
+ BuildConfig: ollama.BuildProviderConfig,
+ },
+ {
+ Type: provider.ProviderCustom,
+ Name: provider.DefaultProviderNameCustom,
+ Enabled: func(c *config.Config) bool {
+ return c.LLMServerURL != "" && (c.LLMServerModel != "" || c.LLMServerConfig != "")
+ },
+ NewConfig: custom.DefaultProviderConfig,
+ New: custom.New,
+ BuildConfig: custom.BuildProviderConfig,
+ },
+ {
+ Type: provider.ProviderDeepSeek,
+ Name: provider.DefaultProviderNameDeepSeek,
+ Enabled: func(c *config.Config) bool { return c.DeepSeekAPIKey != "" },
+ NewConfig: ignoreConfig(deepseek.DefaultProviderConfig),
+ New: deepseek.New,
+ BuildConfig: fromData(deepseek.BuildProviderConfig),
+ },
+ {
+ Type: provider.ProviderGLM,
+ Name: provider.DefaultProviderNameGLM,
+ Enabled: func(c *config.Config) bool { return c.GLMAPIKey != "" },
+ NewConfig: ignoreConfig(glm.DefaultProviderConfig),
+ New: glm.New,
+ BuildConfig: fromData(glm.BuildProviderConfig),
+ },
+ {
+ Type: provider.ProviderKimi,
+ Name: provider.DefaultProviderNameKimi,
+ Enabled: func(c *config.Config) bool { return c.KimiAPIKey != "" },
+ NewConfig: ignoreConfig(kimi.DefaultProviderConfig),
+ New: kimi.New,
+ BuildConfig: fromData(kimi.BuildProviderConfig),
+ },
+ {
+ Type: provider.ProviderQwen,
+ Name: provider.DefaultProviderNameQwen,
+ Enabled: func(c *config.Config) bool { return c.QwenAPIKey != "" },
+ NewConfig: ignoreConfig(qwen.DefaultProviderConfig),
+ New: qwen.New,
+ BuildConfig: fromData(qwen.BuildProviderConfig),
+ },
+ {
+ Type: provider.ProviderMiniMax,
+ Name: provider.DefaultProviderNameMiniMax,
+ Enabled: func(c *config.Config) bool { return c.MiniMaxAPIKey != "" },
+ NewConfig: ignoreConfig(minimax.DefaultProviderConfig),
+ New: minimax.New,
+ BuildConfig: fromData(minimax.BuildProviderConfig),
+ },
+}
+
+func entryForType(t provider.ProviderType) (registryEntry, bool) {
+ for _, e := range providerRegistry {
+ if e.Type == t {
+ return e, true
+ }
+ }
+ return registryEntry{}, false
+}
diff --git a/backend/pkg/server/models/providers.go b/backend/pkg/server/models/providers.go
index 12483ffe..f23faf14 100644
--- a/backend/pkg/server/models/providers.go
+++ b/backend/pkg/server/models/providers.go
@@ -18,23 +18,11 @@ func (s ProviderType) String() string {
// Valid is function to control input/output data
func (s ProviderType) Valid() error {
- providerType := provider.ProviderType(s)
- switch providerType {
- case provider.ProviderOpenAI,
- provider.ProviderAnthropic,
- provider.ProviderGemini,
- provider.ProviderBedrock,
- provider.ProviderOllama,
- provider.ProviderCustom,
- provider.ProviderDeepSeek,
- provider.ProviderGLM,
- provider.ProviderKimi,
- provider.ProviderQwen,
- provider.ProviderMiniMax:
- return nil
- default:
+ if !provider.AllProviderTypes.Contains(provider.ProviderType(s)) {
return fmt.Errorf("invalid ProviderType: %s", s)
}
+
+ return nil
}
// Validate is function to use callback to control input/output data