┌─────────────────────────────────────────────────────────────┐
│                        Agent Layer                          │
│  (Coder, Summarizer, Task, Title)                         │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                     LLM Interface Layer                      │
│  (models/models.go - 统一模型接口)                          │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                    Provider Implementation                  │
├─────────┬──────────┬──────────┬──────────┬────────────────┤
│Anthropic│ OpenAI   │  Copilot │ Gemini   │ ... (其他)     │
└─────────┴──────────┴──────────┴──────────┴────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                    Network Transport                        │
│  (HTTP/REST - 不同 Provider 的 API 调用)                   │
└─────────────────────────────────────────────────────────────┘

// internal/llm/models/models.go
type ModelID string

const (
    // Anthropic
    Claude4Opus       ModelID = "claude-4-opus-20250514"
    Claude4Sonnet     ModelID = "claude-4-sonnet-20250514"
    Claude4Haiku      ModelID = "claude-4-haiku-20250620"
    Claude35Sonnet   ModelID = "claude-3-5-sonnet-20241022"
    Claude35Haiku    ModelID = "claude-3-5-haiku-20241022"
    
    // OpenAI
    GPT4o            ModelID = "chatgpt-4o-latest"
    GPT4Turbo        ModelID = "gpt-4-turbo"
    GPT4oMini        ModelID = "gpt-4o-mini"
    
    // GitHub Copilot
    CopilotGPT4o     ModelID = "copilot-gpt-4o"
    CopilotGPT4oMini ModelID = "copilot-gpt-4o-mini"
    
    // Google
    Gemini15Pro      ModelID = "gemini-1.5-pro"
    Gemini15Flash    ModelID = "gemini-1.5-flash"
    Gemini2Flash     ModelID = "gemini-2.0-flash"
    
    // Groq
    GroqLlama70B     ModelID = "llama-3.3-70b-versatile"
    GroqMixtral8x7B ModelID = "mixtral-8x7b-32768"
    
    // OpenRouter
    OpenRouterGPT4o  ModelID = "openrouter/openai/gpt-4o"
    
    // xAI
    XAIGrok2         ModelID = "grok-2-1212"
    XAIGrok2Mini     ModelID = "grok-2-mini"
    
    // Local
    LocalModel       ModelID = "local"
)

type Model struct {
    ID              ModelID
    Provider        ModelProvider
    Name            string
    ContextWindow   int64
    MaxTokens       int64        // 最大输出 token 数
    DefaultMaxTokens int64       // 默认 max_tokens
    InputCostPer1M  float64      // 输入成本 ($/1M tokens)
    OutputCostPer1M float64      // 输出成本 ($/1M tokens)
    CanReason       bool         // 是否支持推理（思考链）
    SupportsTools   bool         // 是否支持工具调用
    IsVision        bool         // 是否支持视觉
}

type ModelProvider string

// internal/llm/models/models.go
var SupportedModels = map[ModelID]Model{
    // Anthropic
    Claude4Opus: {
        ID:              Claude4Opus,
        Provider:        ProviderAnthropic,
        Name:            "Claude 4 Opus",
        ContextWindow:   200000,
        MaxTokens:       8192,
        DefaultMaxTokens: 8192,
        InputCostPer1M:  15.0,
        OutputCostPer1M: 75.0,
        CanReason:       true,
        SupportsTools:   true,
    },
    Claude4Sonnet: {
        ID:              Claude4Sonnet,
        Provider:        ProviderAnthropic,
        Name:            "Claude 4 Sonnet",
        ContextWindow:   200000,
        MaxTokens:       8192,
        DefaultMaxTokens: 8192,
        InputCostPer1M:  3.0,
        OutputCostPer1M: 15.0,
        CanReason:       true,
        SupportsTools:   true,
    },
    // ... 更多模型
}

// internal/llm/provider/provider.go
type Provider interface {
    // 创建聊天完成请求
    CreateChatCompletion(ctx context.Context, modelID models.ModelID, messages []Message, tools []Tool, options Options) (*ChatCompletion, error)
    
    // 获取模型列表
    ListModels(ctx context.Context) ([]models.ModelID, error)
    
    // Provider 名称
    Name() models.ModelProvider
    
    // 检查 API Key 是否有效
    ValidateAPIKey(ctx context.Context, apiKey string) error
}

