SimAgentPlg 0.1.0__py3-none-any.whl

allagent/__init__.py

@@ -0,0 +1,17 @@
+"""All Agent — a lightweight multi-agent framework with ReAct reasoning, tool dispatch, and MCP integration."""
+
+from allagent.agent.react.reactor import ReactLoop
+from allagent.agent.chat.chat import ChatLoop
+from allagent.agent.base import LLMConfig, StepOutcome, BaseHandler
+from allagent.plugins.mcp.mcp_manager import McpServerManager
+from allagent.plugins.skill.skill_manager import SkillManager
+
+__all__ = [
+    "ReactLoop",
+    "ChatLoop",
+    "LLMConfig",
+    "StepOutcome",
+    "BaseHandler",
+    "McpServerManager",
+    "SkillManager",
+]

allagent/agent/__init__.py

@@ -0,0 +1,7 @@
+"""Agent 调度 — ReAct / Chat 循环。"""
+
+from allagent.agent.react.reactor import ReactLoop
+from allagent.agent.chat.chat import ChatLoop
+from allagent.agent.base import LLMConfig
+
+__all__ = ["ReactLoop", "ChatLoop", "LLMConfig"]

allagent/agent/base.py

@@ -0,0 +1,223 @@
+import asyncio
+from typing import Optional, Any, cast
+import os
+
+from dataclasses import dataclass
+from openai import AsyncOpenAI
+from abc import ABC, abstractmethod
+from dotenv import load_dotenv
+from openai.types.chat import ChatCompletionMessage
+
+from allagent.logger import get_logger
+from .tool_schema import LOCAL_TOOLS
+
+load_dotenv()
+
+logger = get_logger("LLMCONFIG")
+
+BASE_PROMPT = """
+你是一个帮助用户完成各种任务的聊天助手
+"""
+
+
+@dataclass
+class StepOutcome:
+    data: Any  # 工具返回值
+    next_prompt: Optional[str] = None  # 下一轮追加的 prompt，None 表示任务完成
+    should_exit: bool = False  # True 表示立即退出
+
+
+# bash 命令黑名单
+BASH_BLACKLIST = [
+    "rm ",
+    "rm\n",
+    "rm\t",
+    "rm(",
+    "rm;",
+    "rm\\",
+    "rm|",
+    "rm&",
+    "rm<",
+    "rm>",
+    "sudo ",
+    "mkfs.",
+    "dd if=",
+    ":(){ :|:& };:",
+    "> /dev/sda",
+    "/dev/null",
+    "chmod 777",
+]
+
+
+async def bash_run(
+    code: str,
+    timeout: int = 60,
+    cwd: Optional[str] = None,
+    maxlen: int = 10000,
+) -> dict:
+    """异步执行 bash 代码片段，返回执行结果 dict。"""
+    logger.info("bash_run 脚本:\n%s...", code[:40])
+
+    for pattern in BASH_BLACKLIST:
+        if pattern in code:
+            logger.warning("bash_run 命中黑名单: %s", pattern.strip())
+            return {
+                "status": "error",
+                "msg": f"禁止执行危险命令: {pattern.strip()}",
+                "exit_code": -1,
+            }
+
+    try:
+        process = await asyncio.create_subprocess_exec(
+            "bash",
+            "-c",
+            code,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            cwd=cwd,
+        )
+
+        stdout_chunks: list[str] = []
+
+        async def read_stdout() -> None:
+            assert process.stdout is not None
+            while True:
+                line_bytes = await process.stdout.readline()
+                if not line_bytes:
+                    break
+                try:
+                    line = line_bytes.decode("utf-8")
+                except UnicodeDecodeError:
+                    line = line_bytes.decode("gbk", errors="ignore")
+                stdout_chunks.append(line)
+
+        read_task = asyncio.create_task(read_stdout())
+
+        try:
+            await asyncio.wait_for(process.wait(), timeout=timeout)
+        except asyncio.TimeoutError:
+            try:
+                process.kill()
+            except Exception:
+                pass
+            await process.wait()
+            stdout_chunks.append("\n[Timeout Error] 超时强制终止\n")
+
+        await read_task
+
+        stdout_str = "".join(stdout_chunks)
+        exit_code = process.returncode if process.returncode is not None else -1
+        status = "success" if exit_code == 0 else "error"
+
+        return {
+            "status": status,
+            "stdout": stdout_str[-maxlen:],
+            "exit_code": exit_code,
+        }
+
+    except Exception as e:
+        return {"status": "error", "msg": str(e)}
+
+
+class BaseHandler:
+    """
+    工具调度基类 —— 约定优于配置：
+    子类只需定义 do_{tool_name} 方法，LLM 调用该工具时会自动反射路由。
+    """
+
+    async def dispatch(
+        self, tool_name: str, args: dict, index: int = 0, tool_num: int = 1
+    ) -> StepOutcome:
+        """
+        根据 tool_name 反射到 self.do_{tool_name} 方法。
+        自动注入 _index / _tool_num 参数。
+        """
+        method_name = f"do_{tool_name}"
+        if hasattr(self, method_name):
+            args["_index"] = index
+            args["_tool_num"] = tool_num
+            return await getattr(self, method_name)(args)
+        else:
+            return StepOutcome(
+                None, next_prompt=f"未知工具 {tool_name}", should_exit=False
+            )
+
+
+class LLMConfig(BaseHandler, ABC):
+    """
+    为后续ReAct, Plan and Execute,提供基础框架
+    它用于调用任何兼容OpenAI接口的服务，并默认使用流式响应。
+    """
+
+    def __init__(self, temperature: float = 0.7):
+        """
+        初始化客户端。参数从环境变量加载。
+        """
+        model = os.getenv("CHAT_MODEL")
+        api_key = os.getenv("MODEL_API_KEY")
+        base_url = os.getenv("MODEL_URL")
+        timeout = int(os.getenv("LLM_TIMEOUT", 60))
+        self.temperature = temperature
+
+        if not model or not api_key or not base_url:
+            raise ValueError("模型ID、API密钥和服务地址必须被提供或在.env文件中定义。")
+
+        self.model = model
+        self.apiKey = api_key
+        self.baseUrl = base_url
+        self.timeout = timeout
+        self.exec_cwd = os.getcwd()
+        self.messages: list = []
+        self.all_tools = [*LOCAL_TOOLS]
+        self.client = AsyncOpenAI(api_key=api_key, base_url=base_url, timeout=timeout)
+
+    @abstractmethod
+    async def runtime(
+        self, *, task: str, system_prompt: str = BASE_PROMPT,
+        history: Optional[list[dict]] = None,
+    ) -> str | None:
+        pass
+
+    async def chat_text(
+        self, messages: list[dict[str, str]], *, tools: Optional[list[dict[str, str]]]
+    ) -> ChatCompletionMessage:
+        """Call the configured chat model and return stripped text."""
+
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=cast(Any, messages),
+                temperature=self.temperature,
+                tools=tools,  # ty:ignore[invalid-argument-type]
+            )
+        except Exception as exc:
+            raise KeyError(f"chat completion failed: {exc}") from exc
+        message: ChatCompletionMessage = response.choices[0].message
+        return message
+
+    async def do_bash_run(self, args: dict) -> StepOutcome:
+        """执行 bash 代码片段。"""
+        code = args.get("code") or args.get("script")
+        if not code:
+            logger.warning("bash_run 缺少 code 参数")
+            return StepOutcome(
+                "[Error] Code missing. Use 'code' or 'script' arg.",
+                next_prompt="\n",
+            )
+
+        try:
+            timeout = int(args.get("timeout", 60))
+        except Exception:
+            timeout = 60
+
+        tool_num = args.get("_tool_num", 1)
+        maxlen = max(1, 10000 // tool_num)
+
+        logger.info("执行 bash_run, timeout=%d, cwd=%s", timeout, self.exec_cwd)
+        result = await bash_run(code, timeout=timeout, cwd=self.exec_cwd, maxlen=maxlen)
+        logger.info(
+            "bash_run 完成, status=%s, exit_code=%s",
+            result.get("status"),
+            result.get("exit_code"),
+        )
+        return StepOutcome(result, next_prompt="\n")

allagent/agent/chat/chat.py

@@ -0,0 +1,56 @@
+from allagent.logger import get_logger
+
+from typing import Optional
+
+from allagent.agent.base import LLMConfig
+
+logger = get_logger("CHATAGENT")
+
+CHAT_PROMPT = """
+现在你的身份是我的同龄好朋友，我们日常随意聊天。
+说话接地气、幽默风趣，偶尔开玩笑，不用正式话术。
+可以一起聊生活、兴趣、美食、趣事，接话自然流畅，不要像机器人。
+"""
+
+MAX_STEP = 5
+
+
+class ChatLoop(LLMConfig):
+
+    def __init__(
+        self,
+    ) -> None:
+        super().__init__()
+
+    async def runtime(
+        self,
+        *,
+        task: str,
+        system_prompt: str = CHAT_PROMPT,
+        history: Optional[list[dict]] = None,
+    ) -> str | None:
+
+        self.messages = [{"role": "system", "content": system_prompt}]
+        if history:
+            self.messages.extend(history)
+        self.messages.append({"role": "user", "content": task})
+
+        for turn in range(MAX_STEP):
+            logger.info("第 %d/%d 轮", turn + 1, MAX_STEP)
+
+            message = await self.chat_text(self.messages, tools=None)
+            self.messages.append(message.model_dump())
+            return message.content
+
+
+async def main():
+    task = "你好介绍一下自己"
+    loop = ChatLoop()
+    result = await loop.runtime(task=task)
+    logger.info("Chat 运行结果: %s", result)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

allagent/agent/react/mcp_config.json

@@ -0,0 +1,10 @@
+{
+    "playwright": {
+      "command": "npx",
+      "args": [
+        "@playwright/mcp@latest",
+        "--headless",
+        "--browser=chrome"
+      ]
+    }
+}

allagent/agent/react/react_skill/weather/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: 查询天气的免费网站
+description: 通过多个免费天气网站查询实时天气和预报
+---
+
+# 天气查询 Skill
+
+本 Skill 集成了以下免费的天气查询服务，可直接通过 HTTP 请求获取天气信息。
+
+## 支持的免费天气网站
+
+### 1. wttr.in
+- **网址**：https://wttr.in
+- **说明**：命令行风格的天气服务，支持 `curl wttr.in/城市名` 返回简洁的文本天气信息。
+- **特点**：无需 API Key，支持中英文，可自定义输出格式（如 `?format="%c+%t"`）。
+
+### 2. Open-Meteo
+- **网址**：https://open-meteo.com
+- **API 端点**：`https://api.open-meteo.com/v1/forecast`
+- **说明**：免费、开源的天气 API，返回 JSON 格式的预报和实时数据。
+- **特点**：无需注册，支持全球任意经纬度查询，最多 16 天预报。
+
+### 3. NOAA Weather API (美国)
+- **网址**：https://www.weather.gov/documentation/services-web-api
+- **说明**：美国国家气象局官方 API，提供权威的天气、预警和观测数据。
+- **特点**：完全免费，无需 API Key，但建议设置 User-Agent 标识。
+
+### 4. 7Timer!
+- **网址**：https://www.7timer.info
+- **API 端点**：`http://www.7timer.info/bin/api.pl`
+- **说明**：提供气象学和天文学天气数据，支持全球查询。
+- **特点**：免费，无需 API Key，返回 JSON 或 XML 格式。
+
+### 5. WeatherAPI (免费层级)
+- **网址**：https://www.weatherapi.com
+- **说明**：提供免费层级的 API（每天 100 万次调用，需注册获取 API Key）。
+- **特点**：实时天气、预报、历史数据，免费版足够个人使用。
+
+## 使用建议
+
+- 快速查询推荐 **wttr.in**，无需解析 JSON。
+- 需要结构化数据推荐 **Open-Meteo**，完全免费且功能强大。
+- 美国区域查询推荐 **NOAA API**，数据权威。

allagent/agent/react/reactor.py

@@ -0,0 +1,123 @@
+import json
+from pathlib import Path
+
+from allagent.logger import get_logger
+
+from typing import Optional
+
+from allagent.plugins import McpServerManager, SkillManager
+from allagent.agent.base import LLMConfig, StepOutcome
+
+logger = get_logger("REACTAGENT")
+
+REACT_LOOP_PROMPT = """
+你是一个有能力调用外部工具的智能助手。你必须严格遵循以下 ReAct 流程：
+
+1. Thought: 分析当前问题，规划下一步行动。
+2. Action: 调用一个工具来执行行动。
+   - 如果需要操作浏览器/文件系统/技能，调用对应的 MCP 工具或技能工具。
+重要规则：
+- 每轮只能调用一个或一组工具，不能同时输出思考内容和工具调用之外的文字。
+- 工具执行结果会返回给你，请根据结果继续思考下一步。
+- 不要重复相同的无效操作。
+"""
+
+MAX_STEP = 20
+
+
+class ReactLoop(LLMConfig):
+
+    def __init__(
+        self,
+    ) -> None:
+        super().__init__()
+        self._startup: bool = False
+        _agent_dir = Path(__file__).parent
+        self.mcp_manager: McpServerManager = McpServerManager(
+            _agent_dir / "mcp_config.json"
+        )
+        self.skill_manager: SkillManager = SkillManager(_agent_dir / "react_skill")
+
+    async def dispatch(
+        self, tool_name: str, args: dict, index: int = 0, tool_num: int = 1
+    ) -> StepOutcome:
+        outcome = await super().dispatch(tool_name, args, index, tool_num)
+        if outcome.next_prompt and outcome.next_prompt.startswith("未知工具"):
+            result = await self.mcp_manager.call_tool(tool_name, args)
+            return StepOutcome(data=result)
+        return outcome
+
+    async def startup(self) -> None:
+        await self.mcp_manager.startup()
+        mcp_tools = self.mcp_manager.get_openai_tools()
+        self.all_tools.extend(mcp_tools)
+        await self.skill_manager.discover()
+
+    async def runtime(
+        self, *, task: str, system_prompt: str = REACT_LOOP_PROMPT,
+        history: Optional[list[dict]] = None,
+    ) -> str | None:
+
+        if self._startup is False:
+            await self.startup()
+            self._startup = True
+
+        self.messages = [{"role": "system", "content": system_prompt}]
+        if history:
+            self.messages.extend(history)
+        self.messages.append({"role": "user", "content": task})
+
+        last_skill_name: str | None = None
+
+        for turn in range(MAX_STEP):
+            logger.info("第 %d/%d 轮", turn + 1, MAX_STEP)
+
+            skill_dispatch = await self.skill_manager.dispatch(self.messages)
+
+            if skill_dispatch:
+                skill_name = skill_dispatch.get("skill_name", "")
+                if skill_name and skill_name != last_skill_name:
+                    last_skill_name = skill_name
+                    self.messages.extend(skill_dispatch["messages"])
+
+            message = await self.chat_text(self.messages, tools=self.all_tools)
+            self.messages.append(message.model_dump())
+
+            if not message.tool_calls:
+                if message.content:
+                    return message.content  # 普通文字回复直接返回
+                continue
+
+            fn_calls = [tc for tc in message.tool_calls if tc.type == "function"]
+
+            for ii, tc in enumerate(fn_calls):
+                tool_args = json.loads(tc.function.arguments)
+                outcome = await self.dispatch(
+                    tc.function.name, tool_args, index=ii, tool_num=len(fn_calls)
+                )
+
+                if outcome.should_exit:
+                    return outcome.data
+                if outcome.next_prompt is None:
+                    break
+
+                self.messages.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": tc.id,
+                        "content": str(outcome.data),
+                    }
+                )
+
+
+async def main():
+    task = "写一个python脚本保存到本地，主要是打印helloworld并测试它,测试完成后删除"
+    loop = ReactLoop()
+    result = await loop.runtime(task=task)
+    logger.info("ReAct 运行结果: %s", result)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

