SimAgentPlg 0.1.0__tar.gz

simagentplg-0.1.0/.env_example

@@ -0,0 +1,8 @@
+MODEL_API_KEY=sk-9f226850f31a474ba7b6dddc6c7c3ff7
+MODEL_URL=https://api.deepseek.com
+
+SKILL_MODEL=deepseek-v4-flash
+
+CHAT_MODEL=deepseek-v4-flash
+
+LLM_TIMEOUT=30

simagentplg-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+.env
+
+__pycache__/
+
+my_skills
+
+.ruff_cache
+
+.playwright-mcp
+
+.DS_Store
+
+NapcatBot

simagentplg-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

simagentplg-0.1.0/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.

simagentplg-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,172 @@
+# 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/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "SimAgentPlg"
+version = "0.1.0"
+description = "A lightweight multi-agent framework with ReAct reasoning, tool dispatch, and MCP integration"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.12"
+dependencies = [
+    "fastmcp>=3.4.2",
+    "openai>=2.41.0",
+    "python-dotenv>=1.2.2",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/allagent"]

simagentplg-0.1.0/src/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",
+]

simagentplg-0.1.0/src/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"]

simagentplg-0.1.0/src/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")