kailash 0.9.17__tar.gz → 0.9.19__tar.gz

{kailash-0.9.17/src/kailash.egg-info → kailash-0.9.19}/PKG-INFO

@@ -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 → kailash-0.9.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kailash"
-version = "0.9.17"
+version = "0.9.19"
 description = "Python SDK for the Kailash container-node architecture"
 authors = [
     {name = "Integrum", email = "info@integrum.com"}

{kailash-0.9.17 → kailash-0.9.19}/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.9.17",
+    version="0.9.19",
     author="Integrum",
     author_email="info@integrum.com",
     description="Python SDK for the Kailash container-node architecture",

{kailash-0.9.17 → kailash-0.9.19}/src/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-0.9.17 → kailash-0.9.19}/src/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-0.9.17 → kailash-0.9.19}/src/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-0.9.17 → kailash-0.9.19}/src/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-0.9.17 → kailash-0.9.19}/src/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