chuk-tool-processor 0.6.12__py3-none-any.whl → 0.6.13__py3-none-any.whl

chuk_tool_processor/mcp/transport/__init__.py

@@ -10,13 +10,13 @@ All transports now follow the same interface and provide consistent behavior:
 """
 
 from .base_transport import MCPBaseTransport
-from .stdio_transport import StdioTransport
-from .sse_transport import SSETransport
 from .http_streamable_transport import HTTPStreamableTransport
+from .sse_transport import SSETransport
+from .stdio_transport import StdioTransport
 
 __all__ = [
     "MCPBaseTransport",
     "StdioTransport",
-    "SSETransport", 
+    "SSETransport",
     "HTTPStreamableTransport",
-]
+]

chuk_tool_processor/mcp/transport/base_transport.py

@@ -2,16 +2,17 @@
 """
 Abstract base class for MCP transports with complete interface definition.
 """
+
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 
 class MCPBaseTransport(ABC):
     """
     Abstract base class for all MCP transport implementations.
-    
+
     Defines the complete interface that all transports must implement
     for consistency across stdio, SSE, and HTTP streamable transports.
     """
@@ -23,7 +24,7 @@ class MCPBaseTransport(ABC):
     async def initialize(self) -> bool:
         """
         Initialize the transport connection.
-        
+
         Returns:
             True if initialization was successful, False otherwise.
         """
@@ -41,7 +42,7 @@ class MCPBaseTransport(ABC):
     async def send_ping(self) -> bool:
         """
         Send a ping to verify the connection is alive.
-        
+
         Returns:
             True if ping was successful, False otherwise.
         """
@@ -51,7 +52,7 @@ class MCPBaseTransport(ABC):
     def is_connected(self) -> bool:
         """
         Check if the transport is connected and ready for operations.
-        
+
         Returns:
             True if connected, False otherwise.
         """
@@ -61,46 +62,47 @@ class MCPBaseTransport(ABC):
     #  Core MCP operations                                               #
     # ------------------------------------------------------------------ #
     @abstractmethod
-    async def get_tools(self) -> List[Dict[str, Any]]:
+    async def get_tools(self) -> list[dict[str, Any]]:
         """
         Get the list of available tools from the server.
-        
+
         Returns:
             List of tool definitions.
         """
         pass
 
     @abstractmethod
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any], 
-                       timeout: Optional[float] = None) -> Dict[str, Any]:
+    async def call_tool(
+        self, tool_name: str, arguments: dict[str, Any], timeout: float | None = None
+    ) -> dict[str, Any]:
         """
         Call a tool with the given arguments.
-        
+
         Args:
             tool_name: Name of the tool to call
             arguments: Arguments to pass to the tool
             timeout: Optional timeout for the operation
-            
+
         Returns:
             Dictionary with 'isError' boolean and either 'content' or 'error'
         """
         pass
 
     @abstractmethod
-    async def list_resources(self) -> Dict[str, Any]:
+    async def list_resources(self) -> dict[str, Any]:
         """
         List available resources from the server.
-        
+
         Returns:
             Dictionary containing resources list or empty dict if not supported.
         """
         pass
 
     @abstractmethod
-    async def list_prompts(self) -> Dict[str, Any]:
+    async def list_prompts(self) -> dict[str, Any]:
         """
         List available prompts from the server.
-        
+
         Returns:
             Dictionary containing prompts list or empty dict if not supported.
         """
@@ -110,10 +112,10 @@ class MCPBaseTransport(ABC):
     #  Metrics and monitoring (all transports should support these)     #
     # ------------------------------------------------------------------ #
     @abstractmethod
-    def get_metrics(self) -> Dict[str, Any]:
+    def get_metrics(self) -> dict[str, Any]:
         """
         Get performance and connection metrics.
-        
+
         Returns:
             Dictionary containing metrics data.
         """
@@ -127,10 +129,10 @@ class MCPBaseTransport(ABC):
     # ------------------------------------------------------------------ #
     #  Backward compatibility and utility methods                       #
     # ------------------------------------------------------------------ #
-    def get_streams(self) -> List[tuple]:
+    def get_streams(self) -> list[tuple]:
         """
         Get underlying stream objects for backward compatibility.
