kailash 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

kailash/mcp_server/server.py

@@ -203,42 +203,47 @@ class MCPServerBase(ABC):
         try:
             # Try independent FastMCP package first (when available)
             from fastmcp import FastMCP
+
             self._mcp = FastMCP(self.name)
         except ImportError:
             logger.warning("FastMCP not available, using fallback mode")
             # Use same fallback as MCPServer
             self._mcp = self._create_fallback_server()
-    
+
     def _create_fallback_server(self):
         """Create a fallback server when FastMCP is not available."""
+
         class FallbackMCPServer:
             def __init__(self, name: str):
                 self.name = name
                 self._tools = {}
                 self._resources = {}
                 self._prompts = {}
-            
+
             def tool(self, *args, **kwargs):
                 def decorator(func):
                     self._tools[func.__name__] = func
                     return func
+
                 return decorator
-            
+
             def resource(self, uri):
                 def decorator(func):
                     self._resources[uri] = func
                     return func
+
                 return decorator
-            
+
             def prompt(self, name):
                 def decorator(func):
                     self._prompts[name] = func
                     return func
+
                 return decorator
-            
+
             def run(self, **kwargs):
                 raise NotImplementedError("FastMCP not available")
-        
+
         return FallbackMCPServer(self.name)
 
     def start(self):
@@ -503,6 +508,7 @@ class MCPServer:
         try:
             # Try independent FastMCP package first (when available)
             from fastmcp import FastMCP
+
             self._mcp = FastMCP(self.name)
             logger.info(f"Initialized FastMCP server: {self.name}")
         except ImportError as e1:
@@ -510,6 +516,7 @@ class MCPServer:
             try:
                 # Fallback to official MCP FastMCP (when fixed)
                 from mcp.server import FastMCP
+
                 self._mcp = FastMCP(self.name)
                 logger.info(f"Initialized official FastMCP server: {self.name}")
             except ImportError as e2:
@@ -517,56 +524,66 @@ class MCPServer:
                 # Final fallback: Create a minimal FastMCP-compatible wrapper
                 logger.info(f"Using low-level MCP Server fallback for: {self.name}")
                 self._mcp = self._create_fallback_server()
-                
+
     def _create_fallback_server(self):
         """Create a fallback server when FastMCP is not available."""
         logger.info("Creating fallback server implementation")
-        
+
         class FallbackMCPServer:
             """Minimal FastMCP-compatible server for when FastMCP is unavailable."""
-            
+
             def __init__(self, name: str):
                 self.name = name
                 self._tools = {}
                 self._resources = {}
                 self._prompts = {}
                 logger.info(f"Fallback MCP server '{name}' initialized")
-            
+
             def tool(self, *args, **kwargs):
                 """Tool decorator that stores tool registration."""
+
                 def decorator(func):
                     tool_name = func.__name__
                     self._tools[tool_name] = func
                     logger.debug(f"Registered fallback tool: {tool_name}")
                     return func
+
                 return decorator
-            
+
             def resource(self, uri):
                 """Resource decorator that stores resource registration."""
+
                 def decorator(func):
                     self._resources[uri] = func
                     logger.debug(f"Registered fallback resource: {uri}")
                     return func
+
                 return decorator
-            
+
             def prompt(self, name):
                 """Prompt decorator that stores prompt registration."""
+
                 def decorator(func):
                     self._prompts[name] = func
                     logger.debug(f"Registered fallback prompt: {name}")
                     return func
+
                 return decorator
-            
+
             def run(self, **kwargs):
                 """Placeholder run method."""
-                logger.warning(f"Fallback server '{self.name}' run() called - FastMCP features limited")
-                logger.info(f"Registered: {len(self._tools)} tools, {len(self._resources)} resources, {len(self._prompts)} prompts")
+                logger.warning(
+                    f"Fallback server '{self.name}' run() called - FastMCP features limited"
+                )
+                logger.info(
+                    f"Registered: {len(self._tools)} tools, {len(self._resources)} resources, {len(self._prompts)} prompts"
+                )
                 # In a real implementation, we would set up low-level MCP protocol here
                 raise NotImplementedError(
                     "Full MCP protocol not implemented in fallback mode. "
                     "Install 'fastmcp>=2.10.0' or wait for official MCP package fix."
                 )
