opencomputer 0.1.0__py3-none-any.whl

opencomputer/gateway/dispatch.py

@@ -0,0 +1,89 @@
+"""
+Gateway dispatch — route inbound MessageEvents to the agent loop.
+
+This is the glue between channel adapters (Telegram, Discord, etc.)
+and the AgentLoop. Each adapter calls `Dispatch.handle_message(event)`;
+we map chat_id → session_id and invoke the loop.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import logging
+
+from opencomputer.agent.loop import AgentLoop
+from plugin_sdk.core import MessageEvent
+
+logger = logging.getLogger("opencomputer.gateway.dispatch")
+
+
+class Dispatch:
+    """Map channel messages to agent-loop runs, keeping per-chat sessions separate."""
+
+    def __init__(self, loop: AgentLoop) -> None:
+        self.loop = loop
+        # One lock per chat_id — prevents interleaved turns from the same chat
+        self._locks: dict[str, asyncio.Lock] = {}
+        # Adapter reference (set by Gateway) so we can send typing indicators
+        self._adapters_by_platform: dict = {}
+
+    def register_adapter(self, platform: str, adapter) -> None:
+        self._adapters_by_platform[platform] = adapter
+
+    def _session_id_for(self, event: MessageEvent) -> str:
+        """Stable session id: hash(platform + chat_id). Keeps history per chat."""
+        h = hashlib.sha256(f"{event.platform.value}:{event.chat_id}".encode())
+        return h.hexdigest()[:32]
+
+    async def handle_message(self, event: MessageEvent) -> str | None:
+        """
+        Handle one inbound message. Runs the agent loop and returns the
+        final assistant text for the adapter to send back.
+
+        Also starts a periodic typing-indicator heartbeat on the source
+        channel so the user sees "..." while the agent thinks.
+        """
+        if not event.text.strip():
+            return None
+        session_id = self._session_id_for(event)
+        lock = self._locks.setdefault(session_id, asyncio.Lock())
+        async with lock:
+            # Start a typing heartbeat (Telegram's typing state expires after
+            # ~5s, so we re-send every 4s until the turn completes).
+            heartbeat = asyncio.create_task(
+                self._typing_heartbeat(event.platform.value, event.chat_id)
+            )
+            try:
+                result = await self.loop.run_conversation(
+                    user_message=event.text,
+                    session_id=session_id,
+                )
+                return result.final_message.content or None
+            except Exception as e:  # noqa: BLE001
+                logger.exception("dispatch error for %s: %s", event.platform, e)
+                return f"[error: {type(e).__name__}: {e}]"
+            finally:
+                heartbeat.cancel()
+                try:
+                    await heartbeat
+                except (asyncio.CancelledError, Exception):
+                    pass
+
+    async def _typing_heartbeat(self, platform: str, chat_id: str) -> None:
+        """Send typing indicator every 4s until cancelled."""
+        adapter = self._adapters_by_platform.get(platform)
+        if adapter is None:
+            return
+        try:
+            while True:
+                try:
+                    await adapter.send_typing(chat_id)
+                except Exception:
+                    pass  # typing is best-effort
+                await asyncio.sleep(4.0)
+        except asyncio.CancelledError:
+            return
+
+
+__all__ = ["Dispatch"]

opencomputer/gateway/protocol.py

@@ -0,0 +1,84 @@
+"""
+Gateway wire protocol — JSON over WebSocket.
+
+Clients connect to the gateway and exchange messages in this format.
+Openclaw-style: typed schemas, request/response/event messages.
+
+Three message shapes:
+    req   — client → gateway request            {type:"req", id, method, params}
+    res   — gateway → client response           {type:"res", id, ok, payload?, error?}
+    event — gateway → client server-push event  {type:"event", event, payload}
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+# ─── Request ────────────────────────────────────────────────────
+
+
+class WireRequest(BaseModel):
+    type: Literal["req"] = "req"
+    id: str
+    method: str
+    params: dict[str, Any] = Field(default_factory=dict)
+
+
+# ─── Response ───────────────────────────────────────────────────
+
+
+class WireResponse(BaseModel):
+    type: Literal["res"] = "res"
+    id: str
+    ok: bool
+    payload: dict[str, Any] | None = None
+    error: str | None = None
+
+
+# ─── Events (server-push) ───────────────────────────────────────
+
+
+class WireEvent(BaseModel):
+    type: Literal["event"] = "event"
+    event: str  # e.g. "turn.begin", "tool.call", "assistant.delta", "turn.end"
+    payload: dict[str, Any] = Field(default_factory=dict)
+
+
+# ─── Method names (client → gateway) ────────────────────────────
+
+# These are the RPC methods clients can call.
+METHOD_HELLO = "hello"  # handshake, exchange capabilities
+METHOD_CHAT = "chat"  # send a user message, get assistant response
+METHOD_SESSION_LIST = "sessions.list"
+METHOD_SEARCH = "search"
+METHOD_SKILLS_LIST = "skills.list"
+
+
+# ─── Event names (gateway → client) ─────────────────────────────
+
+EVENT_TURN_BEGIN = "turn.begin"
+EVENT_TURN_END = "turn.end"
+EVENT_TOOL_CALL = "tool.call"
+EVENT_TOOL_RESULT = "tool.result"
+EVENT_ASSISTANT_MESSAGE = "assistant.message"
+EVENT_ERROR = "error"
+
+
+__all__ = [
+    "WireRequest",
+    "WireResponse",
+    "WireEvent",
+    "METHOD_HELLO",
+    "METHOD_CHAT",
+    "METHOD_SESSION_LIST",
+    "METHOD_SEARCH",
+    "METHOD_SKILLS_LIST",
+    "EVENT_TURN_BEGIN",
+    "EVENT_TURN_END",
+    "EVENT_TOOL_CALL",
+    "EVENT_TOOL_RESULT",
+    "EVENT_ASSISTANT_MESSAGE",
+    "EVENT_ERROR",
+]

