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

chuk_tool_processor/mcp/stream_manager.py

@@ -265,7 +265,20 @@ class StreamManager:
         tool_name: str,
         arguments: Dict[str, Any],
         server_name: Optional[str] = None,
+        timeout: Optional[float] = None,  # Add timeout parameter
     ) -> Dict[str, Any]:
+        """
+        Call a tool on the appropriate server with timeout support.
+        
+        Args:
+            tool_name: Name of the tool to call
+            arguments: Arguments to pass to the tool
+            server_name: Optional server name (auto-detected if not provided)
+            timeout: Optional timeout for the call
+            
+        Returns:
+            Dictionary containing the tool result or error
+        """
         server_name = server_name or self.get_server_for_tool(tool_name)
         if not server_name or server_name not in self.transports:
             # wording kept exactly for unit-test expectation
@@ -273,8 +286,27 @@ class StreamManager:
                 "isError": True,
                 "error": f"No server found for tool: {tool_name}",
             }
-        return await self.transports[server_name].call_tool(tool_name, arguments)
-
+        
+        transport = self.transports[server_name]
+        
+        # Apply timeout if specified
+        if timeout is not None:
+            logger.debug("Calling tool '%s' with %ss timeout", tool_name, timeout)
+            try:
+                return await asyncio.wait_for(
+                    transport.call_tool(tool_name, arguments),
+                    timeout=timeout
+                )
+            except asyncio.TimeoutError:
+                logger.warning("Tool '%s' timed out after %ss", tool_name, timeout)
+                return {
+                    "isError": True,
+                    "error": f"Tool call timed out after {timeout}s",
+                }
+        else:
+            # No timeout specified, call directly
+            return await transport.call_tool(tool_name, arguments)
+        
     # ------------------------------------------------------------------ #
     #  shutdown                                                          #
     # ------------------------------------------------------------------ #

chuk_tool_processor/mcp/transport/sse_transport.py

@@ -1,12 +1,20 @@
 # 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
 
 import asyncio
 import contextlib
 import json
+import os
 from typing import Any, Dict, List, Optional
 
 import httpx
@@ -16,7 +24,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 +38,416 @@ 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
+        
+        # NEW: Auto-detect bearer token from environment if not provided
+        if not self.api_key:
+            bearer_token = os.getenv("MCP_BEARER_TOKEN")
+            if bearer_token:
+                self.api_key = bearer_token
+                print(f"🔑 Using bearer token from MCP_BEARER_TOKEN environment variable")
 
         # 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:
+            # NEW: Handle both "Bearer token" and just "token" formats
+            if self.api_key.startswith("Bearer "):
+                headers["Authorization"] = self.api_key
+            else:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+            print(f"🔑 Added Authorization header to httpx client")
+
         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
+                            # NEW: Handle URLs that need trailing slash fix
+                            if "/messages?" in data and "/messages/?" not in data:
+                                data = data.replace("/messages?", "/messages/?", 1)
+                                print(f"🔧 Fixed URL redirect: added trailing slash")
+                            
+                            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.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.1.7
+Version: 0.3
 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.3.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
@@ -17,14 +17,14 @@ chuk_tool_processor/logging/formatter.py,sha256=RhlV6NqBYRBOtytDY49c9Y1J4l02ZjNX
 chuk_tool_processor/logging/helpers.py,sha256=c1mS1sb_rh4bKG0hisyvT7l7cirQfXPSyWeBqmqALRw,5941
 chuk_tool_processor/logging/metrics.py,sha256=s59Au8q0eqGGtJMDqmJBZhbJHh4BWGE1CzT0iI8lRS8,3624
 chuk_tool_processor/mcp/__init__.py,sha256=vR9HHxLpXlKTIIwJJRr3QTmZegcdedR1YKyb46j6FIM,689
-chuk_tool_processor/mcp/mcp_tool.py,sha256=BcFsW0iVXUpE0o-h3u2hYX-88EmfV80nMUoZPyZs_IY,3242
+chuk_tool_processor/mcp/mcp_tool.py,sha256=a7WnBiu8DaSuZ8RI0Ums4M5A7v46RvijlqZa0020wWg,4922
 chuk_tool_processor/mcp/register_mcp_tools.py,sha256=0q73gafC1d0ei_gqNidcUeY7NUg13UZdjhVOKEFcD5o,3642
-chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=FmXyOG9DuH2pzr1TLTFRFLlW23YkFG8rzSdpybtPCJg,2865
+chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=T0V27azQy06yc-RSc5uzEKyhbyAXFT-7O3pIn4k10HQ,3769
 chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=P9qSgmxoNQbsOlGp83DlLLpN9BsG__MhlRsxFplNP3M,2753
-chuk_tool_processor/mcp/stream_manager.py,sha256=mrmlG54P_xLbDYz_rBjdu-OPMnbi916dgyJg7BrIbjM,12798
+chuk_tool_processor/mcp/stream_manager.py,sha256=cRnGiuX2A4vHLP91XxFyNKp9Qbv41ImiqMS9F3UlUoA,14030
 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=RC_m1relMkr5gQCUbH1z9JB2raZHj2MIEIq9Qyfpw0Y,17696
 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.3.dist-info/METADATA,sha256=9D_wk8oZqFKWnxdjMTcqB9K2bIa0QrBk7Ep_kxqBZZ0,10163
+chuk_tool_processor-0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_tool_processor-0.3.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.3.dist-info/RECORD,,

{chuk_tool_processor-0.1.7.dist-info → chuk_tool_processor-0.3.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