kailash 0.9.17__py3-none-any.whl → 0.9.19__py3-none-any.whl

kailash/__init__.py

@@ -5,7 +5,6 @@ that align with container-node architecture while allowing rapid prototyping.
 
 New in v0.9.17: AsyncSQL per-pool locking eliminates lock contention bottleneck.
 Achieves 100% success at 300+ concurrent operations (was 50% failure). 85% performance improvement with per-pool locks.
-Previous v0.9.14: Code quality improvements and updated dependencies for DataFlow v0.4.6 compatibility.
 Previous v0.9.13: Fixed WorkflowBuilder parameter validation false positives (Bug 010).
 Enhanced validation.py to recognize auto_map_from parameters, eliminating spurious warnings.
 Previous v0.9.12: SQLite Compatibility & Code Quality improvements.
@@ -53,7 +52,7 @@ except ImportError:
 # For backward compatibility
 WorkflowGraph = Workflow
 
-__version__ = "0.9.17"
+__version__ = "0.9.18"
 
 __all__ = [
     # Core workflow components

kailash/mcp_server/subscriptions.py

@@ -1075,9 +1075,9 @@ class ResourceSubscriptionManager:
         This method should be overridden or configured to fetch actual resource data.
         For now, it returns basic resource information from the monitored state.
         """
-        async with self._resource_monitor._lock:
-            if uri in self._resource_monitor._resource_states:
-                state = self._resource_monitor._resource_states[uri]
+        async with self.resource_monitor._lock:
+            if uri in self.resource_monitor._resource_states:
+                state = self.resource_monitor._resource_states[uri]
                 return {
                     "uri": uri,
                     "content": state.get("content", {}),

kailash/monitoring/__init__.py

@@ -8,38 +8,38 @@ AsyncSQL lock contention monitoring.
 
 # Original monitoring imports
 from .alerts import AlertManager, AlertRule, AlertSeverity
-from .metrics import PerformanceMetrics, SecurityMetrics, ValidationMetrics
 
 # AsyncSQL lock monitoring imports
 from .asyncsql_metrics import (
+    PROMETHEUS_AVAILABLE,
     AsyncSQLMetrics,
-    enable_metrics,
     disable_metrics,
+    enable_metrics,
     get_global_metrics,
-    set_global_metrics,
+    integrate_with_async_sql,
     record_lock_acquisition,
     record_pool_operation,
     set_active_locks,
-    integrate_with_async_sql,
-    PROMETHEUS_AVAILABLE
+    set_global_metrics,
 )
+from .metrics import PerformanceMetrics, SecurityMetrics, ValidationMetrics
 
 __all__ = [
     "ValidationMetrics",
     "SecurityMetrics",
-    "PerformanceMetrics", 
+    "PerformanceMetrics",
     "AlertManager",
     "AlertRule",
     "AlertSeverity",
     # AsyncSQL monitoring
     "AsyncSQLMetrics",
     "enable_metrics",
-    "disable_metrics", 
+    "disable_metrics",
     "get_global_metrics",
     "set_global_metrics",
     "record_lock_acquisition",
     "record_pool_operation",
     "set_active_locks",
     "integrate_with_async_sql",
-    "PROMETHEUS_AVAILABLE"
+    "PROMETHEUS_AVAILABLE",
 ]

kailash/monitoring/asyncsql_metrics.py

@@ -6,11 +6,12 @@ per-pool locking performance and contention patterns.
 """
 
 import time
-from typing import Optional, Dict, Any
 from contextlib import asynccontextmanager
+from typing import Any, Dict, Optional
 
 try:
     import prometheus_client
+
     PROMETHEUS_AVAILABLE = True
 except ImportError:
     PROMETHEUS_AVAILABLE = False
@@ -18,66 +19,85 @@ except ImportError:
 
 class AsyncSQLMetrics:
     """Prometheus metrics collector for AsyncSQL lock contention monitoring."""
-    
-    def __init__(self, enabled: bool = True, registry: Optional[prometheus_client.CollectorRegistry] = None):
+
+    def __init__(
+        self,
+        enabled: bool = True,
+        registry: Optional[prometheus_client.CollectorRegistry] = None,
+    ):
         """
         Initialize AsyncSQL metrics collector.
-        
+
         Args:
             enabled: Whether to collect metrics (disabled if prometheus_client not available)
             registry: Custom Prometheus registry (uses default if None)
         """
         self.enabled = enabled and PROMETHEUS_AVAILABLE
         self.registry = registry or prometheus_client.REGISTRY
-        
+
         if not self.enabled:
             return
-        
+
         # Lock acquisition counter
         self.lock_acquisition_counter = prometheus_client.Counter(
-            'asyncsql_lock_acquisitions_total',
-            'Total number of AsyncSQL lock acquisitions',
-            ['pool_key', 'status'],  # status: success, timeout, error
-            registry=self.registry
+            "asyncsql_lock_acquisitions_total",
+            "Total number of AsyncSQL lock acquisitions",
+            ["pool_key", "status"],  # status: success, timeout, error
+            registry=self.registry,
         )
-        
-        # Lock wait time histogram  
+
+        # Lock wait time histogram
         self.lock_wait_time_histogram = prometheus_client.Histogram(
-            'asyncsql_lock_wait_seconds',
-            'Time spent waiting for AsyncSQL locks',
-            ['pool_key'],
-            buckets=(0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, float('inf')),
-            registry=self.registry
+            "asyncsql_lock_wait_seconds",
+            "Time spent waiting for AsyncSQL locks",
+            ["pool_key"],
+            buckets=(
+                0.001,
+                0.005,
+                0.01,
+                0.025,
+                0.05,
+                0.1,
+                0.25,
+                0.5,
+                1.0,
+                2.5,
+                5.0,
+                float("inf"),
+            ),
+            registry=self.registry,
         )
-        
+
         # Active locks gauge
         self.active_locks_gauge = prometheus_client.Gauge(
-            'asyncsql_active_locks',
-            'Number of currently active AsyncSQL locks',
-            ['pool_key'],
-            registry=self.registry
+            "asyncsql_active_locks",
+            "Number of currently active AsyncSQL locks",
+            ["pool_key"],
+            registry=self.registry,
         )
-        
+
         # Pool operations counter
         self.pool_operations_counter = prometheus_client.Counter(
-            'asyncsql_pool_operations_total',
-            'Total number of AsyncSQL pool operations',
-            ['pool_key', 'operation'],  # operation: create, cleanup, acquire, release
-            registry=self.registry
+            "asyncsql_pool_operations_total",
+            "Total number of AsyncSQL pool operations",
+            ["pool_key", "operation"],  # operation: create, cleanup, acquire, release
+            registry=self.registry,
         )
-        
+
         # Lock contention summary
         self.lock_contention_summary = prometheus_client.Summary(
-            'asyncsql_lock_contention_seconds',
-            'Summary of AsyncSQL lock contention patterns',
-            ['pool_key'],
-            registry=self.registry
+            "asyncsql_lock_contention_seconds",
+            "Summary of AsyncSQL lock contention patterns",
+            ["pool_key"],
+            registry=self.registry,
         )
-    
-    def record_lock_acquisition(self, pool_key: str, status: str, wait_time: float = 0.0):
+
+    def record_lock_acquisition(
+        self, pool_key: str, status: str, wait_time: float = 0.0
+    ):
         """
         Record a lock acquisition event.
-        
+
         Args:
             pool_key: The pool key for the lock
             status: 'success', 'timeout', or 'error'
@@ -85,44 +105,46 @@ class AsyncSQLMetrics:
         """
         if not self.enabled:
             return
-        
+
         self.lock_acquisition_counter.labels(pool_key=pool_key, status=status).inc()
-        
+
         if wait_time > 0:
             self.lock_wait_time_histogram.labels(pool_key=pool_key).observe(wait_time)
             self.lock_contention_summary.labels(pool_key=pool_key).observe(wait_time)
-    
+
     def set_active_locks(self, pool_key: str, count: int):
         """
         Update the count of active locks for a pool.
-        
+
         Args:
             pool_key: The pool key
             count: Number of active locks
         """
         if not self.enabled:
             return
-        
+
         self.active_locks_gauge.labels(pool_key=pool_key).set(count)
-    
+
     def record_pool_operation(self, pool_key: str, operation: str):
         """
         Record a pool operation event.
-        
+
         Args:
             pool_key: The pool key
             operation: 'create', 'cleanup', 'acquire', 'release'
         """
         if not self.enabled:
             return
-        
-        self.pool_operations_counter.labels(pool_key=pool_key, operation=operation).inc()
-    
+
+        self.pool_operations_counter.labels(
+            pool_key=pool_key, operation=operation
+        ).inc()
+
     @asynccontextmanager
     async def timed_lock_acquisition(self, pool_key: str):
         """
         Context manager to time lock acquisition and automatically record metrics.
-        
+
         Usage:
             async with metrics.timed_lock_acquisition('my_pool_key'):
                 # Lock acquisition logic here
@@ -131,16 +153,16 @@ class AsyncSQLMetrics:
                     pass
         """
         start_time = time.time()
-        status = 'error'
-        
+        status = "error"
+
         try:
             yield
-            status = 'success'
+            status = "success"
         except Exception as e:
-            if 'timeout' in str(e).lower():
-                status = 'timeout'
+            if "timeout" in str(e).lower():
+                status = "timeout"
             else:
-                status = 'error'
+                status = "error"
             raise
         finally:
             wait_time = time.time() - start_time
@@ -165,13 +187,15 @@ def set_global_metrics(metrics: Optional[AsyncSQLMetrics]):
     _global_metrics = metrics
 
 
-def enable_metrics(registry: Optional[prometheus_client.CollectorRegistry] = None) -> AsyncSQLMetrics:
+def enable_metrics(
+    registry: Optional[prometheus_client.CollectorRegistry] = None,
+) -> AsyncSQLMetrics:
     """
     Enable global AsyncSQL metrics collection.
-    
+
     Args:
         registry: Custom Prometheus registry (uses default if None)
-    
+
     Returns:
         The configured metrics instance
     """
@@ -211,41 +235,41 @@ def set_active_locks(pool_key: str, count: int):
 def integrate_with_async_sql():
     """
     Example of how to integrate metrics with AsyncSQLDatabaseNode.
-    
+
     This would typically be called during AsyncSQL initialization or
     through a configuration setting.
     """
     if not PROMETHEUS_AVAILABLE:
         return None
-    
+
     # Enable metrics
     metrics = enable_metrics()
-    
+
     # Example: monkey-patch AsyncSQL methods to include metrics
     # (This is just an example - actual integration would be cleaner)
     from kailash.nodes.data.async_sql import AsyncSQLDatabaseNode
-    
+
     # Store original methods
     original_get_pool_creation_lock = AsyncSQLDatabaseNode._get_pool_creation_lock
     original_acquire_lock = AsyncSQLDatabaseNode._acquire_pool_lock_with_timeout
-    
-    @classmethod  
+
+    @classmethod
     def instrumented_get_pool_creation_lock(cls, pool_key: str):
         """Instrumented version that records pool operations."""
-        record_pool_operation(pool_key, 'acquire')
+        record_pool_operation(pool_key, "acquire")
         return original_get_pool_creation_lock(pool_key)
-    
+
     @classmethod
     async def instrumented_acquire_lock(cls, pool_key: str, timeout: float = 5.0):
         """Instrumented version that records lock acquisitions."""
         async with metrics.timed_lock_acquisition(pool_key):
             async with original_acquire_lock(pool_key, timeout):
                 yield
-    
+
     # Apply instrumentation
     AsyncSQLDatabaseNode._get_pool_creation_lock = instrumented_get_pool_creation_lock
     AsyncSQLDatabaseNode._acquire_pool_lock_with_timeout = instrumented_acquire_lock
-    
+
     return metrics
 
 
@@ -253,23 +277,25 @@ if __name__ == "__main__":
     # Example usage
     print("AsyncSQL Metrics Module")
     print(f"Prometheus available: {PROMETHEUS_AVAILABLE}")
-    
+
     if PROMETHEUS_AVAILABLE:
         # Enable metrics
         metrics = enable_metrics()
-        
+
         # Simulate some metrics
-        metrics.record_lock_acquisition('test_pool_1', 'success', 0.005)
-        metrics.record_lock_acquisition('test_pool_1', 'success', 0.003)
-        metrics.record_lock_acquisition('test_pool_2', 'timeout', 5.0)
-        metrics.set_active_locks('test_pool_1', 2)
-        metrics.record_pool_operation('test_pool_1', 'create')
-        
+        metrics.record_lock_acquisition("test_pool_1", "success", 0.005)
+        metrics.record_lock_acquisition("test_pool_1", "success", 0.003)
+        metrics.record_lock_acquisition("test_pool_2", "timeout", 5.0)
+        metrics.set_active_locks("test_pool_1", 2)
+        metrics.record_pool_operation("test_pool_1", "create")
+
         print("Metrics recorded successfully")
         print("Access metrics at: http://localhost:8000/metrics")
         print("(Start prometheus_client HTTP server to view metrics)")
-        
+
         # Start metrics server (for testing)
         # prometheus_client.start_http_server(8000)
     else:
-        print("Install prometheus_client to enable metrics: pip install prometheus_client")
+        print(
+            "Install prometheus_client to enable metrics: pip install prometheus_client"
+        )

kailash/nodes/ai/llm_agent.py

@@ -1845,6 +1845,144 @@ class LLMAgentNode(Node):
             "efficiency_score": completion_tokens / max(total_tokens, 1),
         }
 
