完善错误处理

Author: Eric0308

config.yaml

@@ -54,7 +54,7 @@ use_private_config: false
 # 选择使用的模块
 selected_module:
   ASR: DoubaoASR
-  TTS: DoubaoTTS
+  TTS: EdgeTTS
   LLM: OllamaLLM
   VLLLM: ChatGLMVLLM
 

src/core/connection.go

@@ -433,6 +433,15 @@ func (h *ConnectionHandler) handleChatMessage(ctx context.Context, text string)
 }
 
 func (h *ConnectionHandler) genResponseByLLM(ctx context.Context, messages []providers.Message, round int) error {
+	defer func() {
+		if r := recover(); r != nil {
+			h.logger.Error(fmt.Sprintf("genResponseByLLM发生panic: %v", r))
+			errorMsg := "抱歉，处理您的请求时发生了错误"
+			h.tts_last_text_index = 1 // 重置文本索引
+			h.SpeakAndPlay(errorMsg, 1, round)
+		}
+	}()
+
 	llmStartTime := time.Now()
 	h.logger.FormatInfo("开始生成LLM回复, round:%d 打印message", round)
 	for _, msg := range messages {
@@ -463,6 +472,14 @@ func (h *ConnectionHandler) genResponseByLLM(ctx context.Context, messages []pro
 		content := response.Content
 		toolCall := response.ToolCalls
 
+		if response.Error != "" {
+			h.logger.Error(fmt.Sprintf("LLM响应错误: %s", response.Error))
+			errorMsg := "抱歉，服务暂时不可用，请稍后再试"
+			h.tts_last_text_index = 1 // 重置文本索引
+			h.SpeakAndPlay(errorMsg, 1, round)
+			return fmt.Errorf("LLM响应错误: %s", response.Error)
+		}
+
 		if content != "" {
 			// 累加content_arguments
 			contentArguments += content
@@ -486,11 +503,23 @@ func (h *ConnectionHandler) genResponseByLLM(ctx context.Context, messages []pro
 		}
 
 		if content != "" {
+			if strings.Contains(content, "服务响应异常") {
+				h.logger.Error(fmt.Sprintf("检测到LLM服务异常: %s", content))
+				errorMsg := "抱歉，服务暂时不可用，请稍后再试"
+				h.tts_last_text_index = 1 // 重置文本索引
+				h.SpeakAndPlay(errorMsg, 1, round)
+				return fmt.Errorf("LLM服务异常")
+			}
+
 			if !toolCallFlag {
 				responseMessage = append(responseMessage, content)
 			}
 			// 处理分段
 			fullText := utils.JoinStrings(responseMessage)
+			if len(fullText) <= processedChars {
+				h.logger.Warn(fmt.Sprintf("文本处理异常: fullText长度=%d, processedChars=%d", len(fullText), processedChars))
+				continue
+			}
 			currentText := fullText[processedChars:]
 
 			// 按标点符号分割
@@ -562,12 +591,17 @@ func (h *ConnectionHandler) genResponseByLLM(ctx context.Context, messages []pro
 	}
 
 	// 处理剩余文本
-	remainingText := utils.JoinStrings(responseMessage)[processedChars:]
-	if remainingText != "" {
-		textIndex++
-		h.logger.Info(fmt.Sprintf("LLM回复分段[剩余文本]: %s, index: %d, round:%d", remainingText, textIndex, round))
-		h.tts_last_text_index = textIndex
-		h.SpeakAndPlay(remainingText, textIndex, round)
+	fullResponse := utils.JoinStrings(responseMessage)
+	if len(fullResponse) > processedChars {
+		remainingText := fullResponse[processedChars:]
+		if remainingText != "" {
+			textIndex++
+			h.logger.Info(fmt.Sprintf("LLM回复分段[剩余文本]: %s, index: %d, round:%d", remainingText, textIndex, round))
+			h.tts_last_text_index = textIndex
+			h.SpeakAndPlay(remainingText, textIndex, round)
+		}
+	} else {
+		h.logger.Info(fmt.Sprintf("无剩余文本需要处理: fullResponse长度=%d, processedChars=%d", len(fullResponse), processedChars))
 	}
 
 	// 分析回复并发送相应的情绪

src/core/mcp/client.go

@@ -66,6 +66,8 @@ func NewClient(config *Config, logger *utils.Logger) (*Client, error) {
 		}
 		c.stdioClient = stdioClient
 		c.useStdioClient = true
+	} else {
+		fmt.Println("Unsupported MCP client type, only stdio client is supported")
 	}
 
 	return c, nil

src/core/mcp/manager.go

@@ -120,22 +120,27 @@ func (m *Manager) preInitializeServers() error {
 		}
 
 		srvConfigMap, ok := srvConfig.(map[string]interface{})
+
 		if !ok {
+			m.logger.Warn(fmt.Sprintf("Invalid configuration format for server %s", name))
 			continue
 		}
 
 		// 创建并启动外部MCP客户端
 		clientConfig, err := convertConfig(srvConfigMap)
 		if err != nil {
+			m.logger.Error(fmt.Sprintf("Failed to convert config for server %s: %v", name, err))
 			continue
 		}
 
 		client, err := NewClient(clientConfig, m.logger)
 		if err != nil {
+			m.logger.Error(fmt.Sprintf("Failed to create MCP client for server %s: %v", name, err))
 			continue
 		}
 
 		if err := client.Start(context.Background()); err != nil {
+			m.logger.Error(fmt.Sprintf("Failed to start MCP client %s: %v", name, err))
 			continue
 		}
 		m.clients[name] = client

src/core/providers/asr/doubao/doubao.go

@@ -7,6 +7,7 @@ import (
 	"encoding/binary"
 	"encoding/json"
 	"fmt"
+	"net"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -474,37 +475,68 @@ func (p *Provider) AddAudioWithContext(ctx context.Context, data []byte) error {
 		p.isStreaming = true
 		// 开启一个协程来处理响应，读取最后的结果，读取完成后关闭协程
 		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					p.logger.Error(fmt.Sprintf("流式识别协程发生错误: %v", r))
+				}
+				p.connMutex.Lock()
+				p.isStreaming = false // 标记流式识别结束
+				if p.conn != nil {
+					p.closeConnection()
+				}
+				p.connMutex.Unlock()
+			}()
+
 			for {
-				_, response, err := p.conn.ReadMessage()
-				if err != nil {
-					p.connMutex.Lock()
-					p.err = fmt.Errorf("读取响应失败: %v", err)
+				// 检查连接状态，避免在连接关闭后继续读取
+				p.connMutex.Lock()
+				if !p.isStreaming || p.conn == nil {
 					p.connMutex.Unlock()
 					return
 				}
+				conn := p.conn
+				p.connMutex.Unlock()
+
+				conn.SetReadDeadline(time.Now().Add(30 * time.Second))
+
+				_, response, err := conn.ReadMessage()
+				if err != nil {
+					var shouldStop bool
+					var logMsg string
+
+					if websocket.IsCloseError(err, websocket.CloseGoingAway, websocket.CloseNormalClosure) {
+						logMsg = "WebSocket连接正常关闭"
+						shouldStop = false
+					} else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+						logMsg = "WebSocket读取超时，可能连接空闲"
+						shouldStop = true
+					} else {
+						logMsg = fmt.Sprintf("读取响应失败: %v", err)
+						shouldStop = true
+					}
+
+					p.logger.Info(logMsg)
+					if shouldStop {
+						p.setErrorAndStop(fmt.Errorf("%s", logMsg))
+					}
+				}
 
 				result, err := p.parseResponse(response)
 				if err != nil {
-					p.connMutex.Lock()
-					p.err = fmt.Errorf("解析响应失败: %v", err)
-					p.connMutex.Unlock()
+					p.setErrorAndStop(fmt.Errorf("解析响应失败: %v", err))
 					return
 				}
 
 				var respPayload responsePayload
 
 				payloadMsgData, err := json.Marshal(result["payload_msg"])
 				if err != nil {
-					p.connMutex.Lock()
-					p.err = fmt.Errorf("重新序列化响应payload_msg失败: %v", err)
-					p.connMutex.Unlock()
+					p.setErrorAndStop(fmt.Errorf("重新序列化响应payload_msg失败: %v", err))
 					return
 				}
 
 				if err := json.Unmarshal(payloadMsgData, &respPayload); err != nil {
-					p.connMutex.Lock()
-					p.err = fmt.Errorf("解析最终响应payload失败: %v. Raw: %s", err, string(payloadMsgData))
-					p.connMutex.Unlock()
+					p.setErrorAndStop(fmt.Errorf("解析最终响应payload失败: %v", err))
 					return
 				}
 
@@ -547,6 +579,13 @@ func (p *Provider) AddAudioWithContext(ctx context.Context, data []byte) error {
 	return nil
 }
 
+func (p *Provider) setErrorAndStop(err error) {
+	p.connMutex.Lock()
+	p.err = err
+	p.isStreaming = false
+	p.connMutex.Unlock()
+}
+
 func (p *Provider) closeConnection() {
 	defer func() {
 		if r := recover(); r != nil {

src/core/providers/llm/openai/openai.go

@@ -192,7 +192,6 @@ func (p *Provider) ResponseWithFunctions(ctx context.Context, sessionID string,
 						}
 					}
 					chunk.ToolCalls = toolCalls
-					fmt.Println("openai tool calls:", chunk.ToolCalls)
 				}
 
 				responseChan <- chunk