Add files via upload

2026-03-30 16:00:39 +02:00 · 2026-03-23 02:15:46 +08:00
parent ea5a81e14e
commit a31c4996c7
16 changed files with 2533 additions and 86 deletions
--- a/README.md
+++ b/README.md
@@ -92,6 +92,7 @@ CyberStrikeAI is an **AI-native security testing platform** built in Go. It inte
 - 🛡️ Vulnerability management with CRUD operations, severity tracking, status workflow, and statistics
 - 📋 Batch task management: create task queues, add multiple tasks, and execute them sequentially
 - 🎭 Role-based testing: predefined security testing roles (Penetration Testing, CTF, Web App Scanning, etc.) with custom prompts and tool restrictions
+- 🧩 **Multi-agent mode (Eino DeepAgent)**: optional orchestration where a coordinator delegates work to Markdown-defined sub-agents via the `task` tool; main agent in `agents/orchestrator.md` (or `kind: orchestrator`), sub-agents under `agents/*.md`; chat mode switch when `multi_agent.enabled` is true (see [Multi-agent doc](docs/MULTI_AGENT_EINO.md))
 - 🎯 Skills system: 20+ predefined security testing skills (SQL injection, XSS, API security, etc.) that can be attached to roles or called on-demand by AI agents
 - 📱 **Chatbot**: DingTalk and Lark (Feishu) long-lived connections so you can talk to CyberStrikeAI from mobile (see [Robot / Chatbot guide](docs/robot_en.md) for setup and commands)
 - 🐚 **WebShell management**: Add and manage WebShell connections (e.g. IceSword/AntSword compatible), use a virtual terminal for command execution, a built-in file manager for file operations, and an AI assistant tab that orchestrates tests and keeps per-connection conversation history; supports PHP, ASP, ASPX, JSP and custom shell types with configurable request method and command parameter.
@@ -195,6 +196,7 @@ Requirements / tips:

 ### Core Workflows
 - **Conversation testing** – Natural-language prompts trigger toolchains with streaming SSE output.
+- **Single vs multi-agent** – With `multi_agent.enabled: true`, the chat UI can switch between **single** (classic ReAct loop) and **multi** (Eino DeepAgent + `task` sub-agents). Multi mode uses `/api/multi-agent/stream`; tools are bridged from the same MCP stack as single-agent.
 - **Role-based testing** – Select from predefined security testing roles (Penetration Testing, CTF, Web App Scanning, API Security Testing, etc.) to customize AI behavior and tool availability. Each role applies custom system prompts and can restrict available tools for focused testing scenarios.
 - **Tool monitor** – Inspect running jobs, execution logs, and large-result attachments.
 - **History & audit** – Every conversation and tool invocation is stored in SQLite with replay.
@@ -238,6 +240,15 @@ Requirements / tips:
   ```
 2. Restart the server or reload configuration; the role appears in the role selector dropdown.

+### Multi-Agent Mode (Eino DeepAgent)
+- **What it is** – An optional second execution path based on CloudWeGo **Eino** `adk/prebuilt/deep`: a **coordinator** (main agent) calls a **`task`** tool to run ephemeral **sub-agents**, each with its own model loop and tool set derived from the current role.
+- **Markdown agents** – Under `agents_dir` (default `agents/`, relative to `config.yaml`), define:
+  - **Orchestrator**: file name `orchestrator.md` *or* any `.md` with front matter `kind: orchestrator` (only **one** per directory). Sets Deep agent name/id, description, and optional full system prompt (body); if the body is empty, `multi_agent.orchestrator_instruction` and then Eino defaults apply.
+  - **Sub-agents**: other `*.md` files (YAML front matter + body as instruction). They are **not** used as `task` targets if classified as orchestrator.
+- **Management** – Web UI: **Agents → Agent management** for CRUD on Markdown agents; API prefix `/api/multi-agent/markdown-agents`.
+- **Config** – `multi_agent` block in `config.yaml`: `enabled`, `default_mode` (`single` | `multi`), `robot_use_multi_agent`, `batch_use_multi_agent`, `max_iteration`, `orchestrator_instruction`, optional YAML `sub_agents` merged with disk (same `id` → Markdown wins).
+- **Details** – Streaming events, robots, batch queue, and troubleshooting: **[docs/MULTI_AGENT_EINO.md](docs/MULTI_AGENT_EINO.md)**.
+
 ### Skills System
 - **Predefined skills** – System includes 20+ predefined security testing skills (SQL injection, XSS, API security, cloud security, container security, etc.) in the `skills/` directory.
 - **Skill hints in prompts** – When a role is selected, skill names attached to that role are added to the system prompt as recommendations. Skill content is not automatically injected; AI agents must use the `read_skill` tool to access skill details when needed.
@@ -428,6 +439,7 @@ A test SSE MCP server is available at `cmd/test-sse-mcp-server/` for validation

 ### Automation Hooks
 - **REST APIs** – everything the UI uses (auth, conversations, tool runs, monitor, vulnerabilities, roles) is available over JSON.
+- **Multi-agent APIs** – `POST /api/multi-agent/stream` (SSE, when enabled), `POST /api/multi-agent` (non-streaming), Markdown agents under `/api/multi-agent/markdown-agents` (list/get/create/update/delete).
 - **Role APIs** – manage security testing roles via `/api/roles` endpoints: `GET /api/roles` (list all roles), `GET /api/roles/:name` (get role), `POST /api/roles` (create role), `PUT /api/roles/:name` (update role), `DELETE /api/roles/:name` (delete role). Roles are stored as YAML files in the `roles/` directory and support hot-reload.
 - **Vulnerability APIs** – manage vulnerabilities via `/api/vulnerabilities` endpoints: `GET /api/vulnerabilities` (list with filters), `POST /api/vulnerabilities` (create), `GET /api/vulnerabilities/:id` (get), `PUT /api/vulnerabilities/:id` (update), `DELETE /api/vulnerabilities/:id` (delete), `GET /api/vulnerabilities/stats` (statistics).
 - **Batch Task APIs** – manage batch task queues via `/api/batch-tasks` endpoints: `POST /api/batch-tasks` (create queue), `GET /api/batch-tasks` (list queues), `GET /api/batch-tasks/:queueId` (get queue), `POST /api/batch-tasks/:queueId/start` (start execution), `POST /api/batch-tasks/:queueId/cancel` (cancel), `DELETE /api/batch-tasks/:queueId` (delete), `POST /api/batch-tasks/:queueId/tasks` (add task), `PUT /api/batch-tasks/:queueId/tasks/:taskId` (update task), `DELETE /api/batch-tasks/:queueId/tasks/:taskId` (delete task). Tasks execute sequentially, each creating a separate conversation with full status tracking.
@@ -476,6 +488,13 @@ knowledge:
    hybrid_weight: 0.7  # Weight for vector search (1.0 = pure vector, 0.0 = pure keyword)
 roles_dir: "roles"  # Role configuration directory (relative to config file)
 skills_dir: "skills"  # Skills directory (relative to config file)
+agents_dir: "agents"  # Multi-agent Markdown definitions (orchestrator + sub-agents)
+multi_agent:
+  enabled: false
+  default_mode: "single"   # single | multi (UI default when multi-agent is enabled)
+  robot_use_multi_agent: false
+  batch_use_multi_agent: false
+  orchestrator_instruction: ""  # Optional; used when orchestrator.md body is empty
 ```

 ### Tool Definition Example (`tools/nmap.yaml`)
@@ -520,6 +539,7 @@ enabled: true

 ## Related documentation

+- [Multi-agent mode (Eino)](docs/MULTI_AGENT_EINO.md): DeepAgent orchestration, `agents/*.md`, APIs, and chat/stream behavior.
 - [Robot / Chatbot guide (DingTalk & Lark)](docs/robot_en.md): Full setup, commands, and troubleshooting for using CyberStrikeAI from DingTalk or Lark on your phone. **Follow this doc to avoid common pitfalls.**

 ## Project Layout
@@ -532,7 +552,8 @@ CyberStrikeAI/
 ├── tools/               # YAML tool recipes (100+ examples provided)
 ├── roles/               # Role configurations (12+ predefined security testing roles)
 ├── skills/              # Skills directory (20+ predefined security testing skills)
-├── docs/                # Documentation (e.g. robot/chbot guide)
+├── agents/              # Multi-agent Markdown (orchestrator.md + sub-agent *.md)
+├── docs/                # Documentation (e.g. robot/chatbot guide, MULTI_AGENT_EINO.md)
 ├── images/              # Docs screenshots & diagrams
 ├── config.yaml          # Runtime configuration
 ├── run.sh               # Convenience launcher
--- a/README_CN.md
+++ b/README_CN.md
@@ -91,6 +91,7 @@ CyberStrikeAI 是一款 **AI 原生安全测试平台**，基于 Go 构建，集
 - 🛡️ 漏洞管理功能：完整的漏洞 CRUD 操作，支持严重程度分级、状态流转、按对话/严重程度/状态过滤，以及统计看板
 - 📋 批量任务管理：创建任务队列，批量添加任务，依次顺序执行，支持任务编辑与状态跟踪
 - 🎭 角色化测试：预设安全测试角色（渗透测试、CTF、Web 应用扫描等），支持自定义提示词和工具限制
+- 🧩 **多代理模式（Eino DeepAgent）**：可选编排——协调主代理通过 `task` 调度 Markdown 定义的子代理；主代理见 `agents/orchestrator.md` 或 front matter `kind: orchestrator`，子代理为 `agents/*.md`；开启 `multi_agent.enabled` 后聊天可切换单代理/多代理（详见 [多代理说明](docs/MULTI_AGENT_EINO.md)）
 - 🎯 Skills 技能系统：20+ 预设安全测试技能（SQL 注入、XSS、API 安全等），可附加到角色或由 AI 按需调用
 - 📱 **机器人**：支持钉钉、飞书长连接，在手机端与 CyberStrikeAI 对话（配置与命令详见 [机器人使用说明](docs/robot.md)）
 - 🐚 **WebShell 管理**：添加与管理 WebShell 连接（兼容冰蝎/蚁剑等），通过虚拟终端执行命令、内置文件管理进行文件操作，并提供按连接维度保存历史的 AI 助手标签页；支持 PHP/ASP/ASPX/JSP 及自定义类型，可配置请求方法与命令参数。
@@ -193,6 +194,7 @@ go build -o cyberstrike-ai cmd/server/main.go

 ### 常用流程
 - **对话测试**：自然语言触发多步工具编排，SSE 实时输出。
+- **单代理 / 多代理**：配置 `multi_agent.enabled: true` 后，聊天界面可切换 **单代理**（原有 ReAct 循环）与 **多代理**（Eino DeepAgent + `task` 子代理）。多代理走 `/api/multi-agent/stream`，MCP 工具与单代理同源桥接。
 - **角色化测试**：从预设的安全测试角色（渗透测试、CTF、Web 应用扫描、API 安全测试等）中选择，自定义 AI 行为和可用工具。每个角色可应用自定义系统提示词，并可限制可用工具列表，实现聚焦的测试场景。
 - **工具监控**：查看任务队列、执行日志、大文件附件。
 - **会话历史**：所有对话与工具调用保存在 SQLite，可随时重放。
