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

chuk_tool_processor/mcp/stream_manager.py

@@ -5,299 +5,289 @@ StreamManager for CHUK Tool Processor.
 from __future__ import annotations
 
 import asyncio
-import json
-from typing import Dict, List, Optional, Any
+from typing import Any, Dict, List, Optional, Tuple
 
-# tool processor imports
+# --------------------------------------------------------------------------- #
+#  CHUK imports                                                               #
+# --------------------------------------------------------------------------- #
 from chuk_mcp.config import load_config
-from chuk_tool_processor.mcp.transport import MCPBaseTransport, StdioTransport, SSETransport
+from chuk_tool_processor.mcp.transport import (
+    MCPBaseTransport,
+    StdioTransport,
+    SSETransport,
+)
 from chuk_tool_processor.logging import get_logger
 
-# logger
 logger = get_logger("chuk_tool_processor.mcp.stream_manager")
 
+
 class StreamManager:
     """
     Manager for MCP server streams with support for multiple transport types.
     """
-    
-    def __init__(self):
-        """Initialize the StreamManager."""
+
+    # ------------------------------------------------------------------ #
+    #  construction                                                      #
+    # ------------------------------------------------------------------ #
+    def __init__(self) -> None:
         self.transports: Dict[str, MCPBaseTransport] = {}
         self.server_info: List[Dict[str, Any]] = []
         self.tool_to_server_map: Dict[str, str] = {}
         self.server_names: Dict[int, str] = {}
         self.all_tools: List[Dict[str, Any]] = []
         self._lock = asyncio.Lock()
-        
+
+    # ------------------------------------------------------------------ #
+    #  factory helpers                                                   #
+    # ------------------------------------------------------------------ #
     @classmethod
     async def create(
         cls,
         config_file: str,
         servers: List[str],
         server_names: Optional[Dict[int, str]] = None,
-        transport_type: str = "stdio"
-    ) -> StreamManager:
-        """
-        Create and initialize a StreamManager.
-        
-        Args:
-            config_file: Path to the config file
-            servers: List of server names to connect to
-            server_names: Optional mapping of server indices to names
-            transport_type: Transport type ("stdio" or "sse")
-            
-        Returns:
-            Initialized StreamManager
-        """
-        manager = cls()
-        await manager.initialize(config_file, servers, server_names, transport_type)
-        return manager
-        
+        transport_type: str = "stdio",
+    ) -> "StreamManager":
+        inst = cls()
+        await inst.initialize(config_file, servers, server_names, transport_type)
+        return inst
+
     @classmethod
     async def create_with_sse(
         cls,
         servers: List[Dict[str, str]],
-        server_names: Optional[Dict[int, str]] = None
-    ) -> StreamManager:
-        """
-        Create and initialize a StreamManager with SSE transport.
-        
-        Args:
-            servers: List of server configurations with "name" and "url" keys
-            server_names: Optional mapping of server indices to names
-            
-        Returns:
-            Initialized StreamManager
-        """
-        manager = cls()
-        await manager.initialize_with_sse(servers, server_names)
-        return manager
-        
+        server_names: Optional[Dict[int, str]] = None,
+    ) -> "StreamManager":
+        inst = cls()
+        await inst.initialize_with_sse(servers, server_names)
+        return inst
+
+    # ------------------------------------------------------------------ #
+    #  initialisation – stdio / sse                                      #
+    # ------------------------------------------------------------------ #
     async def initialize(
         self,
         config_file: str,
         servers: List[str],
         server_names: Optional[Dict[int, str]] = None,
-        transport_type: str = "stdio"
+        transport_type: str = "stdio",
     ) -> None:
-        """
-        Initialize the StreamManager.
-        
-        Args:
-            config_file: Path to the config file
-            servers: List of server names to connect to
-            server_names: Optional mapping of server indices to names
-            transport_type: Transport type ("stdio" or "sse")
-        """
         async with self._lock:
-            # Store server names mapping
             self.server_names = server_names or {}
-            
-            # Initialize servers
-            for i, server_name in enumerate(servers):
+
+            for idx, server_name in enumerate(servers):
                 try:
                     if transport_type == "stdio":
