chuk-tool-processor 0.1.7__py3-none-any.whl → 0.2__py3-none-any.whl

chuk_tool_processor/execution/strategies/inprocess_strategy.py

@@ -1,11 +1,13 @@
 #!/usr/bin/env python
 # chuk_tool_processor/execution/strategies/inprocess_strategy.py
 """
-In-process execution strategy for tools with true streaming support.
+In-process execution strategy for tools with proper timeout handling.
 
 This strategy executes tools concurrently in the same process using asyncio.
 It has special support for streaming tools, accessing their stream_execute method
 directly to enable true item-by-item streaming.
+
+FIXED: Ensures consistent timeout handling across all execution paths.
 """
 from __future__ import annotations
 
@@ -36,7 +38,7 @@ async def _noop_cm():
 
 # --------------------------------------------------------------------------- #
 class InProcessStrategy(ExecutionStrategy):
-    """Execute tools in the local event-loop with optional concurrency cap."""
+    """Execute tools in the local event-loop with optional concurrency cap and consistent timeout handling."""
 
     def __init__(
         self,
@@ -53,7 +55,7 @@ class InProcessStrategy(ExecutionStrategy):
             max_concurrency: Maximum number of concurrent executions
         """
         self.registry = registry
-        self.default_timeout = default_timeout
+        self.default_timeout = default_timeout or 30.0  # Always have a default
         self._sem = asyncio.Semaphore(max_concurrency) if max_concurrency else None
         
         # Task tracking for cleanup
@@ -64,6 +66,9 @@ class InProcessStrategy(ExecutionStrategy):
         # Tracking for which calls are being handled directly by the executor
         # to prevent duplicate streaming results
         self._direct_streaming_calls = set()
+        
+        logger.debug("InProcessStrategy initialized with timeout: %ss, max_concurrency: %s", 
+                    self.default_timeout, max_concurrency)
 
     # ------------------------------------------------------------------ #
     def mark_direct_streaming(self, call_ids: Set[str]) -> None:
@@ -116,11 +121,15 @@ class InProcessStrategy(ExecutionStrategy):
         """
         if not calls:
             return []
+        
+        # Use default_timeout if no timeout specified
+        effective_timeout = timeout if timeout is not None else self.default_timeout
+        logger.debug("Executing %d calls with %ss timeout each", len(calls), effective_timeout)
             
         tasks = []
         for call in calls:
             task = asyncio.create_task(
-                self._execute_single_call(call, timeout or self.default_timeout)
+                self._execute_single_call(call, effective_timeout)  # Always pass timeout
             )
             self._active_tasks.add(task)
             task.add_done_callback(self._active_tasks.discard)
@@ -142,10 +151,13 @@ class InProcessStrategy(ExecutionStrategy):
         if not calls:
             return
 
+        # Use default_timeout if no timeout specified
+        effective_timeout = timeout if timeout is not None else self.default_timeout
+
         queue: asyncio.Queue[ToolResult] = asyncio.Queue()
         tasks = {
             asyncio.create_task(
-                self._stream_tool_call(call, queue, timeout or self.default_timeout)
+                self._stream_tool_call(call, queue, effective_timeout)  # Always pass timeout
             )
             for call in calls
             if call.id not in self._direct_streaming_calls
@@ -170,7 +182,7 @@ class InProcessStrategy(ExecutionStrategy):
         self,
         call: ToolCall,
         queue: asyncio.Queue,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required
     ) -> None:
         """
         Execute a tool call with streaming support.
@@ -181,7 +193,7 @@ class InProcessStrategy(ExecutionStrategy):
         Args:
             call: The tool call to execute
             queue: Queue to put results into
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
         """
         # Skip if call is being handled directly by the executor
         if call.id in self._direct_streaming_calls:
@@ -269,7 +281,7 @@ class InProcessStrategy(ExecutionStrategy):
         tool: Any, 
         call: ToolCall, 
         queue: asyncio.Queue, 
-        timeout: Optional[float]
+        timeout: float,  # Make timeout required
     ) -> None:
         """
         Stream results from a streaming tool with timeout support.
@@ -281,12 +293,14 @@ class InProcessStrategy(ExecutionStrategy):
             tool: The tool instance
             call: Tool call data
             queue: Queue to put results into
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
         """
         start_time = datetime.now(timezone.utc)
         machine = os.uname().nodename
         pid = os.getpid()
         
+        logger.debug("Streaming %s with %ss timeout", call.tool, timeout)
+        
         # Define the streaming task
         async def streamer():
             try:
@@ -318,15 +332,17 @@ class InProcessStrategy(ExecutionStrategy):
                 await queue.put(error_result)
         
         try:
-            # Execute with timeout if specified
-            if timeout:
-                await asyncio.wait_for(streamer(), timeout)
-            else:
-                await streamer()
+            # Always execute with timeout
+            await asyncio.wait_for(streamer(), timeout)
+            logger.debug("%s streaming completed within %ss", call.tool, timeout)
                 
         except asyncio.TimeoutError:
             # Handle timeout
             now = datetime.now(timezone.utc)