-        
+
         Returns:
             List of (read_stream, write_stream) tuples, empty if not applicable.
         """
@@ -153,64 +155,46 @@ class MCPBaseTransport(ABC):
     # ------------------------------------------------------------------ #
     #  Shared helper methods for response normalization                  #
     # ------------------------------------------------------------------ #
-    def _normalize_mcp_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
+    def _normalize_mcp_response(self, response: dict[str, Any]) -> dict[str, Any]:
         """
         Normalize MCP response to consistent format.
-        
+
         This provides shared logic for all transports to ensure consistent
         response format regardless of transport type.
         """
         # Handle explicit error in response
         if "error" in response:
             error_info = response["error"]
-            if isinstance(error_info, dict):
-                error_msg = error_info.get("message", "Unknown error")
-            else:
-                error_msg = str(error_info)
-            
-            return {
-                "isError": True,
-                "error": error_msg
-            }
+            error_msg = error_info.get("message", "Unknown error") if isinstance(error_info, dict) else str(error_info)
+
+            return {"isError": True, "error": error_msg}
 
         # Handle successful response with result
         if "result" in response:
             result = response["result"]
-            
+
             if isinstance(result, dict) and "content" in result:
-                return {
-                    "isError": False,
-                    "content": self._extract_mcp_content(result["content"])
-                }
+                return {"isError": False, "content": self._extract_mcp_content(result["content"])}
             else:
-                return {
-                    "isError": False,
-                    "content": result
-                }
+                return {"isError": False, "content": result}
 
         # Handle direct content-based response
         if "content" in response:
-            return {
-                "isError": False,
-                "content": self._extract_mcp_content(response["content"])
-            }
+            return {"isError": False, "content": self._extract_mcp_content(response["content"])}
 
         # Fallback
-        return {
-            "isError": False,
-            "content": response
-        }
+        return {"isError": False, "content": response}
 
     def _extract_mcp_content(self, content_list: Any) -> Any:
         """
         Extract content from MCP content format.
-        
+
         Handles the standard MCP content format where content is a list
         of content items with type and data.
         """
         if not isinstance(content_list, list) or not content_list:
             return content_list
-        
+
         # Handle single content item
         if len(content_list) == 1:
             content_item = content_list[0]
@@ -220,12 +204,13 @@ class MCPBaseTransport(ABC):
                     # Try to parse JSON, fall back to plain text
                     try:
                         import json
+
                         return json.loads(text_content)
                     except json.JSONDecodeError:
                         return text_content
                 else:
                     return content_item
-        
+
         # Multiple content items - return as-is
         return content_list
 
@@ -234,21 +219,21 @@ class MCPBaseTransport(ABC):
     # ------------------------------------------------------------------ #
     def __repr__(self) -> str:
         """Standard string representation for all transports."""
-        status = "initialized" if getattr(self, '_initialized', False) else "not initialized"
-        
+        status = "initialized" if getattr(self, "_initialized", False) else "not initialized"
+
         # Add metrics info if available
         metrics_info = ""
-        if hasattr(self, 'enable_metrics') and getattr(self, 'enable_metrics', False):
+        if hasattr(self, "enable_metrics") and getattr(self, "enable_metrics", False):
             metrics = self.get_metrics()
             if metrics.get("total_calls", 0) > 0:
                 success_rate = (metrics.get("successful_calls", 0) / metrics["total_calls"]) * 100
                 metrics_info = f", calls: {metrics['total_calls']}, success: {success_rate:.1f}%"
-        
+
         # Add transport-specific info - FIXED FORMAT
         transport_info = ""
-        if hasattr(self, 'url'):
+        if hasattr(self, "url"):
             transport_info = f", url={self.url}"  # Fixed: was "url: "
-        elif hasattr(self, 'server_params') and hasattr(self.server_params, 'command'):
+        elif hasattr(self, "server_params") and hasattr(self.server_params, "command"):
             transport_info = f", command={self.server_params.command}"  # Fixed: was "command: "
-        
-        return f"{self.__class__.__name__}(status={status}{transport_info}{metrics_info})"
+
+        return f"{self.__class__.__name__}(status={status}{transport_info}{metrics_info})"