feat: add Grok, OpenAI, Claude, Gemini, Kimi AI providers

- Add new MCP clients for Grok (xAI), OpenAI, Claude, Gemini, Kimi - Update auto_trader, backtest, and strategy to support all providers - Add provider icons and fix SVG gradient conflicts - Add API application links and hints in model config modal - Show model version in AI model list cards - Add Chinese/English translations for provider hints - Remove deprecated traders component files
2026-07-15 08:46:58 +08:00 · 2025-12-11 15:16:59 +08:00
parent 78b5e73966
commit e5703ffab6
24 changed files with 695 additions and 837 deletions
--- a/mcp/claude_client.go
+++ b/mcp/claude_client.go
@@ -0,0 +1,128 @@
+package mcp
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+const (
+	ProviderClaude       = "claude"
+	DefaultClaudeBaseURL = "https://api.anthropic.com/v1"
+	DefaultClaudeModel   = "claude-opus-4-5-20251101"
+)
+
+type ClaudeClient struct {
+	*Client
+}
+
+// NewClaudeClient creates Claude client (backward compatible)
+func NewClaudeClient() AIClient {
+	return NewClaudeClientWithOptions()
+}
+
+// NewClaudeClientWithOptions creates Claude client (supports options pattern)
+func NewClaudeClientWithOptions(opts ...ClientOption) AIClient {
+	// 1. Create Claude preset options
+	claudeOpts := []ClientOption{
+		WithProvider(ProviderClaude),
+		WithModel(DefaultClaudeModel),
+		WithBaseURL(DefaultClaudeBaseURL),
+	}
+
+	// 2. Merge user options (user options have higher priority)
+	allOpts := append(claudeOpts, opts...)
+
+	// 3. Create base client
+	baseClient := NewClient(allOpts...).(*Client)
+
+	// 4. Create Claude client
+	claudeClient := &ClaudeClient{
+		Client: baseClient,
+	}
+
+	// 5. Set hooks to point to ClaudeClient (implement dynamic dispatch)
+	baseClient.hooks = claudeClient
+
+	return claudeClient
+}
+
+func (c *ClaudeClient) SetAPIKey(apiKey string, customURL string, customModel string) {
+	c.APIKey = apiKey
+
+	if len(apiKey) > 8 {
+		c.logger.Infof("🔧 [MCP] Claude API Key: %s...%s", apiKey[:4], apiKey[len(apiKey)-4:])
+	}
+	if customURL != "" {
+		c.BaseURL = customURL
+		c.logger.Infof("🔧 [MCP] Claude using custom BaseURL: %s", customURL)
+	} else {
+		c.logger.Infof("🔧 [MCP] Claude using default BaseURL: %s", c.BaseURL)
+	}
+	if customModel != "" {
+		c.Model = customModel
+		c.logger.Infof("🔧 [MCP] Claude using custom Model: %s", customModel)
+	} else {
+		c.logger.Infof("🔧 [MCP] Claude using default Model: %s", c.Model)
+	}
+}
+
+// setAuthHeader Claude uses x-api-key header instead of Authorization Bearer
+func (c *ClaudeClient) setAuthHeader(reqHeaders http.Header) {
+	reqHeaders.Set("x-api-key", c.APIKey)
+	reqHeaders.Set("anthropic-version", "2023-06-01")
+}
+
+// buildUrl Claude uses /messages endpoint
+func (c *ClaudeClient) buildUrl() string {
+	return fmt.Sprintf("%s/messages", c.BaseURL)
+}
+
+// buildMCPRequestBody Claude has different request format
+func (c *ClaudeClient) buildMCPRequestBody(systemPrompt, userPrompt string) map[string]any {
+	requestBody := map[string]any{
+		"model":      c.Model,
+		"max_tokens": c.MaxTokens,
+		"system":     systemPrompt,
+		"messages": []map[string]string{
+			{"role": "user", "content": userPrompt},
+		},
+	}
+
+	return requestBody
+}
+
+// parseMCPResponse Claude has different response format
+func (c *ClaudeClient) parseMCPResponse(body []byte) (string, error) {
+	var response struct {
+		Content []struct {
+			Type string `json:"type"`
+			Text string `json:"text"`
+		} `json:"content"`
+		Error *struct {
+			Type    string `json:"type"`
+			Message string `json:"message"`
+		} `json:"error"`
+	}
+
+	if err := json.Unmarshal(body, &response); err != nil {
+		return "", fmt.Errorf("failed to parse Claude response: %w, body: %s", err, string(body))
+	}
+
+	if response.Error != nil {
+		return "", fmt.Errorf("Claude API error: %s - %s", response.Error.Type, response.Error.Message)
+	}
+
+	if len(response.Content) == 0 {
+		return "", fmt.Errorf("Claude returned empty content, body: %s", string(body))
+	}
+
+	// Find text content
+	for _, content := range response.Content {
+		if content.Type == "text" {
+			return content.Text, nil
+		}
+	}
+
+	return "", fmt.Errorf("no text content in Claude response")
+}
--- a/mcp/gemini_client.go
+++ b/mcp/gemini_client.go
@@ -0,0 +1,71 @@
+package mcp
+
+import (
+	"net/http"
+)
+
+const (
+	ProviderGemini       = "gemini"
+	DefaultGeminiBaseURL = "https://generativelanguage.googleapis.com/v1beta/openai"
+	DefaultGeminiModel   = "gemini-3-pro-preview"
+)
+
+type GeminiClient struct {
+	*Client
+}
+
+// NewGeminiClient creates Gemini client (backward compatible)
+func NewGeminiClient() AIClient {
+	return NewGeminiClientWithOptions()
+}
+
+// NewGeminiClientWithOptions creates Gemini client (supports options pattern)
+func NewGeminiClientWithOptions(opts ...ClientOption) AIClient {
+	// 1. Create Gemini preset options
+	geminiOpts := []ClientOption{
+		WithProvider(ProviderGemini),
+		WithModel(DefaultGeminiModel),
+		WithBaseURL(DefaultGeminiBaseURL),
+	}
+
+	// 2. Merge user options (user options have higher priority)
+	allOpts := append(geminiOpts, opts...)
+
+	// 3. Create base client
+	baseClient := NewClient(allOpts...).(*Client)
+
+	// 4. Create Gemini client
+	geminiClient := &GeminiClient{
+		Client: baseClient,
+	}
+
+	// 5. Set hooks to point to GeminiClient (implement dynamic dispatch)
+	baseClient.hooks = geminiClient
+
+	return geminiClient
+}
+
+func (c *GeminiClient) SetAPIKey(apiKey string, customURL string, customModel string) {
+	c.APIKey = apiKey
+
+	if len(apiKey) > 8 {
+		c.logger.Infof("🔧 [MCP] Gemini API Key: %s...%s", apiKey[:4], apiKey[len(apiKey)-4:])
+	}
+	if customURL != "" {
+		c.BaseURL = customURL
+		c.logger.Infof("🔧 [MCP] Gemini using custom BaseURL: %s", customURL)
+	} else {
+		c.logger.Infof("🔧 [MCP] Gemini using default BaseURL: %s", c.BaseURL)
+	}
+	if customModel != "" {
+		c.Model = customModel
+		c.logger.Infof("🔧 [MCP] Gemini using custom Model: %s", customModel)
+	} else {
+		c.logger.Infof("🔧 [MCP] Gemini using default Model: %s", c.Model)
+	}
+}
+
+// Gemini OpenAI-compatible API uses standard Bearer auth
+func (c *GeminiClient) setAuthHeader(reqHeaders http.Header) {
+	c.Client.setAuthHeader(reqHeaders)
+}
--- a/mcp/grok_client.go
+++ b/mcp/grok_client.go
@@ -0,0 +1,71 @@
+package mcp
+
+import (
+	"net/http"
+)
+
+const (
+	ProviderGrok       = "grok"
+	DefaultGrokBaseURL = "https://api.x.ai/v1"
+	DefaultGrokModel   = "grok-3-latest"
+)
+
+type GrokClient struct {
+	*Client
+}
+
+// NewGrokClient creates Grok client (backward compatible)
+func NewGrokClient() AIClient {
+	return NewGrokClientWithOptions()
+}
+
+// NewGrokClientWithOptions creates Grok client (supports options pattern)
+func NewGrokClientWithOptions(opts ...ClientOption) AIClient {
+	// 1. Create Grok preset options
+	grokOpts := []ClientOption{
+		WithProvider(ProviderGrok),
+		WithModel(DefaultGrokModel),
+		WithBaseURL(DefaultGrokBaseURL),
+	}
+
+	// 2. Merge user options (user options have higher priority)
+	allOpts := append(grokOpts, opts...)
+
+	// 3. Create base client
+	baseClient := NewClient(allOpts...).(*Client)
+
+	// 4. Create Grok client
+	grokClient := &GrokClient{
+		Client: baseClient,
+	}
+
+	// 5. Set hooks to point to GrokClient (implement dynamic dispatch)
+	baseClient.hooks = grokClient
+
+	return grokClient
+}
+
+func (c *GrokClient) SetAPIKey(apiKey string, customURL string, customModel string) {
+	c.APIKey = apiKey
+
+	if len(apiKey) > 8 {
+		c.logger.Infof("🔧 [MCP] Grok API Key: %s...%s", apiKey[:4], apiKey[len(apiKey)-4:])
+	}
+	if customURL != "" {
+		c.BaseURL = customURL
+		c.logger.Infof("🔧 [MCP] Grok using custom BaseURL: %s", customURL)
+	} else {
+		c.logger.Infof("🔧 [MCP] Grok using default BaseURL: %s", c.BaseURL)
+	}
+	if customModel != "" {
+		c.Model = customModel
+		c.logger.Infof("🔧 [MCP] Grok using custom Model: %s", customModel)
+	} else {
+		c.logger.Infof("🔧 [MCP] Grok using default Model: %s", c.Model)
+	}
+}
+
+// Grok uses standard OpenAI-compatible API with Bearer auth
+func (c *GrokClient) setAuthHeader(reqHeaders http.Header) {
+	c.Client.setAuthHeader(reqHeaders)
+}
--- a/mcp/kimi_client.go
+++ b/mcp/kimi_client.go
@@ -0,0 +1,71 @@
+package mcp
+
+import (
+	"net/http"
+)
+
+const (
+	ProviderKimi       = "kimi"
+	DefaultKimiBaseURL = "https://api.moonshot.ai/v1" // Global endpoint (use api.moonshot.cn for China)
+	DefaultKimiModel   = "moonshot-v1-auto"
+)
+
+type KimiClient struct {
+	*Client
+}
+
+// NewKimiClient creates Kimi (Moonshot) client (backward compatible)
+func NewKimiClient() AIClient {
+	return NewKimiClientWithOptions()
+}
+
+// NewKimiClientWithOptions creates Kimi client (supports options pattern)
+func NewKimiClientWithOptions(opts ...ClientOption) AIClient {
+	// 1. Create Kimi preset options
+	kimiOpts := []ClientOption{
+		WithProvider(ProviderKimi),
+		WithModel(DefaultKimiModel),
+		WithBaseURL(DefaultKimiBaseURL),
+	}
+
+	// 2. Merge user options (user options have higher priority)
+	allOpts := append(kimiOpts, opts...)
+
+	// 3. Create base client
+	baseClient := NewClient(allOpts...).(*Client)
+
+	// 4. Create Kimi client
+	kimiClient := &KimiClient{
+		Client: baseClient,
+	}
+
+	// 5. Set hooks to point to KimiClient (implement dynamic dispatch)
+	baseClient.hooks = kimiClient
+
+	return kimiClient
+}
+
+func (c *KimiClient) SetAPIKey(apiKey string, customURL string, customModel string) {
+	c.APIKey = apiKey
+
+	if len(apiKey) > 8 {
+		c.logger.Infof("🔧 [MCP] Kimi API Key: %s...%s", apiKey[:4], apiKey[len(apiKey)-4:])
+	}
+	if customURL != "" {
+		c.BaseURL = customURL
+		c.logger.Infof("🔧 [MCP] Kimi using custom BaseURL: %s", customURL)
+	} else {
+		c.logger.Infof("🔧 [MCP] Kimi using default BaseURL: %s", c.BaseURL)
+	}
+	if customModel != "" {
+		c.Model = customModel
+		c.logger.Infof("🔧 [MCP] Kimi using custom Model: %s", customModel)
+	} else {
+		c.logger.Infof("🔧 [MCP] Kimi using default Model: %s", c.Model)
+	}
+}
+
+// Kimi uses standard OpenAI-compatible API, so we just use the base client methods
+func (c *KimiClient) setAuthHeader(reqHeaders http.Header) {
+	c.Client.setAuthHeader(reqHeaders)
+}
--- a/mcp/openai_client.go
+++ b/mcp/openai_client.go
@@ -0,0 +1,71 @@
+package mcp
+
+import (
+	"net/http"
+)
+
+const (
+	ProviderOpenAI       = "openai"
+	DefaultOpenAIBaseURL = "https://api.openai.com/v1"
+	DefaultOpenAIModel   = "gpt-5.1"
+)
+
+type OpenAIClient struct {
+	*Client
+}
+
+// NewOpenAIClient creates OpenAI client (backward compatible)
+func NewOpenAIClient() AIClient {
+	return NewOpenAIClientWithOptions()
+}
+
+// NewOpenAIClientWithOptions creates OpenAI client (supports options pattern)
+func NewOpenAIClientWithOptions(opts ...ClientOption) AIClient {
+	// 1. Create OpenAI preset options
+	openaiOpts := []ClientOption{
+		WithProvider(ProviderOpenAI),
+		WithModel(DefaultOpenAIModel),
+		WithBaseURL(DefaultOpenAIBaseURL),
+	}
+
+	// 2. Merge user options (user options have higher priority)
+	allOpts := append(openaiOpts, opts...)
+
+	// 3. Create base client
+	baseClient := NewClient(allOpts...).(*Client)
+
+	// 4. Create OpenAI client
+	openaiClient := &OpenAIClient{
+		Client: baseClient,
+	}
+
+	// 5. Set hooks to point to OpenAIClient (implement dynamic dispatch)
+	baseClient.hooks = openaiClient
+
+	return openaiClient
+}
+
+func (c *OpenAIClient) SetAPIKey(apiKey string, customURL string, customModel string) {
+	c.APIKey = apiKey
+
+	if len(apiKey) > 8 {
+		c.logger.Infof("🔧 [MCP] OpenAI API Key: %s...%s", apiKey[:4], apiKey[len(apiKey)-4:])
+	}
+	if customURL != "" {
+		c.BaseURL = customURL
+		c.logger.Infof("🔧 [MCP] OpenAI using custom BaseURL: %s", customURL)
+	} else {
+		c.logger.Infof("🔧 [MCP] OpenAI using default BaseURL: %s", c.BaseURL)
+	}
+	if customModel != "" {
+		c.Model = customModel
+		c.logger.Infof("🔧 [MCP] OpenAI using custom Model: %s", customModel)
+	} else {
+		c.logger.Infof("🔧 [MCP] OpenAI using default Model: %s", c.Model)
+	}
+}
+
+// OpenAI uses standard Bearer auth
+func (c *OpenAIClient) setAuthHeader(reqHeaders http.Header) {
+	c.Client.setAuthHeader(reqHeaders)
+}