chuk-tool-processor 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

chuk_tool_processor/mcp/transport/base_transport.py

@@ -0,0 +1,103 @@
+# chuk_tool_processor/mcp/transport/base_transport.py
+"""
+Abstract transport layer for MCP communication.
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List
+
+
+class MCPBaseTransport(ABC):
+    """
+    Abstract base class for MCP transport mechanisms.
+    """
+
+    # ------------------------------------------------------------------ #
+    #  connection lifecycle                                              #
+    # ------------------------------------------------------------------ #
+    @abstractmethod
+    async def initialize(self) -> bool:
+        """
+        Establish the connection.
+
+        Returns
+        -------
+        bool
+            ``True`` if the connection was initialised successfully.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Tear down the connection and release all resources."""
+        raise NotImplementedError
+
+    # ------------------------------------------------------------------ #
+    #  diagnostics                                                       #
+    # ------------------------------------------------------------------ #
+    @abstractmethod
+    async def send_ping(self) -> bool:
+        """
+        Send a **ping** request.
+
+        Returns
+        -------
+        bool
+            ``True`` on success, ``False`` otherwise.
+        """
+        raise NotImplementedError
+
+    # ------------------------------------------------------------------ #
+    #  tool handling                                                     #
+    # ------------------------------------------------------------------ #
+    @abstractmethod
+    async def get_tools(self) -> List[Dict[str, Any]]:
+        """
+        Return a list with *all* tool definitions exposed by the server.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def call_tool(
+        self, tool_name: str, arguments: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Execute *tool_name* with *arguments* and return the normalised result.
+        """
+        raise NotImplementedError
+
+    # ------------------------------------------------------------------ #
+    #  new: resources & prompts                                          #
+    # ------------------------------------------------------------------ #
+    @abstractmethod
+    async def list_resources(self) -> Dict[str, Any]:
+        """
+        Retrieve the server’s resources catalogue.
+
+        Expected shape::
+            { "resources": [ {...}, ... ], "nextCursor": "…", … }
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def list_prompts(self) -> Dict[str, Any]:
+        """
+        Retrieve the server’s prompt catalogue.
+
+        Expected shape::
+            { "prompts": [ {...}, ... ], "nextCursor": "…", … }
+        """
+        raise NotImplementedError
+
+    # ------------------------------------------------------------------ #
+    #  optional helper (non-abstract)                                    #
+    # ------------------------------------------------------------------ #
+    def get_streams(self):
+        """
+        Return a list of ``(read_stream, write_stream)`` tuples.
+
+        Transports that do not expose their low-level streams can simply leave
+        the default implementation (which returns an empty list).
+        """
+        return []

chuk_tool_processor/mcp/transport/sse_transport.py

@@ -0,0 +1,189 @@
+# chuk_tool_processor/mcp/transport/sse_transport.py
+"""
+Server-Sent Events (SSE) transport for MCP communication – implemented with **httpx**.
+"""
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from .base_transport import MCPBaseTransport
+
+# --------------------------------------------------------------------------- #
+# Helpers                                                                     #
+# --------------------------------------------------------------------------- #
+DEFAULT_TIMEOUT = 5.0  # seconds
+HEADERS_JSON: Dict[str, str] = {"accept": "application/json"}
+
+
+def _url(base: str, path: str) -> str:
+    """Join *base* and *path* with exactly one slash."""
+    return f"{base.rstrip('/')}/{path.lstrip('/')}"
+
+
+# --------------------------------------------------------------------------- #
+# Transport                                                                   #
+# --------------------------------------------------------------------------- #
+class SSETransport(MCPBaseTransport):
+    """
+    Minimal SSE/REST transport.  It speaks a simple REST dialect:
+
+        GET  /ping                → 200 OK
+        GET  /tools/list          → {"tools": [...]}
+        POST /tools/call          → {"name": ..., "result": ...}
+        GET  /resources/list      → {"resources": [...]}
+        GET  /prompts/list        → {"prompts": [...]}
+        GET  /events              → <text/event-stream>
+    """
+
+    EVENTS_PATH = "/events"
+
+    # ------------------------------------------------------------------ #
+    # Construction                                                       #
+    # ------------------------------------------------------------------ #
+    def __init__(self, url: str, api_key: Optional[str] = None) -> None:
+        self.base_url = url.rstrip("/")
+        self.api_key = api_key
+
+        # httpx client (None until initialise)
+        self._client: httpx.AsyncClient | None = None
+        self.session: httpx.AsyncClient | None = None  # ← kept for legacy tests
+
+        # background reader
+        self._reader_task: asyncio.Task | None = None
+        self._incoming_queue: "asyncio.Queue[dict[str, Any]]" = asyncio.Queue()
+
+    # ------------------------------------------------------------------ #
+    # Life-cycle                                                         #
+    # ------------------------------------------------------------------ #
+    async def initialize(self) -> bool:
+        """Open the httpx client and start the /events consumer."""
+        if self._client:  # already initialised
+            return True
+
+        self._client = httpx.AsyncClient(
+            headers={"authorization": self.api_key} if self.api_key else None,
+            timeout=DEFAULT_TIMEOUT,
+        )
+        self.session = self._client  # legacy attribute for tests
+
+        # spawn reader (best-effort reconnect)
+        self._reader_task = asyncio.create_task(self._consume_events(), name="sse-reader")
+
+        # verify connection
+        return await self.send_ping()
+
+    async def close(self) -> None:
+        """Stop background reader and close the httpx client."""
+        if self._reader_task:
+            self._reader_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._reader_task
+            self._reader_task = None
+
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+            self.session = None  # keep tests happy
+
+    # ------------------------------------------------------------------ #
+    # Internal helpers                                                   #
+    # ------------------------------------------------------------------ #
+    async def _get_json(self, path: str) -> Any:
+        if not self._client:
+            raise RuntimeError("Transport not initialised")
+
+        resp = await self._client.get(_url(self.base_url, path), headers=HEADERS_JSON)
+        resp.raise_for_status()
+        return resp.json()
+
+    async def _post_json(self, path: str, payload: Dict[str, Any]) -> Any:
+        if not self._client:
+            raise RuntimeError("Transport not initialised")
+
+        resp = await self._client.post(
+            _url(self.base_url, path), json=payload, headers=HEADERS_JSON
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    # ------------------------------------------------------------------ #
+    # Public API (implements MCPBaseTransport)                           #
+    # ------------------------------------------------------------------ #
+    async def send_ping(self) -> bool:
+        if not self._client:
+            return False
+        try:
+            await self._get_json("/ping")
+            return True
+        except Exception:  # pragma: no cover
+            return False
+
+    async def get_tools(self) -> List[Dict[str, Any]]:
+        if not self._client:
+            return []
+        try:
+            data = await self._get_json("/tools/list")
+            return data.get("tools", []) if isinstance(data, dict) else []
+        except Exception:  # pragma: no cover
+            return []
+
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        # ─── tests expect this specific message if *not* initialised ───
+        if not self._client:
+            return {"isError": True, "error": "SSE transport not implemented"}
+
+        try:
+            payload = {"name": tool_name, "arguments": arguments}
+            return await self._post_json("/tools/call", payload)
+        except Exception as exc:  # pragma: no cover
+            return {"isError": True, "error": str(exc)}
+
+    # ----------------------- extras used by StreamManager ------------- #
+    async def list_resources(self) -> List[Dict[str, Any]]:
+        if not self._client:
+            return []
+        try:
+            data = await self._get_json("/resources/list")
+            return data.get("resources", []) if isinstance(data, dict) else []
+        except Exception:  # pragma: no cover
+            return []
+
+    async def list_prompts(self) -> List[Dict[str, Any]]:
+        if not self._client:
+            return []
+        try:
+            data = await self._get_json("/prompts/list")
+            return data.get("prompts", []) if isinstance(data, dict) else []
+        except Exception:  # pragma: no cover
+            return []
+
+    # ------------------------------------------------------------------ #
+    # Background event-stream reader                                     #
+    # ------------------------------------------------------------------ #
+    async def _consume_events(self) -> None:  # pragma: no cover
+        """Continuously read `/events` and push JSON objects onto a queue."""
+        if not self._client:
+            return
+
+        while True:
+            try:
+                async with self._client.stream(
+                    "GET", _url(self.base_url, self.EVENTS_PATH), headers=HEADERS_JSON
+                ) as resp:
+                    resp.raise_for_status()
+                    async for line in resp.aiter_lines():
+                        if not line:
+                            continue
+                        try:
+                            await self._incoming_queue.put(json.loads(line))
+                        except json.JSONDecodeError:
+                            continue
+            except asyncio.CancelledError:
+                break
+            except Exception:
+                await asyncio.sleep(1.0)  # back-off and retry

chuk_tool_processor/mcp/transport/stdio_transport.py

@@ -0,0 +1,197 @@
+# chuk_tool_processor/mcp/transport/stdio_transport.py
+from __future__ import annotations
+
+from contextlib import AsyncExitStack
+import json
+from typing import Dict, Any, List, Optional
+
+# ------------------------------------------------------------------ #
+#  Local import                                                      #
+# ------------------------------------------------------------------ #
+from .base_transport import MCPBaseTransport
+
+# ------------------------------------------------------------------ #
+#  chuk-protocol imports                                             #
+# ------------------------------------------------------------------ #
+from chuk_mcp.mcp_client.transport.stdio.stdio_client import stdio_client
+from chuk_mcp.mcp_client.messages.initialize.send_messages import send_initialize
+from chuk_mcp.mcp_client.messages.ping.send_messages import send_ping
+
+# tools
+from chuk_mcp.mcp_client.messages.tools.send_messages import (
+    send_tools_call,
+    send_tools_list,
+)
+
+# NEW: resources & prompts
+from chuk_mcp.mcp_client.messages.resources.send_messages import (
+    send_resources_list,
+)
+from chuk_mcp.mcp_client.messages.prompts.send_messages import (
+    send_prompts_list,
+)
+
+
+class StdioTransport(MCPBaseTransport):
+    """
+    Stdio transport for MCP communication.
+    """
+
+    def __init__(self, server_params):
+        self.server_params = server_params
+        self.read_stream = None
+        self.write_stream = None
+        self._context_stack: Optional[AsyncExitStack] = None
+
+    # --------------------------------------------------------------------- #
+    #  Connection management                                                #
+    # --------------------------------------------------------------------- #
+    async def initialize(self) -> bool:
+        try:
+            self._context_stack = AsyncExitStack()
+            await self._context_stack.__aenter__()
+
+            ctx = stdio_client(self.server_params)
+            self.read_stream, self.write_stream = await self._context_stack.enter_async_context(
+                ctx
+            )
+
+            init_result = await send_initialize(self.read_stream, self.write_stream)
+            return bool(init_result)
+
+        except Exception as e:  # pragma: no cover
+            import logging
+
+            logging.error(f"Error initializing stdio transport: {e}")
+            if self._context_stack:
+                try:
+                    await self._context_stack.__aexit__(None, None, None)
+                except Exception:
+                    pass
+            return False
+
+    async def close(self) -> None:
+        if self._context_stack:
+            try:
+                await self._context_stack.__aexit__(None, None, None)
+            except Exception:
+                pass
+        self.read_stream = None
+        self.write_stream = None
+        self._context_stack = None
+
+    # --------------------------------------------------------------------- #
+    #  Utility                                                              #
+    # --------------------------------------------------------------------- #
+    async def send_ping(self) -> bool:
+        if not self.read_stream or not self.write_stream:
+            return False
+        return await send_ping(self.read_stream, self.write_stream)
+
+    async def get_tools(self) -> List[Dict[str, Any]]:
+        if not self.read_stream or not self.write_stream:
+            return []
+        tools_response = await send_tools_list(self.read_stream, self.write_stream)
+        return tools_response.get("tools", [])
+
+    # NEW ------------------------------------------------------------------ #
+    #  Resources / Prompts                                                   #
+    # --------------------------------------------------------------------- #
+    async def list_resources(self) -> Dict[str, Any]:
+        """
+        Return the result of *resources/list*.  If the connection is not yet
+        initialised an empty dict is returned.
+        """
+        if not self.read_stream or not self.write_stream:
+            return {}
+        try:
+            return await send_resources_list(self.read_stream, self.write_stream)
+        except Exception as exc:  # pragma: no cover
+            import logging
+
+            logging.error(f"Error listing resources: {exc}")
+            return {}
+
+    async def list_prompts(self) -> Dict[str, Any]:
+        """
+        Return the result of *prompts/list*.  If the connection is not yet
+        initialised an empty dict is returned.
+        """
+        if not self.read_stream or not self.write_stream:
+            return {}
+        try:
+            return await send_prompts_list(self.read_stream, self.write_stream)
+        except Exception as exc:  # pragma: no cover
+            import logging
+
+            logging.error(f"Error listing prompts: {exc}")
+            return {}
+
+    # OPTIONAL helper ------------------------------------------------------ #
+    def get_streams(self):
+        """
+        Expose the low-level streams so legacy callers can access them
+        directly.  The base-class’ default returns an empty list; here we
+        return a single-element list when the transport is active.
+        """
+        if self.read_stream and self.write_stream:
+            return [(self.read_stream, self.write_stream)]
+        return []
+
+    # --------------------------------------------------------------------- #
+    #  Main entry-point                                                     #
+    # --------------------------------------------------------------------- #
+    async def call_tool(
+        self, tool_name: str, arguments: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Execute *tool_name* with *arguments* and normalise the server’s reply.
+
+        The echo-server often returns:
+        {
+            "content": [{"type":"text","text":"{\"message\":\"…\"}"}],
+            "isError": false
+        }
+        We unwrap that so callers just receive either a dict or a plain string.
+        """
+        if not self.read_stream or not self.write_stream:
+            return {"isError": True, "error": "Transport not initialized"}
+
+        try:
+            raw = await send_tools_call(
+                self.read_stream, self.write_stream, tool_name, arguments
+            )
+
+            # Handle explicit error wrapper
+            if "error" in raw:
+                return {
+                    "isError": True,
+                    "error": raw["error"].get("message", "Unknown error"),
+                }
+
+            # Preferred: servers that put the answer under "result"
+            if "result" in raw:
+                return {"isError": False, "content": raw["result"]}
+
+            # Common echo-server shape: top-level "content" list
+            if "content" in raw:
+                clist = raw["content"]
+                if isinstance(clist, list) and clist:
+                    first = clist[0]
+                    if isinstance(first, dict) and first.get("type") == "text":
+                        text = first.get("text", "")
+                        # Try to parse as JSON; fall back to plain string
+                        try:
+                            parsed = json.loads(text)
+                            return {"isError": False, "content": parsed}
+                        except json.JSONDecodeError:
+                            return {"isError": False, "content": text}
+
+            # Fallback: give caller whatever the server sent
+            return {"isError": False, "content": raw}
+
+        except Exception as e:  # pragma: no cover
+            import logging
+
+            logging.error(f"Error calling tool {tool_name}: {e}")
+            return {"isError": True, "error": str(e)}