+            actual_duration = (now - start_time).total_seconds()
+            logger.debug("%s streaming timed out after %.3fs (limit: %ss)", 
+                        call.tool, actual_duration, timeout)
+            
             timeout_result = ToolResult(
                 tool=call.tool,
                 result=None,
@@ -341,6 +357,8 @@ class InProcessStrategy(ExecutionStrategy):
         except Exception as e:
             # Handle other errors
             now = datetime.now(timezone.utc)
+            logger.debug("%s streaming failed: %s", call.tool, e)
+            
             error_result = ToolResult(
                 tool=call.tool,
                 result=None,
@@ -356,7 +374,7 @@ class InProcessStrategy(ExecutionStrategy):
         self,
         call: ToolCall,
         queue: asyncio.Queue,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required
     ) -> None:
         """Execute a single call and put the result in the queue."""
         # Skip if call is being handled directly by the executor
@@ -370,17 +388,17 @@ class InProcessStrategy(ExecutionStrategy):
     async def _execute_single_call(
         self,
         call: ToolCall,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required, not optional
     ) -> ToolResult:
         """
-        Execute a single tool call.
+        Execute a single tool call with guaranteed timeout.
 
         The entire invocation – including argument validation – is wrapped
         by the semaphore to honour *max_concurrency*.
         
         Args:
             call: Tool call to execute
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
             
         Returns:
             Tool execution result
@@ -389,6 +407,8 @@ class InProcessStrategy(ExecutionStrategy):
         machine = os.uname().nodename
         start = datetime.now(timezone.utc)
         
+        logger.debug("Executing %s with %ss timeout", call.tool, timeout)
+        
         # Early exit if shutting down
         if self._shutting_down:
             return ToolResult(
@@ -464,19 +484,18 @@ class InProcessStrategy(ExecutionStrategy):
         self,
         tool: Any,
         call: ToolCall,
-        timeout: float | None,
+        timeout: float,  # Make timeout required, not optional
         start: datetime,
         machine: str,
         pid: int,
     ) -> ToolResult:
         """
-        Resolve the correct async entry-point and invoke it with an optional
-        timeout.
+        Resolve the correct async entry-point and invoke it with a guaranteed timeout.
         
         Args:
             tool: Tool instance
             call: Tool call data
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
             start: Start time for the execution
             machine: Machine name
             pid: Process ID
@@ -507,62 +526,46 @@ class InProcessStrategy(ExecutionStrategy):
             )
 
         try:
-            if timeout:
-                # Use a task with explicit cancellation
-                task = asyncio.create_task(fn(**call.arguments))
+            # Always apply timeout
+            logger.debug("Applying %ss timeout to %s", timeout, call.tool)
+            
+            try:
+                result_val = await asyncio.wait_for(fn(**call.arguments), timeout=timeout)
+                
+                end_time = datetime.now(timezone.utc)
+                actual_duration = (end_time - start).total_seconds()
+                logger.debug("%s completed in %.3fs (limit: %ss)", 
+                           call.tool, actual_duration, timeout)
                 
-                try:
-                    # Wait for the task with timeout
-                    result_val = await asyncio.wait_for(task, timeout)
-                    
-                    return ToolResult(
-                        tool=call.tool,
-                        result=result_val,
-                        error=None,
-                        start_time=start,
-                        end_time=datetime.now(timezone.utc),
-                        machine=machine,
-                        pid=pid,
-                    )
-                except asyncio.TimeoutError:
-                    # Cancel the task if it times out
-                    if not task.done():
-                        task.cancel()
-                        
-                        # Wait for cancellation to complete
-                        try:
-                            await task
-                        except asyncio.CancelledError:
-                            # Expected - we just cancelled it
-                            pass
-                        except Exception:
-                            # Ignore any other exceptions during cancellation
-                            pass
-                    
-                    # Return a timeout error
-                    return ToolResult(
-                        tool=call.tool,
-                        result=None,
-                        error=f"Timeout after {timeout}s",
-                        start_time=start,
-                        end_time=datetime.now(timezone.utc),
-                        machine=machine,
-                        pid=pid,
-                    )
-            else:
-                # No timeout
-                result_val = await fn(**call.arguments)
                 return ToolResult(
                     tool=call.tool,
                     result=result_val,
                     error=None,
                     start_time=start,
-                    end_time=datetime.now(timezone.utc),
+                    end_time=end_time,
                     machine=machine,
                     pid=pid,
                 )
+            except asyncio.TimeoutError:
+                # Handle timeout
+                end_time = datetime.now(timezone.utc)
+                actual_duration = (end_time - start).total_seconds()
+                logger.debug("%s timed out after %.3fs (limit: %ss)", 
+                           call.tool, actual_duration, timeout)
+                
+                return ToolResult(
+                    tool=call.tool,
+                    result=None,
+                    error=f"Timeout after {timeout}s",
+                    start_time=start,
+                    end_time=end_time,
+                    machine=machine,
+                    pid=pid,
+                )
+                
         except asyncio.CancelledError:
             # Handle cancellation explicitly
+            logger.debug("%s was cancelled", call.tool)
             return ToolResult(
                 tool=call.tool,
                 result=None,
@@ -574,12 +577,16 @@ class InProcessStrategy(ExecutionStrategy):
             )
         except Exception as exc:
             logger.exception("Error executing %s: %s", call.tool, exc)
