go-svc-code/internal/routes/prompt_stream_routes.go

package routes

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"

	"git.x2erp.com/qdy/go-base/authbase"
	"git.x2erp.com/qdy/go-base/webx"
	"git.x2erp.com/qdy/go-base/webx/router"
	"git.x2erp.com/qdy/go-svc-code/internal/opencode"
)

// PromptStreamRequest 流式对话请求
type PromptStreamRequest struct {
	SessionID string              `json:"sessionID" binding:"required"`
	Parts     []opencode.TextPart `json:"parts" binding:"required"`
	Agent     string              `json:"agent,omitempty"`
	Model     *opencode.ModelInfo `json:"model,omitempty"`
}

// RegisterPromptStreamRoutes 注册流式对话路由
func RegisterPromptStreamRoutes(ws *router.RouterService, webService *webx.WebService, client opencode.OpenCodeClient) {
	// 流式对话需要直接处理 HTTP 流式响应，不能使用标准的路由包装
	// 我们直接注册到 webService 的底层路由器
	webService.GetRouter().Handle("/api/prompt/stream", StreamPromptHandler(client))
}

// StreamPromptHandler 流式对话的 HTTP 处理器（已包含TokenAuth认证）
func StreamPromptHandler(client opencode.OpenCodeClient) http.HandlerFunc {
	// 创建内部处理器
	handler := func(w http.ResponseWriter, r *http.Request) {
		fmt.Printf("🔍 [StreamPromptHandler] 收到流式对话请求: %s %s\n", r.Method, r.URL.String())

		// 解析请求
		var req PromptStreamRequest
		if err := BindJSON(r, &req); err != nil {
			fmt.Printf("🔍 [StreamPromptHandler] 解析请求失败: %v\n", err)
			http.Error(w, fmt.Sprintf("解析请求失败: %v", err), http.StatusBadRequest)
			return
		}

		fmt.Printf("🔍 [StreamPromptHandler] 请求数据: sessionID=%s, agent=%v, parts=%d\n",
			req.SessionID, req.Agent, len(req.Parts))
		if len(req.Parts) > 0 && req.Parts[0].Text != "" {
			fmt.Printf("🔍 [StreamPromptHandler] 用户消息: %s\n", req.Parts[0].Text)
		}

		// 创建 prompt 请求
		prompt := &opencode.PromptRequest{
			Parts: req.Parts,
			Agent: req.Agent,
			Model: req.Model,
		}

		// 设置 SSE 头
		w.Header().Set("Content-Type", "text/event-stream")
		w.Header().Set("Cache-Control", "no-cache")
		w.Header().Set("Connection", "keep-alive")
		w.Header().Set("Access-Control-Allow-Origin", "*")

		// 创建带超时的上下文
		ctx, cancel := context.WithTimeout(r.Context(), 5*time.Minute)
		defer cancel()

		fmt.Printf("🔍 [StreamPromptHandler] 调用 SendPromptStream, sessionID=%s\n", req.SessionID)
		// 获取流式响应通道
		ch, err := client.SendPromptStream(ctx, req.SessionID, prompt)
		if err != nil {
			fmt.Printf("🔍 [StreamPromptHandler] 发送流式请求失败: %v\n", err)
			http.Error(w, fmt.Sprintf("发送流式请求失败: %v", err), http.StatusInternalServerError)
			return
		}
		fmt.Printf("🔍 [StreamPromptHandler] 成功获取流式响应通道\n")

		// 发送流式响应
		flusher, ok := w.(http.Flusher)
		if !ok {
			http.Error(w, "Streaming unsupported", http.StatusInternalServerError)
			return
		}

		fmt.Printf("🔍 [StreamPromptHandler] 开始发送流式响应\n")
		eventCount := 0

		for {
			select {
			case data, ok := <-ch:
				if !ok {
					// 通道关闭，发送结束标记
					fmt.Printf("🔍 [StreamPromptHandler] 流式通道关闭，发送DONE标记，共发送 %d 个事件\n", eventCount)
					fmt.Fprintf(w, "data: [DONE]\n\n")
					flusher.Flush()
					return
				}
				// 发送 SSE 数据
				eventCount++
				fmt.Printf("🔍 [StreamPromptHandler] 发送SSE数据[%d]: %s\n", eventCount, data)

				// 发送 SSE 数据，opencode 数据已包含 payload 字段，不需要额外包装
				var wrappedData string
				if data == "[DONE]" {
					wrappedData = "[DONE]"
				} else {
					// 尝试解析为JSON，检查是否已有payload字段
					var jsonData interface{}
					if err := json.Unmarshal([]byte(data), &jsonData); err == nil {
						// 去重处理：移除message.updated事件中的重复content，并过滤不必要的事件
						jsonData = removeDuplicateContent(jsonData)

						// 如果返回nil，跳过此事件
						if jsonData == nil {
							continue
						}

						// 检查是否是对象且包含payload字段
						if obj, ok := jsonData.(map[string]interface{}); ok && obj["payload"] != nil {
							// 已有payload字段，直接发送原始数据
							wrappedData = data
						} else {
							// 没有payload字段，包装在payload对象中
							wrapped := map[string]interface{}{
								"payload": jsonData,
							}
							wrappedBytes, _ := json.Marshal(wrapped)
							wrappedData = string(wrappedBytes)
						}
					} else {
						// 不是JSON，按原样发送
						wrappedData = data
					}
				}

				fmt.Fprintf(w, "data: %s\n\n", wrappedData)
				flusher.Flush()
			case <-ctx.Done():
				fmt.Printf("🔍 [StreamPromptHandler] 上下文超时\n")
				return
			case <-r.Context().Done():
				fmt.Printf("🔍 [StreamPromptHandler] 客户端断开连接\n")
				return
			}
		}
	}

	// 包装TokenAuth中间件
	return authbase.TokenAuth(http.HandlerFunc(handler)).ServeHTTP
}