type Options struct {
    MaxTokens       int64            // 最大 token 数
    Temperature     float64          // 温度参数
    TopP            float64           // Top-P 采样
    ReasoningEffort string            // 推理努力程度 ( Anthropic )
    Stop            []string          // 停止序列
    Stream          bool              // 是否流式输出
}

type Message struct {
    Role    string   // "user", "assistant", "system", "tool"
    Content string   // 消息内容
    
    // 可选字段
    Name    string   // 用于 tool 角色
    ToolCallID string // 用于 assistant 携带 tool_call
}

type ChatCompletion struct {
    Content       string
    Model         models.ModelID
    StopReason   string  // "stop", "tool_calls", "max_tokens"
    Usage         Usage
    ToolCalls     []ToolCall  // 如果 stop_reason 是 tool_calls
    ReasoningContent string  // 思考链内容 (如果有)
}

type Usage struct {
    PromptTokens     int
    CompletionTokens int
    TotalTokens      int
}

type ToolCall struct {
    ID      string
    Name    string
    Args    string  // JSON 格式的工具参数
}

// internal/llm/provider/anthropic.go
type AnthropicProvider struct {
    apiKey string
    baseURL string  // 默认 https://api.anthropic.com
}

func NewAnthropic(apiKey string) *AnthropicProvider {
    return &AnthropicProvider{
        apiKey: apiKey,
        baseURL: "https://api.anthropic.com/v1",
    }
}

func (p *AnthropicProvider) Name() models.ModelProvider {
    return models.ProviderAnthropic
}

func (p *AnthropicProvider) CreateChatCompletion(
    ctx context.Context,
    modelID models.ModelID,
    messages []Message,
    tools []Tool,
    options Options,
) (*ChatCompletion, error) {
    // 1. 转换为 Anthropic 格式
    anthropicMessages := p.convertMessages(messages)
    
    // 2. 构建请求
    req := anthropicRequest{
        Model:         string(modelID),
        Messages:      anthropicMessages,
        MaxTokens:     options.MaxTokens,
        Temperature:   options.Temperature,
        TopP:          options.TopP,
        Tools:         p.convertTools(tools),
    }
    
    // 3. 添加思考链配置
    if options.ReasoningEffort != "" {
        req.Model = strings.Split(string(modelID), "-")[0] + "-4"
        // 注入思考预算
    }
    
    // 4. 发送请求
    body, err := p.doRequest(ctx, req)
    if err != nil {
        return nil, err
    }
    
    // 5. 解析响应
    return p.parseResponse(body)
}

func (p *AnthropicProvider) convertMessages(messages []Message) []anthropicMessage {
    var result []anthropicMessage
    
    for _, msg := range messages {
        switch msg.Role {
        case "system":
            // Anthropic 使用专门的 system 消息
            result = append(result, anthropicMessage{
                Role:    "user",
                Content: "<system>" + msg.Content + "</system>",
            })
            
        case "user":
            result = append(result, anthropicMessage{
                Role:    "user",
                Content: msg.Content,
            })
            
        case "assistant":
            // 处理工具调用
            if msg.ToolCallID != "" {
                result = append(result, anthropicMessage{
                    Role:    "assistant",
                    Content: "",
                    ToolCalls: []toolCall{{
                        ID:   msg.ToolCallID,
                        Name: msg.Name,
                        Input: json.RawMessage(msg.Content),
                    }},
                })
            } else {
                result = append(result, anthropicMessage{
                    Role:    "assistant",
                    Content: msg.Content,
                })
            }
            
        case "tool":
            result = append(result, anthropicMessage{
                Role:    "user",
                Content: fmt.Sprintf(
                    "<tool_result id=\"%s\">%s</tool_result>",
                    msg.ToolCallID,
                    msg.Content,
                ),
            })
        }
    }
    
    return result
}

func (p *AnthropicProvider) convertTools(tools []Tool) []anthropicTool {
    var result []anthropicTool
    
    for _, tool := range tools {
        result = append(result, anthropicTool{
            Name:        tool.Name,
            Description: tool.Description,
            InputSchema: tool.Parameters,  // JSON Schema 格式
        })
    }
    
    return result
}

// internal/llm/provider/openai.go
type OpenAIProvider struct {
    apiKey   string
    baseURL  string
    orgID    string
    projectID string
}