opencomputer/gateway/server.py

@@ -0,0 +1,77 @@
+"""
+Gateway daemon — runs channel adapters + optional WebSocket server.
+
+Two modes:
+    1. Channel mode: start configured channel adapters (Telegram, Discord, ...).
+       Messages arrive via platform SDKs → Dispatch → AgentLoop → back out.
+    2. Wire mode (optional): also start a WebSocket server on a local port,
+       letting additional clients (TUI, web, mobile) use the same agent via
+       the typed protocol.
+
+Phase 2 focuses on channel mode. Wire mode is scaffolded but minimal.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from opencomputer.agent.loop import AgentLoop
+from opencomputer.gateway.dispatch import Dispatch
+from plugin_sdk.channel_contract import BaseChannelAdapter
+
+logger = logging.getLogger("opencomputer.gateway.server")
+
+
+class Gateway:
+    """The gateway daemon."""
+
+    def __init__(self, loop: AgentLoop) -> None:
+        self.loop = loop
+        self.dispatch = Dispatch(loop)
+        self._adapters: list[BaseChannelAdapter] = []
+
+    def register_adapter(self, adapter: BaseChannelAdapter) -> None:
+        """Register a channel adapter (usually from a loaded plugin)."""
+        adapter.set_message_handler(self.dispatch.handle_message)
+        self._adapters.append(adapter)
+        # Give Dispatch a handle so it can send typing indicators back out.
+        self.dispatch.register_adapter(adapter.platform.value, adapter)
+
+    async def start(self) -> None:
+        """Connect all adapters. Returns once they're all running."""
+        logger.info("gateway: starting %d adapters", len(self._adapters))
+        results = await asyncio.gather(
+            *(a.connect() for a in self._adapters), return_exceptions=True
+        )
+        for adapter, res in zip(self._adapters, results, strict=False):
+            if isinstance(res, Exception):
+                logger.error(
+                    "gateway: adapter %s failed to connect: %s", adapter.platform, res
+                )
+            elif res is False:
+                logger.error("gateway: adapter %s returned False from connect()", adapter.platform)
+
+    async def stop(self) -> None:
+        logger.info("gateway: stopping")
+        await asyncio.gather(
+            *(a.disconnect() for a in self._adapters), return_exceptions=True
+        )
+
+    async def serve_forever(self) -> None:
+        """Connect adapters and block until interrupted."""
+        await self.start()
+        try:
+            while True:
+                await asyncio.sleep(3600)
+        except asyncio.CancelledError:
+            pass
+        finally:
+            await self.stop()
+
+    @property
+    def adapters(self) -> list[BaseChannelAdapter]:
+        return list(self._adapters)
+
+
+__all__ = ["Gateway"]

