修改SSE输出-增加获取历史对话api，简化消息推送

internal/opencode/client.go

@@ -11,6 +11,7 @@ type OpenCodeClient interface {
 	SendPromptStream(ctx context.Context, sessionID string, prompt *PromptRequest) (<-chan string, error)
 	GetSession(ctx context.Context, sessionID string) (*Session, error)
 	ListSessions(ctx context.Context) ([]Session, error)
+	GetSessionMessages(ctx context.Context, sessionID string, limit int) ([]SessionMessage, error)
 	GetBaseURL() string
 	GetPort() int
 }
@@ -72,3 +73,9 @@ type TokenInfo struct {
 	Input  int `json:"input"`
 	Output int `json:"output"`
 }
+
+// SessionMessage 会话消息（包含info和parts）
+type SessionMessage struct {
+	Info  map[string]interface{}   `json:"info"`
+	Parts []map[string]interface{} `json:"parts"`
+}

internal/opencode/direct_client.go

@@ -379,6 +379,50 @@ func (c *DirectClient) GetPort() int {
 	return c.port
 }
 
+// GetSessionMessages 获取会话消息历史
+func (c *DirectClient) GetSessionMessages(ctx context.Context, sessionID string, limit int) ([]SessionMessage, error) {
+	// 构造URL
+	url := fmt.Sprintf("%s/session/%s/message", c.baseURL, sessionID)
+
+	// 添加查询参数
+	if limit > 0 {
+		url = fmt.Sprintf("%s?limit=%d", url, limit)
+	}
+
+	// 发送HTTP请求
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("创建请求失败: %w", err)
+	}
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("获取会话消息失败: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("获取会话消息失败，状态码: %d, 响应体: %s", resp.StatusCode, string(body))
+	}
+
+	// 解析响应
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("读取响应体失败: %w", err)
+	}
+
+	// 解析JSON响应
+	var messages []SessionMessage
+	if err := json.Unmarshal(body, &messages); err != nil {
+		return nil, fmt.Errorf("解析消息响应失败: %w", err)
+	}
+
+	fmt.Fprintf(os.Stderr, "[opencode-direct-client] 获取会话消息成功: sessionID=%s, count=%d\n", sessionID, len(messages))
+	return messages, nil
+}
+
 // writeStreamLog 将流式数据写入日志文件用于分析
 func writeStreamLog(sessionID string, data string) {
 	// 创建日志目录

internal/opencode/mock_client.go

@@ -180,6 +180,95 @@ func (m *MockClient) GetBaseURL() string {
 	return m.baseURL
 }
 
+// GetSessionMessages 模拟获取会话消息
+func (m *MockClient) GetSessionMessages(ctx context.Context, sessionID string, limit int) ([]SessionMessage, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	if m.shouldFail {
+		return nil, fmt.Errorf("模拟错误: %s", m.failMessage)
+	}
+
+	if _, exists := m.sessions[sessionID]; !exists {
+		return nil, fmt.Errorf("会话不存在: %s", sessionID)
+	}
+
+	// 创建模拟消息
+	messages := []SessionMessage{
+		{
+			Info: map[string]interface{}{
+				"id":        "msg-mock-001",
+				"sessionID": sessionID,
+				"role":      "user",
+				"time": map[string]interface{}{
+					"created": float64(1770797040043),
+				},
+				"agent": "code-sql",
+				"model": map[string]interface{}{
+					"providerID": "deepseek",
+					"modelID":    "deepseek-reasoner",
+				},
+			},
+			Parts: []map[string]interface{}{
+				{
+					"id":   "prt-mock-001",
+					"type": "text",
+					"text": "编写查询昨天销售总额的sql代码。简单，用户没有提到的，保持最简单的方式返回内容",
+				},
+			},
+		},
+		{
+			Info: map[string]interface{}{
+				"id":        "msg-mock-002",
+				"sessionID": sessionID,
+				"role":      "assistant",
+				"time": map[string]interface{}{
+					"created":   float64(1770797040072),
+					"completed": float64(1770797045880),
+				},
+				"parentID":   "msg-mock-001",
+				"modelID":    "deepseek-reasoner",
+				"providerID": "deepseek",
+				"mode":       "code-sql",
+				"agent":      "code-sql",
+				"path": map[string]interface{}{
+					"cwd":  "/Users/kenqdy/Documents/v-bdx-workspace",
+					"root": "/",
+				},
+				"cost": 0.000514752,
+				"tokens": map[string]interface{}{
+					"input":     55,
+					"output":    114,
+					"reasoning": 68,
+					"cache": map[string]interface{}{
+						"read":  15104,
+						"write": 0,
+					},
+				},
+				"finish": "tool-calls",
+			},
+			Parts: []map[string]interface{}{
+				{
+					"id":   "prt-mock-002",
+					"type": "step-start",
+				},
+				{
+					"id":   "prt-mock-003",
+					"type": "reasoning",
+					"text": "用户想要查询昨天销售总额的SQL代码...",
+				},
+			},
+		},
+	}
+
+	// 如果有限制，截取消息
+	if limit > 0 && limit < len(messages) {
+		messages = messages[:limit]
+	}
+
+	return messages, nil
+}
+
 // GetPort 获取端口
 func (m *MockClient) GetPort() int {
 	return m.port

internal/routes/prompt_stream_routes.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"git.x2erp.com/qdy/go-base/authbase"
-	goctx "git.x2erp.com/qdy/go-base/ctx"
 	"git.x2erp.com/qdy/go-base/logger"
 	"git.x2erp.com/qdy/go-base/webx"
 	"git.x2erp.com/qdy/go-base/webx/router"
@@ -75,9 +74,8 @@ func StreamPromptHandler(client opencode.OpenCodeClient) http.HandlerFunc {
 		ctx, cancel := context.WithTimeout(r.Context(), 15*time.Minute)
 		defer cancel()
 
-		// 获取事件分发器实例和订阅服务
+		// 获取事件分发器实例
 		dispatcher := event.GetEventDispatcher(client.GetBaseURL(), client.GetPort())
-		subscriptionService := event.GetSubscriptionService()
 
 		// 从认证上下文中获取用户ID（用于缓存，按sessionID分发事件）
 		userID := "unknown-user"
@@ -99,40 +97,14 @@ func StreamPromptHandler(client opencode.OpenCodeClient) http.HandlerFunc {
 
 		logger.Debug(fmt.Sprintf("🔍 [StreamPromptHandler] 用户ID: %s, 用户名: %s, 会话ID: %s", userID, username, req.SessionID))
 
-		// 构建请求上下文
-		reqCtx := &goctx.RequestContext{
-			UserID:   userID,
-			Username: username,
-			// 可以添加更多字段：TraceID、TenantID等
-			TraceID: fmt.Sprintf("stream-%d", time.Now().UnixNano()),
-		}
-
-		// 使用订阅服务注册会话和订阅事件（如果可用）
-		var ch <-chan string
-		var err error
-
-		if subscriptionService != nil {
-			// 使用订阅服务（集成MongoDB和上下文）
-			subscriptionService.RegisterSessionWithContext(req.SessionID, reqCtx)
-			ch, err = subscriptionService.SubscribeWithContext(req.SessionID, reqCtx)
-			if err != nil {
-				logger.Error(fmt.Sprintf("🔍 [StreamPromptHandler] 订阅服务订阅失败: %v", err))
-				http.Error(w, fmt.Sprintf("订阅失败: %v", err), http.StatusInternalServerError)
-				return
-			}
-			defer subscriptionService.UnsubscribeWithContext(req.SessionID, ch, reqCtx)
-		} else {
-			// 回退到直接使用事件分发器
-			logger.Warn("⚠️ [StreamPromptHandler] 订阅服务不可用，使用事件分发器回退")
-			dispatcher.RegisterSession(req.SessionID, userID)
-			ch, err = dispatcher.Subscribe(req.SessionID, userID)
-			if err != nil {
-				logger.Error(fmt.Sprintf("🔍 [StreamPromptHandler] 事件分发器订阅失败: %v", err))
-				http.Error(w, fmt.Sprintf("订阅失败: %v", err), http.StatusInternalServerError)
-				return
-			}
-			defer dispatcher.Unsubscribe(req.SessionID, ch)
+		// 使用事件分发器订阅会话事件
+		ch, err := dispatcher.Subscribe(req.SessionID, userID)
+		if err != nil {
+			logger.Error(fmt.Sprintf("🔍 [StreamPromptHandler] 事件分发器订阅失败: %v", err))
+			http.Error(w, fmt.Sprintf("订阅失败: %v", err), http.StatusInternalServerError)
+			return
 		}
+		defer dispatcher.Unsubscribe(req.SessionID, ch)
 
 		// 发送异步请求到 opencode（触发AI处理）
 		logger.Debug(fmt.Sprintf("🔍 [StreamPromptHandler] 发送异步请求到 opencode, sessionID=%s", req.SessionID))
@@ -143,7 +115,7 @@ func StreamPromptHandler(client opencode.OpenCodeClient) http.HandlerFunc {
 			http.Error(w, fmt.Sprintf("发送请求失败: %v", err), http.StatusInternalServerError)
 			return
 		}
-		logger.Debug(fmt.Sprintf("🔍 [StreamPromptHandler] 异步请求发送成功，等待事件流"))
+		logger.Debug("🔍 [StreamPromptHandler] 异步请求发送成功，等待事件流")
 
 		// 发送流式响应
 		flusher, ok := w.(http.Flusher)
@@ -152,7 +124,7 @@ func StreamPromptHandler(client opencode.OpenCodeClient) http.HandlerFunc {
 			return
 		}
 
-		logger.Debug(fmt.Sprintf("🔍 [StreamPromptHandler] 开始发送流式响应"))
+		logger.Debug("🔍 [StreamPromptHandler] 开始发送流式响应")
 		eventCount := 0
 
 		// 创建心跳定时器，每30秒发送一次心跳保活（SSE注释格式）
@@ -181,7 +153,7 @@ func StreamPromptHandler(client opencode.OpenCodeClient) http.HandlerFunc {
 					if len(preview) > 100 {
 						preview = preview[:100] + "..."
 					}
-					logger.Debug(fmt.Sprintf("🔍 [StreamPromptHandler] 发送SSE数据[%d]: %s", eventCount, preview))
+					//logger.Debug(fmt.Sprintf("🔍 [StreamPromptHandler] 发送SSE数据[%d]: %s", eventCount, preview))
 				}
 
 				// 发送 SSE 数据，opencode 数据已包含 payload 字段，不需要额外包装
@@ -221,15 +193,15 @@ func StreamPromptHandler(client opencode.OpenCodeClient) http.HandlerFunc {
 				fmt.Fprintf(w, "data: %s\n\n", wrappedData)
 				flusher.Flush()
 			case <-ctx.Done():
-				logger.Info(fmt.Sprintf("🔍 [StreamPromptHandler] 上下文超时"))
+				logger.Debug("🔍 [StreamPromptHandler] 上下文超时")
 				return
 			case <-heartbeatTicker.C:
 				// 发送心跳保活（SSE注释格式）
-				logger.Debug(fmt.Sprintf("🔍 [StreamPromptHandler] 发送心跳保活"))
+				logger.Debug("🔍 [StreamPromptHandler] 发送心跳保活")
 				fmt.Fprintf(w, ": heartbeat\n\n")
 				flusher.Flush()
 			case <-r.Context().Done():
-				logger.Info(fmt.Sprintf("🔍 [StreamPromptHandler] 客户端断开连接"))
+				logger.Debug("🔍 [StreamPromptHandler] 客户端断开连接")
 				return
 			}
 		}

internal/routes/session_messages_routes.go

@@ -0,0 +1,57 @@
+package routes
+
+import (
+	"context"
+
+	"git.x2erp.com/qdy/go-base/authbase"
+	"git.x2erp.com/qdy/go-base/ctx"
+	"git.x2erp.com/qdy/go-base/logger"
+	"git.x2erp.com/qdy/go-base/model/response"
+	"git.x2erp.com/qdy/go-base/webx/router"
+	"git.x2erp.com/qdy/go-svc-code/internal/opencode"
+)
+
+// GetSessionMessagesRequest 获取会话消息请求
+type GetSessionMessagesRequest struct {
+	SessionID string `form:"sessionID" binding:"required"`
+	Limit     int    `form:"limit,omitempty"`
+}
+
+// SessionMessagesResponse 会话消息响应
+type SessionMessagesResponse struct {
+	Messages []opencode.SessionMessage `json:"messages"`
+	Count    int                       `json:"count"`
+}
+
+// RegisterSessionMessagesRoutes 注册会话消息路由
+func RegisterSessionMessagesRoutes(ws *router.RouterService, client opencode.OpenCodeClient) {
+	// 获取会话消息历史（需要Token认证）
+	ws.GET("/api/session/messages",
+		func(req *GetSessionMessagesRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[SessionMessagesResponse], error) {
+			if req.SessionID == "" {
+				return &response.QueryResult[SessionMessagesResponse]{
+					Success: false,
+					Message: "参数 sessionID 不能为空",
+				}, nil
+			}
+
+			// 调用 opencode 客户端获取消息
+			messages, err := client.GetSessionMessages(ctx, req.SessionID, req.Limit)
+			if err != nil {
+				logger.Error("获取会话消息失败", "session_id", req.SessionID, "error", err)
+				return &response.QueryResult[SessionMessagesResponse]{
+					Success: false,
+					Message: "获取会话消息失败: " + err.Error(),
+				}, nil
+			}
+
+			return &response.QueryResult[SessionMessagesResponse]{
+				Success: true,
+				Data: SessionMessagesResponse{
+					Messages: messages,
+					Count:    len(messages),
+				},
+			}, nil
+		},
+	).Use(authbase.TokenAuth).Desc("获取指定会话的消息历史").Register()
+}

internal/service/event/cache.go

@@ -1,118 +0,0 @@
-package event
-
-import (
-	"sync"
-	"time"
-)
-
-// SessionUserCache 会话-用户映射缓存，支持TTL过期
-type SessionUserCache struct {
-	mu       sync.RWMutex
-	cache    map[string]cacheEntry
-	ttl      time.Duration
-	stopChan chan struct{}
-}
-
-// cacheEntry 缓存条目
-type cacheEntry struct {
-	userID    string
-	expiresAt time.Time
-}
-
-// NewSessionUserCache 创建新的会话-用户缓存
-func NewSessionUserCache(ttl time.Duration) *SessionUserCache {
-	cache := &SessionUserCache{
-		cache:    make(map[string]cacheEntry),
-		ttl:      ttl,
-		stopChan: make(chan struct{}),
-	}
-
-	// 启动清理协程
-	go cache.cleanupWorker()
-
-	return cache
-}
-
-// Set 设置会话-用户映射
-func (c *SessionUserCache) Set(sessionID, userID string) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	c.cache[sessionID] = cacheEntry{
-		userID:    userID,
-		expiresAt: time.Now().Add(c.ttl),
-	}
-}
-
-// Get 获取用户ID，如果不存在或已过期返回空字符串
-func (c *SessionUserCache) Get(sessionID string) string {
-	c.mu.RLock()
-	entry, exists := c.cache[sessionID]
-	c.mu.RUnlock()
-
-	if !exists {
-		return ""
-	}
-
-	// 检查是否过期
-	if time.Now().After(entry.expiresAt) {
-		// 异步删除过期条目
-		go c.deleteIfExpired(sessionID)
-		return ""
-	}
-
-	return entry.userID
-}
-
-// Delete 删除指定会话的缓存
-func (c *SessionUserCache) Delete(sessionID string) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	delete(c.cache, sessionID)
-}
-
-// deleteIfExpired 检查并删除过期条目
-func (c *SessionUserCache) deleteIfExpired(sessionID string) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if entry, exists := c.cache[sessionID]; exists {
-		if time.Now().After(entry.expiresAt) {
-			delete(c.cache, sessionID)
-		}
-	}
-}
-
-// cleanupWorker 定期清理过期条目的工作协程
-func (c *SessionUserCache) cleanupWorker() {
-	ticker := time.NewTicker(c.ttl / 2)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			c.cleanupExpired()
-		case <-c.stopChan:
-			return
-		}
-	}
-}
-
-// cleanupExpired 清理所有过期条目
-func (c *SessionUserCache) cleanupExpired() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	now := time.Now()
-	for sessionID, entry := range c.cache {
-		if now.After(entry.expiresAt) {
-			delete(c.cache, sessionID)
-		}
-	}
-}
-
-// Stop 停止缓存清理协程
-func (c *SessionUserCache) Stop() {
-	close(c.stopChan)
-}