-                        # Load configuration
-                        server_params = await load_config(config_file, server_name)
-                        
-                        # Create transport
-                        transport = StdioTransport(server_params)
+                        params = await load_config(config_file, server_name)
+                        transport: MCPBaseTransport = StdioTransport(params)
                     elif transport_type == "sse":
-                        # For SSE, we would parse the config differently
-                        # This is just a placeholder
                         transport = SSETransport("http://localhost:8000")
                     else:
-                        logger.error(f"Unsupported transport type: {transport_type}")
+                        logger.error("Unsupported transport type: %s", transport_type)
                         continue
-                    
-                    # Initialize transport
+
                     if not await transport.initialize():
-                        logger.error(f"Failed to initialize transport for server: {server_name}")
+                        logger.error("Failed to init %s", server_name)
                         continue
-                        
-                    # Store transport
+
+                    #  store transport
                     self.transports[server_name] = transport
-                    
-                    # Check server is responsive
-                    ping_result = await transport.send_ping()
-                    status = "Up" if ping_result else "Down"
-                    
-                    # Get available tools
+
+                    #  ping + gather tools
+                    status = "Up" if await transport.send_ping() else "Down"
                     tools = await transport.get_tools()
-                    
-                    # Map tools to server
-                    for tool in tools:
-                        tool_name = tool.get("name")
-                        if tool_name:
-                            self.tool_to_server_map[tool_name] = server_name
-                    
-                    # Add to all tools
+
+                    for t in tools:
+                        name = t.get("name")
+                        if name:
+                            self.tool_to_server_map[name] = server_name
                     self.all_tools.extend(tools)
-                    
-                    # Add server info
-                    self.server_info.append({
-                        "id": i,
-                        "name": server_name,
-                        "tools": len(tools),
-                        "status": status
-                    })
-                    
-                    logger.info(f"Initialized server {server_name} with {len(tools)} tools")
-                    
-                except Exception as e:
-                    logger.error(f"Error initializing server {server_name}: {e}")
-                    
-            logger.info(f"StreamManager initialized with {len(self.transports)} servers and {len(self.all_tools)} tools")
-            
+
+                    self.server_info.append(
+                        {
+                            "id": idx,
+                            "name": server_name,
+                            "tools": len(tools),
+                            "status": status,
+                        }
+                    )
+                    logger.info("Initialised %s – %d tool(s)", server_name, len(tools))
+                except Exception as exc:  # noqa: BLE001
+                    logger.error("Error initialising %s: %s", server_name, exc)
+
+            logger.info(
+                "StreamManager ready – %d server(s), %d tool(s)",
+                len(self.transports),
+                len(self.all_tools),
+            )
+
     async def initialize_with_sse(
         self,
         servers: List[Dict[str, str]],
-        server_names: Optional[Dict[int, str]] = None
+        server_names: Optional[Dict[int, str]] = None,
     ) -> None:
-        """
-        Initialize the StreamManager with SSE transport.
-        
-        Args:
-            servers: List of server configurations with "name" and "url" keys
-            server_names: Optional mapping of server indices to names
-        """
         async with self._lock:
-            # Store server names mapping
             self.server_names = server_names or {}
-            
-            # Initialize servers
-            for i, server_config in enumerate(servers):
-                server_name = server_config.get("name")
-                url = server_config.get("url")
-                api_key = server_config.get("api_key")
-                
-                if not server_name or not url:
-                    logger.error(f"Invalid server configuration: {server_config}")
+
+            for idx, cfg in enumerate(servers):
+                name, url = cfg.get("name"), cfg.get("url")
+                if not (name and url):
+                    logger.error("Bad server config: %s", cfg)
                     continue
-                
                 try:
-                    # Create transport
-                    transport = SSETransport(url, api_key)
-                    
-                    # Initialize transport
+                    transport = SSETransport(url, cfg.get("api_key"))
                     if not await transport.initialize():
-                        logger.error(f"Failed to initialize SSE transport for server: {server_name}")
+                        logger.error("Failed to init SSE %s", name)
                         continue