opencomputer/gateway/wire_server.py

@@ -0,0 +1,256 @@
+"""
+Wire server — WebSocket JSON-RPC server for TUI / IDE / web clients.
+
+Listens on 127.0.0.1:<port> by default. Each connection is independent —
+clients send WireRequests, receive WireResponses (and server-pushed
+WireEvents during long-running calls like chat).
+
+Supported methods:
+  hello                — handshake, returns server capabilities
+  chat                 — send a user message, stream assistant response
+  sessions.list        — list recent sessions
+  search               — FTS5 search across session history
+  skills.list          — list available skills
+
+New methods can be added by plugins in a future phase.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import uuid
+from typing import Any
+
+import websockets
+
+from opencomputer.agent.loop import AgentLoop
+from opencomputer.gateway.protocol import (
+    EVENT_ASSISTANT_MESSAGE,
+    EVENT_ERROR,
+    EVENT_TURN_BEGIN,
+    EVENT_TURN_END,
+    METHOD_CHAT,
+    METHOD_HELLO,
+    METHOD_SEARCH,
+    METHOD_SESSION_LIST,
+    METHOD_SKILLS_LIST,
+    WireEvent,
+    WireRequest,
+    WireResponse,
+)
+
+logger = logging.getLogger("opencomputer.gateway.wire_server")
+
+
+class WireServer:
+    """Minimal JSON-RPC-over-WebSocket server for local clients."""
+
+    def __init__(
+        self,
+        loop: AgentLoop,
+        host: str = "127.0.0.1",
+        port: int = 18789,
+    ) -> None:
+        self.loop = loop
+        self.host = host
+        self.port = port
+        self._server: websockets.WebSocketServer | None = None
+
+    async def start(self) -> None:
+        self._server = await websockets.serve(
+            self._handle_client, self.host, self.port
+        )
+        logger.info("wire: listening on ws://%s:%s", self.host, self.port)
+
+    async def stop(self) -> None:
+        if self._server is not None:
+            self._server.close()
+            await self._server.wait_closed()
+
+    async def _handle_client(
+        self, ws: websockets.WebSocketServerProtocol
+    ) -> None:
+        client_id = str(uuid.uuid4())[:8]
+        logger.info("wire: client %s connected", client_id)
+        try:
+            async for raw in ws:
+                try:
+                    data = json.loads(raw)
+                except json.JSONDecodeError:
+                    await self._send_response(
+                        ws, "", False, error="invalid JSON"
+                    )
+                    continue
+
+                if data.get("type") != "req":
+                    await self._send_response(
+                        ws, data.get("id", ""), False, error="expected type=req"
+                    )
+                    continue
+
+                try:
+                    req = WireRequest(**data)
+                except Exception as e:
+                    await self._send_response(
+                        ws,
+                        data.get("id", ""),
+                        False,
+                        error=f"invalid request: {e}",
+                    )
+                    continue
+
+                try:
+                    await self._dispatch(ws, req)
+                except Exception as e:  # noqa: BLE001
+                    logger.exception("wire dispatch error for method %s", req.method)
+                    await self._send_response(
+                        ws, req.id, False, error=f"{type(e).__name__}: {e}"
+                    )
+        except websockets.ConnectionClosed:
+            pass
+        finally:
+            logger.info("wire: client %s disconnected", client_id)
+
+    async def _dispatch(
+        self, ws: websockets.WebSocketServerProtocol, req: WireRequest
+    ) -> None:
+        if req.method == METHOD_HELLO:
+            await self._send_response(
+                ws,
+                req.id,
+                True,
+                payload={
+                    "server": "opencomputer",
+                    "version": "0.0.1",
+                    "methods": [
+                        METHOD_HELLO,
+                        METHOD_CHAT,
+                        METHOD_SESSION_LIST,
+                        METHOD_SEARCH,
+                        METHOD_SKILLS_LIST,
+                    ],
+                    "events": [
+                        EVENT_TURN_BEGIN,
+                        EVENT_TURN_END,
+                        EVENT_ASSISTANT_MESSAGE,
+                        EVENT_ERROR,
+                    ],
+                },
+            )
+        elif req.method == METHOD_CHAT:
+            await self._handle_chat(ws, req)
+        elif req.method == METHOD_SESSION_LIST:
+            limit = int(req.params.get("limit", 20))
+            rows = self.loop.db.list_sessions(limit=limit)
+            await self._send_response(ws, req.id, True, payload={"sessions": rows})
+        elif req.method == METHOD_SEARCH:
+            query = str(req.params.get("query", ""))
+            limit = int(req.params.get("limit", 20))
+            hits = self.loop.db.search(query, limit=limit)
+            await self._send_response(ws, req.id, True, payload={"hits": hits})
+        elif req.method == METHOD_SKILLS_LIST:
+            skills = self.loop.memory.list_skills()
+            payload = {
+                "skills": [
+                    {
+                        "id": s.id,
+                        "name": s.name,
+                        "description": s.description,
+                        "version": s.version,
+                    }
+                    for s in skills
+                ]
+            }
+            await self._send_response(ws, req.id, True, payload=payload)
+        else:
+            await self._send_response(
+                ws, req.id, False, error=f"unknown method: {req.method}"
+            )
+
+    async def _handle_chat(
+        self, ws: websockets.WebSocketServerProtocol, req: WireRequest
+    ) -> None:
+        user_message = str(req.params.get("message", "")).strip()
+        session_id = req.params.get("session_id") or None
+        if not user_message:
+            await self._send_response(
+                ws, req.id, False, error="empty message"
+            )
+            return
+
+        # Announce turn begin
+        await self._send_event(
+            ws, EVENT_TURN_BEGIN, {"request_id": req.id}
+        )
+
+        # Stream text deltas to the client as assistant messages
+        async def _on_chunk(text: str) -> None:
+            await self._send_event(
+                ws,
+                EVENT_ASSISTANT_MESSAGE,
+                {"delta": text, "request_id": req.id},
+            )
+
+        try:
+            result = await self.loop.run_conversation(
+                user_message=user_message,
+                session_id=session_id,
+                stream_callback=lambda t: asyncio.create_task(_on_chunk(t)),
+            )
+        except Exception as e:  # noqa: BLE001
+            await self._send_event(
+                ws,
+                EVENT_ERROR,
+                {"request_id": req.id, "error": f"{type(e).__name__}: {e}"},
+            )
+            await self._send_response(
+                ws, req.id, False, error=f"{type(e).__name__}: {e}"
+            )
+            return
+
+        await self._send_event(
+            ws,
+            EVENT_TURN_END,
+            {
+                "request_id": req.id,
+                "iterations": result.iterations,
+                "input_tokens": result.input_tokens,
+                "output_tokens": result.output_tokens,
+                "session_id": result.session_id,
+            },
+        )
+        await self._send_response(
+            ws,
+            req.id,
+            True,
+            payload={
+                "text": result.final_message.content,
+                "session_id": result.session_id,
+                "iterations": result.iterations,
+            },
+        )
+
+    async def _send_response(
+        self,
+        ws: websockets.WebSocketServerProtocol,
+        req_id: str,
+        ok: bool,
+        payload: dict[str, Any] | None = None,
+        error: str | None = None,
+    ) -> None:
+        res = WireResponse(id=req_id, ok=ok, payload=payload, error=error)
+        await ws.send(res.model_dump_json())
+
+    async def _send_event(
+        self,
+        ws: websockets.WebSocketServerProtocol,
+        event_name: str,
+        payload: dict[str, Any],
+    ) -> None:
+        ev = WireEvent(event=event_name, payload=payload)
+        await ws.send(ev.model_dump_json())
+
+
+__all__ = ["WireServer"]

opencomputer/hooks/__init__.py

@@ -0,0 +1 @@
+"""Hook engine — lifecycle event intercepts."""

opencomputer/hooks/engine.py

@@ -0,0 +1,79 @@
+"""
+Hook engine — dispatches lifecycle events to registered handlers.
+
+Registration pattern mirrors the tool registry. Plugins call
+`engine.register(HookSpec(...))` at load time. At runtime the agent
+loop emits events via `engine.fire(HookEvent.X, ctx)`.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from collections import defaultdict
+
+from opencomputer.hooks.runner import fire_and_forget
+from plugin_sdk.hooks import HookContext, HookDecision, HookEvent, HookSpec
+
+logger = logging.getLogger("opencomputer.hooks")
+
+
+class HookEngine:
+    """Central dispatcher for lifecycle events."""
+
+    def __init__(self) -> None:
+        self._hooks: dict[HookEvent, list[HookSpec]] = defaultdict(list)
+
+    def register(self, spec: HookSpec) -> None:
+        self._hooks[spec.event].append(spec)
+
+    def unregister_all(self, event: HookEvent | None = None) -> None:
+        if event is None:
+            self._hooks.clear()
+        else:
+            self._hooks[event] = []
+
+    def _matches(self, spec: HookSpec, ctx: HookContext) -> bool:
+        if spec.matcher is None:
+            return True
+        # Matcher is a regex over tool name (for PreToolUse / PostToolUse)
+        tool_name = ""
+        if ctx.tool_call:
+            tool_name = ctx.tool_call.name
+        elif ctx.tool_result:
+            tool_name = ctx.tool_result.tool_call_id  # fallback — not ideal
+        try:
+            return re.search(spec.matcher, tool_name) is not None
+        except re.error:
+            return False
+
+    async def fire_blocking(self, ctx: HookContext) -> HookDecision | None:
+        """Fire a hook event and WAIT for decisions (for PreToolUse approvals).
+
+        Returns the first non-pass decision, or None if all hooks passed.
+        """
+        for spec in self._hooks.get(ctx.event, []):
+            if not self._matches(spec, ctx):
+                continue
+            try:
+                decision = await spec.handler(ctx)
+            except Exception:  # noqa: BLE001
+                logger.exception("blocking hook raised")
+                continue
+            if decision is None or decision.decision == "pass":
+                continue
+            return decision
+        return None
+
+    def fire_and_forget(self, ctx: HookContext) -> None:
+        """Fire a hook event without waiting. Used for PostToolUse logging etc."""
+        for spec in self._hooks.get(ctx.event, []):
+            if not self._matches(spec, ctx):
+                continue
+            fire_and_forget(spec.handler(ctx))
+
+
+engine = HookEngine()
+
+
+__all__ = ["HookEngine", "engine"]

