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

chuk_tool_processor/mcp/transport/stdio_transport.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import time
 from typing import Dict, Any, List, Optional
 import logging
 
@@ -11,28 +12,34 @@ from chuk_mcp.transports.stdio import stdio_client
 from chuk_mcp.transports.stdio.parameters import StdioParameters
 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,
 )
 
-# Optional imports
-try:
-    from chuk_mcp.protocol.messages import send_resources_list, send_resources_read
-    HAS_RESOURCES = True
-except ImportError:
-    HAS_RESOURCES = False
-
-try:
-    from chuk_mcp.protocol.messages import send_prompts_list, send_prompts_get
-    HAS_PROMPTS = True
-except ImportError:
-    HAS_PROMPTS = False
-
 logger = logging.getLogger(__name__)
 
 
 class StdioTransport(MCPBaseTransport):
-    """Ultra-lightweight wrapper around chuk-mcp stdio transport."""
+    """
+    STDIO transport for MCP communication using process pipes.
+    
+    This transport uses subprocess communication via stdin/stdout pipes
+    to communicate with MCP servers.
+    """
 
-    def __init__(self, server_params):
+    def __init__(self, server_params, 
+                 connection_timeout: float = 30.0,
+                 default_timeout: float = 30.0,
+                 enable_metrics: bool = True):
+        """
+        Initialize STDIO transport.
+        
+        Args:
+            server_params: Server parameters (dict or StdioParameters object)
+            connection_timeout: Timeout for initial connection setup
+            default_timeout: Default timeout for operations
+            enable_metrics: Whether to track performance metrics
+        """
         # Convert dict to StdioParameters if needed
         if isinstance(server_params, dict):
             self.server_params = StdioParameters(
@@ -43,107 +50,278 @@ class StdioTransport(MCPBaseTransport):
         else:
             self.server_params = server_params
         
+        self.connection_timeout = connection_timeout
+        self.default_timeout = default_timeout
+        self.enable_metrics = enable_metrics
+        
+        # Connection state
         self._context = None
         self._streams = None
         self._initialized = False
+        
+        # Performance metrics (consistent with other transports)
+        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,
+            "process_restarts": 0,
+            "pipe_errors": 0
+        }
+        
+        logger.debug("STDIO transport initialized for command: %s", 
+                    getattr(self.server_params, 'command', 'unknown'))
 
     async def initialize(self) -> bool:
-        """Initialize by delegating to chuk-mcp."""
+        """Initialize by delegating to chuk-mcp with timeout protection."""
         if self._initialized:
+            logger.warning("Transport already initialized")
             return True
-            
+        
+        start_time = time.time()
+        
         try:
             logger.debug("Initializing STDIO transport...")
+            
+            # Create context with timeout protection
             self._context = stdio_client(self.server_params)
-            self._streams = await self._context.__aenter__()
+            self._streams = await asyncio.wait_for(
+                self._context.__aenter__(),
+                timeout=self.connection_timeout
+            )
+            
+            # Send initialize message with timeout
+            init_result = await asyncio.wait_for(
+                send_initialize(*self._streams),
+                timeout=self.default_timeout
+            )
             
-            # Send initialize message
-            init_result = await send_initialize(*self._streams)
             if init_result:
                 self._initialized = True
-                logger.debug("STDIO transport initialized successfully")
+                
+                if self.enable_metrics:
+                    init_time = time.time() - start_time
+                    self._metrics["initialization_time"] = init_time
+                
+                logger.debug("STDIO transport initialized successfully in %.3fs", time.time() - start_time)
                 return True
             else:
+                logger.error("STDIO initialization failed")
                 await self._cleanup()
                 return False
+                
+        except asyncio.TimeoutError:
+            logger.error("STDIO initialization timed out after %ss", self.connection_timeout)
+            await self._cleanup()
+            return False
         except Exception as e:
             logger.error("Error initializing STDIO transport: %s", e)
             await self._cleanup()
             return False
 
     async def close(self) -> None:
-        """Close by delegating to chuk-mcp context manager."""
+        """Close by delegating to chuk-mcp context manager with enhanced cleanup."""
+        if not self._initialized:
+            return
+        
+        # Log final metrics
+        if self.enable_metrics and self._metrics["total_calls"] > 0:
+            logger.debug(
+                "STDIO transport closing - Total calls: %d, Success rate: %.1f%%, Avg response time: %.3fs",
+                self._metrics["total_calls"],
+                (self._metrics["successful_calls"] / self._metrics["total_calls"] * 100),
+                self._metrics["avg_response_time"]
+            )
+        
         if self._context:
             try:
-                # Simple delegation - the StreamManager now calls this in the correct context
                 await self._context.__aexit__(None, None, None)
+                logger.debug("STDIO context closed")
             except Exception as e:
-                logger.debug("Error during close: %s", e)
+                logger.debug("Error during STDIO close: %s", e)
             finally:
                 await self._cleanup()
 
     async def _cleanup(self) -> None:
-        """Minimal cleanup."""
+        """Clean up internal state."""
         self._context = None
         self._streams = None
         self._initialized = False
 
     async def send_ping(self) -> bool:
-        """Delegate ping to chuk-mcp."""
+        """Send ping with performance tracking."""
         if not self._initialized:
             return False
+        
+        start_time = time.time()
         try:
-            return bool(await send_ping(*self._streams))
-        except Exception:
+            result = await asyncio.wait_for(
+                send_ping(*self._streams),
+                timeout=self.default_timeout
+            )
+            
+            if self.enable_metrics:
+                ping_time = time.time() - start_time
+                self._metrics["last_ping_time"] = ping_time
+                logger.debug("STDIO ping completed in %.3fs: %s", ping_time, result)
+            
+            return bool(result)
+        except asyncio.TimeoutError:
+            logger.error("STDIO ping timed out")
             return False
+        except Exception as e:
+            logger.error("STDIO ping failed: %s", e)
+            if self.enable_metrics:
+                self._metrics["pipe_errors"] += 1
+            return False
+
+    def is_connected(self) -> bool:
+        """Check connection status."""
+        return self._initialized and self._streams is not None
 
     async def get_tools(self) -> List[Dict[str, Any]]:
-        """Delegate tools list to chuk-mcp."""
+        """Get tools list with performance tracking."""
         if not self._initialized:
+            logger.error("Cannot get tools: transport not initialized")
             return []
+        
+        start_time = time.time()
         try:
-            response = await send_tools_list(*self._streams)
+            response = await asyncio.wait_for(
+                send_tools_list(*self._streams),
+                timeout=self.default_timeout
+            )
+            
+            # Normalize response
             if isinstance(response, dict):
-                return response.get("tools", [])
-            return response if isinstance(response, list) else []
-        except Exception:
+                tools = response.get("tools", [])
+            elif isinstance(response, list):
+                tools = response
+            else:
+                logger.warning("Unexpected tools response type: %s", type(response))
+                tools = []
+            
+            if self.enable_metrics:
+                response_time = time.time() - start_time
+                logger.debug("Retrieved %d tools in %.3fs", len(tools), response_time)
+            
+            return tools
+            
+        except asyncio.TimeoutError:
+            logger.error("Get tools timed out")
+            return []
+        except Exception as e:
+            logger.error("Error getting tools: %s", e)
+            if self.enable_metrics:
+                self._metrics["pipe_errors"] += 1
             return []
 
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Delegate tool execution to chuk-mcp."""
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any], 
+                       timeout: Optional[float] = None) -> Dict[str, Any]:
+        """Call tool with timeout support and performance tracking."""
         if not self._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  # FIXED: INCREMENT FIRST
+
         try:
-            response = await send_tools_call(*self._streams, tool_name, arguments)
-            return self._normalize_response(response)
+            logger.debug("Calling tool '%s' with timeout %ss", tool_name, tool_timeout)
+            
+            response = await asyncio.wait_for(
+                send_tools_call(*self._streams, tool_name, arguments),
+                timeout=tool_timeout
+            )
+            
+            response_time = time.time() - start_time
+            result = self._normalize_mcp_response(response)
+            
+            if self.enable_metrics:
+                self._update_metrics(response_time, not result.get("isError", False))
+            
+            if not result.get("isError", False):
+                logger.debug("Tool '%s' completed successfully in %.3fs", tool_name, response_time)
+            else:
+                logger.warning("Tool '%s' failed in %.3fs: %s", tool_name, response_time, result.get('error', 'Unknown error'))
+            
+            return result
+            
+        except asyncio.TimeoutError:
+            response_time = time.time() - start_time
+            if self.enable_metrics:
+                self._update_metrics(response_time, False)
+            
+            error_msg = f"Tool execution timed out after {tool_timeout}s"
+            logger.error("Tool '%s' %s", tool_name, error_msg)
+            return {
+                "isError": True,
+                "error": error_msg
+            }
         except Exception as e:
-            return {"isError": True, "error": f"Tool execution failed: {str(e)}"}
+            response_time = time.time() - start_time
+            if self.enable_metrics:
+                self._update_metrics(response_time, False)
+                self._metrics["pipe_errors"] += 1
+            
+            error_msg = f"Tool execution failed: {str(e)}"
+            logger.error("Tool '%s' error: %s", tool_name, error_msg)
+            return {
+                "isError": True,
+                "error": error_msg
+            }
 
-    def _normalize_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
-        """Minimal response normalization."""
+    def _update_metrics(self, response_time: float, success: bool) -> None:
+        """Update performance metrics."""
+        if success:
+            self._metrics["successful_calls"] += 1
+        else:
+            self._metrics["failed_calls"] += 1
+            
+        self._metrics["total_time"] += response_time
+        # FIXED: Only calculate average if we have total calls
+        if self._metrics["total_calls"] > 0:
+            self._metrics["avg_response_time"] = (
+                self._metrics["total_time"] / self._metrics["total_calls"]
+            )
+
+    def _normalize_mcp_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Normalize response using shared base class logic with STDIO-specific handling.
+        
+        STDIO has special requirements for preserving string representations
+        of numeric values for backward compatibility.
+        """
+        # Handle explicit error in response
         if "error" in response:
             error_info = response["error"]
             error_msg = error_info.get("message", str(error_info)) 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_content(result["content"])}
