Release v0.2.21101

ng-code.log

 Watch mode enabled. Watching for file changes...
 NOTE: Raw file sizes do not reflect development server per-request transformations.
   ➜  Local:   http://localhost:4200/
+❯ Changes detected. Rebuilding...
+✔ Changes detected. Rebuilding...
+Initial chunk files | Names |  Raw size
+main.js             | main  | 303.26 kB | 
+
+Application bundle generation complete. [3.544 seconds]
+
+Page reload sent to client(s).
+❯ Changes detected. Rebuilding...
+✔ Changes detected. Rebuilding...
+Initial chunk files | Names |  Raw size
+main.js             | main  | 303.23 kB | 
+
+Application bundle generation complete. [1.331 seconds]
+
+Page reload sent to client(s).
+❯ Changes detected. Rebuilding...
+✔ Changes detected. Rebuilding...
+Initial chunk files | Names |  Raw size
+main.js             | main  | 303.24 kB | 
+
+Application bundle generation complete. [1.370 seconds]
+
+Page reload sent to client(s).

src/app/components/conversation.component.ts

   private currentStreamSubscription: Subscription | null = null;
   private sessionEventSubscription: Subscription | null = null;
   private shouldScroll = false;
+  private isInThinking = false; // 是否正在思考过程中
+  private thinkingStartIndex = 0; // 思考内容的起始位置（在消息内容中的索引）
 
   constructor(
     private conversationService: ConversationService,
     );
 
     // 订阅流式更新
-    this.subscriptions.add(
-      this.conversationService.streamUpdate$.subscribe(update => {
-        console.log('🔍 [ConversationComponent] 收到流式更新:', update.type, 'data:', update.data?.substring(0, 50));
-        if (update.type === 'text') {
-          // 更新最后一条消息的内容
-          const lastMessage = this.messages[this.messages.length - 1];
-          if (lastMessage && lastMessage.role === 'assistant') {
-            console.log('🔍 [ConversationComponent] 更新AI消息内容，当前长度:', lastMessage.content.length);
-            lastMessage.content += update.data;
-            this.shouldScroll = true;
-          }
-        } else if (update.type === 'done') {
-          // 标记加载完成 - 找到最后一个AI消息
-          let lastAIMessage = null;
-          for (let i = this.messages.length - 1; i >= 0; i--) {
-            if (this.messages[i].role === 'assistant') {
-              lastAIMessage = this.messages[i];
+     this.subscriptions.add(
+       this.conversationService.streamUpdate$.subscribe(update => {
+         console.log('🔍 [ConversationComponent] 收到流式更新:', update.type, 'data:', update.data?.substring(0, 50));
+         
+         // 找到最后一个AI消息
+         let lastAIMessage = null;
+         for (let i = this.messages.length - 1; i >= 0; i--) {
+           if (this.messages[i].role === 'assistant') {
+             lastAIMessage = this.messages[i];
+             break;
+           }
+         }
+         
+         if (!lastAIMessage) return;
+         
+          switch (update.type) {
+            case 'thinking':
+              // 思考过程 - 只在开始时添加标签
+              if (!this.isInThinking) {
+                // 第一次思考，添加标签和换行
+                lastAIMessage.content += '\n[思考] ' + update.data;
+                this.isInThinking = true;
+                this.thinkingStartIndex = lastAIMessage.content.length - update.data.length - 4; // 减去"[思考] "的长度
+              } else {
+                // 继续思考，直接追加内容
+                lastAIMessage.content += update.data;
+              }
+              this.shouldScroll = true;
               break;
-            }
-          }
-          if (lastAIMessage) {
-            console.log('🔍 [ConversationComponent] 设置AI消息loading为false');
-            lastAIMessage.loading = false;
-          }
-          // 重置加载状态并聚焦输入框
-          this.isLoading = false;
-          this.focusInput();
-        } else if (update.type === 'error') {
-          // 处理错误情况 - 找到最后一个AI消息
-          let lastAIMessage = null;
-          for (let i = this.messages.length - 1; i >= 0; i--) {
-            if (this.messages[i].role === 'assistant') {
-              lastAIMessage = this.messages[i];
+              
+            case 'tool':
+              // 工具调用 - 添加标签（每个工具调用独立）
+              lastAIMessage.content += '\n[工具] ' + update.data;
+              this.shouldScroll = true;
+              break;
+              
+            case 'reply':
+              // 最终回复 - 直接追加，清除思考状态
+              this.isInThinking = false;
+              lastAIMessage.content += update.data;
+              this.shouldScroll = true;
+              break;
+              
+            case 'error':
+              // 错误信息 - 添加标签，清除思考状态
+              this.isInThinking = false;
+              console.log('🔍 [ConversationComponent] 错误，设置AI消息loading为false');
+              lastAIMessage.content += '\n\n[错误] ' + update.data;
+              lastAIMessage.loading = false;
+              this.isLoading = false;
+              this.focusInput();
+              break;
+              
+            case 'done':
+              // 完成标记 - 停止加载，清除思考状态
+              this.isInThinking = false;
+              console.log('🔍 [ConversationComponent] 设置AI消息loading为false');
+              lastAIMessage.loading = false;
+              this.isLoading = false;
+              this.focusInput();
               break;
-            }
-          }
-          if (lastAIMessage) {
-            console.log('🔍 [ConversationComponent] 错误，设置AI消息loading为false');
-            lastAIMessage.content += '\n\n[错误: ' + update.data + ']';
-            lastAIMessage.loading = false;
           }
-          // 重置加载状态并聚焦输入框
-          this.isLoading = false;
-          this.focusInput();
-        }
-      })
-    );
+       })
+     );
   }
 
   // 订阅后端推送的事件
     if (resetCount > 0) {
       console.log(`🔍 [ConversationComponent] 取消时重置${resetCount}个AI消息的loading状态`);
     }