@@ -236,6 +238,15 @@ go build -o cyberstrike-ai cmd/server/main.go
   ```
 2. 重启服务或重新加载配置，角色会出现在角色选择下拉菜单中。

+### 多代理模式（Eino DeepAgent）
+- **能力说明**：基于 CloudWeGo **Eino** `adk/prebuilt/deep` 的可选路径：**协调主代理**通过内置 **`task`** 工具启动短时**子代理**，各子代理独立推理，工具集来自当前聊天所选角色（与单代理一致来源）。
+- **Markdown 定义**：在 `agents_dir`（默认 `agents/`，相对 `config.yaml` 所在目录）维护：
+  - **主代理**：固定文件名 `orchestrator.md`，或任意 `.md` 且在 front matter 写 `kind: orchestrator`（**同一目录仅允许一个**主代理）。配置 Deep 的 name/id、description 与可选完整系统提示（正文）；正文为空时依次使用 `multi_agent.orchestrator_instruction`、Eino 内置默认提示。
+  - **子代理**：其余 `*.md`（YAML front matter + 正文作 instruction），不参与主代理定义的文件才会进入 `task` 可选列表。
+- **界面管理**：**Agents → Agent 管理** 对 Markdown 增删改查；HTTP API 前缀 `/api/multi-agent/markdown-agents`。
+- **配置项**：`config.yaml` 中 `multi_agent`：`enabled`、`default_mode`（`single` | `multi`）、`robot_use_multi_agent`、`batch_use_multi_agent`、`max_iteration`、`orchestrator_instruction` 等；可选在 YAML 写 `sub_agents` 与目录合并（同 `id` 时以 Markdown 为准）。
+- **更多细节**：流式事件、机器人与批量任务、排障等见 **[docs/MULTI_AGENT_EINO.md](docs/MULTI_AGENT_EINO.md)**。
+
 ### Skills 技能系统
 - **预设技能**：系统内置 20+ 个预设的安全测试技能（SQL 注入、XSS、API 安全、云安全、容器安全等），位于 `skills/` 目录。
 - **提示词中的技能提示**：当选择某个角色时，该角色附加的技能名称会作为推荐添加到系统提示词中。技能内容不会自动注入，AI 智能体需要时需使用 `read_skill` 工具获取技能详情。
@@ -426,6 +437,7 @@ CyberStrikeAI 支持通过三种传输模式连接外部 MCP 服务器：

 ### 自动化与安全
 - **REST API**：认证、会话、任务、监控、漏洞管理、角色管理等接口全部开放，可与 CI/CD 集成。
+- **多代理 API**：`POST /api/multi-agent/stream`（SSE，需启用多代理）、`POST /api/multi-agent`（非流式）；Markdown 子代理/主代理管理见 `/api/multi-agent/markdown-agents`（列表/读写/增删）。
 - **角色管理 API**：通过 `/api/roles` 端点管理安全测试角色：`GET /api/roles`（列表）、`GET /api/roles/:name`（获取角色）、`POST /api/roles`（创建角色）、`PUT /api/roles/:name`（更新角色）、`DELETE /api/roles/:name`（删除角色）。角色以 YAML 文件形式存储在 `roles/` 目录，支持热加载。
 - **漏洞管理 API**：通过 `/api/vulnerabilities` 端点管理漏洞：`GET /api/vulnerabilities`（列表，支持过滤）、`POST /api/vulnerabilities`（创建）、`GET /api/vulnerabilities/:id`（获取）、`PUT /api/vulnerabilities/:id`（更新）、`DELETE /api/vulnerabilities/:id`（删除）、`GET /api/vulnerabilities/stats`（统计）。
 - **批量任务 API**：通过 `/api/batch-tasks` 端点管理批量任务队列：`POST /api/batch-tasks`（创建队列）、`GET /api/batch-tasks`（列表）、`GET /api/batch-tasks/:queueId`（获取队列）、`POST /api/batch-tasks/:queueId/start`（开始执行）、`POST /api/batch-tasks/:queueId/cancel`（取消）、`DELETE /api/batch-tasks/:queueId`（删除队列）、`POST /api/batch-tasks/:queueId/tasks`（添加任务）、`PUT /api/batch-tasks/:queueId/tasks/:taskId`（更新任务）、`DELETE /api/batch-tasks/:queueId/tasks/:taskId`（删除任务）。任务依次顺序执行，每个任务创建独立对话，支持完整状态跟踪。
@@ -474,6 +486,13 @@ knowledge:
    hybrid_weight: 0.7  # 混合检索权重（0-1），向量检索的权重，1.0 表示纯向量检索，0.0 表示纯关键词检索
 roles_dir: "roles"  # 角色配置文件目录（相对于配置文件所在目录）
 skills_dir: "skills"  # Skills 目录（相对于配置文件所在目录）
+agents_dir: "agents"  # 多代理 Markdown（主代理 orchestrator.md + 子代理 *.md）
+multi_agent:
+  enabled: false
+  default_mode: "single"   # single | multi（开启多代理时的界面默认模式）
+  robot_use_multi_agent: false
+  batch_use_multi_agent: false
+  orchestrator_instruction: ""  # 可选；orchestrator.md 正文为空时使用
 ```

 ### 工具模版示例（`tools/nmap.yaml`）
@@ -518,6 +537,7 @@ enabled: true

 ## 相关文档

+- [多代理模式（Eino）](docs/MULTI_AGENT_EINO.md)：DeepAgent 编排、`agents/*.md`、接口与流式说明。
 - [机器人使用说明（钉钉 / 飞书）](docs/robot.md)：在手机端通过钉钉、飞书与 CyberStrikeAI 对话的完整配置步骤、命令与排查说明，**建议按该文档操作以避免走弯路**。

 ## 项目结构
@@ -530,7 +550,8 @@ CyberStrikeAI/
 ├── tools/               # YAML 工具目录（含 100+ 示例）
 ├── roles/               # 角色配置文件目录（含 12+ 预设安全测试角色）
 ├── skills/              # Skills 目录（含 20+ 预设安全测试技能）
-├── docs/                # 说明文档（如机器人使用说明）
+├── agents/              # 多代理 Markdown（orchestrator.md + 子代理 *.md）
+├── docs/                # 说明文档（如机器人使用说明、MULTI_AGENT_EINO.md）
 ├── images/              # 文档配图
 ├── config.yaml          # 运行配置
 ├── run.sh               # 启动脚本
--- a/internal/agent/agent.go
+++ b/internal/agent/agent.go
@@ -1890,6 +1890,25 @@ func (a *Agent) repairOrphanToolMessages(messages *[]ChatMessage) bool {
 	return removed
 }

