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

chuk_tool_processor/logging/helpers.py

@@ -58,15 +58,15 @@ async def log_context_span(
     prev = log_context.get_copy()
     log_context.update(span_ctx)
 
-    logger.info("Starting %s", operation)
+    logger.debug("Starting %s", operation)
     try:
         yield
         if log_duration:
-            logger.info(
+            logger.debug(
                 "Completed %s", operation, extra={"context": {"duration": time.time() - start}}
             )
         else:
-            logger.info("Completed %s", operation)
+            logger.debug("Completed %s", operation)
     except Exception as exc:
         logger.exception(
             "Error in %s: %s", operation, exc, extra={"context": {"duration": time.time() - start}}
@@ -97,10 +97,10 @@ async def request_logging(
     logger = get_logger("chuk_tool_processor.request")
     request_id = log_context.start_request(request_id)
     start = time.time()
-    logger.info("Starting request %s", request_id)
+    logger.debug("Starting request %s", request_id)
     try:
         yield request_id
-        logger.info(
+        logger.debug(
             "Completed request %s",
             request_id,
             extra={"context": {"duration": time.time() - start}},
@@ -184,4 +184,4 @@ async def log_tool_call(tool_call: Any, tool_result: Any) -> None:
     if tool_result.error:
         logger.error("Tool %s failed: %s", tool_call.tool, tool_result.error, extra={"context": ctx})
     else:
-        logger.info("Tool %s succeeded in %.3fs", tool_call.tool, dur, extra={"context": ctx})
+        logger.debug("Tool %s succeeded in %.3fs", tool_call.tool, dur, extra={"context": ctx})

chuk_tool_processor/mcp/register_mcp_tools.py

@@ -95,7 +95,7 @@ async def register_mcp_tools(
         except Exception as exc:
             logger.error("Failed to register MCP tool '%s': %s", tool_name, exc)
 
-    logger.info("MCP registration complete - %d tool(s) available", len(registered))
+    logger.debug("MCP registration complete - %d tool(s) available", len(registered))
     return registered
 
 
@@ -134,14 +134,14 @@ async def update_mcp_tools_stream_manager(
                 if tool and hasattr(tool, 'set_stream_manager'):
                     tool.set_stream_manager(new_stream_manager)
                     updated_count += 1
-                    logger.debug(f"Updated StreamManager for tool '{namespace}:{tool_name}'")
+                    logger.debug("Updated StreamManager for tool '%s:%s'", namespace, tool_name)
             except Exception as e:
-                logger.warning(f"Failed to update StreamManager for tool '{namespace}:{tool_name}': {e}")
+                logger.warning("Failed to update StreamManager for tool '%s:%s': %s", namespace, tool_name, e)
         
         action = "connected" if new_stream_manager else "disconnected"
-        logger.info(f"StreamManager {action} for {updated_count} tools in namespace '{namespace}'")
+        logger.debug("StreamManager %s for %d tools in namespace '%s'", action, updated_count, namespace)
         
     except Exception as e:
-        logger.error(f"Failed to update tools in namespace '{namespace}': {e}")
+        logger.error("Failed to update tools in namespace '%s': %s", namespace, e)
     
     return updated_count

chuk_tool_processor/mcp/setup_mcp_http_streamable.py

@@ -110,8 +110,8 @@ async def setup_mcp_http_streamable(
         max_retries=max_retries,
     )
 
-    logger.info(
-        "MCP (HTTP Streamable) initialised - %s tool%s registered into namespace '%s'",
+    logger.debug(
+        "MCP (HTTP Streamable) initialised - %d tool%s registered into namespace '%s'",
         len(registered),
         "" if len(registered) == 1 else "s",
         namespace,

chuk_tool_processor/mcp/setup_mcp_sse.py

@@ -89,8 +89,8 @@ async def setup_mcp_sse(  # noqa: C901 - long but just a config facade
         max_retries=max_retries,
     )
 
-    logger.info(
-        "MCP (SSE) initialised - %s tool%s registered into namespace '%s'",
+    logger.debug(
+        "MCP (SSE) initialised - %d tool%s registered into namespace '%s'",
         len(registered),
         "" if len(registered) == 1 else "s",
         namespace,

chuk_tool_processor/mcp/setup_mcp_stdio.py

@@ -73,8 +73,8 @@ async def setup_mcp_stdio(  # noqa: C901 - long but just a config facade
         max_retries=max_retries,
     )
 
-    logger.info(
-        "MCP (stdio) initialised - %s tool%s registered into namespace '%s'",
+    logger.debug(
+        "MCP (stdio) initialised - %d tool%s registered into namespace '%s'",
         len(registered),
         "" if len(registered) == 1 else "s",
         namespace,

chuk_tool_processor/mcp/stream_manager.py

@@ -73,7 +73,7 @@ class StreamManager:
             )
             return inst
         except asyncio.TimeoutError:
-            logger.error(f"StreamManager initialization timed out after {initialization_timeout}s")
+            logger.error("StreamManager initialization timed out after %ss", initialization_timeout)
             raise RuntimeError(f"StreamManager initialization timed out after {initialization_timeout}s")
 
     @classmethod
@@ -99,7 +99,7 @@ class StreamManager:
             )
             return inst
         except asyncio.TimeoutError:
-            logger.error(f"SSE StreamManager initialization timed out after {initialization_timeout}s")
+            logger.error("SSE StreamManager initialization timed out after %ss", initialization_timeout)
             raise RuntimeError(f"SSE StreamManager initialization timed out after {initialization_timeout}s")
 
     @classmethod
@@ -125,7 +125,7 @@ class StreamManager:
             )
             return inst
         except asyncio.TimeoutError:
-            logger.error(f"HTTP Streamable StreamManager initialization timed out after {initialization_timeout}s")
+            logger.error("HTTP Streamable StreamManager initialization timed out after %ss", initialization_timeout)
             raise RuntimeError(f"HTTP Streamable StreamManager initialization timed out after {initialization_timeout}s")
 
     # ------------------------------------------------------------------ #
@@ -196,7 +196,7 @@ class StreamManager:
                         else:
                             sse_url = "http://localhost:8000"
                             api_key = None
-                            logger.warning(f"No URL configured for SSE transport, using default: {sse_url}")
+                            logger.warning("No URL configured for SSE transport, using default: %s", sse_url)
                         
                         transport = SSETransport(
                             sse_url,
@@ -215,7 +215,7 @@ class StreamManager:
                             http_url = "http://localhost:8000"
                             api_key = None
                             session_id = None
-                            logger.warning(f"No URL configured for HTTP Streamable transport, using default: {http_url}")
+                            logger.warning("No URL configured for HTTP Streamable transport, using default: %s", http_url)
                         
                         transport = HTTPStreamableTransport(
                             http_url,
@@ -252,13 +252,13 @@ class StreamManager:
                             "status": status,
                         }
                     )
-                    logger.info("Initialised %s - %d tool(s)", server_name, len(tools))
+                    logger.debug("Initialised %s - %d tool(s)", server_name, len(tools))
                 except asyncio.TimeoutError:
                     logger.error("Timeout initialising %s", server_name)
                 except Exception as exc:
                     logger.error("Error initialising %s: %s", server_name, exc)
 
-            logger.info(
+            logger.debug(
                 "StreamManager ready - %d server(s), %d tool(s)",
                 len(self.transports),
                 len(self.all_tools),
@@ -307,13 +307,13 @@ class StreamManager:
                     self.server_info.append(
                         {"id": idx, "name": name, "tools": len(tools), "status": status}
                     )
-                    logger.info("Initialised SSE %s - %d tool(s)", name, len(tools))
+                    logger.debug("Initialised SSE %s - %d tool(s)", name, len(tools))
                 except asyncio.TimeoutError:
                     logger.error("Timeout initialising SSE %s", name)
                 except Exception as exc:
                     logger.error("Error initialising SSE %s: %s", name, exc)
 
-            logger.info(
+            logger.debug(
                 "StreamManager ready - %d SSE server(s), %d tool(s)",
                 len(self.transports),
                 len(self.all_tools),
@@ -364,13 +364,13 @@ class StreamManager:
                     self.server_info.append(
                         {"id": idx, "name": name, "tools": len(tools), "status": status}
                     )
-                    logger.info("Initialised HTTP Streamable %s - %d tool(s)", name, len(tools))
+                    logger.debug("Initialised HTTP Streamable %s - %d tool(s)", name, len(tools))
                 except asyncio.TimeoutError:
                     logger.error("Timeout initialising HTTP Streamable %s", name)
                 except Exception as exc:
                     logger.error("Error initialising HTTP Streamable %s: %s", name, exc)
 
-            logger.info(
+            logger.debug(
                 "StreamManager ready - %d HTTP Streamable server(s), %d tool(s)",
                 len(self.transports),
                 len(self.all_tools),
@@ -395,20 +395,20 @@ class StreamManager:
             return []
             
         if server_name not in self.transports:
-            logger.error(f"Server '{server_name}' not found in transports")
+            logger.error("Server '%s' not found in transports", server_name)
             return []
         
         transport = self.transports[server_name]
         
         try:
             tools = await asyncio.wait_for(transport.get_tools(), timeout=10.0)
-            logger.debug(f"Found {len(tools)} tools for server {server_name}")
+            logger.debug("Found %d tools for server %s", len(tools), server_name)
             return tools
         except asyncio.TimeoutError:
-            logger.error(f"Timeout listing tools for server {server_name}")
+            logger.error("Timeout listing tools for server %s", server_name)
             return []
         except Exception as e:
-            logger.error(f"Error listing tools for server {server_name}: {e}")
+            logger.error("Error listing tools for server %s: %s", server_name, e)
             return []
 
     # ------------------------------------------------------------------ #
@@ -541,7 +541,7 @@ class StreamManager:
             self._closed = True
             return
         
-        logger.debug(f"Closing {len(self.transports)} transports...")
+        logger.debug("Closing %d transports...", len(self.transports))
         
         try:
             # Use shield to protect the cleanup operation from cancellation
@@ -551,7 +551,7 @@ class StreamManager:
             logger.debug("Close operation cancelled, performing synchronous cleanup")
             self._sync_cleanup()
         except Exception as e:
-            logger.debug(f"Error during close: {e}")
+            logger.debug("Error during close: %s", e)
             self._sync_cleanup()
         finally:
             self._closed = True
@@ -565,7 +565,7 @@ class StreamManager:
         try:
             await self._concurrent_close(transport_items, close_results)
         except Exception as e:
-            logger.debug(f"Concurrent close failed: {e}, falling back to sequential close")
+            logger.debug("Concurrent close failed: %s, falling back to sequential close", e)
             # Strategy 2: Fall back to sequential close
             await self._sequential_close(transport_items, close_results)
         
@@ -575,7 +575,7 @@ class StreamManager:
         # Log summary
         if close_results:
             successful_closes = sum(1 for _, success, _ in close_results if success)
-            logger.debug(f"Transport cleanup: {successful_closes}/{len(close_results)} closed successfully")
+            logger.debug("Transport cleanup: %d/%d closed successfully", successful_closes, len(close_results))
 
     async def _concurrent_close(self, transport_items: List[Tuple[str, MCPBaseTransport]], close_results: List) -> None:
         """Try to close all transports concurrently."""
@@ -602,10 +602,10 @@ class StreamManager:
                 for i, (name, _) in enumerate(close_tasks):
                     result = results[i] if i < len(results) else None
                     if isinstance(result, Exception):
-                        logger.debug(f"Transport {name} close failed: {result}")
+                        logger.debug("Transport %s close failed: %s", name, result)
                         close_results.append((name, False, str(result)))
                     else:
-                        logger.debug(f"Transport {name} closed successfully")
+                        logger.debug("Transport %s closed successfully", name)
                         close_results.append((name, True, None))
                         
             except asyncio.TimeoutError:
@@ -632,16 +632,16 @@ class StreamManager:
                     self._close_single_transport(name, transport),
                     timeout=0.5  # Short timeout per transport
                 )
-                logger.debug(f"Closed transport: {name}")
+                logger.debug("Closed transport: %s", name)
                 close_results.append((name, True, None))
             except asyncio.TimeoutError:
-                logger.debug(f"Transport {name} close timed out (normal during shutdown)")
+                logger.debug("Transport %s close timed out (normal during shutdown)", name)
                 close_results.append((name, False, "timeout"))
             except asyncio.CancelledError:
-                logger.debug(f"Transport {name} close cancelled during event loop shutdown")
+                logger.debug("Transport %s close cancelled during event loop shutdown", name)
                 close_results.append((name, False, "cancelled"))
             except Exception as e:
-                logger.debug(f"Error closing transport {name}: {e}")
+                logger.debug("Error closing transport %s: %s", name, e)
                 close_results.append((name, False, str(e)))
 
     async def _close_single_transport(self, name: str, transport: MCPBaseTransport) -> None:
@@ -650,9 +650,9 @@ class StreamManager:
             if hasattr(transport, 'close') and callable(transport.close):
                 await transport.close()
             else:
-                logger.debug(f"Transport {name} has no close method")
+                logger.debug("Transport %s has no close method", name)
         except Exception as e:
-            logger.debug(f"Error closing transport {name}: {e}")
+            logger.debug("Error closing transport %s: %s", name, e)
             raise
 
     def _sync_cleanup(self) -> None:
@@ -660,9 +660,9 @@ class StreamManager:
         try:
             transport_count = len(self.transports)
             self._cleanup_state()
-            logger.debug(f"Synchronous cleanup completed for {transport_count} transports")
+            logger.debug("Synchronous cleanup completed for %d transports", transport_count)
         except Exception as e:
-            logger.debug(f"Error during synchronous cleanup: {e}")
+            logger.debug("Error during synchronous cleanup: %s", e)
 
     def _cleanup_state(self) -> None:
         """Clean up internal state synchronously."""
@@ -673,7 +673,7 @@ class StreamManager:
             self.all_tools.clear()
             self.server_names.clear()
         except Exception as e:
-            logger.debug(f"Error during state cleanup: {e}")
+            logger.debug("Error during state cleanup: %s", e)
 
     # ------------------------------------------------------------------ #
     #  backwards-compat: streams helper                                  #

chuk_tool_processor/mcp/transport/http_streamable_transport.py

@@ -107,7 +107,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
         start_time = time.time()
         
         try:
-            logger.info(f"Initializing HTTP Streamable transport to {self.url}")
+            logger.debug("Initializing HTTP Streamable transport to %s", self.url)
             
             # Create HTTP parameters for chuk-mcp (following SSE pattern)
             headers = {}
@@ -117,7 +117,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
             
             if self.session_id:
                 headers["X-Session-ID"] = self.session_id
-                logger.debug(f"Using session ID: {self.session_id}")
+                logger.debug("Using session ID: %s", self.session_id)
             
             http_params = StreamableHTTPParameters(
                 url=self.url,
@@ -154,7 +154,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
                 self._metrics["initialization_time"] = init_time
                 self._metrics["last_ping_time"] = ping_time
                 
-                logger.info(f"HTTP Streamable transport initialized successfully in {init_time:.3f}s (ping: {ping_time:.3f}s)")
+                logger.debug("HTTP Streamable transport initialized successfully in %.3fs (ping: %.3fs)", init_time, ping_time)
                 return True
             else:
                 logger.warning("HTTP connection established but ping failed")
@@ -164,12 +164,12 @@ class HTTPStreamableTransport(MCPBaseTransport):
                 return True
 
         except asyncio.TimeoutError:
-            logger.error(f"HTTP Streamable initialization timed out after {self.connection_timeout}s")
+            logger.error("HTTP Streamable initialization timed out after %ss", self.connection_timeout)
             logger.error("This may indicate the server is not responding to MCP initialization")
             await self._cleanup()
             return False
         except Exception as e:
-            logger.error(f"Error initializing HTTP Streamable transport: {e}", exc_info=True)
+            logger.error("Error initializing HTTP Streamable transport: %s", e, exc_info=True)
             await self._cleanup()
             return False
 
@@ -180,10 +180,11 @@ class HTTPStreamableTransport(MCPBaseTransport):
         
         # Log final metrics (enhanced from SSE)
         if self.enable_metrics and self._metrics["total_calls"] > 0:
-            logger.info(
-                f"HTTP Streamable transport closing - Total calls: {self._metrics['total_calls']}, "
-                f"Success rate: {(self._metrics['successful_calls']/self._metrics['total_calls']*100):.1f}%, "
-                f"Avg response time: {self._metrics['avg_response_time']:.3f}s"
+            logger.debug(
+                "HTTP Streamable 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"]
             )
             
         try:
@@ -192,7 +193,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
                 logger.debug("HTTP Streamable context closed")
                 
         except Exception as e:
-            logger.debug(f"Error during transport close: {e}")
+            logger.debug("Error during transport close: %s", e)
         finally:
             await self._cleanup()
 
@@ -219,14 +220,14 @@ class HTTPStreamableTransport(MCPBaseTransport):
             if self.enable_metrics:
                 ping_time = time.time() - start_time
                 self._metrics["last_ping_time"] = ping_time
-                logger.debug(f"Ping completed in {ping_time:.3f}s: {result}")
+                logger.debug("Ping completed in %.3fs: %s", ping_time, result)
             
             return bool(result)
         except asyncio.TimeoutError:
             logger.error("Ping timed out")
             return False
         except Exception as e:
-            logger.error(f"Ping failed: {e}")
+            logger.error("Ping failed: %s", e)
             return False
 
     async def get_tools(self) -> List[Dict[str, Any]]:
@@ -248,12 +249,12 @@ class HTTPStreamableTransport(MCPBaseTransport):
             elif isinstance(tools_response, list):
                 tools = tools_response
             else:
-                logger.warning(f"Unexpected tools response type: {type(tools_response)}")
+                logger.warning("Unexpected tools response type: %s", type(tools_response))
                 tools = []
             
             if self.enable_metrics:
                 response_time = time.time() - start_time
-                logger.debug(f"Retrieved {len(tools)} tools in {response_time:.3f}s")
+                logger.debug("Retrieved %d tools in %.3fs", len(tools), response_time)
             
             return tools
             
@@ -261,7 +262,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
             logger.error("Get tools timed out")
             return []
         except Exception as e:
-            logger.error(f"Error getting tools: {e}")
+            logger.error("Error getting tools: %s", e)
             return []
 
     async def call_tool(self, tool_name: str, arguments: Dict[str, Any], 
@@ -280,7 +281,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
             self._metrics["total_calls"] += 1
 
         try:
-            logger.debug(f"Calling tool '{tool_name}' with timeout {tool_timeout}s")
+            logger.debug("Calling tool '%s' with timeout %ss", tool_name, tool_timeout)
             
             raw_response = await asyncio.wait_for(
                 send_tools_call(
@@ -299,9 +300,9 @@ class HTTPStreamableTransport(MCPBaseTransport):
                 self._update_metrics(response_time, not result.get("isError", False))
                 
             if not result.get("isError", False):
-                logger.debug(f"Tool '{tool_name}' completed successfully in {response_time:.3f}s")
+                logger.debug("Tool '%s' completed successfully in %.3fs", tool_name, response_time)
             else:
-                logger.warning(f"Tool '{tool_name}' failed in {response_time:.3f}s: {result.get('error', 'Unknown error')}")
+                logger.warning("Tool '%s' failed in %.3fs: %s", tool_name, response_time, result.get('error', 'Unknown error'))
             
             return result
 
@@ -311,7 +312,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
                 self._update_metrics(response_time, False)
                 
             error_msg = f"Tool execution timed out after {tool_timeout}s"
-            logger.error(f"Tool '{tool_name}' {error_msg}")
+            logger.error("Tool '%s' %s", tool_name, error_msg)
             return {
                 "isError": True,
                 "error": error_msg
@@ -322,7 +323,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
                 self._update_metrics(response_time, False)
                 
             error_msg = f"Tool execution failed: {str(e)}"
-            logger.error(f"Tool '{tool_name}' error: {error_msg}")
+            logger.error("Tool '%s' error: %s", tool_name, error_msg)
             return {
                 "isError": True,
                 "error": error_msg
@@ -359,7 +360,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
             logger.error("List resources timed out")
             return {}
         except Exception as e:
-            logger.debug(f"Error listing resources: {e}")
+            logger.debug("Error listing resources: %s", e)
             return {}
 
     async def list_prompts(self) -> Dict[str, Any]:
@@ -381,7 +382,7 @@ class HTTPStreamableTransport(MCPBaseTransport):
             logger.error("List prompts timed out")
             return {}
         except Exception as e:
-            logger.debug(f"Error listing prompts: {e}")
+            logger.debug("Error listing prompts: %s", e)
             return {}
 
     def _normalize_tool_response(self, raw_response: Dict[str, Any]) -> Dict[str, Any]:

chuk_tool_processor/mcp/transport/sse_transport.py

@@ -1,7 +1,7 @@
 # chuk_tool_processor/mcp/transport/sse_transport.py
 """
 Fixed SSE transport that matches your server's actual behavior.
-Based on your working debug script.
+Based on your working debug script with smart URL detection.
 """
 from __future__ import annotations
 
@@ -26,13 +26,21 @@ class SSETransport(MCPBaseTransport):
     """
 
     def __init__(self, url: str, api_key: Optional[str] = None, 
+                 headers: Optional[Dict[str, str]] = None,
                  connection_timeout: float = 30.0, default_timeout: float = 30.0):
         """Initialize SSE transport."""
         self.url = url.rstrip('/')
         self.api_key = api_key
+        self.configured_headers = headers or {}
         self.connection_timeout = connection_timeout
         self.default_timeout = default_timeout
         
+        # DEBUG: Log what we received
+        logger.debug("SSE Transport initialized with:")
+        logger.debug("  URL: %s", self.url)
+        logger.debug("  API Key: %s", "***" if api_key else None)
+        logger.debug("  Headers: %s", {k: v[:10] + "..." if len(v) > 10 else v for k, v in self.configured_headers.items()})
+        
         # State
         self.session_id = None
         self.message_url = None
@@ -48,11 +56,41 @@ class SSETransport(MCPBaseTransport):
         self.sse_response = None
         self.sse_stream_context = None
 
+    def _construct_sse_url(self, base_url: str) -> str:
+        """
+        Construct the SSE endpoint URL from the base URL.
+        
+        Smart detection to avoid double-appending /sse if already present.
+        """
+        # Remove trailing slashes
+        base_url = base_url.rstrip('/')
+        
+        # Check if URL already ends with /sse
+        if base_url.endswith('/sse'):
+            # Already has /sse, use as-is
+            logger.debug("URL already contains /sse endpoint: %s", base_url)
+            return base_url
+        
+        # Append /sse to the base URL
+        sse_url = f"{base_url}/sse"
+        logger.debug("Appending /sse to base URL: %s -> %s", base_url, sse_url)
+        return sse_url
+
     def _get_headers(self) -> Dict[str, str]:
         """Get headers with auth if available."""
         headers = {}
+        
+        # Add configured headers first
+        if self.configured_headers:
+            headers.update(self.configured_headers)
+        
+        # Add API key as Bearer token if provided (this will override any Authorization header)
         if self.api_key:
             headers['Authorization'] = f'Bearer {self.api_key}'
+        
+        # DEBUG: Log what headers we're sending
+        logger.debug("Sending headers: %s", {k: v[:10] + "..." if len(v) > 10 else v for k, v in headers.items()})
+        
         return headers
 
     async def initialize(self) -> bool:
@@ -62,15 +100,15 @@ class SSETransport(MCPBaseTransport):
             return True
         
         try:
-            logger.info("Initializing SSE transport...")
+            logger.debug("Initializing SSE transport...")
             
             # Create HTTP clients
             self.stream_client = httpx.AsyncClient(timeout=self.connection_timeout)
             self.send_client = httpx.AsyncClient(timeout=self.default_timeout)
             
-            # Connect to SSE stream
-            sse_url = f"{self.url}/sse"
-            logger.debug(f"Connecting to SSE: {sse_url}")
+            # Connect to SSE stream with smart URL construction
+            sse_url = self._construct_sse_url(self.url)
+            logger.debug("Connecting to SSE: %s", sse_url)
             
             self.sse_stream_context = self.stream_client.stream(
                 'GET', sse_url, headers=self._get_headers()
@@ -78,10 +116,10 @@ class SSETransport(MCPBaseTransport):
             self.sse_response = await self.sse_stream_context.__aenter__()
             
             if self.sse_response.status_code != 200:
-                logger.error(f"SSE connection failed: {self.sse_response.status_code}")
+                logger.error("SSE connection failed: %s", self.sse_response.status_code)
                 return False
             
-            logger.info("SSE streaming connection established")
+            logger.debug("SSE streaming connection established")
             
             # Start SSE processing task
             self.sse_task = asyncio.create_task(self._process_sse_stream())
@@ -97,7 +135,7 @@ class SSETransport(MCPBaseTransport):
                 logger.error("Failed to get session info from SSE")
                 return False
             
-            logger.info(f"Session ready: {self.session_id}")
+            logger.debug("Session ready: %s", self.session_id)
             
             # Now do MCP initialization
             try:
@@ -111,22 +149,22 @@ class SSETransport(MCPBaseTransport):
                 })
                 
                 if 'error' in init_response:
-                    logger.error(f"Initialize failed: {init_response['error']}")
+                    logger.error("Initialize failed: %s", init_response['error'])
                     return False
                 
                 # Send initialized notification
                 await self._send_notification("notifications/initialized")
                 
                 self._initialized = True
-                logger.info("SSE transport initialized successfully")
+                logger.debug("SSE transport initialized successfully")
                 return True
                 
             except Exception as e:
-                logger.error(f"MCP initialization failed: {e}")
+                logger.error("MCP initialization failed: %s", e)
                 return False
                 
         except Exception as e:
-            logger.error(f"Error initializing SSE transport: {e}", exc_info=True)
+            logger.error("Error initializing SSE transport: %s", e, exc_info=True)
             await self._cleanup()
             return False
 
@@ -148,7 +186,7 @@ class SSETransport(MCPBaseTransport):
                     if 'session_id=' in endpoint_path:
                         self.session_id = endpoint_path.split('session_id=')[1].split('&')[0]
                     
-                    logger.debug(f"Got session info: {self.session_id}")
+                    logger.debug("Got session info: %s", self.session_id)
                     continue
                 
                 # Handle JSON-RPC responses
@@ -170,13 +208,13 @@ class SSETransport(MCPBaseTransport):
                                 future = self.pending_requests.pop(request_id)
                                 if not future.done():
                                     future.set_result(response_data)
-                                    logger.debug(f"Resolved request: {request_id}")
+                                    logger.debug("Resolved request: %s", request_id)
                     
                     except json.JSONDecodeError:
                         pass  # Not JSON, ignore
                         
         except Exception as e:
-            logger.error(f"SSE stream error: {e}")
+            logger.error("SSE stream error: %s", e)
 
     async def _send_request(self, method: str, params: Dict[str, Any] = None, 
                            timeout: Optional[float] = None) -> Dict[str, Any]:
@@ -273,15 +311,15 @@ class SSETransport(MCPBaseTransport):
             response = await self._send_request("tools/list", {})
             
             if 'error' in response:
-                logger.error(f"Error getting tools: {response['error']}")
+                logger.error("Error getting tools: %s", response['error'])
                 return []
             
             tools = response.get('result', {}).get('tools', [])
-            logger.debug(f"Retrieved {len(tools)} tools")
+            logger.debug("Retrieved %d tools", len(tools))
             return tools
             
         except Exception as e:
-            logger.error(f"Error getting tools: {e}")
+            logger.error("Error getting tools: %s", e)
             return []
 
     async def call_tool(self, tool_name: str, arguments: Dict[str, Any], 
@@ -294,7 +332,7 @@ class SSETransport(MCPBaseTransport):
             }
 
         try:
-            logger.debug(f"Calling tool {tool_name} with args: {arguments}")
+            logger.debug("Calling tool %s with args: %s", tool_name, arguments)
             
             response = await self._send_request(
                 "tools/call",
@@ -347,10 +385,10 @@ class SSETransport(MCPBaseTransport):
         except asyncio.TimeoutError:
             return {
                 "isError": True,
-                "error": f"Tool execution timed out"
+                "error": "Tool execution timed out"
             }
         except Exception as e:
-            logger.error(f"Error calling tool {tool_name}: {e}")
+            logger.error("Error calling tool %s: %s", tool_name, e)
             return {
                 "isError": True,
                 "error": str(e)
@@ -364,7 +402,7 @@ class SSETransport(MCPBaseTransport):
         try:
             response = await self._send_request("resources/list", {}, timeout=10.0)
             if 'error' in response:
-                logger.debug(f"Resources not supported: {response['error']}")
+                logger.debug("Resources not supported: %s", response['error'])
                 return {}
             return response.get('result', {})
         except Exception:
@@ -378,7 +416,7 @@ class SSETransport(MCPBaseTransport):
         try:
             response = await self._send_request("prompts/list", {}, timeout=10.0)
             if 'error' in response:
-                logger.debug(f"Prompts not supported: {response['error']}")
+                logger.debug("Prompts not supported: %s", response['error'])
                 return {}
             return response.get('result', {})
         except Exception:

chuk_tool_processor/mcp/transport/stdio_transport.py

@@ -53,7 +53,7 @@ class StdioTransport(MCPBaseTransport):
             return True
             
         try:
-            logger.info("Initializing STDIO transport...")
+            logger.debug("Initializing STDIO transport...")
             self._context = stdio_client(self.server_params)
             self._streams = await self._context.__aenter__()
             
@@ -61,13 +61,13 @@ class StdioTransport(MCPBaseTransport):
             init_result = await send_initialize(*self._streams)
             if init_result:
                 self._initialized = True
-                logger.info("STDIO transport initialized successfully")
+                logger.debug("STDIO transport initialized successfully")
                 return True
             else:
                 await self._cleanup()
                 return False
         except Exception as e:
-            logger.error(f"Error initializing STDIO transport: {e}")
+            logger.error("Error initializing STDIO transport: %s", e)
             await self._cleanup()
             return False
 
@@ -78,7 +78,7 @@ class StdioTransport(MCPBaseTransport):
                 # Simple delegation - the StreamManager now calls this in the correct context
                 await self._context.__aexit__(None, None, None)
             except Exception as e:
-                logger.debug(f"Error during close: {e}")
+                logger.debug("Error during close: %s", e)
             finally:
                 await self._cleanup()
 

{chuk_tool_processor-0.6.4.dist-info → chuk_tool_processor-0.6.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.6.4
+Version: 0.6.6
 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>
@@ -20,7 +20,7 @@ Classifier: Framework :: AsyncIO
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: chuk-mcp>=0.5.1
+Requires-Dist: chuk-mcp>=0.5.2
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: pydantic>=2.11.3
 Requires-Dist: uuid>=1.30

{chuk_tool_processor-0.6.4.dist-info → chuk_tool_processor-0.6.6.dist-info}/RECORD

@@ -14,20 +14,20 @@ chuk_tool_processor/execution/wrappers/retry.py,sha256=giws8cxs7zfR2ZnBz3WYxtr1-
 chuk_tool_processor/logging/__init__.py,sha256=UDFPYU_bzeUUSN8qw3nMpo-FMKXetIi7OYtN3W3iPbg,3794
 chuk_tool_processor/logging/context.py,sha256=69EsAhCiya_4zyivz1uUJAhwo0rXpOoTvePWvaFYIi8,12225
 chuk_tool_processor/logging/formatter.py,sha256=RhlV6NqBYRBOtytDY49c9Y1J4l02ZjNXIgVRn03tfSQ,3061
-chuk_tool_processor/logging/helpers.py,sha256=c1mS1sb_rh4bKG0hisyvT7l7cirQfXPSyWeBqmqALRw,5941
+chuk_tool_processor/logging/helpers.py,sha256=0j-PoFUGyzl9NQ6jJEcS3YKV8AJgs8VwUpYa-6UiWT0,5946
 chuk_tool_processor/logging/metrics.py,sha256=s59Au8q0eqGGtJMDqmJBZhbJHh4BWGE1CzT0iI8lRS8,3624
 chuk_tool_processor/mcp/__init__.py,sha256=QkHgRu_YAjmYNTEYMK4bYILu8KK6b0aziTKvBVTRXvI,1052
 chuk_tool_processor/mcp/mcp_tool.py,sha256=x4zivoBaO7xiepUTN5kfbGcNDNh8rAxvQdgyqduCdRw,17768
-chuk_tool_processor/mcp/register_mcp_tools.py,sha256=BYKO6PddixWq9-KxW_fDyzSLcAPam7_BWNopu9y63bs,4879
-chuk_tool_processor/mcp/setup_mcp_http_streamable.py,sha256=HCzJ8AtlY5dZt4wyOnzR9LHN6TkkEzEhDUpZEFj89Co,4537
-chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=kzvy_tRlu66UN0iX1wBk7qSFXXUt7wPrUQB31XpP-zI,3794
-chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=Pp6ON_fn54uMsX8VyM6-_Lmk1I-uOLG1M65gfjvBj3w,2883
-chuk_tool_processor/mcp/stream_manager.py,sha256=3JSxoVpvAI0_gZt7Njhp0vgpTnh4mLt2Mf2RIE6jUFc,31485
+chuk_tool_processor/mcp/register_mcp_tools.py,sha256=s6mQMtZr7dswT2WXDJ84zjOTSi3cOmtRTGGdLMl15bM,4897
+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=DN58d76J3Xkg9DI3f6EFe9qAG-ZsFa4dW0ARygOZkz4,31527
 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=jtjv3RQU7753hV3QV3ZLhzJlP1w9zOy-_hI7OOjEC9A,19067
-chuk_tool_processor/mcp/transport/sse_transport.py,sha256=BiIQBQUpU5XGdISiPZ_fWvsD54cv2wtFGQ6V9EEpeRM,15571
-chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=QEpaGufkYmebrUZJMXHM-Q-Kj8TkkagorgUEqT17GwM,9095
+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/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.4.dist-info/METADATA,sha256=FHCcpjTWntOR3n5HMq_t2IiI49CfXQAvfCckDp_SWZU,23463
-chuk_tool_processor-0.6.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_tool_processor-0.6.4.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.6.4.dist-info/RECORD,,
+chuk_tool_processor-0.6.6.dist-info/METADATA,sha256=xjCU03q8dyRa8VbmtEO5ZjLiJbWzid6ccy5TItWokSo,23463
+chuk_tool_processor-0.6.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_tool_processor-0.6.6.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.6.6.dist-info/RECORD,,