chuk-tool-processor 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

chuk_tool_processor/__init__.py

@@ -1 +0,0 @@
-# chuk_tool_processor/__init__.py

chuk_tool_processor/core/processor.py

@@ -72,14 +72,14 @@ class ToolProcessor:
         
         # Apply optional wrappers
         if enable_retries:
-            self.logger.info("Enabling retry logic")
+            self.logger.debug("Enabling retry logic")
             self.executor = RetryableToolExecutor(
                 executor=self.executor,
                 default_config=RetryConfig(max_retries=max_retries)
             )
         
         if enable_rate_limiting:
-            self.logger.info("Enabling rate limiting")
+            self.logger.debug("Enabling rate limiting")
             rate_limiter = RateLimiter(
                 global_limit=global_rate_limit,
                 tool_limits=tool_rate_limits
@@ -90,7 +90,7 @@ class ToolProcessor:
             )
         
         if enable_caching:
-            self.logger.info("Enabling result caching")
+            self.logger.debug("Enabling result caching")
             cache = InMemoryCache(default_ttl=cache_ttl)
             self.executor = CachingToolExecutor(
                 executor=self.executor,
@@ -116,7 +116,7 @@ class ToolProcessor:
                 for name in parser_names
             ]
         
-        self.logger.info(f"Initialized with {len(self.parsers)} parser plugins")
+        self.logger.debug(f"Initialized with {len(self.parsers)} parser plugins")
     
     async def process_text(
         self,
@@ -139,16 +139,16 @@ class ToolProcessor:
         """
         # Create request context
         with request_logging(request_id) as req_id:
-            self.logger.info(f"Processing text ({len(text)} chars)")
+            self.logger.debug(f"Processing text ({len(text)} chars)")
             
             # Extract tool calls
             calls = await self._extract_tool_calls(text)
             
             if not calls:
-                self.logger.info("No tool calls found")
+                self.logger.debug("No tool calls found")
                 return []
             
-            self.logger.info(f"Found {len(calls)} tool calls")
+            self.logger.debug(f"Found {len(calls)} tool calls")
             
             # Execute tool calls
             with log_context_span("tool_execution", {"num_calls": len(calls)}):

chuk_tool_processor/execution/wrappers/retry.py

@@ -103,7 +103,7 @@ class RetryableToolExecutor:
                 if result.error:
                     last_error = result.error
                     if config.should_retry(attempt, error_str=result.error):
-                        logger.info(
+                        logger.debug(
                             f"Retrying tool {call.tool} after error: {result.error} (attempt {attempt + 1})"
                         )
                         await asyncio.sleep(config.get_delay(attempt))

chuk_tool_processor/logging/__init__.py

@@ -6,14 +6,12 @@ Other modules can continue to import:
 
     from chuk_tool_processor.logging import get_logger, log_context_span, ...
 """
-
 from __future__ import annotations
-import logging
-import sys
+import logging, sys
 
 from .formatter import StructuredFormatter
-from .context import get_logger, log_context, StructuredAdapter
-from .helpers import log_context_span, request_logging, log_tool_call, metrics
+from .context   import get_logger, log_context, StructuredAdapter
+from .helpers   import log_context_span, request_logging, log_tool_call, metrics
 
 __all__ = [
     "get_logger",
@@ -27,9 +25,9 @@ __all__ = [
 # root logger & handler wiring (done once at import time)
 # --------------------------------------------------------------------------- #
 root_logger = logging.getLogger("chuk_tool_processor")
-root_logger.setLevel(logging.INFO)
+root_logger.setLevel(logging.WARNING)           # ← quieter default
 
 _handler = logging.StreamHandler(sys.stderr)
-_handler.setLevel(logging.INFO)
+_handler.setLevel(logging.WARNING)              # match the logger
 _handler.setFormatter(StructuredFormatter())
 root_logger.addHandler(_handler)

chuk_tool_processor/mcp/__init__.py

@@ -0,0 +1,21 @@
+# chuk_tool_processor/mcp/__init__.py
+"""
+MCP integration for CHUK Tool Processor.
+"""
+from chuk_tool_processor.mcp.transport import MCPBaseTransport, StdioTransport, SSETransport
+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
+
+__all__ = [
+    "MCPBaseTransport",
+    "StdioTransport",
+    "SSETransport",
+    "StreamManager",
+    "MCPTool",
+    "register_mcp_tools",
+    "setup_mcp_stdio",
+    "setup_mcp_sse"
+]

chuk_tool_processor/mcp/mcp_tool.py

@@ -0,0 +1,53 @@
+# chuk_tool_processor/mcp/mcp_tool.py
+"""
+MCP tool that uses StreamManager for execution.
+"""
+
+from typing import Any
+
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+from chuk_tool_processor.logging import get_logger
+
+logger = get_logger("chuk_tool_processor.mcp.mcp_tool")
+
+class MCPTool:
+    """
+    MCP tool that uses StreamManager for execution.
+    
+    This tool handles both namespaced and non-namespaced execution.
+    """
+    
+    def __init__(self, tool_name: str, stream_manager: StreamManager):
+        """
+        Initialize the MCP tool.
+        
+        Args:
+            tool_name: Name of the MCP tool
+            stream_manager: StreamManager instance
+        """
+        self.tool_name = tool_name
+        self.stream_manager = stream_manager
+        
+    async def execute(self, **kwargs: Any) -> Any:
+        """
+        Execute the tool using StreamManager.
+        
+        Args:
+            **kwargs: Tool arguments
+            
+        Returns:
+            Tool result
+        """
+        logger.debug(f"Executing MCP tool {self.tool_name}")
+        
+        result = await self.stream_manager.call_tool(
+            tool_name=self.tool_name,
+            arguments=kwargs
+        )
+        
+        if result.get("isError"):
+            error_msg = result.get("error", "Unknown error")
+            logger.error(f"Error executing MCP tool {self.tool_name}: {error_msg}")
+            raise RuntimeError(error_msg)
+            
+        return result.get("content")

chuk_tool_processor/mcp/register_mcp_tools.py

@@ -0,0 +1,82 @@
+# chuk_tool_processor/mcp/register_mcp_tools.py
+"""
+Registration functions for MCP tools.
+"""
+
+from typing import List, Dict, Any
+
+from chuk_tool_processor.mcp.mcp_tool import MCPTool
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+from chuk_tool_processor.registry.provider import ToolRegistryProvider
+from chuk_tool_processor.logging import get_logger
+
+logger = get_logger("chuk_tool_processor.mcp.register")
+
+
+def register_mcp_tools(
+    stream_manager: StreamManager,
+    namespace: str = "mcp"
+) -> List[str]:
+    """
+    Register MCP tools with the CHUK registry.
+    
+    Args:
+        stream_manager: StreamManager instance
+        namespace: Namespace for the tools
+        
+    Returns:
+        List of registered tool names
+    """
+    registry = ToolRegistryProvider.get_registry()
+    registered_tools = []
+    
+    # Get all tools from StreamManager
+    mcp_tools = stream_manager.get_all_tools()
+    
+    for tool_def in mcp_tools:
+        tool_name = tool_def.get("name")
+        if not tool_name:
+            logger.warning("Tool definition missing name")
+            continue
+            
+        description = tool_def.get("description", f"MCP tool: {tool_name}")
+        
+        try:
+            # Create tool
+            tool = MCPTool(tool_name, stream_manager)
+            
+            # Register with registry under the original name in the given namespace
+            registry.register_tool(
+                tool,
+                name=tool_name,
+                namespace=namespace,
+                metadata={
+                    "description": description,
+                    "is_async": True,
+                    "tags": {"mcp", "remote"},
+                    "argument_schema": tool_def.get("inputSchema", {})
+                }
+            )
+            
+            # Also register the tool in the default namespace with the namespaced name
+            # This allows calling the tool as either "echo" or "stdio.echo" from parsers
+            namespaced_tool_name = f"{namespace}.{tool_name}"
+            registry.register_tool(
+                tool,
+                name=namespaced_tool_name,
+                namespace="default",
+                metadata={
+                    "description": description,
+                    "is_async": True,
+                    "tags": {"mcp", "remote", "namespaced"},
+                    "argument_schema": tool_def.get("inputSchema", {})
+                }
+            )
+            
+            registered_tools.append(tool_name)
+            logger.info(f"Registered MCP tool '{tool_name}' in namespace '{namespace}' (also as '{namespaced_tool_name}' in default)")
+            
+        except Exception as e:
+            logger.error(f"Error registering MCP tool '{tool_name}': {e}")
+    
+    return registered_tools

chuk_tool_processor/mcp/setup_mcp_sse.py

@@ -0,0 +1,74 @@
+# chuk_tool_processor/mcp/setup_mcp_sse.py
+"""
+Setup function for SSE transport MCP integration.
+"""
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+from chuk_tool_processor.core.processor import ToolProcessor
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+from chuk_tool_processor.mcp.register_mcp_tools import register_mcp_tools
+from chuk_tool_processor.logging import get_logger
+
+logger = get_logger("chuk_tool_processor.mcp.setup_sse")
+
+
+async def setup_mcp_sse(
+    servers: List[Dict[str, str]],
+    server_names: Optional[Dict[int, str]] = None,
+    default_timeout: float = 10.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 = "mcp"
+) -> tuple[ToolProcessor, StreamManager]:
+    """
+    Set up MCP with SSE transport and CHUK Tool Processor.
+    
+    Args:
+        servers: List of server configurations with "name" and "url" keys
+        server_names: Optional mapping of server indices to names
+        default_timeout: Default timeout for tool execution
+        max_concurrency: Maximum concurrent executions
+        enable_caching: Whether to enable caching
+        cache_ttl: Cache TTL 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 retries
+        max_retries: Maximum retry attempts
+        namespace: Namespace for MCP tools
+        
+    Returns:
+        Tuple of (processor, stream_manager)
+    """
+    # Create and initialize StreamManager with SSE transport
+    stream_manager = await StreamManager.create_with_sse(
+        servers=servers,
+        server_names=server_names
+    )
+    
+    # Register MCP tools
+    registered_tools = register_mcp_tools(stream_manager, namespace)
+    
+    # Create processor
+    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(f"Set up MCP (SSE) with {len(registered_tools)} tools")
+    return processor, stream_manager

chuk_tool_processor/mcp/setup_mcp_stdio.py

@@ -0,0 +1,78 @@
+# chuk_tool_processor/mcp/setup_mcp_stdio.py
+"""
+Setup function for stdio transport MCP integration.
+"""
+from __future__ import annotations
+
+from typing import Dict, List, Optional
+
+from chuk_tool_processor.core.processor import ToolProcessor
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+from chuk_tool_processor.mcp.register_mcp_tools import register_mcp_tools
+from chuk_tool_processor.logging import get_logger
+
+logger = get_logger("chuk_tool_processor.mcp.setup_stdio")
+
+
+async def setup_mcp_stdio(
+    config_file: str,
+    servers: List[str],
+    server_names: Optional[Dict[int, str]] = None,
+    default_timeout: float = 10.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 = "mcp"
+) -> tuple[ToolProcessor, StreamManager]:
+    """
+    Set up MCP with stdio transport and CHUK Tool Processor.
+    
+    Args:
+        config_file: Path to the config file
+        servers: List of server names to connect to
+        server_names: Optional mapping of server indices to names
+        default_timeout: Default timeout for tool execution
+        max_concurrency: Maximum concurrent executions
+        enable_caching: Whether to enable caching
+        cache_ttl: Cache TTL 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 retries
+        max_retries: Maximum retry attempts
+        namespace: Namespace for MCP tools
+        
+    Returns:
+        Tuple of (processor, stream_manager)
+    """
+    # Create and initialize StreamManager with stdio transport
+    stream_manager = await StreamManager.create(
+        config_file=config_file,
+        servers=servers,
+        server_names=server_names,
+        transport_type="stdio"
+    )
+    
+    # Register MCP tools
+    registered_tools = register_mcp_tools(stream_manager, namespace)
+    
+    # Create processor
+    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(f"Set up MCP (stdio) with {len(registered_tools)} tools")
+    return processor, stream_manager

chuk_tool_processor/mcp/stream_manager.py

@@ -0,0 +1,303 @@
+# chuk_tool_processor/mcp/stream_manager.py
+"""
+StreamManager for CHUK Tool Processor.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Dict, List, Optional, Any
+
+# tool processor imports
+from chuk_mcp.config import load_config
+from chuk_tool_processor.mcp.transport import MCPBaseTransport, StdioTransport, SSETransport
+from chuk_tool_processor.logging import get_logger
+
+# logger
+logger = get_logger("chuk_tool_processor.mcp.stream_manager")
+
+class StreamManager:
+    """
+    Manager for MCP server streams with support for multiple transport types.
+    """
+    
+    def __init__(self):
+        """Initialize the StreamManager."""
+        self.transports: Dict[str, MCPBaseTransport] = {}
+        self.server_info: List[Dict[str, Any]] = []
+        self.tool_to_server_map: Dict[str, str] = {}
+        self.server_names: Dict[int, str] = {}
+        self.all_tools: List[Dict[str, Any]] = []
+        self._lock = asyncio.Lock()
+        
+    @classmethod
+    async def create(
+        cls,
+        config_file: str,
+        servers: List[str],
+        server_names: Optional[Dict[int, str]] = None,
+        transport_type: str = "stdio"
+    ) -> StreamManager:
+        """
+        Create and initialize a StreamManager.
+        
+        Args:
+            config_file: Path to the config file
+            servers: List of server names to connect to
+            server_names: Optional mapping of server indices to names
+            transport_type: Transport type ("stdio" or "sse")
+            
+        Returns:
+            Initialized StreamManager
+        """
+        manager = cls()
+        await manager.initialize(config_file, servers, server_names, transport_type)
+        return manager
+        
+    @classmethod
+    async def create_with_sse(
+        cls,
+        servers: List[Dict[str, str]],
+        server_names: Optional[Dict[int, str]] = None
+    ) -> StreamManager:
+        """
+        Create and initialize a StreamManager with SSE transport.
+        
+        Args:
+            servers: List of server configurations with "name" and "url" keys
+            server_names: Optional mapping of server indices to names
+            
+        Returns:
+            Initialized StreamManager
+        """
+        manager = cls()
+        await manager.initialize_with_sse(servers, server_names)
+        return manager
+        
+    async def initialize(
+        self,
+        config_file: str,
+        servers: List[str],
+        server_names: Optional[Dict[int, str]] = None,
+        transport_type: str = "stdio"
+    ) -> None:
+        """
+        Initialize the StreamManager.
+        
+        Args:
+            config_file: Path to the config file
+            servers: List of server names to connect to
+            server_names: Optional mapping of server indices to names
+            transport_type: Transport type ("stdio" or "sse")
+        """
+        async with self._lock:
+            # Store server names mapping
+            self.server_names = server_names or {}
+            
+            # Initialize servers
+            for i, server_name in enumerate(servers):
+                try:
+                    if transport_type == "stdio":
+                        # Load configuration
+                        server_params = await load_config(config_file, server_name)
+                        
+                        # Create transport
+                        transport = StdioTransport(server_params)
+                    elif transport_type == "sse":
+                        # For SSE, we would parse the config differently
+                        # This is just a placeholder
+                        transport = SSETransport("http://localhost:8000")
+                    else:
+                        logger.error(f"Unsupported transport type: {transport_type}")
+                        continue
+                    
+                    # Initialize transport
+                    if not await transport.initialize():
+                        logger.error(f"Failed to initialize transport for server: {server_name}")
+                        continue
+                        
+                    # Store transport
+                    self.transports[server_name] = transport
+                    
+                    # Check server is responsive
+                    ping_result = await transport.send_ping()
+                    status = "Up" if ping_result else "Down"
+                    
+                    # Get available tools
+                    tools = await transport.get_tools()
+                    
+                    # Map tools to server
+                    for tool in tools:
+                        tool_name = tool.get("name")
+                        if tool_name:
+                            self.tool_to_server_map[tool_name] = server_name
+                    
+                    # Add to all tools
+                    self.all_tools.extend(tools)
+                    
+                    # Add server info
+                    self.server_info.append({
+                        "id": i,
+                        "name": server_name,
+                        "tools": len(tools),
+                        "status": status
+                    })
+                    
+                    logger.info(f"Initialized server {server_name} with {len(tools)} tools")
+                    
+                except Exception as e:
+                    logger.error(f"Error initializing server {server_name}: {e}")
+                    
+            logger.info(f"StreamManager initialized with {len(self.transports)} servers and {len(self.all_tools)} tools")
+            
+    async def initialize_with_sse(
+        self,
+        servers: List[Dict[str, str]],
+        server_names: Optional[Dict[int, str]] = None
+    ) -> None:
+        """
+        Initialize the StreamManager with SSE transport.
+        
+        Args:
+            servers: List of server configurations with "name" and "url" keys
+            server_names: Optional mapping of server indices to names
+        """
+        async with self._lock:
+            # Store server names mapping
+            self.server_names = server_names or {}
+            
+            # Initialize servers
+            for i, server_config in enumerate(servers):
+                server_name = server_config.get("name")
+                url = server_config.get("url")
+                api_key = server_config.get("api_key")
+                
+                if not server_name or not url:
+                    logger.error(f"Invalid server configuration: {server_config}")
+                    continue
+                
+                try:
+                    # Create transport
+                    transport = SSETransport(url, api_key)
+                    
+                    # Initialize transport
+                    if not await transport.initialize():
+                        logger.error(f"Failed to initialize SSE transport for server: {server_name}")
+                        continue
+                        
+                    # Store transport
+                    self.transports[server_name] = transport
+                    
+                    # Check server is responsive
+                    ping_result = await transport.send_ping()
+                    status = "Up" if ping_result else "Down"
+                    
+                    # Get available tools
+                    tools = await transport.get_tools()
+                    
+                    # Map tools to server
+                    for tool in tools:
+                        tool_name = tool.get("name")
+                        if tool_name:
+                            self.tool_to_server_map[tool_name] = server_name
+                    
+                    # Add to all tools
+                    self.all_tools.extend(tools)
+                    
+                    # Add server info
+                    self.server_info.append({
+                        "id": i,
+                        "name": server_name,
+                        "tools": len(tools),
+                        "status": status
+                    })
+                    
+                    logger.info(f"Initialized SSE server {server_name} with {len(tools)} tools")
+                    
+                except Exception as e:
+                    logger.error(f"Error initializing SSE server {server_name}: {e}")
+            
+            logger.info(f"StreamManager initialized with {len(self.transports)} SSE servers and {len(self.all_tools)} tools")
+    
+    def get_all_tools(self) -> List[Dict[str, Any]]:
+        """
+        Get all available tools.
+        
+        Returns:
+            List of tool definitions
+        """
+        return self.all_tools
+        
+    def get_server_for_tool(self, tool_name: str) -> Optional[str]:
+        """
+        Get the server name for a tool.
+        
+        Args:
+            tool_name: Tool name
+            
+        Returns:
+            Server name or None if not found
+        """
+        return self.tool_to_server_map.get(tool_name)
+        
+    def get_server_info(self) -> List[Dict[str, Any]]:
+        """
+        Get information about all servers.
+        
+        Returns:
+            List of server info dictionaries
+        """
+        return self.server_info
+        
+    async def call_tool(
+        self,
+        tool_name: str,
+        arguments: Dict[str, Any],
+        server_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Call a tool.
+        
+        Args:
+            tool_name: Tool name
+            arguments: Tool arguments
+            server_name: Optional server name override
+            
+        Returns:
+            Tool result
+        """
+        # Get server name
+        if not server_name:
+            server_name = self.get_server_for_tool(tool_name)
+            
+        if not server_name or server_name not in self.transports:
+            return {
+                "isError": True,
+                "error": f"No server found for tool: {tool_name}"
+            }
+            
+        # Get transport
+        transport = self.transports[server_name]
+        
+        # Call tool
+        return await transport.call_tool(tool_name, arguments)
+    
+    async def close(self) -> None:
+        """Close all transports."""
+        close_tasks = []
+        for name, transport in self.transports.items():
+            close_tasks.append(transport.close())
+        
+        if close_tasks:
+            try:
+                await asyncio.gather(*close_tasks)
+            except asyncio.CancelledError:
+                # Ignore cancellation during cleanup
+                pass
+            except Exception as e:
+                logger.error(f"Error closing transports: {e}")
+        
+        self.transports.clear()
+        self.server_info.clear()
+        self.tool_to_server_map.clear()
+        self.all_tools.clear()

chuk_tool_processor/mcp/transport/__init__.py

@@ -0,0 +1,14 @@
+# chuk_tool_processor/mcp/transport/__init__.py
+"""
+MCP transport implementations.
+"""
+
+from .base_transport import MCPBaseTransport
+from .stdio_transport import StdioTransport
+from .sse_transport import SSETransport
+
+__all__ = [
+    "MCPBaseTransport",
+    "StdioTransport",
+    "SSETransport"
+]

chuk_tool_processor/mcp/transport/base_transport.py

@@ -0,0 +1,64 @@
+# chuk_tool_processor/mcp/transport/base_transport.py
+"""
+Abstract transport layer for MCP communication.
+"""
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List
+
+class MCPBaseTransport(ABC):
+    """
+    Abstract base class for MCP transport mechanisms.
+    """
+    
+    @abstractmethod
+    async def initialize(self) -> bool:
+        """
+        Initialize the transport connection.
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        pass
+        
+    @abstractmethod
+    async def send_ping(self) -> bool:
+        """
+        Send a ping message.
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        pass
+        
+    @abstractmethod
+    async def get_tools(self) -> List[Dict[str, Any]]:
+        """
+        Get available tools.
+        
+        Returns:
+            List of tool definitions
+        """
+        pass
+        
+    @abstractmethod
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Call a tool.
+        
+        Args:
+            tool_name: Tool name
+            arguments: Tool arguments
+            
+        Returns:
+            Tool result
+        """
+        pass
+        
+    @abstractmethod
+    async def close(self) -> None:
+        """Close the transport connection."""
+        pass
+
+
+
+   

chuk_tool_processor/mcp/transport/sse_transport.py

@@ -0,0 +1,59 @@
+# chuk_tool_processor/mcp/transport/sse_transport.py
+"""
+Server-Sent Events (SSE) transport for MCP communication.
+"""
+from typing import Any, Dict, List, Optional
+
+# imports
+from .base_transport import MCPBaseTransport
+
+class SSETransport(MCPBaseTransport):
+    """
+    Server-Sent Events (SSE) transport for MCP communication.
+    """
+    
+    def __init__(self, url: str, api_key: Optional[str] = None):
+        """
+        Initialize the SSE transport.
+        
+        Args:
+            url: Server URL
+            api_key: Optional API key
+        """
+        self.url = url
+        self.api_key = api_key
+        self.session = None
+        self.connection_id = None
+        
+    async def initialize(self) -> bool:
+        """
+        Initialize the SSE connection.
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        # TODO: Implement SSE connection logic
+        # This is currently a placeholder
+        import logging
+        logging.info(f"SSE transport not yet implemented for {self.url}")
+        return False
+        
+    async def send_ping(self) -> bool:
+        """Send a ping message."""
+        # TODO: Implement SSE ping logic
+        return False
+        
+    async def get_tools(self) -> List[Dict[str, Any]]:
+        """Get available tools."""
+        # TODO: Implement SSE tool retrieval logic
+        return []
+        
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Call a tool via SSE."""
+        # TODO: Implement SSE tool calling logic
+        return {"isError": True, "error": "SSE transport not implemented"}
+        
+    async def close(self) -> None:
+        """Close the SSE connection."""
+        # TODO: Implement SSE connection closure logic
+        pass

chuk_tool_processor/mcp/transport/stdio_transport.py

@@ -0,0 +1,125 @@
+# chuk_tool_processor/mcp/transport/stdio_transport.py
+from typing import Dict, Any, List, Optional
+from contextlib import AsyncExitStack
+import json
+
+from .base_transport import MCPBaseTransport
+
+# chuk-protocol imports
+from chuk_mcp.mcp_client.transport.stdio.stdio_client import stdio_client
+from chuk_mcp.mcp_client.messages.initialize.send_messages import send_initialize
+from chuk_mcp.mcp_client.messages.ping.send_messages import send_ping
+from chuk_mcp.mcp_client.messages.tools.send_messages import send_tools_call, send_tools_list
+
+
+class StdioTransport(MCPBaseTransport):
+    """
+    Stdio transport for MCP communication.
+    """
+
+    def __init__(self, server_params):
+        self.server_params = server_params
+        self.read_stream = None
+        self.write_stream = None
+        self._context_stack: Optional[AsyncExitStack] = None
+
+    # --------------------------------------------------------------------- #
+    #  Connection management                                                #
+    # --------------------------------------------------------------------- #
+    async def initialize(self) -> bool:
+        try:
+            self._context_stack = AsyncExitStack()
+            await self._context_stack.__aenter__()
+
+            ctx = stdio_client(self.server_params)
+            self.read_stream, self.write_stream = await self._context_stack.enter_async_context(ctx)
+
+            init_result = await send_initialize(self.read_stream, self.write_stream)
+            return bool(init_result)
+
+        except Exception as e:  # pragma: no cover
+            import logging
+
+            logging.error(f"Error initializing stdio transport: {e}")
+            if self._context_stack:
+                try:
+                    await self._context_stack.__aexit__(None, None, None)
+                except Exception:
+                    pass
+            return False
+
+    async def close(self) -> None:
+        if self._context_stack:
+            try:
+                await self._context_stack.__aexit__(None, None, None)
+            except Exception:
+                pass
+        self.read_stream = None
+        self.write_stream = None
+        self._context_stack = None
+
+    # --------------------------------------------------------------------- #
+    #  Utility                                                              #
+    # --------------------------------------------------------------------- #
+    async def send_ping(self) -> bool:
+        if not self.read_stream or not self.write_stream:
+            return False
+        return await send_ping(self.read_stream, self.write_stream)
+
+    async def get_tools(self) -> List[Dict[str, Any]]:
+        if not self.read_stream or not self.write_stream:
+            return []
+        tools_response = await send_tools_list(self.read_stream, self.write_stream)
+        return tools_response.get("tools", [])
+
+    # --------------------------------------------------------------------- #
+    #  Main entry-point                                                     #
+    # --------------------------------------------------------------------- #
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute *tool_name* with *arguments* and normalise the server’s reply.
+
+        The echo-server often returns:
+        {
+            "content": [{"type":"text","text":"{\"message\":\"…\"}"}],
+            "isError": false
+        }
+        We unwrap that so callers just receive either a dict or a plain string.
+        """
+        if not self.read_stream or not self.write_stream:
+            return {"isError": True, "error": "Transport not initialized"}
+
+        try:
+            raw = await send_tools_call(self.read_stream, self.write_stream, tool_name, arguments)
+
+            # Handle explicit error wrapper
+            if "error" in raw:
+                return {"isError": True,
+                        "error": raw["error"].get("message", "Unknown error")}
+
+            # Preferred: servers that put the answer under "result"
+            if "result" in raw:
+                return {"isError": False, "content": raw["result"]}
+
+            # Common echo-server shape: top-level "content" list
+            if "content" in raw:
+                clist = raw["content"]
+                if isinstance(clist, list) and clist:
+                    first = clist[0]
+                    if isinstance(first, dict) and first.get("type") == "text":
+                        text = first.get("text", "")
+                        # Try to parse as JSON; fall back to plain string
+                        try:
+                            parsed = json.loads(text)
+                            return {"isError": False, "content": parsed}
+                        except json.JSONDecodeError:
+                            return {"isError": False, "content": text}
+
+            # Fallback: give caller whatever the server sent
+            return {"isError": False, "content": raw}
+
+        except Exception as e:  # pragma: no cover
+            import logging
+
+            logging.error(f"Error calling tool {tool_name}: {e}")
+            return {"isError": True, "error": str(e)}

{chuk_tool_processor-0.1.1.dist-info → chuk_tool_processor-0.1.3.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: chuk-tool-processor
-Version: 0.1.1
+Version: 0.1.3
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+Requires-Dist: chuk-mcp>=0.1.12
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: openai>=1.76.0
 Requires-Dist: pydantic>=2.11.3
@@ -21,6 +22,7 @@ The CHUK Tool Processor is a Python library designed to handle the execution of
 2. **Executing tools** with proper isolation and error handling
 3. **Managing tool executions** with retry logic, caching, and rate limiting
 4. **Monitoring tool usage** with comprehensive logging
+5. **MCP (Model Context Protocol) Integration** for remote tool execution
 
 ## Features
 
@@ -34,6 +36,7 @@ The CHUK Tool Processor is a Python library designed to handle the execution of
 - **Retry Logic**: Automatically retry transient failures with exponential backoff
 - **Structured Logging**: Comprehensive logging system for debugging and monitoring
 - **Plugin Discovery**: Dynamically discover and load plugins from packages
+- **MCP Integration**: Connect to and execute remote tools via Model Context Protocol
 
 ## Installation
 
@@ -101,6 +104,159 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+## MCP Integration
+
+The CHUK Tool Processor supports Model Context Protocol (MCP) for connecting to remote tool servers. This enables distributed tool execution and integration with third-party services.
+
+### MCP with Stdio Transport
+
+```python
+import asyncio
+from chuk_tool_processor.mcp import setup_mcp_stdio
+
+async def main():
+    # Configure MCP server
+    config_file = "server_config.json"
+    servers = ["echo", "calculator", "search"]
+    server_names = {0: "echo", 1: "calculator", 2: "search"}
+    
+    # Setup MCP with stdio transport
+    processor, stream_manager = await setup_mcp_stdio(
+        config_file=config_file,
+        servers=servers,
+        server_names=server_names,
+        namespace="mcp",  # All tools will be registered under this namespace
+        enable_caching=True,
+        enable_retries=True
+    )
+    
+    # Process text with MCP tool calls
+    llm_text = """
+    Let me echo your message using the MCP server.
+    
+    <tool name="mcp.echo" args='{"message": "Hello from MCP!"}'/>
+    """
+    
+    results = await processor.process_text(llm_text)
+    
+    for result in results:
+        print(f"Tool: {result.tool}")
+        print(f"Result: {result.result}")
+    
+    # Clean up
+    await stream_manager.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### MCP Server Configuration
+
+Create a server configuration file (`server_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "echo": {
+      "command": "uv",
+      "args": ["--directory", "/path/to/echo-server", "run", "src/echo_server/main.py"]
+    },
+    "calculator": {
+      "command": "node",
+      "args": ["/path/to/calculator-server/index.js"]
+    },
+    "search": {
+      "command": "python",
+      "args": ["/path/to/search-server/main.py"]
+    }
+  }
+}
+```
+
+### Namespaced Tool Access
+
+MCP tools are automatically registered in both their namespace and the default namespace:
+
+```python
+# These are equivalent:
+<tool name="echo" args='{"message": "Hello"}'/>
+<tool name="mcp.echo" args='{"message": "Hello"}'/>
+```
+
+### MCP with SSE Transport
+
+```python
+import asyncio
+from chuk_tool_processor.mcp import setup_mcp_sse
+
+async def main():
+    # Configure SSE servers
+    sse_servers = [
+        {
+            "name": "weather",
+            "url": "https://api.example.com/sse/weather",
+            "api_key": "your_api_key"
+        },
+        {
+            "name": "geocoding",
+            "url": "https://api.example.com/sse/geocoding"
+        }
+    ]
+    
+    # Setup MCP with SSE transport
+    processor, stream_manager = await setup_mcp_sse(
+        servers=sse_servers,
+        server_names={0: "weather", 1: "geocoding"},
+        namespace="remote",
+        enable_caching=True
+    )
+    
+    # Process tool calls
+    llm_text = """
+    Get the weather for New York.
+    
+    <tool name="remote.weather" args='{"location": "New York", "units": "imperial"}'/>
+    """
+    
+    results = await processor.process_text(llm_text)
+    
+    await stream_manager.close()
+```
+
+### MCP Stream Manager
+
+The `StreamManager` class handles all MCP communication:
+
+```python
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+
+# Create and initialize
+stream_manager = await StreamManager.create(
+    config_file="config.json",
+    servers=["echo", "search"],
+    transport_type="stdio"
+)
+
+# Get available tools
+tools = stream_manager.get_all_tools()
+for tool in tools:
+    print(f"Tool: {tool['name']}")
+
+# Get server information
+server_info = stream_manager.get_server_info()
+for server in server_info:
+    print(f"Server: {server['name']}, Status: {server['status']}")
+
+# Call a tool directly
+result = await stream_manager.call_tool(
+    tool_name="echo",
+    arguments={"message": "Hello"}
+)
+
+# Clean up
+await stream_manager.close()
+```
+
 ## Advanced Usage
 
 ### Using Decorators for Tool Configuration
@@ -259,11 +415,16 @@ The tool processor has several key components organized into a modular structure
    - `plugins/discovery.py`: Plugin discovery mechanism
    - `plugins/parsers/`: Parser plugins for different formats
 
-5. **Utils**: Shared utilities
+5. **MCP Integration**: Model Context Protocol support
+   - `mcp/stream_manager.py`: Manages MCP server connections
+   - `mcp/transport/`: Transport implementations (stdio, SSE)
+   - `mcp/setup_mcp_*.py`: Easy setup functions for MCP integration
+
+6. **Utils**: Shared utilities
    - `utils/logging.py`: Structured logging system
    - `utils/validation.py`: Argument and result validation
 
-6. **Core**: Central components
+7. **Core**: Central components
    - `core/processor.py`: Main processor for handling tool calls
    - `core/exceptions.py`: Exception hierarchy
 
@@ -274,6 +435,8 @@ The repository includes several example scripts:
 - `examples/tool_registry_example.py`: Demonstrates tool registration and usage
 - `examples/plugin_example.py`: Shows how to create and use custom plugins
 - `examples/tool_calling_example_usage.py`: Basic example demonstrating tool execution
+- `examples/mcp_stdio_example.py`: MCP stdio transport demonstration
+- `examples/mcp_stdio_example_calling_usage.py`: Complete MCP integration example
 
 Run examples with:
 
@@ -287,6 +450,9 @@ uv run examples/plugin_example.py
 # Tool execution example
 uv run examples/tool_calling_example_usage.py
 
+# MCP example
+uv run examples/mcp_stdio_example.py
+
 # Enable debug logging
 LOGLEVEL=DEBUG uv run examples/tool_calling_example_usage.py
 ```

{chuk_tool_processor-0.1.1.dist-info → chuk_tool_processor-0.1.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
-chuk_tool_processor/__init__.py,sha256=a4pDi8hta4hjhijLGcv3vlWL8iu3F9EynkmB3si7-hg,33
+chuk_tool_processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/core/__init__.py,sha256=slM7pZna88tyZrF3KtN22ApYyCqGNt5Yscv-knsLOOA,38
 chuk_tool_processor/core/exceptions.py,sha256=h4zL1jpCY1Ud1wT8xDeMxZ8GR8ttmkObcv36peUHJEA,1571
-chuk_tool_processor/core/processor.py,sha256=RbHNFYpzn7hhjBXwqPOdRvTGWky4z8tT7k672nwRE0s,10158
+chuk_tool_processor/core/processor.py,sha256=ud7ezONnUFh_aDSapiBGNx-LtZfhAFpYjFuw2m_tFXk,10165
 chuk_tool_processor/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/execution/tool_executor.py,sha256=e1EHE-744uJuB1XeZZF_6VT25Yg1RCd8XI3v8uOrOSo,1794
 chuk_tool_processor/execution/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -10,12 +10,22 @@ chuk_tool_processor/execution/strategies/subprocess_strategy.py,sha256=Er8z7x94E
 chuk_tool_processor/execution/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/execution/wrappers/caching.py,sha256=dA2OULPQ9xCZj-r3ev5LtsCDFDPgoz8tr70YCX5A4Wg,7714
 chuk_tool_processor/execution/wrappers/rate_limiting.py,sha256=pFqD1vLzOtJzsWzpEI7J786gOAbdFY0gVeiO7ElBXbA,4991
-chuk_tool_processor/execution/wrappers/retry.py,sha256=tRIuT5iNAYUY3r9y3shouWCxJZB5VONkBC9qPBaaVdc,6386
-chuk_tool_processor/logging/__init__.py,sha256=YslBwMTCgxboYwnT4w5qX0_BnA0MR62eI8NH9le9G38,1057
+chuk_tool_processor/execution/wrappers/retry.py,sha256=L3lebFWf_IL7DaAhTR541BVIxns7amm5msqYjJcQtnk,6387
+chuk_tool_processor/logging/__init__.py,sha256=kow8qhzuCShXQSpQ4c6OZ0dEok18iMikcYLJTXEluoA,1124
 chuk_tool_processor/logging/context.py,sha256=hQFWGeraHX3DM28JDSiIuhQqep6TBfo1uaLlRRlGMVU,1521
 chuk_tool_processor/logging/formatter.py,sha256=4pO-fLULkD3JPLjZOSiOZPGsjV3c4Ztr5ySda1RAvi4,1754
 chuk_tool_processor/logging/helpers.py,sha256=Fk32BuecWZdyrmv8U0lh4W0AdNx4-gKcCaWBdId_rlI,3569
 chuk_tool_processor/logging/metrics.py,sha256=ti_owuslT-x9cjcbP-_j7jivrlyY-Vb41mVhU-6W-2M,1537
+chuk_tool_processor/mcp/__init__.py,sha256=vR9HHxLpXlKTIIwJJRr3QTmZegcdedR1YKyb46j6FIM,689
+chuk_tool_processor/mcp/mcp_tool.py,sha256=TvZEudgQvaev2jaPw6OGsqAR5GNu6_cPaUCgqiT5ogU,1504
+chuk_tool_processor/mcp/register_mcp_tools.py,sha256=ofE7pEn6sKDH8HWvNamVOaXsitLOaG48M5GhcpqCBbs,2801
+chuk_tool_processor/mcp/setup_mcp_sse.py,sha256=Ep2IKRdH1Y299bCxt9G0NtwnsvguYP6mpraZyUJ8OKU,2643
+chuk_tool_processor/mcp/setup_mcp_stdio.py,sha256=NjTvAFqQHxxN3XubsTgYY3lTrvPVWlnwCzkzbz7WE_M,2747
+chuk_tool_processor/mcp/stream_manager.py,sha256=xdTXDJ08pVpHXvxao0ibXezGqqauMBLXpJhIXgGknOs,10847
+chuk_tool_processor/mcp/transport/__init__.py,sha256=7QQqeSKVKv0N9GcyJuYF0R4FDZeooii5RjggvFFg5GY,296
+chuk_tool_processor/mcp/transport/base_transport.py,sha256=uJcbyHYrw_zpE5Rc9wDo6yT0mmwqwhFXXbHIJxPoOac,1379
+chuk_tool_processor/mcp/transport/sse_transport.py,sha256=BcRRiOEDRiXiVK2rySB0Hm_dITDNHzrCd2h28Yv1r5c,1791
+chuk_tool_processor/mcp/transport/stdio_transport.py,sha256=VxQYbN0jAyeOrQODZtTvityYRYUnbQHz3jc_eMTlv3I,5197
 chuk_tool_processor/models/__init__.py,sha256=TC__rdVa0lQsmJHM_hbLDPRgToa_pQT_UxRcPZk6iVw,40
 chuk_tool_processor/models/execution_strategy.py,sha256=ZPHysmKNHqJmahTtUXAbt1ke09vxy7EhZcsrwTdla8o,508
 chuk_tool_processor/models/tool_call.py,sha256=RZOnx2YczkJN6ym2PLiI4CRzP2qU_5hpMtHxMcFOxY4,298
@@ -41,7 +51,7 @@ chuk_tool_processor/registry/providers/__init__.py,sha256=_0dg4YhyfAV0TXuR_i4ewX
 chuk_tool_processor/registry/providers/memory.py,sha256=29aI5uvykjDmn9ymIukEdUtmTC9SXOAsDu9hw36XF44,4474
 chuk_tool_processor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chuk_tool_processor/utils/validation.py,sha256=7ezn_o-3IHDrzOD3j6ttsAn2s3zS-jIjeBTuqicrs6A,3775
-chuk_tool_processor-0.1.1.dist-info/METADATA,sha256=roW8za1Cw1IKO3ZkzzHYVFzAeFZM2-b8CWKCCwa6Ag0,9300
-chuk_tool_processor-0.1.1.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-chuk_tool_processor-0.1.1.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
-chuk_tool_processor-0.1.1.dist-info/RECORD,,
+chuk_tool_processor-0.1.3.dist-info/METADATA,sha256=lcYGBykoz2doY3Z8cR_SxyvdbXGgmDUUdPzIgLwP8wM,13703
+chuk_tool_processor-0.1.3.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+chuk_tool_processor-0.1.3.dist-info/top_level.txt,sha256=7lTsnuRx4cOW4U2sNJWNxl4ZTt_J1ndkjTbj3pHPY5M,20
+chuk_tool_processor-0.1.3.dist-info/RECORD,,

{chuk_tool_processor-0.1.1.dist-info → chuk_tool_processor-0.1.3.dist-info}/WHEEL

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