internal/service/event/dispatcher.go

@@ -14,426 +14,23 @@ import (
 	"git.x2erp.com/qdy/go-base/logger"
 )
 
-// MessageType 消息类型枚举
-type MessageType string
-
-const (
-	MessageTypeThinking MessageType = "thinking" // 思考过程
-	MessageTypeTool     MessageType = "tool"     // 工具调用
-	MessageTypeReply    MessageType = "reply"    // 最终回复
-	MessageTypeUnknown  MessageType = "unknown"  // 未知类型
-)
-
-// CompletionHook 完成钩子接口，用于消息完成时的处理（如保存到数据库）
-type CompletionHook interface {
-	OnMessageComplete(sessionID string, messageID string, completeText string, eventType string, metadata map[string]interface{})
-}
-
-// MessageState 消息状态，用于跟踪单个消息的增量内容
-type MessageState struct {
-	SessionID  string
-	MessageID  string
-	StartTime  time.Time
-	LastUpdate time.Time
-	Metadata   map[string]interface{}
-
-	// 分离的缓冲区，用于不同类型的内容
-	ReasoningBuffer strings.Builder // 思考内容
-	ReplyBuffer     strings.Builder // 回答内容
-	ToolBuffer      strings.Builder // 工具调用
-
-	// 类型完成状态跟踪
-	CompletedTypes map[string]bool // 已完成的类型: "reasoning", "text", "tool"
-	HookTriggered  map[string]bool // 钩子触发状态，按类型记录
-
-	// 当前活跃类型（用于跟踪正在处理的内容）
-	CurrentType string // 当前正在处理的类型
-}
-
-// MessageAggregator 消息聚合器，负责合并增量内容并检测完成状态
-type MessageAggregator struct {
-	mu                    sync.RWMutex
-	messages              map[string]*MessageState // key: sessionID_messageID
-	hooks                 []CompletionHook
-	OnMessageCompleteFunc func(sessionID string, messageID string, completeText string, messageType MessageType, metadata map[string]interface{}) // 消息完成回调函数
-	OnEventProcessedFunc  func(sessionID string, eventType string, eventData string, eventMap map[string]interface{})                             // 事件处理回调函数
-}
-
-// NewMessageAggregator 创建新的消息聚合器
-func NewMessageAggregator() *MessageAggregator {
-	return &MessageAggregator{
-		messages:              make(map[string]*MessageState),
-		hooks:                 make([]CompletionHook, 0),
-		OnMessageCompleteFunc: nil,
-		OnEventProcessedFunc:  nil,
-	}
-}
-
-// RegisterHook 注册完成钩子
-func (ma *MessageAggregator) RegisterHook(hook CompletionHook) {
-	ma.mu.Lock()
-	defer ma.mu.Unlock()
-	ma.hooks = append(ma.hooks, hook)
-}
-
-// ProcessEvent 处理事件，合并增量内容并检测完成状态
-func (ma *MessageAggregator) ProcessEvent(eventData string, sessionID string) {
-	// 解析事件数据
-	var eventMap map[string]interface{}
-	if err := json.Unmarshal([]byte(eventData), &eventMap); err != nil {
-		logger.Debug(fmt.Sprintf("无法解析事件JSON error=%s dataPreview=%s",
-			err.Error(), safeSubstring(eventData, 0, 200)))
-		return
-	}
-
-	eventType := getEventType(eventMap)
-
-	// 诊断日志：记录处理的事件类型
-	logger.Debug(fmt.Sprintf("🔍 ProcessEvent: sessionID=%s eventType=%s dataPreview=%s",
-		sessionID, eventType, safeSubstring(eventData, 0, 100)))
-
-	// 调用事件处理回调函数（如果有设置）
-	if ma.OnEventProcessedFunc != nil {
-		ma.OnEventProcessedFunc(sessionID, eventType, eventData, eventMap)
-	}
-
-	// 只处理 message.part.updated, message.updated, session.status 事件
-	if eventType == "message.part.updated" {
-		ma.handleMessagePartUpdated(eventMap, sessionID, eventData)
-	} else if eventType == "message.updated" {
-		ma.handleMessageUpdated(eventMap, sessionID)
-	} else if eventType == "session.status" {
-		ma.handleSessionStatus(eventMap, sessionID)
-	} else if eventType == "session.idle" {
-		ma.handleSessionIdle(sessionID)
-	}
-	// 其他事件类型忽略
-}
-
-// handleMessagePartUpdated 处理 message.part.updated 事件
-func (ma *MessageAggregator) handleMessagePartUpdated(eventMap map[string]interface{}, sessionID string, eventData string) {
-	// 提取消息部分信息
-	payload, _ := eventMap["payload"].(map[string]interface{})
-	props, _ := payload["properties"].(map[string]interface{})
-	part, _ := props["part"].(map[string]interface{})
-
-	messageID, _ := part["messageID"].(string)
-	partType, _ := part["type"].(string)
-
-	if messageID == "" || (partType != "text" && partType != "reasoning" && partType != "step-finish" && partType != "tool") {
-		return
-	}
-
-	ma.mu.Lock()
-	defer ma.mu.Unlock()
-
-	key := sessionID + "_" + messageID
-	state, exists := ma.messages[key]
-
-	if !exists {
-		// step-finish 事件不应该创建新状态，它应该总是跟随在text/reasoning事件之后
-		if partType == "step-finish" {
-			logger.Debug(fmt.Sprintf("忽略step-finish事件，无对应消息状态 sessionID=%s messageID=%s",
-				sessionID, messageID))
-			return
-		}
-
-		// 新消息，初始化状态
-		state = &MessageState{
-			SessionID:      sessionID,
-			MessageID:      messageID,
-			StartTime:      time.Now(),
-			LastUpdate:     time.Now(),
-			Metadata:       make(map[string]interface{}),
-			CompletedTypes: make(map[string]bool),
-			HookTriggered:  make(map[string]bool),
-			CurrentType:    partType,
-		}
-		ma.messages[key] = state
-		logger.Debug(fmt.Sprintf("开始跟踪新消息 sessionID=%s messageID=%s type=%s",
-			sessionID, messageID, partType))
-	}
-
-	// 更新增量内容 - 根据类型写入不同的缓冲区
-	state.CurrentType = partType
-
-	if text, ok := part["text"].(string); ok && text != "" {
-		// 根据类型选择缓冲区
-		switch partType {
-		case "reasoning":
-			state.ReasoningBuffer.WriteString(text)
-		case "text":
-			state.ReplyBuffer.WriteString(text)
-		case "tool":
-			// 工具调用可能有text字段，也可能通过其他方式处理
-			state.ToolBuffer.WriteString(text)
-		}
-		state.LastUpdate = time.Now()
-
-		// 记录增量合并日志（仅调试）- 已禁用以减少日志量
-		// logger.Debug(fmt.Sprintf("合并增量内容 sessionID=%s messageID=%s type=%s deltaLength=%d",
-		// 	sessionID, messageID, partType, len(text)))
-	} else if partType == "tool" {
-		// 处理工具调用事件，提取工具信息
-		if name, ok := part["name"].(string); ok && name != "" {
-			toolText := fmt.Sprintf("[工具调用: %s", name)
-			if args, ok := part["arguments"].(string); ok && args != "" {
-				// 参数可能是JSON字符串，可以尝试美化
-				toolText += fmt.Sprintf(" 参数: %s", args)
-			}
-			toolText += "]"
-			state.ToolBuffer.WriteString(toolText)
-			state.LastUpdate = time.Now()
-			logger.Debug(fmt.Sprintf("合并工具调用内容 sessionID=%s messageID=%s toolName=%s",
-				sessionID, messageID, name))
-		}
-	}
-
-	// 检查是否为 step-finish
-	if partType == "step-finish" {
-		// 标记当前类型为完成
-		if state.CurrentType != "" {
-			state.CompletedTypes[state.CurrentType] = true
-			logger.Info(fmt.Sprintf("步骤完成 sessionID=%s messageID=%s type=%s",
-				sessionID, messageID, state.CurrentType))
-
-			// 触发该类型的完成钩子
-			ma.triggerTypeCompletionHooks(state, state.CurrentType)
-		} else {
-			logger.Warn(fmt.Sprintf("step-finish事件无当前类型 sessionID=%s messageID=%s",
-				sessionID, messageID))
-		}
-	}
-}
-
-// handleMessageUpdated 处理 message.updated 事件
-func (ma *MessageAggregator) handleMessageUpdated(eventMap map[string]interface{}, sessionID string) {
-	payload, _ := eventMap["payload"].(map[string]interface{})
-	props, _ := payload["properties"].(map[string]interface{})
-	info, _ := props["info"].(map[string]interface{})
-
-	messageID, _ := info["id"].(string)
-	finishReason, _ := info["finish"].(string)
-
-	if messageID == "" || finishReason == "" {
-		return
-	}
-
-	key := sessionID + "_" + messageID
-	ma.mu.Lock()
-	defer ma.mu.Unlock()
-
-	if state, exists := ma.messages[key]; exists {
-		logger.Info(fmt.Sprintf("消息完成 sessionID=%s messageID=%s finishReason=%s",
-			sessionID, messageID, finishReason))
-
-		// 触发完成钩子（处理所有类型的内容）
-		ma.triggerCompletionHooks(state)
-
-		// 清理完成的消息状态
-		delete(ma.messages, key)
-	}
-}
-
-// handleSessionStatus 处理 session.status 事件
-func (ma *MessageAggregator) handleSessionStatus(eventMap map[string]interface{}, sessionID string) {
-	payload, _ := eventMap["payload"].(map[string]interface{})
-	props, _ := payload["properties"].(map[string]interface{})
-	status, _ := props["status"].(map[string]interface{})
-
-	statusType, _ := status["type"].(string)
-	if statusType == "idle" {
-		logger.Info(fmt.Sprintf("会话进入空闲状态 sessionID=%s", sessionID))
-		// 可以清理该会话的所有消息状态
-		ma.cleanupSession(sessionID)
-	}
-}
-
-// handleSessionIdle 处理 session.idle 事件
-func (ma *MessageAggregator) handleSessionIdle(sessionID string) {
-	logger.Info(fmt.Sprintf("会话空闲事件 sessionID=%s", sessionID))
-	ma.cleanupSession(sessionID)
-}
-
-// cleanupSession 清理指定会话的所有消息状态
-func (ma *MessageAggregator) cleanupSession(sessionID string) {
-	ma.mu.Lock()
-	defer ma.mu.Unlock()
-
-	keysToDelete := make([]string, 0)
-	for key, state := range ma.messages {
-		if state.SessionID == sessionID {
-			keysToDelete = append(keysToDelete, key)
-
-			// 检查是否有未触发的类型内容，强制触发完成钩子
-			hasUnfinishedContent := false
-
-			// 检查每种类型是否有内容但钩子未触发
-			if state.ReasoningBuffer.Len() > 0 {
-				if triggered, exists := state.HookTriggered["reasoning"]; !exists || !triggered {
-					hasUnfinishedContent = true
-				}
-			}
-			if state.ReplyBuffer.Len() > 0 {
-				if triggered, exists := state.HookTriggered["text"]; !exists || !triggered {
-					hasUnfinishedContent = true
-				}
-			}
-			if state.ToolBuffer.Len() > 0 {
-				if triggered, exists := state.HookTriggered["tool"]; !exists || !triggered {
-					hasUnfinishedContent = true
-				}
-			}
-
-			if hasUnfinishedContent {
-				logger.Warn(fmt.Sprintf("强制完成未完成消息 sessionID=%s messageID=%s",
-					sessionID, state.MessageID))
-				ma.triggerCompletionHooks(state)
-			}
-		}
-	}
-
-	for _, key := range keysToDelete {
-		delete(ma.messages, key)
-	}
-
-	if len(keysToDelete) > 0 {
-		logger.Info(fmt.Sprintf("清理会话消息状态 sessionID=%s cleanedCount=%d",
-			sessionID, len(keysToDelete)))
-	}
-}
-
-// triggerTypeCompletionHooks 触发特定类型的完成钩子
-func (ma *MessageAggregator) triggerTypeCompletionHooks(state *MessageState, partType string) {
-	// 避免重复触发
-	if triggered, exists := state.HookTriggered[partType]; exists && triggered {
-		logger.Debug(fmt.Sprintf("钩子已触发过，跳过 sessionID=%s messageID=%s type=%s",
-			state.SessionID, state.MessageID, partType))
-		return
-	}
-
-	// 获取该类型的缓冲区内容
-	var completeText string
-	var textLength int
-
-	switch partType {
-	case "reasoning":
-		completeText = state.ReasoningBuffer.String()
-		textLength = len(completeText)
-	case "text":
-		completeText = state.ReplyBuffer.String()
-		textLength = len(completeText)
-	case "tool":
-		completeText = state.ToolBuffer.String()
-		textLength = len(completeText)
-	default:
-		logger.Warn(fmt.Sprintf("未知类型，跳过钩子触发 sessionID=%s messageID=%s type=%s",
-			state.SessionID, state.MessageID, partType))
-		return
-	}
-
-	duration := time.Since(state.StartTime)
-
-	// 记录完成事件
-	logger.Info(fmt.Sprintf("🔔 类型完成总结 sessionID=%s messageID=%s type=%s textLength=%d duration=%v",
-		state.SessionID, state.MessageID, partType, textLength, duration))
-
-	if textLength > 0 {
-		// 记录文本预览（前200字符）
-		preview := completeText
-		if len(preview) > 200 {
-			preview = preview[:200] + "..."
-		}
-		logger.Info(fmt.Sprintf("📝 类型文本预览: %s", preview))
-	} else {
-		logger.Info("📭 空文本完成事件")
-	}
-
-	// 转换事件类型为消息类型枚举
-	messageType := convertToMessageType(partType)
-
-	// 调用消息完成回调函数（如果设置）- 使用新的类型化接口
-	// 注意：这里调用现有的OnMessageCompleteFunc，传入特定类型的内容
-	if ma.OnMessageCompleteFunc != nil {
-		ma.OnMessageCompleteFunc(state.SessionID, state.MessageID, completeText, messageType, state.Metadata)
-	}
-
-	// 调用所有注册的钩子（保持向后兼容）
-	for _, hook := range ma.hooks {
-		hook.OnMessageComplete(state.SessionID, state.MessageID, completeText, partType, state.Metadata)
-	}
-
-	// 标记该类型的钩子已触发
-	state.HookTriggered[partType] = true
-	logger.Debug(fmt.Sprintf("✅ 类型钩子标记为已触发 sessionID=%s messageID=%s type=%s",
-		state.SessionID, state.MessageID, partType))
-}
-
-// triggerCompletionHooks 触发完成钩子（向后兼容，触发所有类型）
-func (ma *MessageAggregator) triggerCompletionHooks(state *MessageState) {
-	// 遍历所有支持的类型，触发各自的完成钩子
-	types := []string{"reasoning", "text", "tool"}
-	hasAnyContent := false
-
-	for _, partType := range types {
-		// 检查该类型是否有内容
-		var hasContent bool
-		switch partType {
-		case "reasoning":
-			hasContent = state.ReasoningBuffer.Len() > 0
-		case "text":
-			hasContent = state.ReplyBuffer.Len() > 0
-		case "tool":
-			hasContent = state.ToolBuffer.Len() > 0
-		}
-
-		if hasContent {
-			hasAnyContent = true
-			// 触发该类型的完成钩子（函数内部会检查是否已触发）
-			ma.triggerTypeCompletionHooks(state, partType)
-		}
-	}
-
-	// 如果没有内容，至少记录一个事件（保持向后兼容）
-	if !hasAnyContent {
-		logger.Info(fmt.Sprintf("📭 空消息完成事件 sessionID=%s messageID=%s",
-			state.SessionID, state.MessageID))
-	}
-}
-
 // EventDispatcher 事件分发器 - 单例模式
 type EventDispatcher struct {
-	mu                sync.RWMutex
-	baseURL           string
-	port              int
-	subscriptions     map[string]map[chan string]struct{} // sessionID -> set of channels
-	sessionUserCache  *SessionUserCache                   // sessionID -> userID 映射缓存（用于用户验证）
-	client            *http.Client
-	cancelFunc        context.CancelFunc
-	running           bool
-	messageAggregator *MessageAggregator // 消息聚合器
-}
-
-// EventData opencode事件数据结构 - 匹配实际事件格式
-type EventData struct {
-	Directory string                 `json:"directory,omitempty"`
-	Payload   map[string]interface{} `json:"payload"`
-}
-
-// PayloadData payload内部结构（辅助类型）
-type PayloadData struct {
-	Type       string                 `json:"type"`
-	Properties map[string]interface{} `json:"properties,omitempty"`
+	mu            sync.RWMutex
+	baseURL       string
+	port          int
+	subscriptions map[string]map[chan string]struct{} // sessionID -> set of channels
+	client        *http.Client
+	cancelFunc    context.CancelFunc
+	running       bool
 }
 
 // NewEventDispatcher 创建新的事件分发器
 func NewEventDispatcher(baseURL string, port int) *EventDispatcher {
 	return &EventDispatcher{
-		baseURL:           baseURL,
-		port:              port,
-		subscriptions:     make(map[string]map[chan string]struct{}),
-		sessionUserCache:  NewSessionUserCache(20 * time.Minute),
-		messageAggregator: NewMessageAggregator(),
+		baseURL:       baseURL,
+		port:          port,
+		subscriptions: make(map[string]map[chan string]struct{}),
 		client: &http.Client{
 			Timeout: 0, // 无超时限制，用于长连接
 		},
@@ -494,9 +91,6 @@ func (ed *EventDispatcher) Subscribe(sessionID, userID string) (<-chan string, e
 	ed.mu.Lock()
 	defer ed.mu.Unlock()
 
-	// 缓存会话-用户映射（用于未来需要用户验证时）
-	ed.sessionUserCache.Set(sessionID, userID)
-
 	// 创建缓冲通道
 	ch := make(chan string, 100)
 
@@ -538,18 +132,10 @@ func (ed *EventDispatcher) Unsubscribe(sessionID string, ch <-chan string) {
 		// 如果没有订阅者了，清理该会话的映射
 		if len(channels) == 0 {
 			delete(ed.subscriptions, sessionID)
-			ed.sessionUserCache.Delete(sessionID)
 		}
 	}
 }
 
-// RegisterSession 注册会话（前端调用SendPromptStream时调用）
-func (ed *EventDispatcher) RegisterSession(sessionID, userID string) {
-	ed.sessionUserCache.Set(sessionID, userID)
-	logger.Debug(fmt.Sprintf("会话已注册 sessionID=%s userID=%s",
-		sessionID, userID))
-}
-
 // buildSSEURL 构建SSE URL，避免端口重复
 func (ed *EventDispatcher) buildSSEURL() string {
 	// 检查baseURL是否已包含端口
@@ -674,10 +260,6 @@ func (ed *EventDispatcher) connectAndProcessSSE(ctx context.Context, url string)
 				// 分发事件
 				ed.dispatchEvent(data)
 
-				if eventCount%100 == 0 {
-					//logger.Debug(fmt.Sprintf("事件处理统计 totalEvents=%d activeSessions=%d",
-					//	eventCount, len(ed.subscriptions)))
-				}
 			}
 		}
 	}
