流式订阅测试通过-测试通过

src/app/app.component.html

@@ -21,6 +21,17 @@
           <mat-icon class="mr-2 text-gray-600 group-hover:text-red-600">logout</mat-icon>
           <span class="text-sm text-gray-700 group-hover:text-red-700">退出</span>
         </div>
+        
+        <!-- 事件流连接状态指示器 -->
+        <div class="flex items-center" matTooltip="{{ isEventStreamConnected ? '事件流已连接' : '事件流已断开' }}" matTooltipPosition="above">
+          <mat-icon class="mr-1 text-sm" [class.text-green-500]="isEventStreamConnected" [class.text-red-500]="!isEventStreamConnected">
+            {{ isEventStreamConnected ? 'wifi' : 'wifi_off' }}
+          </mat-icon>
+          <span class="text-xs text-gray-600">
+            {{ isEventStreamConnected ? '已连接' : '断开' }}
+          </span>
+        </div>
+        
         <span class="text-sm text-gray-700">
           {{ username }}
         </span>

src/app/app.component.ts

@@ -10,6 +10,7 @@ import { MatMenuModule } from '@angular/material/menu';
 import { MatTooltipModule } from '@angular/material/tooltip';
 import { DragDropModule } from '@angular/cdk/drag-drop';
 import { AuthService } from './services/auth.service';
+import { EventService } from './services/event.service';
 import { Subscription } from 'rxjs';
 import { ConfigService } from 'base-core';
 