opencomputer/hooks/runner.py

@@ -0,0 +1,42 @@
+"""
+Fire-and-forget async runner.
+
+Adapted from kimi-cli's pattern: post-action hooks must NEVER block
+the main loop. We schedule them as independent tasks and log any
+exceptions (never re-raise).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Coroutine
+from typing import Any
+
+logger = logging.getLogger("opencomputer.hooks.runner")
+
+_pending: set[asyncio.Task[Any]] = set()
+
+
+def fire_and_forget(coro: Coroutine[Any, Any, Any]) -> None:
+    """Schedule `coro` to run independently. Exceptions are logged, never raised."""
+    try:
+        task = asyncio.create_task(coro)
+    except RuntimeError:
+        # No running event loop — run synchronously on the current thread as a last resort.
+        asyncio.run(coro)
+        return
+    _pending.add(task)
+    task.add_done_callback(_on_done)
+
+
+def _on_done(task: asyncio.Task[Any]) -> None:
+    _pending.discard(task)
+    if task.cancelled():
+        return
+    exc = task.exception()
+    if exc is not None:
+        logger.warning("fire-and-forget hook raised: %s", exc)
+
+
+__all__ = ["fire_and_forget"]

opencomputer/mcp/__init__.py

@@ -0,0 +1 @@
+"""MCP (Model Context Protocol) integration — connect to external tool servers."""