func NewOpenAI(apiKey string) *OpenAIProvider {
    return &OpenAIProvider{
        apiKey:  apiKey,
        baseURL: "https://api.openai.com/v1",
    }
}

func (p *OpenAIProvider) Name() models.ModelProvider {
    return models.ProviderOpenAI
}

func (p *OpenAIProvider) CreateChatCompletion(
    ctx context.Context,
    modelID models.ModelID,
    messages []Message,
    tools []Tool,
    options Options,
) (*ChatCompletion, error) {
    // 1. 转换为 OpenAI 格式
    openAIMessages := p.convertMessages(messages)
    
    // 2. 构建请求
    req := chatCompletionRequest{
        Model: string(modelID),
        Messages: openAIMessages,
        MaxTokens: options.MaxTokens,
        Temperature: options.Temperature,
        TopP: options.TopP,
        Stop: options.Stop,
        Stream: options.Stream,
    }
    
    // 3. 添加工具定义
    if len(tools) > 0 {
        req.Tools = p.convertTools(tools)
        req.ToolChoice = "auto"
    }
    
    // 4. 发送请求
    body, err := p.doRequest(ctx, req)
    if err != nil {
        return nil, err
    }
    
    // 5. 解析响应
    return p.parseResponse(body)
}

func (p *OpenAIProvider) convertMessages(messages []Message) []openaiMessage {
    var result []openaiMessage
    
    for _, msg := range messages {
        openAIMsg := openaiMessage{
            Role: msg.Role,
        }
        
        if msg.Role == "tool" {
            openAIMsg.ToolCallID = msg.ToolCallID
            openAIMsg.Content = msg.Content
        } else if msg.ToolCallID != "" {
            // Assistant 携带工具调用
            openAIMsg.ToolCalls = []toolCall{{
                ID: msg.ToolCallID,
                Type: "function",
                Function: functionCall{
                    Name: msg.Name,
                    Arguments: msg.Content,
                },
            }}
            openAIMsg.Content = ""  // 有 tool_calls 时 content 可以为空
        } else {
            openAIMsg.Content = msg.Content
        }
        
        result = append(result, openAIMsg)
    }
    
    return result
}

// internal/llm/provider/factory.go
func GetProvider(p models.ModelProvider, apiKey string) Provider {
    switch p {
    case models.ProviderAnthropic:
        return NewAnthropic(apiKey)
    case models.ProviderOpenAI:
        return NewOpenAI(apiKey)
    case models.ProviderCopilot:
        return NewCopilot(apiKey)
    case models.ProviderGemini:
        return NewGemini(apiKey)
    case models.ProviderGroq:
        return NewGroq(apiKey)
    case models.ProviderOpenRouter:
        return NewOpenRouter(apiKey)
    case models.ProviderXAI:
        return NewXAI(apiKey)
    case models.ProviderAzure:
        return NewAzure(apiKey)
    case models.ProviderBedrock:
        return NewBedrock(apiKey)
    case models.ProviderVertexAI:
        return NewVertexAI(apiKey)
    default:
        return nil
    }
}

// internal/config/config.go
func setProviderDefaults() {
    // 按优先级顺序检查
    providers := []struct {
        name         models.ModelProvider
        envVar       string
        defaultModel models.ModelID
    }{
        {models.ProviderCopilot, "GITHUB_TOKEN", models.CopilotGPT4o},
        {models.ProviderAnthropic, "ANTHROPIC_API_KEY", models.Claude4Sonnet},
        {models.ProviderOpenAI, "OPENAI_API_KEY", models.GPT4o},
        {models.ProviderGemini, "GEMINI_API_KEY", models.Gemma15Pro},
        {models.ProviderGroq, "GROQ_API_KEY", models.GroqLlama70B},
        {models.ProviderOpenRouter, "OPENROUTER_API_KEY", models.OpenRouterGPT4o},
        {models.ProviderXAI, "XAI_API_KEY", models.XAIGrok2},
    }
    
    for _, p := range providers {
        if apiKey := os.Getenv(p.envVar); apiKey != "" {
            viper.SetDefault("providers."+string(p.name)+".apiKey", apiKey)
            viper.SetDefault("agents.coder.model", p.defaultModel)
            return  // 找到第一个有效的就返回
        }
    }
}

