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

jarvis/jarvis_methodology/main.py

@@ -8,11 +8,11 @@
 - 列出所有方法论
 """
 
-import argparse
 import hashlib
 import json
 import os
 
+import typer
 import yaml  # type: ignore
 
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -22,8 +22,13 @@ from jarvis.jarvis_utils.methodology import (
 )
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
+app = typer.Typer(help="方法论管理工具")
 
-def import_methodology(input_file):
+
+@app.command("import")
+def import_methodology(
+    input_file: str = typer.Argument(..., help="要导入的方法论文件路径")
+):
     """导入方法论文件（合并策略）"""
     try:
         # 加载现有方法论
@@ -56,9 +61,11 @@ def import_methodology(input_file):
         )
     except (json.JSONDecodeError, OSError) as e:
         PrettyOutput.print(f"导入失败: {str(e)}", OutputType.ERROR)
+        raise typer.Exit(code=1)
 
 
-def export_methodology(output_file):
+@app.command("export")
+def export_methodology(output_file: str = typer.Argument(..., help="导出文件路径")):
     """导出当前方法论到单个文件"""
     try:
         methodologies = _load_all_methodologies()
@@ -72,8 +79,10 @@ def export_methodology(output_file):
         )
     except (OSError, TypeError) as e:
         PrettyOutput.print(f"导出失败: {str(e)}", OutputType.ERROR)
+        raise typer.Exit(code=1)
 
 
+@app.command("list")
 def list_methodologies():
     """列出所有方法论"""
     try:
@@ -83,14 +92,20 @@ def list_methodologies():
             PrettyOutput.print("没有找到方法论", OutputType.INFO)
             return
 
-        PrettyOutput.print("可用方法论:", OutputType.INFO)
+        # 先拼接再统一打印，避免在循环中逐条输出造成信息稀疏
+        lines = ["可用方法论:"]
         for i, (problem_type, _) in enumerate(methodologies.items(), 1):
-            PrettyOutput.print(f"{i}. {problem_type}", OutputType.INFO)
+            lines.append(f"{i}. {problem_type}")
+        PrettyOutput.print("\n".join(lines), OutputType.INFO)
     except (OSError, json.JSONDecodeError) as e:
         PrettyOutput.print(f"列出方法论失败: {str(e)}", OutputType.ERROR)
+        raise typer.Exit(code=1)
 
 
-def extract_methodology(input_file):
+@app.command("extract")
+def extract_methodology(
+    input_file: str = typer.Argument(..., help="要提取方法论的文本文件路径")
+):
     """从文本文件中提取方法论"""
     try:
         # 读取文本文件内容
@@ -129,23 +144,23 @@ def extract_methodology(input_file):
 """
 
         # 调用大模型平台提取方法论
-        print("📥 正在提取方法论...")
+        PrettyOutput.print("正在提取方法论...", OutputType.INFO)
         try:
             response = platform.chat_until_success(prompt)
         except Exception as e:
-            print("❌ 提取失败")
+            PrettyOutput.print("提取失败", OutputType.ERROR)
             PrettyOutput.print(f"提取方法论失败: {str(e)}", OutputType.ERROR)
-            return
+            raise typer.Exit(code=1)
 
         # 提取YAML部分
         methodologies_start = response.find("<methodologies>") + len("<methodologies>")
         methodologies_end = response.find("</methodologies>")
         if methodologies_start == -1 or methodologies_end == -1:
-            print("❌ 响应格式无效")
+            PrettyOutput.print("响应格式无效", OutputType.ERROR)
             PrettyOutput.print(
                 "大模型未返回有效的<methodologies>格式", OutputType.ERROR
             )
-            return
+            raise typer.Exit(code=1)
 
         yaml_content = response[methodologies_start:methodologies_end].strip()
 
@@ -155,14 +170,14 @@ def extract_methodology(input_file):
                 item["problem_type"]: item["content"] for item in data
             }
         except (yaml.YAMLError, KeyError, TypeError) as e:
-            print("❌ YAML解析失败")
+            PrettyOutput.print("YAML解析失败", OutputType.ERROR)
             PrettyOutput.print(f"YAML解析错误: {str(e)}", OutputType.ERROR)