@@ -688,32 +270,28 @@ func (ed *EventDispatcher) dispatchEvent(data string) {
 	// 解析事件数据获取sessionID
 	sessionID := extractSessionIDFromEvent(data)
 
-	// 处理事件聚合（无论是否有sessionID都处理）
-	if ed.messageAggregator != nil && sessionID != "" {
-		ed.messageAggregator.ProcessEvent(data, sessionID)
-	}
-
 	if sessionID == "" {
-		// 没有sessionID的事件（如全局心跳）分发给所有订阅者
-		//logger.Debug(fmt.Sprintf("广播全局事件 dataPreview=%s", safeSubstring(data, 0, 100)))
-		ed.broadcastToAll(data)
+		// 没有sessionID的事件（如全局心跳）丢弃，不广播给所有订阅者
+		// 确保按sessionID严格隔离，避免多用户消息交叉
 		return
 	}
 
-	// 只记录非增量文本事件的路由日志，减少日志量
-	shouldLog := true
+	// 只记录关键事件的路由日志，减少日志输出
 	var eventMap map[string]interface{}
 	if err := json.Unmarshal([]byte(data), &eventMap); err == nil {
-		eventType := getEventType(eventMap)
-		// message.part.updated 是最频繁的事件，跳过其路由日志
-		if eventType == "message.part.updated" {
-			shouldLog = false
+		// 提取事件类型
+		var eventType string
+		if payload, ok := eventMap["payload"].(map[string]interface{}); ok {
+			if t, ok := payload["type"].(string); ok {
+				eventType = t
+			}
+		}
+		// 只记录关键事件类型的路由信息
+		switch eventType {
+		case "session.status", "message.updated", "session.diff", "session.idle":
+			logger.Debug(fmt.Sprintf("路由事件到会话 sessionID=%s type=%s",
+				sessionID, eventType))
 		}
-	}
-
-	if shouldLog {
-		logger.Debug(fmt.Sprintf("路由事件到会话 sessionID=%s dataPreview=%s",
-			sessionID, safeSubstring(data, 0, 100)))
 	}
 
 	// 只分发给订阅该会话的通道
@@ -723,7 +301,6 @@ func (ed *EventDispatcher) dispatchEvent(data string) {
 
 	if !exists {
 		// 没有该会话的订阅者，忽略事件
-		//logger.Debug(fmt.Sprintf("忽略事件，无订阅者 sessionID=%s", sessionID))
 		return
 	}
 
@@ -742,52 +319,18 @@ func (ed *EventDispatcher) dispatchEvent(data string) {
 	ed.mu.RUnlock()
 }
 
-// broadcastToAll 广播事件给所有订阅者（用于全局事件如心跳）
-func (ed *EventDispatcher) broadcastToAll(data string) {
-	//logger.Debug(fmt.Sprintf("广播事件给所有订阅者 dataPreview=%s", safeSubstring(data, 0, 100)))
-	ed.mu.RLock()
-	defer ed.mu.RUnlock()
-
-	for sessionID, channels := range ed.subscriptions {
-		for ch := range channels {
-			select {
-			case ch <- data:
-				// 成功发送
-			default:
-				// 通道已满，丢弃事件
-				logger.Warn(fmt.Sprintf("事件通道已满，丢弃全局事件 sessionID=%s",
-					sessionID))
-			}
-		}
-	}
-}
-
 // extractSessionIDFromEvent 从事件数据中提取sessionID
 func extractSessionIDFromEvent(data string) string {
 	// 尝试解析为JSON
 	var eventMap map[string]interface{}
 	if err := json.Unmarshal([]byte(data), &eventMap); err != nil {
-		logger.ErrorC(fmt.Sprintf("无法解析事件JSON error=%s dataPreview=%s",
-			err.Error(), safeSubstring(data, 0, 200)))
+		logger.Error("无法解析事件JSON", "error", err.Error(), "dataPreview", safeSubstring(data, 0, 200))
 		return ""
 	}
 
-	// 添加调试日志，显示完整事件结构（仅调试时启用）
-	debugMode := true
-	if debugMode {
-		eventJSON, _ := json.MarshalIndent(eventMap, "", "  ")
-		logger.Debug(fmt.Sprintf("事件数据结构 eventStructure=%s",
-			string(eventJSON)))
-	}
-
 	// 递归查找sessionID字段
 	sessionID := findSessionIDRecursive(eventMap)
 
-	if sessionID == "" {
-		//logger.Debug(fmt.Sprintf("未找到sessionID字段 eventType=%s dataPreview=%s",
-		//	getEventType(eventMap), safeSubstring(data, 0, 100)))
-	}
-
 	return sessionID
 }
 
@@ -855,37 +398,6 @@ func findSessionIDRecursive(data interface{}) string {
 	return ""
 }
 
-// getEventType 获取事件类型
-func getEventType(eventMap map[string]interface{}) string {
-	if payload, ok := eventMap["payload"].(map[string]interface{}); ok {
-		if eventType, ok := payload["type"].(string); ok {
-			return eventType
-		}
-	}
-	return "unknown"
-}
-
-// convertToMessageType 将事件类型转换为消息类型枚举
-func convertToMessageType(eventType string) MessageType {
-	switch eventType {
-	case "reasoning":
-		return MessageTypeThinking
-	case "text":
-		return MessageTypeReply
-	case "tool":
-		return MessageTypeTool
-	default:
-		// 尝试识别其他类型
-		if strings.Contains(eventType, "reasoning") || strings.Contains(eventType, "thinking") {
-			return MessageTypeThinking
-		}
-		if strings.Contains(eventType, "tool") || strings.Contains(eventType, "function") {
-			return MessageTypeTool
-		}
-		return MessageTypeUnknown
-	}
-}
-
 // safeSubstring 安全的子字符串函数
 func safeSubstring(s string, start, length int) string {
 	if start < 0 {
@@ -901,40 +413,6 @@ func safeSubstring(s string, start, length int) string {
 	return s[start:end]
 }
 
-// getHookTriggerSource 获取钩子触发源（用于调试）
-func getHookTriggerSource(state *MessageState) string {
-	// 检查是否有任何类型的钩子已触发
-	for _, triggered := range state.HookTriggered {
-		if triggered {
-			return "completed"
-		}
-	}
-	return "unknown"
-}
-
-// RegisterHook 注册完成钩子
-func (ed *EventDispatcher) RegisterHook(hook CompletionHook) {
-	if ed.messageAggregator != nil {
-		ed.messageAggregator.RegisterHook(hook)
-	}
-}
-
-// SetOnMessageCompleteFunc 设置消息完成回调函数
-func (ed *EventDispatcher) SetOnMessageCompleteFunc(f func(sessionID string, messageID string, completeText string, messageType MessageType, metadata map[string]interface{})) {
-	if ed.messageAggregator != nil {
-		ed.messageAggregator.OnMessageCompleteFunc = f
-		logger.Info("✅ 消息完成回调函数已设置")
-	}
-}
-
-// SetOnEventProcessedFunc 设置事件处理回调函数
-func (ed *EventDispatcher) SetOnEventProcessedFunc(f func(sessionID string, eventType string, eventData string, eventMap map[string]interface{})) {
-	if ed.messageAggregator != nil {
-		ed.messageAggregator.OnEventProcessedFunc = f
-		logger.Info("✅ 事件处理回调函数已设置")
-	}
-}
-
 // GetInstance 获取单例实例（线程安全）
 var (
 	instance     *EventDispatcher
@@ -948,30 +426,3 @@ func GetEventDispatcher(baseURL string, port int) *EventDispatcher {
 	})
 	return instance
 }
-
-// DiagnosticHook 诊断钩子实现（用于调试和测试）
-type DiagnosticHook struct{}
-
-func (h *DiagnosticHook) OnMessageComplete(sessionID string, messageID string, completeText string, eventType string, metadata map[string]interface{}) {
-	logger.Info(fmt.Sprintf("🔍 诊断钩子触发: session=%s message=%s type=%s textLength=%d",
-		sessionID, messageID, eventType, len(completeText)))
-
-	if len(completeText) > 0 {
-		preview := completeText
-		if len(preview) > 150 {
-			preview = preview[:150] + "..."
-		}
-		logger.Info(fmt.Sprintf("📋 诊断钩子文本预览: %s", preview))
-	} else {
-		logger.Info("📭 诊断钩子: 空文本")
-	}
-
-	// 记录元数据（如果有）
-	if metadata != nil && len(metadata) > 0 {
-		logger.Info(fmt.Sprintf("📊 诊断钩子元数据: %+v", metadata))
-	}
-}
-
-// 使用示例:
-// dispatcher := GetEventDispatcher("http://localhost", 3000)
-// dispatcher.RegisterHook(&DiagnosticHook{})

internal/service/event/subscription_service.go

@@ -1,146 +0,0 @@
-package event
-
-import (
-	"fmt"
-	"sync"
-
-	"git.x2erp.com/qdy/go-base/ctx"
-	"git.x2erp.com/qdy/go-base/logger"
-	"git.x2erp.com/qdy/go-db/factory/mongodb"
-)
-
-// SubscriptionService 订阅服务，负责管理事件订阅并记录相关日志
-type SubscriptionService struct {
-	dispatcher   *EventDispatcher
-	mongoFactory *mongodb.MongoDBFactory
-}
-
-// NewSubscriptionService 创建新的订阅服务
-func NewSubscriptionService(dispatcher *EventDispatcher, mongoFactory *mongodb.MongoDBFactory) *SubscriptionService {
-	return &SubscriptionService{
-		dispatcher:   dispatcher,
-		mongoFactory: mongoFactory,
-	}
-}
-
-// SubscribeWithContext 使用上下文信息订阅会话事件
-func (s *SubscriptionService) SubscribeWithContext(sessionID string, reqCtx *ctx.RequestContext) (<-chan string, error) {
-	// 提取用户ID（优先使用reqCtx.UserID，如果为空则使用Username）
-	userID := reqCtx.UserID
-	if userID == "" {
-		userID = reqCtx.Username
-	}
-	if userID == "" {
-		userID = "unknown-user"
-	}
-
-	// 记录详细的调试日志
-	logger.Debug(fmt.Sprintf("🔔 订阅服务: 开始订阅 sessionID=%s, userID=%s, tenantID=%s, traceID=%s",
-		sessionID, userID, reqCtx.TenantID, reqCtx.TraceID))
-
-	// 调用事件分发器的Subscribe方法
-	ch, err := s.dispatcher.Subscribe(sessionID, userID)
-	if err != nil {
-		logger.Error(fmt.Sprintf("❌ 订阅服务: 订阅失败 sessionID=%s, error=%v", sessionID, err))
-		return nil, err
-	}
-
-	// 记录成功的订阅信息
-	logger.Info(fmt.Sprintf("✅ 订阅服务: 订阅成功 sessionID=%s, userID=%s, tenantID=%s",
-		sessionID, userID, reqCtx.TenantID))
-
-	// 这里可以扩展：将订阅信息保存到MongoDB
-	// 例如：s.saveSubscriptionToDB(sessionID, reqCtx)
-
-	// 对于调试，记录MongoDB工厂状态
-	if s.mongoFactory != nil {
-		logger.Debug(fmt.Sprintf("🔍 订阅服务: MongoDB工厂可用 sessionID=%s", sessionID))
-		// 可以测试连接或执行其他操作
-	} else {
-		logger.Debug(fmt.Sprintf("⚠️ 订阅服务: MongoDB工厂未配置 sessionID=%s", sessionID))
-	}
-
-	return ch, nil
-}
-
-// UnsubscribeWithContext 使用上下文信息取消订阅
-func (s *SubscriptionService) UnsubscribeWithContext(sessionID string, ch <-chan string, reqCtx *ctx.RequestContext) {
-	// 记录取消订阅日志
-	logger.Debug(fmt.Sprintf("🔔 订阅服务: 取消订阅 sessionID=%s, userID=%s, traceID=%s",
-		sessionID, reqCtx.UserID, reqCtx.TraceID))
-
-	s.dispatcher.Unsubscribe(sessionID, ch)
-
-	// 这里可以扩展：更新MongoDB中的订阅状态
-	// 例如：s.updateSubscriptionStatus(sessionID, "unsubscribed")
-
-	logger.Info(fmt.Sprintf("✅ 订阅服务: 已取消订阅 sessionID=%s", sessionID))
-}
-
-// RegisterSessionWithContext 使用上下文信息注册会话
-func (s *SubscriptionService) RegisterSessionWithContext(sessionID string, reqCtx *ctx.RequestContext) {
-	userID := reqCtx.UserID
-	if userID == "" {
-		userID = reqCtx.Username
-	}
-	if userID == "" {
-		userID = "unknown-user"
-	}
-
-	logger.Debug(fmt.Sprintf("🔔 订阅服务: 注册会话 sessionID=%s, userID=%s, tenantID=%s",
-		sessionID, userID, reqCtx.TenantID))
-
-	s.dispatcher.RegisterSession(sessionID, userID)
-
-	// 这里可以扩展：将会话注册信息保存到MongoDB
-	logger.Info(fmt.Sprintf("✅ 订阅服务: 会话已注册 sessionID=%s", sessionID))
-}
-
-// GetSubscriptionStats 获取订阅统计信息（用于调试和监控）
-func (s *SubscriptionService) GetSubscriptionStats() map[string]interface{} {
-	// 这里可以扩展：从MongoDB获取订阅统计
-	// 目前返回基本信息
-	stats := map[string]interface{}{
-		"service": "SubscriptionService",
-		"status":  "active",
-		"mongoDB": s.mongoFactory != nil,
-	}
-
-	logger.Debug(fmt.Sprintf("📊 订阅服务: 获取统计信息 stats=%+v", stats))
-	return stats
-}
-
-// saveSubscriptionToDB 将订阅信息保存到MongoDB（待扩展）
-func (s *SubscriptionService) saveSubscriptionToDB(sessionID string, reqCtx *ctx.RequestContext) {
-	// 待实现：将订阅信息保存到MongoDB
-	// 可以记录：sessionID, userID, tenantID, subscriptionTime, status等
-	logger.Debug(fmt.Sprintf("💾 订阅服务: 待实现 - 保存订阅信息到数据库 sessionID=%s", sessionID))
-}
-
-// updateSubscriptionStatus 更新MongoDB中的订阅状态（待扩展）
-func (s *SubscriptionService) updateSubscriptionStatus(sessionID string, status string) {
-	// 待实现：更新订阅状态
-	logger.Debug(fmt.Sprintf("💾 订阅服务: 待实现 - 更新订阅状态 sessionID=%s, status=%s", sessionID, status))
-}
-
-// 单例模式
-var (
-	subscriptionServiceInstance *SubscriptionService
-	subscriptionServiceOnce     sync.Once
-)
-
-// InitSubscriptionService 初始化订阅服务单例
-func InitSubscriptionService(dispatcher *EventDispatcher, mongoFactory *mongodb.MongoDBFactory) {
-	subscriptionServiceOnce.Do(func() {
-		subscriptionServiceInstance = NewSubscriptionService(dispatcher, mongoFactory)
-		logger.Info("✅ 订阅服务单例已初始化")
-	})
-}
-
-// GetSubscriptionService 获取订阅服务单例
-func GetSubscriptionService() *SubscriptionService {
-	if subscriptionServiceInstance == nil {
-		logger.Warn("⚠️ 订阅服务单例未初始化，返回nil")
-	}
-	return subscriptionServiceInstance
-}

main.go

@@ -87,52 +87,6 @@ func main() {
 		defer dispatcher.Stop()
 	}
 
-	// 注册诊断钩子（用于调试和日志输出）
-	dispatcher.RegisterHook(&event.DiagnosticHook{})
-	log.Printf("诊断钩子已注册")
-
-	// 设置消息完成回调函数（简单方案）
-	dispatcher.SetOnMessageCompleteFunc(func(sessionID string, messageID string, completeText string, messageType event.MessageType, metadata map[string]interface{}) {
-		textLength := len(completeText)
-		log.Printf("🔔 消息完成总结 sessionID=%s messageID=%s type=%s textLength=%d",
-			sessionID, messageID, messageType, textLength)
-
-		if textLength > 0 {
-			preview := completeText
-			if len(preview) > 200 {
-				preview = preview[:200] + "..."
-			}
-			log.Printf("📝 文本预览: %s", preview)
-		} else {
-			log.Printf("📭 空文本完成事件")
-		}
-
-		// 记录元数据（如果有）
-		if metadata != nil && len(metadata) > 0 {
-			log.Printf("📊 元数据: %+v", metadata)
-		}
-	})
-	log.Printf("消息完成回调函数已设置")
-
-	// 设置事件处理回调函数（记录所有事件）
-	dispatcher.SetOnEventProcessedFunc(func(sessionID string, eventType string, eventData string, eventMap map[string]interface{}) {
-		// 记录所有事件类型（不限于message.part.updated等）
-		dataPreview := eventData
-		if len(dataPreview) > 200 {
-			dataPreview = dataPreview[:200] + "..."
-		}
-		log.Printf("📡 事件处理: sessionID=%s eventType=%s dataPreview=%s",
-			sessionID, eventType, dataPreview)
-
-		// 函数内部可以决定是否要保存特定类型的事件
-		// 例如：只保存message.part.updated事件
-		if eventType == "message.part.updated" {
-			// 可以在这里提取更多信息并保存
-			log.Printf("💾 需要保存的事件类型: %s", eventType)
-		}
-	})
-	log.Printf("事件处理回调函数已设置")
-
 	// 初始化订阅服务单例（暂时注释，使用简单回调方案）
 	// event.InitSubscriptionService(dispatcher, mongoDBFactory)
 	// log.Printf("订阅服务单例已初始化")
@@ -185,6 +139,9 @@ func registerRoutes(ws *router.RouterService, webService *webx.WebService, confi
 	// 日志流路由（需要直接 HTTP 处理器）
 	routes.RegisterLogStreamRoutes(ws, webService, opencodeProcess, opencodePort)
 
+	// 会话消息路由
+	routes.RegisterSessionMessagesRoutes(ws, client)
+
 	// 菜单路由
 	routes.RegisterMenuRoutes(ws, mappingService)
 }

test/integration_test.go

@@ -68,12 +68,12 @@ func TestProcessFunctions(t *testing.T) {
 	t.Logf("✓ 获取可用端口成功: %d", port)
 }
 
-// TestClientInterface 测试客户端接口一致性
-func TestClientInterface(t *testing.T) {
-	// 验证 MockClient 实现了 OpenCodeClient 接口
-	var _ opencode.OpenCodeClient = opencode.NewMockClient(8080)
-	t.Log("✓ MockClient 正确实现了 OpenCodeClient 接口")
-}
+// // TestClientInterface 测试客户端接口一致性
+// func TestClientInterface(t *testing.T) {
+// 	// 验证 MockClient 实现了 OpenCodeClient 接口
+// 	var _ opencode.OpenCodeClient = opencode.NewMockClient(8080)
+// 	t.Log("✓ MockClient 正确实现了 OpenCodeClient 接口")
+// }
 
 // TestAPIEndpoints 测试 API 端点定义
 func TestAPIEndpoints(t *testing.T) {