chuk-tool-processor 0.5.2__tar.gz → 0.6__tar.gz

{chuk_tool_processor-0.5.2 → chuk_tool_processor-0.6}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.5.2
+Version: 0.6
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: chuk-mcp>=0.2.3
+Requires-Dist: chuk-mcp>=0.5
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: pydantic>=2.11.3
 Requires-Dist: uuid>=1.30

{chuk_tool_processor-0.5.2 → chuk_tool_processor-0.6}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chuk-tool-processor"
-version = "0.5.2"
+version = "0.6"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-    "chuk-mcp>=0.2.3",
+    "chuk-mcp>=0.5",
     "dotenv>=0.9.9",
     "pydantic>=2.11.3",
     "uuid>=1.30",

{chuk_tool_processor-0.5.2 → chuk_tool_processor-0.6}/src/chuk_tool_processor/execution/wrappers/retry.py

@@ -2,7 +2,7 @@
 """
 Async-native retry wrapper for tool execution.
 
-Adds exponential–back-off retry logic and *deadline-aware* timeout handling so a
+Adds exponential-back-off retry logic and *deadline-aware* timeout handling so a
 `timeout=` passed by callers is treated as the **total wall-clock budget** for
 all attempts of a single tool call.
 """

{chuk_tool_processor-0.5.2 → chuk_tool_processor-0.6}/src/chuk_tool_processor/mcp/__init__.py

@@ -1,21 +1,34 @@
 # chuk_tool_processor/mcp/__init__.py
 """
 MCP integration for CHUK Tool Processor.
+
+Updated to support the latest MCP transports:
+- STDIO (process-based)
+- SSE (Server-Sent Events)
+- HTTP Streamable (modern replacement for SSE, spec 2025-03-26)
 """
-from chuk_tool_processor.mcp.transport import MCPBaseTransport, StdioTransport, SSETransport
+from chuk_tool_processor.mcp.transport import (
+    MCPBaseTransport, 
+    StdioTransport, 
+    SSETransport, 
+    HTTPStreamableTransport
+)
 from chuk_tool_processor.mcp.stream_manager import StreamManager
 from chuk_tool_processor.mcp.mcp_tool import MCPTool
 from chuk_tool_processor.mcp.register_mcp_tools import register_mcp_tools
 from chuk_tool_processor.mcp.setup_mcp_stdio import setup_mcp_stdio
 from chuk_tool_processor.mcp.setup_mcp_sse import setup_mcp_sse
+from chuk_tool_processor.mcp.setup_mcp_http_streamable import setup_mcp_http_streamable
 
 __all__ = [
     "MCPBaseTransport",
-    "StdioTransport",
+    "StdioTransport", 
     "SSETransport",
+    "HTTPStreamableTransport",
     "StreamManager",
     "MCPTool",
     "register_mcp_tools",
     "setup_mcp_stdio",
-    "setup_mcp_sse"
+    "setup_mcp_sse",
+    "setup_mcp_http_streamable"
 ]

