jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_data/config_schema.json

@@ -7,6 +7,7 @@
     "JARVIS_MCP": {
       "type": "array",
       "description": "MCP工具配置列表",
+      "default": [],
       "items": {
         "type": "object",
         "oneOf": [
@@ -182,11 +183,42 @@
       "description": "执行工具前是否需要确认",
       "default": false
     },
+    "JARVIS_TOOL_FILTER_THRESHOLD": {
+      "type": "number",
+      "description": "AI工具筛选阈值：当可用工具数量超过此值时触发AI筛选",
+      "default": 30
+    },
+    "JARVIS_PLAN_ENABLED": {
+      "type": "boolean",
+      "description": "是否默认启用任务规划。当 Agent 初始化时 plan 参数未指定，将从此配置加载。默认 true。",
+      "default": true
+    },
+    "JARVIS_PLAN_MAX_DEPTH": {
+      "type": "number",
+      "description": "任务规划的最大层数。用于限制 plan 模式的递归拆分深度。仅在启用规划时生效（通过 CLI --plan/--no-plan 控制），默认 2。",
+      "default": 2
+    },
+    "JARVIS_SCRIPT_EXECUTION_TIMEOUT": {
+      "type": "number",
+      "description": "脚本执行的超时时间（秒），仅在非交互模式下生效。",
+      "default": 300
+    },
+    "JARVIS_AUTO_SUMMARY_ROUNDS": {
+      "type": "number",
+      "description": "基于对话轮次的自动总结阈值（达到该轮次后自动总结并清理历史）",
+      "default": 50
+    },
     "JARVIS_CONFIRM_BEFORE_APPLY_PATCH": {
       "type": "boolean",
       "description": "应用补丁前是否需要确认",
       "default": false
     },
+    "JARVIS_PATCH_FORMAT": {
+      "type": "string",
+      "enum": ["all", "search", "search_range"],
+      "description": "补丁格式处理模式：all 同时支持 SEARCH 与 SEARCH_START/SEARCH_END；search 仅允许精确片段匹配；search_range 仅允许范围匹配。",
+      "default": "all"
+    },
     "JARVIS_DATA_PATH": {
       "type": "string",
       "description": "Jarvis数据存储目录路径",
@@ -195,7 +227,7 @@
     "JARVIS_PRETTY_OUTPUT": {
       "type": "boolean",
       "description": "是否启用美化输出",
-      "default": false
+      "default": true
     },
     "JARVIS_USE_METHODOLOGY": {
       "type": "boolean",
@@ -257,12 +289,12 @@
     },
     "JARVIS_CENTRAL_METHODOLOGY_REPO": {
       "type": "string",
-      "description": "中心方法论Git仓库地址，该仓库会自动添加到方法论加载路径中",
+      "description": "中心方法论仓库路径或Git仓库地址。支持本地目录（含git子路径）：若为本地目录将直接加入方法论加载路径；若为Git URL则会克隆到数据目录后加载。",
       "default": ""
     },
     "JARVIS_CENTRAL_TOOL_REPO": {
       "type": "string",
-      "description": "中心工具库Git仓库地址，该仓库会自动克隆到数据目录并加载其中的工具",
+      "description": "中心工具仓库路径或Git仓库地址。支持本地目录（含git子路径）：若为本地目录将直接加载其中的工具；若为Git URL则会克隆到数据目录并加载。",
       "default": ""
     },
     "JARVIS_PRINT_PROMPT": {
@@ -270,31 +302,71 @@
       "description": "是否打印提示",
       "default": false
     },
+    "JARVIS_PRINT_ERROR_TRACEBACK": {
+      "type": "boolean",
+      "description": "是否在错误输出时打印回溯调用链",
+      "default": false
+    },
     "JARVIS_ENABLE_STATIC_ANALYSIS": {
       "type": "boolean",
       "description": "是否启用静态代码分析",
       "default": true
     },
+    "JARVIS_ENABLE_BUILD_VALIDATION": {
+      "type": "boolean",
+      "description": "是否启用构建验证。在代码编辑后自动验证代码能否成功编译/构建，确保编辑不会破坏项目构建。",
+      "default": true
+    },
+    "JARVIS_BUILD_VALIDATION_TIMEOUT": {
+      "type": "number",
+      "description": "构建验证的超时时间（秒）。当构建验证执行时间超过此值时，将终止验证并报告超时。",
+      "default": 30
+    },
+    "JARVIS_ENABLE_IMPACT_ANALYSIS": {
+      "type": "boolean",
+      "description": "是否启用编辑影响范围分析。分析代码编辑的影响范围，识别可能受影响的文件、函数、测试等，帮助评估编辑风险。",
+      "default": true
+    },
     "JARVIS_FORCE_SAVE_MEMORY": {
       "type": "boolean",
       "description": "是否强制保存记忆",
-      "default": true
+      "default": false
     },
     "JARVIS_ENABLE_GIT_JCA_SWITCH": {
       "type": "boolean",
       "description": "在初始化环境前检测Git仓库并提示可切换到代码开发模式（jca）",
-      "default": false
+      "default": true
     },
     "JARVIS_ENABLE_STARTUP_CONFIG_SELECTOR": {
       "type": "boolean",
       "description": "在进入默认通用代理前，列出可用配置（agent/multi_agent/roles）供选择",
-      "default": false
+      "default": true
     },
     "JARVIS_IMMEDIATE_ABORT": {
       "type": "boolean",
       "description": "是否启用立即中断：在对话迭代中检测到中断信号时立即返回",
       "default": false
     },
+    "JARVIS_SAVE_SESSION_HISTORY": {
+      "type": "boolean",
+      "description": "是否保存会话记录",
+      "default": false
+    },
+    "JARVIS_SKIP_PREDEFINED_TASKS": {
+      "type": "boolean",
+      "description": "是否跳过预定义任务加载（不读取 pre-command 列表）",
+      "default": false
+    },
+    "JARVIS_ADDON_PROMPT_THRESHOLD": {
+      "type": "number",
+      "description": "附加提示的触发阈值（字符数）。当消息长度超过此值时，会自动添加默认的附加提示",
+      "default": 1024
+    },
+    "JARVIS_ENABLE_INTENT_RECOGNITION": {
+      "type": "boolean",
+      "description": "是否启用意图识别功能。用于智能上下文推荐中的LLM意图提取和语义分析",
+      "default": true
+    },
     "JARVIS_GIT_CHECK_MODE": {
       "type": "string",
       "enum": ["strict", "warn"],
@@ -341,7 +413,23 @@
     "JARVIS_RAG_GROUPS": {
       "type": "array",
       "description": "预定义的RAG配置组",
-      "default": [],
+      "default": [
+        {
+          "text": {
+            "embedding_model": "BAAI/bge-m3",
+            "rerank_model": "BAAI/bge-reranker-v2-m3",
+            "use_bm25": true,
+            "use_rerank": true
+          }
+        },
+        {
+          "code": {
+            "embedding_model": "Qodo/Qodo-Embed-1-1.5B",
+            "use_bm25": false,
+            "use_rerank": false
+          }
+        }
+      ],
       "items": {
         "type": "object",
         "additionalProperties": {
@@ -421,7 +509,8 @@
         "required": [
           "template"
         ]
-      }
+      },
+      "default": {}
     },
     "OPENAI_API_KEY": {
       "type": "string",

jarvis/jarvis_git_utils/git_commiter.py

@@ -177,30 +177,35 @@ commit信息
                 platform_name = None
                 model_name = None
 
-                if (
-                    agent_from_args
-                    and hasattr(agent_from_args, "model")
-                    and getattr(agent_from_args, "model", None)
-                ):
-                    try:
-                        platform_name = agent_from_args.model.platform_name()
-                        model_name = agent_from_args.model.name()
-                        if not model_group and hasattr(
-                            agent_from_args.model, "model_group"
-                        ):
-                            model_group = agent_from_args.model.model_group
-                    except Exception:
-                        # 安全回退到后续逻辑
-                        platform_name = None
-                        model_name = None
-
-                # 如果未能从agent获取到，再根据 model_group 获取
-                if not platform_name:
+                # 优先根据 model_group 获取（确保配置一致性）
+                # 如果 model_group 存在，强制使用它来解析，避免使用 agent.model 中可能不一致的值
+                if model_group:
                     platform_name = get_normal_platform_name(model_group)
-                if not model_name:
                     model_name = get_normal_model_name(model_group)
-
-                # If no explicit parameters, try to get from existing global agent
+                else:
+                    # 如果没有提供 model_group，尝试从传入的 agent 获取
+                    if (
+                        agent_from_args
+                        and hasattr(agent_from_args, "model")
+                        and getattr(agent_from_args, "model", None)
+                    ):
+                        try:
+                            platform_name = agent_from_args.model.platform_name()
+                            model_name = agent_from_args.model.name()
+                            if hasattr(agent_from_args.model, "model_group"):
+                                model_group = agent_from_args.model.model_group
+                        except Exception:
+                            # 安全回退到后续逻辑
+                            platform_name = None
+                            model_name = None
+                    
+                    # 如果仍未获取到，使用配置文件中的默认值（传入 None 会读取默认配置）
+                    if not platform_name:
+                        platform_name = get_normal_platform_name(None)
+                    if not model_name:
+                        model_name = get_normal_model_name(None)
+
+                # 最后的回退：尝试从全局 agent 获取（仅当仍未获取到时）
                 if not platform_name:
                     agent = get_agent(current_agent_name)
                     if (
@@ -208,10 +213,17 @@ commit信息
                         and hasattr(agent, "model")
                         and getattr(agent, "model", None)
                     ):
-                        platform_name = agent.model.platform_name()
-                        model_name = agent.model.name()
-                        if not model_group and hasattr(agent.model, "model_group"):
-                            model_group = agent.model.model_group
+                        try:
+                            platform_name = agent.model.platform_name()
+                            model_name = agent.model.name()
+                            if not model_group and hasattr(agent.model, "model_group"):
+                                model_group = agent.model.model_group
+                        except Exception:
+                            # 如果全局 agent 也无法获取，使用配置文件默认值
+                            if not platform_name:
+                                platform_name = get_normal_platform_name(None)
+                            if not model_name:
+                                model_name = get_normal_model_name(None)
 
                 # Create a new platform instance
                 if platform_name:

jarvis/jarvis_mcp/sse_mcp_client.py

@@ -5,7 +5,7 @@ import time
 from typing import Any, Callable, Dict, List, Optional
 from urllib.parse import parse_qs, urlencode, urljoin
 
-import requests
+import requests  # type: ignore[import-untyped]
 
 from jarvis.jarvis_mcp import McpClient
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
@@ -568,7 +568,7 @@ class SSEMcpClient(McpClient):
         if self.sse_response:
             try:
                 self.sse_response.close()
-            except:
+            except Exception:
                 pass
 
         # 关闭HTTP会话

jarvis/jarvis_mcp/stdio_mcp_client.py

@@ -296,6 +296,6 @@ class StdioMcpClient(McpClient):
                 self._send_notification("notifications/exit", {})
                 # 等待进程结束
                 self.process.wait(timeout=1)
-            except:
+            except Exception:
                 # 如果进程没有正常退出，强制终止
                 self.process.kill()

jarvis/jarvis_memory_organizer/memory_organizer.py

@@ -203,7 +203,7 @@ tags:
 
             # 解析响应
             import re
-            import yaml
+            import yaml  # type: ignore[import-untyped]
 
             # 提取 <merged_memory> 标签内的内容
             yaml_match = re.search(

jarvis/jarvis_multi_agent/__init__.py

@@ -7,17 +7,20 @@ import yaml
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_agent.output_handler import OutputHandler
 from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
+from jarvis.jarvis_agent.rewrite_file_handler import RewriteFileHandler
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 
 
 class MultiAgent(OutputHandler):
-    def __init__(self, agents_config: List[Dict], main_agent_name: str):
+    def __init__(self, agents_config: List[Dict], main_agent_name: str, common_system_prompt: str = ""):
         self.agents_config = agents_config
         self.agents_config_map = {c["name"]: c for c in agents_config}
         self.agents: Dict[str, Agent] = {}
         self.main_agent_name = main_agent_name
         self.original_question: Optional[str] = None
+        self.common_system_prompt: str = common_system_prompt
 
     def prompt(self) -> str:
         return f"""
@@ -66,18 +69,168 @@ content: |2
 """
 
     def can_handle(self, response: str) -> bool:
-        return len(self._extract_send_msg(response)) > 0
+        # 只要检测到 SEND_MESSAGE 起始标签即认为可处理，
+        # 即便内容有误也由 handle 返回明确错误与修复指导
+        return ot("SEND_MESSAGE") in response
 
     def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
-        send_messages = self._extract_send_msg(response)
-        if len(send_messages) > 1:
+        """
+        处理 SEND_MESSAGE。若存在格式/解析/字段/目标等问题，返回明确错误原因与修复指导。
+        """
+        # 优先使用解析器获取“正确路径”结果
+        parsed = self._extract_send_msg(response)
+        if len(parsed) == 1:
+            msg = parsed[0]
+            # 字段校验
+            to_val = msg.get("to")
+            content_val = msg.get("content")
+            missing = []
+            if not to_val:
+                missing.append("to")
+            if content_val is None or (isinstance(content_val, str) and content_val.strip() == ""):
+                # 允许空格/空行被视为缺失
+                missing.append("content")
+            if missing:
+                guidance = (
+                    "SEND_MESSAGE 字段缺失或为空："
+                    + ", ".join(missing)
+                    + "\n修复建议：\n"
+                    "- 必须包含 to 和 content 字段\n"
+                    "- to: 目标智能体名称（字符串）\n"
+                    "- content: 发送内容，建议使用多行块 |2 保持格式\n"
+                    "示例：\n"
+                    f"{ot('SEND_MESSAGE')}\n"
+                    "to: 目标Agent名称\n"
+                    "content: |2\n"
+                    "  这里填写要发送的消息内容\n"
+                    f"{ct('SEND_MESSAGE')}"
+                )
+                return False, guidance
+            # 类型校验
+            if not isinstance(to_val, str):
+                return False, "SEND_MESSAGE 字段类型错误：to 必须为字符串。修复建议：将 to 改为字符串，如 to: ChapterPolisher"
+            if not isinstance(content_val, str):
+                return False, "SEND_MESSAGE 字段类型错误：content 必须为字符串。修复建议：将 content 改为字符串或使用多行块 content: |2"
+            # 目标校验
+            if to_val not in self.agents_config_map:
+                available = ", ".join(self.agents_config_map.keys())
+                return (
+                    False,
+                    f"目标智能体不存在：'{to_val}' 不在可用列表中。\n"
+                    f"可用智能体：[{available}]\n"
+                    "修复建议：\n"
+                    "- 将 to 修改为上述可用智能体之一\n"
+                    "- 或检查配置中是否遗漏了该智能体的定义"
+                )
+            # 通过校验，交给上层发送
+            return True, {"to": to_val, "content": content_val}
+        elif len(parsed) > 1:
+            return (
+                False,
+                "检测到多个 SEND_MESSAGE 块。一次只能发送一个消息。\n修复建议：合并消息或分多轮发送，每轮仅保留一个 SEND_MESSAGE 块。"
+            )
+        # 未成功解析，进行诊断并返回可操作指导
+        try:
+            normalized = response.replace("\r\n", "\n").replace("\r", "\n")
+        except Exception:
+            normalized = response
+        ot_tag = ot("SEND_MESSAGE")
+        ct_tag = ct("SEND_MESSAGE")
+        has_open = ot_tag in normalized
+        has_close = ct_tag in normalized
+        if has_open and not has_close:
+            return (
+                False,
+                f"检测到 {ot_tag} 但缺少结束标签 {ct_tag}。\n"
+                "修复建议：在消息末尾补充结束标签，并确认标签各自独占一行。\n"
+                "示例：\n"
+                f"{ot_tag}\n"
+                "to: 目标Agent名称\n"
+                "content: |2\n"
+                "  这里填写要发送的消息内容\n"
+                f"{ct_tag}"
+            )
+        # 尝试提取原始块并指出 YAML 问题
+        import re as _re
+        pattern = _re.compile(
+            rf"{_re.escape(ot_tag)}[ \t]*\n(.*?)(?:\n)?[ \t]*{_re.escape(ct_tag)}",
+            _re.DOTALL,
+        )
+        blocks = pattern.findall(normalized)
+        if not blocks:
+            alt_pattern = _re.compile(
+                rf"{_re.escape(ot_tag)}[ \t]*(.*?)[ \t]*{_re.escape(ct_tag)}",
+                _re.DOTALL,
+            )
+            blocks = alt_pattern.findall(normalized)
+        if not blocks:
+            return (
+                False,
+                "SEND_MESSAGE 格式错误：未能识别完整的消息块。\n"
+                "修复建议：确保起止标签在单独行上，且中间内容为合法的 YAML，包含 to 与 content 字段。"
+            )
+        raw = blocks[0]
+        try:
+            msg_obj = yaml.safe_load(raw)
+            if not isinstance(msg_obj, dict):
+                return (
+                    False,
+                    "SEND_MESSAGE 内容必须为 YAML 对象（键值对）。\n"
+                    "修复建议：使用 to 与 content 字段构成的对象。\n"
+                    "示例：\n"
+                    f"{ot('SEND_MESSAGE')}\n"
+                    "to: 目标Agent名称\n"
+                    "content: |2\n"
+                    "  这里填写要发送的消息内容\n"
+                    f"{ct('SEND_MESSAGE')}"
+                )
+            missing_keys = [k for k in ("to", "content") if k not in msg_obj]
+            if missing_keys:
+                return (
+                    False,
+                    "SEND_MESSAGE 缺少必要字段：" + ", ".join(missing_keys) + "\n"
+                    "修复建议：补充缺失字段。\n"
+                    "示例：\n"
+                    f"{ot('SEND_MESSAGE')}\n"
+                    "to: 目标Agent名称\n"
+                    "content: |2\n"
+                    "  这里填写要发送的消息内容\n"
+                    f"{ct('SEND_MESSAGE')}"
+                )
+            # 针对值类型的提示（更细）
+            if not isinstance(msg_obj.get("to"), str):
+                return False, "SEND_MESSAGE 字段类型错误：to 必须为字符串。"
+            if not isinstance(msg_obj.get("content"), str):
+                return False, "SEND_MESSAGE 字段类型错误：content 必须为字符串，建议使用多行块 |2。"
+            # 若到此仍未返回，说明结构基本正确，但 _extract_send_msg 未命中，给出泛化建议
             return (
                 False,
-                "Send multiple messages, please only send one message at a time.",
+                "SEND_MESSAGE 格式可能存在缩进或空白字符问题，导致未被系统识别。\n"
+                "修复建议：\n"
+                "- 确保起止标签各占一行\n"
+                "- 标签与内容之间保留换行\n"
+                "- 使用 content: |2 并保证 YAML 缩进一致\n"
+                "示例：\n"
+                f"{ot('SEND_MESSAGE')}\n"
+                "to: 目标Agent名称\n"
+                "content: |2\n"
+                "  这里填写要发送的消息内容\n"
+                f"{ct('SEND_MESSAGE')}"
+            )
+        except Exception as e:
+            return (
+                False,
+                f"SEND_MESSAGE YAML 解析失败：{str(e)}\n"
+                "修复建议：\n"
+                "- 检查冒号、缩进与引号是否正确\n"
+                "- 使用 content: |2 多行块以避免缩进歧义\n"
+                "示例：\n"
+                f"{ot('SEND_MESSAGE')}\n"
+                "to: 目标Agent名称\n"
+                "content: |2\n"
+                "  这里填写要发送的消息内容\n"
+                f"{ct('SEND_MESSAGE')}"
             )
-        if len(send_messages) == 0:
-            return False, ""
-        return True, send_messages[0]
 
     def name(self) -> str:
         return "SEND_MESSAGE"
@@ -89,16 +242,38 @@ content: |2
         Args:
             content: The content containing send message
         """
-        if ot("SEND_MESSAGE") in content and ct("SEND_MESSAGE") not in content:
-            content += "\n" + ct("SEND_MESSAGE")
-        data = re.findall(
-            ot("SEND_MESSAGE") + r"\n(.*?)\n" + ct("SEND_MESSAGE"), content, re.DOTALL
+        # Normalize line endings to handle CRLF/CR cases to ensure robust matching
+        try:
+            normalized = content.replace("\r\n", "\n").replace("\r", "\n")
+        except Exception:
+            normalized = content
+
+        ot_tag = ot("SEND_MESSAGE")
+        ct_tag = ct("SEND_MESSAGE")
+
+        # Auto-append closing tag if missing
+        if ot_tag in normalized and ct_tag not in normalized:
+            normalized += "\n" + ct_tag
+
+        # Use robust regex with DOTALL; escape tags to avoid regex meta issues
+        pattern = re.compile(
+            rf"{re.escape(ot_tag)}[ \t]*\n(.*?)(?:\n)?[ \t]*{re.escape(ct_tag)}",
+            re.DOTALL,
         )
+        data = pattern.findall(normalized)
+        # Fallback: handle cases without explicit newlines around closing tag
+        if not data:
+            alt_pattern = re.compile(
+                rf"{re.escape(ot_tag)}[ \t]*(.*?)[ \t]*{re.escape(ct_tag)}",
+                re.DOTALL,
+            )
+            data = alt_pattern.findall(normalized)
+
         ret = []
         for item in data:
             try:
                 msg = yaml.safe_load(item)
-                if "to" in msg and "content" in msg:
+                if isinstance(msg, dict) and "to" in msg and "content" in msg:
                     ret.append(msg)
             except Exception:
                 continue
@@ -112,6 +287,20 @@ content: |2
             return None
 
         config = self.agents_config_map[name].copy()
+        # 标记为多智能体运行，避免在非交互模式下自动开启 auto_complete
+        config.setdefault("in_multi_agent", True)
+        # 非主智能体统一禁用自动补全，防止多智能体并行时误触发自动交互
+        if name != self.main_agent_name:
+            config["auto_complete"] = False
+
+        # Prepend common system prompt if configured
+        common_sp = getattr(self, "common_system_prompt", "")
+        if common_sp:
+            existing_sp = config.get("system_prompt", "")
+            if existing_sp:
+                config["system_prompt"] = f"{common_sp}\n\n{existing_sp}"
+            else:
+                config["system_prompt"] = common_sp
 
         if name != self.main_agent_name and self.original_question:
             system_prompt = config.get("system_prompt", "")
@@ -119,18 +308,7 @@ content: |2
                 f"{system_prompt}\n\n# 原始问题\n{self.original_question}"
             )
 
-        output_handler = config.get("output_handler", [])
-        if len(output_handler) == 0:
-            output_handler = [
-                ToolRegistry(),
-                self,
-            ]
-        else:
-            if not any(isinstance(h, MultiAgent) for h in output_handler):
-                output_handler.append(self)
-        config["output_handler"] = output_handler
-
-        agent = Agent(**config)
+        agent = Agent(output_handler=[ToolRegistry(),  EditFileHandler(), RewriteFileHandler(), self],**config)
         self.agents[name] = agent
         return agent
 
@@ -154,9 +332,35 @@ content: |2
                 PrettyOutput.print(f"未知消息类型: {type(msg)}", OutputType.WARNING)
                 break
 
+            # Generate a brief summary via direct model call to avoid run-loop recursion
+            # 如果在配置中显式设置了 summary_on_send=False，则不生成摘要
+            sender_config = self.agents_config_map.get(last_agent_name, {}) if hasattr(self, "agents_config_map") else {}
+            summary_on_send = sender_config.get("summary_on_send", True)
+            summary_text = ""
+            if summary_on_send:
+                try:
+                    # 参照 Agent.generate_summary 的实现思路：基于当前 session.prompt 追加请求提示，直接调用底层模型
+                    multi_agent_summary_prompt = """
+请基于当前会话，为即将发送给其他智能体的协作交接写一段摘要，包含：
+- 已完成的主要工作与产出
+- 关键决策及其理由
+- 已知的约束/风险/边界条件
+- 未解决的问题与待澄清点
+- 下一步建议与对目标智能体的具体请求
+要求：
+- 仅输出纯文本，不包含任何指令或工具调用
+- 使用简洁的要点式表述
+""".strip()
+                    summary_any: Any = agent.model.chat_until_success(  # type: ignore[attr-defined]
+                        f"{agent.session.prompt}\n{multi_agent_summary_prompt}"
+                    )
+                    summary_text = summary_any.strip() if isinstance(summary_any, str) else ""
+                except Exception:
+                    summary_text = ""
             prompt = f"""
 Please handle this message:
 from: {last_agent_name}
+summary_of_sender_work: {summary_text}
 content: {msg['content']}
 """
             to_agent_name = msg.get("to")
@@ -179,10 +383,20 @@ content: {msg['content']}
                 f"{last_agent_name} 正在向 {to_agent_name} 发送消息...", OutputType.INFO
             )
 
+            # Keep a reference to the sender before switching to the receiver
+            sender_agent = agent
+
             agent = self._get_agent(to_agent_name)
             if not agent:
                 return f"智能体 {to_agent_name} 未找到"
 
+            # Check if the sending agent should be cleared
+            sender_config = self.agents_config_map.get(last_agent_name, {})
+            if sender_config.get("clear_after_send_message"):
+                if sender_agent:
+                    PrettyOutput.print(f"清除智能体 {last_agent_name} 在发送消息后的历史记录...", OutputType.INFO)
+                    sender_agent.clear_history()
+
             last_agent_name = agent.name
             msg = agent.run(prompt)
         return ""