allagent/agent/tool_schema.py

@@ -0,0 +1,29 @@
+"""
+本地工具 schema —— 纯数据定义，LLMConfig 默认可用的所有本地工具。
+
+添加新工具只需追加一条 dict，同时在 LLMConfig 中定义对应的 do_xxx 方法。
+"""
+
+LOCAL_TOOLS: list[dict] = [
+    {
+        "type": "function",
+        "function": {
+            "name": "bash_run",
+            "description": "在 Bash 沙箱中执行一段脚本代码，返回 stdout、退出码和状态。用于运行命令行、操作文件、安装依赖等操作。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "code": {
+                        "type": "string",
+                        "description": "要执行的 Bash 脚本代码，支持多行",
+                    },
+                    "timeout": {
+                        "type": "integer",
+                        "description": "最长等待秒数，默认 60",
+                    },
+                },
+                "required": ["code"],
+            },
+        },
+    },
+]

allagent/logger.py

@@ -0,0 +1,46 @@
+import logging
+
+
+def setup_logger(
+    name: str = "All-Agent",
+    level: str = "INFO",
+    log_file: str = "./logs/app.log",
+    fmt: str = "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+):
+    """创建并配置日志记录器，输出到控制台。
+
+    Args:
+        name: 日志记录器名称。
+        level: 最低日志级别，默认为 "INFO"。
+        log_file: 日志文件路径（当前仅保留参数，暂未启用文件输出）。
+        fmt: 日志格式字符串。
+
+    Returns:
+        配置完成的 logging.Logger 实例。
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    if logger.handlers:
+        return logger
+
+    formatter = logging.Formatter(fmt, datefmt="%Y-%m-%d %H:%M:%S")
+
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(level)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+    return logger
+
+
+def get_logger(name: str = "All-Agent") -> logging.Logger:
+    """获取或创建指定名称的日志记录器。
+
+    Args:
+        name: 日志记录器名称，默认为 "All-Agent"。
+
+    Returns:
+        配置完成的 logging.Logger 实例。
+    """
+    return setup_logger(name)

allagent/plugins/__init__.py

@@ -0,0 +1,6 @@
+"""插件系统 — MCP 服务管理 & Skill 技能路由。"""
+
+from allagent.plugins.mcp.mcp_manager import McpServerManager
+from allagent.plugins.skill.skill_manager import SkillManager
+
+__all__ = ["McpServerManager", "SkillManager"]

allagent/plugins/mcp/mcp_manager.py

@@ -0,0 +1,118 @@
+import json
+import asyncio
+from pathlib import Path
+from fastmcp import Client
+from fastmcp.mcp_config import MCPConfig
+from mcp.types import Tool
+from allagent.logger import get_logger
+
+logger = get_logger(name="MCP")
+
+
+class McpServerManager:
+    """MCP 多服务管理器，负责从 JSON 配置加载、连接和管理多个 MCP 服务。
+
+    支持按服务名前缀路由工具调用，单个服务连接失败不影响其他服务。
+    """
+
+    def __init__(self, path: Path | None = None):
+        """初始化管理器。
+
+        Args:
+            path: MCP 配置 JSON 文件路径。
+        """
+        if path is None:
+            path = Path(__file__).parent / "mcp_config.json"
+        self.path = path
+        self.mcp_clients_map: dict[str, Client] = {}
+        self.mcp_tools_map: dict[str, list[Tool]] = {}
+
+    async def startup(self) -> None:
+        """启动所有 MCP 服务连接。
+
+        从 JSON 配置文件读取服务列表，逐个建立连接并拉取工具列表。
+        单个服务连接失败会记录错误日志但不阻断其他服务的启动。
+        """
+        logger.info("MCP 服务管理器启动中...")
+        with open(self.path, "r", encoding="utf-8") as f:
+            mcp_configs = MCPConfig.from_dict(json.load(f))
+            logger.info(f"加载到 {len(mcp_configs.mcpServers)} 个 MCP 服务配置")
+            for service_name, server_model in mcp_configs.mcpServers.items():
+                try:
+                    logger.info(f"正在连接 {service_name} ...")
+                    mcp_client = Client({service_name: server_model.model_dump()})
+                    await mcp_client.__aenter__()
+                    tools = await mcp_client.list_tools()
+                    self.mcp_tools_map[service_name] = tools
+                    self.mcp_clients_map[service_name] = mcp_client
+                    logger.info(f"{service_name} 连接成功，加载 {len(tools)} 个工具")
+                except Exception as e:
+                    logger.error(f"连接 {service_name} 失败: {e}")
+        logger.info(
+            f"MCP 服务管理器启动完成，共 {len(self.mcp_clients_map)} 个服务在线"
+        )
+
+    async def shutdown(self) -> None:
+        """关闭所有 MCP 服务连接，释放资源。"""
+        logger.info("MCP 服务管理器关闭中...")
+        for service_name, mcp_client in self.mcp_clients_map.items():
+            await mcp_client.__aexit__(None, None, None)
+            logger.info(f"{service_name} 已断开")
+        logger.info("MCP 服务管理器已关闭")
+
+    async def call_tool(self, tool_name: str, args: dict[str, str]) -> str:
+        """调用 MCP 工具，按服务名前缀自动路由。
+
+        Args:
+            tool_name: 工具名，格式为 "{服务名}__{工具名}"，如 "playwright__browser_navigate"。
+            args: 传递给工具的参数字典。
+
+        Returns:
+            工具执行结果的字符串表示。
+
+        Raises:
+            ValueError: 当工具名不存在于任何已连接的服务中时抛出。
+        """
+        logger.info(f"调用工具: {tool_name}, 参数: {args}")
+        for service_name, client in self.mcp_clients_map.items():
+            prefix = f"{service_name}__"
+            if tool_name.startswith(prefix):
+                raw_name = tool_name[len(prefix) :]
+                result = await client.call_tool(raw_name, args)
+                logger.info(f"工具 {tool_name} 执行成功")
+                return str(result)
+        logger.error(f"未知的 MCP 工具: {tool_name}")
+        raise ValueError(f"unknown MCP tool: {tool_name}")
+
+    def get_openai_tools(self) -> list[dict]:
+        """将所有已连接服务的工具转换为 OpenAI tools 格式。
+
+        Returns:
+            OpenAI tools 参数格式的列表。
+        """
+        openai_tools = []
+        for service_name, tools in self.mcp_tools_map.items():
+            for tool in tools:
+                openai_tools.append(
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": f"{service_name}__{tool.name}",
+                            "description": tool.description,
+                            "parameters": tool.inputSchema,
+                        },
+                    }
+                )
+        logger.info(f"转换到 OpenAI tools 格式的工具: {len(openai_tools)} 个工具")
+        return openai_tools
+
+
+async def main():
+    mcp_manager = McpServerManager()
+    await mcp_manager.startup()
+    mcp_manager.get_openai_tools()
+    await mcp_manager.shutdown()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

allagent/plugins/skill/skill_manager.py

@@ -0,0 +1,246 @@
+from typing import Optional
+import json
+import os
+import re
+import yaml
+
+from dataclasses import dataclass
+from pathlib import Path
+from dotenv import load_dotenv
+from openai import OpenAI
+from allagent.logger import get_logger
+
+load_dotenv()
+logger = get_logger("skill")
+
+
+@dataclass(frozen=True)
+class Skill:
+    name: str
+    root: Path
+    skill_md: Path
+    template_md: Path | None = None
+    sample_md: Path | None = None
+
+
+class SkillManager:
+    """技能注册表，扫描本地技能目录并通过 LLM 路由用户请求到匹配的技能。
+
+    核心流程：
+    1. discover() — 扫描 skills_root 下含 SKILL.md 的子目录，注册技能
+    2. dispatch() — 用 LLM 从自然语言输入中选择技能并构建 messages
+    3. _build_messages() — 将技能定义、模板、示例拼装为 LLM 对话格式
+    """
+
+    def __init__(self, skills_root: str | Path | None = None):
+        """
+        Args:
+            skills_root: 技能根目录路径，子目录中含 SKILL.md 的会被识别为技能。
+        """
+        if skills_root is None:
+            skills_root = Path(__file__).parent / "my_skills"
+        self.skills_root = Path(skills_root)
+        self._skills: dict[str, Skill] = {}
+        self._discovered: bool = False
+        logger.info("技能注册表初始化，根目录: %s", self.skills_root)
+
+    async def discover(self) -> None:
+        """扫描技能根目录，注册所有含 SKILL.md 的子目录为技能。
+
+        Returns:
+            注册的技能字典 {name: Skill}。
+
+        Raises:
+            FileNotFoundError: 技能根目录不存在。
+        """
+
+        if not self.skills_root.exists():
+            raise FileNotFoundError(f"skills root not found: {self.skills_root}")
+
+        self._skills.clear()
+
+        for child in sorted(self.skills_root.iterdir()):
+            if not child.is_dir():
+                continue
+
+            skill_md = child / "SKILL.md"
+            if not skill_md.exists():
+                continue
+
+            template_md = child / "template.md"
+            sample_md = child / "examples" / "sample.md"
+
+            self._skills[child.name] = Skill(
+                name=child.name,
+                root=child,
+                skill_md=skill_md,
+                template_md=template_md if template_md.exists() else None,
+                sample_md=sample_md if sample_md.exists() else None,
+            )
+
+        if not self._skills:
+            logger.debug(
+                "技能扫描完成，未发现任何技能（skills_root: %s）", self.skills_root
+            )
+        else:
+            logger.info(
+                "发现 %d 个技能: %s", len(self._skills), list(self._skills.keys())
+            )
+
+    async def dispatch(
+        self,
+        messages: list[dict],
+    ) -> Optional[dict]:
+        """用 LLM 根据对话历史自动匹配技能并构建对话消息。
+
+        Args:
+            messages: 当前对话历史消息列表。
+
+        Returns:
+            if not self._discovered:
+                包含 skill_name、task、me
+                self._discovered = True
+            if not self._skills:
+                # 启动时已经扫过一次，仍为空：直接跳过 LLM 路由，避免无意义 IO + 同步阻塞
+                return Nonessages 的 payload 字典。
+            若无匹配返回 None。
+        """
+        if not self._skills:
+            await self.discover()
+
+        client = OpenAI(
+            api_key=os.environ["MODEL_API_KEY"],
+            base_url=os.environ["MODEL_URL"],
+        )
+
+        def _read_skill_frontmatter(skill: Skill) -> dict[str, str]:
+            """解析 SKILL.md 的 YAML 头部。"""
+            text = skill.skill_md.read_text(encoding="utf-8")
+            match = re.match(r"^---\s*\n(.*?)\n---", text, re.DOTALL)
+            if match:
+                return yaml.safe_load(match.group(1))
+            return {}
+
+        skill_list: str = "\n".join(
+            f"- {name}: {_read_skill_frontmatter(skill)}"
+            for name, skill in self._skills.items()
+        )
+
+        # 提取原始任务和最新进展，构建紧凑上下文
+        task = ""
+        latest = ""
+        for m in reversed(messages):
+            if m.get("role") == "assistant" and not latest:
+                latest = m.get("content", "")
+            if m.get("role") == "user" and not task:
+                task = m.get("content", "")
+
+        context = f"原始任务: {task}"
+        if latest:
+            context += f"\n当前进展: {latest[:300]}"
+
+        response = client.chat.completions.create(
+            model=os.environ.get("SKILL_MODEL", "gpt-4o-mini"),
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "你是一个技能路由器。根据用户输入和当前进展，选择最匹配的技能并提取任务描述。\n"
+                        "可用技能列表：\n" + skill_list
+                    ),
+                },
+                {"role": "user", "content": context},
+            ],
+            tools=[
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "select_skill",
+                        "description": "选择要使用的技能并提取任务",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "skill_name": {
+                                    "type": "string",
+                                    "enum": list(self._skills.keys()),
+                                    "description": "选择的技能名",
+                                },
+                                "task": {
+                                    "type": "string",
+                                    "description": "用户想要执行的具体任务",
+                                },
+                            },
+                            "required": ["skill_name", "task"],
+                        },
+                    },
+                }
+            ],
+        )
+
+        msg = response.choices[0].message
+        if not msg.tool_calls:
+            return None
+
+        args = json.loads(
+            msg.tool_calls[0].function.arguments  # ty:ignore[unresolved-attribute]
+        )
+
+        skill_name: str = args.get("skill_name", "")
+        task: str = args.get("task", "")
+
+        try:
+            skill = self._skills[skill_name]
+        except KeyError:
+            logger.warning(
+                "LLM 返回了未知技能: %s，可用: %s，跳过本次路由",
+                skill_name,
+                list(self._skills.keys()),
+            )
+            return None
+
+        logger.info(f"LLM 路由结果 — 技能: {skill_name}, 任务: {task}")
+        return {
+            "skill_name": skill.name,
+            "task": task,
+            "messages": self._build_messages(skill, task),
+        }
+
+    def _build_messages(self, skill: Skill, task: str) -> list[dict[str, str]]:
+        """将技能定义、模板和示例拼装为 LLM 对话消息。
+
+        Args:
+            skill: 技能对象。
+            task: 用户任务描述。
+
+        Returns:
+            [system_message, user_message] 格式的消息列表。
+        """
+        system_parts = [
+            f'You are executing the local skill "{skill.name}".',
+            "",
+            "[SKILL.md]",
+            skill.skill_md.read_text(encoding="utf-8").strip(),
+        ]
+
+        if skill.template_md is not None:
+            system_parts.extend(
+                [
+                    "",
+                    "[template.md]",
+                    skill.template_md.read_text(encoding="utf-8").strip(),
+                ]
+            )
+
+        if skill.sample_md is not None:
+            system_parts.extend(
+                [
+                    "",
+                    "[examples/sample.md]",
+                    skill.sample_md.read_text(encoding="utf-8").strip(),
+                ]
+            )
+
+        return [
+            {"role": "system", "content": "\n".join(system_parts)},
+            {"role": "user", "content": task},
+        ]

simagentplg-0.1.0.dist-info/METADATA

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: SimAgentPlg
+Version: 0.1.0
+Summary: A lightweight multi-agent framework with ReAct reasoning, tool dispatch, and MCP integration
+License: MIT License
+        
+        Copyright (c) 2024
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=3.4.2
+Requires-Dist: openai>=2.41.0
+Requires-Dist: python-dotenv>=1.2.2
+Description-Content-Type: text/markdown
+
+# All Agent
+
+A lightweight multi-agent framework with ReAct reasoning, tool dispatch, and MCP integration.
+
+## Features
+
+- **ReAct Agent** — ReAct (Reasoning + Acting) loop with multi-turn tool calling
+- **Chat Agent** — simple conversational agent with multi-turn history support
+- **Tool Dispatch** — convention-over-configuration: define `do_{tool_name}` methods, auto-routed via reflection
+- **MCP Integration** — pluggable MCP server manager for external tool providers
+- **Skill System** — skill-based prompt injection for domain-specific behaviors
+- **Built-in Bash Executor** — async sandboxed bash execution with timeout, output truncation, and blacklist filtering
+- **Stateless Execution** — each `runtime()` call starts with a clean context; history is caller-managed
+- **OpenAI-compatible** — works with any OpenAI-compatible API (DeepSeek, etc.)
+
+## Installation
+
+```bash
+pip install all-agent
+```
+
+Or with uv:
+
+```bash
+uv pip install all-agent
+```
+
+## Quick Start
+
+Set up your environment variables (`.env`):
+
+```env
+CHAT_MODEL=deepseek-chat
+MODEL_API_KEY=sk-xxxxxxxx
+MODEL_URL=https://api.deepseek.com
+LLM_TIMEOUT=30
+```
+
+### Chat Agent
+
+```python
+from allagent import ChatLoop
+
+loop = ChatLoop()
+result = await loop.runtime(task="介绍一下你自己")
+
+# With multi-turn history
+history = [
+    {"role": "user", "content": "今天天气不错"},
+    {"role": "assistant", "content": "是啊，适合出去走走"},
+]
+result = await loop.runtime(task="我们去哪", history=history)
+```
+
+### ReAct Agent
+
+```python
+from allagent import ReactLoop
+
+loop = ReactLoop()
+result = await loop.runtime(task="帮我写一个Python脚本打印当前时间")
+```
+
+The ReAct agent supports built-in tools (like `bash_run`) and any MCP tools configured in `mcp_config.json`.
+
+### MCP Configuration
+
+Place an `mcp_config.json` alongside your ReactLoop:
+
+```json
+{
+  "mcpServers": {
+    "playwright": {
+      "command": "npx",
+      "args": ["-y", "@anthropic/mcp-playwright"]
+    }
+  }
+}
+```
+
+## Architecture
+
+```
+LLMConfig (BaseHandler, ABC)
+├── ChatLoop         — stateless conversational agent
+├── ReactLoop        — ReAct reasoning + tool dispatch
+│   ├── MCP tools    — external tools via MCP protocol
+│   ├── Skill system — domain-specific prompt injection
+│   └── Local tools  — built-in bash_run, extensible
+└── (future) PlanLoop / ExecuteLoop
+```
+
+### Tool Dispatch Flow
+
+```
+LLM calls "bash_run"
+    → BaseHandler.dispatch("bash_run", args)
+        → hasattr(self, "do_bash_run")?  YES
+            → await self.do_bash_run(args)  ← local tool
+        → NO
+            → "未知工具" → MCP fallback  ← external tool
+```
+
+### Adding a Local Tool
+
+1. Define the tool schema in `tool_schema.py`:
+
+```python
+LOCAL_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "calculator",
+            "description": "Evaluate a math expression",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "expression": {"type": "string", "description": "Math expression"}
+                },
+                "required": ["expression"]
+            }
+        }
+    }
+]
+```
+
+2. Add the `do_calculator` method in `LLMConfig`:
+
+```python
+async def do_calculator(self, args: dict) -> StepOutcome:
+    result = eval(args["expression"])
+    return StepOutcome(data=result, next_prompt="\n")
+```
+
+All agents automatically inherit the new tool.
+
+## API
+
+### `ChatLoop`
+
+```python
+loop = ChatLoop(temperature=0.7)
+await loop.runtime(*, task, system_prompt=None, history=None) -> str | None
+```
+
+### `ReactLoop`
+
+```python
+loop = ReactLoop()
+await loop.runtime(*, task, system_prompt=None, history=None) -> str | None
+```
+
+### `StepOutcome`
+
+```python
+@dataclass
+class StepOutcome:
+    data: Any              # tool return value
+    next_prompt: str | None  # None = task complete
+    should_exit: bool      # True = force exit
+```
+
+## Requirements
+
+- Python >= 3.12
+- fastmcp >= 3.4.2
+- openai >= 2.41.0
+- python-dotenv >= 1.2.2
+
+## License
+
+MIT

simagentplg-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+allagent/__init__.py,sha256=6PWlgh_UTf8CN73z-tWAEnMMgIxEUUkDgHv2gF7EYmQ,551
+allagent/logger.py,sha256=c68Nfd9mx0di_O_03pD6TFphEXQkhcsP9l3WnGSBS2g,1231
+allagent/agent/__init__.py,sha256=QsBZstW1NzZrxqFeieid64wTkJbfS5ddB4T0YFLhaos,236
+allagent/agent/base.py,sha256=GFY-Y_OsWbhDB9sYMJJu3nTuIrKpTG9MClWEAH-fxNQ,6745
+allagent/agent/tool_schema.py,sha256=8fOHDng34YbK40_sg_kgmcP2T9hzGJDuvJ0QIhT41dA,1032
+allagent/agent/chat/chat.py,sha256=_HD4bcjyxptDT5FYRg0Qh3XhGGQK3aOGyRF8u_fIuXE,1406
+allagent/agent/react/mcp_config.json,sha256=Kce3W0yVauJxpiFaVXXRvYAp0BAKOe6-4NrWG_rTIUg,160
+allagent/agent/react/reactor.py,sha256=9FaLj2s7fowoXvncDAjwt4rMwv5Jrok2EAkHIufM9x4,4207
+allagent/agent/react/react_skill/weather/SKILL.md,sha256=T1hYcIiXC4MA__s8y6cgDf6NxSTRdZBWOwUmFsyPI88,1854
+allagent/plugins/__init__.py,sha256=LUEkGUtzKIyM9Ay4BxAx2APEJVyDtwOZtEgvX8Q5muA,237
+allagent/plugins/mcp/mcp_manager.py,sha256=yyEWrdOkFvh4oZP6ene_TY9sVOwmkpQFnMBzLenbc6I,4691
+allagent/plugins/skill/skill_manager.py,sha256=fnD51c4Jhp_c2UrJqka1EPKWDLH5QoakXNWIppTUy7E,8222
+simagentplg-0.1.0.dist-info/METADATA,sha256=EkqqM-jothAVvCBMksW1ifRMMaVH9XgUV9enj3SVwDs,5674
+simagentplg-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+simagentplg-0.1.0.dist-info/licenses/LICENSE,sha256=dUhuoK-TCRQMpuLEAdfme-qPSJI0TlcH9jlNxeg9_EQ,1056
+simagentplg-0.1.0.dist-info/RECORD,,

simagentplg-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

simagentplg-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.