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
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.goindex 743554a9..9615d181 100644--- a/backend/pkg/providers/deepseek/deepseek.go+++ b/backend/pkg/providers/deepseek/deepseek.go@@ -1,19 +1,15 @@package deepseekimport (- "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.goindex d4de0b46..472cbd6f 100644--- a/backend/pkg/providers/glm/glm.go+++ b/backend/pkg/providers/glm/glm.go@@ -1,19 +1,15 @@package glmimport (- "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.goindex a57672f3..32ae043b 100644--- a/backend/pkg/providers/kimi/kimi.go+++ b/backend/pkg/providers/kimi/kimi.go@@ -1,28 +1,20 @@package kimiimport (- "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.ymlvar 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.goindex fda2cb12..97aad7ec 100644--- a/backend/pkg/providers/minimax/minimax.go+++ b/backend/pkg/providers/minimax/minimax.go@@ -1,19 +1,15 @@package minimaximport (- "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.gonew file mode 100644index 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.goindex 44ffd6f9..8bac9fc0 100644--- a/backend/pkg/providers/qwen/qwen.go+++ b/backend/pkg/providers/qwen/qwen.go@@ -1,19 +1,15 @@package qwenimport (- "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)}