// ✅ 这些代码无需修改，继续正常工作
mcpClient := mcp.New()
mcpClient.SetAPIKey(apiKey, url, model)

// ✅ 这些也继续工作
dsClient := mcp.NewDeepSeekClient()
qwenClient := mcp.NewQwenClient()

// 新的推荐用法
client := mcp.NewClient(
    mcp.WithDeepSeekConfig("sk-xxx"),
    mcp.WithTimeout(60 * time.Second),
)

// 使用自定义日志器（如 zap, logrus）
type MyLogger struct {
    zapLogger *zap.Logger
}

func (l *MyLogger) Info(msg string, args ...any) {
    l.zapLogger.Sugar().Infof(msg, args...)
}

// 注入自定义日志器
client := mcp.NewClient(
    mcp.WithLogger(&MyLogger{zapLogger}),
)

// 添加代理、追踪、自定义 TLS 等
customHTTP := &http.Client{
    Timeout: 30 * time.Second,
    Transport: &http.Transport{
        Proxy: http.ProxyFromEnvironment,
        TLSClientConfig: &tls.Config,
    },
}

client := mcp.NewClient(
    mcp.WithHTTPClient(customHTTP),
)

func TestMyCode(t *testing.T) {
    // Mock HTTP 客户端
    mockHTTP := &MockHTTPClient{
        // 返回预设的响应
    }

    // 禁用日志
    client := mcp.NewClient(
        mcp.WithHTTPClient(mockHTTP),
        mcp.WithLogger(mcp.NewNoopLogger()),
    )

    // 测试...
}

client := mcp.NewDeepSeekClientWithOptions(
    mcp.WithAPIKey("sk-xxx"),
    mcp.WithLogger(customLogger),
    mcp.WithTimeout(60 * time.Second),
    mcp.WithMaxRetries(5),
    mcp.WithMaxTokens(4000),
)

// trader/auto_trader.go 中的现有代码
mcpClient := mcp.New()

if config.AIModel == "qwen" {
    mcpClient = mcp.NewQwenClient()
    mcpClient.SetAPIKey(config.QwenKey, config.CustomAPIURL, config.CustomModelName)
} else {
    mcpClient = mcp.NewDeepSeekClient()
    mcpClient.SetAPIKey(config.DeepSeekKey, config.CustomAPIURL, config.CustomModelName)
}

// ✅ 继续工作，无需修改

// 升级后的代码（可选）
var mcpClient mcp.AIClient

if config.AIModel == "qwen" {
    mcpClient = mcp.NewQwenClientWithOptions(
        mcp.WithAPIKey(config.QwenKey),
        mcp.WithBaseURL(config.CustomAPIURL),
        mcp.WithModel(config.CustomModelName),
    )
} else {
    mcpClient = mcp.NewDeepSeekClientWithOptions(
        mcp.WithAPIKey(config.DeepSeekKey),
        mcp.WithBaseURL(config.CustomAPIURL),
        mcp.WithModel(config.CustomModelName),
    )
}

// 添加自定义日志
customLogger := &MyZapLogger{zap.NewProduction()}

mcpClient := mcp.NewDeepSeekClientWithOptions(
    mcp.WithAPIKey(config.DeepSeekKey),
    mcp.WithLogger(customLogger),        // 自定义日志
    mcp.WithTimeout(90 * time.Second),   // 自定义超时
    mcp.WithMaxRetries(5),               // 自定义重试次数
)

// 开发环境：使用详细日志
devClient := mcp.NewClient(
    mcp.WithDeepSeekConfig(apiKey),
    mcp.WithLogger(&defaultLogger{}), // 详细日志
)

// 生产环境：使用 zap 结构化日志
zapLogger, _ := zap.NewProduction()
prodClient := mcp.NewClient(
    mcp.WithDeepSeekConfig(apiKey),
    mcp.WithLogger(&ZapLogger{zapLogger}),
)

// 测试环境：Mock HTTP 响应
mockHTTP := &MockHTTPClient{
    Response: `{"choices":[{"message":{"content":"test"}}]}`,
}

testClient := mcp.NewClient(
    mcp.WithHTTPClient(mockHTTP),
    mcp.WithLogger(mcp.NewNoopLogger()), // 禁用日志
)

// 使用代理
proxyURL, _ := url.Parse("http://proxy.company.com:8080")
proxyClient := &http.Client{
    Transport: &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    },
}

client := mcp.NewClient(
    mcp.WithDeepSeekConfig(apiKey),
    mcp.WithHTTPClient(proxyClient),
)

module github.com/yourorg/mcp

go 1.21

// 无外部依赖！

import "github.com/yourorg/mcp"

client := mcp.NewClient(
    mcp.WithDeepSeekConfig("sk-xxx"),
)

package mypackage_test

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "nofx/mcp"
)

type MockHTTPClient struct {
    Response string
    Error    error
}

func (m *MockHTTPClient) Do(req *http.Request) (*http.Response, error) {
    if m.Error != nil {
        return nil, m.Error
    }

    return &http.Response{
        StatusCode: 200,
        Body:       io.NopCloser(strings.NewReader(m.Response)),
    }, nil
}

func TestAIIntegration(t *testing.T) {
    // Arrange
    mockHTTP := &MockHTTPClient{
        Response: `{"choices":[{"message":{"content":"success"}}]}`,
    }

    client := mcp.NewClient(
        mcp.WithHTTPClient(mockHTTP),
        mcp.WithLogger(mcp.NewNoopLogger()),
    )

    // Act
    result, err := client.CallWithMessages("system", "user")

    // Assert
    assert.NoError(t, err)
    assert.Equal(t, "success", result)
}