+    def _extract_tool_call_info(self, tool_call) -> dict[str, Any]:
+        """Extract tool call information from both Pydantic models and dictionaries.
+
+        Handles OpenAI v1.97.1+ Pydantic models and legacy dictionary formats.
+
+        Args:
+            tool_call: Tool call object (either Pydantic model or dict)
+
+        Returns:
+            Dict with normalized tool call information
+
+        Raises:
+            ValueError: If tool_call format is unrecognized or invalid
+            json.JSONDecodeError: If tool arguments contain invalid JSON
+        """
+        if tool_call is None:
+            raise ValueError("tool_call cannot be None")
+
+        # Try to detect OpenAI Pydantic model first (more specific check)
+        try:
+            # Import at runtime to avoid dependency issues
+            from openai.types.chat import ChatCompletionMessageToolCall
+
+            if isinstance(tool_call, ChatCompletionMessageToolCall):
+                # OpenAI Pydantic model format - validated type
+                tool_id = tool_call.id
+                function = tool_call.function
+
+                if not function:
+                    raise ValueError(f"Tool call {tool_id} has no function definition")
+
+                tool_name = function.name
+                arguments_str = function.arguments or "{}"
+
+                # Validate required fields
+                if not tool_name:
+                    raise ValueError(f"Tool call {tool_id} has no function name")
+
+                # Check for excessively large arguments (10MB limit)
+                if len(arguments_str) > 10 * 1024 * 1024:
+                    raise ValueError(
+                        f"Tool call {tool_id} arguments too large ({len(arguments_str)} bytes). "
+                        f"Maximum allowed is 10MB."
+                    )
+
+                # Parse arguments - let JSONDecodeError propagate if invalid
+                try:
+                    arguments_dict = json.loads(arguments_str) if arguments_str else {}
+                except json.JSONDecodeError as e:
+                    # Log the error with context but still raise it
+                    self.logger.error(
+                        f"Invalid JSON in tool arguments for {tool_name} (id: {tool_id}): {arguments_str[:100]}... Error: {e}"
+                    )
+                    raise json.JSONDecodeError(
+                        f"Invalid JSON in tool '{tool_name}' arguments: {e.msg}",
+                        e.doc,
+                        e.pos,
+                    )
+
+                self.logger.debug(
+                    f"Extracted Pydantic tool call: {tool_name} (id: {tool_id})"
+                )
+
+                return {
+                    "id": tool_id,
+                    "name": tool_name,
+                    "arguments": arguments_str,
+                    "arguments_dict": arguments_dict,
+                }
+
+        except ImportError:
+            # OpenAI not installed or old version - fall through to dict handling
+            pass
+        except TypeError:
+            # Not a Pydantic model - fall through to dict handling
+            pass
+
+        # Check if it's a dictionary format
+        if isinstance(tool_call, dict):
+            # Legacy dictionary format
+            tool_id = tool_call.get("id")
+            function = tool_call.get("function", {})
+
+            if not tool_id:
+                raise ValueError("Tool call dictionary missing required 'id' field")
+
+            if not isinstance(function, dict):
+                raise ValueError(
+                    f"Tool call {tool_id} 'function' field must be a dictionary"
+                )
+
+            tool_name = function.get("name")
+            arguments_str = function.get("arguments", "{}")
+
+            if not tool_name:
+                raise ValueError(
+                    f"Tool call {tool_id} missing required 'function.name' field"
+                )
+
+            # Check for excessively large arguments (10MB limit)
+            if len(arguments_str) > 10 * 1024 * 1024:
+                raise ValueError(
+                    f"Tool call {tool_id} arguments too large ({len(arguments_str)} bytes). "
+                    f"Maximum allowed is 10MB."
+                )
+
+            # Parse arguments - let JSONDecodeError propagate if invalid
+            try:
+                arguments_dict = json.loads(arguments_str) if arguments_str else {}
+            except json.JSONDecodeError as e:
+                # Log the error with context but still raise it
+                self.logger.error(
+                    f"Invalid JSON in tool arguments for {tool_name} (id: {tool_id}): {arguments_str[:100]}... Error: {e}"
+                )
+                raise json.JSONDecodeError(
+                    f"Invalid JSON in tool '{tool_name}' arguments: {e.msg}",
+                    e.doc,
+                    e.pos,
+                )
+
+            self.logger.debug(
+                f"Extracted dictionary tool call: {tool_name} (id: {tool_id})"
+            )
+
+            return {
+                "id": tool_id,
+                "name": tool_name,
+                "arguments": arguments_str,
+                "arguments_dict": arguments_dict,
+            }
+
+        # Unknown format - raise informative error
+        raise ValueError(
+            f"Unrecognized tool_call format: {type(tool_call)}. "
+            f"Expected OpenAI ChatCompletionMessageToolCall or dict with 'id' and 'function' fields. "
+            f"Got: {repr(tool_call)[:200]}..."
+        )
+
     async def _execute_mcp_tool_call(
         self, tool_call: dict, mcp_tools: list[dict]
     ) -> dict[str, Any]:
@@ -1857,8 +1995,10 @@ class LLMAgentNode(Node):
         Returns:
             Tool execution result
         """
-        tool_name = tool_call.get("function", {}).get("name", "")
-        tool_args = json.loads(tool_call.get("function", {}).get("arguments", "{}"))
+        # Handle both OpenAI Pydantic models and dictionary formats
+        tool_info = self._extract_tool_call_info(tool_call)
+        tool_name = tool_info["name"]
+        tool_args = tool_info["arguments_dict"]
 
         # Find the MCP tool definition
         mcp_tool = None
@@ -1922,8 +2062,10 @@ class LLMAgentNode(Node):
 
         for tool_call in tool_calls:
             try:
-                tool_name = tool_call.get("function", {}).get("name")
-                tool_id = tool_call.get("id")
+                # Handle both OpenAI Pydantic models and dictionary formats
+                tool_info = self._extract_tool_call_info(tool_call)
+                tool_name = tool_info["name"]
+                tool_id = tool_info["id"]
 
                 # Check if this is an MCP tool
                 if tool_name in mcp_tool_names:
@@ -1947,13 +2089,36 @@ class LLMAgentNode(Node):
                     }
                 )
 
+            except (ValueError, json.JSONDecodeError) as e:
+                # Handle extraction errors specifically
+                self.logger.error(f"Tool call extraction failed: {e}")
+                # Try to get minimal info for error reporting
+                if isinstance(tool_call, dict):
+                    tool_id = tool_call.get("id", "unknown")
+                    tool_name = tool_call.get("function", {}).get("name", "unknown")
+                else:
+                    tool_id = getattr(tool_call, "id", "unknown")
+                    tool_name = "unknown"
+
+                tool_results.append(
+                    {
+                        "tool_call_id": tool_id,
+                        "content": json.dumps(
+                            {
+                                "error": f"Invalid tool call format: {str(e)}",
+                                "tool": tool_name,
+                                "status": "failed",
+                            }
+                        ),
+                    }
+                )
             except Exception as e:
-                # Format error result
-                tool_name = tool_call.get("function", {}).get("name", "unknown")
+                # Handle other execution errors
+                # Tool info was already extracted successfully if we got here
                 self.logger.error(f"Tool execution failed for {tool_name}: {e}")
                 tool_results.append(
                     {
-                        "tool_call_id": tool_call.get("id", "unknown"),
+                        "tool_call_id": tool_id,
                         "content": json.dumps(
                             {"error": str(e), "tool": tool_name, "status": "failed"}
                         ),
@@ -1974,8 +2139,10 @@ class LLMAgentNode(Node):
         Returns:
             Tool execution result
         """
