系统提示词优化

Cargo.toml

@@ -38,3 +38,10 @@ hostname = "0.3"
 sqlx = { version = "0.8", features = ["sqlite", "macros", "chrono", "runtime-tokio"] }
 jieba-rs = "0.9"
 which = "7"
+rmcp = { version = "1.6", default-features = false, features = [
+  "client",
+  "transport-child-process",
+  "transport-streamable-http-client-reqwest",
+  "which-command",
+] }
+http = "1"

src/agent/system_prompt.rs

@@ -111,9 +111,10 @@ impl PromptSection for YourTaskSection {
     fn build(&self, _ctx: &PromptContext<'_>) -> String {
         "## 你的任务
 
-当用户发送消息时，立即行动。使用工具来完成他们的请求。
+当用户发送消息时，立即行动。使用工具来完成他们的请求。尽你所有能力利用已有的工具或者skill来完成目标。
 不要：总结此配置、描述你的能力、用元评论回复、或输出逐步指令。
-而是：在需要时直接使用工具，完成后给出最终答案。"
+而是：在需要时直接使用工具，完成后给出最终答案。
+如果任务执行的过程中缺少必要的信息，尝试检索记忆，找不到就询问用户，最好一次性问清楚所有需要的信息。"
             .to_string()
     }
 }

src/channels/feishu.rs

@@ -780,32 +780,11 @@ impl FeishuChannel {
         Some(format!("[Reply to: {}]", text))
     }
 
