272 lines
9.1 KiB
Go
272 lines
9.1 KiB
Go
// openai.go - OpenAI 兼容 LLM 客户端实现 // Logan.Li
|
||
// 复用 aiops 既有 LLM 调用模式（model.LLMConfig + resolveEndpoint + /chat/completions + Bearer）。
|
||
// 支持所有 OpenAI 兼容后端：openai / deepseek / qwen / moonshot / ollama / custom。
|
||
package llm
|
||
|
||
import (
|
||
"bufio"
|
||
"bytes"
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"io"
|
||
"net/http"
|
||
"strings"
|
||
"time"
|
||
)
|
||
|
||
// Config LLM 客户端配置（endpoint 已由上层解析为完整 base url） // Logan.Li
|
||
type Config struct {
|
||
Protocol string // "openai" | "anthropic"，由 client.go 工厂决定具体实现
|
||
Endpoint string // 完整 base url，如 https://api.deepseek.com/v1
|
||
APIKey string // Bearer token
|
||
Model string // 模型名，如 deepseek-chat / gpt-4o-mini
|
||
Temperature float64 // 采样温度
|
||
MaxTokens int // 单次最大输出 token
|
||
ReasoningEnabled bool // 是否启用推理/Plan 模式（OpenAI o-series / DeepSeek R1 等） // Logan.Li
|
||
Timeout time.Duration // HTTP 超时（0 表示使用默认 180s）
|
||
}
|
||
|
||
// OpenAIClient OpenAI 兼容客户端 // Logan.Li
|
||
type OpenAIClient struct {
|
||
cfg Config
|
||
client *http.Client
|
||
}
|
||
|
||
// NewOpenAIClient 创建 OpenAI 兼容客户端 // Logan.Li
|
||
// 顶层工厂在 client.go（按 Protocol 路由到 OpenAI / Anthropic 实现）。
|
||
func NewOpenAIClient(cfg Config) Client {
|
||
timeout := cfg.Timeout
|
||
if timeout <= 0 {
|
||
timeout = 180 * time.Second
|
||
}
|
||
return &OpenAIClient{
|
||
cfg: cfg,
|
||
client: &http.Client{Timeout: timeout},
|
||
}
|
||
}
|
||
|
||
// Name 返回客户端名称 // Logan.Li
|
||
func (c *OpenAIClient) Name() string { return "openai-compatible(" + c.cfg.Model + ")" }
|
||
|
||
// isOpenAIReasoningModel 判断是否为使用新推理参数的 OpenAI 模型。 // Logan.Li
|
||
func isOpenAIReasoningModel(model string) bool {
|
||
m := strings.ToLower(model)
|
||
if index := strings.LastIndex(m, "/"); index >= 0 {
|
||
m = m[index+1:]
|
||
}
|
||
return strings.HasPrefix(m, "o1") || strings.HasPrefix(m, "o3") ||
|
||
strings.HasPrefix(m, "o4") || strings.HasPrefix(m, "gpt-5")
|
||
}
|
||
|
||
// isGenericReasoningModel 判断是否为通用推理开关模型（DeepSeek R1 等） // Logan.Li
|
||
func isGenericReasoningModel(model string) bool {
|
||
m := strings.ToLower(model)
|
||
return strings.Contains(m, "reasoning") || strings.Contains(m, "r1") || strings.Contains(m, "deepseek-reasoner")
|
||
}
|
||
|
||
// applyReasoningParams 根据模型类型应用 token 与 reasoning 参数。 // Logan.Li
|
||
func applyReasoningParams(payload *openaiRequest, enabled bool) {
|
||
if isOpenAIReasoningModel(payload.Model) {
|
||
// 新版 OpenAI 推理模型使用 max_completion_tokens 且不接收 temperature。 // Logan.Li
|
||
payload.MaxCompletionTokens = payload.MaxTokens
|
||
payload.MaxTokens = 0
|
||
payload.Temperature = 0
|
||
if enabled {
|
||
payload.ReasoningEffort = "medium"
|
||
}
|
||
return
|
||
}
|
||
if enabled && isGenericReasoningModel(payload.Model) {
|
||
payload.Reasoning = true
|
||
}
|
||
}
|
||
|
||
// openaiRequest OpenAI chat/completions 请求体 // Logan.Li
|
||
type openaiRequest struct {
|
||
Model string `json:"model"`
|
||
Messages []Message `json:"messages"`
|
||
Tools []Tool `json:"tools,omitempty"`
|
||
ToolChoice string `json:"tool_choice,omitempty"` // "auto" 让模型自主决定
|
||
Temperature float64 `json:"temperature,omitempty"`
|
||
MaxTokens int `json:"max_tokens,omitempty"`
|
||
MaxCompletionTokens int `json:"max_completion_tokens,omitempty"` // 新版 OpenAI 推理模型的输出上限 // Logan.Li
|
||
Stream bool `json:"stream,omitempty"` // 流式补全（Stream 方法置 true）
|
||
ReasoningEffort string `json:"reasoning_effort,omitempty"` // OpenAI o-series 推理强度 // Logan.Li
|
||
Reasoning bool `json:"reasoning,omitempty"` // DeepSeek 等部分平台推理开关 // Logan.Li
|
||
}
|
||
|
||
// openaiResponse OpenAI chat/completions 响应体 // Logan.Li
|
||
type openaiResponse struct {
|
||
Choices []struct {
|
||
Message struct {
|
||
Role string `json:"role"`
|
||
Content string `json:"content"`
|
||
ToolCalls []ToolCall `json:"tool_calls"`
|
||
} `json:"message"`
|
||
} `json:"choices"`
|
||
Usage Usage `json:"usage"`
|
||
Error *struct {
|
||
Message string `json:"message"`
|
||
Type string `json:"type"`
|
||
} `json:"error,omitempty"`
|
||
}
|
||
|
||
// Complete 调用 OpenAI 兼容接口完成一轮补全 // Logan.Li
|
||
// 返回 assistant 消息（含思考文本 content 与工具调用计划 tool_calls）+ token 统计。
|
||
func (c *OpenAIClient) Complete(ctx context.Context, req *CompletionRequest) (*CompletionResponse, error) {
|
||
payload := openaiRequest{
|
||
Model: c.cfg.Model,
|
||
Messages: req.Messages,
|
||
Tools: req.Tools,
|
||
ToolChoice: "auto",
|
||
Temperature: c.cfg.Temperature,
|
||
MaxTokens: c.cfg.MaxTokens,
|
||
}
|
||
if payload.MaxTokens <= 0 {
|
||
payload.MaxTokens = 4096
|
||
}
|
||
applyReasoningParams(&payload, req.ReasoningEnabled || c.cfg.ReasoningEnabled)
|
||
body, err := json.Marshal(payload)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("序列化请求失败: %w", err)
|
||
}
|
||
|
||
url := c.cfg.Endpoint + "/chat/completions"
|
||
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
|
||
if err != nil {
|
||
return nil, fmt.Errorf("构造请求失败: %w", err)
|
||
}
|
||
httpReq.Header.Set("Content-Type", "application/json")
|
||
httpReq.Header.Set("Authorization", "Bearer "+c.cfg.APIKey)
|
||
|
||
resp, err := c.client.Do(httpReq)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("LLM 连接失败: %w", err)
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
raw, _ := io.ReadAll(resp.Body)
|
||
if resp.StatusCode != http.StatusOK {
|
||
return nil, fmt.Errorf("LLM 返回错误 (HTTP %d): %s", resp.StatusCode, extractErrorMessage(raw))
|
||
}
|
||
|
||
var parsed openaiResponse
|
||
if err := json.Unmarshal(raw, &parsed); err != nil {
|
||
return nil, fmt.Errorf("解析 LLM 响应失败: %w", err)
|
||
}
|
||
if parsed.Error != nil && parsed.Error.Message != "" {
|
||
return nil, fmt.Errorf("LLM 错误: %s", parsed.Error.Message)
|
||
}
|
||
if len(parsed.Choices) == 0 {
|
||
return nil, fmt.Errorf("LLM 未返回任何结果")
|
||
}
|
||
|
||
choice := parsed.Choices[0].Message
|
||
return &CompletionResponse{
|
||
Model: c.cfg.Model,
|
||
Message: Message{
|
||
Role: choice.Role,
|
||
Content: choice.Content,
|
||
ToolCalls: choice.ToolCalls,
|
||
},
|
||
Usage: parsed.Usage,
|
||
}, nil
|
||
}
|
||
|
||
// Stream 流式补全（OpenAI 兼容 SSE），逐 token 回调 onDelta，返回聚合响应 // Logan.Li
|
||
// 解析 data: {"choices":[{"delta":{"content":"..."}}]} 增量；[DONE] 结束；末块 usage 若有则取。
|
||
func (c *OpenAIClient) Stream(ctx context.Context, req *CompletionRequest, onDelta func(string)) (*CompletionResponse, error) {
|
||
payload := openaiRequest{
|
||
Model: c.cfg.Model,
|
||
Messages: req.Messages,
|
||
Tools: req.Tools,
|
||
ToolChoice: "auto",
|
||
Temperature: c.cfg.Temperature,
|
||
MaxTokens: c.cfg.MaxTokens,
|
||
Stream: true,
|
||
}
|
||
if payload.MaxTokens <= 0 {
|
||
payload.MaxTokens = 4096
|
||
}
|
||
applyReasoningParams(&payload, req.ReasoningEnabled || c.cfg.ReasoningEnabled)
|
||
body, err := json.Marshal(payload)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("序列化请求失败: %w", err)
|
||
}
|
||
url := c.cfg.Endpoint + "/chat/completions"
|
||
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
|
||
if err != nil {
|
||
return nil, fmt.Errorf("构造请求失败: %w", err)
|
||
}
|
||
httpReq.Header.Set("Content-Type", "application/json")
|
||
httpReq.Header.Set("Authorization", "Bearer "+c.cfg.APIKey)
|
||
httpReq.Header.Set("Accept", "text/event-stream")
|
||
|
||
streamClient := &http.Client{Timeout: 0} // 流式由 ctx 控制超时
|
||
resp, err := streamClient.Do(httpReq)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("LLM 连接失败: %w", err)
|
||
}
|
||
defer resp.Body.Close()
|
||
if resp.StatusCode != http.StatusOK {
|
||
raw, _ := io.ReadAll(resp.Body)
|
||
return nil, fmt.Errorf("LLM 返回错误 (HTTP %d): %s", resp.StatusCode, extractErrorMessage(raw))
|
||
}
|
||
|
||
var contentBuilder strings.Builder
|
||
var usage Usage
|
||
reader := bufio.NewReader(resp.Body)
|
||
for {
|
||
line, readErr := reader.ReadString('\n')
|
||
line = strings.TrimSpace(line)
|
||
if line != "" && strings.HasPrefix(line, "data:") {
|
||
data := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
|
||
if data == "[DONE]" {
|
||
break
|
||
}
|
||
var chunk struct {
|
||
Choices []struct {
|
||
Delta struct {
|
||
Content string `json:"content"`
|
||
} `json:"delta"`
|
||
} `json:"choices"`
|
||
Usage *Usage `json:"usage"`
|
||
}
|
||
if json.Unmarshal([]byte(data), &chunk) == nil {
|
||
if len(chunk.Choices) > 0 && chunk.Choices[0].Delta.Content != "" {
|
||
delta := chunk.Choices[0].Delta.Content
|
||
contentBuilder.WriteString(delta)
|
||
if onDelta != nil {
|
||
onDelta(delta)
|
||
}
|
||
}
|
||
if chunk.Usage != nil {
|
||
usage = *chunk.Usage
|
||
}
|
||
}
|
||
}
|
||
if readErr != nil {
|
||
break
|
||
}
|
||
}
|
||
return &CompletionResponse{
|
||
Model: c.cfg.Model,
|
||
Message: Message{Role: "assistant", Content: contentBuilder.String()},
|
||
Usage: usage,
|
||
}, nil
|
||
}
|
||
|
||
// extractErrorMessage 从上游错误响应提取 message 字段 // Logan.Li
|
||
func extractErrorMessage(raw []byte) string {
|
||
var m struct {
|
||
Error struct {
|
||
Message string `json:"message"`
|
||
} `json:"error"`
|
||
}
|
||
if json.Unmarshal(raw, &m) == nil && m.Error.Message != "" {
|
||
return m.Error.Message
|
||
}
|
||
return string(raw)
|
||
}
|