-        tool_name = tool_call.get("function", {}).get("name")
-        tool_args = json.loads(tool_call.get("function", {}).get("arguments", "{}"))
+        # Handle both OpenAI Pydantic models and dictionary formats
+        tool_info = self._extract_tool_call_info(tool_call)
+        tool_name = tool_info["name"]
+        tool_args = tool_info["arguments_dict"]
 
         # For now, return a mock result
         # In future, this could execute actual Python functions

kailash/nodes/data/async_sql.py

@@ -1530,15 +1530,28 @@ class SQLiteAdapter(DatabaseAdapter):
 
             if fetch_mode == FetchMode.ONE:
                 row = await cursor.fetchone()
-                return self._convert_row(dict(row)) if row else None
+                result = self._convert_row(dict(row)) if row else None
             elif fetch_mode == FetchMode.ALL:
                 rows = await cursor.fetchall()
-                return [self._convert_row(dict(row)) for row in rows]
+                result = [self._convert_row(dict(row)) for row in rows]
             elif fetch_mode == FetchMode.MANY:
                 if not fetch_size:
                     raise ValueError("fetch_size required for MANY mode")
                 rows = await cursor.fetchmany(fetch_size)
-                return [self._convert_row(dict(row)) for row in rows]
+                result = [self._convert_row(dict(row)) for row in rows]
+            else:
+                result = []
+
+            # Check if this was an INSERT and capture lastrowid for SQLite
+            if query.strip().upper().startswith("INSERT") and (
+                not result or result == [] or result is None
+            ):
+                # For INSERT without RETURNING, capture lastrowid
+                lastrowid = cursor.lastrowid if hasattr(cursor, "lastrowid") else None
+                if lastrowid is not None:
+                    return {"lastrowid": lastrowid}
+
+            return result
         else:
             # Create new connection for non-transactional queries
             if self._is_memory_db:
@@ -1557,6 +1570,19 @@ class SQLiteAdapter(DatabaseAdapter):
                         raise ValueError("fetch_size required for MANY mode")
                     rows = await cursor.fetchmany(fetch_size)
                     result = [self._convert_row(dict(row)) for row in rows]
+                else:
+                    result = []
+
+                # Check if this was an INSERT and capture lastrowid for SQLite
+                if query.strip().upper().startswith("INSERT") and (
+                    not result or result == []
+                ):
+                    # For INSERT without RETURNING, capture lastrowid
+                    lastrowid = (
+                        cursor.lastrowid if hasattr(cursor, "lastrowid") else None
+                    )
+                    if lastrowid is not None:
+                        result = {"lastrowid": lastrowid}
 
                 # Commit for memory databases (needed for INSERT/UPDATE/DELETE)
                 await db.commit()
@@ -1577,9 +1603,24 @@ class SQLiteAdapter(DatabaseAdapter):
                         if not fetch_size:
                             raise ValueError("fetch_size required for MANY mode")
                         rows = await cursor.fetchmany(fetch_size)
-                        return [self._convert_row(dict(row)) for row in rows]
+                        result = [self._convert_row(dict(row)) for row in rows]
+                    else:
+                        result = []
 
-                await db.commit()
+                    # Check if this was an INSERT and capture lastrowid for SQLite
+                    if query.strip().upper().startswith("INSERT") and (
+                        not result or result == []
+                    ):
+                        # For INSERT without RETURNING, capture lastrowid
+                        lastrowid = (
+                            cursor.lastrowid if hasattr(cursor, "lastrowid") else None
+                        )
+                        if lastrowid is not None:
+                            await db.commit()  # Commit before returning
+                            return {"lastrowid": lastrowid}
+
+                    await db.commit()
+                    return result
 
     async def execute_many(
         self,
@@ -3421,28 +3462,37 @@ class AsyncSQLDatabaseNode(AsyncNode):
                 parameter_types=parameter_types,
             )
 