+                return {"isError": False, "content": self._extract_stdio_content(result["content"])}
             return {"isError": False, "content": result}
         
+        # Handle direct content-based response
         if "content" in response:
-            return {"isError": False, "content": self._extract_content(response["content"])}
+            return {"isError": False, "content": self._extract_stdio_content(response["content"])}
         
         return {"isError": False, "content": response}
 
-    def _extract_content(self, content_list: Any) -> Any:
+    def _extract_stdio_content(self, content_list: Any) -> Any:
         """
-        Minimal content extraction - FIXED to return strings consistently.
+        Extract content with STDIO-specific string preservation logic.
         
-        The test expects result["content"] to be "42" (string), but we were
-        returning 42 (integer) after JSON parsing.
+        STDIO transport preserves string representations of numeric values
+        for backward compatibility with existing tests.
         """
         if not isinstance(content_list, list) or not content_list:
             return content_list
@@ -153,12 +331,11 @@ class StdioTransport(MCPBaseTransport):
             if isinstance(item, dict) and item.get("type") == "text":
                 text = item.get("text", "")
                 
-                # FIXED: Always try to parse JSON, but preserve strings as strings
-                # if they look like simple values (numbers, booleans, etc.)
+                # STDIO-specific: preserve string format for numeric values
                 try:
                     parsed = json.loads(text)
                     # If the parsed result is a simple type and the original was a string,
-                    # keep it as a string to maintain consistency with test expectations
+                    # keep it as a string to maintain compatibility
                     if isinstance(parsed, (int, float, bool)) and isinstance(text, str):
                         # Check if this looks like a simple numeric string
                         if text.strip().isdigit() or (text.strip().replace('.', '', 1).isdigit()):
@@ -170,67 +347,106 @@ class StdioTransport(MCPBaseTransport):
         
         return content_list
 
-    # Optional features
     async def list_resources(self) -> Dict[str, Any]:
-        """Delegate resources to chuk-mcp if available."""
-        if not HAS_RESOURCES or not self._initialized:
+        """List resources with error handling."""
+        if not self._initialized:
             return {}
         try:
-            response = await send_resources_list(*self._streams)
+            response = await asyncio.wait_for(
+                send_resources_list(*self._streams),
+                timeout=self.default_timeout
+            )
             return response if isinstance(response, dict) else {}
-        except Exception:
+        except asyncio.TimeoutError:
+            logger.error("List resources timed out")
+            return {}
+        except Exception as e:
+            logger.debug("Error listing resources: %s", e)
             return {}
 