+            end_time = datetime.now(timezone.utc)
+            actual_duration = (end_time - start).total_seconds()
+            logger.debug("%s failed after %.3fs: %s", call.tool, actual_duration, exc)
+            
             return ToolResult(
                 tool=call.tool,
                 result=None,
                 error=str(exc),
                 start_time=start,
-                end_time=datetime.now(timezone.utc),
+                end_time=end_time,
                 machine=machine,
                 pid=pid,
             )

chuk_tool_processor/execution/strategies/subprocess_strategy.py

@@ -4,6 +4,8 @@ Subprocess execution strategy - truly runs tools in separate OS processes.
 
 This strategy executes tools in separate Python processes using a process pool,
 providing isolation and potentially better parallelism on multi-core systems.
+
+FIXED: Ensures consistent timeout handling across all execution paths.
 """
 from __future__ import annotations
 
@@ -133,7 +135,7 @@ def _process_worker(
         
         try:
             # Execute the tool with timeout
-            if timeout:
+            if timeout is not None and timeout > 0:
                 result_value = loop.run_until_complete(
                     asyncio.wait_for(execute_fn(**arguments), timeout)
                 )
@@ -192,7 +194,7 @@ class SubprocessStrategy(ExecutionStrategy):
         """
         self.registry = registry
         self.max_workers = max_workers
-        self.default_timeout = default_timeout
+        self.default_timeout = default_timeout or 30.0  # Always have a default
         self.worker_init_timeout = worker_init_timeout
         
         # Process pool (initialized lazily)
@@ -204,6 +206,9 @@ class SubprocessStrategy(ExecutionStrategy):
         self._shutdown_event = asyncio.Event()
         self._shutting_down = False
         
+        logger.debug("SubprocessStrategy initialized with timeout: %ss, max_workers: %d", 
+                    self.default_timeout, max_workers)
+        
         # Register shutdown handler if in main thread
         try:
             loop = asyncio.get_running_loop()
@@ -238,12 +243,12 @@ class SubprocessStrategy(ExecutionStrategy):
                     loop.run_in_executor(self._process_pool, _pool_test_func),
                     timeout=self.worker_init_timeout
                 )
-                logger.info(f"Process pool initialized with {self.max_workers} workers")
+                logger.info("Process pool initialized with %d workers", self.max_workers)
             except Exception as e:
                 # Clean up on initialization error
                 self._process_pool.shutdown(wait=False)
                 self._process_pool = None
-                logger.error(f"Failed to initialize process pool: {e}")
+                logger.error("Failed to initialize process pool: %s", e)
                 raise RuntimeError(f"Failed to initialize process pool: {e}") from e
     
     # ------------------------------------------------------------------ #
@@ -296,12 +301,16 @@ class SubprocessStrategy(ExecutionStrategy):
                 )
                 for call in calls
             ]
+        
+        # Use default_timeout if no timeout specified
+        effective_timeout = timeout if timeout is not None else self.default_timeout
+        logger.debug("Executing %d calls in subprocesses with %ss timeout each", len(calls), effective_timeout)
             
         # Create tasks for each call
         tasks = []
         for call in calls:
             task = asyncio.create_task(self._execute_single_call(
-                call, timeout or self.default_timeout
+                call, effective_timeout  # Always pass concrete timeout
             ))
             self._active_tasks.add(task)
             task.add_done_callback(self._active_tasks.discard)
@@ -342,6 +351,9 @@ class SubprocessStrategy(ExecutionStrategy):
                     pid=os.getpid(),
                 )
             return
+        
+        # Use default_timeout if no timeout specified
+        effective_timeout = timeout if timeout is not None else self.default_timeout
             
         # Create a queue for results
         queue = asyncio.Queue()
@@ -350,7 +362,7 @@ class SubprocessStrategy(ExecutionStrategy):
         pending = set()
         for call in calls:
             task = asyncio.create_task(self._execute_to_queue(
-                call, queue, timeout or self.default_timeout
+                call, queue, effective_timeout  # Always pass concrete timeout
             ))
             self._active_tasks.add(task)
             task.add_done_callback(self._active_tasks.discard)
@@ -372,13 +384,13 @@ class SubprocessStrategy(ExecutionStrategy):
                 try:
                     await task
                 except Exception as e:
-                    logger.exception(f"Error in task: {e}")
+                    logger.exception("Error in task: %s", e)
 
     async def _execute_to_queue(
         self,
         call: ToolCall,
         queue: asyncio.Queue,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required
     ) -> None:
         """Execute a single call and put the result in the queue."""
         result = await self._execute_single_call(call, timeout)
@@ -387,20 +399,22 @@ class SubprocessStrategy(ExecutionStrategy):
     async def _execute_single_call(
         self,
         call: ToolCall,
-        timeout: Optional[float],
+        timeout: float,  # Make timeout required
     ) -> ToolResult:
         """
         Execute a single tool call in a separate process.
         
         Args:
             call: Tool call to execute
-            timeout: Optional timeout in seconds
+            timeout: Timeout in seconds (required)
             
         Returns:
             Tool execution result
         """
         start_time = datetime.now(timezone.utc)
         
