chuk-tool-processor 0.6__py3-none-any.whl → 0.6.2__py3-none-any.whl

chuk_tool_processor/mcp/register_mcp_tools.py

@@ -1,55 +1,57 @@
 #!/usr/bin/env python
 # chuk_tool_processor/mcp/register_mcp_tools.py
 """
-Discover the remote MCP tools exposed by a :class:`~chuk_tool_processor.mcp.stream_manager.StreamManager`
-instance and register them in the local CHUK registry.
+Discover the remote MCP tools exposed by a StreamManager and register them locally.
 
-The helper is now **async-native** - call it with ``await``.
+CLEAN & SIMPLE: Just the essentials - create MCPTool wrappers for remote tools.
 """
 
 from __future__ import annotations
 
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from chuk_tool_processor.logging import get_logger
-from chuk_tool_processor.mcp.mcp_tool import MCPTool
+from chuk_tool_processor.mcp.mcp_tool import MCPTool, RecoveryConfig
 from chuk_tool_processor.mcp.stream_manager import StreamManager
 from chuk_tool_processor.registry.provider import ToolRegistryProvider
 
 logger = get_logger("chuk_tool_processor.mcp.register")
 
 
-# --------------------------------------------------------------------------- #
-# public API
-# --------------------------------------------------------------------------- #
 async def register_mcp_tools(
     stream_manager: StreamManager,
     namespace: str = "mcp",
+    *,
+    # Optional resilience configuration
+    default_timeout: float = 30.0,
+    enable_resilience: bool = True,
+    recovery_config: Optional[RecoveryConfig] = None,
 ) -> List[str]:
     """
-    Pull the *remote* tool catalogue from *stream_manager* and create a local
-    async wrapper (:class:`MCPTool`) for each entry.
+    Pull the remote tool catalogue and create local MCPTool wrappers.
 
     Parameters
     ----------
     stream_manager
-        An **initialised** :class:`~chuk_tool_processor.mcp.stream_manager.StreamManager`.
+        An initialised StreamManager.
     namespace
-        All tools are registered twice:
-
-        * under their original name in *namespace* (e.g. ``"mcp.echo"``), and
-        * mirrored into the ``"default"`` namespace as ``"{namespace}.{name}"``
-          so that parsers may reference them unambiguously.
+        Tools are registered under their original name in the specified namespace.
+    default_timeout
+        Default timeout for tool execution
+    enable_resilience
+        Whether to enable resilience features (circuit breaker, retries)
+    recovery_config
+        Optional custom recovery configuration
 
     Returns
     -------
     list[str]
-        The *plain* tool names that were registered (duplicates are ignored).
+        The tool names that were registered.
     """
     registry = await ToolRegistryProvider.get_registry()
     registered: List[str] = []
 
-    # 1️⃣  ask the stream-manager for its catalogue
+    # Get the remote tool catalogue
     mcp_tools: List[Dict[str, Any]] = stream_manager.get_all_tools()
 
     for tool_def in mcp_tools:
@@ -67,9 +69,15 @@ async def register_mcp_tools(
         }
 
         try:
-            wrapper = MCPTool(tool_name, stream_manager)
+            # Create MCPTool wrapper with optional resilience configuration
+            wrapper = MCPTool(
+                tool_name=tool_name,
+                stream_manager=stream_manager,
+                default_timeout=default_timeout,
+                enable_resilience=enable_resilience,
+                recovery_config=recovery_config,
+            )
 
-            # ── primary registration ──────────────────────────────────────
             await registry.register_tool(
                 wrapper,
                 name=tool_name,
@@ -77,24 +85,63 @@ async def register_mcp_tools(
                 metadata=meta,
             )
 
-            # ── mirror into "default" namespace with dotted name ──────────
-            dotted_name = f"{namespace}.{tool_name}"
-            await registry.register_tool(
-                wrapper,
-                name=dotted_name,
-                namespace="default",
-                metadata={**meta, "tags": meta["tags"] | {"namespaced"}},
-            )
-
             registered.append(tool_name)
             logger.debug(
-                "MCP tool '%s' registered (as '%s' & '%s')",
+                "MCP tool '%s' registered as '%s:%s'",
+                tool_name,
+                namespace,
                 tool_name,
-                f"{namespace}:{tool_name}",
-                f"default:{dotted_name}",
             )
-        except Exception as exc:  # noqa: BLE001
+        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))
     return registered
+
+
+async def update_mcp_tools_stream_manager(
+    namespace: str,
+    new_stream_manager: Optional[StreamManager],
+) -> int:
+    """
+    Update the StreamManager reference for all MCP tools in a namespace.
+    
+    Useful for reconnecting tools after StreamManager recovery at the service level.
+    
+    Parameters
+    ----------
+    namespace
+        The namespace containing MCP tools to update
+    new_stream_manager
+        The new StreamManager to use, or None to disconnect
+        
+    Returns
+    -------
+    int
+        Number of tools updated
+    """
+    registry = await ToolRegistryProvider.get_registry()
+    updated_count = 0
+    
+    try:
+        # List all tools in the namespace
+        all_tools = await registry.list_tools()
+        namespace_tools = [name for ns, name in all_tools if ns == namespace]
+        
+        for tool_name in namespace_tools:
+            try:
+                tool = await registry.get_tool(tool_name, namespace)
+                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}'")
+            except Exception as e:
+                logger.warning(f"Failed to update StreamManager for tool '{namespace}:{tool_name}': {e}")
+        
+        action = "connected" if new_stream_manager else "disconnected"
+        logger.info(f"StreamManager {action} for {updated_count} tools in namespace '{namespace}'")
+        
+    except Exception as e:
+        logger.error(f"Failed to update tools in namespace '{namespace}': {e}")
+    
+    return updated_count