chuk_tool_processor-0.6/src/chuk_tool_processor/mcp/setup_mcp_http_streamable.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+# chuk_tool_processor/mcp/setup_mcp_http_streamable.py
+"""
+Bootstrap helper for MCP over **HTTP Streamable** transport.
+
+The HTTP Streamable transport is the modern replacement for SSE transport
+as of MCP spec 2025-03-26, providing better infrastructure compatibility
+and more flexible response handling.
+
+It:
+
+1. spins up :class:`~chuk_tool_processor.mcp.stream_manager.StreamManager`
+   with the `"http_streamable"` transport,
+2. discovers & registers the remote MCP tools locally, and
+3. returns a ready-to-use :class:`~chuk_tool_processor.core.processor.ToolProcessor`.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Tuple
+
+from chuk_tool_processor.core.processor import ToolProcessor
+from chuk_tool_processor.logging import get_logger
+from chuk_tool_processor.mcp.register_mcp_tools import register_mcp_tools
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+
+logger = get_logger("chuk_tool_processor.mcp.setup_http_streamable")
+
+
+# --------------------------------------------------------------------------- #
+# public helper
+# --------------------------------------------------------------------------- #
+async def setup_mcp_http_streamable(
+    *,
+    servers: List[Dict[str, str]],
+    server_names: Optional[Dict[int, str]] = None,
+    connection_timeout: float = 30.0,
+    default_timeout: float = 30.0,
+    max_concurrency: Optional[int] = None,
+    enable_caching: bool = True,
+    cache_ttl: int = 300,
+    enable_rate_limiting: bool = False,
+    global_rate_limit: Optional[int] = None,
+    tool_rate_limits: Optional[Dict[str, tuple]] = None,
+    enable_retries: bool = True,
+    max_retries: int = 3,
+    namespace: str = "http",
+) -> Tuple[ToolProcessor, StreamManager]:
+    """
+    Initialize HTTP Streamable transport MCP + a :class:`ToolProcessor`.
+
+    This uses the modern HTTP Streamable transport (spec 2025-03-26) which
+    provides better infrastructure compatibility and more flexible response
+    handling compared to the deprecated SSE transport.
+    
+    Call with ``await`` from your async context.
+    
+    Args:
+        servers: List of server configurations with 'name', 'url', and optionally 'api_key' keys
+        server_names: Optional mapping of server indices to names
+        connection_timeout: Timeout for initial HTTP connection setup
+        default_timeout: Default timeout for tool execution
+        max_concurrency: Maximum concurrent operations
+        enable_caching: Whether to enable response caching
+        cache_ttl: Cache time-to-live in seconds
+        enable_rate_limiting: Whether to enable rate limiting
+        global_rate_limit: Global rate limit (requests per minute)
+        tool_rate_limits: Per-tool rate limits
+        enable_retries: Whether to enable automatic retries
+        max_retries: Maximum retry attempts
+        namespace: Namespace for registered tools
+        
+    Returns:
+        Tuple of (ToolProcessor, StreamManager)
+        
+    Example:
+        >>> servers = [
+        ...     {
+        ...         "name": "my_server",
+        ...         "url": "http://localhost:8000",
+        ...         "api_key": "optional-api-key"
+        ...     }
+        ... ]
+        >>> processor, stream_manager = await setup_mcp_http_streamable(
+        ...     servers=servers,
+        ...     namespace="mytools"
+        ... )
+    """
+    # 1️⃣  create & connect the stream-manager with HTTP Streamable transport
+    stream_manager = await StreamManager.create_with_http_streamable(
+        servers=servers,
+        server_names=server_names,
+        connection_timeout=connection_timeout,
+        default_timeout=default_timeout,
+    )
+
+    # 2️⃣  pull the remote tool list and register each one locally
+    registered = await register_mcp_tools(stream_manager, namespace=namespace)
+
+    # 3️⃣  build a processor instance configured to your taste
+    processor = ToolProcessor(
+        default_timeout=default_timeout,
+        max_concurrency=max_concurrency,
+        enable_caching=enable_caching,
+        cache_ttl=cache_ttl,
+        enable_rate_limiting=enable_rate_limiting,
+        global_rate_limit=global_rate_limit,
+        tool_rate_limits=tool_rate_limits,
+        enable_retries=enable_retries,
+        max_retries=max_retries,
+    )
+
+    logger.info(
+        "MCP (HTTP Streamable) initialised - %s tool%s registered into namespace '%s'",
+        len(registered),
+        "" if len(registered) == 1 else "s",
+        namespace,
+    )
+    return processor, stream_manager

{chuk_tool_processor-0.5.2 → chuk_tool_processor-0.6}/src/chuk_tool_processor/mcp/setup_mcp_sse.py

@@ -1,20 +1,18 @@
 #!/usr/bin/env python
 # chuk_tool_processor/mcp/setup_mcp_sse.py
 """
-Utility that wires up:
+Bootstrap helper for MCP over **SSE** transport.
 
-1. A :class:`~chuk_tool_processor.mcp.stream_manager.StreamManager`
-   using the SSE transport.
-2. The remote MCP tools exposed by that manager (via
-   :pyfunc:`~chuk_tool_processor.mcp.register_mcp_tools.register_mcp_tools`).
-3. A fully-featured :class:`~chuk_tool_processor.core.processor.ToolProcessor`
-   instance that can execute those tools - with optional caching,
-   rate-limiting, retries, etc.
+It:
+
+1. spins up :class:`~chuk_tool_processor.mcp.stream_manager.StreamManager`
+   with the `"sse"` transport,
+2. discovers & registers the remote MCP tools locally, and
+3. returns a ready-to-use :class:`~chuk_tool_processor.core.processor.ToolProcessor`.
 """
 
 from __future__ import annotations
 
-import os
 from typing import Dict, List, Optional, Tuple
 
 from chuk_tool_processor.core.processor import ToolProcessor
@@ -28,11 +26,12 @@ logger = get_logger("chuk_tool_processor.mcp.setup_sse")
 # --------------------------------------------------------------------------- #
 # public helper
 # --------------------------------------------------------------------------- #
-async def setup_mcp_sse(  # noqa: C901 - long, but just a config wrapper
+async def setup_mcp_sse(  # noqa: C901 - long but just a config facade
     *,
     servers: List[Dict[str, str]],
     server_names: Optional[Dict[int, str]] = None,
-    default_timeout: float = 10.0,
+    connection_timeout: float = 30.0,  # 🔧 INCREASED DEFAULT: was 10.0
+    default_timeout: float = 30.0,     # 🔧 INCREASED DEFAULT: was 10.0
     max_concurrency: Optional[int] = None,
     enable_caching: bool = True,
     cache_ttl: int = 300,
@@ -41,43 +40,43 @@ async def setup_mcp_sse(  # noqa: C901 - long, but just a config wrapper
     tool_rate_limits: Optional[Dict[str, tuple]] = None,
     enable_retries: bool = True,
     max_retries: int = 3,
-    namespace: str = "mcp",
+    namespace: str = "sse",
 ) -> Tuple[ToolProcessor, StreamManager]:
     """