+        logger.debug("Executing %s in subprocess with %ss timeout", call.tool, timeout)
+        
         try:
             # Ensure pool is initialized
             await self._ensure_pool()
@@ -429,8 +443,8 @@ class SubprocessStrategy(ExecutionStrategy):
             # Execute in subprocess
             loop = asyncio.get_running_loop()
             
-            # We need to add safety timeout here to handle process crashes
-            safety_timeout = (timeout or self.default_timeout or 60.0) + 5.0
+            # Add safety timeout to handle process crashes (tool timeout + buffer)
+            safety_timeout = timeout + 5.0
             
             try:
                 result_data = await asyncio.wait_for(
@@ -443,7 +457,7 @@ class SubprocessStrategy(ExecutionStrategy):
                             module_name, 
                             class_name, 
                             call.arguments, 
-                            timeout
+                            timeout  # Pass the actual timeout to worker
                         )
                     ),
                     timeout=safety_timeout
@@ -458,25 +472,40 @@ class SubprocessStrategy(ExecutionStrategy):
                     end_time_str = result_data["end_time"]
                     result_data["end_time"] = datetime.fromisoformat(end_time_str)
                 
+                end_time = datetime.now(timezone.utc)
+                actual_duration = (end_time - start_time).total_seconds()
+                
+                if result_data.get("error"):
+                    logger.debug("%s subprocess failed after %.3fs: %s", 
+                               call.tool, actual_duration, result_data["error"])
+                else:
+                    logger.debug("%s subprocess completed in %.3fs (limit: %ss)", 
+                               call.tool, actual_duration, timeout)
+                
                 # Create ToolResult from worker data
                 return ToolResult(
                     tool=result_data.get("tool", call.tool),
                     result=result_data.get("result"),
                     error=result_data.get("error"),
                     start_time=result_data.get("start_time", start_time),
-                    end_time=result_data.get("end_time", datetime.now(timezone.utc)),
+                    end_time=result_data.get("end_time", end_time),
                     machine=result_data.get("machine", os.uname().nodename),
                     pid=result_data.get("pid", os.getpid()),
                 )
                 
             except asyncio.TimeoutError:
                 # This happens if the worker process itself hangs
+                end_time = datetime.now(timezone.utc)
+                actual_duration = (end_time - start_time).total_seconds()
+                logger.debug("%s subprocess timed out after %.3fs (safety limit: %ss)", 
+                           call.tool, actual_duration, safety_timeout)
+                
                 return ToolResult(
                     tool=call.tool,
                     result=None,
                     error=f"Worker process timed out after {safety_timeout}s",
                     start_time=start_time,
-                    end_time=datetime.now(timezone.utc),
+                    end_time=end_time,
                     machine=os.uname().nodename,
                     pid=os.getpid(),
                 )
@@ -500,6 +529,7 @@ class SubprocessStrategy(ExecutionStrategy):
                 
         except asyncio.CancelledError:
             # Handle cancellation
