auto-agent-kit 0.1.0__py3-none-any.whl

auto_agent_kit/core/mcp_server.py

@@ -0,0 +1,239 @@
+"""MCPServer — MCP 协议服务器
+
+JSON-RPC 2.0 + SSE 传输，用于 Agent 工具暴露和远程调用。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+
+logger = logging.getLogger("auto_agent_kit.mcp")
+
+
+@dataclass
+class MCPTool:
+    """MCP 工具定义"""
+    name: str
+    description: str
+    handler: Callable
+    parameters: dict = field(default_factory=lambda: {"type": "object", "properties": {}})
+
+
+@dataclass
+class MCPRequest:
+    """JSON-RPC 请求"""
+    jsonrpc: str = "2.0"
+    method: str = ""
+    params: Any = None
+    id: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "MCPRequest":
+        return cls(
+            jsonrpc=data.get("jsonrpc", "2.0"),
+            method=data.get("method", ""),
+            params=data.get("params"),
+            id=data.get("id"),
+        )
+
+    def to_response(self, result: Any = None, error: Optional[dict] = None) -> dict:
+        resp = {"jsonrpc": "2.0", "id": self.id}
+        if error:
+            resp["error"] = error
+        else:
+            resp["result"] = result
+        return resp
+
+
+class MCPServer:
+    """MCP 协议服务器 — JSON-RPC 2.0 + SSE"""
+
+    def __init__(self, host: str = "0.0.0.0", port: int = 8901):
+        self.host = host
+        self.port = port
+        self._tools: dict[str, MCPTool] = {}
+        self._request_log: list[dict] = []
+        self._max_log: int = 500
+        self._app: Any = None  # FastAPI app (lazy init)
+        self._started: bool = False
+
+    def register_tool(self, name: str, description: str, handler: Callable,
+                      parameters: Optional[dict] = None):
+        """注册一个 MCP 工具"""
+        self._tools[name] = MCPTool(
+            name=name,
+            description=description,
+            handler=handler,
+            parameters=parameters or {"type": "object", "properties": {}},
+        )
+
+    def register_tools(self, tools: list[dict]):
+        """批量注册工具"""
+        for t in tools:
+            self.register_tool(
+                name=t["name"],
+                description=t.get("description", ""),
+                handler=t["handler"],
+                parameters=t.get("parameters"),
+            )
+
+    def handle_request(self, raw: dict) -> dict:
+        """处理 JSON-RPC 请求"""
+        try:
+            req = MCPRequest.from_dict(raw)
+        except Exception as e:
+            return {"jsonrpc": "2.0", "id": None, "error": {
+                "code": -32700, "message": f"Parse error: {e}"
+            }}
+
+        # 记录请求
+        self._request_log.append({
+            "timestamp": time.time(),
+            "method": req.method,
+            "id": req.id,
+        })
+        if len(self._request_log) > self._max_log:
+            self._request_log = self._request_log[-self._max_log:]
+
+        # 内置方法
+        if req.method == "list_tools":
+            return req.to_response(result={
+                "tools": [
+                    {"name": t.name, "description": t.description, "parameters": t.parameters}
+                    for t in self._tools.values()
+                ]
+            })
+
+        if req.method == "ping":
+            return req.to_response(result={"pong": True, "timestamp": time.time()})
+
+        # 工具调用
+        if req.method == "call_tool":
+            tool_name = req.params.get("name", "") if req.params else ""
+            tool_args = req.params.get("arguments", {}) if req.params else {}
+
+            tool = self._tools.get(tool_name)
+            if not tool:
+                return req.to_response(error={
+                    "code": -32601,
+                    "message": f"Tool not found: {tool_name}",
+                })
+
+            try:
+                result = tool.handler(**tool_args)
+                return req.to_response(result={
+                    "content": [{"type": "text", "text": str(result)}],
+                })
+            except Exception as e:
+                logger.error(f"Tool {tool_name} failed: {e}")
+                return req.to_response(error={
+                    "code": -32000,
+                    "message": f"Tool execution error: {e}",
+                })
+
+        # 未知方法
+        return req.to_response(error={
+            "code": -32601,
+            "message": f"Method not found: {req.method}",
+        })
+
+    def build_app(self):
+        """构建 FastAPI 应用（可选依赖）"""
+        try:
+            from fastapi import FastAPI, Request
+            from fastapi.responses import JSONResponse, StreamingResponse
+        except ImportError:
+            raise ImportError("FastAPI is required for MCPServer HTTP mode. "
+                              "Install: pip install auto-agent-kit[mcp]")
+
+        app = FastAPI(title="AutoAgentKit MCP Server", version="0.1.0")
+
+        @app.get("/health")
+        async def health():
+            return {"status": "ok", "tools": len(self._tools)}
+
+        @app.get("/tools")
+        async def list_tools():
+            return {
+                "tools": [
+                    {"name": t.name, "description": t.description}
+                    for t in self._tools.values()
+                ]
+            }
+
+        @app.post("/rpc")
+        async def rpc(request: Request):
+            body = await request.json()
+            result = self.handle_request(body)
+            return JSONResponse(result)
+
+        @app.get("/sse")
+        async def sse(request: Request):
+            """SSE 端点"""
+            async def event_generator():
+                yield f"data: {json.dumps({'type': 'connected', 'tools': len(self._tools)})}\n\n"
+                # 保持连接
+                while True:
+                    await asyncio.sleep(30)
+                    yield f"data: {json.dumps({'type': 'heartbeat'})}\n\n"
+
+            return StreamingResponse(
+                event_generator(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                },
+            )
+
+        self._app = app
+        return app
+
+    def start(self, host: Optional[str] = None, port: Optional[int] = None):
+        """启动 MCP 服务器"""
+        import asyncio
+        import uvicorn
+
+        host = host or self.host
+        port = port or self.port
+
+        app = self.build_app()
+        self._started = True
+        logger.info(f"MCP Server starting on {host}:{port}")
+        uvicorn.run(app, host=host, port=port, log_level="info")
+
+    def start_async(self, host: Optional[str] = None, port: Optional[int] = None):
+        """异步启动（在已有事件循环中使用）"""
+        import asyncio
+        import uvicorn
+
+        host = host or self.host
+        port = port or self.port
+
+        app = self.build_app()
+        self._started = True
+
+        config = uvicorn.Config(app, host=host, port=port, log_level="info")
+        server = uvicorn.Server(config)
+        return server.serve()
+
+    def get_stats(self) -> dict:
+        """获取服务器统计"""
+        return {
+            "started": self._started,
+            "host": self.host,
+            "port": self.port,
+            "tools_registered": len(self._tools),
+            "requests_handled": len(self._request_log),
+            "tool_names": list(self._tools.keys()),
+        }
+
+    def stop(self):
+        """停止服务器"""
+        self._started = False
+        logger.info("MCP Server stopped")

auto_agent_kit/core/plan_mode.py

@@ -0,0 +1,174 @@
+"""PlanMode — 计划执行模式
+
+将复杂任务分解为可执行步骤，支持 Plan/Act 分离。
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable, Optional
+
+
+class StepStatus(Enum):
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class PlanStep:
+    """单个计划步骤"""
+    id: str
+    description: str
+    status: StepStatus = StepStatus.PENDING
+    dependencies: list[str] = field(default_factory=list)
+    result: Optional[Any] = None
+    error: Optional[str] = None
+    started_at: Optional[float] = None
+    completed_at: Optional[float] = None
+
+    @property
+    def duration(self) -> Optional[float]:
+        if self.started_at and self.completed_at:
+            return self.completed_at - self.started_at
+        return None
+
+
+@dataclass
+class ExecutionPlan:
+    """完整的执行计划"""
+    goal: str
+    steps: list[PlanStep] = field(default_factory=list)
+    created_at: float = field(default_factory=time.time)
+    context: dict[str, Any] = field(default_factory=dict)
+
+    def add_step(self, description: str, dependencies: Optional[list[str]] = None) -> PlanStep:
+        step_id = f"step_{len(self.steps) + 1}"
+        step = PlanStep(
+            id=step_id,
+            description=description,
+            dependencies=dependencies or [],
+        )
+        self.steps.append(step)
+        return step
+
+    def get_next_ready(self) -> Optional[PlanStep]:
+        """获取下一个可执行的步骤（依赖已完成的步骤）"""
+        completed_ids = {s.id for s in self.steps if s.status == StepStatus.COMPLETED}
+        for step in self.steps:
+            if step.status != StepStatus.PENDING:
+                continue
+            if all(dep in completed_ids for dep in step.dependencies):
+                return step
+        return None
+
+    @property
+    def progress(self) -> float:
+        if not self.steps:
+            return 0.0
+        done = sum(1 for s in self.steps if s.status in (StepStatus.COMPLETED, StepStatus.SKIPPED))
+        return done / len(self.steps)
+
+    @property
+    def summary(self) -> str:
+        total = len(self.steps)
+        done = sum(1 for s in self.steps if s.status == StepStatus.COMPLETED)
+        failed = sum(1 for s in self.steps if s.status == StepStatus.FAILED)
+        return f"[{done}/{total} 完成, {failed} 失败, {self.progress*100:.0f}%]"
+
+
+class PlanMode:
+    """计划执行模式 — 将复杂任务分解为可执行步骤"""
+
+    def __init__(self, max_retries: int = 2):
+        self.max_retries = max_retries
+        self.current_plan: Optional[ExecutionPlan] = None
+        self._history: list[dict] = []
+
+    def create_plan(self, goal: str, steps: Optional[list[str]] = None) -> ExecutionPlan:
+        """创建执行计划"""
+        plan = ExecutionPlan(goal=goal)
+        if steps:
+            for desc in steps:
+                plan.add_step(desc)
+        self.current_plan = plan
+        self._history.append({"action": "create_plan", "goal": goal, "steps": len(steps or [])})
+        return plan
+
+    def start_step(self, step_id: str) -> Optional[PlanStep]:
+        """开始执行一个步骤"""
+        if not self.current_plan:
+            return None
+        for step in self.current_plan.steps:
+            if step.id == step_id and step.status == StepStatus.PENDING:
+                step.status = StepStatus.IN_PROGRESS
+                step.started_at = time.time()
+                return step
+        return None
+
+    def complete_step(self, step_id: str, result: Any = None) -> Optional[PlanStep]:
+        """完成一个步骤"""
+        if not self.current_plan:
+            return None
+        for step in self.current_plan.steps:
+            if step.id == step_id and step.status == StepStatus.IN_PROGRESS:
+                step.status = StepStatus.COMPLETED
+                step.completed_at = time.time()
+                step.result = result
+                return step
+        return None
+
+    def fail_step(self, step_id: str, error: str) -> Optional[PlanStep]:
+        """标记步骤失败"""
+        if not self.current_plan:
+            return None
+        for step in self.current_plan.steps:
+            if step.id == step_id and step.status == StepStatus.IN_PROGRESS:
+                step.status = StepStatus.FAILED
+                step.completed_at = time.time()
+                step.error = error
+                return step
+        return None
+
+    def execute_sequentially(self, executor: Callable[[str], Any]) -> list[dict]:
+        """顺序执行所有步骤（无依赖）"""
+        if not self.current_plan:
+            return []
+        results = []
+        for step in self.current_plan.steps:
+            self.start_step(step.id)
+            for attempt in range(self.max_retries + 1):
+                try:
+                    result = executor(step.description)
+                    self.complete_step(step.id, result)
+                    results.append({"step": step.id, "status": "ok", "result": result})
+                    break
+                except Exception as e:
+                    if attempt < self.max_retries:
+                        continue
+                    self.fail_step(step.id, str(e))
+                    results.append({"step": step.id, "status": "failed", "error": str(e)})
+        return results
+
+    def get_plan_status(self) -> dict:
+        """获取计划状态摘要"""
+        if not self.current_plan:
+            return {"status": "no_plan"}
+        return {
+            "goal": self.current_plan.goal,
+            "progress": self.current_plan.progress,
+            "summary": self.current_plan.summary,
+            "steps": [
+                {"id": s.id, "description": s.description, "status": s.status.value}
+                for s in self.current_plan.steps
+            ],
+        }
+
+    def reset(self):
+        """重置计划"""
+        self.current_plan = None

