chuk-tool-processor 0.6.4__py3-none-any.whl → 0.9.7__py3-none-any.whl

chuk_tool_processor/mcp/transport/http_streamable_transport.py

@@ -1,39 +1,30 @@
-# chuk_tool_processor/mcp/transport/http_streamable_transport.py
+# chuk_tool_processor/mcp/transport/http_streamable_transport.py - ENHANCED
 from __future__ import annotations
 
 import asyncio
-import json
-import time
-from typing import Dict, Any, List, Optional
 import logging
-
-from .base_transport import MCPBaseTransport
+import time
+from typing import Any
+
+from chuk_mcp.protocol.messages import (  # type: ignore[import-untyped]
+    send_initialize,
+    send_ping,
+    send_prompts_get,
+    send_prompts_list,
+    send_resources_list,
+    send_resources_read,
+    send_tools_call,
+    send_tools_list,
+)
+from chuk_mcp.transports.http.parameters import StreamableHTTPParameters  # type: ignore[import-untyped]
 
 # 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.transport import (
+    StreamableHTTPTransport as ChukHTTPTransport,  # type: ignore[import-untyped]
+)
+
+from .base_transport import MCPBaseTransport
+from .models import TimeoutConfig, TransportMetrics
 
 logger = logging.getLogger(__name__)
 
@@ -41,457 +32,646 @@ logger = logging.getLogger(__name__)
 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.
+
+    ENHANCED: Now matches SSE transport robustness with improved connection
+    management, health monitoring, and comprehensive error handling.
     """
 
-    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):
+    def __init__(
+        self,
+        url: str,
+        api_key: str | None = None,
+        headers: dict[str, str] | None = None,
+        connection_timeout: float = 30.0,
+        default_timeout: float = 30.0,
+        session_id: str | None = None,
+        enable_metrics: bool = True,
+        oauth_refresh_callback: Any | None = None,
+        timeout_config: TimeoutConfig | None = None,
+    ):
         """
-        Initialize HTTP Streamable transport with chuk-mcp.
-        
+        Initialize HTTP Streamable transport with enhanced configuration.
+
         Args:
             url: HTTP server URL (should end with /mcp)
             api_key: Optional API key for authentication
-            connection_timeout: Timeout for initial connection
-            default_timeout: Default timeout for operations
+            headers: Optional custom headers
+            connection_timeout: Timeout for initial connection (overrides timeout_config.connect)
+            default_timeout: Default timeout for operations (overrides timeout_config.operation)
             session_id: Optional session ID for stateful connections
             enable_metrics: Whether to track performance metrics