@@ -29,11 +30,13 @@ export class AppComponent implements OnInit, OnDestroy {
   minRightWidth = 300;
   maxRightWidth = 600;
   private subscriptions: Subscription = new Subscription();
+  isEventStreamConnected = false;
 
   constructor(
     private router: Router,
     public authService: AuthService,
-    private config: ConfigService
+    private config: ConfigService,
+    private eventService: EventService
   ) {}
   
   ngOnInit() {
@@ -61,6 +64,14 @@ export class AppComponent implements OnInit, OnDestroy {
 
 
     // 订阅路由变化（暂无需要）
+    
+    // 订阅事件流连接状态
+    this.subscriptions.add(
+      this.eventService.connectionStatus$.subscribe(connected => {
+        this.isEventStreamConnected = connected;
+        console.log('事件流连接状态:', connected ? '已连接' : '已断开');
+      })
+    );
   }
   
   get isLoginPage(): boolean {

src/app/components/conversation.component.ts

@@ -69,7 +69,7 @@ import { Session } from '../models/session.model';
           color="primary" 
           class="send-button"
           (click)="sendMessage()"
-          [disabled]="!userInput.trim() || isLoading"
+          [disabled]="!userInput.trim()"
         >
           <mat-icon *ngIf="!isLoading">send</mat-icon>
           <mat-spinner *ngIf="isLoading" diameter="20"></mat-spinner>
@@ -205,6 +205,14 @@ export class ConversationComponent implements OnInit, OnDestroy, AfterViewChecke
     // 订阅活动会话变化
     this.subscriptions.add(
       this.sessionService.activeSession$.subscribe(session => {
+        console.log('🔍 [ConversationComponent] 活动会话变化:', session?.id);
+        
+        // 会话切换时取消当前正在进行的流式请求
+        if (this.activeSession && this.activeSession.id !== session?.id) {
+          console.log('🔍 [ConversationComponent] 会话切换，取消当前流式请求');
+          this.cancelCurrentStream();
+        }
+        
         this.activeSession = session;
         if (session) {
           this.loadMessages(session.id);
@@ -240,6 +248,19 @@ export class ConversationComponent implements OnInit, OnDestroy, AfterViewChecke
           if (lastMessage) {
             lastMessage.loading = false;
           }
+          // 重置加载状态并聚焦输入框
+          this.isLoading = false;
+          this.focusInput();
+        } else if (update.type === 'error') {
+          // 处理错误情况
+          const lastMessage = this.messages[this.messages.length - 1];
+          if (lastMessage && lastMessage.role === 'assistant') {
+            lastMessage.content += '\n\n[错误: ' + update.data + ']';
+            lastMessage.loading = false;
+          }
+          // 重置加载状态并聚焦输入框
+          this.isLoading = false;
+          this.focusInput();
         }
       })
     );
@@ -284,9 +305,9 @@ export class ConversationComponent implements OnInit, OnDestroy, AfterViewChecke
   }
 
   sendMessage() {
-    if (!this.userInput.trim() || !this.activeSession || this.isLoading) return;
+    if (!this.userInput.trim() || !this.activeSession) return;
 
-    // 取消之前可能仍在进行的流式请求
+    // 取消之前可能仍在进行的流式请求（允许打断之前的回答）
     this.cancelCurrentStream();
 
     const userMessage: ChatMessage = {
@@ -320,7 +341,8 @@ export class ConversationComponent implements OnInit, OnDestroy, AfterViewChecke
       this.userInput
     ).subscribe({
       next: () => {
-        this.isLoading = false;
+        // 流式连接已建立，但传输仍在继续
+        // isLoading状态将在流式完成时在streamUpdate$中重置
       },
       error: (error) => {
         console.error('发送消息失败:', error);
@@ -328,6 +350,7 @@ export class ConversationComponent implements OnInit, OnDestroy, AfterViewChecke
         aiMessage.loading = false;
         this.isLoading = false;
         this.currentStreamSubscription = null;
+        this.focusInput();
       },
       complete: () => {
         // 流式完成已在streamUpdate$中处理
@@ -339,9 +362,7 @@ export class ConversationComponent implements OnInit, OnDestroy, AfterViewChecke
     this.userInput = '';
     
     // 聚焦输入框
-    setTimeout(() => {
-      this.messageInput.nativeElement.focus();
-    }, 100);
+    this.focusInput();
   }
 
   formatContent(content: string): string {
@@ -357,4 +378,13 @@ export class ConversationComponent implements OnInit, OnDestroy, AfterViewChecke
       console.error('滚动失败:', err);
     }
   }
+
+  private focusInput() {
+    // 延迟聚焦以确保DOM已更新
+    setTimeout(() => {
+      if (this.messageInput?.nativeElement) {
+        this.messageInput.nativeElement.focus();
+      }
+    }, 100);
+  }
 }

src/app/models/event.model.ts

@@ -0,0 +1,115 @@
+// 全局事件模型
+export interface GlobalEvent {
+  directory?: string;
+  payload: EventPayload;
+}
+
+// 事件负载
+export interface EventPayload {
+  type: string;
+  properties?: Record<string, any>;
+}
+
+// 会话更新事件
+export interface SessionUpdatedEvent {
+  type: 'session.updated';
+  properties: {
+    info: SessionInfo;
+  };
+}
+
+// 会话信息
+export interface SessionInfo {
+  id: string;
+  slug: string;
+  version: string;
+  projectID: string;
+  directory: string;
+  title: string;
+  time: {
+    created: number;
+    updated: number;
+  };
+  summary?: {
+    additions: number;
+    deletions: number;
+    files: number;
+  };
+}
+
+// 会话差异事件
+export interface SessionDiffEvent {
+  type: 'session.diff';
+  properties: {
+    sessionID: string;
+    diff: any[];
+  };
+}
+
+// 服务器心跳事件
+export interface ServerHeartbeatEvent {
+  type: 'server.heartbeat';
+  properties: Record<string, never>;
+}
+
+// 消息更新事件
+export interface MessageUpdatedEvent {
+  type: 'message.updated';
+  properties: {
+    info: MessageInfo;
+  };
+}
+
+// 消息部分更新事件
+export interface MessagePartUpdatedEvent {
+  type: 'message.part.updated';
+  properties: {
+    part: MessagePart;
+    delta?: string;
+  };
+}
+
+// 消息信息
+export interface MessageInfo {
+  id: string;
+  role: string;
+  content?: string;
+  parts?: MessagePart[];
+}
+
+// 消息部分
+export interface MessagePart {
+  type: 'text' | 'reasoning' | string;
+  text?: string;
+}
+
+// 会话状态事件
+export interface SessionStatusEvent {
+  type: 'session.status';
+  properties: {
+    status: {
+      type: string;
+      [key: string]: any;
+    };
+  };
+}
+
+// 服务器连接事件
+export interface ServerConnectedEvent {
+  type: 'server.connected';
+  properties: Record<string, any>;
+}
+
+// 事件类型映射
+export type EventType = 
+  | 'session.updated'
+  | 'session.diff'
+  | 'server.heartbeat'
+  | 'message.updated'
+  | 'message.part.updated'
+  | 'session.status'
+  | 'server.connected'
+  | string;
+
+// 事件处理器类型
+export type EventHandler<T = any> = (event: T) => void;

src/app/services/conversation.service.ts

@@ -50,6 +50,9 @@ export class ConversationService {
       // 创建AbortController用于取消请求
       const abortController = new AbortController();
       
+      // 心跳超时定时器（5分钟）- 用于清理函数访问
+      let heartbeatTimeout: any = null;
+      
       // 使用fetch API以便流式读取SSE响应
       fetch('/api/prompt/stream', {
         method: 'POST',
@@ -79,15 +82,41 @@ export class ConversationService {
         const decoder = new TextDecoder();
         let buffer = '';
         
+        // 心跳超时定时器（5分钟）- 如果5分钟内未收到任何数据（包括心跳），则认为连接已断开
+        // 使用外层声明的heartbeatTimeout变量
+        const HEARTBEAT_TIMEOUT_MS = 5 * 60 * 1000; // 5分钟
+        
+        const resetHeartbeatTimeout = () => {
+          // 清除现有定时器
+          if (heartbeatTimeout) {
+            clearTimeout(heartbeatTimeout);
+          }
+          // 设置新的超时定时器
+          heartbeatTimeout = setTimeout(() => {
+            console.error('🔍 [ConversationService] 心跳超时（5分钟未收到数据），主动断开连接');
+            abortController.abort();
+            this.streamUpdateSubject.next({ type: 'error', data: '连接超时，请重试' });
+            observer.error(new Error('连接超时，请重试'));
+          }, HEARTBEAT_TIMEOUT_MS);
+        };
+        
+        // 初始设置心跳超时定时器
+        resetHeartbeatTimeout();
+        
         const readStream = () => {
-          reader.read().then(({ done, value }) => {
-            if (done) {
-              console.log('🔍 [ConversationService] 流结束');
-              this.streamUpdateSubject.next({ type: 'done', data: '' });
-              observer.next();
-              observer.complete();
-              return;
-            }
+           reader.read().then(({ done, value }) => {
+             if (done) {
+               console.log('🔍 [ConversationService] 流结束');
+               // 清除心跳超时定时器
+               if (heartbeatTimeout) {
+                 clearTimeout(heartbeatTimeout);
+                 heartbeatTimeout = null;
+               }
+               this.streamUpdateSubject.next({ type: 'done', data: '' });
+               observer.next();
+               observer.complete();
+               return;
+             }
             
             // 解码数据
             buffer += decoder.decode(value, { stream: true });
@@ -98,6 +127,17 @@ export class ConversationService {
               const event = buffer.substring(0, eventEnd);
               buffer = buffer.substring(eventEnd + 2); // 移除已处理的事件和两个换行符
               
+              // 重置心跳超时（收到任何事件，包括注释）
+              resetHeartbeatTimeout();
+              
+              // 检查是否为注释行（以冒号开头）
+              if (event.startsWith(':')) {
+                console.log('🔍 [ConversationService] 收到SSE注释:', event.substring(0, 50));
+                // 心跳注释，继续处理下一个事件
+                eventEnd = buffer.indexOf('\n\n');
+                continue;
+              }
+              
               // 查找数据行
               const dataLineStart = event.indexOf('data: ');
               if (dataLineStart !== -1) {
@@ -148,9 +188,12 @@ export class ConversationService {
                         else if (payload.type === 'server.connected') {
                           console.log('🔍 [ConversationService] 服务器连接成功');
                         }
-                        else if (payload.type === 'session.status') {
-                          console.log('🔍 [ConversationService] 会话状态更新:', payload.properties?.status?.type);
-                        }
+                         else if (payload.type === 'session.status') {
+                           console.log('🔍 [ConversationService] 会话状态更新:', payload.properties?.status?.type);
+                         }
+                         else if (payload.type === 'session.idle') {
+                           console.log('🔍 [ConversationService] AI进入空闲状态，保持连接可继续交互');
+                         }
                   } catch (e) {
                     console.error('🔍 [ConversationService] 解析SSE JSON数据失败:', e, '原始数据:', data);
                     // 如果不是JSON，按纯文本处理
@@ -195,6 +238,11 @@ export class ConversationService {
       // 清理函数
       return () => {
         console.log('🔍 [ConversationService] 清理流式连接，取消请求');
+        // 清除心跳超时定时器
+        if (heartbeatTimeout) {
+          clearTimeout(heartbeatTimeout);
+          heartbeatTimeout = null;
+        }
         // 取消fetch请求
         abortController.abort();
       };

src/app/services/event.service.ts

@@ -0,0 +1,344 @@
+import { Injectable, OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
+import { AuthService } from './auth.service';
+import { GlobalEvent, EventPayload, EventType, SessionUpdatedEvent, SessionDiffEvent, ServerHeartbeatEvent, MessageUpdatedEvent, MessagePartUpdatedEvent, SessionStatusEvent, ServerConnectedEvent } from '../models/event.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class EventService implements OnDestroy {
+  private eventSource: EventSource | null = null;
+  private isConnected = false;
+  
+  private subscriptions: Subscription = new Subscription();
+  private reconnectTimeout: any = null;
+  private heartbeatTimeout: any = null;
+  private reconnectAttempts = 0;
+  private maxReconnectAttempts = 5;
+  private reconnectDelay = 3000; // 3秒
+  private heartbeatTimeoutDuration = 5 * 60 * 1000; // 5分钟心跳超时（根据用户要求）
+  
+  // 事件主题，用于广播所有事件
+  private allEventsSubject = new Subject<GlobalEvent>();
+  allEvents$ = this.allEventsSubject.asObservable();
+  
+  // 特定事件类型主题
+  private sessionUpdatedSubject = new Subject<SessionUpdatedEvent>();
+  sessionUpdated$ = this.sessionUpdatedSubject.asObservable();
+  
+  private sessionDiffSubject = new Subject<SessionDiffEvent>();
+  sessionDiff$ = this.sessionDiffSubject.asObservable();
+  
+  private messageUpdatedSubject = new Subject<MessageUpdatedEvent>();
+  messageUpdated$ = this.messageUpdatedSubject.asObservable();
+  
+  private messagePartUpdatedSubject = new Subject<MessagePartUpdatedEvent>();
+  messagePartUpdated$ = this.messagePartUpdatedSubject.asObservable();
+  
+  // 连接状态主题
+  private connectionStatusSubject = new BehaviorSubject<boolean>(false);
+  connectionStatus$ = this.connectionStatusSubject.asObservable();
+  
+  constructor(private authService: AuthService) {
+    this.initializeAuthSubscription();
+  }
+  
+  // 初始化认证状态订阅
+  private initializeAuthSubscription() {
+    this.subscriptions.add(
+      this.authService.authState$.subscribe(authState => {
+        console.log('EventService: 认证状态变化', authState.isAuthenticated);
+        
+        if (authState.isAuthenticated) {
+          // 用户已登录，连接事件流
+          this.connectToEventStream();
+        } else {
+          // 用户登出，断开事件流
+          this.disconnect();
+        }
+      })
+    );
+  }
+  
+  // 连接到事件流
+  connectToEventStream(sessionId?: string) {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    
+    // 检查是否已登录
+    if (!this.authService.isAuthenticated()) {
+      console.warn('未登录状态，不连接事件流');
+      return;
+    }
+    
+    // 获取认证token
+    const token = this.authService.getToken();
+    if (!token) {
+      console.error('无法获取认证token');
+      return;
+    }
+    
+    // 构建带认证参数的URL - 使用日志流端点，因为它发送全局事件
+    let url = `/api/logs/stream?token=${encodeURIComponent(token)}`;
+    if (sessionId) {
+      url += `&sessionId=${sessionId}`;
+    }
+    
+    console.log('EventService: 连接事件流URL:', url);
+    this.eventSource = new EventSource(url);
+    
+    this.eventSource.onopen = () => {
+      console.log('EventService: 事件流连接已建立');
+      this.isConnected = true;
+      this.connectionStatusSubject.next(true);
+      this.reconnectAttempts = 0; // 重置重连计数
+      
+      // 启动心跳超时定时器（5分钟）
+      this.resetHeartbeatTimeout();
+      
+      // 发送连接成功事件
+      this.allEventsSubject.next({
+        payload: {
+          type: 'connection.established',
+          properties: { timestamp: new Date().toISOString() }
+        }
+      });
+    };
+    
+    this.eventSource.onmessage = (event) => {
+      const eventData = event.data;
+      console.log('EventService: 收到原始事件数据:', eventData.substring(0, 200));
+      
+      // 处理SSE注释格式的心跳（保持向后兼容）
+      if (eventData === ': heartbeat' || eventData.startsWith(': ')) {
+        // 重置心跳超时定时器（表示连接活跃）
+        this.resetHeartbeatTimeout();
+        
+        // 发送内部心跳事件，供其他服务订阅
+        this.allEventsSubject.next({
+          payload: {
+            type: 'server.heartbeat.comment',
+            properties: { 
+              timestamp: new Date().toISOString(),
+              rawData: eventData 
+            }
+          }
+        });
+        return;
+      }
+      
+      try {
+        // 解析JSON事件
+        const globalEvent: GlobalEvent = JSON.parse(eventData);
+        this.handleGlobalEvent(globalEvent);
+      } catch (error) {
+        // 如果不是JSON，可能是纯文本日志
+        console.log('EventService: 非JSON事件，可能是纯文本日志:', eventData.substring(0, 100));
+        
+        // 如果是纯文本日志，可以转发给日志服务或忽略
+        // 这里只处理JSON事件
+      }
+    };
+    
+    this.eventSource.onerror = (error) => {
+      console.error('EventService: 事件流连接错误:', error);
+      this.isConnected = false;
+      this.connectionStatusSubject.next(false);
+      
+      // 清除心跳超时定时器
+      this.clearHeartbeatTimeout();
+      
+      // 检查是否仍然登录
+      if (this.authService.isAuthenticated()) {
+        console.log('EventService: 连接断开，正在重连...');
+        this.scheduleReconnect(sessionId);
+      } else {
+        console.log('EventService: 连接断开（用户未登录）');
+      }
+    };
+  }
+  
+  // 处理全局事件
+  private handleGlobalEvent(event: GlobalEvent) {
+    console.log('EventService: 处理全局事件，类型:', event.payload.type);
+    
+    // 任何有效事件都重置心跳超时（表明连接活跃）
+    this.resetHeartbeatTimeout();
+    
+    // 广播所有事件
+    this.allEventsSubject.next(event);
+    
+    // 根据事件类型分发到特定主题
+    const payload = event.payload;
+    
+    switch (payload.type) {
+      case 'session.updated': {
+        const sessionEvent = payload as SessionUpdatedEvent;
+        this.sessionUpdatedSubject.next(sessionEvent);
+        console.log('EventService: 分发 session.updated 事件', sessionEvent.properties.info?.title);
+        break;
+      }
+        
+      case 'session.diff':
+        this.sessionDiffSubject.next(payload as SessionDiffEvent);
+        console.log('EventService: 分发 session.diff 事件');
+        break;
+        
+      case 'server.heartbeat':
+        this.allEventsSubject.next(event); // 已经广播过
+        this.resetHeartbeatTimeout();
+        break;
+        
+      case 'message.updated':
+        this.messageUpdatedSubject.next(payload as MessageUpdatedEvent);
+        console.log('EventService: 分发 message.updated 事件');
+        break;
+        
+      case 'message.part.updated':
+        this.messagePartUpdatedSubject.next(payload as MessagePartUpdatedEvent);
+        console.log('EventService: 分发 message.part.updated 事件');
+        break;
+        
+      case 'session.status':
+        this.allEventsSubject.next(event);
+        console.log('EventService: 分发 session.status 事件');
+        break;
+        
+      case 'server.connected':
+        this.allEventsSubject.next(event);
+        console.log('EventService: 分发 server.connected 事件');
+        break;
+        
+      default:
+        console.log('EventService: 未知事件类型:', payload.type);
+        // 未知事件类型仍然通过 allEvents$ 广播
+    }
+  }
+  
+  // 重置心跳超时定时器
+  private resetHeartbeatTimeout() {
+    // 清除现有超时
+    if (this.heartbeatTimeout) {
+      clearTimeout(this.heartbeatTimeout);
+    }
+    
+    // 设置新的超时定时器（5分钟）
+    this.heartbeatTimeout = setTimeout(() => {
+      console.warn('EventService: 心跳超时（5分钟未收到心跳），尝试重连');
+      this.isConnected = false;
+      this.connectionStatusSubject.next(false);
+      
+      // 清除现有的重连定时器（如果有）
+      if (this.reconnectTimeout) {
+        clearTimeout(this.reconnectTimeout);
+      }
+      
+      // 立即尝试重连
+      if (this.authService.isAuthenticated()) {
+        const activeSession = this.getCurrentSessionId(); // 需要获取当前会话ID
+        this.connectToEventStream(activeSession);
+      }
+    }, this.heartbeatTimeoutDuration);
+    
+    console.log('EventService: 心跳超时定时器已重置（5分钟）');
+  }
+  
+  // 清除心跳超时定时器
+  private clearHeartbeatTimeout() {
+    if (this.heartbeatTimeout) {
+      clearTimeout(this.heartbeatTimeout);
+      this.heartbeatTimeout = null;
+    }
+  }
+  
+  // 获取当前会话ID（用于重连时保持会话过滤）
+  private getCurrentSessionId(): string | undefined {
+    // 这里可以从URL或状态管理获取当前会话ID
+    // 暂时返回undefined，表示不进行会话过滤
+    return undefined;
+  }
+  
+  // 安排重连
+  private scheduleReconnect(sessionId?: string) {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+    }
+    
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error('EventService: 达到最大重连次数，停止重连');
+      return;
+    }
+    
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * Math.pow(1.5, this.reconnectAttempts - 1); // 指数退避
+    
+    console.log(`EventService: ${this.reconnectAttempts}/${this.maxReconnectAttempts} 重连，等待 ${delay}ms`);
+    
+    this.reconnectTimeout = setTimeout(() => {
+      if (this.authService.isAuthenticated()) {
+        this.connectToEventStream(sessionId);
+      }
+    }, delay);
+  }
+  
+  // 断开事件流连接
+  disconnect() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+      this.isConnected = false;
+      this.connectionStatusSubject.next(false);
+      
+      console.log('EventService: 已断开事件流连接');
+    }
+    
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    
+    // 清除心跳超时定时器
+    this.clearHeartbeatTimeout();
+    
+    this.reconnectAttempts = 0;
+  }
+  
+  // 订阅特定事件类型
+  subscribeToEvent<T = any>(eventType: EventType): Observable<T> {
+    return new Observable<T>(observer => {
+      const subscription = this.allEvents$.subscribe(event => {
+        if (event.payload.type === eventType) {
+          observer.next(event.payload as T);
+        }
+      });
+      
+      return () => subscription.unsubscribe();
+    });
+  }
+  
+  // 手动发送事件（用于测试）
+  emitTestEvent(event: GlobalEvent) {
+    this.handleGlobalEvent(event);
+  }
+  
+  // 检查连接状态
+  isStreamConnected(): boolean {
+    return this.isConnected;
+  }
+  
+  // 切换会话过滤
+  switchSession(sessionId?: string) {
+    if (this.authService.isAuthenticated()) {
+      this.connectToEventStream(sessionId);
+    } else {
+      console.warn('未登录状态，无法切换会话过滤');
+    }
+  }
+  
+  ngOnDestroy() {
+    this.subscriptions.unsubscribe();
+    this.disconnect();
+  }
+}

src/app/services/session.service.ts

@@ -1,14 +1,16 @@
-import { Injectable } from '@angular/core';
+import { Injectable, OnDestroy } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
-import { BehaviorSubject, Observable, of } from 'rxjs';
+import { BehaviorSubject, Observable, of, Subscription } from 'rxjs';
 import { map, tap } from 'rxjs/operators';
 import { Session, SessionCreateRequest, SessionCreateApiResponse, SessionListResponse } from '../models/session.model';
 import { AuthService } from './auth.service';
+import { EventService } from './event.service';
+import { SessionUpdatedEvent } from '../models/event.model';
 
 @Injectable({
   providedIn: 'root'
 })
-export class SessionService {
+export class SessionService implements OnDestroy {
   private activeSession = new BehaviorSubject<Session | null>(null);
   activeSession$ = this.activeSession.asObservable();
   
@@ -16,10 +18,15 @@ export class SessionService {
   private sessionsSubject = new BehaviorSubject<Session[]>([]);
   sessions$ = this.sessionsSubject.asObservable();
 
+  private eventSubscription: Subscription = new Subscription();
+
   constructor(
     private http: HttpClient,
-    private authService: AuthService
-  ) {}
+    private authService: AuthService,
+    private eventService: EventService
+  ) {
+    this.setupEventSubscriptions();
+  }
 
   // 获取会话列表（需要认证）
   getSessions(): Observable<Session[]> {
@@ -129,4 +136,53 @@ export class SessionService {
       })
     );
   }
+
+  // 设置事件订阅
+  private setupEventSubscriptions() {
+    // 订阅会话更新事件
+    this.eventSubscription.add(
+      this.eventService.sessionUpdated$.subscribe(event => {
+        this.handleSessionUpdated(event);
+      })
+    );
+  }
+
+  // 处理会话更新事件
+  private handleSessionUpdated(event: SessionUpdatedEvent) {
+    const sessionInfo = event.properties.info;
+    console.log('SessionService: 处理会话更新事件', sessionInfo.id, sessionInfo.title);
+    
+    // 查找现有会话
+    const existingSessionIndex = this.sessions.findIndex(s => s.id === sessionInfo.id);
+    
+    if (existingSessionIndex !== -1) {
+      // 更新现有会话
+      const updatedSession: Session = {
+        ...this.sessions[existingSessionIndex],
+        title: sessionInfo.title,
+        // 保留其他字段如port、baseURL等
+      };
+      this.sessions[existingSessionIndex] = updatedSession;
+      console.log('SessionService: 更新现有会话', updatedSession.title);
+    } else {
+      // 添加新会话到列表开头
+      const newSession: Session = {
+        id: sessionInfo.id,
+        title: sessionInfo.title,
+        // port和baseURL可能在后端创建会话时提供，这里使用默认值
+        // 实际使用中，可以从事件或后续API调用中获取
+        port: 8020, // 默认端口，可根据需要调整
+        baseURL: `http://localhost:8020`, // 默认baseURL
+      };
+      this.sessions.unshift(newSession);
+      console.log('SessionService: 添加新会话', newSession.title);
+    }
+    
+    // 通知订阅者
+    this.sessionsSubject.next([...this.sessions]);
+  }
+
+  ngOnDestroy() {
+    this.eventSubscription.unsubscribe();
+  }
 }