auto_agent_kit/core/tool_router.py

@@ -0,0 +1,130 @@
+"""ToolRouter — 语义工具路由器
+
+阶段性工具暴露，每阶段 ≤ 8 工具，防止上下文膨胀。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Optional
+
+
+class ToolPhase(Enum):
+    """工具阶段"""
+    INIT = "init"  # 初始阶段 — 核心工具
+    EXPLORE = "explore"  # 探索阶段 — 搜索/读取工具
+    EXECUTE = "execute"  # 执行阶段 — 全部工具
+    REVIEW = "review"  # 审查阶段 — 验证/检查工具
+
+
+@dataclass
+class ToolDef:
+    """工具定义"""
+    name: str
+    description: str
+    phase: ToolPhase = ToolPhase.INIT
+    usage_count: int = 0
+    last_used: Optional[float] = None
+    is_active: bool = True
+
+
+class ToolRouter:
+    """语义工具路由器 — 阶段性暴露工具，防止上下文膨胀"""
+
+    PHASE_LIMITS = {
+        ToolPhase.INIT: 5,
+        ToolPhase.EXPLORE: 6,
+        ToolPhase.EXECUTE: 8,
+        ToolPhase.REVIEW: 5,
+    }
+
+    def __init__(self):
+        self._tools: dict[str, ToolDef] = {}
+        self._current_phase: ToolPhase = ToolPhase.INIT
+        self._phase_history: list[ToolPhase] = []
+
+    def register(self, name: str, description: str, phase: ToolPhase = ToolPhase.INIT) -> ToolDef:
+        """注册一个工具"""
+        tool = ToolDef(name=name, description=description, phase=phase)
+        self._tools[name] = tool
+        return tool
+
+    def register_batch(self, tools: list[dict]) -> list[ToolDef]:
+        """批量注册工具"""
+        results = []
+        for t in tools:
+            results.append(self.register(
+                name=t["name"],
+                description=t["description"],
+                phase=ToolPhase(t.get("phase", "init")),
+            ))
+        return results
+
+    def set_phase(self, phase: ToolPhase) -> list[ToolDef]:
+        """切换阶段，返回当前阶段可用工具"""
+        self._phase_history.append(self._current_phase)
+        self._current_phase = phase
+        return self.get_active_tools()
+
+    def get_active_tools(self) -> list[ToolDef]:
+        """获取当前阶段可用工具"""
+        active = [
+            t for t in self._tools.values()
+            if t.phase == self._current_phase and t.is_active
+        ]
+        limit = self.PHASE_LIMITS.get(self._current_phase, 8)
+        return active[:limit]
+
+    def get_all_tools(self) -> list[ToolDef]:
+        """获取所有注册工具"""
+        return list(self._tools.values())
+
+    def use_tool(self, name: str) -> Optional[ToolDef]:
+        """记录工具使用"""
+        import time
+        tool = self._tools.get(name)
+        if tool:
+            tool.usage_count += 1
+            tool.last_used = time.time()
+        return tool
+
+    def deactivate(self, name: str) -> bool:
+        """停用工具"""
+        tool = self._tools.get(name)
+        if tool:
+            tool.is_active = False
+            return True
+        return False
+
+    def activate(self, name: str) -> bool:
+        """启用工具"""
+        tool = self._tools.get(name)
+        if tool:
+            tool.is_active = True
+            return True
+        return False
+
+    def get_stats(self) -> dict:
+        """获取工具使用统计"""
+        return {
+            "total_tools": len(self._tools),
+            "current_phase": self._current_phase.value,
+            "active_tools": len(self.get_active_tools()),
+            "phase_history": [p.value for p in self._phase_history],
+            "usage": {
+                name: {"count": t.usage_count, "phase": t.phase.value}
+                for name, t in self._tools.items()
+            },
+        }
+
+    def find_dead_tools(self, threshold_days: float = 30) -> list[str]:
+        """查找长期未使用的工具"""
+        import time
+        now = time.time()
+        threshold_seconds = threshold_days * 86400
+        dead = []
+        for name, tool in self._tools.items():
+            if tool.last_used and (now - tool.last_used) > threshold_seconds:
+                dead.append(name)
+        return dead