Skip to content

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

refactor(providers): extract shared openaicompat base for OpenAI-compatible providers

Sergey Kozyrenko93c36483c77b
diff --git a/backend/pkg/providers/deepseek/deepseek.go b/backend/pkg/providers/deepseek/deepseek.go
index 743554a9..9615d181 100644
--- a/backend/pkg/providers/deepseek/deepseek.go
+++ b/backend/pkg/providers/deepseek/deepseek.go
@@ -1,19 +1,15 @@
package deepseek
import (
- "context"
"embed"
- "fmt"
"pentagi/pkg/config"
+ "pentagi/pkg/providers/openaicompat"
"pentagi/pkg/providers/pconfig"
"pentagi/pkg/providers/provider"
"pentagi/pkg/system"
- "pentagi/pkg/templates"
"github.com/vxcontrol/langchaingo/llms"
- "github.com/vxcontrol/langchaingo/llms/openai"
- "github.com/vxcontrol/langchaingo/llms/streaming"
)
//go:embed config.yml models.yml
@@ -56,23 +52,11 @@ func DefaultModels() (pconfig.ModelsConfig, error) {
return pconfig.LoadModelsConfigData(configData)
}
-type deepseekProvider struct {
- llm *openai.LLM
- models pconfig.ModelsConfig
- providerName provider.ProviderName
- providerConfig *pconfig.ProviderConfig
- providerPrefix string
-}
-
func New(
cfg *config.Config,
providerName provider.ProviderName,
providerConfig *pconfig.ProviderConfig,
) (provider.Provider, error) {
- if cfg.DeepSeekAPIKey == "" {
- return nil, fmt.Errorf("missing DEEPSEEK_API_KEY environment variable")
- }
-
httpClient, err := system.GetHTTPClient(cfg)
if err != nil {
return nil, err
@@ -83,115 +67,13 @@ func New(
return nil, err
}
- // DeepSeek V4 OpenAI-compatible API expects the legacy string form
- // "reasoning_effort": "high|medium|low" rather than the modern object form
- // "reasoning": {"effort": "..."}. The absence of WithModernReasoningFormat()
- // ensures langchaingo serializes reasoning_effort as a top-level string.
- // WithPreserveReasoningContent() keeps reasoning_content in multi-turn
- // assistant messages with tool calls (required for DeepSeek thinking mode).
- client, err := openai.New(
- openai.WithToken(cfg.DeepSeekAPIKey),
- openai.WithModel(DeepSeekAgentModel),
- openai.WithBaseURL(cfg.DeepSeekServerURL),
- openai.WithHTTPClient(httpClient),
- openai.WithPreserveReasoningContent(),
- )
- if err != nil {
- return nil, err
- }
-
- return &deepseekProvider{
- llm: client,
- models: models,
- providerName: providerName,
- providerConfig: providerConfig,
- providerPrefix: cfg.DeepSeekProvider,
- }, nil
-}
-
-func (p *deepseekProvider) Type() provider.ProviderType {
- return provider.ProviderDeepSeek
-}
-
-func (p *deepseekProvider) Name() provider.ProviderName {
- return p.providerName
-}
-
-func (p *deepseekProvider) GetRawConfig() []byte {
- return p.providerConfig.GetRawConfig()
-}
-
-func (p *deepseekProvider) GetProviderConfig() *pconfig.ProviderConfig {
- return p.providerConfig
-}
-
-func (p *deepseekProvider) GetPriceInfo(opt pconfig.ProviderOptionsType) *pconfig.PriceInfo {
- return p.providerConfig.GetPriceInfoForType(opt)
-}
-
-func (p *deepseekProvider) GetModels() pconfig.ModelsConfig {
- return p.models
-}
-
-func (p *deepseekProvider) Model(opt pconfig.ProviderOptionsType) string {
- model := DeepSeekAgentModel
- opts := llms.CallOptions{Model: &model}
- for _, option := range p.providerConfig.GetOptionsForType(opt) {
- option(&opts)
- }
-
- return opts.GetModel()
-}
-
-func (p *deepseekProvider) ModelWithPrefix(opt pconfig.ProviderOptionsType) string {
- return provider.ApplyModelPrefix(p.Model(opt), p.providerPrefix)
-}
-
-func (p *deepseekProvider) Call(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- prompt string,
-) (string, error) {
- return provider.WrapGenerateFromSinglePrompt(
- ctx, p, opt, p.llm, prompt,
- p.providerConfig.GetOptionsForType(opt)...,
- )
-}
-
-func (p *deepseekProvider) CallEx(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *deepseekProvider) CallWithTools(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- tools []llms.Tool,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithTools(tools),
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *deepseekProvider) GetUsage(info map[string]any) pconfig.CallUsage {
- return pconfig.NewCallUsage(info)
-}
-
-func (p *deepseekProvider) GetToolCallIDTemplate(ctx context.Context, prompter templates.Prompter) (string, error) {
- return provider.DetermineToolCallIDTemplate(ctx, p, pconfig.OptionsTypeSimple, prompter, DeepSeekToolCallIDTemplate)
+ return openaicompat.New(openaicompat.Spec{
+ Type: provider.ProviderDeepSeek,
+ Model: DeepSeekAgentModel,
+ ToolCallIDTemplate: DeepSeekToolCallIDTemplate,
+ APIKey: cfg.DeepSeekAPIKey,
+ ServerURL: cfg.DeepSeekServerURL,
+ Prefix: cfg.DeepSeekProvider,
+ PreserveReasoning: true,
+ }, httpClient, models, providerName, providerConfig)
}
diff --git a/backend/pkg/providers/glm/glm.go b/backend/pkg/providers/glm/glm.go
index d4de0b46..472cbd6f 100644
--- a/backend/pkg/providers/glm/glm.go
+++ b/backend/pkg/providers/glm/glm.go
@@ -1,19 +1,15 @@
package glm
import (
- "context"
"embed"
- "fmt"
"pentagi/pkg/config"
+ "pentagi/pkg/providers/openaicompat"
"pentagi/pkg/providers/pconfig"
"pentagi/pkg/providers/provider"
"pentagi/pkg/system"
- "pentagi/pkg/templates"
"github.com/vxcontrol/langchaingo/llms"
- "github.com/vxcontrol/langchaingo/llms/openai"
- "github.com/vxcontrol/langchaingo/llms/streaming"
)
//go:embed config.yml models.yml
@@ -55,23 +51,11 @@ func DefaultModels() (pconfig.ModelsConfig, error) {
return pconfig.LoadModelsConfigData(configData)
}
-type glmProvider struct {
- llm *openai.LLM
- models pconfig.ModelsConfig
- providerName provider.ProviderName
- providerConfig *pconfig.ProviderConfig
- providerPrefix string
-}
-
func New(
cfg *config.Config,
providerName provider.ProviderName,
providerConfig *pconfig.ProviderConfig,
) (provider.Provider, error) {
- if cfg.GLMAPIKey == "" {
- return nil, fmt.Errorf("missing GLM_API_KEY environment variable")
- }
-
httpClient, err := system.GetHTTPClient(cfg)
if err != nil {
return nil, err
@@ -82,120 +66,13 @@ func New(
return nil, err
}
- // Z.AI GLM OpenAI-compatible API. Thinking mode is controlled via extra_body.thinking.type
- // ("enabled"/"disabled") in the per-agent config. Unlike Kimi/DeepSeek, GLM does not use
- // reasoning_effort and is permissive about temperature (accepts both 1.0 and 0.6 in
- // thinking mode per Z.AI docs), so no WithModernReasoningFormat is needed.
- // Note: langchaingo's reasoning.IsReasoningModel matches glm-4.5/4.6/4.7 prefixes and
- // force-overrides temperature to 1.0, but GLM accepts any temperature so this is harmless.
- // WithPreserveReasoningContent() is required for Preserved Thinking (clear_thinking=false
- // in per-agent extra_body): on the standard API endpoint Z.AI defaults to clearing
- // reasoning_content across turns, so we must both enable preservation server-side
- // AND have langchaingo serialize reasoning_content back into assistant messages with
- // tool calls. Without it the API will reject the request or silently drop history.
- client, err := openai.New(
- openai.WithToken(cfg.GLMAPIKey),
- openai.WithModel(GLMAgentModel),
- openai.WithBaseURL(cfg.GLMServerURL),
- openai.WithHTTPClient(httpClient),
- openai.WithPreserveReasoningContent(),
- )
- if err != nil {
- return nil, err
- }
-
- return &glmProvider{
- llm: client,
- models: models,
- providerName: providerName,
- providerConfig: providerConfig,
- providerPrefix: cfg.GLMProvider,
- }, nil
-}
-
-func (p *glmProvider) Type() provider.ProviderType {
- return provider.ProviderGLM
-}
-
-func (p *glmProvider) Name() provider.ProviderName {
- return p.providerName
-}
-
-func (p *glmProvider) GetRawConfig() []byte {
- return p.providerConfig.GetRawConfig()
-}
-
-func (p *glmProvider) GetProviderConfig() *pconfig.ProviderConfig {
- return p.providerConfig
-}
-
-func (p *glmProvider) GetPriceInfo(opt pconfig.ProviderOptionsType) *pconfig.PriceInfo {
- return p.providerConfig.GetPriceInfoForType(opt)
-}
-
-func (p *glmProvider) GetModels() pconfig.ModelsConfig {
- return p.models
-}
-
-func (p *glmProvider) Model(opt pconfig.ProviderOptionsType) string {
- model := GLMAgentModel
- opts := llms.CallOptions{Model: &model}
- for _, option := range p.providerConfig.GetOptionsForType(opt) {
- option(&opts)
- }
-
- return opts.GetModel()
-}
-
-func (p *glmProvider) ModelWithPrefix(opt pconfig.ProviderOptionsType) string {
- return provider.ApplyModelPrefix(p.Model(opt), p.providerPrefix)
-}
-
-func (p *glmProvider) Call(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- prompt string,
-) (string, error) {
- return provider.WrapGenerateFromSinglePrompt(
- ctx, p, opt, p.llm, prompt,
- p.providerConfig.GetOptionsForType(opt)...,
- )
-}
-
-func (p *glmProvider) CallEx(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *glmProvider) CallWithTools(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- tools []llms.Tool,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithTools(tools),
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *glmProvider) GetUsage(info map[string]any) pconfig.CallUsage {
- return pconfig.NewCallUsage(info)
-}
-
-func (p *glmProvider) GetToolCallIDTemplate(ctx context.Context, prompter templates.Prompter) (string, error) {
- return provider.DetermineToolCallIDTemplate(ctx, p, pconfig.OptionsTypeSimple, prompter, GLMToolCallIDTemplate)
+ return openaicompat.New(openaicompat.Spec{
+ Type: provider.ProviderGLM,
+ Model: GLMAgentModel,
+ ToolCallIDTemplate: GLMToolCallIDTemplate,
+ APIKey: cfg.GLMAPIKey,
+ ServerURL: cfg.GLMServerURL,
+ Prefix: cfg.GLMProvider,
+ PreserveReasoning: true,
+ }, httpClient, models, providerName, providerConfig)
}
diff --git a/backend/pkg/providers/kimi/kimi.go b/backend/pkg/providers/kimi/kimi.go
index a57672f3..32ae043b 100644
--- a/backend/pkg/providers/kimi/kimi.go
+++ b/backend/pkg/providers/kimi/kimi.go
@@ -1,28 +1,20 @@
package kimi
import (
- "context"
"embed"
- "fmt"
"pentagi/pkg/config"
+ "pentagi/pkg/providers/openaicompat"
"pentagi/pkg/providers/pconfig"
"pentagi/pkg/providers/provider"
"pentagi/pkg/system"
- "pentagi/pkg/templates"
"github.com/vxcontrol/langchaingo/llms"
- "github.com/vxcontrol/langchaingo/llms/openai"
- "github.com/vxcontrol/langchaingo/llms/streaming"
)
//go:embed config.yml models.yml
var configFS embed.FS
-// KimiAgentModel is the fallback model used when no agent-specific configuration exists.
-// kimi-k2.5 is chosen as cost-effective default ($0.60/$3.00 input/output vs $0.95/$4.00 for k2.6).
-// All legacy kimi-k2-* models (turbo-preview, 0905-preview, 0711-preview, thinking, thinking-turbo)
-// were deprecated by Moonshot on 2026-05-25 and must not be used.
const KimiAgentModel = "kimi-k2.5"
const KimiToolCallIDTemplate = "{f}:{r:1:d}"
@@ -60,23 +52,11 @@ func DefaultModels() (pconfig.ModelsConfig, error) {
return pconfig.LoadModelsConfigData(configData)
}
-type kimiProvider struct {
- llm *openai.LLM
- models pconfig.ModelsConfig
- providerName provider.ProviderName
- providerConfig *pconfig.ProviderConfig
- providerPrefix string
-}
-
func New(
cfg *config.Config,
providerName provider.ProviderName,
providerConfig *pconfig.ProviderConfig,
) (provider.Provider, error) {
- if cfg.KimiAPIKey == "" {
- return nil, fmt.Errorf("missing KIMI_API_KEY environment variable")
- }
-
httpClient, err := system.GetHTTPClient(cfg)
if err != nil {
return nil, err
@@ -87,117 +67,13 @@ func New(
return nil, err
}
- // Kimi K2.6/K2.5 OpenAI-compatible API requires legacy string form for reasoning
- // (no WithModernReasoningFormat). Thinking mode is controlled via
- // extra_body.thinking.type ("enabled"/"disabled") in the per-agent config, with
- // thinking.keep="all" required for multi-turn tool calls to preserve historical
- // reasoning_content (otherwise Moonshot returns "thinking is enabled but
- // reasoning_content is missing in assistant tool call message").
- // WithPreserveReasoningContent() keeps reasoning_content in TextContent parts
- // before ToolCall in assistant messages — Kimi rejects requests without it.
- client, err := openai.New(
- openai.WithToken(cfg.KimiAPIKey),
- openai.WithModel(KimiAgentModel),
- openai.WithBaseURL(cfg.KimiServerURL),
- openai.WithHTTPClient(httpClient),
- openai.WithPreserveReasoningContent(),
- )
- if err != nil {
- return nil, err
- }
-
- return &kimiProvider{
- llm: client,
- models: models,
- providerName: providerName,
- providerConfig: providerConfig,
- providerPrefix: cfg.KimiProvider,
- }, nil
-}
-
-func (p *kimiProvider) Type() provider.ProviderType {
- return provider.ProviderKimi
-}
-
-func (p *kimiProvider) Name() provider.ProviderName {
- return p.providerName
-}
-
-func (p *kimiProvider) GetRawConfig() []byte {
- return p.providerConfig.GetRawConfig()
-}
-
-func (p *kimiProvider) GetProviderConfig() *pconfig.ProviderConfig {
- return p.providerConfig
-}
-
-func (p *kimiProvider) GetPriceInfo(opt pconfig.ProviderOptionsType) *pconfig.PriceInfo {
- return p.providerConfig.GetPriceInfoForType(opt)
-}
-
-func (p *kimiProvider) GetModels() pconfig.ModelsConfig {
- return p.models
-}
-
-func (p *kimiProvider) Model(opt pconfig.ProviderOptionsType) string {
- model := KimiAgentModel
- opts := llms.CallOptions{Model: &model}
- for _, option := range p.providerConfig.GetOptionsForType(opt) {
- option(&opts)
- }
-
- return opts.GetModel()
-}
-
-func (p *kimiProvider) ModelWithPrefix(opt pconfig.ProviderOptionsType) string {
- return provider.ApplyModelPrefix(p.Model(opt), p.providerPrefix)
-}
-
-func (p *kimiProvider) Call(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- prompt string,
-) (string, error) {
- return provider.WrapGenerateFromSinglePrompt(
- ctx, p, opt, p.llm, prompt,
- p.providerConfig.GetOptionsForType(opt)...,
- )
-}
-
-func (p *kimiProvider) CallEx(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *kimiProvider) CallWithTools(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- tools []llms.Tool,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithTools(tools),
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *kimiProvider) GetUsage(info map[string]any) pconfig.CallUsage {
- return pconfig.NewCallUsage(info)
-}
-
-func (p *kimiProvider) GetToolCallIDTemplate(ctx context.Context, prompter templates.Prompter) (string, error) {
- return provider.DetermineToolCallIDTemplate(ctx, p, pconfig.OptionsTypeSimple, prompter, KimiToolCallIDTemplate)
+ return openaicompat.New(openaicompat.Spec{
+ Type: provider.ProviderKimi,
+ Model: KimiAgentModel,
+ ToolCallIDTemplate: KimiToolCallIDTemplate,
+ APIKey: cfg.KimiAPIKey,
+ ServerURL: cfg.KimiServerURL,
+ Prefix: cfg.KimiProvider,
+ PreserveReasoning: true,
+ }, httpClient, models, providerName, providerConfig)
}
diff --git a/backend/pkg/providers/minimax/minimax.go b/backend/pkg/providers/minimax/minimax.go
index fda2cb12..97aad7ec 100644
--- a/backend/pkg/providers/minimax/minimax.go
+++ b/backend/pkg/providers/minimax/minimax.go
@@ -1,19 +1,15 @@
package minimax
import (
- "context"
"embed"
- "fmt"
"pentagi/pkg/config"
+ "pentagi/pkg/providers/openaicompat"
"pentagi/pkg/providers/pconfig"
"pentagi/pkg/providers/provider"
"pentagi/pkg/system"
- "pentagi/pkg/templates"
"github.com/vxcontrol/langchaingo/llms"
- "github.com/vxcontrol/langchaingo/llms/openai"
- "github.com/vxcontrol/langchaingo/llms/streaming"
)
//go:embed config.yml models.yml
@@ -56,23 +52,11 @@ func DefaultModels() (pconfig.ModelsConfig, error) {
return pconfig.LoadModelsConfigData(configData)
}
-type minimaxProvider struct {
- llm *openai.LLM
- models pconfig.ModelsConfig
- providerName provider.ProviderName
- providerConfig *pconfig.ProviderConfig
- providerPrefix string
-}
-
func New(
cfg *config.Config,
providerName provider.ProviderName,
providerConfig *pconfig.ProviderConfig,
) (provider.Provider, error) {
- if cfg.MiniMaxAPIKey == "" {
- return nil, fmt.Errorf("missing MINIMAX_API_KEY environment variable")
- }
-
httpClient, err := system.GetHTTPClient(cfg)
if err != nil {
return nil, err
@@ -83,108 +67,12 @@ func New(
return nil, err
}
- client, err := openai.New(
- openai.WithToken(cfg.MiniMaxAPIKey),
- openai.WithModel(MiniMaxAgentModel),
- openai.WithBaseURL(cfg.MiniMaxServerURL),
- openai.WithHTTPClient(httpClient),
- )
- if err != nil {
- return nil, err
- }
-
- return &minimaxProvider{
- llm: client,
- models: models,
- providerName: providerName,
- providerConfig: providerConfig,
- providerPrefix: cfg.MiniMaxProvider,
- }, nil
-}
-
-func (p *minimaxProvider) Type() provider.ProviderType {
- return provider.ProviderMiniMax
-}
-
-func (p *minimaxProvider) Name() provider.ProviderName {
- return p.providerName
-}
-
-func (p *minimaxProvider) GetRawConfig() []byte {
- return p.providerConfig.GetRawConfig()
-}
-
-func (p *minimaxProvider) GetProviderConfig() *pconfig.ProviderConfig {
- return p.providerConfig
-}
-
-func (p *minimaxProvider) GetPriceInfo(opt pconfig.ProviderOptionsType) *pconfig.PriceInfo {
- return p.providerConfig.GetPriceInfoForType(opt)
-}
-
-func (p *minimaxProvider) GetModels() pconfig.ModelsConfig {
- return p.models
-}
-
-func (p *minimaxProvider) Model(opt pconfig.ProviderOptionsType) string {
- model := MiniMaxAgentModel
- opts := llms.CallOptions{Model: &model}
- for _, option := range p.providerConfig.GetOptionsForType(opt) {
- option(&opts)
- }
-
- return opts.GetModel()
-}
-
-func (p *minimaxProvider) ModelWithPrefix(opt pconfig.ProviderOptionsType) string {
- return provider.ApplyModelPrefix(p.Model(opt), p.providerPrefix)
-}
-
-func (p *minimaxProvider) Call(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- prompt string,
-) (string, error) {
- return provider.WrapGenerateFromSinglePrompt(
- ctx, p, opt, p.llm, prompt,
- p.providerConfig.GetOptionsForType(opt)...,
- )
-}
-
-func (p *minimaxProvider) CallEx(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *minimaxProvider) CallWithTools(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- tools []llms.Tool,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithTools(tools),
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *minimaxProvider) GetUsage(info map[string]any) pconfig.CallUsage {
- return pconfig.NewCallUsage(info)
-}
-
-func (p *minimaxProvider) GetToolCallIDTemplate(ctx context.Context, prompter templates.Prompter) (string, error) {
- return provider.DetermineToolCallIDTemplate(ctx, p, pconfig.OptionsTypeSimple, prompter, MiniMaxToolCallIDTemplate)
+ return openaicompat.New(openaicompat.Spec{
+ Type: provider.ProviderMiniMax,
+ Model: MiniMaxAgentModel,
+ ToolCallIDTemplate: MiniMaxToolCallIDTemplate,
+ APIKey: cfg.MiniMaxAPIKey,
+ ServerURL: cfg.MiniMaxServerURL,
+ Prefix: cfg.MiniMaxProvider,
+ }, httpClient, models, providerName, providerConfig)
}
diff --git a/backend/pkg/providers/openaicompat/openaicompat.go b/backend/pkg/providers/openaicompat/openaicompat.go
new file mode 100644
index 00000000..e61084d2
--- /dev/null
+++ b/backend/pkg/providers/openaicompat/openaicompat.go
@@ -0,0 +1,169 @@
+// Package openaicompat is the shared implementation for the OpenAI-compatible
+// providers that differ only in constants and credentials (deepseek, glm, kimi,
+// qwen, minimax). The native OpenAI provider is intentionally NOT built on this:
+// it has no model-prefix support and no reasoning-preservation option.
+package openaicompat
+
+import (
+ "context"
+ "fmt"
+ "net/http"
+
+ "pentagi/pkg/providers/pconfig"
+ "pentagi/pkg/providers/provider"
+ "pentagi/pkg/templates"
+
+ "github.com/vxcontrol/langchaingo/llms"
+ "github.com/vxcontrol/langchaingo/llms/openai"
+ "github.com/vxcontrol/langchaingo/llms/streaming"
+)
+
+// Spec is the per-provider data the shared base needs.
+type Spec struct {
+ Type provider.ProviderType
+ Model string // fallback agent model
+ ToolCallIDTemplate string
+ APIKey string
+ ServerURL string
+ Prefix string // LiteLLM model-name prefix (empty disables prefixing)
+ PreserveReasoning bool // adds openai.WithPreserveReasoningContent() for thinking models
+}
+
+// Provider implements provider.Provider over an OpenAI-compatible endpoint.
+type Provider struct {
+ llm *openai.LLM
+ models pconfig.ModelsConfig
+ providerName provider.ProviderName
+ providerConfig *pconfig.ProviderConfig
+ providerType provider.ProviderType
+ prefix string
+ agentModel string
+ toolCallIDTemplate string
+}
+
+// New builds an OpenAI-compatible provider from spec. The caller supplies the
+// shared HTTP client and the already-loaded model catalog.
+func New(
+ spec Spec,
+ httpClient *http.Client,
+ models pconfig.ModelsConfig,
+ providerName provider.ProviderName,
+ providerConfig *pconfig.ProviderConfig,
+) (provider.Provider, error) {
+ if spec.APIKey == "" {
+ return nil, fmt.Errorf("missing API key for provider %q", spec.Type)
+ }
+
+ opts := []openai.Option{
+ openai.WithToken(spec.APIKey),
+ openai.WithModel(spec.Model),
+ openai.WithBaseURL(spec.ServerURL),
+ openai.WithHTTPClient(httpClient),
+ }
+ if spec.PreserveReasoning {
+ opts = append(opts, openai.WithPreserveReasoningContent())
+ }
+
+ client, err := openai.New(opts...)
+ if err != nil {
+ return nil, err
+ }
+
+ return &Provider{
+ llm: client,
+ models: models,
+ providerName: providerName,
+ providerConfig: providerConfig,
+ providerType: spec.Type,
+ prefix: spec.Prefix,
+ agentModel: spec.Model,
+ toolCallIDTemplate: spec.ToolCallIDTemplate,
+ }, nil
+}
+
+func (p *Provider) Type() provider.ProviderType {
+ return p.providerType
+}
+
+func (p *Provider) Name() provider.ProviderName {
+ return p.providerName
+}
+
+func (p *Provider) GetRawConfig() []byte {
+ return p.providerConfig.GetRawConfig()
+}
+
+func (p *Provider) GetProviderConfig() *pconfig.ProviderConfig {
+ return p.providerConfig
+}
+
+func (p *Provider) GetPriceInfo(opt pconfig.ProviderOptionsType) *pconfig.PriceInfo {
+ return p.providerConfig.GetPriceInfoForType(opt)
+}
+
+func (p *Provider) GetModels() pconfig.ModelsConfig {
+ return p.models
+}
+
+func (p *Provider) Model(opt pconfig.ProviderOptionsType) string {
+ model := p.agentModel
+ opts := llms.CallOptions{Model: &model}
+ for _, option := range p.providerConfig.GetOptionsForType(opt) {
+ option(&opts)
+ }
+
+ return opts.GetModel()
+}
+
+func (p *Provider) ModelWithPrefix(opt pconfig.ProviderOptionsType) string {
+ return provider.ApplyModelPrefix(p.Model(opt), p.prefix)
+}
+
+func (p *Provider) Call(
+ ctx context.Context,
+ opt pconfig.ProviderOptionsType,
+ prompt string,
+) (string, error) {
+ return provider.WrapGenerateFromSinglePrompt(
+ ctx, p, opt, p.llm, prompt,
+ p.providerConfig.GetOptionsForType(opt)...,
+ )
+}
+
+func (p *Provider) CallEx(
+ ctx context.Context,
+ opt pconfig.ProviderOptionsType,
+ chain []llms.MessageContent,
+ streamCb streaming.Callback,
+) (*llms.ContentResponse, error) {
+ return provider.WrapGenerateContent(
+ ctx, p, opt, p.llm.GenerateContent, chain,
+ append([]llms.CallOption{
+ llms.WithStreamingFunc(streamCb),
+ }, p.providerConfig.GetOptionsForType(opt)...)...,
+ )
+}
+
+func (p *Provider) CallWithTools(
+ ctx context.Context,
+ opt pconfig.ProviderOptionsType,
+ chain []llms.MessageContent,
+ tools []llms.Tool,
+ streamCb streaming.Callback,
+) (*llms.ContentResponse, error) {
+ return provider.WrapGenerateContent(
+ ctx, p, opt, p.llm.GenerateContent, chain,
+ append([]llms.CallOption{
+ llms.WithTools(tools),
+ llms.WithStreamingFunc(streamCb),
+ }, p.providerConfig.GetOptionsForType(opt)...)...,
+ )
+}
+
+func (p *Provider) GetUsage(info map[string]any) pconfig.CallUsage {
+ return pconfig.NewCallUsage(info)
+}
+
+func (p *Provider) GetToolCallIDTemplate(ctx context.Context, prompter templates.Prompter) (string, error) {
+ return provider.DetermineToolCallIDTemplate(ctx, p, pconfig.OptionsTypeSimple, prompter, p.toolCallIDTemplate)
+}
diff --git a/backend/pkg/providers/qwen/qwen.go b/backend/pkg/providers/qwen/qwen.go
index 44ffd6f9..8bac9fc0 100644
--- a/backend/pkg/providers/qwen/qwen.go
+++ b/backend/pkg/providers/qwen/qwen.go
@@ -1,19 +1,15 @@
package qwen
import (
- "context"
"embed"
- "fmt"
"pentagi/pkg/config"
+ "pentagi/pkg/providers/openaicompat"
"pentagi/pkg/providers/pconfig"
"pentagi/pkg/providers/provider"
"pentagi/pkg/system"
- "pentagi/pkg/templates"
"github.com/vxcontrol/langchaingo/llms"
- "github.com/vxcontrol/langchaingo/llms/openai"
- "github.com/vxcontrol/langchaingo/llms/streaming"
)
//go:embed config.yml models.yml
@@ -56,23 +52,11 @@ func DefaultModels() (pconfig.ModelsConfig, error) {
return pconfig.LoadModelsConfigData(configData)
}
-type qwenProvider struct {
- llm *openai.LLM
- models pconfig.ModelsConfig
- providerName provider.ProviderName
- providerConfig *pconfig.ProviderConfig
- providerPrefix string
-}
-
func New(
cfg *config.Config,
providerName provider.ProviderName,
providerConfig *pconfig.ProviderConfig,
) (provider.Provider, error) {
- if cfg.QwenAPIKey == "" {
- return nil, fmt.Errorf("missing QWEN_API_KEY environment variable")
- }
-
httpClient, err := system.GetHTTPClient(cfg)
if err != nil {
return nil, err
@@ -83,119 +67,13 @@ func New(
return nil, err
}
- // Alibaba Cloud DashScope OpenAI-compatible API. Thinking is controlled via
- // extra_body.enable_thinking (true/false) in the per-agent config — this is a
- // DashScope-specific parameter, not OpenAI standard. Qwen3.5/3.6/3.7 hybrid
- // models have thinking ENABLED by default, so utility agents must explicitly
- // set enable_thinking=false or reasoning_content will be returned inline as
- // part of content (corrupting outputs that expect short deterministic answers
- // like docker image selection or descriptors).
- // WithPreserveReasoningContent() is required for multi-turn with tool calls
- // when preserve_thinking=true is set in extra_body for qwen3.7-max/qwen3.6-plus
- // (other Qwen3 models do not support preserve_thinking).
- client, err := openai.New(
- openai.WithToken(cfg.QwenAPIKey),
- openai.WithModel(QwenAgentModel),
- openai.WithBaseURL(cfg.QwenServerURL),
- openai.WithHTTPClient(httpClient),
- openai.WithPreserveReasoningContent(),
- )
- if err != nil {
- return nil, err
- }
-
- return &qwenProvider{
- llm: client,
- models: models,
- providerName: providerName,
- providerConfig: providerConfig,
- providerPrefix: cfg.QwenProvider,
- }, nil
-}
-
-func (p *qwenProvider) Type() provider.ProviderType {
- return provider.ProviderQwen
-}
-
-func (p *qwenProvider) Name() provider.ProviderName {
- return p.providerName
-}
-
-func (p *qwenProvider) GetRawConfig() []byte {
- return p.providerConfig.GetRawConfig()
-}
-
-func (p *qwenProvider) GetProviderConfig() *pconfig.ProviderConfig {
- return p.providerConfig
-}
-
-func (p *qwenProvider) GetPriceInfo(opt pconfig.ProviderOptionsType) *pconfig.PriceInfo {
- return p.providerConfig.GetPriceInfoForType(opt)
-}
-
-func (p *qwenProvider) GetModels() pconfig.ModelsConfig {
- return p.models
-}
-
-func (p *qwenProvider) Model(opt pconfig.ProviderOptionsType) string {
- model := QwenAgentModel
- opts := llms.CallOptions{Model: &model}
- for _, option := range p.providerConfig.GetOptionsForType(opt) {
- option(&opts)
- }
-
- return opts.GetModel()
-}
-
-func (p *qwenProvider) ModelWithPrefix(opt pconfig.ProviderOptionsType) string {
- return provider.ApplyModelPrefix(p.Model(opt), p.providerPrefix)
-}
-
-func (p *qwenProvider) Call(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- prompt string,
-) (string, error) {
- return provider.WrapGenerateFromSinglePrompt(
- ctx, p, opt, p.llm, prompt,
- p.providerConfig.GetOptionsForType(opt)...,
- )
-}
-
-func (p *qwenProvider) CallEx(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *qwenProvider) CallWithTools(
- ctx context.Context,
- opt pconfig.ProviderOptionsType,
- chain []llms.MessageContent,
- tools []llms.Tool,
- streamCb streaming.Callback,
-) (*llms.ContentResponse, error) {
- return provider.WrapGenerateContent(
- ctx, p, opt, p.llm.GenerateContent, chain,
- append([]llms.CallOption{
- llms.WithTools(tools),
- llms.WithStreamingFunc(streamCb),
- }, p.providerConfig.GetOptionsForType(opt)...)...,
- )
-}
-
-func (p *qwenProvider) GetUsage(info map[string]any) pconfig.CallUsage {
- return pconfig.NewCallUsage(info)
-}
-
-func (p *qwenProvider) GetToolCallIDTemplate(ctx context.Context, prompter templates.Prompter) (string, error) {
- return provider.DetermineToolCallIDTemplate(ctx, p, pconfig.OptionsTypeSimple, prompter, QwenToolCallIDTemplate)
+ return openaicompat.New(openaicompat.Spec{
+ Type: provider.ProviderQwen,
+ Model: QwenAgentModel,
+ ToolCallIDTemplate: QwenToolCallIDTemplate,
+ APIKey: cfg.QwenAPIKey,
+ ServerURL: cfg.QwenServerURL,
+ Prefix: cfg.QwenProvider,
+ PreserveReasoning: true,
+ }, httpClient, models, providerName, providerConfig)
}