Update config.yaml

config.yaml

@@ -10,7 +10,7 @@
 # ============================================
 
 # 前端显示的版本号（可选，不填则显示默认版本）
-version: "v1.6.4"
+version: "v1.6.5"
 # 服务器配置
 server:
   host: 0.0.0.0 # 监听地址，0.0.0.0 表示监听所有网络接口

internal/agent/agent.go

@@ -1905,9 +1905,26 @@ func (a *Agent) ExecuteMCPToolForConversation(ctx context.Context, conversationI
 		a.currentConversationID = prev
 		a.mu.Unlock()
 	}()
+	ctx = withAgentConversationID(ctx, conversationID)
 	return a.executeToolViaMCP(ctx, toolName, args)
 }
 
+// CancelMCPToolExecutionWithNote 取消一次进行中的 MCP 工具（先内部后外部），与监控页「终止工具」一致；note 非空时合并进返回给模型的文本。
+func (a *Agent) CancelMCPToolExecutionWithNote(executionID, note string) bool {
+	executionID = strings.TrimSpace(executionID)
+	note = strings.TrimSpace(note)
+	if executionID == "" {
+		return false
+	}
+	if a.mcpServer != nil && a.mcpServer.CancelToolExecutionWithNote(executionID, note) {
+		return true
+	}
+	if a.externalMCPMgr != nil && a.externalMCPMgr.CancelToolExecutionWithNote(executionID, note) {
+		return true
+	}
+	return false
+}
+
 // extractQuotedToolName 尝试从错误信息中提取被引用的工具名称
 func extractQuotedToolName(errMsg string) string {
 	start := strings.Index(errMsg, "\"")

internal/handler/agent.go

@@ -19,6 +19,7 @@ import (
 	"cyberstrike-ai/internal/agent"
 	"cyberstrike-ai/internal/config"
 	"cyberstrike-ai/internal/database"
+	"cyberstrike-ai/internal/mcp"
 	"cyberstrike-ai/internal/mcp/builtin"
 	"cyberstrike-ai/internal/multiagent"
 
@@ -458,6 +459,57 @@ func appendAttachmentsToMessage(msg string, attachments []ChatAttachment, savedP
 	return b.String()
 }
 
+// appendAssistantMessageNotice 在助手消息末尾追加提示，避免覆盖已生成内容。
+// 若消息为空则直接写入提示；若已包含相同提示则保持不变。
+func (h *AgentHandler) appendAssistantMessageNotice(messageID, notice string) error {
+	trimmedNotice := strings.TrimSpace(notice)
+	if strings.TrimSpace(messageID) == "" || trimmedNotice == "" {
+		return nil
+	}
+	_, err := h.db.Exec(
+		`UPDATE messages
+		 SET content = CASE
+			WHEN content IS NULL OR TRIM(content) = '' THEN ?
+			WHEN INSTR(content, ?) > 0 THEN content
+			ELSE content || '\n\n' || ?
+		 END,
+		     updated_at = ?
+		 WHERE id = ?`,
+		trimmedNotice,
+		trimmedNotice,
+		trimmedNotice,
+		time.Now(),
+		messageID,
+	)
+	return err
+}
+
+// mergeAssistantMessagePartialOnCancel 将取消前已生成的部分回复尽量合并进消息：
+// - content 为空或仅占位（处理中...）时，直接替换为 partial；
+// - 已有正文时，仅在尚未包含 partial 时追加，避免丢失与重复。
+func (h *AgentHandler) mergeAssistantMessagePartialOnCancel(messageID, partial string) error {
+	trimmedPartial := strings.TrimSpace(partial)
+	if strings.TrimSpace(messageID) == "" || trimmedPartial == "" {
+		return nil
+	}
+	_, err := h.db.Exec(
+		`UPDATE messages
+		 SET content = CASE
+			WHEN content IS NULL OR TRIM(content) = '' OR TRIM(content) = '处理中...' THEN ?
+			WHEN INSTR(content, ?) > 0 THEN content
+			ELSE content || '\n\n' || ?
+		 END,
+		     updated_at = ?
+		 WHERE id = ?`,
+		trimmedPartial,
+		trimmedPartial,
+		trimmedPartial,
+		time.Now(),
+		messageID,
+	)
+	return err
+}
+
 // ChatResponse 聊天响应
 type ChatResponse struct {
 	Response        string    `json:"response"`
@@ -725,7 +777,9 @@ func (h *AgentHandler) ProcessMessageForRobot(ctx context.Context, conversationI
 			"deep",
 		)
 		if errMA != nil {
-			h.persistEinoAgentTraceForResume(conversationID, resultMA)
+			if shouldPersistEinoAgentTraceAfterRunError(ctx) {
+				h.persistEinoAgentTraceForResume(conversationID, resultMA)
+			}
 			errMsg := "执行失败: " + errMA.Error()
 			if assistantMessageID != "" {
 				_, _ = h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", errMsg, time.Now(), assistantMessageID)
@@ -1493,6 +1547,8 @@ func (h *AgentHandler) AgentLoopStream(c *gin.Context) {
 	taskCtx, timeoutCancel := context.WithTimeout(baseCtx, 600*time.Minute)
 	defer timeoutCancel()
 	defer cancelWithCause(nil)
+	taskCtx = mcp.WithMCPConversationID(taskCtx, conversationID)
+	taskCtx = mcp.WithToolRunRegistry(taskCtx, h.tasks)
 	progressCallback := h.createProgressCallback(taskCtx, cancelWithCause, conversationID, assistantMessageID, sendEvent)
 	taskCtx = h.injectReactHITLInterceptor(taskCtx, cancelWithCause, conversationID, assistantMessageID, sendEvent)
 
@@ -1568,11 +1624,12 @@ func (h *AgentHandler) AgentLoopStream(c *gin.Context) {
 			h.tasks.UpdateTaskStatus(conversationID, taskStatus)
 
 			if assistantMessageID != "" {
-				if _, updateErr := h.db.Exec(
-					"UPDATE messages SET content = ?, updated_at = ? WHERE id = ?",
-					cancelMsg,
-					time.Now(), assistantMessageID,
-				); updateErr != nil {
+				if result != nil {
+					if updateErr := h.mergeAssistantMessagePartialOnCancel(assistantMessageID, result.Response); updateErr != nil {
+						h.logger.Warn("合并取消前的部分回复失败", zap.Error(updateErr))
+					}
+				}
+				if updateErr := h.appendAssistantMessageNotice(assistantMessageID, cancelMsg); updateErr != nil {
 					h.logger.Warn("更新取消后的助手消息失败", zap.Error(updateErr))
 				}
 				h.db.AddProcessDetail(assistantMessageID, conversationID, "cancelled", cancelMsg, nil)
@@ -1726,22 +1783,39 @@ func (h *AgentHandler) CancelAgentLoop(c *gin.Context) {
 		return
 	}
 
-	if req.ContinueAfter && strings.TrimSpace(req.Reason) == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "continueAfter 为 true 时必须提供非空的 reason（中断说明）"})
+	if req.ContinueAfter {
+		if h.tasks.GetTask(req.ConversationID) == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "未找到正在执行的任务"})
+			return
+		}
+		execID := h.tasks.ActiveMCPExecutionID(req.ConversationID)
+		if execID == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "当前没有正在执行的 MCP 工具（例如模型尚在推理、尚未发起工具调用）。请等待工具开始执行后再试，或使用「彻底停止」结束整轮任务。"})
+			return
+		}
+		note := strings.TrimSpace(req.Reason)
+		if !h.agent.CancelMCPToolExecutionWithNote(execID, note) {
+			c.JSON(http.StatusNotFound, gin.H{"error": "未找到进行中的工具执行或该调用已结束"})
+			return
+		}
+		h.logger.Info("对话页仅终止当前 MCP 工具",
+			zap.String("conversationId", req.ConversationID),
+			zap.String("executionId", execID),
+			zap.Bool("hasNote", note != ""),
+		)
+		c.JSON(http.StatusOK, gin.H{
+			"status":            "tool_abort_requested",
+			"conversationId":    req.ConversationID,
+			"executionId":       execID,
+			"message":           "已请求终止当前工具调用；工具返回后本轮推理将继续（与 MCP 监控页终止一致）。",
+			"continueAfter":     true,
+			"interruptWithNote": note != "",
+		})
 		return
 	}
 
 	var cause error = ErrTaskCancelled
 	msg := "已提交取消请求，任务将在当前步骤完成后停止。"
-	if req.ContinueAfter {
-		if !h.tasks.SetInterruptContinueReason(req.ConversationID, req.Reason) {
-			c.JSON(http.StatusNotFound, gin.H{"error": "未找到正在执行的任务，无法提交中断说明"})
-			return
-		}
-		cause = ErrUserInterruptContinue
-		msg = "已提交中断说明，当前步骤结束后将写入对话并继续迭代。"
-	}
-
 	ok, err := h.tasks.CancelTask(req.ConversationID, cause)
 	if err != nil {
 		h.logger.Error("取消任务失败", zap.Error(err))
@@ -1756,10 +1830,10 @@ func (h *AgentHandler) CancelAgentLoop(c *gin.Context) {
 
 	c.JSON(http.StatusOK, gin.H{
 		"status":           "cancelling",
-		"conversationId":   req.ConversationID,
+		"conversationId": req.ConversationID,
 		"message":          msg,
-		"continueAfter":    req.ContinueAfter,
-		"interruptWithNote": req.ContinueAfter,
+		"continueAfter":    false,
+		"interruptWithNote": false,
 	})
 }
 
@@ -2537,6 +2611,8 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 
 			// 创建进度回调函数：写 DB + 镜像到 task-events，支持刷新后继续流式展示。
 			progressCallback = h.createProgressCallback(taskCtx, cancelWithCause, conversationID, assistantMessageID, sendEvent)
+			taskCtx = mcp.WithMCPConversationID(taskCtx, conversationID)
+			taskCtx = mcp.WithToolRunRegistry(taskCtx, h.tasks)
 
 			// 使用队列配置的角色工具列表（如果为空，表示使用所有工具）
 			useBatchMulti := false
@@ -2576,7 +2652,7 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 			}
 
 			if runErr != nil {
-				if useRunResult {
+				if useRunResult && shouldPersistEinoAgentTraceAfterRunError(baseCtx) {
 					h.persistEinoAgentTraceForResume(conversationID, resultMA)
 				}
 				// 检查是否是取消错误
@@ -2614,11 +2690,7 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 				}
 				// 更新助手消息内容
 				if assistantMessageID != "" {
-					if _, updateErr := h.db.Exec(
-						"UPDATE messages SET content = ?, updated_at = ? WHERE id = ?",
-						cancelMsg,
-						time.Now(), assistantMessageID,
-					); updateErr != nil {
+					if updateErr := h.appendAssistantMessageNotice(assistantMessageID, cancelMsg); updateErr != nil {
 						h.logger.Warn("更新取消后的助手消息失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(updateErr))
 					}
 					// 保存取消详情到数据库
@@ -2632,16 +2704,6 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 						h.logger.Warn("保存取消消息失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(errMsg))
 					}
 				}
-				// 保存代理轨迹（如果存在）
-				if result != nil && (result.LastAgentTraceInput != "" || result.LastAgentTraceOutput != "") {
-					if err := h.db.SaveAgentTrace(conversationID, result.LastAgentTraceInput, result.LastAgentTraceOutput); err != nil {
-						h.logger.Warn("保存取消任务的代理轨迹失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(err))
-					}
-				} else if useRunResult && resultMA != nil && (resultMA.LastAgentTraceInput != "" || resultMA.LastAgentTraceOutput != "") {
-					if err := h.db.SaveAgentTrace(conversationID, resultMA.LastAgentTraceInput, resultMA.LastAgentTraceOutput); err != nil {
-						h.logger.Warn("保存取消任务的代理轨迹失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(err))
-					}
-				}
 				h.batchTaskManager.UpdateTaskStatusWithConversationID(queueID, task.ID, "cancelled", cancelMsg, "", conversationID)
 			} else {
 				h.logger.Error("批量任务执行失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(runErr))

internal/handler/eino_single_agent.go

@@ -10,6 +10,7 @@ import (
 	"sync"
 	"time"
 
+	"cyberstrike-ai/internal/mcp"
 	"cyberstrike-ai/internal/multiagent"
 
 	"github.com/gin-gonic/gin"
@@ -45,7 +46,7 @@ func (h *AgentHandler) EinoSingleAgentLoopStream(c *gin.Context) {
 	sendEvent := func(eventType, message string, data interface{}) {
 		if eventType == "error" && baseCtx != nil {
 			cause := context.Cause(baseCtx)
-			if errors.Is(cause, ErrTaskCancelled) || errors.Is(cause, ErrUserInterruptContinue) {
+			if errors.Is(cause, ErrTaskCancelled) {
 				return
 			}
 		}
@@ -117,13 +118,19 @@ func (h *AgentHandler) EinoSingleAgentLoopStream(c *gin.Context) {
 	}
 
 	var cancelWithCause context.CancelCauseFunc
-	firstRun := true
 	curFinalMessage := prep.FinalMessage
 	curHistory := prep.History
 	roleTools := prep.RoleTools
 
 	taskStatus := "completed"
-	defer h.tasks.FinishTask(conversationID, taskStatus)
+	// 仅在成功 StartTask 后再 FinishTask。若 StartTask 因 ErrTaskAlreadyRunning 失败仍 defer FinishTask，
+	// 会误删其他连接上正在运行的同会话任务，导致「第一次拦截、第二次却放行」。
+	taskOwned := false
+	defer func() {
+		if taskOwned {
+			h.tasks.FinishTask(conversationID, taskStatus)
+		}
+	}()
 
 	sendEvent("progress", "正在启动 Eino ADK 单代理（ChatModelAgent）...", map[string]interface{}{
 		"conversationId": conversationID,
@@ -144,111 +151,69 @@ func (h *AgentHandler) EinoSingleAgentLoopStream(c *gin.Context) {
 	var result *multiagent.RunResult
 	var runErr error
 
-	for {
-		baseCtx, cancelWithCause = context.WithCancelCause(context.Background())
-		taskCtx, timeoutCancel := context.WithTimeout(baseCtx, 600*time.Minute)
+	baseCtx, cancelWithCause = context.WithCancelCause(context.Background())
+	taskCtx, timeoutCancel := context.WithTimeout(baseCtx, 600*time.Minute)
 
-		if firstRun {
-			if _, err := h.tasks.StartTask(conversationID, req.Message, cancelWithCause); err != nil {
-				var errorMsg string
-				if errors.Is(err, ErrTaskAlreadyRunning) {
-					errorMsg = "⚠️ 当前会话已有任务正在执行中，请等待当前任务完成或点击「停止任务」后再尝试。"
-					sendEvent("error", errorMsg, map[string]interface{}{
-						"conversationId": conversationID,
-						"errorType":      "task_already_running",
-					})
-				} else {
-					errorMsg = "❌ 无法启动任务: " + err.Error()
-					sendEvent("error", errorMsg, nil)
-				}
-				if assistantMessageID != "" {
-					_, _ = h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", errorMsg, time.Now(), assistantMessageID)
-				}
-				sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
-				timeoutCancel()
-				return
-			}
-			firstRun = false
+	if _, err := h.tasks.StartTask(conversationID, req.Message, cancelWithCause); err != nil {
+		var errorMsg string
+		if errors.Is(err, ErrTaskAlreadyRunning) {
+			errorMsg = "⚠️ 当前会话已有任务正在执行中，请等待当前任务完成或点击「停止任务」后再尝试。"
+			sendEvent("error", errorMsg, map[string]interface{}{
+				"conversationId": conversationID,
+				"errorType":      "task_already_running",
+			})
 		} else {
-			if err := h.tasks.ResetTaskCancelForContinue(conversationID, cancelWithCause); err != nil {
-				h.logger.Error("续跑任务时重置 cancel 失败", zap.Error(err))
-				taskStatus = "failed"
-				sendEvent("error", err.Error(), nil)
-				sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
-				timeoutCancel()
-				return
-			}
+			errorMsg = "❌ 无法启动任务: " + err.Error()
+			sendEvent("error", errorMsg, nil)
 		}
-
-		progressCallback := h.createProgressCallback(taskCtx, cancelWithCause, conversationID, assistantMessageID, sendEvent)
-		taskCtx = multiagent.WithHITLToolInterceptor(taskCtx, func(ctx context.Context, toolName, arguments string) (string, error) {
-			return h.interceptHITLForEinoTool(ctx, cancelWithCause, conversationID, assistantMessageID, sendEvent, toolName, arguments)
-		})
-
-		result, runErr = multiagent.RunEinoSingleChatModelAgent(
-			taskCtx,
-			h.config,
-			&h.config.MultiAgent,
-			h.agent,
-			h.logger,
-			conversationID,
-			curFinalMessage,
-			curHistory,
-			roleTools,
-			progressCallback,
-		)
+		if assistantMessageID != "" {
+			_, _ = h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", errorMsg, time.Now(), assistantMessageID)
+		}
+		sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
 		timeoutCancel()
+		return
+	}
+	taskOwned = true
 
-		if runErr == nil {
-			break
-		}
+	progressCallback := h.createProgressCallback(taskCtx, cancelWithCause, conversationID, assistantMessageID, sendEvent)
+	taskCtx = mcp.WithMCPConversationID(taskCtx, conversationID)
+	taskCtx = mcp.WithToolRunRegistry(taskCtx, h.tasks)
+	taskCtx = multiagent.WithHITLToolInterceptor(taskCtx, func(ctx context.Context, toolName, arguments string) (string, error) {
+		return h.interceptHITLForEinoTool(ctx, cancelWithCause, conversationID, assistantMessageID, sendEvent, toolName, arguments)
+	})
 
-		h.persistEinoAgentTraceForResume(conversationID, result)
+	result, runErr = multiagent.RunEinoSingleChatModelAgent(
+		taskCtx,
+		h.config,
+		&h.config.MultiAgent,
+		h.agent,
+		h.logger,
+		conversationID,
+		curFinalMessage,
+		curHistory,
+		roleTools,
+		progressCallback,
+	)
+	timeoutCancel()
+
+	if runErr != nil {
 		cause := context.Cause(baseCtx)
-		if errors.Is(cause, ErrUserInterruptContinue) {
-			reason := h.tasks.TakeInterruptContinueReason(conversationID)
-			prepNext, perr := h.prepareSessionAfterUserInterrupt(conversationID, assistantMessageID, reason, roleTools)
-			if perr != nil {
-				h.logger.Error("准备中断后续跑失败", zap.Error(perr))
-				taskStatus = "failed"
-				h.tasks.UpdateTaskStatus(conversationID, taskStatus)
-				errMsg := "中断后续跑失败: " + perr.Error()
-				if assistantMessageID != "" {
-					_, _ = h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", errMsg, time.Now(), assistantMessageID)
-				}
-				sendEvent("error", errMsg, map[string]interface{}{
-					"conversationId": conversationID,
-					"messageId":      assistantMessageID,
-				})
-				sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
-				return
-			}
-			assistantMessageID = prepNext.AssistantMessageID
-			curFinalMessage = prepNext.FinalMessage
-			curHistory = prepNext.History
-			if prepNext.UserMessageID != "" {
-				sendEvent("message_saved", "", map[string]interface{}{
-					"conversationId": conversationID,
-					"userMessageId":  prepNext.UserMessageID,
-				})
-			}
-			sendEvent("user_interrupt_continue", reason, map[string]interface{}{
-				"conversationId": conversationID,
-				"reason":         reason,
-				"messageId":      assistantMessageID,
-			})
-			sendEvent("progress", "已接收中断说明，继续迭代...", map[string]interface{}{
-				"conversationId": conversationID,
-			})
-			continue
+		if shouldPersistEinoAgentTraceAfterRunError(baseCtx) {
+			h.persistEinoAgentTraceForResume(conversationID, result)
 		}
-
 		if errors.Is(cause, ErrTaskCancelled) {
 			taskStatus = "cancelled"
 			h.tasks.UpdateTaskStatus(conversationID, taskStatus)
 			cancelMsg := "任务已被用户取消，后续操作已停止。"
 			if assistantMessageID != "" {
-				_, _ = h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", cancelMsg, time.Now(), assistantMessageID)
+				if result != nil {
+					if err := h.mergeAssistantMessagePartialOnCancel(assistantMessageID, result.Response); err != nil {
+						h.logger.Warn("合并取消前的部分回复失败", zap.Error(err))
+					}
+				}
+				if err := h.appendAssistantMessageNotice(assistantMessageID, cancelMsg); err != nil {
+					h.logger.Warn("更新取消后的助手消息失败", zap.Error(err))
+				}
 				_ = h.db.AddProcessDetail(assistantMessageID, conversationID, "cancelled", cancelMsg, nil)
 			}
 			sendEvent("cancelled", cancelMsg, map[string]interface{}{
@@ -374,7 +339,9 @@ func (h *AgentHandler) EinoSingleAgentLoop(c *gin.Context) {
 		progressCallback,
 	)
 	if runErr != nil {
-		h.persistEinoAgentTraceForResume(prep.ConversationID, result)
+		if shouldPersistEinoAgentTraceAfterRunError(baseCtx) {
+			h.persistEinoAgentTraceForResume(prep.ConversationID, result)
+		}
 		c.JSON(http.StatusInternalServerError, gin.H{"error": runErr.Error()})
 		return
 	}

internal/handler/multi_agent.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"cyberstrike-ai/internal/config"
+	"cyberstrike-ai/internal/mcp"
 	"cyberstrike-ai/internal/multiagent"
 
 	"github.com/gin-gonic/gin"
@@ -62,7 +63,7 @@ func (h *AgentHandler) MultiAgentLoopStream(c *gin.Context) {
 		// 为避免 UI 看到“取消错误 + cancelled 文案”两条回复，这里直接丢弃取消对应的 error。
 		if eventType == "error" && baseCtx != nil {
 			cause := context.Cause(baseCtx)
-			if errors.Is(cause, ErrTaskCancelled) || errors.Is(cause, ErrUserInterruptContinue) {
+			if errors.Is(cause, ErrTaskCancelled) {
 				return
 			}
 		}
@@ -134,14 +135,19 @@ func (h *AgentHandler) MultiAgentLoopStream(c *gin.Context) {
 	}
 
 	var cancelWithCause context.CancelCauseFunc
-	firstRun := true
 	curFinalMessage := prep.FinalMessage
 	curHistory := prep.History
 	roleTools := prep.RoleTools
 	orch := strings.TrimSpace(req.Orchestration)
 
 	taskStatus := "completed"
-	defer h.tasks.FinishTask(conversationID, taskStatus)
+	// 仅在成功 StartTask 后再 FinishTask；避免「任务已存在」分支 return 时误删正在运行的同会话任务。
+	taskOwned := false
+	defer func() {
+		if taskOwned {
+			h.tasks.FinishTask(conversationID, taskStatus)
+		}
+	}()
 
 	sendEvent("progress", "正在启动 Eino 多代理...", map[string]interface{}{
 		"conversationId": conversationID,
@@ -154,113 +160,71 @@ func (h *AgentHandler) MultiAgentLoopStream(c *gin.Context) {
 	var result *multiagent.RunResult
 	var runErr error
 
-	for {
-		baseCtx, cancelWithCause = context.WithCancelCause(context.Background())
-		taskCtx, timeoutCancel := context.WithTimeout(baseCtx, 600*time.Minute)
+	baseCtx, cancelWithCause = context.WithCancelCause(context.Background())
+	taskCtx, timeoutCancel := context.WithTimeout(baseCtx, 600*time.Minute)
 
-		if firstRun {
-			if _, err := h.tasks.StartTask(conversationID, req.Message, cancelWithCause); err != nil {
-				var errorMsg string
-				if errors.Is(err, ErrTaskAlreadyRunning) {
-					errorMsg = "⚠️ 当前会话已有任务正在执行中，请等待当前任务完成或点击「停止任务」后再尝试。"
-					sendEvent("error", errorMsg, map[string]interface{}{
-						"conversationId": conversationID,
-						"errorType":      "task_already_running",
-					})
-				} else {
-					errorMsg = "❌ 无法启动任务: " + err.Error()
-					sendEvent("error", errorMsg, nil)
-				}
-				if assistantMessageID != "" {
-					_, _ = h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", errorMsg, time.Now(), assistantMessageID)
-				}
-				sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
-				timeoutCancel()
-				return
-			}
-			firstRun = false
+	if _, err := h.tasks.StartTask(conversationID, req.Message, cancelWithCause); err != nil {
+		var errorMsg string
+		if errors.Is(err, ErrTaskAlreadyRunning) {
+			errorMsg = "⚠️ 当前会话已有任务正在执行中，请等待当前任务完成或点击「停止任务」后再尝试。"
+			sendEvent("error", errorMsg, map[string]interface{}{
+				"conversationId": conversationID,
+				"errorType":      "task_already_running",
+			})
 		} else {
-			if err := h.tasks.ResetTaskCancelForContinue(conversationID, cancelWithCause); err != nil {
-				h.logger.Error("续跑任务时重置 cancel 失败", zap.Error(err))
-				taskStatus = "failed"
-				sendEvent("error", err.Error(), nil)
-				sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
-				timeoutCancel()
-				return
-			}
+			errorMsg = "❌ 无法启动任务: " + err.Error()
+			sendEvent("error", errorMsg, nil)
 		}
-
-		progressCallback := h.createProgressCallback(taskCtx, cancelWithCause, conversationID, assistantMessageID, sendEvent)
-		taskCtx = multiagent.WithHITLToolInterceptor(taskCtx, func(ctx context.Context, toolName, arguments string) (string, error) {
-			return h.interceptHITLForEinoTool(ctx, cancelWithCause, conversationID, assistantMessageID, sendEvent, toolName, arguments)
-		})
-
-		result, runErr = multiagent.RunDeepAgent(
-			taskCtx,
-			h.config,
-			&h.config.MultiAgent,
-			h.agent,
-			h.logger,
-			conversationID,
-			curFinalMessage,
-			curHistory,
-			roleTools,
-			progressCallback,
-			h.agentsMarkdownDir,
-			orch,
-		)
+		if assistantMessageID != "" {
+			_, _ = h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", errorMsg, time.Now(), assistantMessageID)
+		}
+		sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
 		timeoutCancel()
+		return
+	}
+	taskOwned = true
 
-		if runErr == nil {
-			break
-		}
+	progressCallback := h.createProgressCallback(taskCtx, cancelWithCause, conversationID, assistantMessageID, sendEvent)
+	taskCtx = mcp.WithMCPConversationID(taskCtx, conversationID)
+	taskCtx = mcp.WithToolRunRegistry(taskCtx, h.tasks)
+	taskCtx = multiagent.WithHITLToolInterceptor(taskCtx, func(ctx context.Context, toolName, arguments string) (string, error) {
+		return h.interceptHITLForEinoTool(ctx, cancelWithCause, conversationID, assistantMessageID, sendEvent, toolName, arguments)
+	})
 
-		h.persistEinoAgentTraceForResume(conversationID, result)
+	result, runErr = multiagent.RunDeepAgent(
+		taskCtx,
+		h.config,
+		&h.config.MultiAgent,
+		h.agent,
+		h.logger,
+		conversationID,
+		curFinalMessage,
+		curHistory,
+		roleTools,
+		progressCallback,
+		h.agentsMarkdownDir,
+		orch,
+	)
+	timeoutCancel()
+
+	if runErr != nil {
 		cause := context.Cause(baseCtx)
-		if errors.Is(cause, ErrUserInterruptContinue) {
-			reason := h.tasks.TakeInterruptContinueReason(conversationID)
-			prepNext, perr := h.prepareSessionAfterUserInterrupt(conversationID, assistantMessageID, reason, roleTools)
-			if perr != nil {
-				h.logger.Error("准备中断后续跑失败", zap.Error(perr))
-				taskStatus = "failed"
-				h.tasks.UpdateTaskStatus(conversationID, taskStatus)
-				errMsg := "中断后续跑失败: " + perr.Error()
-				if assistantMessageID != "" {
-					_, _ = h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", errMsg, time.Now(), assistantMessageID)
-				}
-				sendEvent("error", errMsg, map[string]interface{}{
-					"conversationId": conversationID,
-					"messageId":      assistantMessageID,
-				})
-				sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
-				return
-			}
-			assistantMessageID = prepNext.AssistantMessageID
-			curFinalMessage = prepNext.FinalMessage
-			curHistory = prepNext.History
-			if prepNext.UserMessageID != "" {
-				sendEvent("message_saved", "", map[string]interface{}{
-					"conversationId": conversationID,
-					"userMessageId":  prepNext.UserMessageID,
-				})
-			}
-			sendEvent("user_interrupt_continue", reason, map[string]interface{}{
-				"conversationId": conversationID,
-				"reason":         reason,
-				"messageId":      assistantMessageID,
-			})
-			sendEvent("progress", "已接收中断说明，继续迭代...", map[string]interface{}{
-				"conversationId": conversationID,
-			})
-			continue
+		if shouldPersistEinoAgentTraceAfterRunError(baseCtx) {
+			h.persistEinoAgentTraceForResume(conversationID, result)
 		}
-
 		if errors.Is(cause, ErrTaskCancelled) {
 			taskStatus = "cancelled"
 			h.tasks.UpdateTaskStatus(conversationID, taskStatus)
 			cancelMsg := "任务已被用户取消，后续操作已停止。"
 			if assistantMessageID != "" {
-				_, _ = h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", cancelMsg, time.Now(), assistantMessageID)
+				if result != nil {
+					if err := h.mergeAssistantMessagePartialOnCancel(assistantMessageID, result.Response); err != nil {
+						h.logger.Warn("合并取消前的部分回复失败", zap.Error(err))
+					}
+				}
+				if err := h.appendAssistantMessageNotice(assistantMessageID, cancelMsg); err != nil {
+					h.logger.Warn("更新取消后的助手消息失败", zap.Error(err))
+				}
 				_ = h.db.AddProcessDetail(assistantMessageID, conversationID, "cancelled", cancelMsg, nil)
 			}
 			sendEvent("cancelled", cancelMsg, map[string]interface{}{
@@ -388,7 +352,9 @@ func (h *AgentHandler) MultiAgentLoop(c *gin.Context) {
 		strings.TrimSpace(req.Orchestration),
 	)
 	if runErr != nil {
-		h.persistEinoAgentTraceForResume(prep.ConversationID, result)
+		if shouldPersistEinoAgentTraceAfterRunError(baseCtx) {
+			h.persistEinoAgentTraceForResume(prep.ConversationID, result)
+		}
 		h.logger.Error("Eino DeepAgent 执行失败", zap.Error(runErr))
 		errMsg := "执行失败: " + runErr.Error()
 		if prep.AssistantMessageID != "" {

internal/handler/multi_agent_prepare.go

@@ -3,7 +3,6 @@ package handler
 import (
 	"fmt"
 	"strings"
-	"time"
 
 	"cyberstrike-ai/internal/agent"
 	"cyberstrike-ai/internal/database"
@@ -143,64 +142,3 @@ func (h *AgentHandler) prepareMultiAgentSession(req *ChatRequest) (*multiAgentPr
 		UserMessageID:      userMessageID,
 	}, nil
 }
-
-// prepareSessionAfterUserInterrupt 用户「中断并说明」后：结束当前助手占位、写入用户说明、新建助手占位，并生成下一轮 Run 所需的 History + FinalMessage。
-func (h *AgentHandler) prepareSessionAfterUserInterrupt(conversationID, prevAssistantMessageID, reason string, roleTools []string) (*multiAgentPrepared, error) {
-	if strings.TrimSpace(conversationID) == "" {
-		return nil, fmt.Errorf("conversationId 为空")
-	}
-	if _, err := h.db.GetConversation(conversationID); err != nil {
-		return nil, fmt.Errorf("对话不存在")
-	}
-	note := "（已根据用户说明中断当前步骤，正在继续迭代。）"
-	if prevAssistantMessageID != "" {
-		if _, err := h.db.Exec("UPDATE messages SET content = ?, updated_at = ? WHERE id = ?", note, time.Now(), prevAssistantMessageID); err != nil {
-			return nil, fmt.Errorf("更新助手消息失败: %w", err)
-		}
-		r := strings.TrimSpace(reason)
-		detail := "用户中断并说明"
-		if r != "" {
-			detail += "：" + r
-		}
-		_ = h.db.AddProcessDetail(prevAssistantMessageID, conversationID, "user_interrupt", detail, map[string]interface{}{
-			"reason": r,
-		})
-	}
-	userContent := fmt.Sprintf("【用户中断说明】%s\n\n请根据以上说明调整并继续任务。", strings.TrimSpace(reason))
-	if strings.TrimSpace(reason) == "" {
-		userContent = "【用户中断说明】（未填写具体原因）\n\n请根据情况调整并继续任务。"
-	}
-	userMsgRow, err := h.db.AddMessage(conversationID, "user", userContent, nil)
-	if err != nil {
-		return nil, fmt.Errorf("保存用户消息失败: %w", err)
-	}
-	assistantMsg, err := h.db.AddMessage(conversationID, "assistant", "处理中...", nil)
-	if err != nil || assistantMsg == nil {
-		return nil, fmt.Errorf("创建助手占位失败: %w", err)
-	}
-	msgs, err := h.db.GetMessages(conversationID)
-	if err != nil || len(msgs) < 2 {
-		return nil, fmt.Errorf("读取消息历史失败或消息不足")
-	}
-	histMsgs := msgs[:len(msgs)-2]
-	agentHistory := make([]agent.ChatMessage, 0, len(histMsgs))
-	for _, msg := range histMsgs {
-		agentHistory = append(agentHistory, agent.ChatMessage{
-			Role:    msg.Role,
-			Content: msg.Content,
-		})
-	}
-	userMessageID := ""
-	if userMsgRow != nil {
-		userMessageID = userMsgRow.ID
-	}
-	return &multiAgentPrepared{
-		ConversationID:     conversationID,
-		CreatedNew:         false,
-		History:            agentHistory,
-		FinalMessage:       userContent,
-		RoleTools:          roleTools,
-		AssistantMessageID: assistantMsg.ID,
-		UserMessageID:      userMessageID,
-	}, nil
-}

internal/handler/openapi.go

@@ -463,11 +463,11 @@ func (h *OpenAPIHandler) GetOpenAPISpec(c *gin.Context) {
 						},
 						"reason": map[string]interface{}{
 							"type":        "string",
-							"description": "中断说明；与 continueAfter 同时为真时必填，将写入对话并由同一会话流式迭代继续",
+							"description": "可选。与 MCP 监控页「终止并说明」一致：非空时合并进当前工具返回给模型的文本（含 USER INTERRUPT NOTE 块）",
 						},
 						"continueAfter": map[string]interface{}{
 							"type":        "boolean",
-							"description": "为 true 时取消当前运行步骤并注入 reason 后继续迭代（非彻底停止）",
+							"description": "为 true 时仅终止当前进行中的 MCP 工具调用（不取消整轮任务）；须已有工具在执行，否则 400",
 						},
 					},
 				},

internal/handler/task_manager.go

@@ -11,12 +11,16 @@ import (
 // ErrTaskCancelled 用户取消任务的错误
 var ErrTaskCancelled = errors.New("agent task cancelled by user")
 
-// ErrUserInterruptContinue 用户在进度条上「中断并说明」：取消当前运行步骤，将说明写入对话并继续迭代（与 ErrTaskCancelled 区分）
-var ErrUserInterruptContinue = errors.New("user interrupt with continue")
-
 // ErrTaskAlreadyRunning 会话已有任务正在执行
 var ErrTaskAlreadyRunning = errors.New("agent task already running for conversation")
 
+// shouldPersistEinoAgentTraceAfterRunError：Eino 相关 Run 非成功返回时，是否仍写入 last_react_* 供下轮 loadHistoryFromAgentTrace。
+// 当前策略：无论正常结束、异常结束或用户主动停止，都尽量保留最后可用轨迹，
+// 以便在同一会话继续时可基于原始上下文续跑，而不是回退到仅消息文本历史。
+func shouldPersistEinoAgentTraceAfterRunError(baseCtx context.Context) bool {
+	return true
+}
+
 // AgentTask 描述正在运行的Agent任务
 type AgentTask struct {
 	ConversationID string    `json:"conversationId"`
@@ -25,12 +29,56 @@ type AgentTask struct {
 	Status         string    `json:"status"`
 	CancellingAt   time.Time `json:"-"` // 进入 cancelling 状态的时间，用于清理长时间卡住的任务
 
-	// InterruptContinueReason 由 /api/agent-loop/cancel 在 continueAfter 时写入，Run 返回后由 handler 取出并清空
-	InterruptContinueReason string `json:"-"`
+	// ActiveMCPExecutionID 当前正在执行的 MCP 工具 executionId（仅内存，供「中断并继续」= 仅掐当前工具）
+	ActiveMCPExecutionID string `json:"-"`
 
 	cancel func(error)
 }
 
+// RegisterRunningTool 实现 mcp.ToolRunRegistry：工具开始时登记本会话当前 executionId。
+func (m *AgentTaskManager) RegisterRunningTool(conversationID, executionID string) {
+	conversationID = strings.TrimSpace(conversationID)
+	executionID = strings.TrimSpace(executionID)
+	if conversationID == "" || executionID == "" {
+		return
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if t, ok := m.tasks[conversationID]; ok && t != nil {
+		t.ActiveMCPExecutionID = executionID
+	}
+}
+
+// UnregisterRunningTool 工具结束时清除登记（仅当 id 仍匹配时清除，避免并发串单）。
+func (m *AgentTaskManager) UnregisterRunningTool(conversationID, executionID string) {
+	conversationID = strings.TrimSpace(conversationID)
+	executionID = strings.TrimSpace(executionID)
+	if conversationID == "" || executionID == "" {
+		return
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if t, ok := m.tasks[conversationID]; ok && t != nil {
+		if t.ActiveMCPExecutionID == executionID {
+			t.ActiveMCPExecutionID = ""
+		}
+	}
+}
+
+// ActiveMCPExecutionID 返回当前会话进行中的工具 executionId，无则空串。
+func (m *AgentTaskManager) ActiveMCPExecutionID(conversationID string) string {
+	conversationID = strings.TrimSpace(conversationID)
+	if conversationID == "" {
+		return ""
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if t, ok := m.tasks[conversationID]; ok && t != nil {
+		return strings.TrimSpace(t.ActiveMCPExecutionID)
+	}
+	return ""
+}
+
 // CompletedTask 已完成的任务（用于历史记录）
 type CompletedTask struct {
 	ConversationID string    `json:"conversationId"`
@@ -147,49 +195,6 @@ func (m *AgentTaskManager) StartTask(conversationID, message string, cancel cont
 	return task, nil
 }
 
-// SetInterruptContinueReason 在发起 ErrUserInterruptContinue 取消前写入用户说明（须任务仍存在）。
-func (m *AgentTaskManager) SetInterruptContinueReason(conversationID, reason string) bool {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	task, ok := m.tasks[conversationID]
-	if !ok {
-		return false
-	}
-	task.InterruptContinueReason = strings.TrimSpace(reason)
-	return true
-}
-
-// TakeInterruptContinueReason 取出并清空用户中断说明。
-func (m *AgentTaskManager) TakeInterruptContinueReason(conversationID string) string {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	task, ok := m.tasks[conversationID]
-	if !ok {
-		return ""
-	}
-	r := task.InterruptContinueReason
-	task.InterruptContinueReason = ""
-	return r
-}
-
-// ResetTaskCancelForContinue 在一次「中断并继续」后恢复任务为 running 并绑定新的 cancel（同一会话同一条 HTTP 流内续跑）。
-func (m *AgentTaskManager) ResetTaskCancelForContinue(conversationID string, cancel context.CancelCauseFunc) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	task, ok := m.tasks[conversationID]
-	if !ok {
-		return errors.New("no active task")
-	}
-	task.cancel = func(err error) {
-		if cancel != nil {
-			cancel(err)
-		}
-	}
-	task.Status = "running"
-	task.CancellingAt = time.Time{}
-	return nil
-}
-
 // CancelTask 取消指定会话的任务。若任务已在取消中，仍返回 (true, nil) 以便接口幂等、前端不报错。
 func (m *AgentTaskManager) CancelTask(conversationID string, cause error) (bool, error) {
 	m.mu.Lock()

internal/mcp/external_manager.go

@@ -458,7 +458,9 @@ func (m *ExternalMCPManager) CallTool(ctx context.Context, toolName string, args
 
 	execCtx, runCancel := context.WithCancel(ctx)
 	m.registerRunningCancel(executionID, runCancel)
+	notifyToolRunBegin(ctx, executionID)
 	defer func() {
+		notifyToolRunEnd(ctx, executionID)
 		runCancel()
 		m.unregisterRunningCancel(executionID)
 	}()

internal/mcp/run_context.go

@@ -0,0 +1,77 @@
+package mcp
+
+import (
+	"context"
+	"strings"
+)
+
+// ToolRunRegistry 在工具开始/结束时登记当前 executionId，供对话页「仅终止当前工具」与监控页共用取消逻辑。
+type ToolRunRegistry interface {
+	RegisterRunningTool(conversationID, executionID string)
+	UnregisterRunningTool(conversationID, executionID string)
+}
+
+type toolRunRegistryCtxKey struct{}
+type mcpConversationIDCtxKey struct{}
+
+// WithToolRunRegistry 将登记器注入 ctx（Eino / 原生 Agent 任务 ctx）。
+func WithToolRunRegistry(ctx context.Context, reg ToolRunRegistry) context.Context {
+	if ctx == nil || reg == nil {
+		return ctx
+	}
+	return context.WithValue(ctx, toolRunRegistryCtxKey{}, reg)
+}
+
+// ToolRunRegistryFromContext 取出登记器（无则 nil）。
+func ToolRunRegistryFromContext(ctx context.Context) ToolRunRegistry {
+	if ctx == nil {
+		return nil
+	}
+	v, _ := ctx.Value(toolRunRegistryCtxKey{}).(ToolRunRegistry)
+	return v
+}
+
+// WithMCPConversationID 将对话 ID 注入 ctx，供 CallTool 内与 executionId 关联。
+func WithMCPConversationID(ctx context.Context, conversationID string) context.Context {
+	if ctx == nil {
+		return nil
+	}
+	id := strings.TrimSpace(conversationID)
+	if id == "" {
+		return ctx
+	}
+	return context.WithValue(ctx, mcpConversationIDCtxKey{}, id)
+}
+
+// MCPConversationIDFromContext 读取对话 ID。
+func MCPConversationIDFromContext(ctx context.Context) string {
+	if ctx == nil {
+		return ""
+	}
+	v, _ := ctx.Value(mcpConversationIDCtxKey{}).(string)
+	return v
+}
+
+func notifyToolRunBegin(ctx context.Context, executionID string) {
+	reg := ToolRunRegistryFromContext(ctx)
+	if reg == nil {
+		return
+	}
+	conv := MCPConversationIDFromContext(ctx)
+	if conv == "" || strings.TrimSpace(executionID) == "" {
+		return
+	}
+	reg.RegisterRunningTool(conv, executionID)
+}
+
+func notifyToolRunEnd(ctx context.Context, executionID string) {
+	reg := ToolRunRegistryFromContext(ctx)
+	if reg == nil {
+		return
+	}
+	conv := MCPConversationIDFromContext(ctx)
+	if conv == "" || strings.TrimSpace(executionID) == "" {
+		return
+	}
+	reg.UnregisterRunningTool(conv, executionID)
+}

internal/mcp/server.go

@@ -803,7 +803,9 @@ func (s *Server) CallTool(ctx context.Context, toolName string, args map[string]
 
 	execCtx, runCancel := context.WithCancel(ctx)
 	s.registerRunningCancel(executionID, runCancel)
+	notifyToolRunBegin(ctx, executionID)
 	defer func() {
+		notifyToolRunEnd(ctx, executionID)
 		runCancel()
 		s.unregisterRunningCancel(executionID)
 	}()

internal/multiagent/eino_adk_run_loop.go

@@ -19,6 +19,40 @@ import (
 	"go.uber.org/zap"
 )
 
+// normalizeStreamingDelta 将可能是“累计片段”的 chunk 归一化为“纯增量”。
+// 一些模型/桥接层在流式过程中会重复发送已输出前缀，前端若直接 buffer+=chunk 会出现“结巴”重复。
+func normalizeStreamingDelta(current, incoming string) (next, delta string) {
+	if incoming == "" {
+		return current, ""
+	}
+	if current == "" {
+		return incoming, incoming
+	}
+	if incoming == current {
+		return current, ""
+	}
+	// incoming 是累计全文（包含 current 前缀）
+	if strings.HasPrefix(incoming, current) {
+		return incoming, incoming[len(current):]
+	}
+	// incoming 完全是已输出尾部重发
+	if strings.HasSuffix(current, incoming) {
+		return current, ""
+	}
+
+	// 处理边界重叠：current 后缀与 incoming 前缀重叠，只追加非重叠部分。
+	max := len(current)
+	if len(incoming) < max {
+		max = len(incoming)
+	}
+	for overlap := max; overlap > 0; overlap-- {
+		if current[len(current)-overlap:] == incoming[:overlap] {
+			return current + incoming[overlap:], incoming[overlap:]
+		}
+	}
+	return current + incoming, incoming
+}
+
 func isEinoIterationLimitError(err error) bool {
 	if err == nil {
 		return false
@@ -430,9 +464,10 @@ func runEinoADKAgentLoop(ctx context.Context, args *einoADKRunLoopArgs, baseMsgs
 			streamHeaderSent := false
 			var reasoningStreamID string
 			var toolStreamFragments []schema.ToolCall
-			var subAssistantBuf strings.Builder
+			var subAssistantBuf string
 			var subReplyStreamID string
-			var mainAssistantBuf strings.Builder
+			var mainAssistantBuf string
+			var reasoningBuf string
 			var streamRecvErr error
 			for {
 				chunk, rerr := mv.MessageStream.Recv()
@@ -453,59 +488,69 @@ func runEinoADKAgentLoop(ctx context.Context, args *einoADKRunLoopArgs, baseMsgs
 					continue
 				}
 				if progress != nil && strings.TrimSpace(chunk.ReasoningContent) != "" {
-					if reasoningStreamID == "" {
-						reasoningStreamID = fmt.Sprintf("eino-reasoning-%s-%d", conversationID, atomic.AddInt64(&reasoningStreamSeq, 1))
-						progress("thinking_stream_start", " ", map[string]interface{}{
-							"streamId":      reasoningStreamID,
-							"source":        "eino",
-							"einoAgent":     ev.AgentName,
-							"einoRole":      einoRoleTag(ev.AgentName),
-							"orchestration": orchMode,
+					var reasoningDelta string
+					reasoningBuf, reasoningDelta = normalizeStreamingDelta(reasoningBuf, chunk.ReasoningContent)
+					if reasoningDelta != "" {
+						if reasoningStreamID == "" {
+							reasoningStreamID = fmt.Sprintf("eino-reasoning-%s-%d", conversationID, atomic.AddInt64(&reasoningStreamSeq, 1))
+							progress("thinking_stream_start", " ", map[string]interface{}{
+								"streamId":      reasoningStreamID,
+								"source":        "eino",
+								"einoAgent":     ev.AgentName,
+								"einoRole":      einoRoleTag(ev.AgentName),
+								"orchestration": orchMode,
+							})
+						}
+						progress("thinking_stream_delta", reasoningDelta, map[string]interface{}{
+							"streamId": reasoningStreamID,
 						})
 					}
-					progress("thinking_stream_delta", chunk.ReasoningContent, map[string]interface{}{
-						"streamId": reasoningStreamID,
-					})
 				}
 				if chunk.Content != "" {
 					if progress != nil && streamsMainAssistant(ev.AgentName) {
-						if !streamHeaderSent {
-							progress("response_start", "", map[string]interface{}{
-								"conversationId":     conversationID,
-								"mcpExecutionIds":    snapshotMCPIDs(),
-								"messageGeneratedBy": "eino:" + ev.AgentName,
-								"einoRole":           "orchestrator",
-								"einoAgent":          ev.AgentName,
-								"orchestration":      orchMode,
+						var contentDelta string
+						mainAssistantBuf, contentDelta = normalizeStreamingDelta(mainAssistantBuf, chunk.Content)
+						if contentDelta != "" {
+							if !streamHeaderSent {
+								progress("response_start", "", map[string]interface{}{
+									"conversationId":     conversationID,
+									"mcpExecutionIds":    snapshotMCPIDs(),
+									"messageGeneratedBy": "eino:" + ev.AgentName,
+									"einoRole":           "orchestrator",
+									"einoAgent":          ev.AgentName,
+									"orchestration":      orchMode,
+								})
+								streamHeaderSent = true
+							}
+							progress("response_delta", contentDelta, map[string]interface{}{
+								"conversationId":  conversationID,
+								"mcpExecutionIds": snapshotMCPIDs(),
+								"einoRole":        "orchestrator",
+								"einoAgent":       ev.AgentName,
+								"orchestration":   orchMode,
 							})
-							streamHeaderSent = true
 						}
-						progress("response_delta", chunk.Content, map[string]interface{}{
-							"conversationId":  conversationID,
-							"mcpExecutionIds": snapshotMCPIDs(),
-							"einoRole":        "orchestrator",
-							"einoAgent":       ev.AgentName,
-							"orchestration":   orchMode,
-						})
-						mainAssistantBuf.WriteString(chunk.Content)
 					} else if !streamsMainAssistant(ev.AgentName) {
-						if progress != nil {
-							if subReplyStreamID == "" {
-								subReplyStreamID = fmt.Sprintf("eino-sub-reply-%s-%d", conversationID, atomic.AddInt64(&einoSubReplyStreamSeq, 1))
-								progress("eino_agent_reply_stream_start", "", map[string]interface{}{
+						var subDelta string
+						subAssistantBuf, subDelta = normalizeStreamingDelta(subAssistantBuf, chunk.Content)
+						if subDelta != "" {
+							if progress != nil {
+								if subReplyStreamID == "" {
+									subReplyStreamID = fmt.Sprintf("eino-sub-reply-%s-%d", conversationID, atomic.AddInt64(&einoSubReplyStreamSeq, 1))
+									progress("eino_agent_reply_stream_start", "", map[string]interface{}{
+										"streamId":       subReplyStreamID,
+										"einoAgent":      ev.AgentName,
+										"einoRole":       "sub",
+										"conversationId": conversationID,
+										"source":         "eino",
+									})
+								}
+								progress("eino_agent_reply_stream_delta", subDelta, map[string]interface{}{
 									"streamId":       subReplyStreamID,
-									"einoAgent":      ev.AgentName,
-									"einoRole":       "sub",
 									"conversationId": conversationID,
-									"source":         "eino",
 								})
 							}
-							progress("eino_agent_reply_stream_delta", chunk.Content, map[string]interface{}{
-								"streamId":       subReplyStreamID,
-								"conversationId": conversationID,
-							})
 						}
-						subAssistantBuf.WriteString(chunk.Content)
 					}
 				}
 				if len(chunk.ToolCalls) > 0 {
@@ -513,7 +558,7 @@ func runEinoADKAgentLoop(ctx context.Context, args *einoADKRunLoopArgs, baseMsgs
 				}
 			}
 			if streamsMainAssistant(ev.AgentName) {
-				if s := strings.TrimSpace(mainAssistantBuf.String()); s != "" {
+				if s := strings.TrimSpace(mainAssistantBuf); s != "" {
 					lastAssistant = s
 					runAccumulatedMsgs = append(runAccumulatedMsgs, schema.AssistantMessage(s, nil))
 					if orchMode == "plan_execute" && strings.EqualFold(strings.TrimSpace(ev.AgentName), "executor") {
@@ -521,8 +566,8 @@ func runEinoADKAgentLoop(ctx context.Context, args *einoADKRunLoopArgs, baseMsgs
 					}
 				}
 			}
-			if subAssistantBuf.Len() > 0 && progress != nil {
-				if s := strings.TrimSpace(subAssistantBuf.String()); s != "" {
+			if strings.TrimSpace(subAssistantBuf) != "" && progress != nil {
+				if s := strings.TrimSpace(subAssistantBuf); s != "" {
 					if subReplyStreamID != "" {
 						progress("eino_agent_reply_stream_end", s, map[string]interface{}{
 							"streamId":       subReplyStreamID,

internal/openai/claude_bridge.go

@@ -499,6 +499,7 @@ func (c *Client) claudeChatCompletionStream(ctx context.Context, payload interfa
 
 	reader := bufio.NewReader(resp.Body)
 	var full strings.Builder
+	fullText := ""
 
 	for {
 		line, readErr := reader.ReadString('\n')
@@ -531,9 +532,14 @@ func (c *Client) claudeChatCompletionStream(ctx context.Context, payload interfa
 			if deltaType == "text_delta" {
 				text, _ := delta["text"].(string)
 				if text != "" {
-					full.WriteString(text)
+					var textOut string
+					fullText, textOut = normalizeStreamingDelta(fullText, text)
+					if textOut == "" {
+						continue
+					}
+					full.WriteString(textOut)
 					if onDelta != nil {
-						if err := onDelta(text); err != nil {
+						if err := onDelta(textOut); err != nil {
 							return full.String(), err
 						}
 					}
@@ -603,6 +609,7 @@ func (c *Client) claudeChatCompletionStreamWithToolCalls(
 
 	reader := bufio.NewReader(resp.Body)
 	var full strings.Builder
+	fullText := ""
 	finishReason := ""
 
 	// 追踪当前正在构建的 content blocks
@@ -665,9 +672,14 @@ func (c *Client) claudeChatCompletionStreamWithToolCalls(
 			if deltaType == "text_delta" {
 				text, _ := delta["text"].(string)
 				if text != "" {
-					full.WriteString(text)
+					var textOut string
+					fullText, textOut = normalizeStreamingDelta(fullText, text)
+					if textOut == "" {
+						continue
+					}
+					full.WriteString(textOut)
 					if onContentDelta != nil {
-						if err := onContentDelta(text); err != nil {
+						if err := onContentDelta(textOut); err != nil {
 							return full.String(), nil, finishReason, err
 						}
 					}

internal/openai/openai.go

@@ -33,6 +33,38 @@ func (e *APIError) Error() string {
 	return fmt.Sprintf("openai api error: status=%d body=%s", e.StatusCode, e.Body)
 }
 
+// normalizeStreamingDelta 将可能是“累计片段/重发片段”的内容归一化为“纯增量”。
+// 部分兼容网关会返回累计 content；若直接 append 会出现重复文本（结巴）。
+func normalizeStreamingDelta(current, incoming string) (next, delta string) {
+	if incoming == "" {
+		return current, ""
+	}
+	if current == "" {
+		return incoming, incoming
+	}
+	if incoming == current {
+		return current, ""
+	}
+	if strings.HasPrefix(incoming, current) {
+		return incoming, incoming[len(current):]
+	}
+	if strings.HasSuffix(current, incoming) {
+		return current, ""
+	}
+
+	// 边界重叠：current 后缀与 incoming 前缀重合，仅追加非重叠部分。
+	max := len(current)
+	if len(incoming) < max {
+		max = len(incoming)
+	}
+	for overlap := max; overlap > 0; overlap-- {
+		if current[len(current)-overlap:] == incoming[:overlap] {
+			return current + incoming[overlap:], incoming[overlap:]
+		}
+	}
+	return current + incoming, incoming
+}
+
 // NewClient 创建一个新的OpenAI客户端。
 func NewClient(cfg *config.OpenAIConfig, httpClient *http.Client, logger *zap.Logger) *Client {
 	if httpClient == nil {
@@ -219,6 +251,7 @@ func (c *Client) ChatCompletionStream(ctx context.Context, payload interface{},
 
 	reader := bufio.NewReader(resp.Body)
 	var full strings.Builder
+	fullText := ""
 
 	// 典型 SSE 结构：
 	// data: {...}\n\n
@@ -263,9 +296,14 @@ func (c *Client) ChatCompletionStream(ctx context.Context, payload interface{},
 			continue
 		}
 
-		full.WriteString(delta)
+		var deltaOut string
+		fullText, deltaOut = normalizeStreamingDelta(fullText, delta)
+		if deltaOut == "" {
+			continue
+		}
+		full.WriteString(deltaOut)
 		if onDelta != nil {
-			if err := onDelta(delta); err != nil {
+			if err := onDelta(deltaOut); err != nil {
 				return full.String(), err
 			}
 		}
@@ -380,6 +418,7 @@ func (c *Client) ChatCompletionStreamWithToolCalls(
 
 	reader := bufio.NewReader(resp.Body)
 	var full strings.Builder
+	fullText := ""
 	finishReason := ""
 
 	for {
@@ -426,10 +465,14 @@ func (c *Client) ChatCompletionStreamWithToolCalls(
 			content = delta.Text
 		}
 		if content != "" {
-			full.WriteString(content)
-			if onContentDelta != nil {
-				if err := onContentDelta(content); err != nil {
-					return full.String(), nil, finishReason, err
+			var contentOut string
+			fullText, contentOut = normalizeStreamingDelta(fullText, content)
+			if contentOut != "" {
+				full.WriteString(contentOut)
+				if onContentDelta != nil {
+					if err := onContentDelta(contentOut); err != nil {
+						return full.String(), nil, finishReason, err
+					}
 				}
 			}
 		}

web/static/i18n/en-US.json

@@ -396,7 +396,7 @@
     "stopTask": "Stop task",
     "interruptModalTitle": "Interrupt current step",
     "interruptReasonLabel": "Interrupt note",
-    "interruptModalHint": "Your note is saved as a user message and the agent continues in the same stream. Use \"Stop completely\" to end the task.",
+    "interruptModalHint": "Same as MCP monitor \"Stop tool\": ends only the in-flight tool call; the conversation and this run continue. Optional note is merged into the tool result (bilingual USER INTERRUPT NOTE, not raw CLI). Leave empty for a plain stop. If no tool is running yet (model still thinking), wait for a tool call or use \"Stop completely\".",
     "interruptReasonPlaceholder": "e.g. Tool is too slow—skip and summarize…",
     "interruptReasonRequired": "Please enter a short note so the model can continue accordingly.",
     "interruptSubmitting": "Submitting...",

web/static/i18n/zh-CN.json

@@ -385,7 +385,7 @@
     "stopTask": "停止任务",
     "interruptModalTitle": "中断当前步骤",
     "interruptReasonLabel": "中断说明",
-    "interruptModalHint": "填写说明后将作为一条用户消息写入对话，智能体在同一会话内继续迭代。若只需完全停止任务，请点「彻底停止」。",
+    "interruptModalHint": "与 MCP 监控页「终止工具」一致：仅结束当前这一次工具调用，整条对话与本轮推理会继续；工具返回中可附带说明（中英 USER INTERRUPT NOTE 块，与命令行原文区分）。留空则等同仅终止工具。若当前没有工具在执行（模型尚在思考），请等待工具开始或改用「彻底停止」。",
     "interruptReasonPlaceholder": "例如：工具耗时过长，请先跳过并总结当前结果…",
     "interruptReasonRequired": "请填写中断说明，以便模型根据你的意图继续。",
     "interruptSubmitting": "提交中...",

web/static/js/monitor.js

@@ -356,6 +356,23 @@ function isChatMessagesPinnedToBottom() {
     return scrollHeight - clientHeight - scrollTop <= CHAT_SCROLL_PIN_THRESHOLD_PX;
 }
 
+/** 顶栏「停止任务」与进度条按钮对齐时，用会话 ID 反查当前页的 progress 块 ID（无则弹窗内仍可按会话取消） */
+function findProgressIdByConversationId(conversationId) {
+    if (!conversationId) {
+        return null;
+    }
+    let fallback = null;
+    for (const [pid, st] of progressTaskState) {
+        if (st && st.conversationId === conversationId) {
+            fallback = pid;
+            if (document.getElementById(pid)) {
+                return pid;
+            }
+        }
+    }
+    return fallback;
+}
+
 function registerProgressTask(progressId, conversationId = null) {
     const state = progressTaskState.get(progressId) || {};
     state.conversationId = conversationId !== undefined && conversationId !== null
@@ -412,7 +429,7 @@ async function requestCancel(conversationId) {
     return result;
 }
 
-/** 用户填写说明后中断当前步骤，由后端写入对话并继续同一条流式迭代 */
+/** 与 MCP 监控一致：仅终止当前进行中的工具调用，工具返回后本轮推理继续（可选 reason 合并进工具结果） */
 async function requestCancelWithContinue(conversationId, reason) {
     const response = await apiFetch('/api/agent-loop/cancel', {
         method: 'POST',
@@ -433,7 +450,10 @@ async function requestCancelWithContinue(conversationId, reason) {
 }
 
 function openUserInterruptModal(progressId, conversationId) {
-    userInterruptModalPending = { progressId, conversationId };
+    userInterruptModalPending = {
+        progressId: progressId != null && progressId !== '' ? progressId : null,
+        conversationId,
+    };
     const ta = document.getElementById('user-interrupt-reason');
     if (ta) {
         ta.value = '';
@@ -457,13 +477,9 @@ async function submitUserInterruptContinue() {
         return;
     }
     const reason = (document.getElementById('user-interrupt-reason') && document.getElementById('user-interrupt-reason').value || '').trim();
-    if (!reason) {
-        alert(typeof window.t === 'function' ? window.t('tasks.interruptReasonRequired') : '请填写中断说明');
-        return;
-    }
     const { progressId, conversationId } = userInterruptModalPending;
     closeUserInterruptModal();
-    const stopBtn = document.getElementById(`${progressId}-stop-btn`);
+    const stopBtn = progressId ? document.getElementById(`${progressId}-stop-btn`) : null;
     try {
         if (stopBtn) {
             stopBtn.disabled = true;
@@ -486,9 +502,22 @@ async function submitUserInterruptHardCancel() {
     if (!userInterruptModalPending) {
         return;
     }
-    const { progressId } = userInterruptModalPending;
+    const { progressId, conversationId } = userInterruptModalPending;
     closeUserInterruptModal();
-    await performHardCancelProgressTask(progressId);
+    if (progressId) {
+        await performHardCancelProgressTask(progressId);
+        return;
+    }
+    if (!conversationId) {
+        return;
+    }
+    try {
+        await requestCancel(conversationId);
+        loadActiveTasks();
+    } catch (error) {
+        console.error('取消任务失败:', error);
+        alert((typeof window.t === 'function' ? window.t('tasks.cancelTaskFailed') : '取消任务失败') + ': ' + error.message);
+    }
 }
 
 /** 彻底停止任务（原「停止任务」行为） */
@@ -1518,18 +1547,6 @@ function handleStreamEvent(event, progressElement, progressId,
             break;
         }
             
-        case 'user_interrupt_continue': {
-            const d = event.data || {};
-            const reason = (d.reason != null && String(d.reason).trim() !== '') ? String(d.reason).trim() : (event.message || '');
-            const timelineTitle = typeof window.t === 'function' ? window.t('tasks.userInterruptTimelineTitle') : '用户中断说明（继续迭代）';
-            addTimelineItem(timeline, 'user_interrupt', {
-                title: '✋ ' + timelineTitle,
-                message: reason,
-                data: d,
-            });
-            break;
-        }
-
         case 'progress':
             const progressTitle = document.querySelector(`#${progressId} .progress-title`);
             if (progressTitle) {
@@ -2533,7 +2550,7 @@ function renderActiveTasks(tasks) {
             if (cancelBtn) {
                 cancelBtn.onclick = (evt) => {
                     evt.stopPropagation();
-                    cancelActiveTask(task.conversationId, cancelBtn);
+                    cancelActiveTask(task.conversationId);
                 };
                 if (task.status === 'cancelling') {
                     cancelBtn.disabled = true;
@@ -2546,21 +2563,12 @@ function renderActiveTasks(tasks) {
     });
 }
 
-async function cancelActiveTask(conversationId, button) {
-    if (!conversationId) return;
-    const originalText = button.textContent;
-    button.disabled = true;
-    button.textContent = typeof window.t === 'function' ? window.t('tasks.cancelling') : '取消中...';
-
-    try {
-        await requestCancel(conversationId);
-        loadActiveTasks();
-    } catch (error) {
-        console.error('取消任务失败:', error);
-        alert((typeof window.t === 'function' ? window.t('tasks.cancelTaskFailed') : '取消任务失败') + ': ' + error.message);
-        button.disabled = false;
-        button.textContent = originalText;
+function cancelActiveTask(conversationId) {
+    if (!conversationId) {
+        return;
     }
+    const progressId = findProgressIdByConversationId(conversationId);
+    openUserInterruptModal(progressId, conversationId);
 }
 
 let monitorPanelFetchSeq = 0;