+// ToolsForRole 返回与单 Agent 循环一致的工具定义（OpenAI function 格式），供 Eino DeepAgent 等编排层绑定 MCP 工具。
+func (a *Agent) ToolsForRole(roleTools []string) []Tool {
+	return a.getAvailableTools(roleTools)
+}
+
+// ExecuteMCPToolForConversation 在指定会话上下文中执行 MCP 工具（行为与主 Agent 循环中的工具调用一致，如自动注入 conversation_id）。
+func (a *Agent) ExecuteMCPToolForConversation(ctx context.Context, conversationID, toolName string, args map[string]interface{}) (*ToolExecutionResult, error) {
+	a.mu.Lock()
+	prev := a.currentConversationID
+	a.currentConversationID = conversationID
+	a.mu.Unlock()
+	defer func() {
+		a.mu.Lock()
+		a.currentConversationID = prev
+		a.mu.Unlock()
+	}()
+	return a.executeToolViaMCP(ctx, toolName, args)
+}
+
 // extractQuotedToolName 尝试从错误信息中提取被引用的工具名称
 func extractQuotedToolName(errMsg string) string {
 	start := strings.Index(errMsg, "\"")
--- a/internal/agents/markdown.go
+++ b/internal/agents/markdown.go
@@ -0,0 +1,449 @@
+// Package agents 从 agents/ 目录加载 Markdown 代理定义（子代理 + 可选主代理 orchestrator.md / kind: orchestrator）。
+package agents
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"unicode"
+
+	"cyberstrike-ai/internal/config"
+
+	"gopkg.in/yaml.v3"
+)
+
+// OrchestratorMarkdownFilename 固定文件名：存在则视为 Deep 主代理定义，且不参与子代理列表。
+const OrchestratorMarkdownFilename = "orchestrator.md"
+
+// FrontMatter 对应 Markdown 文件头部字段（与文档示例一致）。
+type FrontMatter struct {
+	Name          string      `yaml:"name"`
+	ID            string      `yaml:"id"`
+	Description   string      `yaml:"description"`
+	Tools         interface{} `yaml:"tools"` // 字符串 "A, B" 或 []string
+	MaxIterations int         `yaml:"max_iterations"`
+	BindRole      string      `yaml:"bind_role,omitempty"`
+	Kind          string      `yaml:"kind,omitempty"` // orchestrator = 主代理（亦可仅用文件名 orchestrator.md）
+}
+
+// OrchestratorMarkdown 从 agents 目录解析出的主代理（Deep 协调者）定义。
+type OrchestratorMarkdown struct {
+	Filename    string
+	EinoName    string // 写入 deep.Config.Name / 流式事件过滤
+	DisplayName string
+	Description string
+	Instruction string
+}
+
+// MarkdownDirLoad 一次扫描 agents 目录的结果（子代理不含主代理文件）。
+type MarkdownDirLoad struct {
+	SubAgents    []config.MultiAgentSubConfig
+	Orchestrator *OrchestratorMarkdown
+	FileEntries  []FileAgent // 含主代理与所有子代理，供管理 API 列表
+}
+
+// IsOrchestratorMarkdown 判断该文件是否表示主代理：固定文件名 orchestrator.md，或 front matter kind: orchestrator。
+func IsOrchestratorMarkdown(filename string, fm FrontMatter) bool {
+	base := filepath.Base(strings.TrimSpace(filename))
+	if strings.EqualFold(base, OrchestratorMarkdownFilename) {
+		return true
+	}
+	return strings.EqualFold(strings.TrimSpace(fm.Kind), "orchestrator")
+}
+
+// WantsMarkdownOrchestrator 保存前判断是否会把该文件作为主代理（用于唯一性校验）。
+func WantsMarkdownOrchestrator(filename string, kindField string, raw string) bool {
+	if strings.EqualFold(strings.TrimSpace(kindField), "orchestrator") {
+		return true
+	}
+	base := filepath.Base(strings.TrimSpace(filename))
+	if strings.EqualFold(base, OrchestratorMarkdownFilename) {
+		return true
+	}
+	if strings.TrimSpace(raw) == "" {
+		return false
+	}
+	sub, err := ParseMarkdownSubAgent(filename, raw)
+	if err != nil {
+		return false
+	}
+	return strings.EqualFold(strings.TrimSpace(sub.Kind), "orchestrator")
+}
+
+// SplitFrontMatter 分离 YAML front matter 与正文（--- ... ---）。
+func SplitFrontMatter(content string) (frontYAML string, body string, err error) {
+	s := strings.TrimSpace(content)
+	if !strings.HasPrefix(s, "---") {
+		return "", s, nil
+	}
+	rest := strings.TrimPrefix(s, "---")
+	rest = strings.TrimLeft(rest, "\r\n")
+	end := strings.Index(rest, "\n---")
+	if end < 0 {
+		return "", "", fmt.Errorf("agents: 缺少结束的 --- 分隔符")
+	}
+	fm := strings.TrimSpace(rest[:end])
+	body = strings.TrimSpace(rest[end+4:])
+	body = strings.TrimLeft(body, "\r\n")
+	return fm, body, nil
+}
+
+func parseToolsField(v interface{}) []string {
+	if v == nil {
+		return nil
+	}
+	switch t := v.(type) {
+	case string:
+		return splitToolList(t)
+	case []interface{}:
+		var out []string
+		for _, x := range t {
+			if s, ok := x.(string); ok && strings.TrimSpace(s) != "" {
+				out = append(out, strings.TrimSpace(s))
+			}
+		}
+		return out
+	case []string:
+		var out []string
+		for _, s := range t {
+			if strings.TrimSpace(s) != "" {
+				out = append(out, strings.TrimSpace(s))
+			}
+		}
+		return out
+	default:
+		return nil
+	}
+}
+
+func splitToolList(s string) []string {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return nil
+	}
+	parts := strings.FieldsFunc(s, func(r rune) bool {
+		return r == ',' || r == ';' || r == '|'
+	})
+	var out []string
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// SlugID 从 name 生成可用的代理 id（小写、连字符）。
+func SlugID(name string) string {
+	var b strings.Builder
+	name = strings.TrimSpace(strings.ToLower(name))
+	lastDash := false
+	for _, r := range name {
+		switch {
+		case unicode.IsLetter(r) && r < unicode.MaxASCII, unicode.IsDigit(r):
+			b.WriteRune(r)
+			lastDash = false
+		case r == ' ' || r == '_' || r == '/' || r == '.':
+			if !lastDash && b.Len() > 0 {
+				b.WriteByte('-')
+				lastDash = true
+			}
+		}
+	}
+	s := strings.Trim(b.String(), "-")
+	if s == "" {
+		return "agent"
+	}
+	return s
+}
+
+// sanitizeEinoAgentID 规范化 Deep 主代理在 Eino 中的 Name：小写 ASCII、数字、连字符，与默认 cyberstrike-deep 一致。
+func sanitizeEinoAgentID(s string) string {
+	s = strings.TrimSpace(strings.ToLower(s))
+	var b strings.Builder
+	for _, r := range s {
+		switch {
+		case unicode.IsLetter(r) && r < unicode.MaxASCII, unicode.IsDigit(r):
+			b.WriteRune(r)
+		case r == '-':
+			b.WriteRune(r)
+		}
+	}
+	out := strings.Trim(b.String(), "-")
+	if out == "" {
+		return "cyberstrike-deep"
+	}
+	return out
+}
+
+func parseMarkdownAgentRaw(filename string, content string) (FrontMatter, string, error) {
+	var fm FrontMatter
+	fmStr, body, err := SplitFrontMatter(content)
+	if err != nil {
+		return fm, "", err
+	}
+	if strings.TrimSpace(fmStr) == "" {
+		return fm, "", fmt.Errorf("agents: %s 无 YAML front matter", filename)
+	}
+	if err := yaml.Unmarshal([]byte(fmStr), &fm); err != nil {
+		return fm, "", fmt.Errorf("agents: 解析 front matter: %w", err)
+	}
+	return fm, body, nil
+}
+
+func orchestratorFromParsed(filename string, fm FrontMatter, body string) (*OrchestratorMarkdown, error) {
+	display := strings.TrimSpace(fm.Name)
+	if display == "" {
+		display = "Orchestrator"
+	}
+	rawID := strings.TrimSpace(fm.ID)
+	if rawID == "" {
+		rawID = SlugID(display)
+	}
+	eino := sanitizeEinoAgentID(rawID)
+	return &OrchestratorMarkdown{
+		Filename:    filepath.Base(strings.TrimSpace(filename)),
+		EinoName:    eino,
+		DisplayName: display,
+		Description: strings.TrimSpace(fm.Description),
+		Instruction: strings.TrimSpace(body),
+	}, nil
+}
+
+func orchestratorConfigFromOrchestrator(o *OrchestratorMarkdown) config.MultiAgentSubConfig {
+	if o == nil {
+		return config.MultiAgentSubConfig{}
+	}
+	return config.MultiAgentSubConfig{
+		ID:            o.EinoName,
+		Name:          o.DisplayName,
+		Description:   o.Description,
+		Instruction:   o.Instruction,
+		Kind:          "orchestrator",
+	}
+}
+
+func subAgentFromFrontMatter(filename string, fm FrontMatter, body string) (config.MultiAgentSubConfig, error) {
+	var out config.MultiAgentSubConfig
+	name := strings.TrimSpace(fm.Name)
+	if name == "" {
+		return out, fmt.Errorf("agents: %s 缺少 name 字段", filename)
+	}
+	id := strings.TrimSpace(fm.ID)
+	if id == "" {
+		id = SlugID(name)
+	}
+	out.ID = id
+	out.Name = name
+	out.Description = strings.TrimSpace(fm.Description)
+	out.Instruction = strings.TrimSpace(body)
+	out.RoleTools = parseToolsField(fm.Tools)
+	out.MaxIterations = fm.MaxIterations
+	out.BindRole = strings.TrimSpace(fm.BindRole)
+	out.Kind = strings.TrimSpace(fm.Kind)
+	return out, nil
+}
+
+func collectMarkdownBasenames(dir string) ([]string, error) {
+	if strings.TrimSpace(dir) == "" {
+		return nil, nil
+	}
+	st, err := os.Stat(dir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	if !st.IsDir() {
+		return nil, fmt.Errorf("agents: 不是目录: %s", dir)
+	}
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, err
+	}
+	var names []string
+	for _, e := range entries {
+		if e.IsDir() {
+			continue
+		}
+		n := e.Name()
+		if strings.HasPrefix(n, ".") {
+			continue
+		}
+		if !strings.EqualFold(filepath.Ext(n), ".md") {
+			continue
+		}
+		if strings.EqualFold(n, "README.md") {
+			continue
+		}
+		names = append(names, n)
+	}
+	sort.Strings(names)
+	return names, nil
+}
+
+// LoadMarkdownAgentsDir 扫描 agents 目录：拆出至多一个主代理与其余子代理。
+func LoadMarkdownAgentsDir(dir string) (*MarkdownDirLoad, error) {
+	out := &MarkdownDirLoad{}
+	names, err := collectMarkdownBasenames(dir)
+	if err != nil {
+		return nil, err
+	}
+	for _, n := range names {
+		p := filepath.Join(dir, n)
+		b, err := os.ReadFile(p)
+		if err != nil {
+			return nil, err
+		}
+		fm, body, err := parseMarkdownAgentRaw(n, string(b))
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", n, err)
+		}
+		if IsOrchestratorMarkdown(n, fm) {
+			if out.Orchestrator != nil {
+				return nil, fmt.Errorf("agents: 仅能定义一个主代理（Deep 协调者），已有 %s，又与 %s 冲突", out.Orchestrator.Filename, n)
+			}
+			orch, err := orchestratorFromParsed(n, fm, body)
+			if err != nil {
+				return nil, fmt.Errorf("%s: %w", n, err)
+			}
+			out.Orchestrator = orch
+			out.FileEntries = append(out.FileEntries, FileAgent{
+				Filename:       n,
+				Config:         orchestratorConfigFromOrchestrator(orch),
+				IsOrchestrator: true,
+			})
+			continue
+		}
+		sub, err := subAgentFromFrontMatter(n, fm, body)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", n, err)
+		}
+		out.SubAgents = append(out.SubAgents, sub)
+		out.FileEntries = append(out.FileEntries, FileAgent{Filename: n, Config: sub, IsOrchestrator: false})
+	}
+	return out, nil
+}
+
+// ParseMarkdownSubAgent 将单个 Markdown 文件解析为 MultiAgentSubConfig。
+func ParseMarkdownSubAgent(filename string, content string) (config.MultiAgentSubConfig, error) {
+	fm, body, err := parseMarkdownAgentRaw(filename, content)
+	if err != nil {
+		return config.MultiAgentSubConfig{}, err
+	}
+	if IsOrchestratorMarkdown(filename, fm) {
+		orch, err := orchestratorFromParsed(filename, fm, body)
+		if err != nil {
+			return config.MultiAgentSubConfig{}, err
+		}
+		return orchestratorConfigFromOrchestrator(orch), nil
+	}
+	return subAgentFromFrontMatter(filename, fm, body)
+}
+
+// LoadMarkdownSubAgents 读取目录下所有子代理 .md（不含主代理 orchestrator.md / kind: orchestrator）。
+func LoadMarkdownSubAgents(dir string) ([]config.MultiAgentSubConfig, error) {
+	load, err := LoadMarkdownAgentsDir(dir)
+	if err != nil {
+		return nil, err
+	}
+	return load.SubAgents, nil
+}
+
+// FileAgent 单个 Markdown 文件及其解析结果。
+type FileAgent struct {
+	Filename       string
+	Config         config.MultiAgentSubConfig
+	IsOrchestrator bool
+}
+
+// LoadMarkdownAgentFiles 列出目录下全部 .md（含主代理），供管理 API 使用。
+func LoadMarkdownAgentFiles(dir string) ([]FileAgent, error) {
+	load, err := LoadMarkdownAgentsDir(dir)
+	if err != nil {
+		return nil, err
+	}
+	return load.FileEntries, nil
+}
+
+// MergeYAMLAndMarkdown 合并 config.yaml 中的 sub_agents 与 Markdown 定义：同 id 时 Markdown 覆盖 YAML；仅存在于 Markdown 的条目追加在 YAML 顺序之后。
+func MergeYAMLAndMarkdown(yamlSubs []config.MultiAgentSubConfig, mdSubs []config.MultiAgentSubConfig) []config.MultiAgentSubConfig {
+	mdByID := make(map[string]config.MultiAgentSubConfig)
+	for _, m := range mdSubs {
+		id := strings.TrimSpace(m.ID)
+		if id == "" {
+			continue
+		}
+		mdByID[id] = m
+	}
+	yamlIDSet := make(map[string]bool)
+	for _, y := range yamlSubs {
+		yamlIDSet[strings.TrimSpace(y.ID)] = true
+	}
+	out := make([]config.MultiAgentSubConfig, 0, len(yamlSubs)+len(mdSubs))
+	for _, y := range yamlSubs {
+		id := strings.TrimSpace(y.ID)
+		if id == "" {
+			continue
+		}
+		if m, ok := mdByID[id]; ok {
+			out = append(out, m)
+		} else {
+			out = append(out, y)
+		}
+	}
+	for _, m := range mdSubs {
+		id := strings.TrimSpace(m.ID)
+		if id == "" || yamlIDSet[id] {
+			continue
+		}
+		out = append(out, m)
+	}
+	return out
+}
+
+// EffectiveSubAgents 供多代理运行时使用。
+func EffectiveSubAgents(yamlSubs []config.MultiAgentSubConfig, agentsDir string) ([]config.MultiAgentSubConfig, error) {
+	md, err := LoadMarkdownSubAgents(agentsDir)
+	if err != nil {
+		return nil, err
+	}
+	if len(md) == 0 {
+		return yamlSubs, nil
+	}
+	return MergeYAMLAndMarkdown(yamlSubs, md), nil
+}
+
+// BuildMarkdownFile 根据配置序列化为可写回磁盘的 Markdown。
+func BuildMarkdownFile(sub config.MultiAgentSubConfig) ([]byte, error) {
+	fm := FrontMatter{
+		Name:          sub.Name,
+		ID:            sub.ID,
+		Description:   sub.Description,
+		MaxIterations: sub.MaxIterations,
+		BindRole:      sub.BindRole,
+	}
+	if k := strings.TrimSpace(sub.Kind); k != "" {
+		fm.Kind = k
+	}
+	if len(sub.RoleTools) > 0 {
+		fm.Tools = sub.RoleTools
+	}
+	head, err := yaml.Marshal(fm)
+	if err != nil {
+		return nil, err
+	}
+	var b strings.Builder
+	b.WriteString("---\n")
+	b.Write(head)
+	b.WriteString("---\n\n")
+	b.WriteString(strings.TrimSpace(sub.Instruction))
+	if !strings.HasSuffix(sub.Instruction, "\n") && sub.Instruction != "" {
+		b.WriteString("\n")
+	}
+	return []byte(b.String()), nil
+}
--- a/internal/agents/markdown_orchestrator_test.go
+++ b/internal/agents/markdown_orchestrator_test.go
@@ -0,0 +1,66 @@
+package agents
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestLoadMarkdownAgentsDir_OrchestratorExcludedFromSubs(t *testing.T) {
+	dir := t.TempDir()
+	orch := filepath.Join(dir, OrchestratorMarkdownFilename)
+	if err := os.WriteFile(orch, []byte(`---
+id: cyberstrike-deep
+name: Main
+description: Test desc
+---
+
+Hello orchestrator
+`), 0644); err != nil {
+		t.Fatal(err)
+	}
+	subPath := filepath.Join(dir, "worker.md")
+	if err := os.WriteFile(subPath, []byte(`---
+id: worker
+name: Worker
+description: W
+---
+
+Do work
+`), 0644); err != nil {
+		t.Fatal(err)
+	}
+	load, err := LoadMarkdownAgentsDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if load.Orchestrator == nil || load.Orchestrator.EinoName != "cyberstrike-deep" {
+		t.Fatalf("orchestrator: %+v", load.Orchestrator)
+	}
+	if len(load.SubAgents) != 1 || load.SubAgents[0].ID != "worker" {
+		t.Fatalf("subs: %+v", load.SubAgents)
+	}
+	if len(load.FileEntries) != 2 {
+		t.Fatalf("file entries: %d", len(load.FileEntries))
+	}
+	var orchFile *FileAgent
+	for i := range load.FileEntries {
+		if load.FileEntries[i].IsOrchestrator {
+			orchFile = &load.FileEntries[i]
+			break
+		}
+	}
+	if orchFile == nil || orchFile.Filename != OrchestratorMarkdownFilename {
+		t.Fatal("missing orchestrator file entry")
+	}
+}
+
+func TestLoadMarkdownAgentsDir_DuplicateOrchestrator(t *testing.T) {
+	dir := t.TempDir()
+	_ = os.WriteFile(filepath.Join(dir, OrchestratorMarkdownFilename), []byte("---\nname: A\n---\n\nx\n"), 0644)
+	_ = os.WriteFile(filepath.Join(dir, "b.md"), []byte("---\nname: B\nkind: orchestrator\n---\n\ny\n"), 0644)
+	_, err := LoadMarkdownAgentsDir(dir)
+	if err == nil {
+		t.Fatal("expected duplicate orchestrator error")
+	}
+}
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -298,6 +298,19 @@ func New(cfg *config.Config, log *logger.Logger) (*App, error) {
 	skillsManager := skills.NewManager(skillsDir, log.Logger)
 	log.Logger.Info("Skills管理器已初始化", zap.String("skillsDir", skillsDir))

+	agentsDir := cfg.AgentsDir
+	if agentsDir == "" {
+		agentsDir = "agents"
+	}
+	if !filepath.IsAbs(agentsDir) {
+		agentsDir = filepath.Join(configDir, agentsDir)
+	}
+	if err := os.MkdirAll(agentsDir, 0755); err != nil {
+		log.Logger.Warn("创建 agents 目录失败", zap.String("path", agentsDir), zap.Error(err))
+	}
+	markdownAgentsHandler := handler.NewMarkdownAgentsHandler(agentsDir)
+	log.Logger.Info("多代理 Markdown 子 Agent 目录", zap.String("agentsDir", agentsDir))
+
 	// 注册Skills工具到MCP服务器（让AI可以按需调用，带数据库存储支持统计）
 	// 创建一个适配器，将database.DB适配为SkillStatsStorage接口
 	var skillStatsStorage skills.SkillStatsStorage
@@ -309,6 +322,7 @@ func New(cfg *config.Config, log *logger.Logger) (*App, error) {
 	// 创建处理器
 	agentHandler := handler.NewAgentHandler(agent, db, cfg, log.Logger)
 	agentHandler.SetSkillsManager(skillsManager) // 设置Skills管理器
+	agentHandler.SetAgentsMarkdownDir(agentsDir)
 	// 如果知识库已启用，设置知识库管理器到AgentHandler以便记录检索日志
 	if knowledgeManager != nil {
 		agentHandler.SetKnowledgeManager(knowledgeManager)
@@ -443,6 +457,7 @@ func New(cfg *config.Config, log *logger.Logger) (*App, error) {
 		chatUploadsHandler,
 		roleHandler,
 		skillsHandler,
+		markdownAgentsHandler,
 		fofaHandler,
 		terminalHandler,
 		mcpServer,
@@ -572,6 +587,7 @@ func setupRoutes(
 	chatUploadsHandler *handler.ChatUploadsHandler,
 	roleHandler *handler.RoleHandler,
 	skillsHandler *handler.SkillsHandler,
+	markdownAgentsHandler *handler.MarkdownAgentsHandler,
 	fofaHandler *handler.FofaHandler,
 	terminalHandler *handler.TerminalHandler,
 	mcpServer *mcp.Server,
@@ -611,6 +627,16 @@ func setupRoutes(
 		protected.GET("/agent-loop/tasks", agentHandler.ListAgentTasks)
 		protected.GET("/agent-loop/tasks/completed", agentHandler.ListCompletedTasks)

+		// Eino DeepAgent 多代理（与单 Agent 并存，需 config.multi_agent.enabled）
+		// 多代理路由常注册；是否可用由运行时 h.config.MultiAgent.Enabled 决定（应用配置后无需重启）
+		protected.POST("/multi-agent", agentHandler.MultiAgentLoop)
+		protected.POST("/multi-agent/stream", agentHandler.MultiAgentLoopStream)
+		protected.GET("/multi-agent/markdown-agents", markdownAgentsHandler.ListMarkdownAgents)
+		protected.GET("/multi-agent/markdown-agents/:filename", markdownAgentsHandler.GetMarkdownAgent)
+		protected.POST("/multi-agent/markdown-agents", markdownAgentsHandler.CreateMarkdownAgent)
+		protected.PUT("/multi-agent/markdown-agents/:filename", markdownAgentsHandler.UpdateMarkdownAgent)
+		protected.DELETE("/multi-agent/markdown-agents/:filename", markdownAgentsHandler.DeleteMarkdownAgent)
+
 		// 信息收集 - FOFA 查询（后端代理）
 		protected.POST("/fofa/search", fofaHandler.Search)
 		// 信息收集 - 自然语言解析为 FOFA 语法（需人工确认后再查询）
@@ -1147,7 +1173,7 @@ func registerWebshellTools(mcpServer *mcp.Server, db *database.DB, webshellHandl
 			"type": "object",
 			"properties": map[string]interface{}{
 				"connection_id": map[string]interface{}{"type": "string", "description": "WebShell 连接 ID"},
-				"path": map[string]interface{}{"type": "string", "description": "目录路径，默认 ."},
+				"path":          map[string]interface{}{"type": "string", "description": "目录路径，默认 ."},
 			},
 			"required": []string{"connection_id"},
 		},
@@ -1179,7 +1205,7 @@ func registerWebshellTools(mcpServer *mcp.Server, db *database.DB, webshellHandl
 			"type": "object",
 			"properties": map[string]interface{}{
 				"connection_id": map[string]interface{}{"type": "string", "description": "WebShell 连接 ID"},
-				"path": map[string]interface{}{"type": "string", "description": "文件路径"},
+				"path":          map[string]interface{}{"type": "string", "description": "文件路径"},
 			},
 			"required": []string{"connection_id", "path"},
 		},
@@ -1211,8 +1237,8 @@ func registerWebshellTools(mcpServer *mcp.Server, db *database.DB, webshellHandl
 			"type": "object",
 			"properties": map[string]interface{}{
 				"connection_id": map[string]interface{}{"type": "string", "description": "WebShell 连接 ID"},
-				"path": map[string]interface{}{"type": "string", "description": "文件路径"},
-				"content": map[string]interface{}{"type": "string", "description": "要写入的内容"},
+				"path":          map[string]interface{}{"type": "string", "description": "文件路径"},
+				"content":       map[string]interface{}{"type": "string", "description": "要写入的内容"},
 			},
 			"required": []string{"connection_id", "path", "content"},
 		},
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -31,23 +31,68 @@ type Config struct {
 	RolesDir    string                `yaml:"roles_dir,omitempty" json:"roles_dir,omitempty"`   // 角色配置文件目录（新方式）
 	Roles       map[string]RoleConfig `yaml:"roles,omitempty" json:"roles,omitempty"`           // 向后兼容：支持在主配置文件中定义角色
 	SkillsDir   string                `yaml:"skills_dir,omitempty" json:"skills_dir,omitempty"` // Skills配置文件目录
+	AgentsDir   string                `yaml:"agents_dir,omitempty" json:"agents_dir,omitempty"` // 多代理子 Agent Markdown 定义目录（*.md，YAML front matter）
+	MultiAgent  MultiAgentConfig      `yaml:"multi_agent,omitempty" json:"multi_agent,omitempty"`
+}
+
+// MultiAgentConfig 基于 CloudWeGo Eino DeepAgent 的多代理编排（与单 Agent /agent-loop 并存）。
+type MultiAgentConfig struct {
+	Enabled                 bool                  `yaml:"enabled" json:"enabled"`
+	DefaultMode             string                `yaml:"default_mode" json:"default_mode"`                   // single | multi，供前端默认展示
+	RobotUseMultiAgent      bool                  `yaml:"robot_use_multi_agent" json:"robot_use_multi_agent"` // 为 true 时钉钉/飞书/企微机器人走 Eino 多代理
+	BatchUseMultiAgent      bool                  `yaml:"batch_use_multi_agent" json:"batch_use_multi_agent"` // 为 true 时批量任务队列中每子任务走 Eino 多代理
+	MaxIteration            int                   `yaml:"max_iteration" json:"max_iteration"`                 // Deep 主代理最大推理轮次
+	SubAgentMaxIterations   int                   `yaml:"sub_agent_max_iterations" json:"sub_agent_max_iterations"`
+	WithoutGeneralSubAgent  bool                  `yaml:"without_general_sub_agent" json:"without_general_sub_agent"`
+	WithoutWriteTodos       bool                  `yaml:"without_write_todos" json:"without_write_todos"`
+	OrchestratorInstruction string                `yaml:"orchestrator_instruction" json:"orchestrator_instruction"`
+	SubAgents               []MultiAgentSubConfig `yaml:"sub_agents" json:"sub_agents"`
+}
+
+// MultiAgentSubConfig 子代理（Eino ChatModelAgent），由 DeepAgent 通过 task 工具调度。
+type MultiAgentSubConfig struct {
+	ID            string   `yaml:"id" json:"id"`
+	Name          string   `yaml:"name" json:"name"`
+	Description   string   `yaml:"description" json:"description"`
+	Instruction   string   `yaml:"instruction" json:"instruction"`
+	BindRole      string   `yaml:"bind_role,omitempty" json:"bind_role,omitempty"` // 可选：关联主配置 roles 中的角色名；未配 role_tools 时沿用该角色的 tools，并把 skills 写入指令提示
+	RoleTools     []string `yaml:"role_tools" json:"role_tools"`                   // 与单 Agent 角色工具相同 key；空表示全部工具（bind_role 可补全 tools）
+	MaxIterations int      `yaml:"max_iterations" json:"max_iterations"`
+	Kind          string   `yaml:"kind,omitempty" json:"kind,omitempty"` // 仅 Markdown：kind=orchestrator 表示 Deep 主代理（与 orchestrator.md 二选一约定）
+}
+
+// MultiAgentPublic 返回给前端的精简信息（不含子代理指令全文）。
+type MultiAgentPublic struct {
+	Enabled            bool   `json:"enabled"`
+	DefaultMode        string `json:"default_mode"`
+	RobotUseMultiAgent bool   `json:"robot_use_multi_agent"`
+	BatchUseMultiAgent bool   `json:"batch_use_multi_agent"`
+	SubAgentCount      int    `json:"sub_agent_count"`
+}
+
+// MultiAgentAPIUpdate 设置页/API 仅更新多代理标量字段；写入 YAML 时不覆盖 sub_agents 等块。
+type MultiAgentAPIUpdate struct {
+	Enabled            bool   `json:"enabled"`
+	DefaultMode        string `json:"default_mode"`
+	RobotUseMultiAgent bool   `json:"robot_use_multi_agent"`
+	BatchUseMultiAgent bool   `json:"batch_use_multi_agent"`
 }

 // RobotsConfig 机器人配置（企业微信、钉钉、飞书等）
 type RobotsConfig struct {
-	Wecom   RobotWecomConfig   `yaml:"wecom,omitempty" json:"wecom,omitempty"`     // 企业微信
+	Wecom    RobotWecomConfig    `yaml:"wecom,omitempty" json:"wecom,omitempty"`       // 企业微信
 	Dingtalk RobotDingtalkConfig `yaml:"dingtalk,omitempty" json:"dingtalk,omitempty"` // 钉钉
-	Lark    RobotLarkConfig    `yaml:"lark,omitempty" json:"lark,omitempty"`     // 飞书
+	Lark     RobotLarkConfig     `yaml:"lark,omitempty" json:"lark,omitempty"`         // 飞书
 }

 // RobotWecomConfig 企业微信机器人配置
 type RobotWecomConfig struct {
-	Enabled       bool   `yaml:"enabled" json:"enabled"`
-	Token         string `yaml:"token" json:"token"`                     // 回调 URL 校验 Token
+	Enabled        bool   `yaml:"enabled" json:"enabled"`
+	Token          string `yaml:"token" json:"token"`                       // 回调 URL 校验 Token
 	EncodingAESKey string `yaml:"encoding_aes_key" json:"encoding_aes_key"` // EncodingAESKey
-	CorpID        string `yaml:"corp_id" json:"corp_id"`               // 企业 ID
-	Secret        string `yaml:"secret" json:"secret"`                  // 应用 Secret
-	AgentID       int64  `yaml:"agent_id" json:"agent_id"`              // 应用 AgentId
+	CorpID         string `yaml:"corp_id" json:"corp_id"`                   // 企业 ID
+	Secret         string `yaml:"secret" json:"secret"`                     // 应用 Secret
+	AgentID        int64  `yaml:"agent_id" json:"agent_id"`                 // 应用 AgentId
 }

 // RobotDingtalkConfig 钉钉机器人配置
@@ -59,9 +104,9 @@ type RobotDingtalkConfig struct {

 // RobotLarkConfig 飞书机器人配置
 type RobotLarkConfig struct {
-	Enabled   bool   `yaml:"enabled" json:"enabled"`
-	AppID     string `yaml:"app_id" json:"app_id"`         // 应用 App ID
-	AppSecret string `yaml:"app_secret" json:"app_secret"` // 应用 App Secret
+	Enabled     bool   `yaml:"enabled" json:"enabled"`
+	AppID       string `yaml:"app_id" json:"app_id"`             // 应用 App ID
+	AppSecret   string `yaml:"app_secret" json:"app_secret"`     // 应用 App Secret
 	VerifyToken string `yaml:"verify_token" json:"verify_token"` // 事件订阅 Verification Token（可选）
 }

@@ -79,7 +124,7 @@ type MCPConfig struct {
 	Enabled         bool   `yaml:"enabled"`
 	Host            string `yaml:"host"`
 	Port            int    `yaml:"port"`
-	AuthHeader      string `yaml:"auth_header,omitempty"`      // 鉴权 header 名，留空表示不鉴权
+	AuthHeader      string `yaml:"auth_header,omitempty"`       // 鉴权 header 名，留空表示不鉴权
 	AuthHeaderValue string `yaml:"auth_header_value,omitempty"` // 鉴权 header 值，需与请求中该 header 一致
 }

@@ -164,17 +209,17 @@ type ToolConfig struct {

 // ParameterConfig 参数配置
 type ParameterConfig struct {
-	Name        string      `yaml:"name"`                  // 参数名称
-	Type        string      `yaml:"type"`                  // 参数类型: string, int, bool, array
-	Description string      `yaml:"description"`           // 参数描述
-	Required    bool        `yaml:"required,omitempty"`    // 是否必需
-	Default     interface{} `yaml:"default,omitempty"`      // 默认值
-	ItemType    string      `yaml:"item_type,omitempty"`    // 当 type 为 array 时，数组元素类型，如 string, number, object
-	Flag        string      `yaml:"flag,omitempty"`         // 命令行标志，如 "-u", "--url", "-p"
-	Position    *int        `yaml:"position,omitempty"`     // 位置参数的位置（从0开始）
-	Format      string      `yaml:"format,omitempty"`      // 参数格式: "flag", "positional", "combined" (flag=value), "template"
-	Template    string      `yaml:"template,omitempty"`    // 模板字符串，如 "{flag} {value}" 或 "{value}"
-	Options     []string    `yaml:"options,omitempty"`     // 可选值列表（用于枚举）
+	Name        string      `yaml:"name"`                // 参数名称
+	Type        string      `yaml:"type"`                // 参数类型: string, int, bool, array
+	Description string      `yaml:"description"`         // 参数描述
+	Required    bool        `yaml:"required,omitempty"`  // 是否必需
+	Default     interface{} `yaml:"default,omitempty"`   // 默认值
+	ItemType    string      `yaml:"item_type,omitempty"` // 当 type 为 array 时，数组元素类型，如 string, number, object
+	Flag        string      `yaml:"flag,omitempty"`      // 命令行标志，如 "-u", "--url", "-p"
+	Position    *int        `yaml:"position,omitempty"`  // 位置参数的位置（从0开始）
+	Format      string      `yaml:"format,omitempty"`    // 参数格式: "flag", "positional", "combined" (flag=value), "template"
+	Template    string      `yaml:"template,omitempty"`  // 模板字符串，如 "{flag} {value}" 或 "{value}"
+	Options     []string    `yaml:"options,omitempty"`   // 可选值列表（用于枚举）
 }

 func Load(path string) (*Config, error) {
@@ -683,8 +728,8 @@ func Default() *Config {
 			MaxTotalTokens: 120000,
 		},
 		Agent: AgentConfig{
-			MaxIterations:      30,  // 默认最大迭代次数
-			ToolTimeoutMinutes: 10,  // 单次工具执行默认最多 10 分钟，避免异常长时间占用
+			MaxIterations:      30, // 默认最大迭代次数
+			ToolTimeoutMinutes: 10, // 单次工具执行默认最多 10 分钟，避免异常长时间占用
 		},
 		Security: SecurityConfig{
 			Tools:    []ToolConfig{}, // 工具配置应该从 config.yaml 或 tools/ 目录加载
@@ -711,11 +756,11 @@ func Default() *Config {
 				HybridWeight:        0.7,
 			},
 			Indexing: IndexingConfig{
-				ChunkSize:        768,   // 增加到 768，更好的上下文保持
+				ChunkSize:        768, // 增加到 768，更好的上下文保持
 				ChunkOverlap:     50,
-				MaxChunksPerItem: 20,    // 限制单个知识项最多 20 个块，避免消耗过多配额
-				MaxRPM:           100,   // 默认 100 RPM，避免 429 错误
-				RateLimitDelayMs: 600,   // 600ms 间隔，对应 100 RPM
+				MaxChunksPerItem: 20,  // 限制单个知识项最多 20 个块，避免消耗过多配额
+				MaxRPM:           100, // 默认 100 RPM，避免 429 错误
+				RateLimitDelayMs: 600, // 600ms 间隔，对应 100 RPM
 				MaxRetries:       3,
 				RetryDelayMs:     1000,
 			},
@@ -735,20 +780,20 @@ type KnowledgeConfig struct {
 // IndexingConfig 索引构建配置（用于控制知识库索引构建时的行为）
 type IndexingConfig struct {
 	// 分块配置
-	ChunkSize       int `yaml:"chunk_size,omitempty" json:"chunk_size,omitempty"`           // 每个块的最大 token 数（估算），默认 512
-	ChunkOverlap    int `yaml:"chunk_overlap,omitempty" json:"chunk_overlap,omitempty"`     // 块之间的重叠 token 数，默认 50
+	ChunkSize        int `yaml:"chunk_size,omitempty" json:"chunk_size,omitempty"`                   // 每个块的最大 token 数（估算），默认 512
+	ChunkOverlap     int `yaml:"chunk_overlap,omitempty" json:"chunk_overlap,omitempty"`             // 块之间的重叠 token 数，默认 50
 	MaxChunksPerItem int `yaml:"max_chunks_per_item,omitempty" json:"max_chunks_per_item,omitempty"` // 单个知识项的最大块数量，0 表示不限制

 	// 速率限制配置（用于避免 API 速率限制）
 	RateLimitDelayMs int `yaml:"rate_limit_delay_ms,omitempty" json:"rate_limit_delay_ms,omitempty"` // 请求间隔时间（毫秒），0 表示不使用固定延迟
-	MaxRPM          int `yaml:"max_rpm,omitempty" json:"max_rpm,omitempty"`                         // 每分钟最大请求数，0 表示不限制
+	MaxRPM           int `yaml:"max_rpm,omitempty" json:"max_rpm,omitempty"`                         // 每分钟最大请求数，0 表示不限制

 	// 重试配置（用于处理临时错误）
-	MaxRetries     int `yaml:"max_retries,omitempty" json:"max_retries,omitempty"`       // 最大重试次数，默认 3
-	RetryDelayMs   int `yaml:"retry_delay_ms,omitempty" json:"retry_delay_ms,omitempty"` // 重试间隔（毫秒），默认 1000
+	MaxRetries   int `yaml:"max_retries,omitempty" json:"max_retries,omitempty"`       // 最大重试次数，默认 3
+	RetryDelayMs int `yaml:"retry_delay_ms,omitempty" json:"retry_delay_ms,omitempty"` // 重试间隔（毫秒），默认 1000

 	// 批处理配置（用于批量嵌入，当前未使用，保留扩展）
-	BatchSize      int `yaml:"batch_size,omitempty" json:"batch_size,omitempty"`         // 批量处理大小，0 表示逐个处理
+	BatchSize int `yaml:"batch_size,omitempty" json:"batch_size,omitempty"` // 批量处理大小，0 表示逐个处理
 }

 // EmbeddingConfig 嵌入配置
--- a/internal/einomcp/holder.go
+++ b/internal/einomcp/holder.go
@@ -0,0 +1,21 @@
+package einomcp
+
+import "sync"
+
+// ConversationHolder 在每次 DeepAgent 运行前写入会话 ID，供 MCP 工具桥接使用。
+type ConversationHolder struct {
+	mu sync.RWMutex
+	id string
+}
+
+func (h *ConversationHolder) Set(id string) {
+	h.mu.Lock()
+	h.id = id
+	h.mu.Unlock()
+}
+
+func (h *ConversationHolder) Get() string {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+	return h.id
+}
--- a/internal/einomcp/mcp_tools.go
+++ b/internal/einomcp/mcp_tools.go
@@ -0,0 +1,101 @@
+package einomcp
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"cyberstrike-ai/internal/agent"
+
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"github.com/eino-contrib/jsonschema"
+)
+
+// ExecutionRecorder 可选，在 MCP 工具成功返回且带有 execution id 时回调（用于汇总 mcpExecutionIds）。
+type ExecutionRecorder func(executionID string)
+
+// ToolsFromDefinitions 将单 Agent 使用的 OpenAI 风格工具定义转为 Eino InvokableTool，执行时走 Agent 的 MCP 路径。
+func ToolsFromDefinitions(ag *agent.Agent, holder *ConversationHolder, defs []agent.Tool, rec ExecutionRecorder) ([]tool.BaseTool, error) {
+	out := make([]tool.BaseTool, 0, len(defs))
+	for _, d := range defs {
+		if d.Type != "function" || d.Function.Name == "" {
+			continue
+		}
+		info, err := toolInfoFromDefinition(d)
+		if err != nil {
+			return nil, fmt.Errorf("tool %q: %w", d.Function.Name, err)
+		}
+		out = append(out, &mcpBridgeTool{
+			info:   info,
+			name:   d.Function.Name,
+			agent:  ag,
+			holder: holder,
+			record: rec,
+		})
+	}
+	return out, nil
+}
+
+func toolInfoFromDefinition(d agent.Tool) (*schema.ToolInfo, error) {
+	fn := d.Function
+	raw, err := json.Marshal(fn.Parameters)
+	if err != nil {
+		return nil, err
+	}
+	var js jsonschema.Schema
+	if len(raw) > 0 && string(raw) != "null" && string(raw) != "{}" {
+		if err := json.Unmarshal(raw, &js); err != nil {
+			return nil, err
+		}
+	}
+	if js.Type == "" {
+		js.Type = string(schema.Object)
+	}
+	if js.Properties == nil && js.Type == string(schema.Object) {
+		// 空参数对象
+	}
+	return &schema.ToolInfo{
+		Name:        fn.Name,
+		Desc:        fn.Description,
+		ParamsOneOf: schema.NewParamsOneOfByJSONSchema(&js),
+	}, nil
+}
+
+type mcpBridgeTool struct {
+	info   *schema.ToolInfo
+	name   string
+	agent  *agent.Agent
+	holder *ConversationHolder
+	record ExecutionRecorder
+}
+
+func (m *mcpBridgeTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	_ = ctx
+	return m.info, nil
+}
+
+func (m *mcpBridgeTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	_ = opts
+	var args map[string]interface{}
+	if argumentsInJSON != "" && argumentsInJSON != "null" {
+		if err := json.Unmarshal([]byte(argumentsInJSON), &args); err != nil {
+			return "", fmt.Errorf("invalid tool arguments JSON: %w", err)
+		}
+	}
+	if args == nil {
+		args = map[string]interface{}{}
+	}
+	conv := m.holder.Get()
+	res, err := m.agent.ExecuteMCPToolForConversation(ctx, conv, m.name, args)
+	if err != nil {
+		return "", err
+	}
+	if res == nil {
+		return "", nil
+	}
+	if res.ExecutionID != "" && m.record != nil {
+		m.record(res.ExecutionID)
+	}
+	return res.Result, nil
+}
--- a/internal/handler/agent.go
+++ b/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)
 		}

 		// 移动到下一个任务
--- a/internal/handler/config.go
+++ b/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 {
--- a/internal/handler/markdown_agents.go
+++ b/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": "已删除"})
+}
--- a/internal/handler/multi_agent.go
+++ b/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
+	}
+}
--- a/internal/handler/multi_agent_prepare.go
+++ b/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
+}
--- a/internal/handler/openapi.go
+++ b/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{"对话交互"},
--- a/internal/multiagent/runner.go
+++ b/internal/multiagent/runner.go
@@ -0,0 +1,721 @@
+// Package multiagent 使用 CloudWeGo Eino 的 DeepAgent（adk/prebuilt/deep）编排多代理，MCP 工具经 einomcp 桥接到现有 Agent。
+package multiagent
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"sort"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"cyberstrike-ai/internal/agent"
+	"cyberstrike-ai/internal/agents"
+	"cyberstrike-ai/internal/config"
+	"cyberstrike-ai/internal/einomcp"
+
+	einoopenai "github.com/cloudwego/eino-ext/components/model/openai"
+	"github.com/cloudwego/eino/adk"
+	"github.com/cloudwego/eino/adk/prebuilt/deep"
+	"github.com/cloudwego/eino/compose"
+	"github.com/cloudwego/eino/schema"
+	"go.uber.org/zap"
+)
+
+// RunResult 与单 Agent 循环结果字段对齐，便于复用存储与 SSE 收尾逻辑。
+type RunResult struct {
+	Response        string
+	MCPExecutionIDs []string
+	LastReActInput  string
+	LastReActOutput string
+}
+
+// RunDeepAgent 使用 Eino DeepAgent 执行一轮对话（流式事件通过 progress 回调输出）。
+func RunDeepAgent(
+	ctx context.Context,
+	appCfg *config.Config,
+	ma *config.MultiAgentConfig,
+	ag *agent.Agent,
+	logger *zap.Logger,
+	conversationID string,
+	userMessage string,
+	history []agent.ChatMessage,
+	roleTools []string,
+	progress func(eventType, message string, data interface{}),
+	agentsMarkdownDir string,
+) (*RunResult, error) {
+	if appCfg == nil || ma == nil || ag == nil {
+		return nil, fmt.Errorf("multiagent: 配置或 Agent 为空")
+	}
+
+	effectiveSubs := ma.SubAgents
+	var orch *agents.OrchestratorMarkdown
+	if strings.TrimSpace(agentsMarkdownDir) != "" {
+		load, merr := agents.LoadMarkdownAgentsDir(agentsMarkdownDir)
+		if merr != nil {
+			if logger != nil {
+				logger.Warn("加载 agents 目录 Markdown 失败，沿用 config 中的 sub_agents", zap.Error(merr))
+			}
+		} else {
+			effectiveSubs = agents.MergeYAMLAndMarkdown(ma.SubAgents, load.SubAgents)
+			orch = load.Orchestrator
+		}
+	}
+	if ma.WithoutGeneralSubAgent && len(effectiveSubs) == 0 {
+		return nil, fmt.Errorf("multi_agent.without_general_sub_agent 为 true 时，必须在 multi_agent.sub_agents 或 agents 目录 Markdown 中配置至少一个子代理")
+	}
+
+	holder := &einomcp.ConversationHolder{}
+	holder.Set(conversationID)
+
+	var mcpIDsMu sync.Mutex
+	var mcpIDs []string
+	recorder := func(id string) {
+		if id == "" {
+			return
+		}
+		mcpIDsMu.Lock()
+		mcpIDs = append(mcpIDs, id)
+		mcpIDsMu.Unlock()
+	}
+
+	// 与单代理流式一致：在 response_start / response_delta 的 data 中带当前 mcpExecutionIds，供主聊天绑定复制与展示。
+	snapshotMCPIDs := func() []string {
+		mcpIDsMu.Lock()
+		defer mcpIDsMu.Unlock()
+		out := make([]string, len(mcpIDs))
+		copy(out, mcpIDs)
+		return out
+	}
+
+	mainDefs := ag.ToolsForRole(roleTools)
+	mainTools, err := einomcp.ToolsFromDefinitions(ag, holder, mainDefs, recorder)
+	if err != nil {
+		return nil, err
+	}
+
+	httpClient := &http.Client{
+		Timeout: 30 * time.Minute,
+		Transport: &http.Transport{
+			DialContext: (&net.Dialer{
+				Timeout:   300 * time.Second,
+				KeepAlive: 300 * time.Second,
+			}).DialContext,
+			MaxIdleConns:          100,
+			MaxIdleConnsPerHost:   10,
+			IdleConnTimeout:       90 * time.Second,
+			TLSHandshakeTimeout:   30 * time.Second,
+			ResponseHeaderTimeout: 60 * time.Minute,
+		},
+	}
+
+	baseModelCfg := &einoopenai.ChatModelConfig{
+		APIKey:     appCfg.OpenAI.APIKey,
+		BaseURL:    strings.TrimSuffix(appCfg.OpenAI.BaseURL, "/"),
+		Model:      appCfg.OpenAI.Model,
+		HTTPClient: httpClient,
+	}
+
+	deepMaxIter := ma.MaxIteration
+	if deepMaxIter <= 0 {
+		deepMaxIter = appCfg.Agent.MaxIterations
+	}
+	if deepMaxIter <= 0 {
+		deepMaxIter = 40
+	}
+
+	subDefaultIter := ma.SubAgentMaxIterations
+	if subDefaultIter <= 0 {
+		subDefaultIter = 20
+	}
+
+	subAgents := make([]adk.Agent, 0, len(effectiveSubs))
+	for _, sub := range effectiveSubs {
+		id := strings.TrimSpace(sub.ID)
+		if id == "" {
+			return nil, fmt.Errorf("multi_agent.sub_agents 中存在空的 id")
+		}
+		name := strings.TrimSpace(sub.Name)
+		if name == "" {
+			name = id
+		}
+		desc := strings.TrimSpace(sub.Description)
+		if desc == "" {
+			desc = fmt.Sprintf("Specialist agent %s for penetration testing workflow.", id)
+		}
+		instr := strings.TrimSpace(sub.Instruction)
+		if instr == "" {
+			instr = "你是 CyberStrikeAI 中的专业子代理，在授权渗透测试场景下协助完成用户委托的子任务。优先使用可用工具获取证据，回答简洁专业。"
+		}
+
+		roleTools := sub.RoleTools
+		bind := strings.TrimSpace(sub.BindRole)
+		if bind != "" && appCfg.Roles != nil {
+			if r, ok := appCfg.Roles[bind]; ok && r.Enabled {
+				if len(roleTools) == 0 && len(r.Tools) > 0 {
+					roleTools = r.Tools
+				}
+				if len(r.Skills) > 0 {
+					var b strings.Builder
+					b.WriteString(instr)
+					b.WriteString("\n\n本角色推荐通过 list_skills / read_skill 按需加载的 Skills：")
+					for i, s := range r.Skills {
+						if i > 0 {
+							b.WriteString("、")
+						}
+						b.WriteString(s)
+					}
+					b.WriteString("。")
+					instr = b.String()
+				}
+			}
+		}
+
+		subModel, err := einoopenai.NewChatModel(ctx, baseModelCfg)
+		if err != nil {
+			return nil, fmt.Errorf("子代理 %q ChatModel: %w", id, err)
+		}
+
+		subDefs := ag.ToolsForRole(roleTools)
+		subTools, err := einomcp.ToolsFromDefinitions(ag, holder, subDefs, recorder)
+		if err != nil {
+			return nil, fmt.Errorf("子代理 %q 工具: %w", id, err)
+		}
+
+		subMax := sub.MaxIterations
+		if subMax <= 0 {
+			subMax = subDefaultIter
+		}
+
+		sa, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
+			Name:        id,
+			Description: desc,
+			Instruction: instr,
+			Model:       subModel,
+			ToolsConfig: adk.ToolsConfig{
+				ToolsNodeConfig: compose.ToolsNodeConfig{
+					Tools: subTools,
+				},
+				EmitInternalEvents: true,
+			},
+			MaxIterations: subMax,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("子代理 %q: %w", id, err)
+		}
+		subAgents = append(subAgents, sa)
+	}
+
+	mainModel, err := einoopenai.NewChatModel(ctx, baseModelCfg)
+	if err != nil {
+		return nil, fmt.Errorf("Deep 主模型: %w", err)
+	}
+
+	// 与 deep.Config.Name 一致。子代理的 assistant 正文也会经 EmitInternalEvents 流出，若全部当主回复会重复（编排器总结 + 子代理原文）。
+	orchestratorName := "cyberstrike-deep"
+	orchDescription := "Coordinates specialist agents and MCP tools for authorized security testing."
+	orchInstruction := strings.TrimSpace(ma.OrchestratorInstruction)
+	if orch != nil {
+		if strings.TrimSpace(orch.EinoName) != "" {
+			orchestratorName = strings.TrimSpace(orch.EinoName)
+		}
+		if d := strings.TrimSpace(orch.Description); d != "" {
+			orchDescription = d
+		}
+		if ins := strings.TrimSpace(orch.Instruction); ins != "" {
+			orchInstruction = ins
+		}
+	}
+	da, err := deep.New(ctx, &deep.Config{
+		Name:                   orchestratorName,
+		Description:            orchDescription,
+		ChatModel:              mainModel,
+		Instruction:            orchInstruction,
+		SubAgents:              subAgents,
+		WithoutGeneralSubAgent: ma.WithoutGeneralSubAgent,
+		WithoutWriteTodos:      ma.WithoutWriteTodos,
+		MaxIteration:           deepMaxIter,
+		ToolsConfig: adk.ToolsConfig{
+			ToolsNodeConfig: compose.ToolsNodeConfig{
+				Tools: mainTools,
+			},
+			EmitInternalEvents: true,
+		},
+	})
+	if err != nil {
+		return nil, fmt.Errorf("deep.New: %w", err)
+	}
+
+	msgs := historyToMessages(history)
+	msgs = append(msgs, schema.UserMessage(userMessage))
+
+	runner := adk.NewRunner(ctx, adk.RunnerConfig{
+		Agent:           da,
+		EnableStreaming: true,
+	})
+	iter := runner.Run(ctx, msgs)
+
+	streamsMainAssistant := func(agent string) bool {
+		return agent == "" || agent == orchestratorName
+	}
+
+	var lastAssistant string
+	var reasoningStreamSeq int64
+	var einoSubReplyStreamSeq int64
+	toolEmitSeen := make(map[string]struct{})
+	for {
+		ev, ok := iter.Next()
+		if !ok {
+			break
+		}
+		if ev == nil {
+			continue
+		}
+		if ev.Err != nil {
+			if progress != nil {
+				progress("error", ev.Err.Error(), map[string]interface{}{
+					"conversationId": conversationID,
+					"source":         "eino",
+				})
+			}
+			return nil, ev.Err
+		}
+		if ev.AgentName != "" && progress != nil {
+			progress("progress", fmt.Sprintf("[Eino] %s", ev.AgentName), map[string]interface{}{
+				"conversationId": conversationID,
+				"einoAgent":      ev.AgentName,
+			})
+		}
+		if ev.Output == nil || ev.Output.MessageOutput == nil {
+			continue
+		}
+		mv := ev.Output.MessageOutput
+
+		if mv.IsStreaming && mv.MessageStream != nil {
+			streamHeaderSent := false
+			var reasoningStreamID string
+			var toolStreamFragments []schema.ToolCall
+			var subAssistantBuf strings.Builder
+			var subReplyStreamID string
+			for {
+				chunk, rerr := mv.MessageStream.Recv()
+				if rerr != nil {
+					if errors.Is(rerr, io.EOF) {
+						break
+					}
+					if logger != nil {
+						logger.Warn("eino stream recv", zap.Error(rerr))
+					}
+					break
+				}
+				if chunk == nil {
+					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,
+						})
+					}
+					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,
+							})
+							streamHeaderSent = true
+						}
+						progress("response_delta", chunk.Content, map[string]interface{}{
+							"conversationId":  conversationID,
+							"mcpExecutionIds": snapshotMCPIDs(),
+						})
+						lastAssistant += 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{}{
+									"streamId":       subReplyStreamID,
+									"einoAgent":      ev.AgentName,
+									"conversationId": conversationID,
+									"source":         "eino",
+								})
+							}
+							progress("eino_agent_reply_stream_delta", chunk.Content, map[string]interface{}{
+								"streamId":       subReplyStreamID,
+								"conversationId": conversationID,
+							})
+						}
+						subAssistantBuf.WriteString(chunk.Content)
+					}
+				}
+				// 收集流式 tool_calls 全部分片；arguments 在最后一帧常为 ""，需按 index/id 合并后才能展示 subagent_type/description。
+				if len(chunk.ToolCalls) > 0 {
+					toolStreamFragments = append(toolStreamFragments, chunk.ToolCalls...)
+				}
+			}
+			if subAssistantBuf.Len() > 0 && progress != nil {
+				if s := strings.TrimSpace(subAssistantBuf.String()); s != "" {
+					if subReplyStreamID != "" {
+						progress("eino_agent_reply_stream_end", s, map[string]interface{}{
+							"streamId":       subReplyStreamID,
+							"einoAgent":      ev.AgentName,
+							"conversationId": conversationID,
+							"source":         "eino",
+						})
+					} else {
+						progress("eino_agent_reply", s, map[string]interface{}{
+							"conversationId": conversationID,
+							"einoAgent":      ev.AgentName,
+							"source":         "eino",
+						})
+					}
+				}
+			}
+			var lastToolChunk *schema.Message
+			if merged := mergeStreamingToolCallFragments(toolStreamFragments); len(merged) > 0 {
+				lastToolChunk = &schema.Message{ToolCalls: merged}
+			}
+			tryEmitToolCallsOnce(lastToolChunk, ev.AgentName, conversationID, progress, toolEmitSeen)
+			continue
+		}
+
+		msg, gerr := mv.GetMessage()
+		if gerr != nil || msg == nil {
+			continue
+		}
+		tryEmitToolCallsOnce(mergeMessageToolCalls(msg), ev.AgentName, conversationID, progress, toolEmitSeen)
+
+		if mv.Role == schema.Assistant {
+			if progress != nil && strings.TrimSpace(msg.ReasoningContent) != "" {
+				progress("thinking", strings.TrimSpace(msg.ReasoningContent), map[string]interface{}{
+					"conversationId": conversationID,
+					"source":         "eino",
+					"einoAgent":      ev.AgentName,
+				})
+			}
+			body := strings.TrimSpace(msg.Content)
+			if body != "" {
+				if streamsMainAssistant(ev.AgentName) {
+					if progress != nil {
+						progress("response_start", "", map[string]interface{}{
+							"conversationId":     conversationID,
+							"mcpExecutionIds":    snapshotMCPIDs(),
+							"messageGeneratedBy": "eino:" + ev.AgentName,
+						})
+						progress("response_delta", body, map[string]interface{}{
+							"conversationId":  conversationID,
+							"mcpExecutionIds": snapshotMCPIDs(),
+						})
+					}
+					lastAssistant += body
+				} else if progress != nil {
+					progress("eino_agent_reply", body, map[string]interface{}{
+						"conversationId": conversationID,
+						"einoAgent":      ev.AgentName,
+						"source":         "eino",
+					})
+				}
+			}
+		}
+
+		if mv.Role == schema.Tool && progress != nil {
+			toolName := msg.ToolName
+			if toolName == "" {
+				toolName = mv.ToolName
+			}
+			preview := msg.Content
+			if len(preview) > 200 {
+				preview = preview[:200] + "..."
+			}
+			data := map[string]interface{}{
+				"toolName":       toolName,
+				"success":        true,
+				"result":         msg.Content,
+				"resultPreview":  preview,
+				"conversationId": conversationID,
+				"einoAgent":      ev.AgentName,
+				"source":         "eino",
+			}
+			if msg.ToolCallID != "" {
+				data["toolCallId"] = msg.ToolCallID
+			}
+			progress("tool_result", fmt.Sprintf("工具结果 (%s)", toolName), data)
+		}
+	}
+
+	mcpIDsMu.Lock()
+	ids := append([]string(nil), mcpIDs...)
+	mcpIDsMu.Unlock()
+
+	histJSON, _ := json.Marshal(msgs)
+	cleaned := strings.TrimSpace(lastAssistant)
+	cleaned = dedupeRepeatedParagraphs(cleaned, 80)
+	cleaned = dedupeParagraphsByLineFingerprint(cleaned, 100)
+	out := &RunResult{
+		Response:        cleaned,
+		MCPExecutionIDs: ids,
+		LastReActInput:  string(histJSON),
+		LastReActOutput: cleaned,
+	}
+	if out.Response == "" {
+		out.Response = "（Eino DeepAgent 已完成，但未捕获到助手文本输出。请查看过程详情或日志。）"
+		out.LastReActOutput = out.Response
+	}
+	return out, nil
+}
+
+func historyToMessages(history []agent.ChatMessage) []adk.Message {
+	if len(history) == 0 {
+		return nil
+	}
+	const maxTurns = 40
+	start := 0
+	if len(history) > maxTurns {
+		start = len(history) - maxTurns
+	}
+	out := make([]adk.Message, 0, len(history[start:]))
+	for _, h := range history[start:] {
+		switch h.Role {
+		case "user":
+			if strings.TrimSpace(h.Content) != "" {
+				out = append(out, schema.UserMessage(h.Content))
+			}
+		case "assistant":
+			if strings.TrimSpace(h.Content) == "" && len(h.ToolCalls) > 0 {
+				continue
+			}
+			if strings.TrimSpace(h.Content) != "" {
+				out = append(out, schema.AssistantMessage(h.Content, nil))
+			}
+		default:
+			continue
+		}
+	}
+	return out
+}
+
+// mergeStreamingToolCallFragments 将流式多帧的 ToolCall 按 index 合并 arguments（与 schema.concatToolCalls 行为一致）。
+func mergeStreamingToolCallFragments(fragments []schema.ToolCall) []schema.ToolCall {
+	if len(fragments) == 0 {
+		return nil
+	}
+	m, err := schema.ConcatMessages([]*schema.Message{{ToolCalls: fragments}})
+	if err != nil || m == nil {
+		return fragments
+	}
+	return m.ToolCalls
+}
+
+// mergeMessageToolCalls 非流式路径上若仍带分片式 tool_calls，合并后再上报 UI。
+func mergeMessageToolCalls(msg *schema.Message) *schema.Message {
+	if msg == nil || len(msg.ToolCalls) == 0 {
+		return msg
+	}
+	m, err := schema.ConcatMessages([]*schema.Message{msg})
+	if err != nil || m == nil {
+		return msg
+	}
+	out := *msg
+	out.ToolCalls = m.ToolCalls
+	return &out
+}
+
+// toolCallStableID 用于流式阶段去重；OpenAI 流式常先给 index 后补 id。
+func toolCallStableID(tc schema.ToolCall) string {
+	if tc.ID != "" {
+		return tc.ID
+	}
+	if tc.Index != nil {
+		return fmt.Sprintf("idx:%d", *tc.Index)
+	}
+	return ""
+}
+
+// toolCallDisplayName 避免前端「未知工具」：DeepAgent 内置 task 等可能延迟写入 function.name。
+func toolCallDisplayName(tc schema.ToolCall) string {
+	if n := strings.TrimSpace(tc.Function.Name); n != "" {
+		return n
+	}
+	if n := strings.TrimSpace(tc.Type); n != "" && !strings.EqualFold(n, "function") {
+		return n
+	}
+	return "task"
+}
+
+// toolCallsSignatureFlush 用于去重键；无 id/index 时用占位 pos，避免流末帧缺 id 时整条工具事件丢失。
+func toolCallsSignatureFlush(msg *schema.Message) string {
+	if msg == nil || len(msg.ToolCalls) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(msg.ToolCalls))
+	for i, tc := range msg.ToolCalls {
+		id := toolCallStableID(tc)
+		if id == "" {
+			id = fmt.Sprintf("pos:%d", i)
+		}
+		parts = append(parts, id+"|"+toolCallDisplayName(tc))
+	}
+	sort.Strings(parts)
+	return strings.Join(parts, ";")
+}
+
+// toolCallsRichSignature 用于去重：同一次流式已上报后，紧随其后的非流式消息常带相同 tool_calls。
+func toolCallsRichSignature(msg *schema.Message) string {
+	base := toolCallsSignatureFlush(msg)
+	if base == "" {
+		return ""
+	}
+	parts := make([]string, 0, len(msg.ToolCalls))
+	for _, tc := range msg.ToolCalls {
+		id := toolCallStableID(tc)
+		arg := tc.Function.Arguments
+		if len(arg) > 240 {
+			arg = arg[:240]
+		}
+		parts = append(parts, id+":"+arg)
+	}
+	sort.Strings(parts)
+	return base + "|" + strings.Join(parts, ";")
+}
+
+func tryEmitToolCallsOnce(msg *schema.Message, agentName, conversationID string, progress func(string, string, interface{}), seen map[string]struct{}) {
+	if msg == nil || len(msg.ToolCalls) == 0 || progress == nil || seen == nil {
+		return
+	}
+	if toolCallsSignatureFlush(msg) == "" {
+		return
+	}
+	sig := agentName + "\x1e" + toolCallsRichSignature(msg)
+	if _, ok := seen[sig]; ok {
+		return
+	}
+	seen[sig] = struct{}{}
+	emitToolCallsFromMessage(msg, agentName, conversationID, progress)
+}
+
+func emitToolCallsFromMessage(msg *schema.Message, agentName, conversationID string, progress func(string, string, interface{})) {
+	if msg == nil || len(msg.ToolCalls) == 0 || progress == nil {
+		return
+	}
+	progress("tool_calls_detected", fmt.Sprintf("检测到 %d 个工具调用", len(msg.ToolCalls)), map[string]interface{}{
+		"count":          len(msg.ToolCalls),
+		"conversationId": conversationID,
+		"source":         "eino",
+		"einoAgent":      agentName,
+	})
+	for idx, tc := range msg.ToolCalls {
+		argStr := strings.TrimSpace(tc.Function.Arguments)
+		if argStr == "" && len(tc.Extra) > 0 {
+			if b, mErr := json.Marshal(tc.Extra); mErr == nil {
+				argStr = string(b)
+			}
+		}
+		var argsObj map[string]interface{}
+		if argStr != "" {
+			if uErr := json.Unmarshal([]byte(argStr), &argsObj); uErr != nil || argsObj == nil {
+				argsObj = map[string]interface{}{"_raw": argStr}
+			}
+		}
+		display := toolCallDisplayName(tc)
+		toolCallID := tc.ID
+		if toolCallID == "" && tc.Index != nil {
+			toolCallID = fmt.Sprintf("eino-stream-%d", *tc.Index)
+		}
+		progress("tool_call", fmt.Sprintf("正在调用工具: %s", display), map[string]interface{}{
+			"toolName":       display,
+			"arguments":      argStr,
+			"argumentsObj":   argsObj,
+			"toolCallId":     toolCallID,
+			"index":          idx + 1,
+			"total":          len(msg.ToolCalls),
+			"conversationId": conversationID,
+			"source":         "eino",
+			"einoAgent":      agentName,
+		})
+	}
+}
+
+// dedupeRepeatedParagraphs 去掉完全相同的连续/重复段落，缓解多代理各自复述同一列表。
+func dedupeRepeatedParagraphs(s string, minLen int) string {
+	if s == "" || minLen <= 0 {
+		return s
+	}
+	paras := strings.Split(s, "\n\n")
+	var out []string
+	seen := make(map[string]bool)
+	for _, p := range paras {
+		t := strings.TrimSpace(p)
+		if len(t) < minLen {
+			out = append(out, p)
+			continue
+		}
+		if seen[t] {
+			continue
+		}
+		seen[t] = true
+		out = append(out, p)
+	}
+	return strings.TrimSpace(strings.Join(out, "\n\n"))
+}
+
+// dedupeParagraphsByLineFingerprint 去掉「正文行集合相同」的重复段落（开场白略不同也会合并），缓解多代理各写一遍目录清单。
+func dedupeParagraphsByLineFingerprint(s string, minParaLen int) string {
+	if s == "" || minParaLen <= 0 {
+		return s
+	}
+	paras := strings.Split(s, "\n\n")
+	var out []string
+	seen := make(map[string]bool)
+	for _, p := range paras {
+		t := strings.TrimSpace(p)
+		if len(t) < minParaLen {
+			out = append(out, p)
+			continue
+		}
+		fp := paragraphLineFingerprint(t)
+		// 指纹仅在「≥4 条非空行」时有效；单行/短段落长回复（如自我介绍）fp 为空，必须保留，否则会误删全文并触发「未捕获到助手文本」占位。
+		if fp == "" {
+			out = append(out, p)
+			continue
+		}
+		if seen[fp] {
+			continue
+		}
+		seen[fp] = true
+		out = append(out, p)
+	}
+	return strings.TrimSpace(strings.Join(out, "\n\n"))
+}
+
+func paragraphLineFingerprint(t string) string {
+	lines := strings.Split(t, "\n")
+	norm := make([]string, 0, len(lines))
+	for _, L := range lines {
+		s := strings.TrimSpace(L)
+		if s == "" {
+			continue
+		}
+		norm = append(norm, s)
+	}
+	if len(norm) < 4 {
+		return ""
+	}
+	sort.Strings(norm)
+	return strings.Join(norm, "\x1e")
+}