+            logger.debug("%s subprocess was cancelled", call.tool)
             return ToolResult(
                 tool=call.tool,
                 result=None,
@@ -512,13 +542,18 @@ class SubprocessStrategy(ExecutionStrategy):
             
         except Exception as e:
             # Handle any other errors
-            logger.exception(f"Error executing {call.tool} in subprocess: {e}")
+            logger.exception("Error executing %s in subprocess: %s", call.tool, e)
+            end_time = datetime.now(timezone.utc)
+            actual_duration = (end_time - start_time).total_seconds()
+            logger.debug("%s subprocess setup failed after %.3fs: %s", 
+                       call.tool, actual_duration, e)
+            
             return ToolResult(
                 tool=call.tool,
                 result=None,
                 error=f"Error: {str(e)}",
                 start_time=start_time,
-                end_time=datetime.now(timezone.utc),
+                end_time=end_time,
                 machine=os.uname().nodename,
                 pid=os.getpid(),
             )
@@ -531,7 +566,7 @@ class SubprocessStrategy(ExecutionStrategy):
     async def _signal_handler(self, sig: int) -> None:
         """Handle termination signals."""
         signame = signal.Signals(sig).name
-        logger.info(f"Received {signame}, shutting down process pool")
+        logger.info("Received %s, shutting down process pool", signame)
         await self.shutdown()
         
     async def shutdown(self) -> None:
@@ -549,7 +584,7 @@ class SubprocessStrategy(ExecutionStrategy):
         # Cancel all active tasks
         active_tasks = list(self._active_tasks)
         if active_tasks:
-            logger.info(f"Cancelling {len(active_tasks)} active tool executions")
+            logger.info("Cancelling %d active tool executions", len(active_tasks))
             for task in active_tasks:
                 task.cancel()
                 

chuk_tool_processor/mcp/transport/sse_transport.py

@@ -1,6 +1,13 @@
 # chuk_tool_processor/mcp/transport/sse_transport.py
 """
-Server-Sent Events (SSE) transport for MCP communication – implemented with **httpx**.
+Proper MCP SSE transport that follows the standard MCP SSE protocol.
+
+This transport:
+1. Connects to /sse for SSE stream
+2. Listens for 'endpoint' event to get message URL  
+3. Sends MCP initialize handshake FIRST
+4. Only then proceeds with tools/list and tool calls
+5. Handles async responses via SSE message events
 """
 from __future__ import annotations
 
@@ -16,7 +23,7 @@ from .base_transport import MCPBaseTransport
 # --------------------------------------------------------------------------- #
 # Helpers                                                                     #
 # --------------------------------------------------------------------------- #
-DEFAULT_TIMEOUT = 5.0  # seconds
+DEFAULT_TIMEOUT = 30.0  # Longer timeout for real servers
 HEADERS_JSON: Dict[str, str] = {"accept": "application/json"}
 
 
@@ -30,160 +37,399 @@ def _url(base: str, path: str) -> str:
 # --------------------------------------------------------------------------- #
 class SSETransport(MCPBaseTransport):
     """
-    Minimal SSE/REST transport.  It speaks a simple REST dialect:
-
-        GET  /ping                → 200 OK
-        GET  /tools/list          → {"tools": [...]}
-        POST /tools/call          → {"name": ..., "result": ...}
-        GET  /resources/list      → {"resources": [...]}
-        GET  /prompts/list        → {"prompts": [...]}
-        GET  /events              → <text/event-stream>
+    Proper MCP SSE transport that follows the standard protocol:
+    
+    1. GET /sse → Establishes SSE connection
+    2. Waits for 'endpoint' event → Gets message URL
+    3. Sends MCP initialize handshake → Establishes session
+    4. POST to message URL → Sends tool calls
+    5. Waits for async responses via SSE message events
     """
 
-    EVENTS_PATH = "/events"
-
-    # ------------------------------------------------------------------ #
-    # Construction                                                       #
-    # ------------------------------------------------------------------ #
     def __init__(self, url: str, api_key: Optional[str] = None) -> None:
         self.base_url = url.rstrip("/")
         self.api_key = api_key
 
         # httpx client (None until initialise)
         self._client: httpx.AsyncClient | None = None
-        self.session: httpx.AsyncClient | None = None  # ← kept for legacy tests
+        self.session: httpx.AsyncClient | None = None
 
-        # background reader
-        self._reader_task: asyncio.Task | None = None
-        self._incoming_queue: "asyncio.Queue[dict[str, Any]]" = asyncio.Queue()
+        # MCP SSE state
+        self._message_url: Optional[str] = None
+        self._session_id: Optional[str] = None
+        self._sse_task: Optional[asyncio.Task] = None
+        self._connected = asyncio.Event()
+        self._initialized = asyncio.Event()  # NEW: Track MCP initialization
+        
+        # Async message handling
+        self._pending_requests: Dict[str, asyncio.Future] = {}
+        self._message_lock = asyncio.Lock()
 
     # ------------------------------------------------------------------ #
     # Life-cycle                                                         #
     # ------------------------------------------------------------------ #
     async def initialize(self) -> bool:
-        """Open the httpx client and start the /events consumer."""
-        if self._client:  # already initialised
+        """Initialize the MCP SSE transport."""
+        if self._client:
             return True
 
+        headers = {}
+        if self.api_key:
+            headers["authorization"] = self.api_key
+
         self._client = httpx.AsyncClient(
-            headers={"authorization": self.api_key} if self.api_key else None,
+            headers=headers,
             timeout=DEFAULT_TIMEOUT,
         )
-        self.session = self._client  # legacy attribute for tests
+        self.session = self._client
 
-        # spawn reader (best-effort reconnect)
-        self._reader_task = asyncio.create_task(self._consume_events(), name="sse-reader")
+        # Start SSE connection and wait for endpoint
+        self._sse_task = asyncio.create_task(self._handle_sse_connection())
+        
+        try:
+            # Wait for endpoint event (up to 10 seconds)
+            await asyncio.wait_for(self._connected.wait(), timeout=10.0)
+            
+            # NEW: Send MCP initialize handshake
+            if await self._initialize_mcp_session():
+                return True
+            else:
+                print("❌ MCP initialization failed")
+                return False
+                
+        except asyncio.TimeoutError:
+            print("❌ Timeout waiting for SSE endpoint event")
+            return False
+        except Exception as e:
+            print(f"❌ SSE initialization failed: {e}")
+            return False
+
+    async def _initialize_mcp_session(self) -> bool:
+        """Send the required MCP initialize handshake."""
+        if not self._message_url:
+            print("❌ No message URL available for initialization")
+            return False
+        
+        try:
+            print("🔄 Sending MCP initialize handshake...")
+            
+            # Required MCP initialize message
+            init_message = {
+                "jsonrpc": "2.0",
+                "id": "initialize",
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {
+                        "tools": {},
+                        "resources": {},
+                        "prompts": {},
+                        "sampling": {}
+                    },
+                    "clientInfo": {
+                        "name": "chuk-tool-processor",
+                        "version": "1.0.0"
+                    }
+                }
+            }
+            
+            response = await self._send_message(init_message)
+            
+            if "result" in response:
+                server_info = response["result"]
+                print(f"✅ MCP initialized: {server_info.get('serverInfo', {}).get('name', 'Unknown Server')}")
+                
+                # Send initialized notification (required by MCP spec)
+                notification = {
+                    "jsonrpc": "2.0",
+                    "method": "notifications/initialized"
+                }
+                
+                # Send notification (don't wait for response)
+                await self._send_notification(notification)
+                self._initialized.set()
+                return True
+            else:
+                print(f"❌ MCP initialization failed: {response}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ MCP initialization error: {e}")
+            return False
 