-                        
-                    # Store transport
-                    self.transports[server_name] = transport
-                    
-                    # Check server is responsive
-                    ping_result = await transport.send_ping()
-                    status = "Up" if ping_result else "Down"
-                    
-                    # Get available tools
+
+                    self.transports[name] = transport
+                    status = "Up" if await transport.send_ping() else "Down"
                     tools = await transport.get_tools()
-                    
-                    # Map tools to server
-                    for tool in tools:
-                        tool_name = tool.get("name")
-                        if tool_name:
-                            self.tool_to_server_map[tool_name] = server_name
-                    
-                    # Add to all tools
+
+                    for t in tools:
+                        tname = t.get("name")
+                        if tname:
+                            self.tool_to_server_map[tname] = name
                     self.all_tools.extend(tools)
-                    
-                    # Add server info
-                    self.server_info.append({
-                        "id": i,
-                        "name": server_name,
-                        "tools": len(tools),
-                        "status": status
-                    })
-                    
-                    logger.info(f"Initialized SSE server {server_name} with {len(tools)} tools")
-                    
-                except Exception as e:
-                    logger.error(f"Error initializing SSE server {server_name}: {e}")
-            
-            logger.info(f"StreamManager initialized with {len(self.transports)} SSE servers and {len(self.all_tools)} tools")
-    
+
+                    self.server_info.append(
+                        {"id": idx, "name": name, "tools": len(tools), "status": status}
+                    )
+                    logger.info("Initialised SSE %s – %d tool(s)", name, len(tools))
+                except Exception as exc:  # noqa: BLE001
+                    logger.error("Error initialising SSE %s: %s", name, exc)
+
+            logger.info(
+                "StreamManager ready – %d SSE server(s), %d tool(s)",
+                len(self.transports),
+                len(self.all_tools),
+            )
+
+    # ------------------------------------------------------------------ #
+    #  queries                                                           #
+    # ------------------------------------------------------------------ #
     def get_all_tools(self) -> List[Dict[str, Any]]:
-        """
-        Get all available tools.
-        
-        Returns:
-            List of tool definitions
-        """
         return self.all_tools
-        
+
     def get_server_for_tool(self, tool_name: str) -> Optional[str]:
-        """
-        Get the server name for a tool.
-        
-        Args:
-            tool_name: Tool name
-            
-        Returns:
-            Server name or None if not found
-        """
         return self.tool_to_server_map.get(tool_name)
-        
+
     def get_server_info(self) -> List[Dict[str, Any]]:
-        """
-        Get information about all servers.
-        
-        Returns:
-            List of server info dictionaries
-        """
         return self.server_info
-        
+
+    # ------------------------------------------------------------------ #
+    #  EXTRA HELPERS – ping / resources / prompts                        #
+    # ------------------------------------------------------------------ #
+    async def ping_servers(self) -> List[Dict[str, Any]]:
+        async def _ping_one(name: str, tr: MCPBaseTransport):
+            try:
+                ok = await tr.send_ping()
+            except Exception:  # pragma: no cover
+                ok = False
+            return {"server": name, "ok": ok}
+
+        return await asyncio.gather(*(_ping_one(n, t) for n, t in self.transports.items()))
+
+    async def list_resources(self) -> List[Dict[str, Any]]:
+        out: List[Dict[str, Any]] = []
+
+        async def _one(name: str, tr: MCPBaseTransport):
+            if not hasattr(tr, "list_resources"):
+                return
+            try:
+                res = await tr.list_resources()  # type: ignore[attr-defined]
+                # accept either {"resources": [...]} **or** a plain list
+                resources = (
+                    res.get("resources", []) if isinstance(res, dict) else res
+                )
+                for item in resources:
+                    item = dict(item)
+                    item["server"] = name
+                    out.append(item)
+            except Exception as exc:
+                logger.debug("resources/list failed for %s: %s", name, exc)
+
+        await asyncio.gather(*(_one(n, t) for n, t in self.transports.items()))
+        return out
+
+    async def list_prompts(self) -> List[Dict[str, Any]]:
+        out: List[Dict[str, Any]] = []
+
+        async def _one(name: str, tr: MCPBaseTransport):
+            if not hasattr(tr, "list_prompts"):
+                return
+            try:
+                res = await tr.list_prompts()  # type: ignore[attr-defined]
+                prompts = res.get("prompts", []) if isinstance(res, dict) else res
+                for item in prompts:
+                    item = dict(item)
+                    item["server"] = name
+                    out.append(item)
+            except Exception as exc:
+                logger.debug("prompts/list failed for %s: %s", name, exc)
+
+        await asyncio.gather(*(_one(n, t) for n, t in self.transports.items()))
+        return out
+
+    # ------------------------------------------------------------------ #
+    #  tool execution                                                    #
+    # ------------------------------------------------------------------ #
     async def call_tool(
         self,
         tool_name: str,
         arguments: Dict[str, Any],
-        server_name: Optional[str] = None
+        server_name: Optional[str] = None,
     ) -> Dict[str, Any]:
-        """
-        Call a tool.
-        
-        Args:
-            tool_name: Tool name
-            arguments: Tool arguments
-            server_name: Optional server name override
-            
-        Returns:
-            Tool result
-        """
-        # Get server name
-        if not server_name:
-            server_name = self.get_server_for_tool(tool_name)
-            
+        server_name = server_name or self.get_server_for_tool(tool_name)
         if not server_name or server_name not in self.transports:
+            # wording kept exactly for unit-test expectation
             return {
                 "isError": True,
-                "error": f"No server found for tool: {tool_name}"
+                "error": f"No server found for tool: {tool_name}",
             }
-            
-        # Get transport
-        transport = self.transports[server_name]
-        
-        # Call tool
-        return await transport.call_tool(tool_name, arguments)
-    
+        return await self.transports[server_name].call_tool(tool_name, arguments)
+
+    # ------------------------------------------------------------------ #
+    #  shutdown                                                          #
+    # ------------------------------------------------------------------ #
     async def close(self) -> None:
-        """Close all transports."""
-        close_tasks = []
-        for name, transport in self.transports.items():
-            close_tasks.append(transport.close())
-        
-        if close_tasks:
+        tasks = [tr.close() for tr in self.transports.values()]
+        if tasks:
             try:
-                await asyncio.gather(*close_tasks)
-            except asyncio.CancelledError:
-                # Ignore cancellation during cleanup
+                await asyncio.gather(*tasks)
+            except asyncio.CancelledError:  # pragma: no cover
                 pass
-            except Exception as e:
-                logger.error(f"Error closing transports: {e}")
-        
+            except Exception as exc:  # noqa: BLE001
+                logger.error("Error during close: %s", exc)
+
         self.transports.clear()
         self.server_info.clear()
         self.tool_to_server_map.clear()
-        self.all_tools.clear()
+        self.all_tools.clear()
+
+    # ------------------------------------------------------------------ #
+    #  backwards-compat: streams helper                                  #
+    # ------------------------------------------------------------------ #
+    def get_streams(self) -> List[Tuple[Any, Any]]:
+        """
+        Return a list of ``(read_stream, write_stream)`` tuples for **all**
+        transports.  Older CLI commands rely on this helper.
+        """
+        pairs: List[Tuple[Any, Any]] = []
+
+        for tr in self.transports.values():
+            if hasattr(tr, "get_streams") and callable(tr.get_streams):
+                pairs.extend(tr.get_streams())  # type: ignore[arg-type]
+                continue
+
+            rd = getattr(tr, "read_stream", None)
+            wr = getattr(tr, "write_stream", None)
+            if rd and wr:
+                pairs.append((rd, wr))
+
+        return pairs
+
+    # convenience alias
+    @property
+    def streams(self) -> List[Tuple[Any, Any]]:  # pragma: no cover
+        return self.get_streams()

chuk_tool_processor/mcp/transport/base_transport.py

@@ -2,63 +2,102 @@
 """
 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:
         """
