Files
yunzerwebsiteallinone/go/controllers/platform_ai.go
T
2026-11-16 17:22:50 +08:00

1100 lines
30 KiB
Go

package controllers
import (
"bufio"
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
"time"
"server/models"
"server/pkg/identity"
"github.com/beego/beego/v2/client/orm"
beego "github.com/beego/beego/v2/server/web"
)
type PlatformAiController struct {
beego.Controller
}
func (c *PlatformAiController) jsonErr(httpStatus, bizCode int, msg string) {
c.Ctx.Output.SetStatus(httpStatus)
c.Data["json"] = map[string]any{"code": bizCode, "msg": msg}
_ = c.ServeJSON()
}
func maskKey(key string) string {
key = strings.TrimSpace(key)
if len(key) <= 8 {
if key == "" {
return ""
}
return "***"
}
return key[:4] + "***" + key[len(key)-4:]
}
func fillProvider(m *models.PlatformAiProvider) {
if m.Models != "" {
var raw []json.RawMessage
if err := json.Unmarshal([]byte(m.Models), &raw); err == nil {
for _, r := range raw {
var item models.AiModelItem
if err := json.Unmarshal(r, &item); err == nil && item.ID != "" {
m.ModelsList = append(m.ModelsList, item)
continue
}
var s string
if err := json.Unmarshal(r, &s); err == nil && s != "" {
m.ModelsList = append(m.ModelsList, models.AiModelItem{ID: s, Name: s})
}
}
}
}
m.ApiKeyMasked = maskKey(m.ApiKey)
m.ApiKey = ""
}
func (c *PlatformAiController) List() {
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
ptype := strings.TrimSpace(c.GetString("provider_type"))
qs := models.Orm.QueryTable(new(models.PlatformAiProvider)).
Filter("delete_time__isnull", true)
if ptype != "" {
qs = qs.Filter("provider_type", ptype)
}
var rows []models.PlatformAiProvider
_, _ = qs.OrderBy("-is_default", "-id").All(&rows)
for i := range rows {
fillProvider(&rows[i])
}
c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": rows}
_ = c.ServeJSON()
}
type platformAiProviderPayload struct {
ID uint64 `json:"id"`
ProviderType string `json:"provider_type"`
ApiType string `json:"api_type"`
Name string `json:"name"`
ApiBase string `json:"api_base"`
ApiKey string `json:"api_key"`
Models []models.AiModelItem `json:"models"`
DefaultModel string `json:"default_model"`
IsDefault int8 `json:"is_default"`
Status int8 `json:"status"`
Remark string `json:"remark"`
}
func readProviderPayload(c *PlatformAiController) (*platformAiProviderPayload, bool) {
raw, err := io.ReadAll(c.Ctx.Request.Body)
if err != nil {
c.jsonErr(400, 400, "参数错误")
return nil, false
}
var p platformAiProviderPayload
if err := json.Unmarshal(raw, &p); err != nil {
c.jsonErr(400, 400, "参数错误")
return nil, false
}
p.ProviderType = strings.TrimSpace(p.ProviderType)
p.ApiType = strings.TrimSpace(p.ApiType)
if p.ApiType == "" {
p.ApiType = "chat_completions"
}
switch p.ApiType {
case "chat_completions", "responses", "anthropic":
default:
c.jsonErr(400, 400, "不支持的协议类型")
return nil, false
}
p.Name = strings.TrimSpace(p.Name)
p.ApiBase = strings.TrimRight(strings.TrimSpace(p.ApiBase), "/")
if p.ProviderType == "" || p.Name == "" || p.ApiBase == "" {
c.jsonErr(400, 400, "服务商类型、名称、API基址不能为空")
return nil, false
}
return &p, true
}
func (p *platformAiProviderPayload) toModel() *models.PlatformAiProvider {
modelsJSON, _ := json.Marshal(p.Models)
return &models.PlatformAiProvider{
ID: p.ID, ProviderType: p.ProviderType, ApiType: p.ApiType, Name: p.Name, ApiBase: p.ApiBase,
ApiKey: p.ApiKey, Models: string(modelsJSON), DefaultModel: strings.TrimSpace(p.DefaultModel),
IsDefault: p.IsDefault, Status: p.Status, Remark: strings.TrimSpace(p.Remark),
}
}
func (c *PlatformAiController) Create() {
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
p, ok := readProviderPayload(c)
if !ok {
return
}
m := p.toModel()
if m.Status != 0 {
m.Status = 1
}
if p.IsDefault == 1 {
_, _ = models.Orm.QueryTable(new(models.PlatformAiProvider)).
Filter("delete_time__isnull", true).Update(map[string]any{"is_default": 0})
}
id, err := models.Orm.Insert(m)
if err != nil {
c.jsonErr(500, 500, "保存失败: "+err.Error())
return
}
c.Data["json"] = map[string]any{"code": 200, "msg": "保存成功", "data": map[string]any{"id": id}}
_ = c.ServeJSON()
}
func (c *PlatformAiController) Update() {
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
id, _ := c.GetInt64(":id", 0)
if id <= 0 {
c.jsonErr(400, 400, "无效ID")
return
}
p, ok := readProviderPayload(c)
if !ok {
return
}
m := p.toModel()
update := map[string]any{
"provider_type": m.ProviderType, "api_type": m.ApiType, "name": m.Name, "api_base": m.ApiBase,
"models": m.Models, "default_model": m.DefaultModel,
"is_default": m.IsDefault, "status": m.Status, "remark": m.Remark,
}
if strings.TrimSpace(p.ApiKey) != "" {
update["api_key"] = p.ApiKey
}
if p.IsDefault == 1 {
_, _ = models.Orm.QueryTable(new(models.PlatformAiProvider)).
Filter("delete_time__isnull", true).Filter("id__ne", id).
Update(map[string]any{"is_default": 0})
}
n, err := models.Orm.QueryTable(new(models.PlatformAiProvider)).
Filter("id", id).Filter("delete_time__isnull", true).Update(update)
if err != nil {
c.jsonErr(500, 500, "保存失败: "+err.Error())
return
}
if n == 0 {
c.jsonErr(404, 404, "配置不存在")
return
}
c.Data["json"] = map[string]any{"code": 200, "msg": "保存成功"}
_ = c.ServeJSON()
}
func (c *PlatformAiController) Delete() {
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
id, _ := c.GetInt64(":id", 0)
n, err := models.Orm.QueryTable(new(models.PlatformAiProvider)).
Filter("id", id).Filter("delete_time__isnull", true).
Update(map[string]any{"delete_time": time.Now()})
if err != nil {
c.jsonErr(500, 500, "删除失败: "+err.Error())
return
}
if n == 0 {
c.jsonErr(404, 404, "配置不存在")
return
}
c.Data["json"] = map[string]any{"code": 200, "msg": "删除成功"}
_ = c.ServeJSON()
}
func loadPlatformProvider(id uint64) (*models.PlatformAiProvider, error) {
var m models.PlatformAiProvider
qs := models.Orm.QueryTable(new(models.PlatformAiProvider)).
Filter("delete_time__isnull", true).Filter("status", 1)
if id > 0 {
err := qs.Filter("id", id).One(&m)
return &m, err
}
err := qs.Filter("is_default", 1).One(&m)
if err != nil {
err = models.Orm.QueryTable(new(models.PlatformAiProvider)).
Filter("delete_time__isnull", true).Filter("status", 1).
OrderBy("-id").One(&m)
}
return &m, err
}
func chatCompletion(provider *models.PlatformAiProvider, model string, messages []map[string]string) (string, error) {
switch provider.ApiType {
case "responses":
return chatResponses(provider, model, messages)
case "anthropic":
return chatAnthropic(provider, model, messages)
default:
return chatCompletions(provider, model, messages)
}
}
func doAIRequest(req *http.Request, apiKey string) ([]byte, int, error) {
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+apiKey)
client := &http.Client{Timeout: 90 * time.Second}
resp, err := client.Do(req)
if err != nil {
return nil, 0, err
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
return body, resp.StatusCode, nil
}
func chatCompletions(provider *models.PlatformAiProvider, model string, messages []map[string]string) (string, error) {
payload := map[string]any{"model": model, "messages": messages, "stream": false}
body, _ := json.Marshal(payload)
req, err := http.NewRequest("POST", provider.ApiBase+"/chat/completions", bytes.NewReader(body))
if err != nil {
return "", err
}
respBody, status, err := doAIRequest(req, provider.ApiKey)
if err != nil {
return "", err
}
if status != 200 {
return "", errUpstream(string(respBody))
}
var out struct {
Choices []struct {
Message struct {
Content string `json:"content"`
} `json:"message"`
} `json:"choices"`
Error *struct {
Message string `json:"message"`
} `json:"error"`
}
if err := json.Unmarshal(respBody, &out); err != nil {
return "", err
}
if out.Error != nil && out.Error.Message != "" {
return "", errUpstream(out.Error.Message)
}
if len(out.Choices) == 0 {
return "", errUpstream("上游返回为空")
}
return out.Choices[0].Message.Content, nil
}
func chatResponses(provider *models.PlatformAiProvider, model string, messages []map[string]string) (string, error) {
payload := map[string]any{"model": model, "input": messages}
body, _ := json.Marshal(payload)
req, err := http.NewRequest("POST", provider.ApiBase+"/responses", bytes.NewReader(body))
if err != nil {
return "", err
}
respBody, status, err := doAIRequest(req, provider.ApiKey)
if err != nil {
return "", err
}
if status != 200 {
return "", errUpstream(string(respBody))
}
var out struct {
OutputText string `json:"output_text"`
Output []struct {
Type string `json:"type"`
Content []struct {
Type string `json:"type"`
Text string `json:"text"`
} `json:"content"`
} `json:"output"`
Error *struct {
Message string `json:"message"`
} `json:"error"`
}
if err := json.Unmarshal(respBody, &out); err != nil {
return "", err
}
if out.Error != nil && out.Error.Message != "" {
return "", errUpstream(out.Error.Message)
}
if out.OutputText != "" {
return out.OutputText, nil
}
for _, item := range out.Output {
for _, c := range item.Content {
if c.Text != "" {
return c.Text, nil
}
}
}
return "", errUpstream("上游返回为空")
}
func chatAnthropic(provider *models.PlatformAiProvider, model string, messages []map[string]string) (string, error) {
var systemParts []string
var msgs []map[string]string
for _, m := range messages {
role := m["role"]
if role == "system" {
systemParts = append(systemParts, m["content"])
continue
}
if role == "assistant" {
role = "assistant"
} else {
role = "user"
}
msgs = append(msgs, map[string]string{"role": role, "content": m["content"]})
}
payload := map[string]any{
"model": model,
"max_tokens": 4096,
"messages": msgs,
}
if len(systemParts) > 0 {
payload["system"] = strings.Join(systemParts, "\n")
}
body, _ := json.Marshal(payload)
base := strings.TrimRight(provider.ApiBase, "/")
if !strings.HasSuffix(base, "/v1") {
base += "/v1"
}
req, err := http.NewRequest("POST", base+"/messages", bytes.NewReader(body))
if err != nil {
return "", err
}
req.Header.Set("x-api-key", provider.ApiKey)
req.Header.Set("anthropic-version", "2023-06-01")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{Timeout: 90 * time.Second}
resp, err := client.Do(req)
if err != nil {
return "", err
}
defer resp.Body.Close()
respBody, _ := io.ReadAll(resp.Body)
if resp.StatusCode != 200 {
return "", errUpstream(string(respBody))
}
var out struct {
Content []struct {
Type string `json:"type"`
Text string `json:"text"`
} `json:"content"`
Error *struct {
Message string `json:"message"`
} `json:"error"`
}
if err := json.Unmarshal(respBody, &out); err != nil {
return "", err
}
if out.Error != nil && out.Error.Message != "" {
return "", errUpstream(out.Error.Message)
}
for _, c := range out.Content {
if c.Text != "" {
return c.Text, nil
}
}
return "", errUpstream("上游返回为空")
}
type upstreamError string
func (e upstreamError) Error() string { return "AI服务调用失败: " + string(e) }
func errUpstream(msg string) error { return upstreamError(msg) }
func (c *PlatformAiController) Test() {
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
var req struct {
ID uint64 `json:"id"`
Model string `json:"model"`
}
raw, _ := io.ReadAll(c.Ctx.Request.Body)
_ = json.Unmarshal(raw, &req)
provider, err := loadPlatformProvider(req.ID)
if err != nil {
c.jsonErr(400, 400, "服务商配置不存在或未启用")
return
}
model := strings.TrimSpace(req.Model)
if model == "" {
model = provider.DefaultModel
}
if model == "" {
var list []models.AiModelItem
_ = json.Unmarshal([]byte(provider.Models), &list)
if len(list) > 0 {
model = list[0].ID
}
}
if model == "" {
c.jsonErr(400, 400, "未配置可用模型")
return
}
start := time.Now()
content, err := chatCompletion(provider, model, []map[string]string{
{"role": "user", "content": "请只回复两个字:正常"},
})
if err != nil {
c.jsonErr(502, 502, err.Error())
return
}
c.Data["json"] = map[string]any{
"code": 200, "msg": "连接成功",
"data": map[string]any{
"latency_ms": int(time.Since(start).Milliseconds()),
"reply": content,
"model": model,
},
}
_ = c.ServeJSON()
}
func (c *PlatformAiController) Chat() {
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
var req struct {
ProviderID uint64 `json:"provider_id"`
Model string `json:"model"`
Messages []map[string]string `json:"messages"`
}
raw, _ := io.ReadAll(c.Ctx.Request.Body)
if err := json.Unmarshal(raw, &req); err != nil || len(req.Messages) == 0 {
c.jsonErr(400, 400, "参数错误")
return
}
provider, err := loadPlatformProvider(req.ProviderID)
if err != nil {
c.jsonErr(400, 400, "服务商配置不存在或未启用")
return
}
model := strings.TrimSpace(req.Model)
if model == "" {
model = provider.DefaultModel
}
if model == "" {
c.jsonErr(400, 400, "未选择模型")
return
}
clean := make([]map[string]string, 0, len(req.Messages))
for _, m := range req.Messages {
role := strings.TrimSpace(m["role"])
if role != "user" && role != "assistant" && role != "system" {
continue
}
clean = append(clean, map[string]string{"role": role, "content": m["content"]})
}
if len(clean) == 0 {
c.jsonErr(400, 400, "消息为空")
return
}
content, err := chatCompletion(provider, model, clean)
if err != nil {
c.jsonErr(502, 502, err.Error())
return
}
c.Data["json"] = map[string]any{
"code": 200, "msg": "success",
"data": map[string]any{"content": content, "model": model},
}
_ = c.ServeJSON()
}
var ocrConfigTags = []string{"ocr_enabled", "ocr_provider_id", "ocr_model", "ocr_prompt"}
func (c *PlatformAiController) OcrConfig() {
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
all := models.GetPlatformSiteTagMap()
data := make(map[string]string, len(ocrConfigTags))
for _, tag := range ocrConfigTags {
data[tag] = all[tag]
}
c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": data}
_ = c.ServeJSON()
}
func (c *PlatformAiController) SaveOcrConfig() {
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
raw, err := io.ReadAll(c.Ctx.Request.Body)
if err != nil {
c.jsonErr(400, 400, "参数错误")
return
}
var payload map[string]string
if err := json.Unmarshal(raw, &payload); err != nil {
c.jsonErr(400, 400, "参数错误")
return
}
values := make(map[string]string, len(ocrConfigTags))
for _, tag := range ocrConfigTags {
if v, ok := payload[tag]; ok {
values[tag] = strings.TrimSpace(v)
}
}
if len(values) == 0 {
c.jsonErr(400, 400, "参数错误")
return
}
if err := models.SavePlatformSiteSettings(values); err != nil {
c.jsonErr(500, 500, "保存失败: "+err.Error())
return
}
c.Data["json"] = map[string]any{"code": 200, "msg": "保存成功"}
_ = c.ServeJSON()
}
func (c *PlatformAiController) RecognizeOcr() {
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
all := models.GetPlatformSiteTagMap()
enabled := strings.TrimSpace(all["ocr_enabled"]) == "1"
c.Data["json"] = map[string]any{
"code": 200,
"msg": "success",
"data": map[string]any{
"enabled": enabled,
"provider_id": all["ocr_provider_id"],
"model": all["ocr_model"],
"recognized": false,
"message": "OCR 识别服务待接入,配置已保存",
"placeholder": true,
},
}
_ = c.ServeJSON()
}
func writeStreamEvent(w http.ResponseWriter, flusher http.Flusher, ev map[string]any) {
b, _ := json.Marshal(ev)
fmt.Fprintf(w, "data: %s\n\n", b)
if flusher != nil {
flusher.Flush()
}
}
func buildStreamRequest(provider *models.PlatformAiProvider, model string, messages []map[string]any) (*http.Request, error) {
var url string
var payload map[string]any
switch provider.ApiType {
case "responses":
url = provider.ApiBase + "/responses"
payload = map[string]any{"model": model, "input": messages, "stream": true}
case "anthropic":
base := strings.TrimRight(provider.ApiBase, "/")
if !strings.HasSuffix(base, "/v1") {
base += "/v1"
}
url = base + "/messages"
var systemParts []string
var msgs []map[string]any
for _, m := range messages {
role, _ := m["role"].(string)
if role == "system" {
if s, ok := m["content"].(string); ok {
systemParts = append(systemParts, s)
}
continue
}
if role != "assistant" {
role = "user"
}
msgs = append(msgs, map[string]any{"role": role, "content": anthropicContent(m["content"])})
}
payload = map[string]any{"model": model, "max_tokens": 4096, "messages": msgs, "stream": true}
if len(systemParts) > 0 {
payload["system"] = strings.Join(systemParts, "\n")
}
default:
url = provider.ApiBase + "/chat/completions"
payload = map[string]any{"model": model, "messages": messages, "stream": true}
}
body, _ := json.Marshal(payload)
req, err := http.NewRequest("POST", url, bytes.NewReader(body))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
if provider.ApiType == "anthropic" {
req.Header.Set("x-api-key", provider.ApiKey)
req.Header.Set("anthropic-version", "2023-06-01")
} else {
req.Header.Set("Authorization", "Bearer "+provider.ApiKey)
}
return req, nil
}
func anthropicContent(content any) []map[string]any {
if s, ok := content.(string); ok {
return []map[string]any{{"type": "text", "text": s}}
}
arr, ok := content.([]any)
if !ok {
return []map[string]any{{"type": "text", "text": ""}}
}
var blocks []map[string]any
for _, item := range arr {
m, ok := item.(map[string]any)
if !ok {
continue
}
switch m["type"] {
case "text":
if t, ok := m["text"].(string); ok {
blocks = append(blocks, map[string]any{"type": "text", "text": t})
}
case "image_url":
if iu, ok := m["image_url"].(map[string]any); ok {
if u, ok := iu["url"].(string); ok {
if media, data, ok := parseDataURL(u); ok {
blocks = append(blocks, map[string]any{
"type": "image",
"source": map[string]any{
"type": "base64",
"media_type": media,
"data": data,
},
})
}
}
}
}
}
if len(blocks) == 0 {
blocks = append(blocks, map[string]any{"type": "text", "text": ""})
}
return blocks
}
func parseDataURL(u string) (media, data string, ok bool) {
if !strings.HasPrefix(u, "data:") {
return "", "", false
}
rest := strings.TrimPrefix(u, "data:")
idx := strings.Index(rest, ";base64,")
if idx < 0 {
return "", "", false
}
return rest[:idx], rest[idx+len(";base64,"):], true
}
func normalizeStreamData(apiType string, data string) ([]map[string]any, bool) {
data = strings.TrimSpace(data)
if data == "" || data == "[DONE]" {
return nil, data == "[DONE]"
}
var raw map[string]any
if err := json.Unmarshal([]byte(data), &raw); err != nil {
return nil, false
}
switch apiType {
case "responses":
typ, _ := raw["type"].(string)
switch typ {
case "response.output_text.delta":
if d, ok := raw["delta"].(string); ok && d != "" {
return []map[string]any{{"t": "delta", "c": d}}, false
}
case "response.reasoning_summary_text.delta", "response.reasoning_text.delta":
if d, ok := raw["delta"].(string); ok && d != "" {
return []map[string]any{{"t": "think", "c": d}}, false
}
case "response.completed":
return nil, true
case "response.failed", "error":
msg := "上游返回错误"
if e, ok := raw["error"].(map[string]any); ok {
if m, ok := e["message"].(string); ok {
msg = m
}
}
if r, ok := raw["response"].(map[string]any); ok {
if e, ok := r["error"].(map[string]any); ok {
if m, ok := e["message"].(string); ok {
msg = m
}
}
}
return []map[string]any{{"t": "error", "c": msg}}, true
}
case "anthropic":
typ, _ := raw["type"].(string)
switch typ {
case "content_block_delta":
if d, ok := raw["delta"].(map[string]any); ok {
dt, _ := d["type"].(string)
if dt == "text_delta" {
if t, ok := d["text"].(string); ok && t != "" {
return []map[string]any{{"t": "delta", "c": t}}, false
}
}
if dt == "thinking_delta" {
if t, ok := d["thinking"].(string); ok && t != "" {
return []map[string]any{{"t": "think", "c": t}}, false
}
}
}
case "message_stop":
return nil, true
case "error":
msg := "上游返回错误"
if e, ok := raw["error"].(map[string]any); ok {
if m, ok := e["message"].(string); ok {
msg = m
}
}
return []map[string]any{{"t": "error", "c": msg}}, true
}
default:
choices, _ := raw["choices"].([]any)
if len(choices) > 0 {
if ch, ok := choices[0].(map[string]any); ok {
if delta, ok := ch["delta"].(map[string]any); ok {
var evs []map[string]any
if t, ok := delta["reasoning_content"].(string); ok && t != "" {
evs = append(evs, map[string]any{"t": "think", "c": t})
}
if t, ok := delta["content"].(string); ok && t != "" {
evs = append(evs, map[string]any{"t": "delta", "c": t})
}
return evs, false
}
}
}
if e, ok := raw["error"].(map[string]any); ok {
if m, ok := e["message"].(string); ok {
return []map[string]any{{"t": "error", "c": m}}, true
}
}
}
return nil, false
}
func (c *PlatformAiController) ChatStream() {
defer c.StopRun()
if _, err := requirePlatform(&c.Controller); err != nil {
code := identity.Status(err)
c.jsonErr(code, code, err.Error())
return
}
var req struct {
ProviderID uint64 `json:"provider_id"`
Model string `json:"model"`
Messages []map[string]any `json:"messages"`
SessionID uint64 `json:"session_id"`
}
raw, _ := io.ReadAll(c.Ctx.Request.Body)
if err := json.Unmarshal(raw, &req); err != nil || len(req.Messages) == 0 {
c.jsonErr(400, 400, "参数错误")
return
}
if req.SessionID > 0 {
persistUserMessage(req.SessionID, req.Messages[len(req.Messages)-1]["content"])
}
provider, err := loadPlatformProvider(req.ProviderID)
if err != nil {
c.jsonErr(400, 400, "服务商配置不存在或未启用")
return
}
model := strings.TrimSpace(req.Model)
if model == "" {
model = provider.DefaultModel
}
if model == "" {
c.jsonErr(400, 400, "未选择模型")
return
}
clean := make([]map[string]any, 0, len(req.Messages))
for _, m := range req.Messages {
role, _ := m["role"].(string)
role = strings.TrimSpace(role)
if role != "user" && role != "assistant" && role != "system" {
continue
}
clean = append(clean, map[string]any{"role": role, "content": m["content"]})
}
if len(clean) == 0 {
c.jsonErr(400, 400, "消息为空")
return
}
upReq, err := buildStreamRequest(provider, model, clean)
if err != nil {
c.jsonErr(500, 500, "构建请求失败")
return
}
client := &http.Client{Timeout: 300 * time.Second}
resp, err := client.Do(upReq)
if err != nil {
c.jsonErr(502, 502, "AI服务调用失败: "+err.Error())
return
}
defer resp.Body.Close()
rw := c.Ctx.ResponseWriter.ResponseWriter
rw.Header().Set("Content-Type", "text/event-stream; charset=utf-8")
rw.Header().Set("Cache-Control", "no-cache")
rw.Header().Set("Connection", "keep-alive")
rw.Header().Set("X-Accel-Buffering", "no")
rw.WriteHeader(200)
flusher, _ := rw.(http.Flusher)
if resp.StatusCode != 200 {
body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
writeStreamEvent(rw, flusher, map[string]any{"t": "error", "c": "AI服务调用失败: " + string(body)})
writeStreamEvent(rw, flusher, map[string]any{"t": "done"})
return
}
scanner := bufio.NewScanner(resp.Body)
scanner.Buffer(make([]byte, 64*1024), 1024*1024)
var accContent, accThink strings.Builder
for scanner.Scan() {
line := scanner.Text()
if !strings.HasPrefix(line, "data:") {
continue
}
payload := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
events, isDone := normalizeStreamData(provider.ApiType, payload)
for _, ev := range events {
writeStreamEvent(rw, flusher, ev)
if ev["t"] == "delta" {
if s, ok := ev["c"].(string); ok {
accContent.WriteString(s)
}
} else if ev["t"] == "think" {
if s, ok := ev["c"].(string); ok {
accThink.WriteString(s)
}
}
}
if isDone {
break
}
}
writeStreamEvent(rw, flusher, map[string]any{"t": "done"})
persistStreamResult(req.SessionID, accContent.String(), accThink.String())
}
func persistStreamResult(sessionID uint64, content, think string) {
if sessionID == 0 {
return
}
var last models.PlatformAiChatMessage
_ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
Filter("session_id", sessionID).OrderBy("-seq").Limit(1).One(&last, "seq")
_, _ = models.Orm.Insert(&models.PlatformAiChatMessage{
SessionID: sessionID,
Role: "assistant",
Content: content,
Think: think,
Seq: last.Seq + 1,
CreateTime: time.Now(),
})
_, _ = models.Orm.QueryTable(new(models.PlatformAiChatSession)).
Filter("id", sessionID).
Update(orm.Params{"update_time": time.Now()})
}
func persistUserMessage(sessionID uint64, content any) {
if sessionID == 0 {
return
}
b, _ := json.Marshal(content)
var last models.PlatformAiChatMessage
_ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
Filter("session_id", sessionID).OrderBy("-seq").Limit(1).One(&last, "seq")
_, _ = models.Orm.Insert(&models.PlatformAiChatMessage{
SessionID: sessionID,
Role: "user",
Content: string(b),
Seq: last.Seq + 1,
CreateTime: time.Now(),
})
var cnt int64
_, _ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
Filter("session_id", sessionID).Count()
if cnt == 1 {
if s := userContentText(content); s != "" {
if r := []rune(s); len(r) > 30 {
s = string(r[:30]) + "..."
}
_, _ = models.Orm.QueryTable(new(models.PlatformAiChatSession)).
Filter("id", sessionID).Update(orm.Params{"title": s})
}
}
_, _ = models.Orm.QueryTable(new(models.PlatformAiChatSession)).
Filter("id", sessionID).
Update(orm.Params{"update_time": time.Now()})
}
func userContentText(content any) string {
switch v := content.(type) {
case string:
return v
case []any:
var sb strings.Builder
for _, item := range v {
if m, ok := item.(map[string]any); ok && m["type"] == "text" {
if t, ok := m["text"].(string); ok {
sb.WriteString(t)
}
}
}
return sb.String()
}
return ""
}
func (c *PlatformAiController) ListChatSessions() {
if _, err := requirePlatform(&c.Controller); err != nil {
c.jsonErr(403, 403, "无权限")
return
}
var list []models.PlatformAiChatSession
_, err := models.Orm.QueryTable(new(models.PlatformAiChatSession)).
Filter("delete_time__isnull", true).
OrderBy("-is_top", "-update_time").Limit(100).All(&list)
if err != nil {
c.jsonErr(500, 500, "查询失败")
return
}
c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": list}
_ = c.ServeJSON()
}
func (c *PlatformAiController) CreateChatSession() {
if _, err := requirePlatform(&c.Controller); err != nil {
c.jsonErr(403, 403, "无权限")
return
}
var req struct {
ProviderID uint64 `json:"provider_id"`
Model string `json:"model"`
}
_ = json.Unmarshal(c.Ctx.Input.RequestBody, &req)
s := models.PlatformAiChatSession{
ProviderID: req.ProviderID,
Model: req.Model,
CreateTime: time.Now(),
UpdateTime: time.Now(),
}
id, err := models.Orm.Insert(&s)
if err != nil {
c.jsonErr(500, 500, "创建失败")
return
}
s.ID = uint64(id)
c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": s}
_ = c.ServeJSON()
}
func (c *PlatformAiController) GetChatSessionMessages() {
if _, err := requirePlatform(&c.Controller); err != nil {
c.jsonErr(403, 403, "无权限")
return
}
id, _ := c.GetInt64(":id")
var msgs []models.PlatformAiChatMessage
_, _ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
Filter("session_id", id).OrderBy("seq").All(&msgs)
c.Data["json"] = map[string]any{"code": 200, "msg": "success", "data": msgs}
_ = c.ServeJSON()
}
func (c *PlatformAiController) UpdateChatSession() {
if _, err := requirePlatform(&c.Controller); err != nil {
c.jsonErr(403, 403, "无权限")
return
}
id, _ := c.GetInt64(":id")
var req struct {
Title *string `json:"title"`
IsTop *int8 `json:"is_top"`
}
_ = json.Unmarshal(c.Ctx.Input.RequestBody, &req)
params := orm.Params{}
if req.Title != nil {
t := strings.TrimSpace(*req.Title)
if t == "" {
t = "新对话"
}
if r := []rune(t); len(r) > 100 {
t = string(r[:100])
}
params["title"] = t
}
if req.IsTop != nil {
params["is_top"] = *req.IsTop
}
if len(params) == 0 {
c.jsonErr(400, 400, "无更新内容")
return
}
_, err := models.Orm.QueryTable(new(models.PlatformAiChatSession)).
Filter("id", id).Update(params)
if err != nil {
c.jsonErr(500, 500, "更新失败")
return
}
c.Data["json"] = map[string]any{"code": 200, "msg": "success"}
_ = c.ServeJSON()
}
func (c *PlatformAiController) DeleteChatSession() {
if _, err := requirePlatform(&c.Controller); err != nil {
c.jsonErr(403, 403, "无权限")
return
}
id, _ := c.GetInt64(":id")
now := time.Now()
_, _ = models.Orm.QueryTable(new(models.PlatformAiChatSession)).
Filter("id", id).Update(orm.Params{"delete_time": now})
_, _ = models.Orm.QueryTable(new(models.PlatformAiChatMessage)).
Filter("session_id", id).Delete()
c.Data["json"] = map[string]any{"code": 200, "msg": "success"}
_ = c.ServeJSON()
}