-        
+
         return FallbackMCPServer(self.name)
 
     def tool(

kailash/middleware/communication/api_gateway.py

@@ -15,7 +15,14 @@ from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Union
 from urllib.parse import parse_qs
 
-from fastapi import Depends, FastAPI, HTTPException, Request, WebSocket, WebSocketDisconnect
+from fastapi import (
+    Depends,
+    FastAPI,
+    HTTPException,
+    Request,
+    WebSocket,
+    WebSocketDisconnect,
+)
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, StreamingResponse
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer

kailash/middleware/core/agent_ui.py

@@ -135,6 +135,7 @@ Author: Kailash SDK Team
 """
 
 import asyncio
+import copy
 import logging
 import time
 import uuid
@@ -563,6 +564,8 @@ class AgentUIMiddleware:
             workflow = session.workflows[workflow_id]
         elif workflow_id in self.shared_workflows:
             workflow = self.shared_workflows[workflow_id]
+            # FIX: Copy shared workflow to session before execution
+            session.add_workflow(workflow_id, workflow)
         else:
             raise ValueError(f"Workflow {workflow_id} not found")
 
@@ -658,6 +661,8 @@ class AgentUIMiddleware:
             workflow = session.workflows[workflow_id]
         elif workflow_id in self.shared_workflows:
             workflow = self.shared_workflows[workflow_id]
+            # FIX: Copy shared workflow to session before execution
+            session.add_workflow(workflow_id, workflow)
         else:
             raise ValueError(f"Workflow {workflow_id} not found")
 

kailash/nodes/admin/security_event.py

@@ -24,7 +24,11 @@ from enum import Enum
 from typing import Any, Dict, List, Optional, Tuple
 
 from kailash.access_control import UserContext
-from kailash.nodes.admin.audit_log import AuditEventType, AuditSeverity, EnterpriseAuditLogNode
+from kailash.nodes.admin.audit_log import (
+    AuditEventType,
+    AuditSeverity,
+    EnterpriseAuditLogNode,
+)
 from kailash.nodes.base import Node, NodeParameter, register_node
 from kailash.nodes.data import AsyncSQLDatabaseNode
 from kailash.sdk_exceptions import NodeExecutionError, NodeValidationError

kailash/nodes/admin/user_management.py

@@ -26,6 +26,7 @@ from typing import Any, Dict, List, Optional, Set, Union
 from uuid import uuid4
 
 import bcrypt
+
 from kailash.nodes.base import Node, NodeParameter, register_node
 from kailash.nodes.data import SQLDatabaseNode
 from kailash.sdk_exceptions import NodeExecutionError, NodeValidationError

kailash/nodes/api/http.py

@@ -12,11 +12,16 @@ from typing import Any
 
 import aiohttp
 import requests
+from pydantic import BaseModel
+
 from kailash.nodes.base import Node, NodeParameter, register_node
 from kailash.nodes.base_async import AsyncNode
 from kailash.sdk_exceptions import NodeExecutionError, NodeValidationError
-from kailash.utils.resource_manager import AsyncResourcePool, ResourcePool, managed_resource
-from pydantic import BaseModel
+from kailash.utils.resource_manager import (
+    AsyncResourcePool,
+    ResourcePool,
+    managed_resource,
+)
 
 
 class HTTPMethod(str, Enum):

kailash/nodes/auth/mfa.py

@@ -17,6 +17,7 @@ from datetime import UTC, datetime, timedelta
 from typing import Any, Dict, List, Optional, Tuple
 
 import qrcode
+
 from kailash.nodes.base import Node, NodeParameter, register_node
 from kailash.nodes.mixins import LoggingMixin, PerformanceMixin, SecurityMixin
 from kailash.nodes.security.audit_log import AuditLogNode

kailash/nodes/base.py

@@ -1070,7 +1070,9 @@ class Node(ABC):
                 # ENTERPRISE PARAMETER INJECTION FIX: Runtime inputs should take precedence over config dict
                 # First apply config dict values, then re-apply runtime inputs to ensure they override
                 for key, value in nested_config.items():
-                    if key not in runtime_inputs:  # Only use config values if not overridden by runtime
+                    if (
+                        key not in runtime_inputs
+                    ):  # Only use config values if not overridden by runtime
                         merged_inputs[key] = value
                 # Don't remove the config key as some nodes might need it
 

kailash/nodes/cache/cache_invalidation.py

@@ -368,7 +368,7 @@ class CacheInvalidationNode(AsyncNode):
                     return
 
             redis_url = kwargs.get("redis_url", "redis://localhost:6379")
-            
+
             # Only recreate Redis client if the current one is problematic
             if self._redis_client:
                 try:
@@ -382,18 +382,22 @@ class CacheInvalidationNode(AsyncNode):
                         await self._redis_client.aclose()
                     except:
                         pass  # Ignore errors when closing old client
-                
+
             try:
                 self._redis_client = redis.from_url(redis_url)
                 # Test connection with proper error handling
                 try:
                     await asyncio.wait_for(self._redis_client.ping(), timeout=2.0)
-                    self.logger.debug(f"Fresh Redis connection established to {redis_url}")
+                    self.logger.debug(
+                        f"Fresh Redis connection established to {redis_url}"
+                    )
                 except (asyncio.TimeoutError, RuntimeError) as e:
                     if "Event loop is closed" in str(e):
                         # Event loop issue - create new client without ping test
                         self._redis_client = redis.from_url(redis_url)
-                        self.logger.debug("Created Redis client without ping test due to event loop issue")
+                        self.logger.debug(
+                            "Created Redis client without ping test due to event loop issue"
+                        )
                     else:
                         raise
             except Exception as e:
@@ -843,10 +847,10 @@ class CacheInvalidationNode(AsyncNode):
             # Event loop is running, schedule the coroutine
             import concurrent.futures
             import threading
-            
+
             result_holder = {}
             exception_holder = {}
-            
+
             def run_in_new_loop():
                 try:
                     # Create a new event loop for this thread
@@ -854,17 +858,17 @@ class CacheInvalidationNode(AsyncNode):
                     asyncio.set_event_loop(new_loop)
                     try:
                         result = new_loop.run_until_complete(self.async_run(**kwargs))
-                        result_holder['result'] = result
+                        result_holder["result"] = result
                     finally:
                         new_loop.close()
                 except Exception as e:
-                    exception_holder['error'] = e
-            
+                    exception_holder["error"] = e
+
             thread = threading.Thread(target=run_in_new_loop)
             thread.start()
             thread.join()
-            
-            if 'error' in exception_holder:
-                raise exception_holder['error']
-            
-            return result_holder['result']
+
+            if "error" in exception_holder:
+                raise exception_holder["error"]
+
+            return result_holder["result"]

kailash/nodes/code/python.py

@@ -57,7 +57,11 @@ from pathlib import Path
 from typing import Any, get_type_hints
 
 from kailash.nodes.base import Node, NodeMetadata, NodeParameter, register_node
-from kailash.sdk_exceptions import NodeConfigurationError, NodeExecutionError, SafetyViolationError
+from kailash.sdk_exceptions import (
+    NodeConfigurationError,
+    NodeExecutionError,
+    SafetyViolationError,
+)
 from kailash.security import (
     ExecutionTimeoutError,
     MemoryLimitError,
@@ -402,7 +406,6 @@ class CodeExecutor:
 
         # Sanitize inputs
         sanitized_inputs = validate_node_parameters(inputs, self.security_config)
-        
 
         # Create isolated namespace
         import builtins