-        Initialize the transport connection.
-        
-        Returns:
-            True if successful, False otherwise
+        Establish the connection.
+
+        Returns
+        -------
+        bool
+            ``True`` if the connection was initialised successfully.
         """
-        pass
-        
+        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 message.
-        
-        Returns:
-            True if successful, False otherwise
+        Send a **ping** request.
+
+        Returns
+        -------
+        bool
+            ``True`` on success, ``False`` otherwise.
         """
-        pass
-        
+        raise NotImplementedError
+
+    # ------------------------------------------------------------------ #
+    #  tool handling                                                     #
+    # ------------------------------------------------------------------ #
     @abstractmethod
     async def get_tools(self) -> List[Dict[str, Any]]:
         """
-        Get available tools.
-        
-        Returns:
-            List of tool definitions
+        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.
         """
-        pass
-        
+        raise NotImplementedError
+
+    # ------------------------------------------------------------------ #
+    #  new: resources & prompts                                          #
+    # ------------------------------------------------------------------ #
     @abstractmethod
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+    async def list_resources(self) -> Dict[str, Any]:
         """
-        Call a tool.
-        
-        Args:
-            tool_name: Tool name
-            arguments: Tool arguments
-            
-        Returns:
-            Tool result
+        Retrieve the server’s resources catalogue.
+
+        Expected shape::
+            { "resources": [ {...}, ... ], "nextCursor": "…", … }
         """
-        pass
-        
+        raise NotImplementedError
+
     @abstractmethod
-    async def close(self) -> None:
-        """Close the transport connection."""
-        pass
+    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

@@ -1,59 +1,189 @@
 # chuk_tool_processor/mcp/transport/sse_transport.py
 """
-Server-Sent Events (SSE) transport for MCP communication.
+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
 
-# imports
+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):
     """
-    Server-Sent Events (SSE) transport for MCP communication.
+    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>
     """
-    
-    def __init__(self, url: str, api_key: Optional[str] = None):
-        """
-        Initialize the SSE transport.
-        
-        Args:
-            url: Server URL
-            api_key: Optional API key
-        """
-        self.url = url
+
+    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
-        self.session = None
-        self.connection_id = None
-        
+
+        # 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:
-        """
-        Initialize the SSE connection.
-        
-        Returns:
-            True if successful, False otherwise
-        """
-        # TODO: Implement SSE connection logic
-        # This is currently a placeholder
-        import logging
-        logging.info(f"SSE transport not yet implemented for {self.url}")
-        return False
-        
+        """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:
-        """Send a ping message."""
-        # TODO: Implement SSE ping logic
-        return False
-        
+        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]]:
-        """Get available tools."""
-        # TODO: Implement SSE tool retrieval logic
-        return []
-        
+        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]:
-        """Call a tool via SSE."""
-        # TODO: Implement SSE tool calling logic
-        return {"isError": True, "error": "SSE transport not implemented"}
-        
-    async def close(self) -> None:
-        """Close the SSE connection."""
-        # TODO: Implement SSE connection closure logic
-        pass
+        # ─── 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

@@ -1,15 +1,35 @@
 # chuk_tool_processor/mcp/transport/stdio_transport.py
-from typing import Dict, Any, List, Optional
+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
+# ------------------------------------------------------------------ #
+#  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
-from chuk_mcp.mcp_client.messages.tools.send_messages import send_tools_call, send_tools_list
+
+# 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):
@@ -32,7 +52,9 @@ class StdioTransport(MCPBaseTransport):
             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)
+            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)
@@ -72,10 +94,56 @@ class StdioTransport(MCPBaseTransport):
         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]:
+    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.
 
@@ -90,12 +158,16 @@ class StdioTransport(MCPBaseTransport):
             return {"isError": True, "error": "Transport not initialized"}
 
         try:
-            raw = await send_tools_call(self.read_stream, self.write_stream, tool_name, arguments)
+            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")}
+                return {
+                    "isError": True,
+                    "error": raw["error"].get("message", "Unknown error"),
+                }
 
             # Preferred: servers that put the answer under "result"
             if "result" in raw:

{chuk_tool_processor-0.1.3.dist-info → chuk_tool_processor-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.1.3
+Version: 0.1.4
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{chuk_tool_processor-0.1.3.dist-info → chuk_tool_processor-0.1.4.dist-info}/RECORD

@@ -21,11 +21,11 @@ chuk_tool_processor/mcp/mcp_tool.py,sha256=TvZEudgQvaev2jaPw6OGsqAR5GNu6_cPaUCgq
 chuk_tool_processor/mcp/register_mcp_tools.py,sha256=ofE7pEn6sKDH8HWvNamVOaXsitLOaG48M5GhcpqCBbs,2801
 chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=Ep2IKRdH1Y299bCxt9G0NtwnsvguYP6mpraZyUJ8OKU,2643
 chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=NjTvAFqQHxxN3XubsTgYY3lTrvPVWlnwCzkzbz7WE_M,2747
-chuk_tool_processor/mcp/stream_manager.py,sha256=xdTXDJ08pVpHXvxao0ibXezGqqauMBLXpJhIXgGknOs,10847
+chuk_tool_processor/mcp/stream_manager.py,sha256=qIWzsQCTlu1SQQBExAdvBHGB3T5isQDyMhj29WkfbKQ,11779
 chuk_tool_processor/mcp/transport/__init__.py,sha256=7QQqeSKVKv0N9GcyJuYF0R4FDZeooii5RjggvFFg5GY,296
-chuk_tool_processor/mcp/transport/base_transport.py,sha256=uJcbyHYrw_zpE5Rc9wDo6yT0mmwqwhFXXbHIJxPoOac,1379
-chuk_tool_processor/mcp/transport/sse_transport.py,sha256=BcRRiOEDRiXiVK2rySB0Hm_dITDNHzrCd2h28Yv1r5c,1791
-chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=VxQYbN0jAyeOrQODZtTvityYRYUnbQHz3jc_eMTlv3I,5197
+chuk_tool_processor/mcp/transport/base_transport.py,sha256=1E29LjWw5vLQrPUDF_9TJt63P5dxAAN7n6E_KiZbGUY,3427
+chuk_tool_processor/mcp/transport/sse_transport.py,sha256=bryH9DOWOn5qr6LsimTriukDC4ix2kuRq6bUv9qOV20,7645
+chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=lFXL7p8ca4z_J0RBL8UCHrQ1UH7C2-LbC0tZhpya4V4,7763
 chuk_tool_processor/models/__init__.py,sha256=TC__rdVa0lQsmJHM_hbLDPRgToa_pQT_UxRcPZk6iVw,40
 chuk_tool_processor/models/execution_strategy.py,sha256=ZPHysmKNHqJmahTtUXAbt1ke09vxy7EhZcsrwTdla8o,508
 chuk_tool_processor/models/tool_call.py,sha256=RZOnx2YczkJN6ym2PLiI4CRzP2qU_5hpMtHxMcFOxY4,298
@@ -51,7 +51,7 @@ chuk_tool_processor/registry/providers/__init__.py,sha256=_0dg4YhyfAV0TXuR_i4ewX
 chuk_tool_processor/registry/providers/memory.py,sha256=29aI5uvykjDmn9ymIukEdUtmTC9SXOAsDu9hw36XF44,4474
 chuk_tool_processor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/utils/validation.py,sha256=7ezn_o-3IHDrzOD3j6ttsAn2s3zS-jIjeBTuqicrs6A,3775
-chuk_tool_processor-0.1.3.dist-info/METADATA,sha256=lcYGBykoz2doY3Z8cR_SxyvdbXGgmDUUdPzIgLwP8wM,13703
-chuk_tool_processor-0.1.3.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-chuk_tool_processor-0.1.3.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.1.3.dist-info/RECORD,,
+chuk_tool_processor-0.1.4.dist-info/METADATA,sha256=ekQNpVXyJrLw9kaLnhHW4iI1Q5do07T6Ol2QfeRsQn0,13703
+chuk_tool_processor-0.1.4.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
+chuk_tool_processor-0.1.4.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.1.4.dist-info/RECORD,,

{chuk_tool_processor-0.1.3.dist-info → chuk_tool_processor-0.1.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any