kailash 0.6.5__py3-none-any.whl → 0.7.0__py3-none-any.whl

kailash/nodes/ai/llm_agent.py

@@ -363,6 +363,13 @@ class LLMAgentNode(Node):
                 default={},
                 description="Configuration for tool execution behavior",
             ),
+            "use_real_mcp": NodeParameter(
+                name="use_real_mcp",
+                type=bool,
+                required=False,
+                default=True,
+                description="Use real MCP tool execution instead of mock execution",
+            ),
         }
 
     def run(self, **kwargs) -> dict[str, Any]:
@@ -629,12 +636,14 @@ class LLMAgentNode(Node):
             )
 
             # Retrieve MCP context if configured
-            mcp_context_data = self._retrieve_mcp_context(mcp_servers, mcp_context)
+            mcp_context_data = self._retrieve_mcp_context(
+                mcp_servers, mcp_context, kwargs
+            )
 
             # Discover MCP tools if enabled
             discovered_mcp_tools = []
             if auto_discover_tools and mcp_servers:
-                discovered_mcp_tools = self._discover_mcp_tools(mcp_servers)
+                discovered_mcp_tools = self._discover_mcp_tools(mcp_servers, kwargs)
                 # Merge MCP tools with existing tools
                 tools = self._merge_tools(tools, discovered_mcp_tools)
 
@@ -976,7 +985,7 @@ class LLMAgentNode(Node):
             return asyncio.run(coro)
 
     def _retrieve_mcp_context(
-        self, mcp_servers: list[dict], mcp_context: list[str]
+        self, mcp_servers: list[dict], mcp_context: list[str], kwargs: dict = None
     ) -> list[dict[str, Any]]:
         """
         Retrieve context from Model Context Protocol (MCP) servers.
@@ -1043,7 +1052,7 @@ class LLMAgentNode(Node):
         context_data = []
 
         # Check if we should use real MCP implementation
-        use_real_mcp = hasattr(self, "_mcp_client") or self._should_use_real_mcp()
+        use_real_mcp = hasattr(self, "_mcp_client") or self._should_use_real_mcp(kwargs)
 
         if use_real_mcp:
             # Use internal MCP client for real implementation
@@ -1224,14 +1233,25 @@ class LLMAgentNode(Node):
 
         return context_data
 
-    def _should_use_real_mcp(self) -> bool:
+    def _should_use_real_mcp(self, kwargs: dict = None) -> bool:
         """Check if real MCP implementation should be used."""
-        # Check environment variable or configuration
         import os
 
-        return os.environ.get("KAILASH_USE_REAL_MCP", "false").lower() == "true"
+        # 1. Check explicit parameter first (highest priority)
+        if kwargs and "use_real_mcp" in kwargs:
+            return kwargs["use_real_mcp"]
 
-    def _discover_mcp_tools(self, mcp_servers: list[dict]) -> list[dict[str, Any]]:
+        # 2. Check environment variable (fallback)
+        env_value = os.environ.get("KAILASH_USE_REAL_MCP", "").lower()
+        if env_value in ("true", "false"):
+            return env_value == "true"
+
+        # 3. Default to True (real MCP execution)
+        return True
+
+    def _discover_mcp_tools(
+        self, mcp_servers: list[dict], kwargs: dict = None
+    ) -> list[dict[str, Any]]:
         """
         Discover available tools from MCP servers.
 
@@ -1244,7 +1264,7 @@ class LLMAgentNode(Node):
         discovered_tools = []
 
         # Check if we should use real MCP implementation
-        use_real_mcp = hasattr(self, "_mcp_client") or self._should_use_real_mcp()
+        use_real_mcp = hasattr(self, "_mcp_client") or self._should_use_real_mcp(kwargs)
 
         if use_real_mcp:
             try:

kailash/nodes/api/__init__.py

@@ -23,7 +23,7 @@ import warnings
 from .auth import APIKeyNode, BasicAuthNode, OAuth2Node
 from .graphql import AsyncGraphQLClientNode, GraphQLClientNode
 from .http import AsyncHTTPRequestNode, HTTPRequestNode
