Add files via upload

internal/handler/agent.go

@@ -19,6 +19,7 @@ import (
 	"cyberstrike-ai/internal/config"
 	"cyberstrike-ai/internal/database"
 	"cyberstrike-ai/internal/mcp/builtin"
+	"cyberstrike-ai/internal/multiagent"
 	"cyberstrike-ai/internal/skills"
 
 	"github.com/gin-gonic/gin"
@@ -77,7 +78,8 @@ type AgentHandler struct {
 	knowledgeManager interface {    // 知识库管理器接口
 		LogRetrieval(conversationID, messageID, query, riskType string, retrievedItems []string) error
 	}
-	skillsManager *skills.Manager // Skills管理器
+	skillsManager       *skills.Manager // Skills管理器
+	agentsMarkdownDir   string          // 多代理：Markdown 子 Agent 目录（绝对路径，空则不从磁盘合并）
 }
 
 // NewAgentHandler 创建新的Agent处理器
@@ -112,6 +114,11 @@ func (h *AgentHandler) SetSkillsManager(manager *skills.Manager) {
 	h.skillsManager = manager
 }
 
+// SetAgentsMarkdownDir 设置 agents/*.md 子代理目录（绝对路径）；空表示仅使用 config.yaml 中的 sub_agents。
+func (h *AgentHandler) SetAgentsMarkdownDir(absDir string) {
+	h.agentsMarkdownDir = strings.TrimSpace(absDir)
+}
+
 // ChatAttachment 聊天附件（用户上传的文件）
 type ChatAttachment struct {
 	FileName string `json:"fileName"` // 文件名
@@ -123,8 +130,8 @@ type ChatAttachment struct {
 type ChatRequest struct {
 	Message              string           `json:"message" binding:"required"`
 	ConversationID       string           `json:"conversationId,omitempty"`
-	Role                 string           `json:"role,omitempty"`                 // 角色名称
-	Attachments          []ChatAttachment  `json:"attachments,omitempty"`
+	Role                 string           `json:"role,omitempty"` // 角色名称
+	Attachments          []ChatAttachment `json:"attachments,omitempty"`
 	WebShellConnectionID string           `json:"webshellConnectionId,omitempty"` // WebShell 管理 - AI 助手：当前选中的连接 ID，仅使用 webshell_* 工具
 }
 
@@ -315,7 +322,7 @@ func (h *AgentHandler) AgentLoop(c *gin.Context) {
 
 	// 应用角色用户提示词和工具配置
 	finalMessage := req.Message
-	var roleTools []string // 角色配置的工具列表
+	var roleTools []string  // 角色配置的工具列表
 	var roleSkills []string // 角色配置的skills列表（用于提示AI，但不硬编码内容）
 
 	// WebShell AI 助手模式：绑定当前连接，仅开放 webshell_* 工具并注入 connection_id
@@ -484,6 +491,53 @@ func (h *AgentHandler) ProcessMessageForRobot(ctx context.Context, conversationI
 	}
 	progressCallback := h.createProgressCallback(conversationID, assistantMessageID, nil)
 
+	useRobotMulti := h.config != nil && h.config.MultiAgent.Enabled && h.config.MultiAgent.RobotUseMultiAgent
+	if useRobotMulti {
+		resultMA, errMA := multiagent.RunDeepAgent(
+			ctx,
+			h.config,
+			&h.config.MultiAgent,
+			h.agent,
+			h.logger,
+			conversationID,
+			finalMessage,
+			agentHistoryMessages,
+			roleTools,
+			progressCallback,
+			h.agentsMarkdownDir,
+		)
+		if errMA != nil {
+			errMsg := "执行失败: " + errMA.Error()
+			if assistantMessageID != "" {
+				_, _ = h.db.Exec("UPDATE messages SET content = ? WHERE id = ?", errMsg, assistantMessageID)
+				_ = h.db.AddProcessDetail(assistantMessageID, conversationID, "error", errMsg, nil)
+			}
+			return "", conversationID, errMA
+		}
+		if assistantMessageID != "" {
+			mcpIDsJSON := ""
+			if len(resultMA.MCPExecutionIDs) > 0 {
+				jsonData, _ := json.Marshal(resultMA.MCPExecutionIDs)
+				mcpIDsJSON = string(jsonData)
+			}
+			_, err = h.db.Exec(
+				"UPDATE messages SET content = ?, mcp_execution_ids = ? WHERE id = ?",
+				resultMA.Response, mcpIDsJSON, assistantMessageID,
+			)
+			if err != nil {
+				h.logger.Warn("机器人：更新助手消息失败", zap.Error(err))
+			}
+		} else {
+			if _, err = h.db.AddMessage(conversationID, "assistant", resultMA.Response, resultMA.MCPExecutionIDs); err != nil {
+				h.logger.Warn("机器人：保存助手消息失败", zap.Error(err))
+			}
+		}
+		if resultMA.LastReActInput != "" || resultMA.LastReActOutput != "" {
+			_ = h.db.SaveReActData(conversationID, resultMA.LastReActInput, resultMA.LastReActOutput)
+		}
+		return resultMA.Response, conversationID, nil
+	}
+
 	result, err := h.agent.AgentLoopWithProgress(ctx, finalMessage, agentHistoryMessages, conversationID, progressCallback, roleTools, roleSkills)
 	if err != nil {
 		errMsg := "执行失败: " + err.Error()
@@ -662,6 +716,14 @@ func (h *AgentHandler) createProgressCallback(conversationID, assistantMessageID
 			}
 		}
 
+		// 子代理回复流式增量不落库；结束时合并为一条 eino_agent_reply
+		if assistantMessageID != "" && eventType == "eino_agent_reply_stream_end" {
+			if err := h.db.AddProcessDetail(assistantMessageID, conversationID, "eino_agent_reply", message, data); err != nil {
+				h.logger.Warn("保存过程详情失败", zap.Error(err), zap.String("eventType", eventType))
+			}
+			return
+		}
+
 		// 保存过程详情到数据库（排除response/done事件，它们会在后面单独处理）
 		// 另外：response_start/response_delta 是模型流式增量，保存会导致过程详情膨胀，因此不落库。
 		if assistantMessageID != "" &&
@@ -671,7 +733,10 @@ func (h *AgentHandler) createProgressCallback(conversationID, assistantMessageID
 			eventType != "response_delta" &&
 			eventType != "tool_result_delta" &&
 			eventType != "thinking_stream_start" &&
-			eventType != "thinking_stream_delta" {
+			eventType != "thinking_stream_delta" &&
+			eventType != "eino_agent_reply_stream_start" &&
+			eventType != "eino_agent_reply_stream_delta" &&
+			eventType != "eino_agent_reply_stream_end" {
 			if err := h.db.AddProcessDetail(assistantMessageID, conversationID, eventType, message, data); err != nil {
 				h.logger.Warn("保存过程详情失败", zap.Error(err), zap.String("eventType", eventType))
 			}
@@ -1499,7 +1564,7 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 
 		// 应用角色用户提示词和工具配置
 		finalMessage := task.Message
-		var roleTools []string // 角色配置的工具列表
+		var roleTools []string  // 角色配置的工具列表
 		var roleSkills []string // 角色配置的skills列表（用于提示AI，但不硬编码内容）
 		if queue.Role != "" && queue.Role != "默认" {
 			if h.config.Roles != nil {
@@ -1553,28 +1618,42 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 		h.batchTaskManager.SetTaskCancel(queueID, cancel)
 		// 使用队列配置的角色工具列表（如果为空，表示使用所有工具）
 		// 注意：skills不会硬编码注入，但会在系统提示词中提示AI这个角色推荐使用哪些skills
-		result, err := h.agent.AgentLoopWithProgress(ctx, finalMessage, []agent.ChatMessage{}, conversationID, progressCallback, roleTools, roleSkills)
+		useBatchMulti := h.config != nil && h.config.MultiAgent.Enabled && h.config.MultiAgent.BatchUseMultiAgent
+		var result *agent.AgentLoopResult
+		var resultMA *multiagent.RunResult
+		var runErr error
+		if useBatchMulti {
+			resultMA, runErr = multiagent.RunDeepAgent(ctx, h.config, &h.config.MultiAgent, h.agent, h.logger, conversationID, finalMessage, []agent.ChatMessage{}, roleTools, progressCallback, h.agentsMarkdownDir)
+		} else {
+			result, runErr = h.agent.AgentLoopWithProgress(ctx, finalMessage, []agent.ChatMessage{}, conversationID, progressCallback, roleTools, roleSkills)
+		}
 		// 任务执行完成，清理取消函数
 		h.batchTaskManager.SetTaskCancel(queueID, nil)
 		cancel()
 
-		if err != nil {
+		if runErr != nil {
 			// 检查是否是取消错误
 			// 1. 直接检查是否是 context.Canceled（包括包装后的错误）
 			// 2. 检查错误消息中是否包含"context canceled"或"cancelled"关键字
 			// 3. 检查 result.Response 中是否包含取消相关的消息
-			errStr := err.Error()
-			isCancelled := errors.Is(err, context.Canceled) ||
+			errStr := runErr.Error()
+			partialResp := ""
+			if result != nil {
+				partialResp = result.Response
+			} else if resultMA != nil {
+				partialResp = resultMA.Response
+			}
+			isCancelled := errors.Is(runErr, context.Canceled) ||
 				strings.Contains(strings.ToLower(errStr), "context canceled") ||
 				strings.Contains(strings.ToLower(errStr), "context cancelled") ||
-				(result != nil && result.Response != "" && (strings.Contains(result.Response, "任务已被取消") || strings.Contains(result.Response, "任务执行中断")))
+				(partialResp != "" && (strings.Contains(partialResp, "任务已被取消") || strings.Contains(partialResp, "任务执行中断")))
 
 			if isCancelled {
 				h.logger.Info("批量任务被取消", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID))
 				cancelMsg := "任务已被用户取消，后续操作已停止。"
-				// 如果result中有更具体的取消消息，使用它
-				if result != nil && result.Response != "" && (strings.Contains(result.Response, "任务已被取消") || strings.Contains(result.Response, "任务执行中断")) {
-					cancelMsg = result.Response
+				// 如果执行结果中有更具体的取消消息，使用它
+				if partialResp != "" && (strings.Contains(partialResp, "任务已被取消") || strings.Contains(partialResp, "任务执行中断")) {
+					cancelMsg = partialResp
 				}
 				// 更新助手消息内容
 				if assistantMessageID != "" {
@@ -1601,11 +1680,15 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 					if err := h.db.SaveReActData(conversationID, result.LastReActInput, result.LastReActOutput); err != nil {
 						h.logger.Warn("保存取消任务的ReAct数据失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(err))
 					}
+				} else if resultMA != nil && (resultMA.LastReActInput != "" || resultMA.LastReActOutput != "") {
+					if err := h.db.SaveReActData(conversationID, resultMA.LastReActInput, resultMA.LastReActOutput); err != nil {
+						h.logger.Warn("保存取消任务的ReAct数据失败", 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(err))
-				errorMsg := "执行失败: " + err.Error()
+				h.logger.Error("批量任务执行失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(runErr))
+				errorMsg := "执行失败: " + runErr.Error()
 				// 更新助手消息内容
 				if assistantMessageID != "" {
 					if _, updateErr := h.db.Exec(
@@ -1620,42 +1703,57 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 						h.logger.Warn("保存错误详情失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(err))
 					}
 				}
-				h.batchTaskManager.UpdateTaskStatus(queueID, task.ID, "failed", "", err.Error())
+				h.batchTaskManager.UpdateTaskStatus(queueID, task.ID, "failed", "", runErr.Error())
 			}
 		} else {
 			h.logger.Info("批量任务执行成功", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID))
 
+			var resText string
+			var mcpIDs []string
+			var lastIn, lastOut string
+			if useBatchMulti {
+				resText = resultMA.Response
+				mcpIDs = resultMA.MCPExecutionIDs
+				lastIn = resultMA.LastReActInput
+				lastOut = resultMA.LastReActOutput
+			} else {
+				resText = result.Response
+				mcpIDs = result.MCPExecutionIDs
+				lastIn = result.LastReActInput
+				lastOut = result.LastReActOutput
+			}
+
 			// 更新助手消息内容
 			if assistantMessageID != "" {
 				mcpIDsJSON := ""
-				if len(result.MCPExecutionIDs) > 0 {
-					jsonData, _ := json.Marshal(result.MCPExecutionIDs)
+				if len(mcpIDs) > 0 {
+					jsonData, _ := json.Marshal(mcpIDs)
 					mcpIDsJSON = string(jsonData)
 				}
 				if _, updateErr := h.db.Exec(
 					"UPDATE messages SET content = ?, mcp_execution_ids = ? WHERE id = ?",
-					result.Response,
+					resText,
 					mcpIDsJSON,
 					assistantMessageID,
 				); updateErr != nil {
 					h.logger.Warn("更新助手消息失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(updateErr))
 					// 如果更新失败，尝试创建新消息
-					_, err = h.db.AddMessage(conversationID, "assistant", result.Response, result.MCPExecutionIDs)
+					_, err = h.db.AddMessage(conversationID, "assistant", resText, mcpIDs)
 					if err != nil {
 						h.logger.Error("保存助手消息失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(err))
 					}
 				}
 			} else {
 				// 如果没有预先创建的助手消息，创建一个新的
-				_, err = h.db.AddMessage(conversationID, "assistant", result.Response, result.MCPExecutionIDs)
+				_, err = h.db.AddMessage(conversationID, "assistant", resText, mcpIDs)
 				if err != nil {
 					h.logger.Error("保存助手消息失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID), zap.Error(err))
 				}
 			}
 
 			// 保存ReAct数据
-			if result.LastReActInput != "" || result.LastReActOutput != "" {
-				if err := h.db.SaveReActData(conversationID, result.LastReActInput, result.LastReActOutput); err != nil {
+			if lastIn != "" || lastOut != "" {
+				if err := h.db.SaveReActData(conversationID, lastIn, lastOut); err != nil {
 					h.logger.Warn("保存ReAct数据失败", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.Error(err))
 				} else {
 					h.logger.Info("已保存ReAct数据", zap.String("queueId", queueID), zap.String("taskId", task.ID), zap.String("conversationId", conversationID))
@@ -1663,7 +1761,7 @@ func (h *AgentHandler) executeBatchQueue(queueID string) {
 			}
 
 			// 保存结果
-			h.batchTaskManager.UpdateTaskStatusWithConversationID(queueID, task.ID, "completed", result.Response, "", conversationID)
+			h.batchTaskManager.UpdateTaskStatusWithConversationID(queueID, task.ID, "completed", resText, "", conversationID)
 		}
 
 		// 移动到下一个任务

internal/handler/config.go

@@ -12,6 +12,7 @@ import (
 	"sync"
 	"time"
 
+	"cyberstrike-ai/internal/agents"
 	"cyberstrike-ai/internal/config"
 	"cyberstrike-ai/internal/knowledge"
 	"cyberstrike-ai/internal/mcp"
@@ -168,13 +169,14 @@ func (h *ConfigHandler) SetRobotRestarter(restarter RobotRestarter) {
 
 // GetConfigResponse 获取配置响应
 type GetConfigResponse struct {
-	OpenAI    config.OpenAIConfig    `json:"openai"`
-	FOFA      config.FofaConfig      `json:"fofa"`
-	MCP       config.MCPConfig       `json:"mcp"`
-	Tools     []ToolConfigInfo       `json:"tools"`
-	Agent     config.AgentConfig     `json:"agent"`
-	Knowledge config.KnowledgeConfig `json:"knowledge"`
-	Robots    config.RobotsConfig     `json:"robots,omitempty"`
+	OpenAI     config.OpenAIConfig     `json:"openai"`
+	FOFA       config.FofaConfig       `json:"fofa"`
+	MCP        config.MCPConfig        `json:"mcp"`
+	Tools      []ToolConfigInfo        `json:"tools"`
+	Agent      config.AgentConfig      `json:"agent"`
+	Knowledge  config.KnowledgeConfig  `json:"knowledge"`
+	Robots     config.RobotsConfig     `json:"robots,omitempty"`
+	MultiAgent config.MultiAgentPublic `json:"multi_agent,omitempty"`
 }
 
 // ToolConfigInfo 工具配置信息
@@ -240,14 +242,37 @@ func (h *ConfigHandler) GetConfig(c *gin.Context) {
 		}
 	}
 
+	subAgentCount := len(h.config.MultiAgent.SubAgents)
+	agentsDir := strings.TrimSpace(h.config.AgentsDir)
+	if agentsDir == "" {
+		agentsDir = "agents"
+	}
+	if !filepath.IsAbs(agentsDir) {
+		agentsDir = filepath.Join(filepath.Dir(h.configPath), agentsDir)
+	}
+	if load, err := agents.LoadMarkdownAgentsDir(agentsDir); err == nil {
+		subAgentCount = len(agents.MergeYAMLAndMarkdown(h.config.MultiAgent.SubAgents, load.SubAgents))
+	}
+	multiPub := config.MultiAgentPublic{
+		Enabled:            h.config.MultiAgent.Enabled,
+		DefaultMode:        h.config.MultiAgent.DefaultMode,
+		RobotUseMultiAgent: h.config.MultiAgent.RobotUseMultiAgent,
+		BatchUseMultiAgent: h.config.MultiAgent.BatchUseMultiAgent,
+		SubAgentCount:      subAgentCount,
+	}
+	if strings.TrimSpace(multiPub.DefaultMode) == "" {
+		multiPub.DefaultMode = "single"
+	}
+
 	c.JSON(http.StatusOK, GetConfigResponse{
-		OpenAI:    h.config.OpenAI,
-		FOFA:      h.config.FOFA,
-		MCP:       h.config.MCP,
-		Tools:     tools,
-		Agent:     h.config.Agent,
-		Knowledge: h.config.Knowledge,
-		Robots:    h.config.Robots,
+		OpenAI:     h.config.OpenAI,
+		FOFA:       h.config.FOFA,
+		MCP:        h.config.MCP,
+		Tools:      tools,
+		Agent:      h.config.Agent,
+		Knowledge:  h.config.Knowledge,
+		Robots:     h.config.Robots,
+		MultiAgent: multiPub,
 	})
 }
 
@@ -499,13 +524,14 @@ func (h *ConfigHandler) GetTools(c *gin.Context) {
 
 // UpdateConfigRequest 更新配置请求
 type UpdateConfigRequest struct {
-	OpenAI    *config.OpenAIConfig    `json:"openai,omitempty"`
-	FOFA      *config.FofaConfig      `json:"fofa,omitempty"`
-	MCP       *config.MCPConfig       `json:"mcp,omitempty"`
-	Tools     []ToolEnableStatus      `json:"tools,omitempty"`
-	Agent     *config.AgentConfig     `json:"agent,omitempty"`
-	Knowledge *config.KnowledgeConfig `json:"knowledge,omitempty"`
-	Robots    *config.RobotsConfig    `json:"robots,omitempty"`
+	OpenAI     *config.OpenAIConfig        `json:"openai,omitempty"`
+	FOFA       *config.FofaConfig          `json:"fofa,omitempty"`
+	MCP        *config.MCPConfig           `json:"mcp,omitempty"`
+	Tools      []ToolEnableStatus          `json:"tools,omitempty"`
+	Agent      *config.AgentConfig         `json:"agent,omitempty"`
+	Knowledge  *config.KnowledgeConfig     `json:"knowledge,omitempty"`
+	Robots     *config.RobotsConfig        `json:"robots,omitempty"`
+	MultiAgent *config.MultiAgentAPIUpdate `json:"multi_agent,omitempty"`
 }
 
 // ToolEnableStatus 工具启用状态
@@ -592,6 +618,23 @@ func (h *ConfigHandler) UpdateConfig(c *gin.Context) {
 		)
 	}
 
+	// 多代理标量（sub_agents 等仍由 config.yaml 维护）
+	if req.MultiAgent != nil {
+		h.config.MultiAgent.Enabled = req.MultiAgent.Enabled
+		dm := strings.TrimSpace(req.MultiAgent.DefaultMode)
+		if dm == "multi" || dm == "single" {
+			h.config.MultiAgent.DefaultMode = dm
+		}
+		h.config.MultiAgent.RobotUseMultiAgent = req.MultiAgent.RobotUseMultiAgent
+		h.config.MultiAgent.BatchUseMultiAgent = req.MultiAgent.BatchUseMultiAgent
+		h.logger.Info("更新多代理配置",
+			zap.Bool("enabled", h.config.MultiAgent.Enabled),
+			zap.String("default_mode", h.config.MultiAgent.DefaultMode),
+			zap.Bool("robot_use_multi_agent", h.config.MultiAgent.RobotUseMultiAgent),
+			zap.Bool("batch_use_multi_agent", h.config.MultiAgent.BatchUseMultiAgent),
+		)
+	}
+
 	// 更新工具启用状态
 	if req.Tools != nil {
 		// 分离内部工具和外部工具
@@ -910,6 +953,7 @@ func (h *ConfigHandler) saveConfig() error {
 	updateFOFAConfig(root, h.config.FOFA)
 	updateKnowledgeConfig(root, h.config.Knowledge)
 	updateRobotsConfig(root, h.config.Robots)
+	updateMultiAgentConfig(root, h.config.MultiAgent)
 	// 更新外部MCP配置（使用external_mcp.go中的函数，同一包中可直接调用）
 	// 读取原始配置以保持向后兼容
 	originalConfigs := make(map[string]map[string]bool)
@@ -1119,6 +1163,15 @@ func updateRobotsConfig(doc *yaml.Node, cfg config.RobotsConfig) {
 	setStringInMap(larkNode, "verify_token", cfg.Lark.VerifyToken)
 }
 
+func updateMultiAgentConfig(doc *yaml.Node, cfg config.MultiAgentConfig) {
+	root := doc.Content[0]
+	maNode := ensureMap(root, "multi_agent")
+	setBoolInMap(maNode, "enabled", cfg.Enabled)
+	setStringInMap(maNode, "default_mode", cfg.DefaultMode)
+	setBoolInMap(maNode, "robot_use_multi_agent", cfg.RobotUseMultiAgent)
+	setBoolInMap(maNode, "batch_use_multi_agent", cfg.BatchUseMultiAgent)
+}
+
 func ensureMap(parent *yaml.Node, path ...string) *yaml.Node {
 	current := parent
 	for _, key := range path {

internal/handler/markdown_agents.go

@@ -0,0 +1,299 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"cyberstrike-ai/internal/agents"
+	"cyberstrike-ai/internal/config"
+
+	"github.com/gin-gonic/gin"
+)
+
+var markdownAgentFilenameRe = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9_.-]*\.md$`)
+
+// MarkdownAgentsHandler 管理 agents 目录下子代理 Markdown（增删改查）。
+type MarkdownAgentsHandler struct {
+	dir string
+}
+
+// NewMarkdownAgentsHandler dir 须为已解析的绝对路径。
+func NewMarkdownAgentsHandler(dir string) *MarkdownAgentsHandler {
+	return &MarkdownAgentsHandler{dir: strings.TrimSpace(dir)}
+}
+
+func (h *MarkdownAgentsHandler) safeJoin(filename string) (string, error) {
+	filename = strings.TrimSpace(filename)
+	if filename == "" || !markdownAgentFilenameRe.MatchString(filename) {
+		return "", fmt.Errorf("非法文件名")
+	}
+	clean := filepath.Clean(filename)
+	if clean != filename || strings.Contains(clean, "..") {
+		return "", fmt.Errorf("非法文件名")
+	}
+	return filepath.Join(h.dir, clean), nil
+}
+
+// existingOtherOrchestrator 若目录中已有别的主代理文件，返回其文件名；writingBasename 为当前正在写入的文件名时视为同一文件不冲突。
+func existingOtherOrchestrator(dir, writingBasename string) (other string, err error) {
+	load, err := agents.LoadMarkdownAgentsDir(dir)
+	if err != nil {
+		return "", err
+	}
+	if load.Orchestrator == nil {
+		return "", nil
+	}
+	if strings.EqualFold(load.Orchestrator.Filename, writingBasename) {
+		return "", nil
+	}
+	return load.Orchestrator.Filename, nil
+}
+
+// ListMarkdownAgents GET /api/multi-agent/markdown-agents
+func (h *MarkdownAgentsHandler) ListMarkdownAgents(c *gin.Context) {
+	if h.dir == "" {
+		c.JSON(http.StatusOK, gin.H{"agents": []any{}, "dir": "", "error": "未配置 agents 目录"})
+		return
+	}
+	files, err := agents.LoadMarkdownAgentFiles(h.dir)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	out := make([]gin.H, 0, len(files))
+	for _, fa := range files {
+		sub := fa.Config
+		out = append(out, gin.H{
+			"filename":        fa.Filename,
+			"id":              sub.ID,
+			"name":            sub.Name,
+			"description":     sub.Description,
+			"is_orchestrator": fa.IsOrchestrator,
+			"kind":            sub.Kind,
+		})
+	}
+	c.JSON(http.StatusOK, gin.H{"agents": out, "dir": h.dir})
+}
+
+// GetMarkdownAgent GET /api/multi-agent/markdown-agents/:filename
+func (h *MarkdownAgentsHandler) GetMarkdownAgent(c *gin.Context) {
+	filename := c.Param("filename")
+	path, err := h.safeJoin(filename)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	b, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			c.JSON(http.StatusNotFound, gin.H{"error": "文件不存在"})
+			return
+		}
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	sub, err := agents.ParseMarkdownSubAgent(filename, string(b))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	isOrch := agents.IsOrchestratorMarkdown(filename, agents.FrontMatter{Kind: sub.Kind})
+	c.JSON(http.StatusOK, gin.H{
+		"filename":        filename,
+		"raw":             string(b),
+		"id":              sub.ID,
+		"name":            sub.Name,
+		"description":     sub.Description,
+		"tools":           sub.RoleTools,
+		"instruction":     sub.Instruction,
+		"bind_role":       sub.BindRole,
+		"max_iterations":  sub.MaxIterations,
+		"kind":            sub.Kind,
+		"is_orchestrator": isOrch,
+	})
+}
+
+type markdownAgentBody struct {
+	Filename       string   `json:"filename"`
+	ID             string   `json:"id"`
+	Name           string   `json:"name"`
+	Description    string   `json:"description"`
+	Tools          []string `json:"tools"`
+	Instruction    string   `json:"instruction"`
+	BindRole       string   `json:"bind_role"`
+	MaxIterations  int      `json:"max_iterations"`
+	Kind           string   `json:"kind"`
+	Raw            string   `json:"raw"`
+}
+
+// CreateMarkdownAgent POST /api/multi-agent/markdown-agents
+func (h *MarkdownAgentsHandler) CreateMarkdownAgent(c *gin.Context) {
+	if h.dir == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "未配置 agents 目录"})
+		return
+	}
+	var body markdownAgentBody
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	filename := strings.TrimSpace(body.Filename)
+	if filename == "" {
+		if strings.EqualFold(strings.TrimSpace(body.Kind), "orchestrator") {
+			filename = agents.OrchestratorMarkdownFilename
+		} else {
+			base := agents.SlugID(body.Name)
+			if base == "" {
+				base = "agent"
+			}
+			filename = base + ".md"
+		}
+	}
+	path, err := h.safeJoin(filename)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	if _, err := os.Stat(path); err == nil {
+		c.JSON(http.StatusConflict, gin.H{"error": "文件已存在"})
+		return
+	}
+	sub := config.MultiAgentSubConfig{
+		ID:            strings.TrimSpace(body.ID),
+		Name:          strings.TrimSpace(body.Name),
+		Description:   strings.TrimSpace(body.Description),
+		Instruction:   strings.TrimSpace(body.Instruction),
+		RoleTools:     body.Tools,
+		BindRole:      strings.TrimSpace(body.BindRole),
+		MaxIterations: body.MaxIterations,
+		Kind:          strings.TrimSpace(body.Kind),
+	}
+	if strings.EqualFold(filepath.Base(path), agents.OrchestratorMarkdownFilename) && sub.Kind == "" {
+		sub.Kind = "orchestrator"
+	}
+	if sub.ID == "" {
+		sub.ID = agents.SlugID(sub.Name)
+	}
+	if sub.Name == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "name 必填"})
+		return
+	}
+	var out []byte
+	if strings.TrimSpace(body.Raw) != "" {
+		out = []byte(body.Raw)
+	} else {
+		out, err = agents.BuildMarkdownFile(sub)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+	}
+	if want := agents.WantsMarkdownOrchestrator(filepath.Base(path), body.Kind, string(out)); want {
+		other, oerr := existingOtherOrchestrator(h.dir, filepath.Base(path))
+		if oerr != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": oerr.Error()})
+			return
+		}
+		if other != "" {
+			c.JSON(http.StatusConflict, gin.H{"error": fmt.Sprintf("已存在主代理定义：%s，请先删除或取消其主代理标记", other)})
+			return
+		}
+	}
+	if err := os.MkdirAll(h.dir, 0755); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	if err := os.WriteFile(path, out, 0644); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"filename": filepath.Base(path), "message": "已创建"})
+}
+
+// UpdateMarkdownAgent PUT /api/multi-agent/markdown-agents/:filename
+func (h *MarkdownAgentsHandler) UpdateMarkdownAgent(c *gin.Context) {
+	filename := c.Param("filename")
+	path, err := h.safeJoin(filename)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	var body markdownAgentBody
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	sub := config.MultiAgentSubConfig{
+		ID:            strings.TrimSpace(body.ID),
+		Name:          strings.TrimSpace(body.Name),
+		Description:   strings.TrimSpace(body.Description),
+		Instruction:   strings.TrimSpace(body.Instruction),
+		RoleTools:     body.Tools,
+		BindRole:      strings.TrimSpace(body.BindRole),
+		MaxIterations: body.MaxIterations,
+		Kind:          strings.TrimSpace(body.Kind),
+	}
+	if strings.EqualFold(filename, agents.OrchestratorMarkdownFilename) && sub.Kind == "" {
+		sub.Kind = "orchestrator"
+	}
+	if sub.Name == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "name 必填"})
+		return
+	}
+	if sub.ID == "" {
+		sub.ID = agents.SlugID(sub.Name)
+	}
+	var out []byte
+	if strings.TrimSpace(body.Raw) != "" {
+		out = []byte(body.Raw)
+	} else {
+		out, err = agents.BuildMarkdownFile(sub)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+	}
+	if want := agents.WantsMarkdownOrchestrator(filename, body.Kind, string(out)); want {
+		other, oerr := existingOtherOrchestrator(h.dir, filename)
+		if oerr != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": oerr.Error()})
+			return
+		}
+		if other != "" {
+			c.JSON(http.StatusConflict, gin.H{"error": fmt.Sprintf("已存在主代理定义：%s，请先删除或取消其主代理标记", other)})
+			return
+		}
+	}
+	if err := os.WriteFile(path, out, 0644); err != nil {
+		if os.IsNotExist(err) {
+			c.JSON(http.StatusNotFound, gin.H{"error": "文件不存在"})
+			return
+		}
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "已保存"})
+}
+
+// DeleteMarkdownAgent DELETE /api/multi-agent/markdown-agents/:filename
+func (h *MarkdownAgentsHandler) DeleteMarkdownAgent(c *gin.Context) {
+	filename := c.Param("filename")
+	path, err := h.safeJoin(filename)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+	if err := os.Remove(path); err != nil {
+		if os.IsNotExist(err) {
+			c.JSON(http.StatusNotFound, gin.H{"error": "文件不存在"})
+			return
+		}
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "已删除"})
+}

internal/handler/multi_agent.go

@@ -0,0 +1,289 @@
+package handler
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"cyberstrike-ai/internal/multiagent"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// MultiAgentLoopStream Eino DeepAgent 流式对话（需 config.multi_agent.enabled）。
+func (h *AgentHandler) MultiAgentLoopStream(c *gin.Context) {
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+	if h.config == nil || !h.config.MultiAgent.Enabled {
+		ev := StreamEvent{Type: "error", Message: "多代理未启用，请在设置或 config.yaml 中开启 multi_agent.enabled"}
+		b, _ := json.Marshal(ev)
+		fmt.Fprintf(c.Writer, "data: %s\n\n", b)
+		done := StreamEvent{Type: "done", Message: ""}
+		db, _ := json.Marshal(done)
+		fmt.Fprintf(c.Writer, "data: %s\n\n", db)
+		if flusher, ok := c.Writer.(http.Flusher); ok {
+			flusher.Flush()
+		}
+		return
+	}
+
+	var req ChatRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		event := StreamEvent{Type: "error", Message: "请求参数错误: " + err.Error()}
+		b, _ := json.Marshal(event)
+		fmt.Fprintf(c.Writer, "data: %s\n\n", b)
+		c.Writer.Flush()
+		return
+	}
+
+	c.Header("X-Accel-Buffering", "no")
+
+	clientDisconnected := false
+	sendEvent := func(eventType, message string, data interface{}) {
+		if clientDisconnected {
+			return
+		}
+		select {
+		case <-c.Request.Context().Done():
+			clientDisconnected = true
+			return
+		default:
+		}
+		ev := StreamEvent{Type: eventType, Message: message, Data: data}
+		b, _ := json.Marshal(ev)
+		if _, err := fmt.Fprintf(c.Writer, "data: %s\n\n", b); err != nil {
+			clientDisconnected = true
+			return
+		}
+		if flusher, ok := c.Writer.(http.Flusher); ok {
+			flusher.Flush()
+		} else {
+			c.Writer.Flush()
+		}
+	}
+
+	h.logger.Info("收到 Eino DeepAgent 流式请求",
+		zap.String("conversationId", req.ConversationID),
+	)
+
+	prep, err := h.prepareMultiAgentSession(&req)
+	if err != nil {
+		sendEvent("error", err.Error(), nil)
+		sendEvent("done", "", nil)
+		return
+	}
+	if prep.CreatedNew {
+		sendEvent("conversation", "会话已创建", map[string]interface{}{
+			"conversationId": prep.ConversationID,
+		})
+	}
+
+	conversationID := prep.ConversationID
+	assistantMessageID := prep.AssistantMessageID
+
+	progressCallback := h.createProgressCallback(conversationID, assistantMessageID, sendEvent)
+
+	baseCtx, cancelWithCause := context.WithCancelCause(context.Background())
+	taskCtx, timeoutCancel := context.WithTimeout(baseCtx, 600*time.Minute)
+	defer timeoutCancel()
+	defer cancelWithCause(nil)
+
+	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 = ? WHERE id = ?", errorMsg, assistantMessageID)
+		}
+		sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
+		return
+	}
+
+	taskStatus := "completed"
+	defer h.tasks.FinishTask(conversationID, taskStatus)
+
+	sendEvent("progress", "正在启动 Eino DeepAgent...", map[string]interface{}{
+		"conversationId": conversationID,
+	})
+
+	result, runErr := multiagent.RunDeepAgent(
+		taskCtx,
+		h.config,
+		&h.config.MultiAgent,
+		h.agent,
+		h.logger,
+		conversationID,
+		prep.FinalMessage,
+		prep.History,
+		prep.RoleTools,
+		progressCallback,
+		h.agentsMarkdownDir,
+	)
+
+	if runErr != nil {
+		h.logger.Error("Eino DeepAgent 执行失败", zap.Error(runErr))
+		cause := context.Cause(baseCtx)
+		if errors.Is(cause, ErrTaskCancelled) {
+			taskStatus = "cancelled"
+			h.tasks.UpdateTaskStatus(conversationID, taskStatus)
+			cancelMsg := "任务已被用户取消，后续操作已停止。"
+			if assistantMessageID != "" {
+				_, _ = h.db.Exec("UPDATE messages SET content = ? WHERE id = ?", cancelMsg, assistantMessageID)
+				_ = h.db.AddProcessDetail(assistantMessageID, conversationID, "cancelled", cancelMsg, nil)
+			}
+			sendEvent("cancelled", cancelMsg, map[string]interface{}{
+				"conversationId": conversationID,
+				"messageId":      assistantMessageID,
+			})
+			sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
+			return
+		}
+
+		taskStatus = "failed"
+		h.tasks.UpdateTaskStatus(conversationID, taskStatus)
+		errMsg := "执行失败: " + runErr.Error()
+		if assistantMessageID != "" {
+			_, _ = h.db.Exec("UPDATE messages SET content = ? WHERE id = ?", errMsg, assistantMessageID)
+			_ = h.db.AddProcessDetail(assistantMessageID, conversationID, "error", errMsg, nil)
+		}
+		sendEvent("error", errMsg, map[string]interface{}{
+			"conversationId": conversationID,
+			"messageId":      assistantMessageID,
+		})
+		sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
+		return
+	}
+
+	if assistantMessageID != "" {
+		mcpIDsJSON := ""
+		if len(result.MCPExecutionIDs) > 0 {
+			jsonData, _ := json.Marshal(result.MCPExecutionIDs)
+			mcpIDsJSON = string(jsonData)
+		}
+		_, _ = h.db.Exec(
+			"UPDATE messages SET content = ?, mcp_execution_ids = ? WHERE id = ?",
+			result.Response,
+			mcpIDsJSON,
+			assistantMessageID,
+		)
+	}
+
+	if result.LastReActInput != "" || result.LastReActOutput != "" {
+		if err := h.db.SaveReActData(conversationID, result.LastReActInput, result.LastReActOutput); err != nil {
+			h.logger.Warn("保存 ReAct 数据失败", zap.Error(err))
+		}
+	}
+
+	sendEvent("response", result.Response, map[string]interface{}{
+		"mcpExecutionIds": result.MCPExecutionIDs,
+		"conversationId":  conversationID,
+		"messageId":       assistantMessageID,
+		"agentMode":       "eino_deep",
+	})
+	sendEvent("done", "", map[string]interface{}{"conversationId": conversationID})
+}
+
+// MultiAgentLoop Eino DeepAgent 非流式对话（与 POST /api/agent-loop 对齐，需 multi_agent.enabled）。
+func (h *AgentHandler) MultiAgentLoop(c *gin.Context) {
+	if h.config == nil || !h.config.MultiAgent.Enabled {
+		c.JSON(http.StatusNotFound, gin.H{"error": "多代理未启用，请在 config.yaml 中设置 multi_agent.enabled: true"})
+		return
+	}
+
+	var req ChatRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	h.logger.Info("收到 Eino DeepAgent 非流式请求", zap.String("conversationId", req.ConversationID))
+
+	prep, err := h.prepareMultiAgentSession(&req)
+	if err != nil {
+		status, msg := multiAgentHTTPErrorStatus(err)
+		c.JSON(status, gin.H{"error": msg})
+		return
+	}
+
+	result, runErr := multiagent.RunDeepAgent(
+		c.Request.Context(),
+		h.config,
+		&h.config.MultiAgent,
+		h.agent,
+		h.logger,
+		prep.ConversationID,
+		prep.FinalMessage,
+		prep.History,
+		prep.RoleTools,
+		nil,
+		h.agentsMarkdownDir,
+	)
+	if runErr != nil {
+		h.logger.Error("Eino DeepAgent 执行失败", zap.Error(runErr))
+		errMsg := "执行失败: " + runErr.Error()
+		if prep.AssistantMessageID != "" {
+			_, _ = h.db.Exec("UPDATE messages SET content = ? WHERE id = ?", errMsg, prep.AssistantMessageID)
+		}
+		c.JSON(http.StatusInternalServerError, gin.H{"error": errMsg})
+		return
+	}
+
+	if prep.AssistantMessageID != "" {
+		mcpIDsJSON := ""
+		if len(result.MCPExecutionIDs) > 0 {
+			jsonData, _ := json.Marshal(result.MCPExecutionIDs)
+			mcpIDsJSON = string(jsonData)
+		}
+		_, _ = h.db.Exec(
+			"UPDATE messages SET content = ?, mcp_execution_ids = ? WHERE id = ?",
+			result.Response,
+			mcpIDsJSON,
+			prep.AssistantMessageID,
+		)
+	}
+
+	if result.LastReActInput != "" || result.LastReActOutput != "" {
+		if err := h.db.SaveReActData(prep.ConversationID, result.LastReActInput, result.LastReActOutput); err != nil {
+			h.logger.Warn("保存 ReAct 数据失败", zap.Error(err))
+		}
+	}
+
+	c.JSON(http.StatusOK, ChatResponse{
+		Response:        result.Response,
+		MCPExecutionIDs: result.MCPExecutionIDs,
+		ConversationID:  prep.ConversationID,
+		Time:            time.Now(),
+	})
+}
+
+func multiAgentHTTPErrorStatus(err error) (int, string) {
+	msg := err.Error()
+	switch {
+	case strings.Contains(msg, "对话不存在"):
+		return http.StatusNotFound, msg
+	case strings.Contains(msg, "未找到该 WebShell"):
+		return http.StatusBadRequest, msg
+	case strings.Contains(msg, "附件最多"):
+		return http.StatusBadRequest, msg
+	case strings.Contains(msg, "保存用户消息失败"), strings.Contains(msg, "创建对话失败"):
+		return http.StatusInternalServerError, msg
+	case strings.Contains(msg, "保存上传文件失败"):
+		return http.StatusInternalServerError, msg
+	default:
+		return http.StatusBadRequest, msg
+	}
+}

internal/handler/multi_agent_prepare.go

@@ -0,0 +1,133 @@
+package handler
+
+import (
+	"fmt"
+	"strings"
+
+	"cyberstrike-ai/internal/agent"
+	"cyberstrike-ai/internal/database"
+	"cyberstrike-ai/internal/mcp/builtin"
+
+	"go.uber.org/zap"
+)
+
+// multiAgentPrepared 多代理请求在调用 Eino 前的会话与消息准备结果。
+type multiAgentPrepared struct {
+	ConversationID     string
+	CreatedNew         bool
+	History            []agent.ChatMessage
+	FinalMessage       string
+	RoleTools          []string
+	AssistantMessageID string
+}
+
+func (h *AgentHandler) prepareMultiAgentSession(req *ChatRequest) (*multiAgentPrepared, error) {
+	if len(req.Attachments) > maxAttachments {
+		return nil, fmt.Errorf("附件最多 %d 个", maxAttachments)
+	}
+
+	conversationID := strings.TrimSpace(req.ConversationID)
+	createdNew := false
+	if conversationID == "" {
+		title := safeTruncateString(req.Message, 50)
+		var conv *database.Conversation
+		var err error
+		if strings.TrimSpace(req.WebShellConnectionID) != "" {
+			conv, err = h.db.CreateConversationWithWebshell(strings.TrimSpace(req.WebShellConnectionID), title)
+		} else {
+			conv, err = h.db.CreateConversation(title)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("创建对话失败: %w", err)
+		}
+		conversationID = conv.ID
+		createdNew = true
+	} else {
+		if _, err := h.db.GetConversation(conversationID); err != nil {
+			return nil, fmt.Errorf("对话不存在")
+		}
+	}
+
+	agentHistoryMessages, err := h.loadHistoryFromReActData(conversationID)
+	if err != nil {
+		historyMessages, getErr := h.db.GetMessages(conversationID)
+		if getErr != nil {
+			agentHistoryMessages = []agent.ChatMessage{}
+		} else {
+			agentHistoryMessages = make([]agent.ChatMessage, 0, len(historyMessages))
+			for _, msg := range historyMessages {
+				agentHistoryMessages = append(agentHistoryMessages, agent.ChatMessage{
+					Role:    msg.Role,
+					Content: msg.Content,
+				})
+			}
+		}
+	}
+
+	finalMessage := req.Message
+	var roleTools []string
+	if req.WebShellConnectionID != "" {
+		conn, errConn := h.db.GetWebshellConnection(strings.TrimSpace(req.WebShellConnectionID))
+		if errConn != nil || conn == nil {
+			h.logger.Warn("WebShell AI 助手：未找到连接", zap.String("id", req.WebShellConnectionID), zap.Error(errConn))
+			return nil, fmt.Errorf("未找到该 WebShell 连接")
+		}
+		remark := conn.Remark
+		if remark == "" {
+			remark = conn.URL
+		}
+		finalMessage = fmt.Sprintf("[WebShell 助手上下文] 当前连接 ID：%s，备注：%s。可用工具（仅在该连接上操作时使用，connection_id 填 \"%s\"）：webshell_exec、webshell_file_list、webshell_file_read、webshell_file_write、record_vulnerability、list_knowledge_risk_types、search_knowledge_base、list_skills、read_skill。请根据用户输入决定下一步：若仅为问候、闲聊或简单问题，直接简短回复即可，不必调用工具；当用户明确需要执行命令、列目录、读写文件、记录漏洞或检索知识库/查看 Skills 等操作时再调用上述工具。\n\n用户请求：%s",
+			conn.ID, remark, conn.ID, req.Message)
+		roleTools = []string{
+			builtin.ToolWebshellExec,
+			builtin.ToolWebshellFileList,
+			builtin.ToolWebshellFileRead,
+			builtin.ToolWebshellFileWrite,
+			builtin.ToolRecordVulnerability,
+			builtin.ToolListKnowledgeRiskTypes,
+			builtin.ToolSearchKnowledgeBase,
+			builtin.ToolListSkills,
+			builtin.ToolReadSkill,
+		}
+	} else if req.Role != "" && req.Role != "默认" && h.config != nil && h.config.Roles != nil {
+		if role, exists := h.config.Roles[req.Role]; exists && role.Enabled {
+			if role.UserPrompt != "" {
+				finalMessage = role.UserPrompt + "\n\n" + req.Message
+			}
+			roleTools = role.Tools
+		}
+	}
+
+	var savedPaths []string
+	if len(req.Attachments) > 0 {
+		var aerr error
+		savedPaths, aerr = saveAttachmentsToDateAndConversationDir(req.Attachments, conversationID, h.logger)
+		if aerr != nil {
+			return nil, fmt.Errorf("保存上传文件失败: %w", aerr)
+		}
+	}
+	finalMessage = appendAttachmentsToMessage(finalMessage, req.Attachments, savedPaths)
+
+	userContent := userMessageContentForStorage(req.Message, req.Attachments, savedPaths)
+	if _, err = h.db.AddMessage(conversationID, "user", userContent, nil); err != nil {
+		h.logger.Error("保存用户消息失败", zap.Error(err))
+		return nil, fmt.Errorf("保存用户消息失败: %w", err)
+	}
+
+	assistantMsg, aerr := h.db.AddMessage(conversationID, "assistant", "处理中...", nil)
+	var assistantMessageID string
+	if aerr != nil {
+		h.logger.Warn("创建助手消息占位失败", zap.Error(aerr))
+	} else if assistantMsg != nil {
+		assistantMessageID = assistantMsg.ID
+	}
+
+	return &multiAgentPrepared{
+		ConversationID:     conversationID,
+		CreatedNew:         createdNew,
+		History:            agentHistoryMessages,
+		FinalMessage:       finalMessage,
+		RoleTools:          roleTools,
+		AssistantMessageID: assistantMessageID,
+	}, nil
+}

internal/handler/openapi.go

@@ -1481,6 +1481,91 @@ func (h *OpenAPIHandler) GetOpenAPISpec(c *gin.Context) {
 					},
 				},
 			},
+			"/api/multi-agent": map[string]interface{}{
+				"post": map[string]interface{}{
+					"tags":        []string{"对话交互"},
+					"summary":     "发送消息并获取 AI 回复（Eino DeepAgent，非流式）",
+					"description": "与 `POST /api/agent-loop` 请求体相同，但由 **CloudWeGo Eino DeepAgent** 执行多代理编排。**前提**：`multi_agent.enabled: true`（可在设置页或 `config.yaml` 开启）；未启用时返回 404 JSON。请求体支持 `webshellConnectionId`（与单代理 WebShell 助手一致）。",
+					"operationId": "sendMessageMultiAgent",
+					"requestBody": map[string]interface{}{
+						"required": true,
+						"content": map[string]interface{}{
+							"application/json": map[string]interface{}{
+								"schema": map[string]interface{}{
+									"type": "object",
+									"properties": map[string]interface{}{
+										"message": map[string]interface{}{
+											"type":        "string",
+											"description": "要发送的消息（必需）",
+										},
+										"conversationId": map[string]interface{}{
+											"type":        "string",
+											"description": "对话 ID（可选，不提供则新建）",
+										},
+										"role": map[string]interface{}{
+											"type":        "string",
+											"description": "角色名称（可选）",
+										},
+										"webshellConnectionId": map[string]interface{}{
+											"type":        "string",
+											"description": "WebShell 连接 ID（可选，与 agent-loop 行为一致）",
+										},
+									},
+									"required": []string{"message"},
+								},
+							},
+						},
+					},
+					"responses": map[string]interface{}{
+						"200": map[string]interface{}{
+							"description": "成功，响应格式同 /api/agent-loop",
+						},
+						"400": map[string]interface{}{"description": "参数错误"},
+						"401": map[string]interface{}{"description": "未授权"},
+						"404": map[string]interface{}{"description": "多代理未启用或对话不存在"},
+						"500": map[string]interface{}{"description": "执行失败"},
+					},
+				},
+			},
+			"/api/multi-agent/stream": map[string]interface{}{
+				"post": map[string]interface{}{
+					"tags":        []string{"对话交互"},
+					"summary":     "发送消息并获取 AI 回复（Eino DeepAgent，SSE）",
+					"description": "与 `POST /api/agent-loop/stream` 类似，事件类型兼容；由 Eino DeepAgent 执行。**前提**：`multi_agent.enabled: true`；路由常注册，未启用时仍返回 200 SSE，流内首条为 `type: error` 后接 `done`。支持 `webshellConnectionId`。",
+					"operationId": "sendMessageMultiAgentStream",
+					"requestBody": map[string]interface{}{
+						"required": true,
+						"content": map[string]interface{}{
+							"application/json": map[string]interface{}{
+								"schema": map[string]interface{}{
+									"type": "object",
+									"properties": map[string]interface{}{
+										"message":            map[string]interface{}{"type": "string"},
+										"conversationId":     map[string]interface{}{"type": "string"},
+										"role":               map[string]interface{}{"type": "string"},
+										"webshellConnectionId": map[string]interface{}{"type": "string"},
+									},
+									"required": []string{"message"},
+								},
+							},
+						},
+					},
+					"responses": map[string]interface{}{
+						"200": map[string]interface{}{
+							"description": "text/event-stream（SSE）",
+							"content": map[string]interface{}{
+								"text/event-stream": map[string]interface{}{
+									"schema": map[string]interface{}{
+										"type":        "string",
+										"description": "SSE 流",
+									},
+								},
+							},
+						},
+						"401": map[string]interface{}{"description": "未授权"},
+					},
+				},
+			},
 			"/api/agent-loop/cancel": map[string]interface{}{
 				"post": map[string]interface{}{
 					"tags":        []string{"对话交互"},