+    // 重置思考状态
+    this.isInThinking = false;
+    this.thinkingStartIndex = 0;
   }
 
   loadMessages(sessionId: string) {
     console.log('🔍 [ConversationComponent] 创建AI消息，loading=true');
     this.messages.push(aiMessage);
     this.shouldScroll = true;
+    
+    // 重置思考状态
+    this.isInThinking = false;
+    this.thinkingStartIndex = 0;
 
     // 发送到服务
     this.isLoading = true;

src/app/models/conversation.model.ts

   output: number;
 }
 
+// 消息类型
+export type MessageType = 'thinking' | 'tool' | 'reply' | 'error';
+
 // 对话消息（前端显示用）
 export interface ChatMessage {
   id: string;
   role: 'user' | 'assistant' | 'system';
+  type?: MessageType; // 消息类型（思考、工具、回复、错误）
   content: string;
   timestamp: Date;
   sessionID: string;
 
 // 流式响应块
 export interface StreamChunk {
-  type: 'text' | 'error' | 'done';
+  type: MessageType | 'done';
   data: string;
 }

src/app/services/conversation.service.ts

       // 创建AbortController用于取消请求
       const abortController = new AbortController();
       
-      // 心跳超时定时器（5分钟）- 用于清理函数访问
-      let heartbeatTimeout: any = null;
+      // 发送超时定时器 - 控制发送消息到后端的超时（30秒）
+      let sendTimeout: any = null;
       
       // 使用fetch API以便流式读取SSE响应
       fetch('/api/prompt/stream', {
         const decoder = new TextDecoder();
         let buffer = '';
         
-        // 心跳超时定时器（5分钟）- 如果5分钟内未收到任何数据（包括心跳），则认为连接已断开
-        // 使用外层声明的heartbeatTimeout变量
-        const HEARTBEAT_TIMEOUT_MS = 5 * 60 * 1000; // 5分钟
+        // 发送请求超时（30秒）- 控制发送消息到后端的超时
+        const SEND_TIMEOUT_MS = 30 * 1000; // 30秒
+        sendTimeout = setTimeout(() => {
+          console.error('🔍 [ConversationService] 发送请求超时（30秒未收到初始响应）');
+          abortController.abort();
+          this.streamUpdateSubject.next({ type: 'error', data: '发送请求超时，请重试' });
+          observer.error(new Error('发送请求超时，请重试'));
+        }, SEND_TIMEOUT_MS);
         
-        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();
+        // 请求成功后清除发送超时
+        clearTimeout(sendTimeout);
         
         const readStream = () => {
            reader.read().then(({ done, value }) => {
-             if (done) {
-               console.log('🔍 [ConversationService] 流结束');
-               // 清除心跳超时定时器
-               if (heartbeatTimeout) {
-                 clearTimeout(heartbeatTimeout);
-                 heartbeatTimeout = null;
-               }
-                this.streamUpdateSubject.next({ type: 'done', data: '' });
-                observer.complete();
-               return;
+              if (done) {
+                console.log('🔍 [ConversationService] 流结束');
+                     // 清除发送超时定时器
+                     clearTimeout(sendTimeout);
+                 this.streamUpdateSubject.next({ type: 'done', data: '' });
+                 observer.complete();
+                return;
              }
             
             // 解码数据
               const event = buffer.substring(0, eventEnd);
               buffer = buffer.substring(eventEnd + 2); // 移除已处理的事件和两个换行符
               
-              // 重置心跳超时（收到任何事件，包括注释）
-              resetHeartbeatTimeout();
+              // 收到事件，继续处理
               
               // 检查是否为注释行（以冒号开头）
               if (event.startsWith(':')) {
                 console.log('🔍 [ConversationService] 收到SSE数据:', data.substring(0, 100));
                 
                 if (data === '[DONE]') {
-                   console.log('🔍 [ConversationService] 收到DONE标记');
-                   this.streamUpdateSubject.next({ type: 'done', data: '' });
-                   observer.complete();
-                  return;
+                    console.log('🔍 [ConversationService] 收到DONE标记');
+                     // 清除发送超时定时器
+                     clearTimeout(sendTimeout);
+                    this.streamUpdateSubject.next({ type: 'done', data: '' });
+                    observer.complete();
+                   return;
                 } else {
                   try {
                     // 解析JSON格式的SSE数据
                         // 处理消息部分更新事件（包含文本内容）
                         if (payload.type === 'message.part.updated' && payload.properties?.part) {
                           const part = payload.properties.part;
-                          // 支持 text 和 reasoning 类型
-                          if ((part.type === 'text' || part.type === 'reasoning') && part.text) {
-                            // 优先使用 delta 字段（增量），如果没有则使用完整文本
-                            const delta = payload.properties.delta || part.text;
-                            console.log('🔍 [ConversationService] 收到部分内容 (类型:', part.type, 'delta:', delta, '):', part.text.substring(0, 50));
-                            this.streamUpdateSubject.next({ type: 'text', data: delta });
-                          }
+                           // 支持 text、reasoning 和 tool 类型
+                           if ((part.type === 'text' || part.type === 'reasoning' || part.type === 'tool') && part.text) {
+                             // 优先使用 delta 字段（增量），如果没有则使用完整文本
+                             const delta = payload.properties.delta || part.text;
+                             
+                             // 映射事件类型到前端消息类型
+                             let frontendType: 'thinking' | 'tool' | 'reply' | 'error';
+                             if (part.type === 'reasoning') {
+                               frontendType = 'thinking';
+                             } else if (part.type === 'tool') {
+                               frontendType = 'tool';
+                             } else {
+                               frontendType = 'reply'; // text 类型
+                             }
+                             
+                             console.log('🔍 [ConversationService] 收到部分内容 (类型:', part.type, '=>', frontendType, 'delta:', delta, '):', part.text.substring(0, 50));
+                             this.streamUpdateSubject.next({ type: frontendType, data: delta });
+                           }
                         }
                          // 处理消息更新事件（包含完整消息信息）
                          else if (payload.type === 'message.updated' && payload.properties?.info) {
                          }
                   } catch (e) {
                     console.error('🔍 [ConversationService] 解析SSE JSON数据失败:', e, '原始数据:', data);
-                    // 如果不是JSON，按纯文本处理
-                    this.streamUpdateSubject.next({ type: 'text', data });
+                     // 如果不是JSON，按纯文本处理
+                     this.streamUpdateSubject.next({ type: 'reply', data });
                   }
                 }
               }
         }
       });
       
-      // 清理函数
-      return () => {
-        console.log('🔍 [ConversationService] 清理流式连接，取消请求');
-        // 清除心跳超时定时器
-        if (heartbeatTimeout) {
-          clearTimeout(heartbeatTimeout);
-          heartbeatTimeout = null;
-        }
-        // 取消fetch请求
-        abortController.abort();
-      };
+       // 清理函数
+       return () => {
+         console.log('🔍 [ConversationService] 清理流式连接，取消请求');
+         // 清除发送超时定时器
+         clearTimeout(sendTimeout);
+         // 取消fetch请求
+         abortController.abort();
+       };
     });
   }
 

src/app/services/menu.service.ts

       throw new Error(`参数 menu_item_id 不能为空`);
     }
     
-    console.log('发送请求到 /api/menu/sessions，参数 menu_item_id:', menuItemId);
-    return this.http.get<SessionIdsResponse>('/api/menu/sessions', {
-      params: { menu_item_id: menuItemId }
-    }).pipe(
+    console.log(`发送请求到 /api/menu/sessions/${menuItemId}`);
+    return this.http.get<SessionIdsResponse>(`/api/menu/sessions/${menuItemId}`).pipe(
       map(response => {
         console.log('getSessionIdsByMenuItem响应:', response);
-        if (response.success && response.data) {
-          console.log('返回会话ID列表:', response.data);
-          return response.data;
+        if (response.success) {
+          const data = response.data || [];
+          console.log('返回会话ID列表:', data);
+          return data;
         } else {
           console.error('获取会话ID列表失败:', response.message || response.error);
           throw new Error(response.message || response.error || '获取会话ID列表失败');