@baimingtao/lbs-agent 1.0.0

package/tools/mcp/registry.py

@@ -0,0 +1,538 @@
+"""MCP Server Registry — 让 MCP 配置真正进入 Agent Runtime。
+
+对标 LBS 风格：MCP server 配置是 data，registry 是 runtime。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+import uuid
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class McpServer:
+    name: str
+    command: str = ""
+    args: list[str] = field(default_factory=list)
+    env: dict[str, str] = field(default_factory=dict)
+    enabled: bool = True
+    description: str = ""
+    transport: str = "stdio"  # stdio | http
+    url: str = ""
+    headers: dict[str, str] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    @staticmethod
+    def _redact_text(value: str) -> str:
+        lowered = value.lower()
+        if any(token in lowered for token in ("token", "secret", "password", "api_key", "authorization")):
+            return "<redacted>"
+        return value
+
+    @classmethod
+    def _redact_mapping(cls, values: dict[str, Any]) -> dict[str, Any]:
+        return {
+            str(key): ("<redacted>" if any(token in str(key).lower() for token in ("token", "secret", "password", "api_key", "authorization")) else value)
+            for key, value in values.items()
+        }
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "command": self.command,
+            "args": list(self.args),
+            "env": dict(self.env),
+            "enabled": self.enabled,
+            "description": self.description,
+            "transport": self.transport,
+            "url": self.url,
+            "headers": dict(self.headers),
+            "metadata": dict(self.metadata),
+        }
+
+    def public_dict(self) -> dict[str, Any]:
+        payload = self.to_dict()
+        payload["args"] = [self._redact_text(str(value)) for value in self.args]
+        payload["env"] = self._redact_mapping(self.env)
+        payload["headers"] = self._redact_mapping(self.headers)
+        payload["metadata"] = self._redact_mapping(self.metadata)
+        return payload
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "McpServer":
+        return cls(
+            name=d.get("name", ""),
+            command=d.get("command", ""),
+            args=list(d.get("args", []) or []),
+            env=dict(d.get("env", {}) or {}),
+            enabled=bool(d.get("enabled", True)),
+            description=d.get("description", ""),
+            transport=d.get("transport", "stdio").replace("streamable-http", "http"),
+            url=d.get("url", ""),
+            headers=dict(d.get("headers", {}) or {}),
+            metadata=dict(d.get("metadata", {}) or {}),
+        )
+
+
+class McpRegistry:
+    """持久化 MCP server 注册表。
+
+    基于 YAML / JSON 文件 + 原子写。线程安全。
+    """
+
+    def __init__(self, config_path: str | Path, *, virtual_proxy: bool = True, timeout_seconds: float = 30.0):
+        self.config_path = Path(config_path)
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.RLock()
+        self._servers: dict[str, McpServer] = {}
+        self._processes: dict[str, Any] = {}
+        self._discovered_tools: dict[str, list[dict[str, Any]]] = {}
+        self._discovery_errors: dict[str, str] = {}
+        self.virtual_proxy = virtual_proxy
+        self.timeout_seconds = timeout_seconds
+        self._raw_config: dict[str, Any] = {}
+        self._load()
+
+    def clear_discovery_cache(self, name: str | None = None) -> None:
+        if name:
+            self._discovered_tools.pop(name, None)
+            self._discovery_errors.pop(name, None)
+        else:
+            self._discovered_tools.clear()
+            self._discovery_errors.clear()
+
+    def discovery_status(self, name: str | None = None) -> dict[str, Any]:
+        names = [name] if name else [s.name for s in self.list_servers(include_disabled=True)]
+        result: dict[str, Any] = {}
+        for item in names:
+            server = self.get_server(item)
+            if server is None:
+                result[item] = {"status": "missing", "error": "MCP server 不存在"}
+            elif not server.enabled:
+                result[item] = {"status": "disabled", "error": "MCP server 未启用"}
+            elif item in self._discovery_errors:
+                result[item] = {"status": "discovery_failed", "error": self._discovery_errors[item]}
+            elif item in self._discovered_tools:
+                result[item] = {"status": "discovered", "tool_count": len(self._discovered_tools[item])}
+            else:
+                result[item] = {"status": "unknown"}
+        return result
+
+    # ── 进程生命周期方法（见下方定义） ──────────────────
+
+    def _load(self) -> None:
+        if not self.config_path.exists():
+            return
+        try:
+            text = self.config_path.read_text(encoding="utf-8")
+            if self.config_path.suffix.lower() in {".yaml", ".yml"}:
+                import yaml
+                raw = yaml.safe_load(text) or {}
+            else:
+                raw = json.loads(text)
+        except Exception:
+            return
+        self._raw_config = dict(raw) if isinstance(raw, dict) else {}
+        servers = self._raw_config.get("mcp_servers", {}) or {}
+        for name, spec in servers.items():
+            self._servers[name] = McpServer.from_dict({"name": name, **(spec or {})})
+
+    def _save(self) -> None:
+        import os as _os
+        with self._lock:
+            payload = dict(self._raw_config or {})
+            payload["mcp_servers"] = {n: s.to_dict() for n, s in self._servers.items()}
+            tmp = self.config_path.with_suffix(self.config_path.suffix + ".tmp")
+            if self.config_path.suffix.lower() in {".yaml", ".yml"}:
+                import yaml
+                tmp.write_text(yaml.safe_dump(payload, allow_unicode=True, default_flow_style=False, sort_keys=False), encoding="utf-8")
+            else:
+                tmp.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+            _os.replace(tmp, self.config_path)
+
+    def list_servers(self, include_disabled: bool = False) -> list[McpServer]:
+        return [s for s in self._servers.values() if s.enabled or include_disabled]
+
+    def get_server(self, name: str) -> McpServer | None:
+        return self._servers.get(name)
+
+    def upsert(self, name: str, *, command: str = "", args: list[str] | None = None, env: dict[str, str] | None = None, transport: str = "stdio", url: str = "", headers: dict[str, str] | None = None, description: str = "", enabled: bool = True) -> McpServer:
+        server = McpServer(
+            name=name,
+            command=command,
+            args=list(args or []),
+            env=dict(env or {}),
+            transport=transport,
+            url=url,
+            description=description,
+            headers=dict(headers or {}),
+            enabled=enabled,
+        )
+        with self._lock:
+            self._servers[name] = server
+            self._save()
+        return server
+
+    def remove(self, name: str) -> bool:
+        with self._lock:
+            if name in self._servers:
+                del self._servers[name]
+                self._save()
+                return True
+            return False
+
+    def set_enabled(self, name: str, enabled: bool) -> bool:
+        with self._lock:
+            server = self._servers.get(name)
+            if not server:
+                return False
+            server.enabled = enabled
+            self._save()
+            return True
+
+    # ── 暴露给 Agent 的工具发现 API ──────────────────
+
+    def discover_tool_specs(self) -> list[dict[str, Any]]:
+        """连接 enabled server，发现真实 MCP tools；失败时保留兼容 virtual invoke tool。"""
+        specs: list[dict[str, Any]] = []
+        for server in self.list_servers(include_disabled=False):
+            discovered = self._discover_server_tools(server)
+            if discovered:
+                specs.extend(discovered)
+                if self.virtual_proxy:
+                    # 兼容旧 Agent/profile 的 virtual proxy。
+                    specs.append({
+                        "name": f"mcp_{server.name}__invoke",
+                        "description": server.description or f"MCP server {server.name} virtual invoke proxy",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "method": {"type": "string", "description": "MCP method to invoke"},
+                                "params": {"type": "object", "description": "Method params"},
+                            },
+                            "required": ["method"],
+                        },
+                        "metadata": {
+                            "transport": server.transport,
+                            "command": server.command,
+                            "args": server.args,
+                            "url": server.url,
+                            "server": server.name,
+                            "headers": dict(server.headers),
+                            "virtual_proxy": True,
+                        },
+                    })
+                continue
+            if self.virtual_proxy:
+                specs.append({
+                    "name": f"mcp_{server.name}__invoke",
+                    "description": server.description or f"MCP server {server.name}",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "method": {"type": "string", "description": "MCP method to invoke"},
+                            "params": {"type": "object", "description": "Method params"},
+                        },
+                        "required": ["method"],
+                    },
+                    "metadata": {
+                        "transport": server.transport,
+                        "command": server.command,
+                        "args": server.args,
+                        "url": server.url,
+                        "server": server.name,
+                        "headers": dict(server.headers),
+                    },
+                })
+        return specs
+
+    @staticmethod
+    def _tool_name(server_name: str, tool_name: str) -> str:
+        safe_server = re.sub(r"[^A-Za-z0-9_]+", "_", server_name).strip("_") or "server"
+        safe_tool = re.sub(r"[^A-Za-z0-9_]+", "_", tool_name).strip("_") or "tool"
+        return f"mcp_{safe_server}_{safe_tool}"
+
+    @staticmethod
+    def _expand_env(value: str) -> str:
+        if not isinstance(value, str):
+            return value
+        return re.sub(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)|%([A-Za-z_][A-Za-z0-9_]*)%", lambda m: os.environ.get(next(g for g in m.groups() if g), m.group(0)), value)
+
+    def _server_command(self, command: str) -> str:
+        if os.name == "nt" and command.lower() in {"python", "python3"}:
+            return sys.executable
+        return command
+
+    def _server_env(self, server: McpServer) -> dict[str, str]:
+        env = dict(os.environ)
+        env.update({str(k): self._expand_env(str(v)) for k, v in (server.env or {}).items()})
+        return env
+
+    async def _list_all_tools(self, session) -> list[Any]:
+        tools: list[Any] = []
+        cursor = None
+        while True:
+            result = await session.list_tools(cursor=cursor)
+            tools.extend(list(getattr(result, "tools", []) or []))
+            cursor = getattr(result, "nextCursor", None)
+            if not cursor:
+                return tools
+
+    def _discover_server_tools(self, server: McpServer) -> list[dict[str, Any]]:
+        cached = self._discovered_tools.get(server.name)
+        if cached is not None:
+            return list(cached)
+        try:
+            import anyio
+            from mcp import ClientSession
+            from mcp.client.stdio import StdioServerParameters, stdio_client
+            http_client_factory = None
+            try:
+                from mcp.client.streamable_http import streamable_http_client as http_client_factory
+            except Exception:
+                try:
+                    from mcp.client.streamable_http import streamablehttp_client as http_client_factory
+                except Exception:
+                    pass
+        except Exception:
+            return []
+
+        async def _run():
+            if server.transport == "stdio":
+                if not server.command:
+                    return []
+                params = StdioServerParameters(command=self._server_command(server.command), args=list(server.args), env=self._server_env(server))
+                async with stdio_client(params) as (read, write):
+                    async with ClientSession(read, write) as session:
+                        await session.initialize()
+                        tools = await self._list_all_tools(session)
+                        return tools
+            if server.transport == "http" and http_client_factory is not None and server.url:
+                import httpx
+                headers = dict(server.headers or {})
+                async with httpx.AsyncClient(headers=headers) as client:
+                    async with http_client_factory(server.url, http_client=client) as (read, write, _):
+                        async with ClientSession(read, write) as session:
+                            await session.initialize()
+                            tools = await self._list_all_tools(session)
+                            return tools
+            return []
+
+        try:
+            tools = self._run_anyio(self._run_with_timeout, _run)
+        except Exception as exc:
+            self._discovery_errors[server.name] = f"{type(exc).__name__}: {exc}"
+            return []
+        specs = []
+        for tool in tools:
+            name = str(getattr(tool, "name", "") or "")
+            if not name:
+                continue
+            annotations = getattr(tool, "annotations", None)
+            annotation_data = annotations.model_dump() if hasattr(annotations, "model_dump") else {}
+            specs.append({
+                "name": self._tool_name(server.name, name),
+                "description": str(getattr(tool, "description", None) or getattr(tool, "title", None) or name),
+                "parameters": getattr(tool, "inputSchema", None) or {"type": "object", "properties": {}},
+                "metadata": {"transport": server.transport, "command": server.command, "args": list(server.args), "url": server.url, "server": server.name, "method": name, "headers": McpServer._redact_mapping(server.headers), "annotations": annotation_data},
+            })
+        self._discovered_tools[server.name] = specs
+        self._discovery_errors.pop(server.name, None)
+        return specs
+
+    async def _run_with_timeout(self, operation):
+        import anyio
+        with anyio.fail_after(self.timeout_seconds):
+            return await operation()
+
+    @staticmethod
+    def _run_anyio(func, *args):
+        """在独立线程里跑 anyio.run，避免和已有 asyncio 事件循环冲突。
+
+        FastAPI/uvicorn 的请求处理线程里已经有 running asyncio loop，
+        直接 anyio.run 会 RuntimeError: Already running asyncio in this thread。
+        用 threading.Thread 隔离即可。
+        """
+        import anyio
+        result_box: dict[str, Any] = {}
+
+        def _worker():
+            try:
+                result_box["value"] = anyio.run(func, *args)
+            except BaseException as exc:
+                result_box["error"] = exc
+
+        t = threading.Thread(target=_worker, daemon=True)
+        t.start()
+        t.join(timeout=None)
+        if "error" in result_box:
+            raise result_box["error"]
+        return result_box.get("value")
+
+    # ── 进程生命周期：真的把 MCP server 拉起/关闭 ──────────────────
+
+    def start_server(self, name: str) -> bool:
+        """启动一个 MCP server 进程（stdio transport）。
+
+        Returns True 表示成功拉起（或者已经在跑）。
+        Returns False 表示 server 不存在、已禁用或启动失败。
+        """
+        import subprocess
+        import sys
+        server = self.get_server(name)
+        if server is None:
+            return False
+        if not server.enabled:
+            return False
+        if server.transport == "http":
+            # HTTP 模式的 server 由外部托管，这里只登记可达性
+            return bool(server.url)
+        if not server.command:
+            return False
+        with self._lock:
+            running = self._processes.get(name)
+            if running is not None:
+                # 已在跑：检查是否还活着
+                if running.poll() is None:
+                    return True
+                # 死了就清掉，重新拉
+                self._processes.pop(name, None)
+            try:
+                merged_env = dict(os.environ if hasattr(os, "environ") else {})
+                merged_env.update(server.env)
+                proc = subprocess.Popen(
+                    [self._server_command(server.command)] + list(server.args),
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    env=merged_env,
+                )
+                self._processes[name] = proc
+                return True
+            except Exception:
+                return False
+
+    def stop_server(self, name: str) -> bool:
+        """停止一个 MCP server 进程。"""
+        with self._lock:
+            proc = self._processes.pop(name, None)
+            if proc is None:
+                return False
+            try:
+                proc.terminate()
+                try:
+                    proc.wait(timeout=5)
+                except Exception:
+                    proc.kill()
+                return True
+            except Exception:
+                return False
+
+    def stop_all(self) -> int:
+        """停止所有 MCP server 进程。返回成功停止的个数。"""
+        stopped = 0
+        with self._lock:
+            names = list(self._processes.keys())
+        for name in names:
+            if self.stop_server(name):
+                stopped += 1
+        return stopped
+
+    def is_running(self, name: str) -> bool:
+        with self._lock:
+            proc = self._processes.get(name)
+        if proc is None:
+            return False
+        return proc.poll() is None
+
+    def start_all_enabled(self) -> int:
+        """拉起所有 enabled 的 server，返回成功数。"""
+        started = 0
+        for server in self.list_servers(include_disabled=False):
+            if self.start_server(server.name):
+                started += 1
+        return started
+
+
+    def invoke_tool(self, server_name: str, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """真实调用 MCP tool。
+
+        当前先支持 stdio transport；HTTP transport 后续再补。
+        返回统一 dict：{"ok": bool, "content": ..., "error": ...}
+        """
+        server = self.get_server(server_name)
+        if server is None:
+            return {"ok": False, "error": f"MCP server 不存在: {server_name}"}
+        if not server.enabled:
+            return {"ok": False, "error": f"MCP server 未启用: {server_name}"}
+        try:
+            import anyio
+            from mcp import ClientSession
+            from mcp.client.stdio import StdioServerParameters, stdio_client
+            try:
+                # 新版 API
+                from mcp.client.streamable_http import streamable_http_client as streamable_http_client
+            except Exception:
+                try:
+                    # 兼容旧版 API 名
+                    from mcp.client.streamable_http import streamablehttp_client as streamable_http_client
+                except Exception:
+                    streamable_http_client = None
+        except Exception as e:
+            return {"ok": False, "error": f"MCP 依赖不可用: {type(e).__name__}: {e}"}
+
+        async def _run_once():
+            if server.transport == "stdio":
+                if not server.command:
+                    raise RuntimeError(f"MCP server 缺少 command: {server_name}")
+                proc_env = self._server_env(server)
+                stdio = StdioServerParameters(command=self._server_command(server.command), args=list(server.args), env=proc_env)
+                async with stdio_client(stdio) as (read, write):
+                    async with ClientSession(read, write) as session:
+                        await session.initialize()
+                        return await session.call_tool(method, params or {})
+            if server.transport == "http":
+                if not server.url:
+                    raise RuntimeError(f"MCP server 缺少 url: {server_name}")
+                if streamable_http_client is None:
+                    raise RuntimeError("当前 mcp 版本不支持 streamable_http client")
+                headers = dict(server.headers or {}) or None
+                if headers:
+                    import httpx
+                    async with httpx.AsyncClient(headers=headers) as http_client:
+                        async with streamable_http_client(server.url, http_client=http_client) as (read, write, _get_session_id):
+                            async with ClientSession(read, write) as session:
+                                await session.initialize()
+                                return await session.call_tool(method, params or {})
+                async with streamable_http_client(server.url) as (read, write, _get_session_id):
+                    async with ClientSession(read, write) as session:
+                        await session.initialize()
+                        return await session.call_tool(method, params or {})
+            raise RuntimeError(f"当前 transport 不支持: {server.transport}")
+
+        try:
+            result = self._run_anyio(self._run_with_timeout, _run_once)
+            structured = getattr(result, "structuredContent", None)
+            is_error = bool(getattr(result, "isError", False))
+            content_blocks = getattr(result, "content", []) or []
+            text_parts = [getattr(b, "text", "") for b in content_blocks if getattr(b, "type", "") == "text"]
+            joined_text = "\n".join([t for t in text_parts if t])
+            payload = structured if structured is not None else {"text": joined_text}
+            return {"ok": not is_error, "content": payload, "raw_text": joined_text, "error": "" if not is_error else (joined_text or "MCP tool 调用失败")}
+        except Exception as e:
+            return {"ok": False, "error": f"MCP 调用异常: {type(e).__name__}: {e}"}
+
+    def status(self) -> dict[str, Any]:
+        return {
+            "total": len(self._servers),
+            "enabled": sum(1 for s in self._servers.values() if s.enabled),
+            "servers": [s.public_dict() for s in self._servers.values()],
+            "discovery": self.discovery_status(),
+        }

package/tools/mcp/servers/__init__.py

@@ -0,0 +1,46 @@
+"""
+MCP Server — 将 LBS Agent 的工具暴露为 MCP server。
+
+最小实现：通过 ToolRegistry 生成 MCP tool 定义，
+支持 tools/list 和 tools/call JSON-RPC 方法。
+
+后续可对接真正的 stdio/SSE transport。
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+class MCPServerExporter:
+    """把 ToolRegistry 导出为 MCP server 工具列表。"""
+
+    def __init__(self, tool_registry):
+        self._registry = tool_registry
+
+    def list_tools(self) -> list[dict[str, Any]]:
+        """返回 MCP 格式的工具列表。"""
+        tools = []
+        if not self._registry:
+            return tools
+        for spec in self._registry.describe_tools():
+            tools.append({
+                "name": spec.get("name", ""),
+                "description": spec.get("description", ""),
+                "inputSchema": spec.get("parameters", {}),
+            })
+        return tools
+
+    def call_tool(self, name: str, arguments: dict[str, Any]) -> dict[str, Any]:
+        """调用一个工具并返回 MCP 格式结果。"""
+        from tools.tool.runtime import ToolRuntime, ToolCall, ToolContext
+        runtime = ToolRuntime(self._registry)
+        result = runtime.invoke(
+            ToolCall(id="mcp_call", name=name, arguments=arguments),
+            ToolContext(),
+        )
+        return {
+            "content": result.to_display_content(),
+            "isError": not result.ok,
+        }

package/tools/skill/__init__.py

@@ -0,0 +1,4 @@
+"""LBS Skill 框架。"""
+from .registry import SkillRegistry, SkillEntry, SkillSource, SkillSourceConfigStore, discover
+
+__all__ = ["SkillRegistry", "SkillEntry", "SkillSource", "SkillSourceConfigStore", "discover"]