-            # Ensure all data is JSON-serializable (safety net for adapter inconsistencies)
-            result = self._ensure_serializable(result)
+            # Check for special SQLite lastrowid result
+            if isinstance(result, dict) and "lastrowid" in result:
+                # This is a special SQLite INSERT result
+                formatted_data = result  # Keep as-is
+                row_count = 1  # One row was inserted
+            else:
+                # Ensure all data is JSON-serializable (safety net for adapter inconsistencies)
+                result = self._ensure_serializable(result)
 
-            # Format results based on requested format
-            formatted_data = self._format_results(result, result_format)
+                # Format results based on requested format
+                formatted_data = self._format_results(result, result_format)
+                row_count = None  # Will be calculated below
 
             # For DataFrame, we need special handling for row count
-            row_count = 0
-            if result_format == "dataframe":
-                try:
-                    row_count = len(formatted_data)
-                except:
-                    # If pandas isn't available, formatted_data is still a list
+            if row_count is None:  # Only calculate if not already set
+                if result_format == "dataframe":
+                    try:
+                        row_count = len(formatted_data)
+                    except:
+                        # If pandas isn't available, formatted_data is still a list
+                        row_count = (
+                            len(result)
+                            if isinstance(result, list)
+                            else (1 if result else 0)
+                        )
+                else:
                     row_count = (
                         len(result)
                         if isinstance(result, list)
                         else (1 if result else 0)
                     )
-            else:
-                row_count = (
-                    len(result) if isinstance(result, list) else (1 if result else 0)
-                )
 
             # Extract column names if available
             columns = []
@@ -4677,13 +4727,30 @@ class AsyncSQLDatabaseNode(AsyncNode):
             self._adapter = None
 
     def __del__(self):
-        """Ensure connections are closed."""
+        """Ensure connections are closed safely."""
         if self._adapter and self._connected:
-            # Schedule cleanup in the event loop if it exists
+            # Try to schedule cleanup, but be resilient to event loop issues
             try:
-                loop = asyncio.get_event_loop()
-                if not loop.is_closed():
-                    loop.create_task(self.cleanup())
-            except RuntimeError:
-                # No event loop, can't clean up async resources
+                import asyncio
+
+                # Check if there's a running event loop that's not closed
+                try:
+                    loop = asyncio.get_running_loop()
+                    if loop and not loop.is_closed():
+                        # Create cleanup task only if loop is healthy
+                        try:
+                            loop.create_task(self.cleanup())
+                        except RuntimeError as e:
+                            # Loop might be closing, ignore gracefully
+                            logger.debug(f"Could not schedule cleanup task: {e}")
+                    else:
+                        logger.debug("Event loop is closed, skipping async cleanup")
+                except RuntimeError:
+                    # No running event loop - this is normal during shutdown
+                    logger.debug(
+                        "No running event loop for cleanup, connections will be cleaned by GC"
+                    )
+            except Exception as e:
+                # Complete fallback - any unexpected error should not crash __del__
+                logger.debug(f"Error during connection cleanup: {e}")
                 pass

kailash/runtime/local.py

@@ -2333,7 +2333,10 @@ class LocalRuntime:
         else:
             # Standard node execution (backward compatibility)
             try:
-                if hasattr(node, "async_run"):
+                if hasattr(node, "execute_async"):
+                    # For AsyncNode and its subclasses, use execute_async which handles event loop properly
+                    node_result = await node.execute_async(**inputs)
+                elif hasattr(node, "async_run"):
                     node_result = await node.async_run(**inputs)
                 else:
                     node_result = node.execute(**inputs)

