chuk-tool-processor 0.6.7__py3-none-any.whl → 0.6.9__py3-none-any.whl

chuk_tool_processor/mcp/transport/http_streamable_transport.py

@@ -1,4 +1,4 @@
-# chuk_tool_processor/mcp/transport/http_streamable_transport.py
+# chuk_tool_processor/mcp/transport/http_streamable_transport.py - FIXED
 from __future__ import annotations
 
 import asyncio
@@ -10,30 +10,18 @@ import logging
 from .base_transport import MCPBaseTransport
 
 # Import chuk-mcp HTTP transport components
-try:
-    from chuk_mcp.transports.http import http_client
-    from chuk_mcp.transports.http.parameters import StreamableHTTPParameters
-    from chuk_mcp.protocol.messages import (
-        send_initialize,
-        send_ping, 
-        send_tools_list,
-        send_tools_call,
-    )
-    HAS_HTTP_SUPPORT = True
-except ImportError:
-    HAS_HTTP_SUPPORT = False
-
-# Import optional resource and prompt support
-try:
-    from chuk_mcp.protocol.messages import (
-        send_resources_list,
-        send_resources_read,
-        send_prompts_list,
-        send_prompts_get,
-    )
-    HAS_RESOURCES_PROMPTS = True
-except ImportError:
-    HAS_RESOURCES_PROMPTS = False
+from chuk_mcp.transports.http import http_client
+from chuk_mcp.transports.http.parameters import StreamableHTTPParameters
+from chuk_mcp.protocol.messages import (
+    send_initialize,
+    send_ping, 
+    send_tools_list,
+    send_tools_call,
+    send_resources_list,
+    send_resources_read,
+    send_prompts_list,
+    send_prompts_get,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -42,13 +30,15 @@ class HTTPStreamableTransport(MCPBaseTransport):
     """
     HTTP Streamable transport using chuk-mcp HTTP client.
     
-    This implements the modern MCP spec (2025-03-26) replacement for SSE transport.
-    Follows the same patterns as SSETransport but uses HTTP requests instead of SSE.
+    FIXED: Improved connection management and parameter configuration
+    to eliminate "server disconnected" errors.
     """
 
     def __init__(self, url: str, api_key: Optional[str] = None, 
-                 connection_timeout: float = 30.0, default_timeout: float = 30.0,
-                 session_id: Optional[str] = None, enable_metrics: bool = True):
+                 connection_timeout: float = 30.0, 
+                 default_timeout: float = 30.0,
+                 session_id: Optional[str] = None, 
+                 enable_metrics: bool = True):
         """
         Initialize HTTP Streamable transport with chuk-mcp.
         
@@ -72,13 +62,19 @@ class HTTPStreamableTransport(MCPBaseTransport):
         self.session_id = session_id
         self.enable_metrics = enable_metrics
         
-        # State tracking (following SSE pattern)
+        logger.debug("HTTP Streamable transport initialized with URL: %s", self.url)
+        if self.api_key:
+            logger.debug("API key configured for authentication")
+        if self.session_id:
+            logger.debug("Session ID configured: %s", self.session_id)
+        
+        # State tracking
         self._http_context = None
         self._read_stream = None
         self._write_stream = None
         self._initialized = False
         
-        # Performance metrics (enhanced from SSE version)
+        # Performance metrics (consistent with other transports)
         self._metrics = {
             "total_calls": 0,
             "successful_calls": 0,
@@ -86,20 +82,13 @@ class HTTPStreamableTransport(MCPBaseTransport):
             "total_time": 0.0,
             "avg_response_time": 0.0,
             "last_ping_time": None,
-            "initialization_time": None
+            "initialization_time": None,
+            "connection_resets": 0,
+            "stream_errors": 0
         }
-        
-        if not HAS_HTTP_SUPPORT:
-            logger.warning("HTTP Streamable transport not available - operations will fail")
-        if not HAS_RESOURCES_PROMPTS:
-            logger.debug("Resources/prompts not available in chuk-mcp")
 
     async def initialize(self) -> bool:
-        """Initialize using chuk-mcp http_client (following SSE pattern)."""
-        if not HAS_HTTP_SUPPORT:
-            logger.error("HTTP Streamable transport not available in chuk-mcp")
-            return False
-            
+        """Initialize using chuk-mcp http_client with improved configuration."""
         if self._initialized:
             logger.warning("Transport already initialized")
             return True
@@ -109,8 +98,14 @@ class HTTPStreamableTransport(MCPBaseTransport):
         try:
             logger.debug("Initializing HTTP Streamable transport to %s", self.url)
             
-            # Create HTTP parameters for chuk-mcp (following SSE pattern)
-            headers = {}
+            # FIXED: Proper HTTP headers (match working diagnostic)
+            headers = {
+                "Content-Type": "application/json",
+                "Accept": "application/json, text/event-stream",
+            }
+            
+            # FIXED: Only set Authorization header, not both bearer_token and headers
+            bearer_token = None
             if self.api_key:
                 headers["Authorization"] = f"Bearer {self.api_key}"
                 logger.debug("API key configured for authentication")
@@ -119,17 +114,21 @@ class HTTPStreamableTransport(MCPBaseTransport):
                 headers["X-Session-ID"] = self.session_id
                 logger.debug("Using session ID: %s", self.session_id)
             
+            # FIXED: Use only valid StreamableHTTPParameters
             http_params = StreamableHTTPParameters(
                 url=self.url,
-                timeout=self.connection_timeout,
+                timeout=self.default_timeout,          # FIXED: Use default_timeout for operations
                 headers=headers,
-                bearer_token=self.api_key,
+                bearer_token=bearer_token,             # FIXED: Don't duplicate auth
                 session_id=self.session_id,
-                enable_streaming=True,  # Enable SSE streaming when available
-                max_concurrent_requests=10
+                enable_streaming=True,
+                max_concurrent_requests=5,             # FIXED: Reduce concurrency for stability
+                max_retries=2,                         # FIXED: Add retry configuration
+                retry_delay=1.0,                       # FIXED: Short retry delay
+                user_agent="chuk-tool-processor/1.0.0",
             )
             
-            # Create and enter the HTTP context (same pattern as SSE)
+            # Create and enter the HTTP context
             self._http_context = http_client(http_params)
             
             logger.debug("Establishing HTTP connection and MCP handshake...")
@@ -138,8 +137,20 @@ class HTTPStreamableTransport(MCPBaseTransport):
                 timeout=self.connection_timeout
             )
             
-            # At this point, chuk-mcp should have established the HTTP connection
-            # Verify the connection works with a simple ping (same as SSE)
+            # FIXED: Simplified MCP initialize sequence (match working diagnostic)
+            logger.debug("Sending MCP initialize request...")
+            init_start = time.time()
+            
+            # Send initialize request with default parameters
+            init_result = await asyncio.wait_for(
+                send_initialize(self._read_stream, self._write_stream),
+                timeout=self.default_timeout
+            )
+            
+            init_time = time.time() - init_start
+            logger.debug("MCP initialize completed in %.3fs", init_time)
+            
+            # Verify the connection works with a simple ping
             logger.debug("Verifying connection with ping...")
             ping_start = time.time()
             ping_success = await asyncio.wait_for(
@@ -150,17 +161,19 @@ class HTTPStreamableTransport(MCPBaseTransport):
             
             if ping_success:
                 self._initialized = True
-                init_time = time.time() - start_time
-                self._metrics["initialization_time"] = init_time
-                self._metrics["last_ping_time"] = ping_time
+                total_init_time = time.time() - start_time
+                if self.enable_metrics:
+                    self._metrics["initialization_time"] = total_init_time
+                    self._metrics["last_ping_time"] = ping_time
                 
-                logger.debug("HTTP Streamable transport initialized successfully in %.3fs (ping: %.3fs)", init_time, ping_time)
+                logger.debug("HTTP Streamable transport initialized successfully in %.3fs (ping: %.3fs)", total_init_time, ping_time)
                 return True
             else:
                 logger.warning("HTTP connection established but ping failed")
-                # Still consider it initialized since connection was established (same as SSE)
+                # Still consider it initialized since connection was established
                 self._initialized = True
-                self._metrics["initialization_time"] = time.time() - start_time
+                if self.enable_metrics:
+                    self._metrics["initialization_time"] = time.time() - start_time
                 return True
 
         except asyncio.TimeoutError:
@@ -174,11 +187,11 @@ class HTTPStreamableTransport(MCPBaseTransport):
             return False
 
     async def close(self) -> None:
-        """Close the HTTP Streamable transport properly (same pattern as SSE)."""
+        """Close the HTTP Streamable transport properly."""
         if not self._initialized:
             return
         
-        # Log final metrics (enhanced from SSE)
+        # Log final metrics
         if self.enable_metrics and self._metrics["total_calls"] > 0:
             logger.debug(
                 "HTTP Streamable transport closing - Total calls: %d, Success rate: %.1f%%, Avg response time: %.3fs",
@@ -198,14 +211,14 @@ class HTTPStreamableTransport(MCPBaseTransport):
             await self._cleanup()
 
     async def _cleanup(self) -> None:
-        """Clean up internal state (same as SSE)."""
+        """Clean up internal state."""
         self._http_context = None
         self._read_stream = None
         self._write_stream = None
         self._initialized = False
 
     async def send_ping(self) -> bool:
-        """Send ping with performance tracking (enhanced from SSE)."""
+        """Send ping with performance tracking."""
         if not self._initialized or not self._read_stream:
             logger.error("Cannot send ping: transport not initialized")
             return False
@@ -220,18 +233,24 @@ class HTTPStreamableTransport(MCPBaseTransport):
             if self.enable_metrics:
                 ping_time = time.time() - start_time
                 self._metrics["last_ping_time"] = ping_time
-                logger.debug("Ping completed in %.3fs: %s", ping_time, result)
+                logger.debug("HTTP Streamable ping completed in %.3fs: %s", ping_time, result)
             
             return bool(result)
         except asyncio.TimeoutError:
-            logger.error("Ping timed out")
+            logger.error("HTTP Streamable ping timed out")
             return False
         except Exception as e:
-            logger.error("Ping failed: %s", e)
+            logger.error("HTTP Streamable ping failed: %s", e)
+            if self.enable_metrics:
+                self._metrics["stream_errors"] += 1
             return False
 
+    def is_connected(self) -> bool:
+        """Check connection status."""
+        return self._initialized and self._read_stream is not None and self._write_stream is not None
+
     async def get_tools(self) -> List[Dict[str, Any]]:
-        """Get tools list with performance tracking (enhanced from SSE)."""
+        """Get tools list with performance tracking."""
         if not self._initialized:
             logger.error("Cannot get tools: transport not initialized")
             return []
@@ -243,7 +262,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
                 timeout=self.default_timeout
             )
             
-            # Normalize response (same as SSE)
+            # Normalize response
             if isinstance(tools_response, dict):
                 tools = tools_response.get("tools", [])
             elif isinstance(tools_response, list):
@@ -263,6 +282,8 @@ class HTTPStreamableTransport(MCPBaseTransport):
             return []
         except Exception as e:
             logger.error("Error getting tools: %s", e)
+            if self.enable_metrics:
+                self._metrics["stream_errors"] += 1
             return []
 
     async def call_tool(self, tool_name: str, arguments: Dict[str, Any], 
@@ -283,6 +304,15 @@ class HTTPStreamableTransport(MCPBaseTransport):
         try:
             logger.debug("Calling tool '%s' with timeout %ss", tool_name, tool_timeout)
             
+            # FIXED: Add connection state check before making call
+            if not self.is_connected():
+                logger.warning("Connection lost, attempting to reconnect...")
+                if not await self.initialize():
+                    return {
+                        "isError": True,
+                        "error": "Failed to reconnect to server"
+                    }
+            
             raw_response = await asyncio.wait_for(
                 send_tools_call(
                     self._read_stream, 
@@ -294,7 +324,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
             )
             
             response_time = time.time() - start_time
-            result = self._normalize_tool_response(raw_response)
+            result = self._normalize_mcp_response(raw_response)
             
             if self.enable_metrics:
                 self._update_metrics(response_time, not result.get("isError", False))
@@ -321,6 +351,12 @@ class HTTPStreamableTransport(MCPBaseTransport):
             response_time = time.time() - start_time
             if self.enable_metrics:
                 self._update_metrics(response_time, False)
+                self._metrics["stream_errors"] += 1
+                
+            # FIXED: Check if this is a connection error that should trigger reconnect
+            if "connection" in str(e).lower() or "disconnected" in str(e).lower():
+                logger.warning("Connection error detected, marking as disconnected: %s", e)
+                self._initialized = False
                 
             error_msg = f"Tool execution failed: {str(e)}"
             logger.error("Tool '%s' error: %s", tool_name, error_msg)
@@ -330,23 +366,20 @@ class HTTPStreamableTransport(MCPBaseTransport):
             }
 
     def _update_metrics(self, response_time: float, success: bool) -> None:
-        """Update performance metrics (new feature)."""
+        """Update performance metrics."""
         if success:
             self._metrics["successful_calls"] += 1
         else:
             self._metrics["failed_calls"] += 1
             
         self._metrics["total_time"] += response_time
-        self._metrics["avg_response_time"] = (
-            self._metrics["total_time"] / self._metrics["total_calls"]
-        )
+        if self._metrics["total_calls"] > 0:
+            self._metrics["avg_response_time"] = (
+                self._metrics["total_time"] / self._metrics["total_calls"]
+            )
 
     async def list_resources(self) -> Dict[str, Any]:
-        """List resources using chuk-mcp (same as SSE)."""
-        if not HAS_RESOURCES_PROMPTS:
-            logger.debug("Resources/prompts not available in chuk-mcp")
-            return {}
-            
+        """List resources using chuk-mcp."""
         if not self._initialized:
             return {}
         
@@ -364,11 +397,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
             return {}
 
     async def list_prompts(self) -> Dict[str, Any]:
-        """List prompts using chuk-mcp (same as SSE)."""
-        if not HAS_RESOURCES_PROMPTS:
-            logger.debug("Resources/prompts not available in chuk-mcp")
-            return {}
-            
+        """List prompts using chuk-mcp."""
         if not self._initialized:
             return {}
         
@@ -385,87 +414,15 @@ class HTTPStreamableTransport(MCPBaseTransport):
             logger.debug("Error listing prompts: %s", e)
             return {}
 
-    def _normalize_tool_response(self, raw_response: Dict[str, Any]) -> Dict[str, Any]:
-        """Normalize response for backward compatibility (same as SSE)."""
-        # Handle explicit error in response
-        if "error" in raw_response:
-            error_info = raw_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
-            }
-
-        # Handle successful response with result
-        if "result" in raw_response:
-            result = raw_response["result"]
-            
-            if isinstance(result, dict) and "content" in result:
-                return {
-                    "isError": False,
-                    "content": self._extract_content(result["content"])
-                }
-            else:
-                return {
-                    "isError": False,
-                    "content": result
-                }
-
-        # Handle direct content-based response
-        if "content" in raw_response:
-            return {
-                "isError": False,
-                "content": self._extract_content(raw_response["content"])
-            }
-
-        # Fallback
-        return {
-            "isError": False,
-            "content": raw_response
-        }
-
-    def _extract_content(self, content_list: Any) -> Any:
-        """Extract content from MCP content format (same as SSE)."""
-        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]
-            if isinstance(content_item, dict):
-                if content_item.get("type") == "text":
-                    text_content = content_item.get("text", "")
-                    # Try to parse JSON, fall back to plain text
-                    try:
-                        return json.loads(text_content)
-                    except json.JSONDecodeError:
-                        return text_content
-                else:
-                    return content_item
-        
-        # Multiple content items
-        return content_list
-
-    def get_streams(self) -> List[tuple]:
-        """Provide streams for backward compatibility (same as SSE)."""
-        if self._initialized and self._read_stream and self._write_stream:
-            return [(self._read_stream, self._write_stream)]
-        return []
-
-    def is_connected(self) -> bool:
-        """Check connection status (same as SSE)."""
-        return self._initialized and self._read_stream is not None and self._write_stream is not None
-
+    # ------------------------------------------------------------------ #
+    #  Metrics and monitoring (consistent with other transports)        #
+    # ------------------------------------------------------------------ #
     def get_metrics(self) -> Dict[str, Any]:
-        """Get performance metrics (new feature)."""
+        """Get performance metrics."""
         return self._metrics.copy()
 
     def reset_metrics(self) -> None:
-        """Reset performance metrics (new feature)."""
+        """Reset performance metrics."""
         self._metrics = {
             "total_calls": 0,
             "successful_calls": 0,
@@ -473,26 +430,30 @@ class HTTPStreamableTransport(MCPBaseTransport):
             "total_time": 0.0,
             "avg_response_time": 0.0,
             "last_ping_time": self._metrics.get("last_ping_time"),
-            "initialization_time": self._metrics.get("initialization_time")
+            "initialization_time": self._metrics.get("initialization_time"),
+            "connection_resets": self._metrics.get("connection_resets", 0),
+            "stream_errors": 0
         }
 
+    # ------------------------------------------------------------------ #
+    #  Backward compatibility                                            #
+    # ------------------------------------------------------------------ #
+    def get_streams(self) -> List[tuple]:
+        """Provide streams for backward compatibility."""
+        if self._initialized and self._read_stream and self._write_stream:
+            return [(self._read_stream, self._write_stream)]
+        return []
+
+    # ------------------------------------------------------------------ #
+    #  Context manager support                                           #
+    # ------------------------------------------------------------------ #
     async def __aenter__(self):
-        """Context manager support (same as SSE)."""
+        """Context manager support."""
         success = await self.initialize()
         if not success:
-            raise RuntimeError("Failed to initialize HTTP Streamable transport")
+            raise RuntimeError("Failed to initialize HTTPStreamableTransport")
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Context manager cleanup (same as SSE)."""
-        await self.close()
-
-    def __repr__(self) -> str:
-        """Enhanced string representation for debugging."""
-        status = "initialized" if self._initialized else "not initialized"
-        metrics_info = ""
-        if self.enable_metrics and self._metrics["total_calls"] > 0:
-            success_rate = (self._metrics["successful_calls"] / self._metrics["total_calls"]) * 100
-            metrics_info = f", calls: {self._metrics['total_calls']}, success: {success_rate:.1f}%"
-        
-        return f"HTTPStreamableTransport(status={status}, url={self.url}{metrics_info})"
+        """Context manager cleanup."""
+        await self.close()