integrations

type AIModelFactory ¶

type AIModelFactory struct {
	// contains filtered or unexported fields
}

AIModelFactory creates AI model integrations based on provider type

func NewAIModelFactory(toolRepo interfaces.ToolRepository, logger *zap.Logger) *AIModelFactory

func (f *AIModelFactory) CreateModelIntegration(agent *entities.Agent, provider *entities.Provider, apiKey string) (interfaces.AIModelIntegration, error)

type AIModelIntegration ¶

type AIModelIntegration struct {
	// contains filtered or unexported fields
}

AIModelIntegration implements the Base API

func NewAIModelIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*AIModelIntegration, error)

func NewGenericAIModelIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*AIModelIntegration, error)

func (m *AIModelIntegration) GenerateResponse(ctx context.Context, messages []*entities.Message, toolList []*entities.Tool, options map[string]any, callback interfaces.MessageCallback) ([]*entities.Message, error)

func (m *AIModelIntegration) GetLastUsage() (*entities.Usage, error)

func (m *AIModelIntegration) GetUsage() (*entities.Usage, error)

func (m *AIModelIntegration) ModelName() string

func (m *AIModelIntegration) ProviderType() entities.ProviderType

type AnthropicIntegration ¶

type AnthropicIntegration struct {
	// contains filtered or unexported fields
}

AnthropicIntegration implements the Anthropic Claude API

func NewAnthropicIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*AnthropicIntegration, error)

func (m *AnthropicIntegration) GenerateResponse(ctx context.Context, messages []*entities.Message, toolList []*entities.Tool, options map[string]any, callback interfaces.MessageCallback) ([]*entities.Message, error)

func (m *AnthropicIntegration) GetLastUsage() (*entities.Usage, error)

func (m *AnthropicIntegration) GetUsage() (*entities.Usage, error)

func (m *AnthropicIntegration) ModelName() string

func (m *AnthropicIntegration) ProviderType() entities.ProviderType

type DeepseekIntegration ¶

type DeepseekIntegration struct {
	*AIModelIntegration
}

DeepseekIntegration implements the Deepseek API For now, we'll use Base implementation as DeepSeek uses an Base-compatible API, but in the future this could have DeepSeek-specific customizations

func NewDeepseekIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*DeepseekIntegration, error)

func (m *DeepseekIntegration) ProviderType() entities.ProviderType

type DrujensenIntegration ¶ added in v1.8.0

type DrujensenIntegration struct {
	*AIModelIntegration
}

DrujensenIntegration implements the Drujensen API Uses OpenAI-compatible API

func NewDrujensenIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*DrujensenIntegration, error)

func (m *DrujensenIntegration) ProviderType() entities.ProviderType

type GenericIntegration ¶

type GenericIntegration struct {
	*AIModelIntegration
}

GenericIntegration implements the Generic API For now, we'll use Base implementation as DeepSeek uses an Base-compatible API, but in the future this could have DeepSeek-specific customizations

func NewGenericIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*GenericIntegration, error)

func (m *GenericIntegration) ProviderType() entities.ProviderType

type GoogleIntegration ¶

type GoogleIntegration struct {
	*AIModelIntegration
}

GoogleIntegration implements the Google Gemini API For now, we'll use Base implementation as a temporary measure, but in a real implementation this would use the Gemini API

func NewGoogleIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*GoogleIntegration, error)

func (m *GoogleIntegration) ProviderType() entities.ProviderType

type GroqIntegration ¶

type GroqIntegration struct {
	*AIModelIntegration
}

GroqIntegration implements the Groq API For now, we'll use Base implementation as DeepSeek uses an Base-compatible API, but in the future this could have DeepSeek-specific customizations

func NewGroqIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*GroqIntegration, error)

func (m *GroqIntegration) ProviderType() entities.ProviderType

type MistralIntegration ¶

type MistralIntegration struct {
	*AIModelIntegration
}

func NewMistralIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*MistralIntegration, error)

func (m *MistralIntegration) ProviderType() entities.ProviderType

type OllamaIntegration ¶

type OllamaIntegration struct {
	*AIModelIntegration
}

OllamaIntegration implements the Ollama API For now, we'll use Base implementation as Ollama can use an Base-compatible API, but in the future this would have Ollama-specific customizations

func NewOllamaIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*OllamaIntegration, error)

func (m *OllamaIntegration) ProviderType() entities.ProviderType

type OpenAIIntegration ¶

type OpenAIIntegration struct {
	*AIModelIntegration
}

OpenAIIntegration implements the OpenAI API For now, we'll use Base implementation as DeepSeek uses an Base-compatible API, but in the future this could have DeepSeek-specific customizations

func NewOpenAIIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*OpenAIIntegration, error)

func (m *OpenAIIntegration) ProviderType() entities.ProviderType

type TogetherIntegration ¶

type TogetherIntegration struct {
	*AIModelIntegration
}

TogetherIntegration implements the Together API For now, we'll use Base implementation as DeepSeek uses an Base-compatible API, but in the future this could have DeepSeek-specific customizations

func NewTogetherIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*TogetherIntegration, error)

func (m *TogetherIntegration) ProviderType() entities.ProviderType

type XAIIntegration ¶

type XAIIntegration struct {
	*AIModelIntegration
}

XAIIntegration implements the X.AI (Grok) API For now, we'll use Base implementation as the API is similar, but in the future, this would have X.AI-specific customizations

func NewXAIIntegration(baseURL, apiKey, model string, toolRepo interfaces.ToolRepository, logger *zap.Logger) (*XAIIntegration, error)

func (m *XAIIntegration) ProviderType() entities.ProviderType