-    async def read_resource(self, uri: str) -> Dict[str, Any]:
-        """Delegate resource reading to chuk-mcp if available."""
-        if not HAS_RESOURCES or not self._initialized:
+    async def list_prompts(self) -> Dict[str, Any]:
+        """List prompts with error handling."""
+        if not self._initialized:
             return {}
         try:
-            response = await send_resources_read(*self._streams, uri)
+            response = await asyncio.wait_for(
+                send_prompts_list(*self._streams),
+                timeout=self.default_timeout
+            )
             return response if isinstance(response, dict) else {}
-        except Exception:
+        except asyncio.TimeoutError:
+            logger.error("List prompts timed out")
+            return {}
+        except Exception as e:
+            logger.debug("Error listing prompts: %s", e)
             return {}
 
-    async def list_prompts(self) -> Dict[str, Any]:
-        """Delegate prompts to chuk-mcp if available."""
-        if not HAS_PROMPTS or not self._initialized:
+    async def read_resource(self, uri: str) -> Dict[str, Any]:
+        """Read a specific resource."""
+        if not self._initialized:
             return {}
         try:
-            response = await send_prompts_list(*self._streams)
+            response = await asyncio.wait_for(
+                send_resources_read(*self._streams, uri),
+                timeout=self.default_timeout
+            )
             return response if isinstance(response, dict) else {}