-from .monitoring import HealthCheckNode
+from .monitoring import APIHealthCheckNode
 from .rate_limiting import (
     AsyncRateLimitedAPINode,
     RateLimitConfig,
@@ -71,7 +71,7 @@ __all__ = [
     "AsyncRateLimitedAPINode",
     "create_rate_limiter",
     # Monitoring and Security
-    "HealthCheckNode",
+    "APIHealthCheckNode",
     "SecurityScannerNode",
     # Backwards compatibility
     "HTTPClientNode",  # Deprecated alias

kailash/nodes/api/monitoring.py

@@ -13,7 +13,7 @@ from kailash.nodes.base import Node, NodeParameter, register_node
 
 
 @register_node()
-class HealthCheckNode(Node):
+class APIHealthCheckNode(Node):
     """
     Performs health checks on various system components and services.
 

kailash/nodes/base_async.py

@@ -46,10 +46,13 @@ class AsyncNode(Node):
     """
 
     def execute(self, **runtime_inputs) -> dict[str, Any]:
-        """Execute the node synchronously by running async code in a new event loop.
+        """Execute the node synchronously by running async code with proper event loop handling.
 
-        This override allows AsyncNode to work with synchronous runtimes like LocalRuntime
-        by wrapping the async execution in a synchronous interface.
+        This enhanced implementation handles all event loop scenarios:
+        1. No event loop: Create new one with asyncio.run()
+        2. Event loop running: Use ThreadPoolExecutor with isolated loop
+        3. Threaded contexts: Proper thread-safe execution
+        4. Windows compatibility: ProactorEventLoopPolicy support
 
         Args:
             **runtime_inputs: Runtime inputs for node execution
@@ -62,7 +65,9 @@ class AsyncNode(Node):
             NodeExecutionError: If execution fails
         """
         import asyncio
+        import concurrent.futures
         import sys
+        import threading
 
         # For sync execution, we always create a new event loop
         # This avoids complexity with nested loops and ensures clean execution
@@ -70,22 +75,57 @@ class AsyncNode(Node):
             # Windows requires special handling
             asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
 
+        # Check if we're in a thread without an event loop
+        current_thread = threading.current_thread()
+        is_main_thread = isinstance(current_thread, threading._MainThread)
+
         # Run the async method - handle existing event loop
         try:
             # Try to get current event loop
             loop = asyncio.get_running_loop()
+            # Event loop is running - need to run in separate thread
+            return self._execute_in_thread(**runtime_inputs)
         except RuntimeError:
-            # No event loop running, safe to use asyncio.run()
-            return asyncio.run(self.execute_async(**runtime_inputs))
-        else:
-            # Event loop is running, create a task
-            import concurrent.futures
-
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(
-                    asyncio.run, self.execute_async(**runtime_inputs)
-                )
-                return future.result()
+            # No event loop running
+            if is_main_thread:
+                # Main thread without loop - safe to use asyncio.run()
+                return asyncio.run(self.execute_async(**runtime_inputs))
+            else:
+                # Non-main thread without loop - create new loop
+                return self._execute_in_new_loop(**runtime_inputs)
+
+    def _execute_in_thread(self, **runtime_inputs) -> dict[str, Any]:
+        """Execute async code in a separate thread with its own event loop."""
+        import asyncio
+        import concurrent.futures
+
+        def run_in_new_loop():
+            """Run async code in a completely new event loop."""
+            # Create fresh event loop for this thread
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            try:
+                return new_loop.run_until_complete(self.execute_async(**runtime_inputs))
+            finally:
+                new_loop.close()
+                asyncio.set_event_loop(None)
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(run_in_new_loop)
+            return future.result()
+
+    def _execute_in_new_loop(self, **runtime_inputs) -> dict[str, Any]:
+        """Execute async code by creating a new event loop in current thread."""
+        import asyncio
+
+        # Create and set new event loop for this thread
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(self.execute_async(**runtime_inputs))
+        finally:
+            loop.close()
+            asyncio.set_event_loop(None)
 
     def run(self, **kwargs) -> dict[str, Any]:
         """Synchronous run is not supported for AsyncNode.

kailash/nodes/code/async_python.py

@@ -783,7 +783,7 @@ class AsyncPythonCodeNode(AsyncNode):
                 "max_concurrent_tasks",
                 "max_memory_mb",
                 "imports",
-                "config",
+                # Note: "config" removed - it's a valid runtime parameter name
             }
             runtime_inputs = {k: v for k, v in kwargs.items() if k not in config_params}