kailash 0.6.6__tar.gz → 0.8.0__tar.gz

{kailash-0.6.6/src/kailash.egg-info → kailash-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.6.6
+Version: 0.8.0
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum
@@ -21,7 +21,7 @@ Requires-Dist: matplotlib>=3.5
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: click>=8.0
 Requires-Dist: pytest>=8.3.5
-Requires-Dist: mcp[cli]>=1.9.2
+Requires-Dist: mcp[cli]==1.11.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: numpy>=2.2.5
 Requires-Dist: scipy>=1.15.3
@@ -78,6 +78,7 @@ Requires-Dist: passlib>=1.7.4
 Requires-Dist: pyotp>=2.9.0
 Requires-Dist: opentelemetry-instrumentation-fastapi>=0.55b1
 Requires-Dist: seaborn>=0.13.2
+Requires-Dist: sqlparse>=0.5.3
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=3.0; extra == "dev"

{kailash-0.6.6 → kailash-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kailash"
-version = "0.6.6"
+version = "0.8.0"
 description = "Python SDK for the Kailash container-node architecture"
 authors = [
     {name = "Integrum", email = "info@integrum.com"}
@@ -25,7 +25,7 @@ dependencies = [
     "pyyaml>=6.0",
     "click>=8.0",
     "pytest>=8.3.5",
-    "mcp[cli]>=1.9.2",
+    "mcp[cli]==1.11.0",
     "pandas>=2.2.3",
     "numpy>=2.2.5",
     "scipy>=1.15.3",
@@ -82,6 +82,7 @@ dependencies = [
     "pyotp>=2.9.0",
     "opentelemetry-instrumentation-fastapi>=0.55b1",
     "seaborn>=0.13.2",
+    "sqlparse>=0.5.3",
 ]
 
 [project.optional-dependencies]

{kailash-0.6.6 → kailash-0.8.0}/setup.py

@@ -13,7 +13,7 @@ with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
 # Package configuration
 setup(
     name="kailash",
-    version="0.6.3",
+    version="0.7.0",
     author="Integrum",
     author_email="info@integrum.com",
     description="Python SDK for the Kailash container-node architecture",
@@ -50,6 +50,16 @@ setup(
         "viz": [
             "pygraphviz>=1.9",
         ],
+        "dataflow": [
+            "dataflow>=0.1.0",
+        ],
+        "nexus": [
+            "nexus>=1.0.0",
+        ],
+        "all": [
+            "dataflow>=0.1.0",
+            "nexus>=1.0.0",
+        ],
     },
     # Entry points for CLI
     entry_points={

{kailash-0.6.6 → kailash-0.8.0}/src/kailash/__init__.py

@@ -3,9 +3,10 @@
 The Kailash SDK provides a comprehensive framework for creating nodes and workflows
 that align with container-node architecture while allowing rapid prototyping.
 
-New in v0.6.6: AgentUIMiddleware shared workflow fix, execute() method standardization.
-Previous v0.6.5: Enterprise AsyncSQL enhancements with optimistic locking, comprehensive
-testing improvements, and production-grade documentation.
+New in v0.7.0: Complete DataFlow and Nexus application frameworks, infrastructure hardening
+with 100% E2E test pass rate, enhanced AsyncNode event loop handling, 8 new monitoring operations,
+distributed transactions, QueryBuilder/QueryCache with Redis, and real MCP execution by default.
+Previous v0.6.6: AgentUIMiddleware shared workflow fix, execute() method standardization.
 """
 
 from kailash.nodes.base import Node, NodeMetadata, NodeParameter
@@ -23,6 +24,23 @@ try:
         AIChatMiddleware,
         APIGateway,
         RealtimeMiddleware,
+    )
+
+    # Import Nexus multi-channel framework (v0.6.7+)
+    from kailash.nexus import NexusGateway, create_nexus
+
+    # Import new server classes (v0.6.7+)
+    from kailash.servers import (
+        DurableWorkflowServer,
+        EnterpriseWorkflowServer,
+        WorkflowServer,
+    )
+
+    # Import updated create_gateway function with enterprise defaults
+    from kailash.servers.gateway import (
+        create_basic_gateway,
+        create_durable_gateway,
+        create_enterprise_gateway,
         create_gateway,
     )
 
@@ -34,7 +52,7 @@ except ImportError:
 # For backward compatibility
 WorkflowGraph = Workflow
 
-__version__ = "0.6.6"
+__version__ = "0.8.0"
 
 __all__ = [
     # Core workflow components
@@ -50,14 +68,26 @@ __all__ = [
     "LocalRuntime",
 ]
 
-# Add middleware to exports if available
+# Add middleware and servers to exports if available
 if _MIDDLEWARE_AVAILABLE:
     __all__.extend(
         [
+            # Legacy middleware
             "AgentUIMiddleware",
             "RealtimeMiddleware",
             "APIGateway",
             "AIChatMiddleware",
+            # New server classes
+            "WorkflowServer",
+            "DurableWorkflowServer",
+            "EnterpriseWorkflowServer",
+            # Gateway creation functions
             "create_gateway",
+            "create_enterprise_gateway",
+            "create_durable_gateway",
+            "create_basic_gateway",
+            # Nexus multi-channel framework
+            "NexusGateway",
+            "create_nexus",
         ]
     )

{kailash-0.6.6 → kailash-0.8.0}/src/kailash/access_control.py

@@ -435,6 +435,17 @@ class AccessControlManager:
         self, user: UserContext, workflow_id: str, permission: WorkflowPermission
     ) -> AccessDecision:
         """Check if user has permission on workflow"""
+        # If access control is disabled, allow all access
+        if not self.enabled:
+            return AccessDecision(
+                allowed=True,
+                reason="Access control disabled",
+                applied_rules=[],
+                conditions_met={},
+                masked_fields=[],
+                redirect_node=None,
+            )
+
         cache_key = f"workflow:{workflow_id}:{user.user_id}:{permission.value}"
 
         # Check cache
@@ -462,6 +473,17 @@ class AccessControlManager:
         runtime_context: dict[str, Any] = None,
     ) -> AccessDecision:
         """Check if user has permission on node"""
+        # If access control is disabled, allow all access
+        if not self.enabled:
+            return AccessDecision(
+                allowed=True,
+                reason="Access control disabled",
+                applied_rules=[],
+                conditions_met={},
+                masked_fields=[],
+                redirect_node=None,
+            )
+
         cache_key = f"node:{node_id}:{user.user_id}:{permission.value}"
 
         # For runtime-dependent permissions, don't use cache
@@ -494,65 +516,56 @@ class AccessControlManager:
         return decision
 
     def get_accessible_nodes(
-        self, user: UserContext, workflow_id: str, permission: NodePermission
-    ) -> set[str]:
-        """Get all nodes user can access in a workflow"""
-        accessible = set()
-
-        # Get all node rules for this workflow
-        node_rules = [
-            r
-            for r in self.rules
-            if r.resource_type == "node" and r.permission == permission
-        ]
-
-        for rule in node_rules:
-            if self._rule_applies_to_user(rule, user):
-                if rule.effect == PermissionEffect.ALLOW:
-                    accessible.add(rule.resource_id)
-                elif rule.effect == PermissionEffect.DENY:
-                    accessible.discard(rule.resource_id)
-
+        self, user: UserContext, nodes: list[str], permission: NodePermission
+    ) -> list[str]:
+        """Get all nodes user can access from a list of nodes"""
+        # If access control is disabled, allow access to all nodes
+        if not self.enabled:
+            return nodes
+
+        accessible = []
+        for node_id in nodes:
+            decision = self.check_node_access(user, node_id, permission)
+            if decision.allowed:
+                accessible.append(node_id)
         return accessible
 
     def get_permission_based_route(
         self,
         user: UserContext,
-        conditional_node_id: str,
-        true_path_nodes: list[str],
-        false_path_nodes: list[str],
-    ) -> list[str]:
-        """Determine which path user should take based on permissions"""
-        # Check if user has access to nodes in true path
-        true_path_accessible = all(
-            self.check_node_access(user, node_id, NodePermission.EXECUTE).allowed
-            for node_id in true_path_nodes
-        )
+        node_id: str,
+        permission: NodePermission,
+        alternatives: dict[str, str] = None,
+    ) -> str | None:
+        """Get alternative route if user doesn't have access to node"""
+        # If access control is disabled, allow access to requested node
+        if not self.enabled:
+            return None
 
-        if true_path_accessible:
-            return true_path_nodes
-        else:
-            # Check false path
-            false_path_accessible = all(
-                self.check_node_access(user, node_id, NodePermission.EXECUTE).allowed
-                for node_id in false_path_nodes
-            )
+        decision = self.check_node_access(user, node_id, permission)
 
-            if false_path_accessible:
-                return false_path_nodes
-            else:
-                # User can't access either path
-                return []
+        if decision.allowed:
+            return None  # No alternative needed
+
+        # If access denied and alternatives provided, return alternative
+        if alternatives and node_id in alternatives:
+            return alternatives[node_id]
+
+        return None
 
     def mask_node_output(
         self, user: UserContext, node_id: str, output: dict[str, Any]
     ) -> dict[str, Any]:
         """Mask sensitive fields in node output"""
-        decision = self.check_node_access(user, node_id, NodePermission.READ_OUTPUT)
+        # If access control is disabled, don't mask anything
+        if not self.enabled:
+            return output
+
+        decision = self.check_node_access(user, node_id, NodePermission.MASK_OUTPUT)
 
         if not decision.allowed:
-            # Completely mask output
-            return {"_masked": True, "reason": "Access denied"}
+            # No masking rules found, return original output
+            return output
 
         if decision.masked_fields:
             # Mask specific fields
@@ -626,7 +639,12 @@ class AccessControlManager:
                 break
 
         allowed = final_effect == PermissionEffect.ALLOW
-        reason = f"Permission {permission.value} {'granted' if allowed else 'denied'} for {resource_type} {resource_id}"
+
+        # Set reason based on rules found
+        if not applicable_rules:
+            reason = f"No matching rules found for {resource_type} {resource_id}"
+        else:
+            reason = f"Permission {permission.value} {'granted' if allowed else 'denied'} for {resource_type} {resource_id}"
 
         return AccessDecision(
             allowed=allowed,

kailash-0.8.0/src/kailash/adapters/__init__.py

@@ -0,0 +1,5 @@
+"""Integration adapters for bridging different component systems in Kailash SDK."""
+
+from .mcp_platform_adapter import MCPPlatformAdapter
+
+__all__ = ["MCPPlatformAdapter"]

kailash-0.8.0/src/kailash/adapters/mcp_platform_adapter.py

@@ -0,0 +1,273 @@
+"""Adapter for bridging mcp_platform and core SDK parameter formats."""
+
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+class MCPPlatformAdapter:
+    """Adapter to translate between mcp_platform and SDK MCP parameter formats."""
+
+    @staticmethod
+    def translate_server_config(platform_config: Dict[str, Any]) -> Dict[str, Any]:
+        """Translate mcp_platform server config to SDK format.
+
+        Args:
+            platform_config: Server config from mcp_platform
+
+        Returns:
+            SDK-compatible server config
+        """
+        if not isinstance(platform_config, dict):
+            logger.error(f"Platform config must be dict, got {type(platform_config)}")
+            return {}
+
+        # Extract mcp_platform format: {"transport": "stdio", "command": "...", "args": [...]}
+        sdk_config = {}
+
+        # Map required fields
+        if "name" not in platform_config:
+            # Generate name from command if not provided
+            command = platform_config.get("command", "unknown")
+            sdk_config["name"] = command.split("/")[-1].split("\\")[-1]
+        else:
+            sdk_config["name"] = platform_config["name"]
+
+        # Transport mapping
+        transport = platform_config.get("transport", "stdio")
+        sdk_config["transport"] = transport
+
+        # Command mapping
+        if "command" in platform_config:
+            sdk_config["command"] = platform_config["command"]
+
+        # Arguments mapping
+        if "args" in platform_config:
+            sdk_config["args"] = platform_config["args"]
+        elif "arguments" in platform_config:
+            sdk_config["args"] = platform_config["arguments"]
+
+        # Environment mapping
+        if "env" in platform_config:
+            sdk_config["env"] = platform_config["env"]
+        elif "environment" in platform_config:
+            sdk_config["env"] = platform_config["environment"]
+
+        # Server-specific settings
+        if "auto_start" in platform_config:
+            sdk_config["auto_start"] = platform_config["auto_start"]
+
+        if "timeout" in platform_config:
+            sdk_config["timeout"] = platform_config["timeout"]
+
+        # Tool list mapping
+        if "tools" in platform_config:
+            sdk_config["tools"] = platform_config["tools"]
+
+        logger.debug(f"Translated platform config to SDK format: {sdk_config}")
+        return sdk_config
+
+    @staticmethod
+    def translate_mcp_servers_list(
+        platform_servers: List[Dict[str, Any]],
+    ) -> List[Dict[str, Any]]:
+        """Translate list of mcp_platform server configs to SDK format.
+
+        Args:
+            platform_servers: List of server configs from mcp_platform
+
+        Returns:
+            List of SDK-compatible server configs
+        """
+        if not isinstance(platform_servers, list):
+            logger.error(f"Platform servers must be list, got {type(platform_servers)}")
+            return []
+
+        sdk_servers = []
+        for i, platform_config in enumerate(platform_servers):
+            try:
+                sdk_config = MCPPlatformAdapter.translate_server_config(platform_config)
+                if sdk_config:
+                    sdk_servers.append(sdk_config)
+                else:
+                    logger.warning(
+                        f"Failed to translate server config {i}: {platform_config}"
+                    )
+            except Exception as e:
+                logger.error(f"Error translating server config {i}: {e}")
+
+        return sdk_servers
+
+    @staticmethod
+    def translate_tool_parameters(
+        platform_params: Dict[str, Any], tool_schema: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Translate mcp_platform tool parameters to SDK format.
+
+        Args:
+            platform_params: Parameters from mcp_platform
+            tool_schema: Optional tool schema for validation
+
+        Returns:
+            SDK-compatible tool parameters
+        """
+        if not isinstance(platform_params, dict):
+            logger.error(f"Platform params must be dict, got {type(platform_params)}")
+            return {}
+
+        sdk_params = {}
+
+        # Handle nested server configuration
+        if "server_config" in platform_params:
+            server_config = platform_params["server_config"]
+            sdk_params["mcp_server_config"] = (
+                MCPPlatformAdapter.translate_server_config(server_config)
+            )
+
+        # Handle tool-specific parameters
+        for key, value in platform_params.items():
+            if key == "server_config":
+                continue  # Already handled above
+
+            # Parameter name mapping
+            if key == "tool_name":
+                sdk_params["name"] = value
+            elif key == "tool_args":
+                sdk_params["arguments"] = value
+            elif key == "tool_params":
+                sdk_params["parameters"] = value
+            else:
+                sdk_params[key] = value
+
+        # Validate against tool schema if provided
+        if tool_schema and "parameters" in tool_schema:
+            required_params = tool_schema["parameters"].get("required", [])
+            missing_params = [p for p in required_params if p not in sdk_params]
+            if missing_params:
+                logger.warning(f"Missing required tool parameters: {missing_params}")
+
+        logger.debug(f"Translated tool parameters: {sdk_params}")
+        return sdk_params
+
+    @staticmethod
+    def translate_llm_agent_config(platform_config: Dict[str, Any]) -> Dict[str, Any]:
+        """Translate mcp_platform LLM agent config to SDK format.
+
+        Args:
+            platform_config: LLM agent config from mcp_platform
+
+        Returns:
+            SDK-compatible LLM agent config
+        """
+        if not isinstance(platform_config, dict):
+            logger.error(f"Platform config must be dict, got {type(platform_config)}")
+            return {}
+
+        sdk_config = platform_config.copy()
+
+        # Handle mcp_platform server configuration
+        if "server_config" in platform_config:
+            server_config = platform_config["server_config"]
+            if isinstance(server_config, dict):
+                # Single server config
+                sdk_config["mcp_servers"] = [
+                    MCPPlatformAdapter.translate_server_config(server_config)
+                ]
+            elif isinstance(server_config, list):
+                # Multiple server configs
+                sdk_config["mcp_servers"] = (
+                    MCPPlatformAdapter.translate_mcp_servers_list(server_config)
+                )
+
+            # Remove the old key
+            sdk_config.pop("server_config")
+
+        # Handle server_configs (plural) as well
+        if "server_configs" in platform_config:
+            server_configs = platform_config["server_configs"]
+            sdk_config["mcp_servers"] = MCPPlatformAdapter.translate_mcp_servers_list(
+                server_configs
+            )
+            sdk_config.pop("server_configs")
+
+        # Ensure use_real_mcp is set correctly
+        if "use_real_mcp" not in sdk_config:
+            sdk_config["use_real_mcp"] = True  # Default to real MCP execution
+
+        logger.debug(f"Translated LLM agent config: {sdk_config}")
+        return sdk_config
+
+    @staticmethod
+    def validate_integration(
+        platform_data: Dict[str, Any], expected_sdk_format: str
+    ) -> bool:
+        """Validate that platform data can be properly translated to SDK format.
+
+        Args:
+            platform_data: Data from mcp_platform
+            expected_sdk_format: Expected SDK format type ("server_config", "tool_params", "llm_config")
+
+        Returns:
+            True if valid for translation, False otherwise
+        """
+        if not isinstance(platform_data, dict):
+            logger.error(f"Platform data must be dict for {expected_sdk_format}")
+            return False
+
+        if expected_sdk_format == "server_config":
+            required_fields = ["transport"]
+            optional_fields = ["command", "name", "args"]
+
+        elif expected_sdk_format == "tool_params":
+            required_fields = []
+            optional_fields = ["tool_name", "tool_args", "server_config"]
+
+        elif expected_sdk_format == "llm_config":
+            required_fields = []
+            optional_fields = ["server_config", "server_configs", "mcp_servers"]
+
+        else:
+            logger.error(f"Unknown SDK format: {expected_sdk_format}")
+            return False
+
+        # Check for required fields
+        missing_required = [f for f in required_fields if f not in platform_data]
+        if missing_required:
+            logger.error(
+                f"Missing required fields for {expected_sdk_format}: {missing_required}"
+            )
+            return False
+
+        # Check if we have at least some relevant fields
+        has_relevant_fields = any(
+            f in platform_data for f in required_fields + optional_fields
+        )
+        if not has_relevant_fields:
+            logger.warning(f"No relevant fields found for {expected_sdk_format}")
+            return False
+
+        return True
+
+    @staticmethod
+    def create_error_recovery_config(
+        original_config: Any, error_msg: str
+    ) -> Dict[str, Any]:
+        """Create a recovery configuration when translation fails.
+
+        Args:
+            original_config: The original configuration that failed
+            error_msg: Error message describing the failure
+
+        Returns:
+            Recovery configuration
+        """
+        return {
+            "name": "error_recovery",
+            "transport": "stdio",
+            "command": "echo",
+            "args": ["Error in MCP configuration"],
+            "original_config": original_config,
+            "error_message": error_msg,
+            "recovery_mode": True,
+        }

{kailash-0.6.6 → kailash-0.8.0}/src/kailash/api/workflow_api.py

@@ -11,7 +11,7 @@ from enum import Enum
 from typing import Any
 
 import uvicorn
-from fastapi import BackgroundTasks, FastAPI, HTTPException
+from fastapi import BackgroundTasks, FastAPI, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, Field
 
@@ -31,12 +31,26 @@ class ExecutionMode(str, Enum):
 class WorkflowRequest(BaseModel):
     """Base request model for workflow execution."""
 
-    inputs: dict[str, Any] = Field(..., description="Input data for workflow nodes")
+    inputs: dict[str, Any] | None = Field(
+        None, description="Input data for workflow nodes"
+    )
+    parameters: dict[str, Any] | None = Field(
+        None, description="Legacy: parameters for workflow execution"
+    )
     config: dict[str, Any] | None = Field(
         None, description="Node configuration overrides"
     )
     mode: ExecutionMode = Field(ExecutionMode.SYNC, description="Execution mode")
 
+    def get_inputs(self) -> dict[str, Any]:
+        """Get inputs, supporting both 'inputs' and 'parameters' format."""
+        if self.inputs is not None:
+            return self.inputs
+        elif self.parameters is not None:
+            return self.parameters
+        else:
+            return {}
+
 
 class WorkflowResponse(BaseModel):
     """Base response model for workflow execution."""
@@ -115,6 +129,21 @@ class WorkflowAPI:
     def _setup_routes(self):
         """Setup API routes dynamically based on workflow."""
 
+        # Root execution endpoint (convenience for direct workflow execution)
+        @self.app.post("/")
+        async def execute_workflow_root(
+            request: Request, background_tasks: BackgroundTasks
+        ):
+            """Execute the workflow with provided inputs (root endpoint)."""
+            try:
+                # Try to parse JSON body
+                json_data = await request.json()
+                workflow_request = WorkflowRequest(**json_data)
+            except:
+                # If no JSON or invalid JSON, create empty request
+                workflow_request = WorkflowRequest()
+            return await execute_workflow(workflow_request, background_tasks)
+
         # Main execution endpoint
         @self.app.post("/execute")
         async def execute_workflow(
@@ -195,7 +224,9 @@ class WorkflowAPI:
 
             # Execute workflow with inputs
             results = await asyncio.to_thread(
-                self.runtime.execute, self.workflow_graph, parameters=request.inputs
+                self.runtime.execute,
+                self.workflow_graph,
+                parameters=request.get_inputs(),
             )
 
             # Handle tuple return from runtime

kailash-0.8.0/src/kailash/channels/__init__.py

@@ -0,0 +1,21 @@
+"""Channel abstractions for Nexus multi-channel architecture.
+
+This module provides the core channel abstractions for the Kailash Nexus framework,
+enabling unified management of API, CLI, and MCP interfaces through a common channel abstraction.
+"""
+
+from .api_channel import APIChannel
+from .base import Channel, ChannelConfig
+from .cli_channel import CLIChannel
+from .mcp_channel import MCPChannel
+from .session import CrossChannelSession, SessionManager
+
+__all__ = [
+    "Channel",
+    "ChannelConfig",
+    "APIChannel",
+    "CLIChannel",
+    "MCPChannel",
+    "SessionManager",
+    "CrossChannelSession",
+]