-    Spin up an SSE-backed *StreamManager*, register all its remote tools,
-    and return a ready-to-go :class:`ToolProcessor`.
+    Initialise SSE-transport MCP + a :class:`ToolProcessor`.
 
-    Everything is **async-native** - call with ``await``.
-    
-    NEW: Automatically detects and adds bearer token from MCP_BEARER_TOKEN
-    environment variable if not explicitly provided in server config.
-    """
+    Call with ``await`` from your async context.
     
-    # NEW: Auto-detect and add bearer token to servers if available
-    bearer_token = os.getenv("MCP_BEARER_TOKEN")
-    if bearer_token:
-        logger.info("Found MCP_BEARER_TOKEN environment variable, adding to server configs")
+    Args:
+        servers: List of server configurations with 'name' and 'url' keys
+        server_names: Optional mapping of server indices to names
+        connection_timeout: Timeout for initial SSE connection setup
+        default_timeout: Default timeout for tool execution
+        max_concurrency: Maximum concurrent operations
+        enable_caching: Whether to enable response caching
+        cache_ttl: Cache time-to-live in seconds
+        enable_rate_limiting: Whether to enable rate limiting
+        global_rate_limit: Global rate limit (requests per minute)
+        tool_rate_limits: Per-tool rate limits
+        enable_retries: Whether to enable automatic retries
+        max_retries: Maximum retry attempts
+        namespace: Namespace for registered tools
         
-        # Add api_key to servers that don't already have it
-        enhanced_servers = []
-        for server in servers:
-            enhanced_server = dict(server)  # Make a copy
-            if "api_key" not in enhanced_server and bearer_token:
-                enhanced_server["api_key"] = bearer_token
-                logger.info("Added bearer token to server: %s", enhanced_server.get("name", "unnamed"))
-            enhanced_servers.append(enhanced_server)
-        servers = enhanced_servers
-    
-    # 1️⃣  connect to the remote MCP servers
+    Returns:
+        Tuple of (ToolProcessor, StreamManager)
+    """
+    # 1️⃣  create & connect the stream-manager with BOTH timeout parameters
     stream_manager = await StreamManager.create_with_sse(
         servers=servers,
         server_names=server_names,
+        connection_timeout=connection_timeout,  # 🔧 ADD THIS LINE
+        default_timeout=default_timeout,        # 🔧 ADD THIS LINE
     )
 
-    # 2️⃣  introspect & register their tools in the local registry
+    # 2️⃣  pull the remote tool list and register each one locally
     registered = await register_mcp_tools(stream_manager, namespace=namespace)
 
-    # 3️⃣  build a processor configured to your liking
+    # 3️⃣  build a processor instance configured to your taste
     processor = ToolProcessor(
         default_timeout=default_timeout,
         max_concurrency=max_concurrency,

{chuk_tool_processor-0.5.2 → chuk_tool_processor-0.6}/src/chuk_tool_processor/mcp/setup_mcp_stdio.py

@@ -48,11 +48,13 @@ async def setup_mcp_stdio(  # noqa: C901 - long but just a config facade
     Call with ``await`` from your async context.
     """
     # 1️⃣  create & connect the stream-manager
+    # FIXED: Pass the default_timeout parameter to StreamManager.create
     stream_manager = await StreamManager.create(
         config_file=config_file,
         servers=servers,
         server_names=server_names,
         transport_type="stdio",
+        default_timeout=default_timeout,  # 🔧 ADD THIS LINE
     )
 
     # 2️⃣  pull the remote tool list and register each one locally
@@ -77,4 +79,4 @@ async def setup_mcp_stdio(  # noqa: C901 - long but just a config facade
         "" if len(registered) == 1 else "s",
         namespace,
     )
-    return processor, stream_manager
+    return processor, stream_manager