-        # verify connection
-        return await self.send_ping()
+    async def _send_notification(self, notification: Dict[str, Any]) -> None:
+        """Send a JSON-RPC notification (no response expected)."""
+        if not self._client or not self._message_url:
+            return
+            
+        try:
+            headers = {"Content-Type": "application/json"}
+            await self._client.post(
+                self._message_url,
+                json=notification,
+                headers=headers
+            )
+        except Exception as e:
+            print(f"⚠️ Failed to send notification: {e}")
 
     async def close(self) -> None:
-        """Stop background reader and close the httpx client."""
-        if self._reader_task:
-            self._reader_task.cancel()
+        """Close the transport."""
+        # Cancel any pending requests
+        for future in self._pending_requests.values():
+            if not future.done():
+                future.cancel()
+        self._pending_requests.clear()
+        
+        if self._sse_task:
+            self._sse_task.cancel()
             with contextlib.suppress(asyncio.CancelledError):
-                await self._reader_task
-            self._reader_task = None
+                await self._sse_task
+            self._sse_task = None
 
         if self._client:
             await self._client.aclose()
             self._client = None
-            self.session = None  # keep tests happy
+            self.session = None
 
     # ------------------------------------------------------------------ #
-    # Internal helpers                                                   #
+    # SSE Connection Handler                                             #
     # ------------------------------------------------------------------ #
-    async def _get_json(self, path: str) -> Any:
+    async def _handle_sse_connection(self) -> None:
+        """Handle the SSE connection and extract the endpoint URL."""
         if not self._client:
-            raise RuntimeError("Transport not initialised")
-
-        resp = await self._client.get(_url(self.base_url, path), headers=HEADERS_JSON)
-        resp.raise_for_status()
-        return resp.json()
+            return
 
-    async def _post_json(self, path: str, payload: Dict[str, Any]) -> Any:
-        if not self._client:
-            raise RuntimeError("Transport not initialised")
+        try:
+            headers = {
+                "Accept": "text/event-stream",
+                "Cache-Control": "no-cache"
+            }
+            
+            async with self._client.stream(
+                "GET", f"{self.base_url}/sse", headers=headers
+            ) as response:
+                response.raise_for_status()
+                
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+                        
+                    # Parse SSE events
+                    if line.startswith("event: "):
+                        event_type = line[7:].strip()
+                        
+                    elif line.startswith("data: ") and 'event_type' in locals():
+                        data = line[6:].strip()
+                        
+                        if event_type == "endpoint":
+                            # Got the endpoint URL for messages - construct full URL
+                            self._message_url = f"{self.base_url}{data}"
+                            
+                            # Extract session_id if present
+                            if "session_id=" in data:
+                                self._session_id = data.split("session_id=")[1].split("&")[0]
+                            
+                            print(f"✅ Got message endpoint: {self._message_url}")
+                            self._connected.set()
+                            
+                        elif event_type == "message":
+                            # Handle incoming JSON-RPC responses
+                            try:
+                                message = json.loads(data)
+                                await self._handle_incoming_message(message)
+                            except json.JSONDecodeError:
+                                print(f"❌ Failed to parse message: {data}")
+                                
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            print(f"❌ SSE connection failed: {e}")
 
-        resp = await self._client.post(
-            _url(self.base_url, path), json=payload, headers=HEADERS_JSON
-        )
-        resp.raise_for_status()
-        return resp.json()
+    async def _handle_incoming_message(self, message: Dict[str, Any]) -> None:
+        """Handle incoming JSON-RPC response messages."""
+        message_id = message.get("id")
+        if message_id and message_id in self._pending_requests:
+            # Complete the pending request
+            future = self._pending_requests.pop(message_id)
+            if not future.done():
+                future.set_result(message)
 
     # ------------------------------------------------------------------ #
-    # Public API (implements MCPBaseTransport)                           #
+    # MCP Protocol Methods                                               #
     # ------------------------------------------------------------------ #
     async def send_ping(self) -> bool:
-        if not self._client:
-            return False
-        try:
-            await self._get_json("/ping")
-            return True
-        except Exception:  # pragma: no cover
-            return False
+        """Test if we have a working and initialized connection."""
+        return self._message_url is not None and self._initialized.is_set()
 
     async def get_tools(self) -> List[Dict[str, Any]]:
-        if not self._client:
+        """Get available tools using tools/list."""
+        # NEW: Wait for initialization before proceeding
+        if not self._initialized.is_set():
+            print("⏳ Waiting for MCP initialization...")
+            try:
+                await asyncio.wait_for(self._initialized.wait(), timeout=10.0)
+            except asyncio.TimeoutError:
+                print("❌ Timeout waiting for MCP initialization")
+                return []
+        
+        if not self._message_url:
             return []
+            
         try:
-            data = await self._get_json("/tools/list")
-            return data.get("tools", []) if isinstance(data, dict) else []
-        except Exception:  # pragma: no cover
-            return []
+            message = {
+                "jsonrpc": "2.0",
+                "id": "tools_list",
+                "method": "tools/list",
+                "params": {}
+            }
+            
+            response = await self._send_message(message)
+            
+            if "result" in response and "tools" in response["result"]:
+                return response["result"]["tools"]
+                
+        except Exception as e:
+            print(f"❌ Failed to get tools: {e}")
+            
+        return []
 
     async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
-        # ─── tests expect this specific message if *not* initialised ───
-        if not self._client:
-            return {"isError": True, "error": "SSE transport not implemented"}
+        """Execute a tool call using the MCP protocol."""
+        # NEW: Ensure initialization before tool calls
+        if not self._initialized.is_set():
+            return {"isError": True, "error": "MCP session not initialized"}
+            
+        if not self._message_url:
+            return {"isError": True, "error": "No message endpoint available"}
+
+        try:
+            message = {
+                "jsonrpc": "2.0",
+                "id": f"call_{tool_name}",
+                "method": "tools/call",
+                "params": {
+                    "name": tool_name,
+                    "arguments": arguments
+                }
+            }
+            
+            response = await self._send_message(message)
+            
+            # Process MCP response
+            if "error" in response:
+                return {
+                    "isError": True,
+                    "error": response["error"].get("message", "Unknown error")
+                }
+            
+            if "result" in response:
+                result = response["result"]
+                
+                # Handle MCP tool response format
+                if "content" in result:
+                    # Extract content from MCP format
+                    content = result["content"]
+                    if isinstance(content, list) and content:
+                        # Take first content item
+                        first_content = content[0]
+                        if isinstance(first_content, dict) and "text" in first_content:
+                            return {"isError": False, "content": first_content["text"]}
+                    
+                    return {"isError": False, "content": content}
+                
+                # Direct result
+                return {"isError": False, "content": result}
+            
+            return {"isError": True, "error": "No result in response"}
+            
+        except Exception as e:
+            return {"isError": True, "error": str(e)}
+
+    async def _send_message(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Send a JSON-RPC message to the server and wait for async response."""
+        if not self._client or not self._message_url:
+            raise RuntimeError("Transport not properly initialized")
+
+        message_id = message.get("id")
+        if not message_id:
+            raise ValueError("Message must have an ID")
+
+        # Create a future for this request
+        future = asyncio.Future()
+        async with self._message_lock:
+            self._pending_requests[message_id] = future
 
         try:
-            payload = {"name": tool_name, "arguments": arguments}
-            return await self._post_json("/tools/call", payload)
-        except Exception as exc:  # pragma: no cover
-            return {"isError": True, "error": str(exc)}
+            headers = {"Content-Type": "application/json"}
+            
+            # Send the request
+            response = await self._client.post(
+                self._message_url,
+                json=message,
+                headers=headers
+            )
+            
+            # Check if server accepted the request
+            if response.status_code == 202:
+                # Server accepted - wait for async response via SSE
+                try:
+                    response_message = await asyncio.wait_for(future, timeout=30.0)
+                    return response_message
+                except asyncio.TimeoutError:
+                    raise RuntimeError(f"Timeout waiting for response to message {message_id}")
+            else:
+                # Immediate response - parse and return
+                response.raise_for_status()
+                return response.json()
+                
+        finally:
+            # Clean up pending request
+            async with self._message_lock:
+                self._pending_requests.pop(message_id, None)
 
-    # ----------------------- extras used by StreamManager ------------- #
+    # ------------------------------------------------------------------ #
+    # Additional MCP methods                                             #
+    # ------------------------------------------------------------------ #
     async def list_resources(self) -> List[Dict[str, Any]]:
-        if not self._client:
+        """List available resources."""
+        if not self._initialized.is_set() or not self._message_url:
             return []
+            
         try:
-            data = await self._get_json("/resources/list")
-            return data.get("resources", []) if isinstance(data, dict) else []
-        except Exception:  # pragma: no cover
-            return []
+            message = {
+                "jsonrpc": "2.0",
+                "id": "resources_list",
+                "method": "resources/list",
+                "params": {}
+            }
+            
+            response = await self._send_message(message)
+            if "result" in response and "resources" in response["result"]:
+                return response["result"]["resources"]
+                
+        except Exception:
+            pass
+            
+        return []
 
     async def list_prompts(self) -> List[Dict[str, Any]]:
-        if not self._client:
+        """List available prompts."""
+        if not self._initialized.is_set() or not self._message_url:
             return []
+            
         try:
-            data = await self._get_json("/prompts/list")
-            return data.get("prompts", []) if isinstance(data, dict) else []
-        except Exception:  # pragma: no cover
-            return []
-
-    # ------------------------------------------------------------------ #
-    # Background event-stream reader                                     #
-    # ------------------------------------------------------------------ #
-    async def _consume_events(self) -> None:  # pragma: no cover
-        """Continuously read `/events` and push JSON objects onto a queue."""
-        if not self._client:
-            return
-
-        while True:
-            try:
-                async with self._client.stream(
-                    "GET", _url(self.base_url, self.EVENTS_PATH), headers=HEADERS_JSON
-                ) as resp:
-                    resp.raise_for_status()
-                    async for line in resp.aiter_lines():
-                        if not line:
-                            continue
-                        try:
-                            await self._incoming_queue.put(json.loads(line))
-                        except json.JSONDecodeError:
-                            continue
-            except asyncio.CancelledError:
-                break
-            except Exception:
-                await asyncio.sleep(1.0)  # back-off and retry
+            message = {
+                "jsonrpc": "2.0",
+                "id": "prompts_list", 
+                "method": "prompts/list",
+                "params": {}
+            }
+            
+            response = await self._send_message(message)
+            if "result" in response and "prompts" in response["result"]:
+                return response["result"]["prompts"]
+                
+        except Exception:
+            pass
+            
+        return []

{chuk_tool_processor-0.1.7.dist-info → chuk_tool_processor-0.2.dist-info}/METADATA

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

{chuk_tool_processor-0.1.7.dist-info → chuk_tool_processor-0.2.dist-info}/RECORD

@@ -5,8 +5,8 @@ chuk_tool_processor/core/processor.py,sha256=ttEYZTQHctXXiUP8gxAMCCSjbRvyOHojQe_
 chuk_tool_processor/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/execution/tool_executor.py,sha256=NSzmvqGMMyKuVapJAmPr-YtNgGhZI3fcAxhilyGG5kY,12174
 chuk_tool_processor/execution/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_tool_processor/execution/strategies/inprocess_strategy.py,sha256=7Vx8zZ10DSK73tfinahAHElprctIJ1f4WKaR8lJf_Jk,21710
-chuk_tool_processor/execution/strategies/subprocess_strategy.py,sha256=6ByvqHhZ5fenrV7yPNRUHeid-htTiVu05Gn0n6ImXg4,20477
+chuk_tool_processor/execution/strategies/inprocess_strategy.py,sha256=UJIv1g3Z9LpMsTYa9cqJB376StsI0up3cftH4OkqC2I,22582
+chuk_tool_processor/execution/strategies/subprocess_strategy.py,sha256=Rb5GTffl-4dkAQG_zz8wjggqyWznVOr9gReLGHmE2io,22469
 chuk_tool_processor/execution/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/execution/wrappers/caching.py,sha256=1pSyouYT4H7AGkNcK_7wWAIT1d4AKnHJlKBODPO8tZw,20416
 chuk_tool_processor/execution/wrappers/rate_limiting.py,sha256=CBBsI1VLosjo8dZXLeJ3IaclGvy9VdjGyqgunY089KQ,9231
@@ -24,7 +24,7 @@ chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=P9qSgmxoNQbsOlGp83DlLLpN9BsG__
 chuk_tool_processor/mcp/stream_manager.py,sha256=mrmlG54P_xLbDYz_rBjdu-OPMnbi916dgyJg7BrIbjM,12798
 chuk_tool_processor/mcp/transport/__init__.py,sha256=7QQqeSKVKv0N9GcyJuYF0R4FDZeooii5RjggvFFg5GY,296
 chuk_tool_processor/mcp/transport/base_transport.py,sha256=1E29LjWw5vLQrPUDF_9TJt63P5dxAAN7n6E_KiZbGUY,3427
-chuk_tool_processor/mcp/transport/sse_transport.py,sha256=bryH9DOWOn5qr6LsimTriukDC4ix2kuRq6bUv9qOV20,7645
+chuk_tool_processor/mcp/transport/sse_transport.py,sha256=AkEs02ef11dLbBju6mYIZwdMF6zm0tcME_I8LEVSmrQ,16710
 chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=lFXL7p8ca4z_J0RBL8UCHrQ1UH7C2-LbC0tZhpya4V4,7763
 chuk_tool_processor/models/__init__.py,sha256=TC__rdVa0lQsmJHM_hbLDPRgToa_pQT_UxRcPZk6iVw,40
 chuk_tool_processor/models/execution_strategy.py,sha256=UVW35YIeMY2B3mpIKZD2rAkyOPayI6ckOOUALyf0YiQ,2115
@@ -52,7 +52,7 @@ chuk_tool_processor/registry/providers/__init__.py,sha256=eigwG_So11j7WbDGSWaKd3
 chuk_tool_processor/registry/providers/memory.py,sha256=LlpPUU9E7S8Se6Q3VyKxLwpNm82SvmP8GLUmI8MkHxQ,5188
 chuk_tool_processor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/utils/validation.py,sha256=fiTSsHq7zx-kyd755GaFCvPCa-EVasSpg0A1liNHkxU,4138
-chuk_tool_processor-0.1.7.dist-info/METADATA,sha256=vqD7WCOAdv5CWGyQv0Hyp3oxWKGDkslRby84vVdCvLw,10165
-chuk_tool_processor-0.1.7.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-chuk_tool_processor-0.1.7.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.1.7.dist-info/RECORD,,
+chuk_tool_processor-0.2.dist-info/METADATA,sha256=BF2f_DLVJk59zAMransa5Ca3wH5alCzPih6xFsNkscc,10163
+chuk_tool_processor-0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_tool_processor-0.2.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.2.dist-info/RECORD,,

{chuk_tool_processor-0.1.7.dist-info → chuk_tool_processor-0.2.dist-info}/WHEEL

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