+            oauth_refresh_callback: Optional async callback to refresh OAuth tokens
+            timeout_config: Optional timeout configuration model with connect/operation/quick/shutdown
         """
         # Ensure URL points to the /mcp endpoint
-        if not url.endswith('/mcp'):
+        if not url.endswith("/mcp"):
             self.url = f"{url.rstrip('/')}/mcp"
         else:
             self.url = url
-            
+
         self.api_key = api_key
-        self.connection_timeout = connection_timeout
-        self.default_timeout = default_timeout
+        self.configured_headers = headers or {}
         self.session_id = session_id
         self.enable_metrics = enable_metrics
-        
-        # State tracking (following SSE pattern)
-        self._http_context = None
+        self.oauth_refresh_callback = oauth_refresh_callback
+
+        # Use timeout config or create from individual parameters
+        if timeout_config is None:
+            timeout_config = TimeoutConfig(connect=connection_timeout, operation=default_timeout)
+
+        self.timeout_config = timeout_config
+        self.connection_timeout = timeout_config.connect
+        self.default_timeout = timeout_config.operation
+
+        logger.debug("HTTP Streamable transport initialized with URL: %s", self.url)
+        if self.api_key:
+            logger.debug("API key configured for authentication")
+        if self.configured_headers:
+            logger.debug("Custom headers configured: %s", list(self.configured_headers.keys()))
+        if self.session_id:
+            logger.debug("Session ID configured: %s", self.session_id)
+
+        # State tracking (enhanced like SSE)
+        self._http_transport = None
         self._read_stream = None
         self._write_stream = None
         self._initialized = False
-        
-        # Performance metrics (enhanced from SSE version)
-        self._metrics = {
-            "total_calls": 0,
-            "successful_calls": 0,
-            "failed_calls": 0,
-            "total_time": 0.0,
-            "avg_response_time": 0.0,
-            "last_ping_time": None,
-            "initialization_time": None
+
+        # Health monitoring (NEW - like SSE)
+        self._last_successful_ping = None
+        self._consecutive_failures = 0
+        self._max_consecutive_failures = 3
+
+        # Performance metrics (enhanced like SSE) - use Pydantic model
+        self._metrics = TransportMetrics() if enable_metrics else None
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get headers with authentication and custom headers (like SSE)."""
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "User-Agent": "chuk-tool-processor/1.0.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")
+
+        # Add configured headers first
+        if self.configured_headers:
+            headers.update(self.configured_headers)
+
+        # Add API key as Bearer token if provided and no Authorization header exists
+        # This prevents clobbering OAuth tokens from configured_headers
+        if self.api_key and "Authorization" not in headers:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        # Add session ID if provided
+        if self.session_id:
+            headers["X-Session-ID"] = self.session_id
+
+        return headers
+
+    async def _test_connection_health(self) -> bool:
+        """Test basic HTTP connectivity (like SSE's connectivity test)."""
+        try:
+            import httpx
+
+            async with httpx.AsyncClient(timeout=self.timeout_config.quick) as client:
+                # Test basic connectivity to base URL
+                base_url = self.url.replace("/mcp", "")
+                response = await client.get(f"{base_url}/health", headers=self._get_headers())
+                logger.debug("Health check response: %s", response.status_code)
+                return response.status_code < 500  # Accept any non-server-error
+        except Exception as e:
+            logger.debug("Connection health test failed: %s", e)
+            return True  # Don't fail on health check errors
 
     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 with enhanced error handling and health monitoring."""
         if self._initialized:
             logger.warning("Transport already initialized")
             return True
-        
+
         start_time = time.time()
-        
+
         try:
-            logger.info(f"Initializing HTTP Streamable transport to {self.url}")
-            
-            # Create HTTP parameters for chuk-mcp (following SSE pattern)
-            headers = {}
-            if self.api_key:
-                headers["Authorization"] = f"Bearer {self.api_key}"
-                logger.debug("API key configured for authentication")
-            
-            if self.session_id:
-                headers["X-Session-ID"] = self.session_id
-                logger.debug(f"Using session ID: {self.session_id}")
-            
+            logger.debug("Initializing HTTP Streamable transport to %s", self.url)
+
+            # Test basic connectivity first (like SSE)
+            if not await self._test_connection_health():
+                logger.warning("Connection health test failed, proceeding anyway")
+
+            # Build headers properly
+            headers = self._get_headers()
+            logger.debug("Using headers: %s", list(headers.keys()))
+
+            # Create StreamableHTTPParameters with minimal configuration
+            # NOTE: Keep params minimal - extra params can break message routing
             http_params = StreamableHTTPParameters(
                 url=self.url,
-                timeout=self.connection_timeout,
+                timeout=self.default_timeout,
                 headers=headers,
-                bearer_token=self.api_key,
-                session_id=self.session_id,
-                enable_streaming=True,  # Enable SSE streaming when available
-                max_concurrent_requests=10
+                enable_streaming=True,
             )
-            
-            # Create and enter the HTTP context (same pattern as SSE)
-            self._http_context = http_client(http_params)
-            
-            logger.debug("Establishing HTTP connection and MCP handshake...")
-            self._read_stream, self._write_stream = await asyncio.wait_for(
-                self._http_context.__aenter__(),
-                timeout=self.connection_timeout
+
+            # Create and store transport (will be managed via async with in parent scope)
+            self._http_transport = ChukHTTPTransport(http_params)
+
+            # IMPORTANT: Must use async with for proper stream setup
+            logger.debug("Establishing HTTP connection...")
+            self._http_context_entered = await asyncio.wait_for(
+                self._http_transport.__aenter__(), 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)
+
+            # Get streams after context entered
+            self._read_stream, self._write_stream = await self._http_transport.get_streams()
+
+            # Give the transport's message handler task time to start
+            await asyncio.sleep(0.1)
+
+            # Enhanced MCP initialize sequence
+            logger.debug("Sending MCP initialize request...")
+            init_start = time.time()
+
+            await asyncio.wait_for(
+                send_initialize(self._read_stream, self._write_stream, timeout=self.default_timeout),
+                timeout=self.default_timeout,
+            )
+
+            init_time = time.time() - init_start
+            logger.debug("MCP initialize completed in %.3fs", init_time)
+
+            # Verify connection with ping (enhanced like SSE)
             logger.debug("Verifying connection with ping...")
             ping_start = time.time()
+            # Use connect timeout for initial ping - some servers (like Notion) are slow
+            ping_timeout = self.timeout_config.connect
             ping_success = await asyncio.wait_for(
-                send_ping(self._read_stream, self._write_stream),
-                timeout=5.0
+                send_ping(self._read_stream, self._write_stream, timeout=ping_timeout),
+                timeout=ping_timeout,
             )
             ping_time = time.time() - ping_start
-            
+
             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
-                
-                logger.info(f"HTTP Streamable transport initialized successfully in {init_time:.3f}s (ping: {ping_time:.3f}s)")
+                self._last_successful_ping = time.time()
+                self._consecutive_failures = 0
+
+                total_init_time = time.time() - start_time
+                if self.enable_metrics and self._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)",
+                    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)
+                logger.debug("HTTP connection established but ping failed")
+                # Still consider it initialized since connection was established
                 self._initialized = True
-                self._metrics["initialization_time"] = time.time() - start_time
+                self._consecutive_failures = 1  # Mark one failure
+                if self.enable_metrics and self._metrics:
+                    self._metrics.initialization_time = time.time() - start_time
                 return True
 
-        except asyncio.TimeoutError:
-            logger.error(f"HTTP Streamable initialization timed out after {self.connection_timeout}s")
-            logger.error("This may indicate the server is not responding to MCP initialization")
+        except TimeoutError:
+            logger.error("HTTP Streamable initialization timed out after %ss", self.connection_timeout)
             await self._cleanup()
-            return False
+            if self.enable_metrics and self._metrics:
+                self._metrics.connection_errors += 1
+            raise  # Re-raise for OAuth error detection in mcp-cli
         except Exception as e:
-            logger.error(f"Error initializing HTTP Streamable transport: {e}", exc_info=True)
+            logger.error("Error initializing HTTP Streamable transport: %s", e, exc_info=True)
             await self._cleanup()
+            if self.enable_metrics and self._metrics:
+                self._metrics.connection_errors += 1
+            raise  # Re-raise for OAuth error detection in mcp-cli
+
+    async def _attempt_recovery(self) -> bool:
+        """Attempt to recover from connection issues (NEW - like SSE resilience)."""
+        if self.enable_metrics and self._metrics:
+            self._metrics.recovery_attempts += 1
+
+        logger.debug("Attempting HTTP connection recovery...")
+
+        try:
+            # Clean up existing connection
+            await self._cleanup()
+
+            # Re-initialize
+            return await self.initialize()
+        except Exception as e:
+            logger.warning("Recovery attempt failed: %s", e)
             return False
 
     async def close(self) -> None:
-        """Close the HTTP Streamable transport properly (same pattern as SSE)."""
+        """Close with enhanced cleanup and metrics reporting."""
         if not self._initialized:
             return
-        
-        # Log final metrics (enhanced from SSE)
-        if self.enable_metrics and self._metrics["total_calls"] > 0:
-            logger.info(
-                f"HTTP Streamable transport closing - Total calls: {self._metrics['total_calls']}, "
-                f"Success rate: {(self._metrics['successful_calls']/self._metrics['total_calls']*100):.1f}%, "
-                f"Avg response time: {self._metrics['avg_response_time']:.3f}s"
+
+        # Enhanced metrics logging (like SSE)
+        if self.enable_metrics and self._metrics and self._metrics.total_calls > 0:
+            success_rate = self._metrics.successful_calls / self._metrics.total_calls * 100
+            logger.debug(
+                "HTTP Streamable transport closing - Calls: %d, Success: %.1f%%, "
+                "Avg time: %.3fs, Recoveries: %d, Errors: %d",
+                self._metrics.total_calls,
+                success_rate,
+                self._metrics.avg_response_time,
+                self._metrics.recovery_attempts,
+                self._metrics.connection_errors,
             )
-            
+
         try:
-            if self._http_context is not None:
-                await self._http_context.__aexit__(None, None, None)
+            if self._http_transport is not None:
+                await self._http_transport.__aexit__(None, None, None)
                 logger.debug("HTTP Streamable context closed")
-                
+
         except Exception as e:
-            logger.debug(f"Error during transport close: {e}")
+            logger.debug("Error during transport close: %s", e)
         finally:
             await self._cleanup()
 
     async def _cleanup(self) -> None:
-        """Clean up internal state (same as SSE)."""
-        self._http_context = None
+        """Enhanced cleanup with state reset."""
+        self._http_transport = 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)."""
+        """Enhanced ping with health monitoring (like SSE)."""
         if not self._initialized or not self._read_stream:
-            logger.error("Cannot send ping: transport not initialized")
+            logger.debug("Cannot send ping: transport not initialized")
             return False
-        
+
         start_time = time.time()
         try:
             result = await asyncio.wait_for(
-                send_ping(self._read_stream, self._write_stream),
-                timeout=self.default_timeout
+                send_ping(self._read_stream, self._write_stream, timeout=self.default_timeout),
+                timeout=self.default_timeout,
             )
-            
-            if self.enable_metrics:
+
+            success = bool(result)
+
+            if success:
+                self._last_successful_ping = time.time()
+                self._consecutive_failures = 0
+            else:
+                self._consecutive_failures += 1
+
+            if self.enable_metrics and self._metrics:
                 ping_time = time.time() - start_time
-                self._metrics["last_ping_time"] = ping_time
-                logger.debug(f"Ping completed in {ping_time:.3f}s: {result}")
-            
-            return bool(result)
-        except asyncio.TimeoutError:
-            logger.error("Ping timed out")
+                self._metrics.last_ping_time = ping_time
+                logger.debug("HTTP Streamable ping completed in %.3fs: %s", ping_time, success)
+
+            return success
+        except TimeoutError:
+            logger.error("HTTP Streamable ping timed out")
+            self._consecutive_failures += 1
             return False
         except Exception as e:
-            logger.error(f"Ping failed: {e}")
+            logger.error("HTTP Streamable ping failed: %s", e)
+            self._consecutive_failures += 1
+            if self.enable_metrics and self._metrics:
+                self._metrics.stream_errors += 1
             return False
 
-    async def get_tools(self) -> List[Dict[str, Any]]:
-        """Get tools list with performance tracking (enhanced from SSE)."""
+    def is_connected(self) -> bool:
+        """Enhanced connection status check (like SSE)."""
+        if not self._initialized or not self._read_stream or not self._write_stream:
+            return False
+
+        # Check if we've had too many consecutive failures (like SSE)
+        if self._consecutive_failures >= self._max_consecutive_failures:
+            logger.warning("Connection marked unhealthy after %d failures", self._consecutive_failures)
+            return False
+
+        return True
+
+    async def get_tools(self) -> list[dict[str, Any]]:
+        """Enhanced tools retrieval with error handling."""
         if not self._initialized:
-            logger.error("Cannot get tools: transport not initialized")
+            logger.debug("Cannot get tools: transport not initialized")
             return []
-        
+
         start_time = time.time()
         try:
             tools_response = await asyncio.wait_for(
-                send_tools_list(self._read_stream, self._write_stream),
-                timeout=self.default_timeout
+                send_tools_list(self._read_stream, self._write_stream, timeout=self.default_timeout),
+                timeout=self.default_timeout,
             )
-            
-            # Normalize response (same as SSE)
-            if isinstance(tools_response, dict):
+
+            # Normalize response - handle multiple formats including Pydantic models
+            # 1. Check if it's a Pydantic model with tools attribute (e.g., ListToolsResult from chuk_mcp)
+            if hasattr(tools_response, "tools"):
+                tools = tools_response.tools
+                # Convert Pydantic Tool models to dicts if needed
+                if tools and len(tools) > 0 and hasattr(tools[0], "model_dump"):
+                    tools = [t.model_dump() for t in tools]
+                elif tools and len(tools) > 0 and hasattr(tools[0], "dict"):
+                    tools = [t.dict() for t in tools]
+            # 2. Check if it's a dict with "tools" key
+            elif isinstance(tools_response, dict):
                 tools = tools_response.get("tools", [])
+            # 3. Check if it's already a list
             elif isinstance(tools_response, list):
                 tools = tools_response
             else:
-                logger.warning(f"Unexpected tools response type: {type(tools_response)}")
+                logger.warning("Unexpected tools response type: %s", type(tools_response))
                 tools = []
-            
+
+            # Reset failure count on success
+            self._consecutive_failures = 0
+
             if self.enable_metrics:
                 response_time = time.time() - start_time
-                logger.debug(f"Retrieved {len(tools)} tools in {response_time:.3f}s")
-            
+                logger.debug("Retrieved %d tools in %.3fs", len(tools), response_time)
+
             return tools
-            
-        except asyncio.TimeoutError:
+
+        except TimeoutError:
             logger.error("Get tools timed out")
+            self._consecutive_failures += 1
             return []
         except Exception as e:
-            logger.error(f"Error getting tools: {e}")
+            logger.error("Error getting tools: %s", e)
+            self._consecutive_failures += 1
+            if self.enable_metrics and self._metrics:
+                self._metrics.stream_errors += 1
             return []
 
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any], 
-                       timeout: Optional[float] = None) -> Dict[str, Any]:
-        """Call tool with enhanced performance tracking and error handling."""
+    async def call_tool(
+        self, tool_name: str, arguments: dict[str, Any], timeout: float | None = None
+    ) -> dict[str, Any]:
+        """Enhanced tool calling with recovery and health monitoring."""
         if not self._initialized:
-            return {
-                "isError": True,
-                "error": "Transport not initialized"
-            }
+            return {"isError": True, "error": "Transport not initialized"}
 
         tool_timeout = timeout or self.default_timeout
         start_time = time.time()
-        
-        if self.enable_metrics:
-            self._metrics["total_calls"] += 1
+
+        if self.enable_metrics and self._metrics:
+            self._metrics.total_calls += 1
 
         try:
-            logger.debug(f"Calling tool '{tool_name}' with timeout {tool_timeout}s")
-            
+            logger.debug("Calling tool '%s' with timeout %ss", tool_name, tool_timeout)
+
+            # Enhanced connection check with recovery attempt
+            if not self.is_connected():
+                logger.warning("Connection unhealthy, attempting recovery...")
+                if not await self._attempt_recovery():
+                    if self.enable_metrics:
+                        self._update_metrics(time.time() - start_time, False)
+                    return {"isError": True, "error": "Failed to recover connection"}
+
             raw_response = await asyncio.wait_for(
-                send_tools_call(
-                    self._read_stream, 
-                    self._write_stream, 
-                    tool_name, 
-                    arguments
-                ),
-                timeout=tool_timeout
+                send_tools_call(self._read_stream, self._write_stream, tool_name, arguments), timeout=tool_timeout
             )
-            
+
             response_time = time.time() - start_time
-            result = self._normalize_tool_response(raw_response)
-            
+            result = self._normalize_mcp_response(raw_response)
+
+            # NEW: Check for OAuth errors and attempt refresh if callback is available
+            if result.get("isError", False) and self._is_oauth_error(result.get("error", "")):
+                logger.warning("OAuth error detected: %s", result.get("error"))
+
+                if self.oauth_refresh_callback:
+                    logger.debug("Attempting OAuth token refresh...")
+                    try:
+                        # Call the refresh callback
+                        new_headers = await self.oauth_refresh_callback()
+
+                        if new_headers and "Authorization" in new_headers:
+                            # Update configured headers with new token
+                            self.configured_headers.update(new_headers)
+                            logger.debug("OAuth token refreshed, reconnecting...")
+
+                            # Reconnect with new token
+                            if await self._attempt_recovery():
+                                logger.debug("Retrying tool call after token refresh...")
+                                # Retry the tool call once with new token
+                                raw_response = await asyncio.wait_for(
+                                    send_tools_call(self._read_stream, self._write_stream, tool_name, arguments),
+                                    timeout=tool_timeout,
+                                )
+                                result = self._normalize_mcp_response(raw_response)
+                                logger.debug("Tool call retry completed")
+                            else:
+                                logger.error("Failed to reconnect after token refresh")
+                        else:
+                            logger.warning("Token refresh did not return valid Authorization header")
+                    except Exception as refresh_error:
+                        logger.error("OAuth token refresh failed: %s", refresh_error)
+                else:
+                    logger.warning("OAuth error detected but no refresh callback configured")
+
+            # Reset failure count on success
+            if not result.get("isError", False):
+                self._consecutive_failures = 0
+                self._last_successful_ping = time.time()  # Update health timestamp
+
             if self.enable_metrics:
                 self._update_metrics(response_time, not result.get("isError", False))