// 在 Agent 执行过程中动态切换 Provider
func (a *Agent) switchProvider(modelID models.ModelID) error {
    model, ok := models.SupportedModels[modelID]
    if !ok {
        return fmt.Errorf("unsupported model: %s", modelID)
    }
    
    providerCfg, ok := a.cfg.Providers[model.Provider]
    if !ok || providerCfg.Disabled || providerCfg.APIKey == "" {
        return fmt.Errorf("provider %s not available", model.Provider)
    }
    
    a.provider = provider.GetProvider(model.Provider, providerCfg.APIKey)
    a.modelID = modelID
    
    return nil
}

type CostTracker struct {
    totalPromptTokens     int64
    totalCompletionTokens int64
    mu                    sync.Mutex
}

func (t *CostTracker) Add(usage Usage) {
    t.mu.Lock()
    defer t.mu.Unlock()
    
    t.totalPromptTokens += int64(usage.PromptTokens)
    t.totalCompletionTokens += int64(usage.CompletionTokens)
}

func (t *CostTracker) GetCost(models []models.ModelID) float64 {
    t.mu.Lock()
    defer t.mu.Unlock()
    
    var totalCost float64
    
    for _, modelID := range models {
        model, ok := models.SupportedModels[modelID]
        if !ok {
            continue
        }
        
        // 计算成本
        inputCost := float64(model.InputCostPer1M) / 1_000_000
        outputCost := float64(model.OutputCostPer1M) / 1_000_000
        
        totalCost += float64(t.totalPromptTokens) * inputCost
        totalCost += float64(t.totalCompletionTokens) * outputCost
    }
    
    return totalCost
}

type BudgetManager struct {
    maxBudgetPerSession float64
    maxTokensPerRequest int64
}

func (m *BudgetManager) CanMakeRequest(modelID models.ModelID, estimatedTokens int64) bool {
    // 检查请求 token 限制
    model, ok := models.SupportedModels[modelID]
    if !ok {
        return false
    }
    
    if estimatedTokens > model.MaxTokens {
        return false
    }
    
    if estimatedTokens > m.maxTokensPerRequest {
        return false
    }
    
    return true
}

{
  "type": "content_block",
  "name": "tool_use",
  "input": {
    "id": "toolu_123",
    "name": "Bash",
    "input": {"command": "ls -la"}
  }
}

{
  "id": "call_123",
  "type": "function",
  "function": {
    "name": "Bash",
    "arguments": "{\"command\": \"ls -la\"}"
  }
}

// internal/llm/provider/provider.go
type ToolCall struct {
    ID   string  // 统一 ID
    Name string  // 工具名
    Args string  // JSON 参数
}

// Provider 实现负责转换为自己 Provider 的格式

if options.ReasoningEffort != "" {
    req.Beta = "automated-2025-05-14"
    req.MaxTokens = maxTokens + 16000  // 额外空间存储思考过程
    
    // thinking 块会被追加到响应中
}

func (p *AnthropicProvider) CreateChatCompletionStream(
    ctx context.Context,
    modelID models.ModelID,
    messages []Message,
    tools []Tool,
    options Options,
) (<-chan ChatCompletion, error) {
    stream := make(chan ChatCompletion, 100)
    
    go func() {
        defer close(stream)
        
        // 实现流式解析
        reader := p.doStreamRequest(ctx, req)
        decoder := json.NewDecoder(reader)
        
        for decoder.More() {
            var event anthropicEvent
            if err := decoder.Decode(&event); err != nil {
                return
            }
            
            // 发送增量更新
            stream <- ChatCompletion{
                Content: event.Delta,
            }
        }
    }()
    
    return stream, nil
}

func (p *AnthropicProvider) CreateVisionRequest(
    ctx context.Context,
    modelID models.ModelID,
    text string,
    imageURLs []string,
) (*ChatCompletion, error) {
    content := []any{
        map[string]string{"type": "text", "text": text},
    }
    
    for _, url := range imageURLs {
        content = append(content, map[string]any{
            "type": "image",
            "source": map[string]string{
                "type":  "url",
                "url":   url,
            },
        })
    }
    
    // ...
}

// Agent 代码不需要关心使用的是哪个 Provider
resp, err := a.provider.CreateChatCompletion(ctx, modelID, messages, tools, options)

# 只需要设置 API Key
export ANTHROPIC_API_KEY="sk-ant-..."
opencode