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

chuk_tool_processor/mcp/stream_manager.py

@@ -1,6 +1,6 @@
 # chuk_tool_processor/mcp/stream_manager.py
 """
-StreamManager for CHUK Tool Processor - Enhanced with robust shutdown handling
+StreamManager for CHUK Tool Processor - Enhanced with robust shutdown handling and headers support
 """
 from __future__ import annotations
 
@@ -27,12 +27,12 @@ class StreamManager:
     """
     Manager for MCP server streams with support for multiple transport types.
     
-    Enhanced with robust shutdown handling to prevent event loop closure issues.
+    Enhanced with robust shutdown handling and proper headers support.
     
     Updated to support the latest transports:
     - STDIO (process-based)
-    - SSE (Server-Sent Events) 
-    - HTTP Streamable (modern replacement for SSE, spec 2025-03-26)
+    - SSE (Server-Sent Events) with headers support
+    - HTTP Streamable (modern replacement for SSE, spec 2025-03-26) with headers support
     """
 
     def __init__(self) -> None:
@@ -193,14 +193,17 @@ class StreamManager:
                         if isinstance(params, dict) and 'url' in params:
                             sse_url = params['url']
                             api_key = params.get('api_key')
+                            headers = params.get('headers', {})
                         else:
                             sse_url = "http://localhost:8000"
                             api_key = None
+                            headers = {}
                             logger.warning("No URL configured for SSE transport, using default: %s", sse_url)
                         
                         transport = SSETransport(
                             sse_url,
                             api_key,
+                            headers=headers,
                             default_timeout=default_timeout
                         )
                     elif transport_type == "http_streamable":
@@ -210,16 +213,19 @@ class StreamManager:
                         if isinstance(params, dict) and 'url' in params:
                             http_url = params['url']
                             api_key = params.get('api_key')
+                            headers = params.get('headers', {})
                             session_id = params.get('session_id')
                         else:
                             http_url = "http://localhost:8000"
                             api_key = None
+                            headers = {}
                             session_id = None
                             logger.warning("No URL configured for HTTP Streamable transport, using default: %s", http_url)
                         
                         transport = HTTPStreamableTransport(
                             http_url,
                             api_key,
+                            headers=headers,
                             default_timeout=default_timeout,
                             session_id=session_id
                         )
@@ -271,6 +277,7 @@ class StreamManager:
         connection_timeout: float = 10.0,
         default_timeout: float = 30.0,
     ) -> None:
+        """Initialize with SSE transport with headers support."""
         if self._closed:
             raise RuntimeError("Cannot initialize a closed StreamManager")
             
@@ -283,9 +290,15 @@ class StreamManager:
                     logger.error("Bad server config: %s", cfg)
                     continue
                 try:
+                    # FIXED: Extract and pass headers from server config
+                    headers = cfg.get("headers", {})
+                    if headers:
+                        logger.debug("SSE %s: Using configured headers: %s", name, list(headers.keys()))
+                    
                     transport = SSETransport(
                         url, 
                         cfg.get("api_key"),
+                        headers=headers,  # ← FIXED: Pass headers
                         connection_timeout=connection_timeout,
                         default_timeout=default_timeout
                     )
@@ -326,7 +339,7 @@ class StreamManager:
         connection_timeout: float = 30.0,
         default_timeout: float = 30.0,
     ) -> None:
-        """Initialize with HTTP Streamable transport (modern MCP spec 2025-03-26)."""
+        """Initialize with HTTP Streamable transport with headers support."""
         if self._closed:
             raise RuntimeError("Cannot initialize a closed StreamManager")
             
@@ -339,9 +352,15 @@ class StreamManager:
                     logger.error("Bad server config: %s", cfg)
                     continue
                 try:
+                    # FIXED: Extract and pass headers from server config
+                    headers = cfg.get("headers", {})
+                    if headers:
+                        logger.debug("HTTP Streamable %s: Using configured headers: %s", name, list(headers.keys()))
+                    
                     transport = HTTPStreamableTransport(
                         url, 
                         cfg.get("api_key"),
+                        headers=headers,  # ← FIXED: Pass headers (requires HTTPStreamableTransport to be updated)
                         connection_timeout=connection_timeout,
                         default_timeout=default_timeout,
                         session_id=cfg.get("session_id")

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:
@@ -68,8 +106,8 @@ class SSETransport(MCPBaseTransport):
             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"
+            # 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(

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

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

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

@@ -22,11 +22,11 @@ chuk_tool_processor/mcp/register_mcp_tools.py,sha256=s6mQMtZr7dswT2WXDJ84zjOTSi3
 chuk_tool_processor/mcp/setup_mcp_http_streamable.py,sha256=ZJUAj7LL4CRfc-CBl0SQJk0qfW12IuixR-7J2hbQ8S8,4538
 chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=4nf0V6cykAPLxtgsl8RTAYQdVWITUNu_3CIU1vcLjlo,3795
 chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=L8anrx_b5HDsaMqAfbpWaHex084DTd76W8WBf3ClC48,2884
-chuk_tool_processor/mcp/stream_manager.py,sha256=DN58d76J3Xkg9DI3f6EFe9qAG-ZsFa4dW0ARygOZkz4,31527
+chuk_tool_processor/mcp/stream_manager.py,sha256=DU1RkFDqyz9PZVNBgx-LeJM8Tt7hf-_mmYymRvfnqKY,32701
 chuk_tool_processor/mcp/transport/__init__.py,sha256=0DX7m_VvlXPxijc-88_QTLhq4ZqAgUgzBjSMGL9C_lM,963
 chuk_tool_processor/mcp/transport/base_transport.py,sha256=bqId34OMQMxzMXtrKq_86sot0_x0NS_ecaIllsCyy6I,3423
 chuk_tool_processor/mcp/transport/http_streamable_transport.py,sha256=3I3tNYU8r4YqCbNhMCkoucvZc6VS2ulzeUjDe2FbcRk,19108
-chuk_tool_processor/mcp/transport/sse_transport.py,sha256=smsBrKm-U-nOwsWLz_jbAF7MkmQYx9jkZLWyEw3JFRE,15594
+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
@@ -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.5.dist-info/METADATA,sha256=zwmOSBOSAbk0A8oTfY34RokEr7VjtvUaEfWpGmuXSyg,23463
-chuk_tool_processor-0.6.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_tool_processor-0.6.5.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.6.5.dist-info/RECORD,,
+chuk_tool_processor-0.6.7.dist-info/METADATA,sha256=2MPxA-1YJcyWceWZpucwslCce1w7xewFoDZXb1iDi80,23463
+chuk_tool_processor-0.6.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_tool_processor-0.6.7.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.6.7.dist-info/RECORD,,