-                
+
             if not result.get("isError", False):
-                logger.debug(f"Tool '{tool_name}' completed successfully in {response_time:.3f}s")
+                logger.debug("Tool '%s' completed successfully in %.3fs", tool_name, response_time)
             else:
-                logger.warning(f"Tool '{tool_name}' failed in {response_time:.3f}s: {result.get('error', 'Unknown error')}")
-            
+                logger.warning(
+                    "Tool '%s' failed in %.3fs: %s", tool_name, response_time, result.get("error", "Unknown error")
+                )
+
             return result
 
-        except asyncio.TimeoutError:
+        except TimeoutError:
             response_time = time.time() - start_time
+            self._consecutive_failures += 1
             if self.enable_metrics:
                 self._update_metrics(response_time, False)
-                
+
             error_msg = f"Tool execution timed out after {tool_timeout}s"
-            logger.error(f"Tool '{tool_name}' {error_msg}")
-            return {
-                "isError": True,
-                "error": error_msg
-            }
+            logger.error("Tool '%s' %s", tool_name, error_msg)
+            return {"isError": True, "error": error_msg}
         except Exception as e:
             response_time = time.time() - start_time
-            if self.enable_metrics:
+            self._consecutive_failures += 1
+            if self.enable_metrics and self._metrics:
                 self._update_metrics(response_time, False)
-                
+                self._metrics.stream_errors += 1
+
+            # Enhanced connection error detection
+            error_str = str(e).lower()
+            if any(indicator in error_str for indicator in ["connection", "disconnected", "broken pipe", "eof"]):
+                logger.warning("Connection error detected: %s", e)
+                self._initialized = False
+                if self.enable_metrics and self._metrics:
+                    self._metrics.connection_errors += 1
+
             error_msg = f"Tool execution failed: {str(e)}"
-            logger.error(f"Tool '{tool_name}' error: {error_msg}")
-            return {
-                "isError": True,
-                "error": error_msg
-            }
+            logger.error("Tool '%s' error: %s", tool_name, error_msg)
+            return {"isError": True, "error": error_msg}
 
     def _update_metrics(self, response_time: float, success: bool) -> None:
-        """Update performance metrics (new feature)."""
-        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"]
-        )
+        """Enhanced metrics tracking (like SSE)."""
+        if not self._metrics:
+            return
 
-    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 {}
-            
+        self._metrics.update_call_metrics(response_time, success)
+
+    def _is_oauth_error(self, error_msg: str) -> bool:
+        """
+        Detect if error is OAuth-related per RFC 6750 and MCP OAuth spec.
+
+        Checks for:
+        - RFC 6750 Section 3.1 Bearer token errors (invalid_token, insufficient_scope)
+        - OAuth 2.1 token refresh errors (invalid_grant)
+        - MCP spec OAuth validation failures (401/403 responses)
+        """
+        if not error_msg:
+            return False
+
+        error_lower = error_msg.lower()
+        oauth_indicators = [
+            # RFC 6750 Section 3.1 - Standard Bearer token errors
+            "invalid_token",  # Token expired, revoked, malformed, or invalid
+            "insufficient_scope",  # Request requires higher privileges (403 Forbidden)
+            # OAuth 2.1 token refresh errors
+            "invalid_grant",  # Refresh token errors
+            # MCP spec - OAuth validation failures (401 Unauthorized)
+            "oauth validation",
+            "unauthorized",
+            # Common OAuth error descriptions
+            "expired token",
+            "token expired",
+            "authentication failed",
+            "invalid access token",
+        ]
+
+        return any(indicator in error_lower for indicator in oauth_indicators)
+
+    async def list_resources(self) -> dict[str, Any]:
+        """Enhanced resource listing with error handling."""
         if not self._initialized:
             return {}
-        
+
         try:
             response = await asyncio.wait_for(
-                send_resources_list(self._read_stream, self._write_stream),
-                timeout=self.default_timeout
+                send_resources_list(self._read_stream, self._write_stream), timeout=self.default_timeout
             )
             return response if isinstance(response, dict) else {}