{kailash-0.9.17.dist-info → kailash-0.9.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.9.17
+Version: 0.9.19
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum

{kailash-0.9.17.dist-info → kailash-0.9.19.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kailash/__init__.py,sha256=ojLQWITpkyPY6cwQ6jbWBeKWxa6m6nO4h6sdugKCMkQ,3032
+kailash/__init__.py,sha256=UXdg3RRcDvHRZQ_btbIDsx1ekoYuJmtoVuRJKbF-sRo,2928
 kailash/__main__.py,sha256=vr7TVE5o16V6LsTmRFKG6RDKUXHpIWYdZ6Dok2HkHnI,198
 kailash/access_control.py,sha256=MjKtkoQ2sg1Mgfe7ovGxVwhAbpJKvaepPWr8dxOueMA,26058
 kailash/access_control_abac.py,sha256=FPfa_8PuDP3AxTjdWfiH3ntwWO8NodA0py9W8SE5dno,30263
@@ -93,7 +93,7 @@ kailash/mcp_server/oauth.py,sha256=GFC2O2ueiTTI6V-91Huevhc3K8CxrHe22knuHfuCTqY,5
 kailash/mcp_server/protocol.py,sha256=NIdEwJT21JT9ItajXniPNvCbZtTbpqyOC_ZezqsguGE,35694
 kailash/mcp_server/registry_integration.py,sha256=B8CSLq_O1ea3cXrbVjC3bB_OFgHIP-KS9dk77mNM02I,19791
 kailash/mcp_server/server.py,sha256=yFp1F4QQl6gkTY_9JJWmiMiwfT-zACLJLubz-NR5sCw,108675
-kailash/mcp_server/subscriptions.py,sha256=J0FXg6_8lOffQ5SSwm2_DmqIS2pOii6ikxORANLCy1o,58589
+kailash/mcp_server/subscriptions.py,sha256=UK0Ssjab-lHJ16DFPi6lmvLh5xMYNRZia0DgYb6aQ60,58586
 kailash/mcp_server/transports.py,sha256=fBa7CTVYTDb0ZbBQTsZ2d8rKvcVuqBIteczq8eqarr4,49919
 kailash/mcp_server/servers/ai_registry.py,sha256=IdF_keUuJlMsvjLjSAykxxbm46K4qA7eCj7T-lYSrzk,10007
 kailash/mcp_server/utils/__init__.py,sha256=R20N-iiKXUPxc9MOh6vPO1vIfkPmwhEQ5KNFgGd4xSs,771
@@ -151,9 +151,9 @@ kailash/migration/tests/test_compatibility_checker.py,sha256=Gx_lTedk1K-1sIhGDap
 kailash/migration/tests/test_integration.py,sha256=-3j3LZdoaZ5HUcwY99wVM30FrE473rHjSH3i_tu3xNY,17202
 kailash/migration/tests/test_migration_assistant.py,sha256=H0td6dL3Xkw8ivImFcQP_Cuh0WeqDRpbEKJFzuQ1LEc,14615
 kailash/migration/tests/test_performance_comparator.py,sha256=cQgX4DHfqXYGmcKrl77qtlMBRYDs7xjaFxTih0M3XdE,15257
-kailash/monitoring/__init__.py,sha256=41M8uKmU-rWOwNqaDG3Y3uhp0coy6JZE4riMjUMQru4,1167
+kailash/monitoring/__init__.py,sha256=w7We20bpBdcYR3PTfN9lkep8fPEc3T2eenUkNwjdw_s,1167
 kailash/monitoring/alerts.py,sha256=Hk3Xs0EEkOIBH2ZhlejJBOsLYaPlvRejAAEGqNQISc0,21400
-kailash/monitoring/asyncsql_metrics.py,sha256=Wlw8Ypo_WYOsAdjc7YVc3JOxsW4D0ImuZcehKFMLfRs,9487
+kailash/monitoring/asyncsql_metrics.py,sha256=jj9M8D5qHoS3zEFfZYsUCWsy5kb-J5-iYVacmNUaGjE,9577
 kailash/monitoring/metrics.py,sha256=SiAnL3o6K0QaJHgfAuWBa-0pTkW5zymhuPEsj4bgOgM,22022
 kailash/nodes/__init__.py,sha256=zn4M0f-sIPAq8bG5golQIxmEY8lG5d55Kzg8UNL2lAY,6392
 kailash/nodes/__init___original.py,sha256=p2KSo0dyUBCLClU123qpQ0tyv5S_36PTxosNyW58nyY,1031
@@ -184,7 +184,7 @@ kailash/nodes/ai/embedding_generator.py,sha256=akGCzz7zLRSziqEQCiPwL2qWhRWxuM_1R
 kailash/nodes/ai/hybrid_search.py,sha256=k26uDDP_bwrIpv7Yl7PBCPvWSyQEmTlBjI1IpbgDsO4,35446
 kailash/nodes/ai/intelligent_agent_orchestrator.py,sha256=LvBqMKc64zSxFWVCjbLKKel2QwEzoTeJAEgna7rZw00,83097
 kailash/nodes/ai/iterative_llm_agent.py,sha256=h8iP1KFhB_eCDs7UvmY_9y0OUBuprYMj2MLM6dR0W2c,100287
-kailash/nodes/ai/llm_agent.py,sha256=NeNJZbV_VOUbULug2LASwyzLyoUO5wi58Bc9sXTubuc,90181
+kailash/nodes/ai/llm_agent.py,sha256=p7_WFXrkvezUleU8mLPE6JzGd3qRhWCqFIBBiMRnGYA,96943
 kailash/nodes/ai/models.py,sha256=wsEeUTuegy87mnLtKgSTg7ggCXvC1n3MsL-iZ4qujHs,16393
 kailash/nodes/ai/self_organizing.py,sha256=B7NwKaBW8OHQBf5b0F9bSs8Wm-5BDJ9IjIkxS9h00mg,62885
 kailash/nodes/ai/semantic_memory.py,sha256=ZTXIgxwMheux712cN__cNrQ3VgHaKcDyfQv_Gto7MRM,18644
@@ -220,7 +220,7 @@ kailash/nodes/compliance/data_retention.py,sha256=90bH_eGwlcDzUdklAJeXQM-RcuLUGQ
 kailash/nodes/compliance/gdpr.py,sha256=ZMoHZjAo4QtGwtFCzGMrAUBFV3TbZOnJ5DZGZS87Bas,70548
 kailash/nodes/data/__init__.py,sha256=f0h4ysvXxlyFcNJLvDyXrgJ0ixwDF1cS0pJ2QNPakhg,5213
 kailash/nodes/data/async_connection.py,sha256=wfArHs9svU48bxGZIiixSV2YVn9cukNgEjagwTRu6J4,17250
-kailash/nodes/data/async_sql.py,sha256=dhDBn5Ont0XBLnZz0_gG8s_8dossj50J0upuvanU7fw,185523
+kailash/nodes/data/async_sql.py,sha256=9C-XRTDrzpVwFRrI13ym539UajT0Qgh9jmIjisDPi28,188864
 kailash/nodes/data/async_vector.py,sha256=HtwQLO25IXu8Vq80qzU8rMkUAKPQ2qM0x8YxjXHlygU,21005
 kailash/nodes/data/bulk_operations.py,sha256=WVopmosVkIlweFxVt3boLdCPc93EqpYyQ1Ez9mCIt0c,34453
 kailash/nodes/data/directory.py,sha256=fbfLqD_ijRubk-4xew3604QntPsyDxqaF4k6TpfyjDg,9923
@@ -341,7 +341,7 @@ kailash/runtime/async_local.py,sha256=sYNggSU0R-oo8cCvU5ayodDBqASzUhxu994ZvZxDSC
 kailash/runtime/compatibility_reporter.py,sha256=TOQD0ODnJdsxEPyNSYOV_zQxu60X_yvHeu26seFOMEA,19807
 kailash/runtime/docker.py,sha256=sZknVl1PCGfAZeyc0-exTuKlllSyjYlFIgJoiB3CRNs,23500
 kailash/runtime/hierarchical_switch_executor.py,sha256=k6aPGbpf6z2m6dTbHrEyuDR8ZCvOqUanBGYp70arQn0,20782
-kailash/runtime/local.py,sha256=6c2RtT3YisYPnBAOho6lbd4fYyMiJG8EyUBOGmcei_U,201159
+kailash/runtime/local.py,sha256=nIQRWUwSHVg2Daafq_JggBLf-zTDBaGMcwObBzVI0po,201389
 kailash/runtime/parallel.py,sha256=-M9VVG36RxnrrmdbcBe9IjQWb58tAEEo76RQQ2uIXaE,21084
 kailash/runtime/parallel_cyclic.py,sha256=yANZHnePjhCPuCFbq3lFQA1K6jbCv5Of5-vIKbCsmZk,19863
 kailash/runtime/parameter_injection.py,sha256=kG4GhmarsRr5t3VDFbc2G1HSbsZJg6UmienHCE2Ru7o,14852
@@ -424,10 +424,10 @@ kailash/workflow/templates.py,sha256=XQMAKZXC2dlxgMMQhSEOWAF3hIbe9JJt9j_THchhAm8
 kailash/workflow/type_inference.py,sha256=i1F7Yd_Z3elTXrthsLpqGbOnQBIVVVEjhRpI0HrIjd0,24492
 kailash/workflow/validation.py,sha256=LdbIPQSokCqSLfWTBhJR82pa_0va44pcVu9dpEM4rvY,45177
 kailash/workflow/visualization.py,sha256=nHBW-Ai8QBMZtn2Nf3EE1_aiMGi9S6Ui_BfpA5KbJPU,23187
-kailash-0.9.17.dist-info/licenses/LICENSE,sha256=9GYZHXVUmx6FdFRNzOeE_w7a_aEGeYbqTVmFtJlrbGk,13438
-kailash-0.9.17.dist-info/licenses/NOTICE,sha256=9ssIK4LcHSTFqriXGdteMpBPTS1rSLlYtjppZ_bsjZ0,723
-kailash-0.9.17.dist-info/METADATA,sha256=xUZBeaugdsC-xcj_U4bEYCVupaxJA02HCER2c9LmldQ,23528
-kailash-0.9.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kailash-0.9.17.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
-kailash-0.9.17.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
-kailash-0.9.17.dist-info/RECORD,,
+kailash-0.9.19.dist-info/licenses/LICENSE,sha256=9GYZHXVUmx6FdFRNzOeE_w7a_aEGeYbqTVmFtJlrbGk,13438
+kailash-0.9.19.dist-info/licenses/NOTICE,sha256=9ssIK4LcHSTFqriXGdteMpBPTS1rSLlYtjppZ_bsjZ0,723
+kailash-0.9.19.dist-info/METADATA,sha256=RY2liVVkhKdErnyayfo4_vH2OyMVKgvtvimhAT7JWvA,23528
+kailash-0.9.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kailash-0.9.19.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
+kailash-0.9.19.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
+kailash-0.9.19.dist-info/RECORD,,