临时保存

internal/opencode/direct_client.go

 	"io"
 	"net/http"
 	"os"
+	"path/filepath"
 	"strings"
 	"time"
 )
 	fmt.Printf("🔍 [opencode.DirectClient] 请求 URL: %s\n", url)
 	fmt.Printf("🔍 [opencode.DirectClient] 请求头: %v\n", req.Header)
 
-	resp, err := c.httpClient.Do(req)
+	// 为SSE流创建独立的httpClient，不设置超时限制
+	sseClient := &http.Client{
+		// 不设置Timeout，允许长连接
+		// Timeout: 0 表示无超时限制
+	}
+	resp, err := sseClient.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("发送请求失败: %w", err)
 	}
 				if err == io.EOF {
 					fmt.Printf("🔍 [opencode.DirectClient] SSE流结束，共收到 %d 个事件\n", eventCount)
 				} else {
-					fmt.Printf("🔍 [opencode.DirectClient] 读取错误: %v\n", err)
+					// 区分正常取消和错误
+					if ctx.Err() != nil {
+						fmt.Printf("🔍 [opencode.DirectClient] SSE流正常结束（上下文取消）\n")
+					} else {
+						fmt.Printf("🔍 [opencode.DirectClient] 读取错误: %v\n", err)
+					}
 				}
 				return
 			}
 				eventCount++
 				fmt.Printf("🔍 [opencode.DirectClient] 收到SSE数据[%d]: %s\n", eventCount, data)
 
+				// 写入日志文件用于分析
+				writeStreamLog(sessionID, data)
+
 				select {
 				case ch <- data:
 				case <-ctx.Done():
 
 	fmt.Printf("🔍 [opencode.DirectClient] 订阅全局事件流: %s\n", url)
 
-	resp, err := c.httpClient.Do(req)
+	// 为SSE连接创建独立的httpClient，不设置超时限制
+	sseClient := &http.Client{
+		// 不设置Timeout，允许长连接
+		// Timeout: 0 表示无超时限制
+	}
+
+	resp, err := sseClient.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("订阅事件流失败: %w", err)
 	}
 				eventCount++
 				fmt.Printf("🔍 [opencode.DirectClient] 收到全局事件[%d]: %s\n", eventCount, data)
 
+				// 写入日志文件用于分析
+				writeStreamLog("", data)
+
 				select {
 				case ch <- data:
 				case <-ctx.Done():
 		}
 
 		if err := scanner.Err(); err != nil {
-			fmt.Printf("🔍 [opencode.DirectClient] 扫描事件流错误: %v\n", err)
+			// 区分正常取消和错误
+			if ctx.Err() != nil {
+				fmt.Printf("🔍 [opencode.DirectClient] 全局事件流正常结束（上下文取消）\n")
+			} else {
+				fmt.Printf("🔍 [opencode.DirectClient] 扫描事件流错误: %v\n", err)
+			}
 		}
 	}()
 
 func (c *DirectClient) GetPort() int {
 	return c.port
 }
+
+// writeStreamLog 将流式数据写入日志文件用于分析
+func writeStreamLog(sessionID string, data string) {
+	// 创建日志目录
+	logDir := "/Users/kenqdy/Documents/v-bdx-workspace/svc-code/logs"
+	if err := os.MkdirAll(logDir, 0755); err != nil {
+		fmt.Printf("🔍 [opencode-direct-client] 创建日志目录失败: %v\n", err)
+		return
+	}
+
+	// 生成日志文件名，按日期和会话ID组织
+	dateStr := time.Now().Format("20060102")
+	hourStr := time.Now().Format("15") // 小时
+	var filename string
+
+	if sessionID == "" {
+		// 全局事件按小时组织
+		filename = fmt.Sprintf("stream-global-%s-%s.log", dateStr, hourStr)
+	} else {
+		// 会话事件按会话ID和日期组织
+		filename = fmt.Sprintf("stream-session-%s-%s.log", sessionID, dateStr)
+	}
+
+	filepath := filepath.Join(logDir, filename)
+
+	// 追加写入数据
+	file, err := os.OpenFile(filepath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		fmt.Printf("🔍 [opencode-direct-client] 打开日志文件失败: %v\n", err)
+		return
+	}
+	defer file.Close()
+
+	// 写入时间戳和数据
+	logLine := fmt.Sprintf("[%s] %s\n", time.Now().Format("15:04:05.000"), data)
+	if _, err := file.WriteString(logLine); err != nil {
+		fmt.Printf("🔍 [opencode-direct-client] 写入日志失败: %v\n", err)
+	}
+}

internal/routes/prompt_stream_routes.go

 					// 尝试解析为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字段，直接发送原始数据
 
 	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
+}