-            return
+            raise typer.Exit(code=1)
 
         if not extracted_methodologies:
-            print("❌ 未提取到有效方法论")
+            PrettyOutput.print("未提取到有效方法论", OutputType.WARNING)
             return
-        print("✅ 提取到有效方法论")
+        PrettyOutput.print("提取到有效方法论", OutputType.SUCCESS)
 
         # 加载现有方法论
         existing_methodologies = _load_all_methodologies()
@@ -190,9 +205,13 @@ def extract_methodology(input_file):
         )
     except Exception as e:
         PrettyOutput.print(f"提取失败: {str(e)}", OutputType.ERROR)
+        raise typer.Exit(code=1)
 
 
-def extract_methodology_from_url(url):
+@app.command("extract-url")
+def extract_methodology_from_url(
+    url: str = typer.Argument(..., help="要提取方法论的URL")
+):
     """从URL提取方法论"""
     try:
         # 获取平台实例
@@ -228,23 +247,23 @@ def extract_methodology_from_url(url):
 6. 内容字段使用|保留多行格式
 """
         # 调用大模型平台提取方法论
-        print("📥 正在从URL提取方法论...")
+        PrettyOutput.print("正在从URL提取方法论...", OutputType.INFO)
         try:
             response = platform.chat_until_success(prompt)
         except Exception as e:
-            print("❌ 提取失败")
+            PrettyOutput.print("提取失败", OutputType.ERROR)
             PrettyOutput.print(f"提取方法论失败: {str(e)}", OutputType.ERROR)
-            return
+            raise typer.Exit(code=1)
 
         # 提取YAML部分
         methodologies_start = response.find("<methodologies>") + len("<methodologies>")
         methodologies_end = response.find("</methodologies>")
         if methodologies_start == -1 or methodologies_end == -1:
-            print("❌ 响应格式无效")
+            PrettyOutput.print("响应格式无效", OutputType.ERROR)
             PrettyOutput.print(
                 "大模型未返回有效的<methodologies>格式", OutputType.ERROR
             )
-            return
+            raise typer.Exit(code=1)
 
         yaml_content = response[methodologies_start:methodologies_end].strip()
 
@@ -254,14 +273,14 @@ def extract_methodology_from_url(url):
                 item["problem_type"]: item["content"] for item in data
             }
         except (yaml.YAMLError, KeyError, TypeError) as e:
-            print("❌ YAML解析失败")
+            PrettyOutput.print("YAML解析失败", OutputType.ERROR)
             PrettyOutput.print(f"YAML解析错误: {str(e)}", OutputType.ERROR)
-            return
+            raise typer.Exit(code=1)
 
         if not extracted_methodologies:
-            print("❌ 未提取到有效方法论")
+            PrettyOutput.print("未提取到有效方法论", OutputType.WARNING)
             return
-        print("✅ 提取到有效方法论")
+        PrettyOutput.print("提取到有效方法论", OutputType.SUCCESS)
 
         # 加载现有方法论
         existing_methodologies = _load_all_methodologies()
@@ -289,46 +308,12 @@ def extract_methodology_from_url(url):
         )
     except Exception as e:
         PrettyOutput.print(f"从URL提取失败: {str(e)}", OutputType.ERROR)
+        raise typer.Exit(code=1)
 
 
-def main():
-    """方法论管理工具主函数"""
-    parser = argparse.ArgumentParser(description="方法论管理工具")
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    # import命令
-    import_parser = subparsers.add_parser("import", help="导入方法论文件（合并策略）")
-    import_parser.add_argument("input_file", type=str, help="要导入的方法论文件路径")
-
-    # export命令
-    export_parser = subparsers.add_parser("export", help="导出当前方法论到单个文件")
-    export_parser.add_argument("output_file", type=str, help="导出文件路径")
-
-    # list命令
-    subparsers.add_parser("list", help="列出所有方法论")
-
-    # extract命令
-    extract_parser = subparsers.add_parser("extract", help="从文本文件中提取方法论")
-    extract_parser.add_argument(
-        "input_file", type=str, help="要提取方法论的文本文件路径"
-    )
-
-    # extract-url命令
-    extract_url_parser = subparsers.add_parser("extract-url", help="从URL提取方法论")
-    extract_url_parser.add_argument("url", type=str, help="要提取方法论的URL")
-
-    args = parser.parse_args()
-
-    if args.command == "import":
-        import_methodology(args.input_file)
-    elif args.command == "export":
-        export_methodology(args.output_file)
-    elif args.command == "list":
-        list_methodologies()
-    elif args.command == "extract":
-        extract_methodology(args.input_file)
-    elif args.command == "extract-url":
-        extract_methodology_from_url(args.url)
+def main() -> None:
+    """Application entry point"""
+    app()
 
 
 if __name__ == "__main__":

jarvis/jarvis_multi_agent/__init__.py

@@ -1,22 +1,26 @@
 # -*- coding: utf-8 -*-
 import re
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 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 = {}
-        self.init_agents()
+        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"""
@@ -65,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,
-                f"Send multiple messages, please only send one message at a time.",
+                "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_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"
@@ -88,56 +242,161 @@ content: |2
         Args:
             content: The content containing 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 as e:
+            except Exception:
                 continue
         return ret
 
-    def init_agents(self):
-        for config in self.agents_config:
-            output_handler = config.get("output_handler", [])
-            if len(output_handler) == 0:
-                output_handler = [
-                    ToolRegistry(),
-                    self,
-                ]
+    def _get_agent(self, name: str) -> Union[Agent, None]:
+        if name in self.agents:
+            return self.agents[name]
+
+        if name not in self.agents_config_map:
+            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:
-                output_handler.append(self)
-            config["output_handler"] = output_handler
-            agent = Agent(**config)
-            self.agents[config["name"]] = agent
+                config["system_prompt"] = common_sp
+
+        if name != self.main_agent_name and self.original_question:
+            system_prompt = config.get("system_prompt", "")
+            config["system_prompt"] = (
+                f"{system_prompt}\n\n# 原始问题\n{self.original_question}"
+            )
+
+        agent = Agent(output_handler=[ToolRegistry(),  EditFileHandler(), RewriteFileHandler(), self],**config)
+        self.agents[name] = agent
+        return agent
 
     def run(self, user_input: str) -> str:
-        last_agent = self.main_agent_name
-        msg = self.agents[self.main_agent_name].run(user_input)
+        self.original_question = user_input
+        last_agent_name = self.main_agent_name
+
+        agent = self._get_agent(self.main_agent_name)
+        if not agent:
+            # This should not happen if main_agent_name is correctly configured
+            return f"主智能体 {self.main_agent_name} 未找到"
+
+        msg: Any = agent.run(user_input)
+
         while msg:
             if isinstance(msg, str):
                 return msg
-            elif isinstance(msg, Dict):
-                prompt = f"""
+
+            if not isinstance(msg, Dict):
+                # Should not happen if agent.run() returns str or Dict
+                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}
+from: {last_agent_name}
+summary_of_sender_work: {summary_text}
 content: {msg['content']}
 """
-                if msg["to"] not in self.agents:
-                    PrettyOutput.print(
-                        f"未找到智能体 {msg['to']}，正在重试...", OutputType.WARNING
-                    )
-                    msg = self.agents[last_agent].run(
-                        f"未找到智能体 {msg['to']}，可用智能体列表: {self.agents.keys()}"
-                    )
-                    continue
+            to_agent_name = msg.get("to")
+            if not to_agent_name:
+                return "消息中未指定 `to` 字段"
+
+            if to_agent_name not in self.agents_config_map:
                 PrettyOutput.print(
-                    f"{last_agent} 正在向 {msg['to']} 发送消息...", OutputType.INFO
+                    f"未找到智能体 {to_agent_name}，正在重试...", OutputType.WARNING
+                )
+                agent = self._get_agent(last_agent_name)
+                if not agent:
+                    return f"智能体 {last_agent_name} 未找到"
+                msg = agent.run(
+                    f"未找到智能体 {to_agent_name}，可用智能体列表: {list(self.agents_config_map.keys())}"
                 )
-                last_agent = self.agents[msg["to"]].name
-                msg = self.agents[msg["to"]].run(prompt)
+                continue
+
+            PrettyOutput.print(
+                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 ""