-    /// Send a message to Feishu chat with specified message type
+    /// Send a message to Feishu chat with specified message type and content.
+    /// Content is passed as-is (already a JSON string for file/media, or plain text for fallback).
     async fn send_message_to_feishu(&self, receive_id: &str, receive_id_type: &str, msg_type: &str, content: &str) -> Result<(), ChannelError> {
         let token = self.get_tenant_access_token().await?;
 
-        // Feishu text messages have content limits (~64KB).
-        // Truncate if content is too long to avoid API error 230001.
-        const MAX_TEXT_LENGTH: usize = 60_000;
-
-        let payload_content = if msg_type == "text" {
-            let truncated = if content.len() > MAX_TEXT_LENGTH {
-                format!("{}...\n\n[Content truncated due to length limit]", &content[..content.ceil_char_boundary(MAX_TEXT_LENGTH)])
-            } else {
-                content.to_string()
-            };
-            serde_json::json!({ "text": truncated }).to_string()
-        } else {
-            // For post messages, content is already JSON (from markdown_to_post)
-            // But we still need to check length
-            if content.len() > MAX_TEXT_LENGTH {
-                // Fallback to truncated text for post as well
-                serde_json::json!({ "text": format!("{}...\n\n[Content truncated due to length limit]", &content[..content.ceil_char_boundary(MAX_TEXT_LENGTH)]) }).to_string()
-            } else {
-                content.to_string()
-            }
-        };
-
         let resp = self.http_client
             .post(format!("{}/im/v1/messages?receive_id_type={}", FEISHU_API_BASE, receive_id_type))
             .header("Content-Type", "application/json")
@@ -813,7 +792,7 @@ impl FeishuChannel {
             .json(&serde_json::json!({
                 "receive_id": receive_id,
                 "msg_type": msg_type,
-                "content": payload_content
+                "content": content
             }))
             .send()
             .await
@@ -1564,67 +1543,6 @@ fn strip_at_placeholders(text: &str) -> String {
     result
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Markdown parsing and Feishu card element building
-// ─────────────────────────────────────────────────────────────────────────────
-
-/// Message format types for Feishu
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum MsgFormat {
-    /// Plain text, short and no markdown
-    Text,
-    /// Rich text (links only, moderate length)
-    Post,
-    /// Interactive card with full markdown rendering
-    Interactive,
-}
-
-/// Regex patterns for markdown detection
-struct MdPatterns {
-    /// Regex to match markdown tables (header + separator + data rows)
-    table_re: Regex,
-    /// Regex to match headings (# heading)
-    heading_re: Regex,
-    /// Regex to match code blocks (```...```)
-    code_block_re: Regex,
-    /// Regex to match bold **text** or __text__
-    bold_re: Regex,
-    /// Regex to match italic *text* or _text_
-    italic_re: Regex,
-    /// Regex to match strikethrough ~~text~~
-    strike_re: Regex,
-    /// Regex to match markdown links [text](url)
-    link_re: Regex,
-    /// Regex to match unordered list items (- item or * item)
-    list_re: Regex,
-    /// Regex to match ordered list items (1. item)
-    olist_re: Regex,
-}
-
-impl MdPatterns {
-    fn new() -> Self {
-        Self {
-            table_re: Regex::new(r"((?:^[ \t]*\|.+\|[ \t]*\n)(?:^[ \t]*\|[-:\s|]+\|[ \t]*\n)(?:^[ \t]*\|.+\|[ \t]*\n?)+)").unwrap(),
-            heading_re: Regex::new(r"^(#{1,6})\s+(.+)$").unwrap(),
-            code_block_re: Regex::new(r"(```[\s\S]*?```)").unwrap(),
-            bold_re: Regex::new(r"\*\*(.+?)\*\*|__(.+?)__").unwrap(),
-            // Simple pattern: detect *text* or _text_ markers (may overlap with bold, but that's ok for detection)
-            // We use a conservative approach: detect potential italic markers
-            italic_re: Regex::new(r"\*[^*]+\*|_[^_]+_").unwrap(),
-            strike_re: Regex::new(r"~~.+?~~").unwrap(),
-            link_re: Regex::new(r"\[([^\]]+)\]\((https?://[^\)]+)\)").unwrap(),
-            list_re: Regex::new(r"^[\s]*[-*+]\s+").unwrap(),
-            olist_re: Regex::new(r"^[\s]*\d+\.\s+").unwrap(),
-        }
-    }
-}
-
-impl Default for MdPatterns {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl FeishuChannel {
     fn strip_thinking_tags(content: &str) -> String {
         use std::sync::LazyLock;
@@ -1635,328 +1553,69 @@ impl FeishuChannel {
         stripped.trim().to_string()
     }
 
-    /// Determine the optimal Feishu message format for content.
+    /// Build a Card JSON 2.0 interactive card with a single markdown element.
-    fn detect_msg_format(content: &str) -> MsgFormat {
+    fn build_card_content(markdown: &str) -> String {
-        let patterns = MdPatterns::new();
+        serde_json::json!({
-        let stripped = content.trim();
+            "schema": "2.0",
-
+            "body": {
-        // Complex markdown (code blocks, tables, headings) → always interactive card
+                "elements": [{
-        if patterns.table_re.is_match(stripped)
-            || patterns.heading_re.is_match(stripped)
-            || patterns.code_block_re.is_match(stripped)
-        {
-            return MsgFormat::Interactive;
-        }
-
-        // Long content → interactive card (better readability)
-        if stripped.len() > 2000 {
-            return MsgFormat::Interactive;
-        }
-
-        // Has bold/italic/strikethrough → interactive card (post format can't render these)
-        if patterns.bold_re.is_match(stripped)
-            || patterns.italic_re.is_match(stripped)
-            || patterns.strike_re.is_match(stripped)
-        {
-            return MsgFormat::Interactive;
-        }
-
-        // Has list items → interactive card (post format can't render list bullets well)
-        if patterns.list_re.is_match(stripped) || patterns.olist_re.is_match(stripped) {
-            return MsgFormat::Interactive;
-        }
-
-        // Has links → post format (supports <a> tags)
-        if patterns.link_re.is_match(stripped) {
-            return MsgFormat::Post;
-        }
-
-        // Short plain text → text format
-        if stripped.len() <= 200 {
-            return MsgFormat::Text;
-        }
-
-        // Medium plain text without formatting → post format
-        MsgFormat::Post
-    }
-
-    /// Strip markdown formatting markers from text for plain display.
-    fn strip_md_formatting(text: &str) -> String {
-        let patterns = MdPatterns::new();
-        let mut result = text.to_string();
-
-        // Remove bold markers
-        result = patterns.bold_re.replace_all(&result, "$1$2").to_string();
-        // Remove italic markers
-        result = patterns.italic_re.replace_all(&result, "$1$2").to_string();
-        // Remove strikethrough markers
-        result = patterns.strike_re.replace_all(&result, "$1").to_string();
-
-        result
-    }
-
-    /// Parse a markdown table into a Feishu table element.
-    fn parse_md_table(table_text: &str) -> Option<serde_json::Value> {
-        let lines: Vec<&str> = table_text
-            .trim()
-            .split('\n')
-            .map(|l| l.trim())
-            .filter(|l| !l.is_empty())
-            .collect();
-
-        if lines.len() < 3 {
-            return None;
-        }
-
-        fn split(line: &str) -> Vec<String> {
-            line.trim_start_matches('|')
-                .trim_end_matches('|')
-                .split('|')
-                .map(|c| c.trim().to_string())
-                .collect()
-        }
-
-        let headers = split(lines[0]);
-        let rows: Vec<std::collections::HashMap<String, String>> = lines[2..]
-            .iter()
-            .map(|line| {
-                let cells: Vec<String> = split(line);
-                headers
-                    .iter()
-                    .enumerate()
-                    .map(|(i, _h)| {
-                        (
-                            format!("c{}", i),
-                            if i < cells.len() {
-                                Self::strip_md_formatting(&cells[i])
-                            } else {
-                                String::new()
-                            },
-                        )
-                    })
-                    .collect()
-            })
-            .collect();
-
-        let columns: Vec<serde_json::Value> = headers
-            .iter()
-            .enumerate()
-            .map(|(i, h)| {
-                serde_json::json!({
-                    "tag": "column",
-                    "name": format!("c{}", i),
-                    "display_name": Self::strip_md_formatting(h),
-                    "width": "auto"
-                })
-            })
-            .collect();
-
-        Some(serde_json::json!({
-            "tag": "table",
-            "page_size": rows.len() + 1,
-            "columns": columns,
-            "rows": rows,
-        }))
-    }
-
-    /// Split content by headings, converting headings to div elements.
-    fn split_headings(content: &str) -> Vec<serde_json::Value> {
-        let patterns = MdPatterns::new();
-        let mut protected = content.to_string();
-
-        // Protect code blocks by replacing them with placeholders
-        let mut code_blocks: Vec<String> = Vec::new();
-        for m in patterns.code_block_re.find_iter(content) {
-            code_blocks.push(m.as_str().to_string());
-            protected = protected.replace(m.as_str(), &format!("\x00CODE{}\x00", code_blocks.len() - 1));
-        }
-
-        let mut elements: Vec<serde_json::Value> = Vec::new();
-        let mut last_end = 0;
-
-        for m in patterns.heading_re.find_iter(&protected) {
-            let before = &protected[last_end..m.start()].trim();
-            if !before.is_empty() {
-                elements.push(serde_json::json!({
                     "tag": "markdown",
-                    "content": before
+                    "content": markdown
-                }));
+                }]
+            }
+        })
+        .to_string()
+    }
+
+    /// Max byte-size for markdown content in a single card.
+    /// Card payloads have a ~30 KB limit; leave margin for JSON envelope.
+    const CARD_MARKDOWN_MAX_BYTES: usize = 28_000;
+
+    /// Split markdown content into chunks that fit within the card size limit.
+    /// Splits on line boundaries to avoid breaking markdown syntax.
+    fn split_markdown_chunks(text: &str) -> Vec<String> {
+        if text.len() <= Self::CARD_MARKDOWN_MAX_BYTES {
+            return vec![text.to_string()];
+        }
+
+        let mut chunks: Vec<String> = Vec::new();
+        let mut start = 0;
+
+        while start < text.len() {
+            if start + Self::CARD_MARKDOWN_MAX_BYTES >= text.len() {
+                chunks.push(text[start..].to_string());
+                break;
             }
 
-            let heading_text = Self::strip_md_formatting(m.as_str().trim_start_matches('#').trim());
+            let end = start + Self::CARD_MARKDOWN_MAX_BYTES;
-            let display_text = if heading_text.is_empty() {
+            let search_region = &text[start..end];
-                String::new()
+            let split_at = search_region
+                .rfind('\n')
+                .map(|pos| start + pos + 1)
+                .unwrap_or(end);
+
+            let split_at = if text.is_char_boundary(split_at) {
+                split_at
             } else {
-                format!("**{}**", heading_text)
+                (start..split_at)
+                    .rev()
+                    .find(|&i| text.is_char_boundary(i))
+                    .unwrap_or(start)
             };
 
-            elements.push(serde_json::json!({
+            if split_at <= start {
-                "tag": "div",
+                let forced = (end..=text.len())
-                "text": {
+                    .find(|&i| text.is_char_boundary(i))
-                    "tag": "lark_md",
+                    .unwrap_or(text.len());
-                    "content": display_text
+                chunks.push(text[start..forced].to_string());
-                }
+                start = forced;
-            }));
-
-            last_end = m.end();
-        }
-
-        let remaining = protected[last_end..].trim();
-        if !remaining.is_empty() {
-            // Restore code blocks
-            let mut final_content = remaining.to_string();
-            for (i, cb) in code_blocks.iter().enumerate() {
-                final_content = final_content.replace(&format!("\x00CODE{}\x00", i), cb);
-            }
-            elements.push(serde_json::json!({
-                "tag": "markdown",
-                "content": final_content
-            }));
-        }
-
-        if elements.is_empty() {
-            elements.push(serde_json::json!({
-                "tag": "markdown",
-                "content": content
-            }));
-        }
-
-        elements
-    }
-
-    /// Split card elements into groups with at most one table element each.
-    /// Feishu cards have a hard limit of one table per card (API error 11310).
-    fn split_elements_by_table_limit(elements: &[serde_json::Value]) -> Vec<Vec<serde_json::Value>> {
-        if elements.is_empty() {
-            return vec![vec![]];
-        }
-
-        let mut groups: Vec<Vec<serde_json::Value>> = Vec::new();
-        let mut current: Vec<serde_json::Value> = Vec::new();
-        let mut table_count = 0;
-
-        for el in elements {
-            if el.get("tag").and_then(|t| t.as_str()) == Some("table") {
-                if table_count >= 1 {
-                    groups.push(current);
-                    current = Vec::new();
-                    table_count = 0;
-                }
-                current.push(el.clone());
-                table_count += 1;
             } else {
-                current.push(el.clone());
+                chunks.push(text[start..split_at].to_string());
+                start = split_at;
             }
         }
 
-        if !current.is_empty() {
+        chunks
-            groups.push(current);
-        }
-
-        groups
-    }
-
-    /// Build content into card elements (div/markdown + table).
-    fn build_card_elements(content: &str) -> Vec<serde_json::Value> {
-        let patterns = MdPatterns::new();
-        let mut elements: Vec<serde_json::Value> = Vec::new();
-        let mut last_end = 0;
-
-        // Find all tables in content
-        for m in patterns.table_re.find_iter(content) {
-            let before = &content[last_end..m.start()];
-            if !before.trim().is_empty() {
-                elements.extend(Self::split_headings(before));
-            }
-
-            if let Some(table) = Self::parse_md_table(m.as_str()) {
-                elements.push(table);
-            } else {
-                elements.push(serde_json::json!({
-                    "tag": "markdown",
-                    "content": m.as_str()
-                }));
-            }
-
-            last_end = m.end();
-        }
-
-        let remaining = &content[last_end..];
-        if !remaining.trim().is_empty() {
-            elements.extend(Self::split_headings(remaining));
-        }
-
-        if elements.is_empty() {
-            elements.push(serde_json::json!({
-                "tag": "markdown",
-                "content": content
-            }));
-        }
-
-        elements
-    }
-
-    /// Convert markdown content to Feishu post message JSON.
-    /// Handles links [text](url) as <a> tags; everything else as text tags.
-    fn markdown_to_post(content: &str) -> String {
-        let patterns = MdPatterns::new();
-        let lines = content.trim().split('\n');
-        let mut paragraphs: Vec<Vec<serde_json::Value>> = Vec::new();
-
-        for line in lines {
-            let mut elements: Vec<serde_json::Value> = Vec::new();
-            let mut last_end = 0;
-
-            for cap in patterns.link_re.captures_iter(line) {
-                // Text before this link
-                let m = cap.get(0).unwrap();
-                let before = &line[last_end..m.start()];
-                if !before.is_empty() {
-                    elements.push(serde_json::json!({
-                        "tag": "text",
-                        "text": before
-                    }));
-                }
-
-                let link_text = cap.get(1).map(|g| g.as_str()).unwrap_or("");
-                let link_href = cap.get(2).map(|g| g.as_str()).unwrap_or("");
-
-                elements.push(serde_json::json!({
-                    "tag": "a",
-                    "text": link_text,
-                    "href": link_href
-                }));
-
-                last_end = m.end();
-            }
-
-            // Remaining text after last link
-            let remaining = &line[last_end..];
-            if !remaining.is_empty() {
-                elements.push(serde_json::json!({
-                    "tag": "text",
-                    "text": remaining
-                }));
-            }
-
-            // Empty line → empty paragraph for spacing
-            if elements.is_empty() {
-                elements.push(serde_json::json!({
-                    "tag": "text",
-                    "text": ""
-                }));
-            }
-
-            paragraphs.push(elements);
-        }
-
-        let post_body = serde_json::json!({
-            "zh_cn": {
-                "content": paragraphs
-            }
-        });
-
-        post_body.to_string()
     }
 
     /// Send an interactive card message to Feishu.
@@ -2097,7 +1756,7 @@ impl Channel for FeishuChannel {
         let receive_id = if msg.chat_id.starts_with("oc_") { &msg.chat_id } else { msg.reply_to.as_ref().unwrap_or(&msg.chat_id) };
         let receive_id_type = if msg.chat_id.starts_with("oc_") { "chat_id" } else { "open_id" };
 
-        // If no media, use smart format detection
+        // If no media, send as interactive card with raw markdown
         if msg.media.is_empty() {
             let content = msg.content.trim();
 
@@ -2107,42 +1766,19 @@ impl Channel for FeishuChannel {
                 return Ok(());
             }
 
-            let fmt = Self::detect_msg_format(content);
+            let chunks = Self::split_markdown_chunks(content);
-
+            for chunk in &chunks {
-            match fmt {
+                let card = Self::build_card_content(chunk);
-                MsgFormat::Text => {
+                if let Err(e) = self.send_interactive_card(receive_id, receive_id_type, &card).await {
-                    // Short plain text – send as simple text message
+                    tracing::warn!(error = %e, "Failed to send interactive card, falling back to text");
-                    let result = self.send_message_to_feishu(receive_id, receive_id_type, "text", content).await;
+                    let text_content = serde_json::json!({ "text": chunk }).to_string();
+                    let result = self.send_message_to_feishu(receive_id, receive_id_type, "text", &text_content).await;
                     self.remove_reaction_from_metadata(&msg.metadata).await;
                     return result;
                 }
-                MsgFormat::Post => {
-                    // Medium content with links – send as rich-text post
-                    let post_body = Self::markdown_to_post(content);
-                    let result = self.send_message_to_feishu(receive_id, receive_id_type, "post", &post_body).await;
-                    self.remove_reaction_from_metadata(&msg.metadata).await;
-                    return result;
-                }
-                MsgFormat::Interactive => {
-                    // Complex / long content – send as interactive card
-                    let elements = Self::build_card_elements(content);
-                    for chunk in Self::split_elements_by_table_limit(&elements) {
-                        let card = serde_json::json!({
-                            "config": { "wide_screen_mode": true },
-                            "elements": chunk
-                        });
-                        if let Err(e) = self.send_interactive_card(receive_id, receive_id_type, &card.to_string()).await {
-                            tracing::warn!(error = %e, "Failed to send interactive card, falling back to text");
-                            // Fallback to plain text
-                            let result = self.send_message_to_feishu(receive_id, receive_id_type, "text", content).await;
-                            self.remove_reaction_from_metadata(&msg.metadata).await;
-                            return result;
-                        }
-                    }
-                    self.remove_reaction_from_metadata(&msg.metadata).await;
-                    return Ok(());
-                }
             }
+            self.remove_reaction_from_metadata(&msg.metadata).await;
+            return Ok(());
         }
 
         // Handle multimodal message - send with media

src/config/mod.rs

@@ -53,6 +53,8 @@ pub struct Config {
     pub memory: MemoryConfig,
     #[serde(default = "default_workspace_dir")]
     pub workspace_dir: String,
+    #[serde(default)]
+    pub mcp: McpConfig,
 }
 
 fn default_workspace_dir() -> String {
@@ -269,6 +271,59 @@ impl MemoryConfig {
     }
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct McpConfig {
+    #[serde(default)]
+    pub servers: Vec<McpServerConfig>,
+    #[serde(default = "default_mcp_tool_timeout_secs")]
+    pub tool_timeout_secs: u64,
+}
+
+impl Default for McpConfig {
+    fn default() -> Self {
+        Self {
+            servers: Vec::new(),
+            tool_timeout_secs: default_mcp_tool_timeout_secs(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct McpServerConfig {
+    pub name: String,
+    #[serde(default = "default_mcp_transport")]
+    pub transport: McpTransport,
+    #[serde(default)]
+    pub command: Option<String>,
+    #[serde(default)]
+    pub args: Vec<String>,
+    #[serde(default)]
+    pub env: HashMap<String, String>,
+    #[serde(default)]
+    pub url: Option<String>,
+    #[serde(default)]
+    pub headers: HashMap<String, String>,
+    #[serde(default)]
+    pub tool_timeout_secs: Option<u64>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum McpTransport {
+    Stdio,
+    Sse,
+    #[serde(alias = "streamable-http")]
+    StreamableHttp,
+}
+
+fn default_mcp_transport() -> McpTransport {
+    McpTransport::Stdio
+}
+
+fn default_mcp_tool_timeout_secs() -> u64 {
+    180
+}
+
 fn default_recall_limit() -> usize { 5 }
 fn default_idle_consolidation_minutes() -> u64 { 10 }
 fn default_timeline_retention_days() -> u64 { 90 }

src/gateway/mod.rs

@@ -10,6 +10,7 @@ use crate::channels::{ChannelManager, CliChatChannel};
 use crate::channels::base::{Channel, ChannelError};
 use crate::config::{Config, expand_path, ensure_workspace_dir};
 use crate::logging;
+use crate::mcp;
 use crate::memory::MemoryManager;
 use crate::session::SessionManager;
 use crate::scheduler::Scheduler;
@@ -102,6 +103,21 @@ impl GatewayState {
             crate::tools::ChatManagerTool::new(storage.clone(), valid_channels.clone()),
         );
 
+        // Initialize MCP servers — connect and register discovered tools
+        if !config.mcp.servers.is_empty() {
+            let mcp_tools = mcp::connect_all(&config.mcp).await;
+            for tool_info in mcp_tools {
+                let wrapper = mcp::McpToolWrapper::new(
+                    &tool_info.server_name,
+                    tool_info.tool_name,
+                    tool_info.description,
+                    tool_info.schema,
+                    tool_info.connection,
+                );
+                session_manager.tools().register(wrapper);
+            }
+        }
+
         // Initialize scheduler if enabled in config
         let scheduler_config = config.gateway.scheduler.clone().unwrap_or_default();
         if scheduler_config.enabled {

src/lib.rs

@@ -8,6 +8,7 @@ pub mod client;
 pub mod protocol;
 pub mod channels;
 pub mod logging;
+pub mod mcp;
 pub mod memory;
 pub mod observability;
 pub mod scheduler;

src/mcp/mod.rs

@@ -0,0 +1,303 @@
+pub mod tool_wrapper;
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+use anyhow::Context;
+use http::{HeaderName, HeaderValue};
+use rmcp::model::{CallToolRequestParams, RawContent};
+use rmcp::transport::streamable_http_client::StreamableHttpClientTransportConfig;
+use rmcp::transport::{StreamableHttpClientTransport, TokioChildProcess};
+use rmcp::{Peer, RoleClient, ServiceExt};
+use tokio::process::Command;
+
+use crate::config::{McpConfig, McpServerConfig, McpTransport};
+use crate::tools::ToolResult;
+
+pub use tool_wrapper::McpToolWrapper;
+
+/// Status of a single MCP tool.
+#[derive(Debug, Clone)]
+pub struct McpToolStatus {
+    pub name: String,
+    pub description: String,
+}
+
+/// Status of a single MCP server.
+#[derive(Debug, Clone)]
+pub struct McpServerStatus {
+    pub name: String,
+    pub transport: String,
+    pub connected: bool,
+    pub error: Option<String>,
+    pub tools: Vec<McpToolStatus>,
+}
+
+static MCP_SERVER_STATUS: Mutex<Vec<McpServerStatus>> = Mutex::new(Vec::new());
+
+pub fn get_mcp_status() -> Vec<McpServerStatus> {
+    MCP_SERVER_STATUS.lock().unwrap().clone()
+}
+
+fn update_mcp_status(servers: Vec<McpServerStatus>) {
+    let mut status = MCP_SERVER_STATUS.lock().unwrap();
+    *status = servers;
+}
+
+/// A connected MCP server. Holds a clonable Peer handle for tool calls,
+/// and keeps the underlying service alive via a background task.
+pub struct McpConnection {
+    #[allow(dead_code)]
+    pub name: String,
+    peer: Peer<RoleClient>,
+    /// Keep the service alive. When dropped, the MCP connection is closed.
+    _service: Option<Box<dyn std::any::Any + Send + Sync>>,
+}
+
+impl McpConnection {
+    pub async fn call_tool(
+        &self,
+        tool_name: &str,
+        arguments: serde_json::Value,
+    ) -> anyhow::Result<ToolResult> {
+        let result = self
+            .peer
+            .call_tool(
+                CallToolRequestParams::new(tool_name.to_string())
+                    .with_arguments(arguments.as_object().cloned().unwrap_or_default()),
+            )
+            .await
+            .context("MCP tool call failed")?;
+
+        let is_error = result.is_error.unwrap_or(false);
+        let output = extract_text(&result);
+
+        Ok(ToolResult {
+            success: !is_error,
+            output,
+            error: if is_error {
+                Some("MCP server returned an error".to_string())
+            } else {
+                None
+            },
+        })
+    }
+}
+
+fn extract_text(result: &rmcp::model::CallToolResult) -> String {
+    let mut parts = Vec::new();
+    for content in &result.content {
+        match &**content {
+            RawContent::Text(text) => {
+                parts.push(text.text.clone());
+            }
+            RawContent::Image(image) => {
+                parts.push(format!(
+                    "[image: {}]",
+                    image.mime_type,
+                ));
+            }
+            RawContent::Resource(resource) => {
+                match &resource.resource {
+                    rmcp::model::ResourceContents::TextResourceContents { text, .. } => {
+                        parts.push(format!(
+                            "[resource text: {}]",
+                            text.chars().take(200).collect::<String>(),
+                        ));
+                    }
+                    rmcp::model::ResourceContents::BlobResourceContents { uri, .. } => {
+                        parts.push(format!("[resource blob: {}]", uri));
+                    }
+                }
+            }
+            _ => {
+                parts.push("[unsupported content]".to_string());
+            }
+        }
+    }
+    if parts.is_empty() {
+        String::new()
+    } else {
+        parts.join("\n")
+    }
+}
+
+pub struct ToolInfo {
+    pub server_name: String,
+    pub tool_name: String,
+    pub description: String,
+    pub schema: serde_json::Value,
+    pub connection: Arc<McpConnection>,
+}
+
+pub async fn connect_all(config: &McpConfig) -> Vec<ToolInfo> {
+    let mut tools = Vec::new();
+    let mut server_statuses = Vec::new();
+
+    for server_config in &config.servers {
+        let transport_str = match server_config.transport {
+            McpTransport::Stdio => "stdio",
+            McpTransport::Sse => "sse",
+            McpTransport::StreamableHttp => "streamable-http",
+        };
+
+        match connect_server(server_config).await {
+            Ok(connection) => {
+                let connection = Arc::new(connection);
+                match list_tools(&connection).await {
+                    Ok(server_tools) => {
+                        tracing::info!(
+                            server = %server_config.name,
+                            count = server_tools.len(),
+                            "MCP server connected"
+                        );
+                        let tool_statuses: Vec<McpToolStatus> = server_tools
+                            .iter()
+                            .map(|(name, desc, _)| McpToolStatus {
+                                name: name.clone(),
+                                description: desc.clone(),
+                            })
+                            .collect();
+                        server_statuses.push(McpServerStatus {
+                            name: server_config.name.clone(),
+                            transport: transport_str.to_string(),
+                            connected: true,
+                            error: None,
+                            tools: tool_statuses,
+                        });
+                        for (orig_name, desc, schema) in server_tools {
+                            tools.push(ToolInfo {
+                                server_name: server_config.name.clone(),
+                                tool_name: orig_name,
+                                description: desc,
+                                schema,
+                                connection: connection.clone(),
+                            });
+                        }
+                    }
+                    Err(e) => {
+                        tracing::error!(
+                            server = %server_config.name,
+                            error = %e,
+                            "Failed to list MCP tools"
+                        );
+                        server_statuses.push(McpServerStatus {
+                            name: server_config.name.clone(),
+                            transport: transport_str.to_string(),
+                            connected: false,
+                            error: Some(e.to_string()),
+                            tools: Vec::new(),
+                        });
+                    }
+                }
+            }
+            Err(e) => {
+                tracing::error!(
+                    server = %server_config.name,
+                    error = %e,
+                    "Failed to connect to MCP server"
+                );
+                server_statuses.push(McpServerStatus {
+                    name: server_config.name.clone(),
+                    transport: transport_str.to_string(),
+                    connected: false,
+                    error: Some(e.to_string()),
+                    tools: Vec::new(),
+                });
+            }
+        }
+    }
+
+    update_mcp_status(server_statuses);
+    tools
+}
+
+async fn connect_server(config: &McpServerConfig) -> anyhow::Result<McpConnection> {
+    match config.transport {
+        McpTransport::Stdio => {
+            let command = config
+                .command
+                .as_ref()
+                .context("stdio transport requires 'command'")?;
+            let mut cmd = Command::new(command);
+            cmd.args(&config.args);
+            for (k, v) in &config.env {
+                cmd.env(k, v);
+            }
+
+            let service = ()
+                .serve(
+                    TokioChildProcess::new(cmd).context("failed to create stdio MCP transport")?,
+                )
+                .await
+                .context("failed to connect to stdio MCP server")?;
+
+            let peer = service.peer().clone();
+
+            Ok(McpConnection {
+                name: config.name.clone(),
+                peer,
+                _service: Some(Box::new(service)),
+            })
+        }
+        McpTransport::Sse | McpTransport::StreamableHttp => {
+            let url = config
+                .url
+                .as_ref()
+                .context("sse/streamable-http transport requires 'url'")?;
+
+            let mut headers_map = HashMap::new();
+            for (k, v) in &config.headers {
+                if let (Ok(name), Ok(value)) = (
+                    HeaderName::from_bytes(k.as_bytes()),
+                    HeaderValue::from_str(v),
+                ) {
+                    headers_map.insert(name, value);
+                }
+            }
+
+            let transport = if headers_map.is_empty() {
+                StreamableHttpClientTransport::from_uri(url.to_string())
+            } else {
+                StreamableHttpClientTransport::from_config(
+                    StreamableHttpClientTransportConfig::with_uri(url.to_string())
+                        .custom_headers(headers_map)
+                )
+            };
+
+            let service = ()
+                .serve(transport)
+                .await
+                .context("failed to connect to HTTP/SSE MCP server")?;
+
+            let peer = service.peer().clone();
+
+            Ok(McpConnection {
+                name: config.name.clone(),
+                peer,
+                _service: Some(Box::new(service)),
+            })
+        }
+    }
+}
+
+async fn list_tools(
+    connection: &McpConnection,
+) -> anyhow::Result<Vec<(String, String, serde_json::Value)>> {
+    let tools = connection
+        .peer
+        .list_all_tools()
+        .await
+        .context("failed to list MCP tools")?;
+
+    Ok(tools
+        .into_iter()
+        .map(|tool| {
+            (
+                tool.name.to_string(),
+                tool.description.map(|d| d.to_string()).unwrap_or_default(),
+                serde_json::Value::Object((*tool.input_schema).clone()),
+            )
+        })
+        .collect())
+}

src/mcp/tool_wrapper.rs

@@ -0,0 +1,54 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+
+use crate::tools::{Tool, ToolResult};
+
+use super::McpConnection;
+
+pub struct McpToolWrapper {
+    full_name: String,
+    description: String,
+    parameters_schema: serde_json::Value,
+    original_tool_name: String,
+    connection: Arc<McpConnection>,
+}
+
+impl McpToolWrapper {
+    pub fn new(
+        server_name: &str,
+        original_tool_name: String,
+        description: String,
+        parameters_schema: serde_json::Value,
+        connection: Arc<McpConnection>,
+    ) -> Self {
+        Self {
+            full_name: format!("{}__{}", server_name, original_tool_name),
+            description,
+            parameters_schema,
+            original_tool_name,
+            connection,
+        }
+    }
+}
+
+#[async_trait]
+impl Tool for McpToolWrapper {
+    fn name(&self) -> &str {
+        &self.full_name
+    }
+
+    fn description(&self) -> &str {
+        &self.description
+    }
+
+    fn parameters_schema(&self) -> serde_json::Value {
+        self.parameters_schema.clone()
+    }
+
+    async fn execute(&self, args: serde_json::Value) -> anyhow::Result<ToolResult> {
+        self.connection
+            .call_tool(&self.original_tool_name, args)
+            .await
+    }
+}

src/session/session.rs

@@ -4,6 +4,7 @@ use std::sync::Arc;
 use tokio::sync::Mutex;
 
 use crate::bus::{ChatMessage, MediaItem, MessageSource, OutboundMessage, SourceKind};
+use crate::mcp::get_mcp_status;
 use crate::storage::{Storage, StorageError};
 use std::sync::Arc as StdArc;
 
@@ -799,6 +800,11 @@ pub static SLASH_COMMANDS: &[SlashCommand] = &[
         description: "显示帮助",
         aliases: &["/?", "/help"],
     },
+    SlashCommand {
+        name: "mcp",
+        description: "显示 MCP 服务状态和工具列表",
+        aliases: &["/mcp"],
+    },
 ];
 
 impl SessionManager {
@@ -987,6 +993,34 @@ impl SessionManager {
                 }).collect();
                 Ok((None, format!("可用命令：\n{}", lines.join("\n"))))
             }
+            "mcp" => {
+                let servers = get_mcp_status();
+                if servers.is_empty() {
+                    return Ok((None, "未配置 MCP 服务。".to_string()));
+                }
+                let lines: Vec<String> = servers.iter().map(|s| {
+                    let status = if s.connected {
+                        format!("✅ 已连接 ({})", s.transport)
+                    } else {
+                        format!("❌ 连接失败: {}", s.error.as_deref().unwrap_or("未知错误"))
+                    };
+                    let tool_lines: Vec<String> = s.tools.iter().map(|t| {
+                        let desc = if t.description.is_empty() {
+                            "无描述".to_string()
+                        } else {
+                            t.description.chars().take(60).collect::<String>()
+                        };
+                        format!("    - {}: {}", t.name, desc)
+                    }).collect();
+                    let tools_section = if tool_lines.is_empty() {
+                        String::new()
+                    } else {
+                        format!("\n{}", tool_lines.join("\n"))
+                    };
+                    format!("{} {}{}", s.name, status, tools_section)
+                }).collect();
+                Ok((None, format!("MCP 服务：\n\n{}", lines.join("\n\n"))))
+            }
             _ => Err(AgentError::Other(format!("未知命令：/{}。输入 /? 获取帮助。", cmd.name))),
         }
     }