opencomputer 0.1.0__py3-none-any.whl

opencomputer/mcp/client.py

@@ -0,0 +1,208 @@
+"""
+MCP client — connects to MCP servers (stdio or HTTP) and exposes their
+tools via our tool registry.
+
+Each MCP tool becomes a thin BaseTool subclass that dispatches calls back
+through the live MCP session. Servers are connected lazily in the
+background (kimi-cli pattern) so startup stays fast.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from contextlib import AsyncExitStack
+from dataclasses import dataclass
+from typing import Any
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from opencomputer.agent.config import MCPServerConfig
+from opencomputer.tools.registry import ToolRegistry
+from plugin_sdk.core import ToolCall, ToolResult
+from plugin_sdk.tool_contract import BaseTool, ToolSchema
+
+logger = logging.getLogger("opencomputer.mcp.client")
+
+
+# ─── MCPTool — one tool exposed via MCP ────────────────────────────
+
+
+class MCPTool(BaseTool):
+    """Tool that dispatches calls to an MCP session."""
+
+    parallel_safe = False  # conservative — each server has its own state
+
+    def __init__(
+        self,
+        server_name: str,
+        tool_name: str,
+        description: str,
+        parameters: dict[str, Any],
+        session: ClientSession,
+    ) -> None:
+        self.server_name = server_name
+        self.tool_name = tool_name
+        self.description = description
+        self.parameters = parameters
+        self.session = session
+
+    @property
+    def schema(self) -> ToolSchema:
+        # Namespace MCP tools with the server name so there's no collision
+        # between multiple servers exposing a tool with the same name.
+        display_name = f"{self.server_name}__{self.tool_name}"
+        return ToolSchema(
+            name=display_name,
+            description=self.description,
+            parameters=self.parameters,
+        )
+
+    async def execute(self, call: ToolCall) -> ToolResult:
+        try:
+            result = await self.session.call_tool(
+                name=self.tool_name, arguments=call.arguments
+            )
+            # Convert MCP result to our string format — concatenate text blocks
+            parts: list[str] = []
+            is_error = bool(getattr(result, "isError", False))
+            for block in (result.content or []):
+                if hasattr(block, "text") and block.text:
+                    parts.append(block.text)
+                elif hasattr(block, "type") and block.type == "image":
+                    parts.append("[image]")
+                else:
+                    parts.append(str(block))
+            return ToolResult(
+                tool_call_id=call.id,
+                content="\n".join(parts) or "[empty MCP response]",
+                is_error=is_error,
+            )
+        except Exception as e:  # noqa: BLE001
+            return ToolResult(
+                tool_call_id=call.id,
+                content=f"MCP error from {self.server_name}.{self.tool_name}: {type(e).__name__}: {e}",
+                is_error=True,
+            )
+
+
+# ─── MCPConnection — one live server connection ───────────────────
+
+
+@dataclass(slots=True)
+class MCPConnection:
+    config: MCPServerConfig
+    session: ClientSession | None = None
+    exit_stack: AsyncExitStack | None = None
+    tools: list[MCPTool] = None  # type: ignore[assignment]
+
+    def __post_init__(self) -> None:
+        if self.tools is None:
+            self.tools = []
+
+    async def connect(self) -> bool:
+        """Spin up the server process / HTTP session, initialize, cache tool list."""
+        self.exit_stack = AsyncExitStack()
+        try:
+            if self.config.transport == "stdio":
+                params = StdioServerParameters(
+                    command=self.config.command,
+                    args=list(self.config.args),
+                    env=self.config.env or None,
+                )
+                stdio_ctx = stdio_client(params)
+                streams = await self.exit_stack.enter_async_context(stdio_ctx)
+                read_stream, write_stream = streams
+            elif self.config.transport == "http":
+                # HTTP (SSE) transport kept minimal — just an example hook
+                raise NotImplementedError("http MCP transport — Phase 4.1")
+            else:
+                raise ValueError(f"unknown MCP transport: {self.config.transport}")
+
+            session = await self.exit_stack.enter_async_context(
+                ClientSession(read_stream, write_stream)
+            )
+            await session.initialize()
+            self.session = session
+
+            # List + cache tools
+            tool_list = await session.list_tools()
+            for t in tool_list.tools:
+                self.tools.append(
+                    MCPTool(
+                        server_name=self.config.name,
+                        tool_name=t.name,
+                        description=t.description or "",
+                        parameters=t.inputSchema or {"type": "object", "properties": {}},
+                        session=session,
+                    )
+                )
+            logger.info(
+                "MCP server '%s' connected — %d tool(s)",
+                self.config.name,
+                len(self.tools),
+            )
+            return True
+        except Exception as e:  # noqa: BLE001
+            logger.exception("MCP server '%s' failed to connect: %s", self.config.name, e)
+            await self.disconnect()
+            return False
+
+    async def disconnect(self) -> None:
+        if self.exit_stack is not None:
+            try:
+                await self.exit_stack.aclose()
+            except Exception:  # noqa: BLE001
+                pass
+        self.exit_stack = None
+        self.session = None
+
+
+# ─── MCPManager — orchestrates multiple connections ───────────────
+
+
+class MCPManager:
+    """Manages connections to all configured MCP servers."""
+
+    def __init__(self, tool_registry: ToolRegistry) -> None:
+        self.tool_registry = tool_registry
+        self.connections: list[MCPConnection] = []
+
+    async def connect_all(self, servers: list[MCPServerConfig]) -> int:
+        """Connect to every enabled server + register its tools. Returns tool count."""
+        total = 0
+        for cfg in servers:
+            if not cfg.enabled:
+                continue
+            conn = MCPConnection(config=cfg)
+            ok = await conn.connect()
+            if not ok:
+                continue
+            self.connections.append(conn)
+            for tool in conn.tools:
+                try:
+                    self.tool_registry.register(tool)
+                    total += 1
+                except ValueError:
+                    logger.warning(
+                        "MCP tool name collision (skipped): %s", tool.schema.name
+                    )
+        return total
+
+    async def shutdown(self) -> None:
+        """Disconnect all servers and remove their tools from the registry."""
+        for conn in self.connections:
+            for tool in conn.tools:
+                self.tool_registry.unregister(tool.schema.name)
+            await conn.disconnect()
+        self.connections.clear()
+
+    def schedule_deferred_connect(
+        self, servers: list[MCPServerConfig]
+    ) -> asyncio.Task[int]:
+        """Start connecting in the background (kimi-cli pattern) — returns the Task."""
+        return asyncio.create_task(self.connect_all(servers))
+
+
+__all__ = ["MCPTool", "MCPConnection", "MCPManager"]

opencomputer/plugins/__init__.py

@@ -0,0 +1 @@
+"""Plugin system — discovery (manifest scan) + loader (lazy activation)."""

opencomputer/plugins/discovery.py

@@ -0,0 +1,107 @@
+"""
+Plugin discovery — Phase 1 of the two-phase loader.
+
+Walk the extensions/ and ~/.opencomputer/plugins/ directories, find
+`plugin.json` manifests, and build PluginCandidates. This phase is
+CHEAP — only JSON reads, no imports.
+
+Phase 2 (loader.py) activates a candidate on demand by importing its
+entry module and letting it register its tools/channels/hooks.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+from plugin_sdk.core import PluginManifest
+
+logger = logging.getLogger("opencomputer.plugins.discovery")
+
+_IGNORE_DIRS = {
+    ".git",
+    ".venv",
+    "node_modules",
+    "__pycache__",
+    ".pytest_cache",
+    ".ruff_cache",
+    "dist",
+    "build",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class PluginCandidate:
+    """Metadata-only view of an installed plugin — output of discovery."""
+
+    manifest: PluginManifest
+    root_dir: Path
+    manifest_path: Path
+
+
+def _parse_manifest(manifest_path: Path) -> PluginManifest | None:
+    try:
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except Exception as e:  # noqa: BLE001
+        logger.warning("failed to parse manifest %s: %s", manifest_path, e)
+        return None
+    if "id" not in data or "name" not in data or "version" not in data:
+        logger.warning("manifest %s missing required fields (id, name, version)", manifest_path)
+        return None
+    return PluginManifest(
+        id=str(data["id"]),
+        name=str(data["name"]),
+        version=str(data["version"]),
+        description=str(data.get("description", "")),
+        author=str(data.get("author", "")),
+        homepage=str(data.get("homepage", "")),
+        license=str(data.get("license", "MIT")),
+        kind=data.get("kind", "mixed"),
+        entry=str(data.get("entry", "")),
+    )
+
+
+def discover(search_paths: list[Path]) -> list[PluginCandidate]:
+    """
+    Scan each path for `plugin.json` files. Return a list of PluginCandidates.
+
+    Only direct children of each search path are considered (we don't recurse
+    deeply — plugins live at `<root>/<plugin-id>/plugin.json`).
+    """
+    candidates: list[PluginCandidate] = []
+    seen_ids: set[str] = set()
+
+    for root in search_paths:
+        if not root.exists() or not root.is_dir():
+            continue
+        for entry in sorted(root.iterdir()):
+            if not entry.is_dir() or entry.name in _IGNORE_DIRS or entry.name.startswith("."):
+                continue
+            manifest_path = entry / "plugin.json"
+            if not manifest_path.exists():
+                continue
+            manifest = _parse_manifest(manifest_path)
+            if manifest is None:
+                continue
+            if manifest.id in seen_ids:
+                logger.warning(
+                    "plugin id collision: '%s' — skipping second occurrence at %s",
+                    manifest.id,
+                    entry,
+                )
+                continue
+            seen_ids.add(manifest.id)
+            candidates.append(
+                PluginCandidate(
+                    manifest=manifest,
+                    root_dir=entry,
+                    manifest_path=manifest_path,
+                )
+            )
+
+    return candidates
+
+
+__all__ = ["discover", "PluginCandidate"]

opencomputer/plugins/loader.py

@@ -0,0 +1,155 @@
+"""
+Plugin loader — Phase 2 of the two-phase pattern.
+
+Given a PluginCandidate (from discovery.py), lazily import the entry
+module and call its register() function. Plugins register their tools,
+channel adapters, provider adapters, and hooks with the core registries.
+
+Plugins declare their entry module in plugin.json via the `entry` field
+(e.g. `"entry": "src.plugin"`). We import that module — it must export
+a `register(api)` function where `api` exposes the plugin-facing registries.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import logging
+import sys
+from dataclasses import dataclass
+from typing import Any
+
+from opencomputer.plugins.discovery import PluginCandidate
+
+logger = logging.getLogger("opencomputer.plugins.loader")
+
+
+# Common short names plugins use for their sibling files. Clearing these
+# between plugin loads prevents two plugins (both with a top-level
+# `provider.py`, say) from sharing the first-loaded module.
+_PLUGIN_LOCAL_NAMES = ("provider", "adapter", "plugin", "handlers", "hooks")
+
+
+def _clear_plugin_local_cache() -> None:
+    for name in _PLUGIN_LOCAL_NAMES:
+        sys.modules.pop(name, None)
+
+
+@dataclass(slots=True)
+class LoadedPlugin:
+    """Record of an activated plugin."""
+
+    candidate: PluginCandidate
+    module: Any
+
+
+class PluginAPI:
+    """Passed to each plugin's register() — the narrow runtime surface."""
+
+    def __init__(
+        self,
+        tool_registry: Any,
+        hook_engine: Any,
+        provider_registry: dict[str, Any],
+        channel_registry: dict[str, Any],
+        injection_engine: Any = None,
+    ) -> None:
+        self.tools = tool_registry
+        self.hooks = hook_engine
+        self.providers = provider_registry
+        self.channels = channel_registry
+        self.injection = injection_engine
+
+    def register_tool(self, tool: Any) -> None:
+        self.tools.register(tool)
+
+    def register_hook(self, spec: Any) -> None:
+        self.hooks.register(spec)
+
+    def register_provider(self, name: str, provider: Any) -> None:
+        self.providers[name] = provider
+
+    def register_channel(self, name: str, adapter: Any) -> None:
+        self.channels[name] = adapter
+
+    def register_injection_provider(self, provider: Any) -> None:
+        """Register a DynamicInjectionProvider (plan mode, yolo mode, etc.)."""
+        if self.injection is None:
+            raise RuntimeError(
+                "Injection engine unavailable — plugin-SDK version mismatch?"
+            )
+        self.injection.register(provider)
+
+
+def load_plugin(candidate: PluginCandidate, api: PluginAPI) -> LoadedPlugin | None:
+    """Import a candidate's entry module and call its register(api) function.
+
+    Uses importlib.util.spec_from_file_location with a unique synthetic module
+    name per plugin (based on plugin id). This avoids Python's module cache
+    returning the same module for multiple plugins that happen to share an
+    `entry` value (e.g. all three plugins use "plugin" as their entry).
+
+    Also adds the plugin root to sys.path so the entry module's own sibling
+    imports (e.g. `from adapter import X`) resolve correctly.
+    """
+    manifest = candidate.manifest
+    entry = manifest.entry.strip()
+    if not entry:
+        logger.warning("plugin '%s' has no 'entry' field in manifest", manifest.id)
+        return None
+
+    plugin_root = candidate.root_dir.resolve()
+    plugin_root_str = str(plugin_root)
+    if plugin_root_str not in sys.path:
+        sys.path.insert(0, plugin_root_str)
+
+    entry_path = plugin_root / f"{entry}.py"
+    if not entry_path.exists():
+        logger.warning(
+            "plugin '%s' entry file not found: %s (expected at %s)",
+            manifest.id,
+            entry,
+            entry_path,
+        )
+        return None
+
+    # Clear common sibling module names from sys.modules so this plugin sees
+    # its OWN siblings (not another plugin's cached 'provider' or 'adapter').
+    # Without this, two plugins that both have a top-level 'provider' module
+    # would share the one that loaded first.
+    _clear_plugin_local_cache()
+
+    # Unique module name so sys.modules doesn't collide between plugins
+    synthetic_name = f"_opencomputer_plugin_{manifest.id.replace('-', '_')}_{entry}"
+
+    try:
+        spec = importlib.util.spec_from_file_location(synthetic_name, entry_path)
+        if spec is None or spec.loader is None:
+            raise ImportError(f"no spec for {entry_path}")
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[synthetic_name] = module
+        spec.loader.exec_module(module)
+    except Exception as e:  # noqa: BLE001
+        logger.exception("failed to import plugin '%s' (entry=%s): %s", manifest.id, entry, e)
+        return None
+
+    register_fn = getattr(module, "register", None)
+    if register_fn is None:
+        logger.warning(
+            "plugin '%s' has no register() function in entry module %s",
+            manifest.id,
+            entry,
+        )
+        return None
+
+    try:
+        register_fn(api)
+    except Exception as e:  # noqa: BLE001
+        logger.exception("plugin '%s' register() raised: %s", manifest.id, e)
+        return None
+
+    logger.info("loaded plugin '%s' v%s", manifest.id, manifest.version)
+    return LoadedPlugin(candidate=candidate, module=module)
+
+
+__all__ = ["PluginAPI", "LoadedPlugin", "load_plugin"]

opencomputer/plugins/registry.py

@@ -0,0 +1,56 @@
+"""
+Plugin registry — the active set of loaded plugins + the surfaces they registered.
+
+Holds the provider registry and channel registry (tools go into the
+tool registry from tools/registry.py; hooks go into the hook engine).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from opencomputer.agent.injection import engine as injection_engine
+from opencomputer.hooks.engine import engine as hook_engine
+from opencomputer.plugins.discovery import PluginCandidate, discover
+from opencomputer.plugins.loader import LoadedPlugin, PluginAPI, load_plugin
+from opencomputer.tools.registry import registry as tool_registry
+from plugin_sdk.provider_contract import BaseProvider
+
+
+@dataclass(slots=True)
+class PluginRegistry:
+    """Holds all loaded plugins and the shared API they register into."""
+
+    providers: dict[str, BaseProvider] = field(default_factory=dict)
+    channels: dict[str, object] = field(default_factory=dict)
+    loaded: list[LoadedPlugin] = field(default_factory=list)
+
+    def api(self) -> PluginAPI:
+        return PluginAPI(
+            tool_registry=tool_registry,
+            hook_engine=hook_engine,
+            provider_registry=self.providers,
+            channel_registry=self.channels,
+            injection_engine=injection_engine,
+        )
+
+    def load_all(self, search_paths: list[Path]) -> list[LoadedPlugin]:
+        """Discover + activate all plugins. Returns the list of successfully loaded ones."""
+        candidates = discover(search_paths)
+        api = self.api()
+        for cand in candidates:
+            loaded = load_plugin(cand, api)
+            if loaded:
+                self.loaded.append(loaded)
+        return self.loaded
+
+    def list_candidates(self, search_paths: list[Path]) -> list[PluginCandidate]:
+        """Cheap discovery only — doesn't activate anything."""
+        return discover(search_paths)
+
+
+registry = PluginRegistry()
+
+
+__all__ = ["PluginRegistry", "registry"]