// BindJSON 简单的 JSON 绑定函数
func BindJSON(r *http.Request, v interface{}) error {
	body, err := io.ReadAll(r.Body)
	if err != nil {
		return err
	}
	defer r.Body.Close()

	return json.Unmarshal(body, v)
}

// removeDuplicateContent 移除message.updated事件中的重复content，避免前端重复显示
func removeDuplicateContent(data interface{}) interface{} {
	// 检查是否为map
	obj, ok := data.(map[string]interface{})
	if !ok {
		return data
	}

	// 递归处理payload字段
	if payload, ok := obj["payload"].(map[string]interface{}); ok {
		obj["payload"] = removeDuplicateContent(payload)
	}

	// 如果payload是数组（可能嵌套），处理每个元素
	if payloadArr, ok := obj["payload"].([]interface{}); ok {
		for i, item := range payloadArr {
			if itemMap, ok := item.(map[string]interface{}); ok {
				payloadArr[i] = removeDuplicateContent(itemMap)
			}
		}
	}

	// 检查type字段
	typeVal, hasType := obj["type"]
	if !hasType {
		return obj
	}

	typeStr, ok := typeVal.(string)
	if !ok {
		return obj
	}

	// 事件过滤策略：减少发送给前端的事件数量
	switch typeStr {
	case "message.updated":
		// 检查是否有properties字段
		if properties, ok := obj["properties"].(map[string]interface{}); ok {
			if info, ok := properties["info"].(map[string]interface{}); ok {
				// 移除content字段，避免重复
				delete(info, "content")

				// 检查是否有completed时间，如果没有则过滤掉（只发送最终状态）
				if timeInfo, ok := info["time"].(map[string]interface{}); ok {
					if timeInfo["completed"] == nil {
						// 没有completed时间，这是中间状态，过滤掉
						return nil
					}
				}
			}
		}
	case "session.status":
		// session.status事件很频繁但前端可能不需要，过滤掉
		return nil
	case "session.diff":
		// session.diff事件通常为空，过滤掉
		return nil
	case "server.heartbeat":
		// 心跳事件，过滤掉
		return nil
	case "session.idle":
		// 空闲事件，过滤掉
		return nil
	}

	return obj
}