-        except Exception:
+        except Exception as e:
+            logger.debug("Error reading resource: %s", e)
             return {}
 
     async def get_prompt(self, name: str, arguments: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Delegate prompt retrieval to chuk-mcp if available."""
-        if not HAS_PROMPTS or not self._initialized:
+        """Get a specific prompt."""
+        if not self._initialized:
             return {}
         try:
-            response = await send_prompts_get(*self._streams, name, arguments or {})
+            response = await asyncio.wait_for(
+                send_prompts_get(*self._streams, name, arguments or {}),
+                timeout=self.default_timeout
+            )
             return response if isinstance(response, dict) else {}
-        except Exception:
+        except Exception as e:
+            logger.debug("Error getting prompt: %s", e)
             return {}
 
-    # Backward compatibility
+    # ------------------------------------------------------------------ #
+    #  Metrics and monitoring (now consistent with other transports)    #
+    # ------------------------------------------------------------------ #
+    def get_metrics(self) -> Dict[str, Any]:
+        """Get performance and connection metrics."""
+        return self._metrics.copy()
+
+    def reset_metrics(self) -> None:
+        """Reset performance metrics."""
+        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"),
+            "process_restarts": self._metrics.get("process_restarts", 0),
+            "pipe_errors": 0
+        }
+
+    # ------------------------------------------------------------------ #
+    #  Backward compatibility                                            #
+    # ------------------------------------------------------------------ #
     def get_streams(self) -> List[tuple]:
         """Provide streams for backward compatibility."""
         return [self._streams] if self._streams else []
 
-    def is_connected(self) -> bool:
-        """Check connection status."""
-        return self._initialized
-
+    # ------------------------------------------------------------------ #
+    #  Context manager support (now uses base class with fixed error)   #
+    # ------------------------------------------------------------------ #
     async def __aenter__(self):
         """Context manager support."""
-        if not await self.initialize():
-            raise RuntimeError("Failed to initialize STDIO transport")
+        success = await self.initialize()
+        if not success:
+            raise RuntimeError("Failed to initialize StdioTransport")  # FIXED: message
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Context manager cleanup."""
-        await self.close()
-
-    def __repr__(self) -> str:
-        """String representation."""
-        status = "initialized" if self._initialized else "not initialized"
-        return f"StdioTransport(status={status}, command={getattr(self.server_params, 'command', 'unknown')})"
+        await self.close()

{chuk_tool_processor-0.6.7.dist-info → chuk_tool_processor-0.6.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.6.7
+Version: 0.6.9
 Summary: Async-native framework for registering, discovering, and executing tools referenced in LLM responses
 Author-email: CHUK Team <chrishayuk@somejunkmailbox.com>
 Maintainer-email: CHUK Team <chrishayuk@somejunkmailbox.com>

{chuk_tool_processor-0.6.7.dist-info → chuk_tool_processor-0.6.9.dist-info}/RECORD

@@ -22,12 +22,12 @@ chuk_tool_processor/mcp/register_mcp_tools.py,sha256=s6mQMtZr7dswT2WXDJ84zjOTSi3
 chuk_tool_processor/mcp/setup_mcp_http_streamable.py,sha256=ZJUAj7LL4CRfc-CBl0SQJk0qfW12IuixR-7J2hbQ8S8,4538
 chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=4nf0V6cykAPLxtgsl8RTAYQdVWITUNu_3CIU1vcLjlo,3795
 chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=L8anrx_b5HDsaMqAfbpWaHex084DTd76W8WBf3ClC48,2884
-chuk_tool_processor/mcp/stream_manager.py,sha256=DU1RkFDqyz9PZVNBgx-LeJM8Tt7hf-_mmYymRvfnqKY,32701
-chuk_tool_processor/mcp/transport/__init__.py,sha256=0DX7m_VvlXPxijc-88_QTLhq4ZqAgUgzBjSMGL9C_lM,963
-chuk_tool_processor/mcp/transport/base_transport.py,sha256=bqId34OMQMxzMXtrKq_86sot0_x0NS_ecaIllsCyy6I,3423
-chuk_tool_processor/mcp/transport/http_streamable_transport.py,sha256=3I3tNYU8r4YqCbNhMCkoucvZc6VS2ulzeUjDe2FbcRk,19108
-chuk_tool_processor/mcp/transport/sse_transport.py,sha256=s8an1sHLFsIJwqxUcdSvY6bYBkdyNQ-LkQMqzD5okdI,17253
-chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=DPXLR_OxuCJ2bgwYDuT_iYC_CDcUIySvLNO7JzyiPyc,9099
+chuk_tool_processor/mcp/stream_manager.py,sha256=sRy6X893ISht4XUFVIjUHQ0zVisyP7ex2s2wiPQv2fg,33858
+chuk_tool_processor/mcp/transport/__init__.py,sha256=2IZHt5x8GD7jgPmt5JvUIhSBij4kf9vZta1rL_-UDMc,657
+chuk_tool_processor/mcp/transport/base_transport.py,sha256=EapglrjRuSniGkEoEeL76ZGx_VriHqR1coK32nFMrd8,9175
+chuk_tool_processor/mcp/transport/http_streamable_transport.py,sha256=FkOlZDROLrRdPV5e3UeEwHlUbQlMK9eLaK8LbVcnnOo,18372
+chuk_tool_processor/mcp/transport/sse_transport.py,sha256=zE91K48HNcqcyiUL8nEn-9oDDpR-rHi483WgZ3f-CSA,22684
+chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=I64dYt3ZXGmWMmTegdspKZcLggoNAdvxfqh-z8tAO1s,17683
 chuk_tool_processor/models/__init__.py,sha256=TC__rdVa0lQsmJHM_hbLDPRgToa_pQT_UxRcPZk6iVw,40
 chuk_tool_processor/models/execution_strategy.py,sha256=UVW35YIeMY2B3mpIKZD2rAkyOPayI6ckOOUALyf0YiQ,2115
 chuk_tool_processor/models/streaming_tool.py,sha256=0v2PSPTgZ5TS_PpVdohvVhh99fPwPQM_R_z4RU0mlLM,3541
@@ -54,7 +54,7 @@ chuk_tool_processor/registry/providers/__init__.py,sha256=eigwG_So11j7WbDGSWaKd3
 chuk_tool_processor/registry/providers/memory.py,sha256=6cMtUwLO6zrk3pguQRgxJ2CReHAzewgZsizWZhsoStk,5184
 chuk_tool_processor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/utils/validation.py,sha256=V5N1dH9sJlHepFIbiI2k2MU82o7nvnh0hKyIt2jdgww,4136
-chuk_tool_processor-0.6.7.dist-info/METADATA,sha256=2MPxA-1YJcyWceWZpucwslCce1w7xewFoDZXb1iDi80,23463
-chuk_tool_processor-0.6.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_tool_processor-0.6.7.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.6.7.dist-info/RECORD,,
+chuk_tool_processor-0.6.9.dist-info/METADATA,sha256=ywTwAgW9KZmQxNtELdMvGenXaiFNvjflyvI3oevrbuY,23463
+chuk_tool_processor-0.6.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_tool_processor-0.6.9.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.6.9.dist-info/RECORD,,