-        except asyncio.TimeoutError:
+        except TimeoutError:
             logger.error("List resources timed out")
+            self._consecutive_failures += 1
             return {}
         except Exception as e:
-            logger.debug(f"Error listing resources: {e}")
+            logger.debug("Error listing resources: %s", e)
+            self._consecutive_failures += 1
             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 {}
-            
+    async def list_prompts(self) -> dict[str, Any]:
+        """Enhanced prompt listing with error handling."""
         if not self._initialized:
             return {}
-        
+
         try:
             response = await asyncio.wait_for(
-                send_prompts_list(self._read_stream, self._write_stream),
-                timeout=self.default_timeout
+                send_prompts_list(self._read_stream, self._write_stream), timeout=self.default_timeout
             )
             return response if isinstance(response, dict) else {}
-        except asyncio.TimeoutError:
+        except TimeoutError:
             logger.error("List prompts timed out")
+            self._consecutive_failures += 1
             return {}
         except Exception as e:
-            logger.debug(f"Error listing prompts: {e}")
+            logger.debug("Error listing prompts: %s", e)
+            self._consecutive_failures += 1
             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
-            }
+    async def read_resource(self, uri: str) -> dict[str, Any]:
+        """Read a specific resource."""
+        if not self._initialized:
+            return {}
 
-        # 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"])
+        try:
+            response = await asyncio.wait_for(
+                send_resources_read(self._read_stream, self._write_stream, uri), timeout=self.default_timeout
+            )
+            return response if isinstance(response, dict) else {}
+        except TimeoutError:
+            logger.error("Read resource timed out")
+            self._consecutive_failures += 1
+            return {}
+        except Exception as e:
+            logger.debug("Error reading resource: %s", e)
+            self._consecutive_failures += 1
+            return {}
+
+    async def get_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Get a specific prompt."""
+        if not self._initialized:
+            return {}
+
+        try:
+            response = await asyncio.wait_for(
+                send_prompts_get(self._read_stream, self._write_stream, name, arguments or {}),
+                timeout=self.default_timeout,
+            )
+            return response if isinstance(response, dict) else {}
+        except TimeoutError:
+            logger.error("Get prompt timed out")
+            self._consecutive_failures += 1
+            return {}
+        except Exception as e:
+            logger.debug("Error getting prompt: %s", e)
+            self._consecutive_failures += 1
+            return {}
+
+    def get_metrics(self) -> dict[str, Any]:
+        """Enhanced metrics with health information."""
+        if not self._metrics:
+            return {}
+
+        metrics = self._metrics.to_dict()
+        metrics.update(
+            {
+                "is_connected": self.is_connected(),
+                "consecutive_failures": self._consecutive_failures,
+                "last_successful_ping": self._last_successful_ping,
+                "max_consecutive_failures": self._max_consecutive_failures,
             }
+        )
+        return metrics
 
-        # Fallback
-        return {
-            "isError": False,
-            "content": raw_response
-        }
+    def reset_metrics(self) -> None:
+        """Enhanced metrics reset preserving health state."""
+        if not self._metrics:
+            return
 
-    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
+        # Preserve important historical values
+        preserved_init_time = self._metrics.initialization_time
+        preserved_last_ping = self._metrics.last_ping_time
+        preserved_resets = self._metrics.connection_resets
 
-    def get_streams(self) -> List[tuple]:
-        """Provide streams for backward compatibility (same as SSE)."""
+        # Create new metrics instance with preserved values
+        self._metrics = TransportMetrics(
+            initialization_time=preserved_init_time,
+            last_ping_time=preserved_last_ping,
+            connection_resets=preserved_resets,
+        )
+
+    def get_streams(self) -> list[tuple]:
+        """Enhanced streams access with connection check."""
         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
-
-    def get_metrics(self) -> Dict[str, Any]:
-        """Get performance metrics (new feature)."""
-        return self._metrics.copy()
-
-    def reset_metrics(self) -> None:
-        """Reset performance metrics (new feature)."""
-        self._metrics = {
-            "total_calls": 0,
-            "successful_calls": 0,
-            "failed_calls": 0,
-            "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")
-        }
-
     async def __aenter__(self):
-        """Context manager support (same as SSE)."""
+        """Enhanced context manager entry."""
         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)."""
+        """Enhanced context manager cleanup."""
         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})"