kailash 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

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, AuditLogNode, AuditSeverity
+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
@@ -169,7 +173,7 @@ class SecurityIncident:
 
 
 @register_node()
-class SecurityEventNode(Node):
+class EnterpriseSecurityEventNode(Node):
     """Enterprise security event monitoring and incident response node.
 
     This node provides comprehensive security event processing including:
@@ -412,7 +416,7 @@ class SecurityEventNode(Node):
         self._db_node = AsyncSQLDatabaseNode(name="security_event_db", **db_config)
 
         # Initialize audit logging node
-        self._audit_node = AuditLogNode(database_config=db_config)
+        self._audit_node = EnterpriseAuditLogNode(database_config=db_config)
 
     def _create_event(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
         """Create a new security event with risk scoring."""

kailash/nodes/ai/ai_providers.py

@@ -8,7 +8,11 @@ separation between LLM and embedding capabilities.
 
 import hashlib
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, Dict, List, Union
+
+# Type definitions for flexible message content
+MessageContent = Union[str, List[Dict[str, Any]]]
+Message = Dict[str, Union[str, MessageContent]]
 
 
 class BaseAIProvider(ABC):
@@ -205,12 +209,14 @@ class LLMProvider(BaseAIProvider):
         self._capabilities["chat"] = True
 
     @abstractmethod
-    def chat(self, messages: list[dict[str, str]], **kwargs) -> dict[str, Any]:
+    def chat(self, messages: List[Message], **kwargs) -> dict[str, Any]:
         """
         Generate a chat completion using the provider's LLM.
 
         Args:
             messages: Conversation messages in OpenAI format
+                     Can be simple: [{"role": "user", "content": "text"}]
+                     Or complex: [{"role": "user", "content": [{"type": "text", "text": "..."}, {"type": "image", "path": "..."}]}]
             **kwargs: Provider-specific parameters
 
         Returns:
@@ -391,7 +397,7 @@ class OllamaProvider(UnifiedAIProvider):
 
         return self._available
 
-    def chat(self, messages: list[dict[str, str]], **kwargs) -> dict[str, Any]:
+    def chat(self, messages: List[Message], **kwargs) -> dict[str, Any]:
         """Generate a chat completion using Ollama.
 
         Args:
@@ -435,8 +441,50 @@ class OllamaProvider(UnifiedAIProvider):
             # Remove None values
             options = {k: v for k, v in options.items() if v is not None}
 
+            # Process messages for vision content
+            processed_messages = []
+
+            for msg in messages:
+                if isinstance(msg.get("content"), list):
+                    # Complex content with potential images
+                    text_parts = []
+                    images = []
+
+                    for item in msg["content"]:
+                        if item["type"] == "text":
+                            text_parts.append(item["text"])
+                        elif item["type"] == "image":
+                            # Lazy load vision utilities
+                            from .vision_utils import encode_image
+
+                            if "path" in item:
+                                # For file paths, read the file directly
+                                with open(item["path"], "rb") as f:
+                                    images.append(f.read())
+                            else:
+                                # For base64, decode it to bytes
+                                import base64
+
+                                base64_data = item.get("base64", "")
+                                images.append(base64.b64decode(base64_data))
+
+                    # Ollama expects images as part of the message
+                    message_dict = {
+                        "role": msg["role"],
+                        "content": " ".join(text_parts),
+                    }
+                    if images:
+                        message_dict["images"] = images
+
+                    processed_messages.append(message_dict)
+                else:
+                    # Simple string content (backward compatible)
+                    processed_messages.append(msg)
+
             # Call Ollama
-            response = ollama.chat(model=model, messages=messages, options=options)
+            response = ollama.chat(
+                model=model, messages=processed_messages, options=options
+            )
 
             # Format response to match standard structure
             return {
@@ -545,11 +593,18 @@ class OpenAIProvider(UnifiedAIProvider):
     - Install openai package: `pip install openai`
 
     Supported LLM models:
-    - gpt-4-turbo (latest GPT-4 Turbo)
-    - gpt-4 (standard GPT-4)
-    - gpt-4-32k (32k context window)
-    - gpt-3.5-turbo (latest GPT-3.5)
-    - gpt-3.5-turbo-16k (16k context window)
+    - o4-mini (latest, vision support, recommended)
+    - o3 (reasoning model)
+
+    Note: This provider uses max_completion_tokens parameter compatible with
+    latest OpenAI models. Older models (gpt-4, gpt-3.5-turbo) are not supported.
+
+    Generation Config Parameters:
+    - max_completion_tokens (int): Maximum tokens to generate (recommended)
+    - max_tokens (int): Deprecated, use max_completion_tokens instead
+    - temperature (float): Sampling temperature (0-2)
+    - top_p (float): Nucleus sampling probability
+    - Other standard OpenAI parameters
 
     Supported embedding models:
     - text-embedding-3-large (3072 dimensions, configurable)
@@ -572,19 +627,22 @@ class OpenAIProvider(UnifiedAIProvider):
 
         return self._available
 
-    def chat(self, messages: list[dict[str, str]], **kwargs) -> dict[str, Any]:
+    def chat(self, messages: List[Message], **kwargs) -> dict[str, Any]:
         """
         Generate a chat completion using OpenAI.
 
         Supported kwargs:
-        - model (str): OpenAI model name (default: "gpt-4")
-        - generation_config (dict): Generation parameters
+        - model (str): OpenAI model name (default: "o4-mini")
+        - generation_config (dict): Generation parameters including:
+            - max_completion_tokens (int): Max tokens to generate (recommended)
+            - max_tokens (int): Deprecated, use max_completion_tokens
+            - temperature, top_p, frequency_penalty, presence_penalty, etc.
         - tools (List[Dict]): Function/tool definitions for function calling
         """
         try:
             import openai
 
-            model = kwargs.get("model", "gpt-4")
+            model = kwargs.get("model", "o4-mini")
             generation_config = kwargs.get("generation_config", {})
             tools = kwargs.get("tools", [])
 
@@ -592,13 +650,86 @@ class OpenAIProvider(UnifiedAIProvider):
             if self._client is None:
                 self._client = openai.OpenAI()
 
+            # Process messages for vision content
+            processed_messages = []
+            for msg in messages:
+                if isinstance(msg.get("content"), list):
+                    # Complex content with potential images
+                    processed_content = []
+                    for item in msg["content"]:
+                        if item.get("type") == "text":
+                            processed_content.append(
+                                {"type": "text", "text": item.get("text", "")}
+                            )
+                        elif item.get("type") == "image":
+                            # Lazy load vision utilities
+                            from .vision_utils import (
+                                encode_image,
+                                get_media_type,
+                                validate_image_size,
+                            )
+
+                            if "path" in item:
+                                # Validate image size
+                                is_valid, error_msg = validate_image_size(item["path"])
+                                if not is_valid:
+                                    raise ValueError(
+                                        f"Image validation failed: {error_msg}"
+                                    )
+
+                                base64_image = encode_image(item["path"])
+                                media_type = get_media_type(item["path"])
+                            elif "base64" in item:
+                                base64_image = item["base64"]
+                                media_type = item.get("media_type", "image/jpeg")
+                            else:
+                                raise ValueError(
+                                    "Image item must have either 'path' or 'base64' field"
+                                )
+
+                            processed_content.append(
+                                {
+                                    "type": "image_url",
+                                    "image_url": {
+                                        "url": f"data:{media_type};base64,{base64_image}"
+                                    },
+                                }
+                            )
+
+                    processed_messages.append(
+                        {"role": msg.get("role", "user"), "content": processed_content}
+                    )
+                else:
+                    # Simple string content (backward compatible)
+                    processed_messages.append(msg)
+
+            # Handle max tokens parameter - support both old and new names
+            max_completion = generation_config.get(
+                "max_completion_tokens"
+            ) or generation_config.get("max_tokens", 500)
+
+            # Show deprecation warning if using old parameter
+            # TODO: remove the max_tokens in the future.
+            if (
+                "max_tokens" in generation_config
+                and "max_completion_tokens" not in generation_config
+            ):
+                import warnings
+
+                warnings.warn(
+                    "'max_tokens' is deprecated and will be removed in v0.5.0. "
+                    "Please use 'max_completion_tokens' instead.",
+                    DeprecationWarning,
+                    stacklevel=3,
+                )
+
             # Prepare request
             request_params = {
                 "model": model,
-                "messages": messages,
-                "temperature": generation_config.get("temperature", 0.7),
-                "max_tokens": generation_config.get("max_tokens", 500),
-                "top_p": generation_config.get("top_p", 0.9),
+                "messages": processed_messages,
+                "temperature": generation_config.get("temperature", 1.0),
+                "max_completion_tokens": max_completion,  # Always use new parameter
+                "top_p": generation_config.get("top_p", 1.0),
                 "frequency_penalty": generation_config.get("frequency_penalty"),
                 "presence_penalty": generation_config.get("presence_penalty"),
                 "stop": generation_config.get("stop"),
@@ -649,6 +780,15 @@ class OpenAIProvider(UnifiedAIProvider):
             raise RuntimeError(
                 "OpenAI library not installed. Install with: pip install openai"
             )
+        except openai.BadRequestError as e:
+            # Provide helpful error message for unsupported models or parameters
+            if "max_tokens" in str(e):
+                raise RuntimeError(
+                    "This OpenAI provider requires models that support max_completion_tokens. "
+                    "Please use o4-mini, o3 "
+                    "Older models like gpt-4o or gpt-3.5-turbo are not supported."
+                )
+            raise RuntimeError(f"OpenAI API error: {str(e)}")
         except Exception as e:
             raise RuntimeError(f"OpenAI error: {str(e)}")
 
@@ -772,7 +912,7 @@ class AnthropicProvider(LLMProvider):
 
         return self._available
 
-    def chat(self, messages: list[dict[str, str]], **kwargs) -> dict[str, Any]:
+    def chat(self, messages: List[Message], **kwargs) -> dict[str, Any]:
         """Generate a chat completion using Anthropic."""
         try:
             import anthropic
@@ -790,22 +930,75 @@ class AnthropicProvider(LLMProvider):
 
             for msg in messages:
                 if msg["role"] == "system":
-                    system_message = msg["content"]
+                    # System messages are always text
+                    system_message = (
+                        msg["content"]
+                        if isinstance(msg["content"], str)
+                        else str(msg["content"])
+                    )
                 else:
-                    user_messages.append(msg)
-
-            # Call Anthropic
-            response = self._client.messages.create(
-                model=model,
-                messages=user_messages,
-                system=system_message,
-                max_tokens=generation_config.get("max_tokens", 500),
-                temperature=generation_config.get("temperature", 0.7),
-                top_p=generation_config.get("top_p"),
-                top_k=generation_config.get("top_k"),
-                stop_sequences=generation_config.get("stop_sequences"),
-                metadata=generation_config.get("metadata"),
-            )
+                    # Process potentially complex content
+                    if isinstance(msg.get("content"), list):
+                        # Complex content with potential images
+                        content_parts = []
+
+                        for item in msg["content"]:
+                            if item["type"] == "text":
+                                content_parts.append(
+                                    {"type": "text", "text": item["text"]}
+                                )
+                            elif item["type"] == "image":
+                                # Lazy load vision utilities
+                                from .vision_utils import encode_image, get_media_type
+
+                                if "path" in item:
+                                    base64_image = encode_image(item["path"])
+                                    media_type = get_media_type(item["path"])
+                                else:
+                                    base64_image = item.get("base64", "")
+                                    media_type = item.get("media_type", "image/jpeg")
+
+                                content_parts.append(
+                                    {
+                                        "type": "image",
+                                        "source": {
+                                            "type": "base64",
+                                            "media_type": media_type,
+                                            "data": base64_image,
+                                        },
+                                    }
+                                )
+
+                        user_messages.append(
+                            {"role": msg["role"], "content": content_parts}
+                        )
+                    else:
+                        # Simple string content (backward compatible)
+                        user_messages.append(msg)
+
+            # Call Anthropic - build kwargs to avoid passing None values
+            create_kwargs = {
+                "model": model,
+                "messages": user_messages,
+                "max_tokens": generation_config.get("max_tokens", 500),
+                "temperature": generation_config.get("temperature", 0.7),
+            }
+
+            # Only add optional parameters if they have valid values
+            if system_message is not None:
+                create_kwargs["system"] = system_message
+            if generation_config.get("top_p") is not None:
+                create_kwargs["top_p"] = generation_config.get("top_p")
+            if generation_config.get("top_k") is not None:
+                create_kwargs["top_k"] = generation_config.get("top_k")
+            if generation_config.get("stop_sequences") is not None:
+                create_kwargs["stop_sequences"] = generation_config.get(
+                    "stop_sequences"
+                )
+            if generation_config.get("metadata") is not None:
+                create_kwargs["metadata"] = generation_config.get("metadata")
+
+            response = self._client.messages.create(**create_kwargs)
 
             # Format response
             return {
@@ -1232,16 +1425,33 @@ class MockProvider(UnifiedAIProvider):
         """Mock provider is always available."""
         return True
 
-    def chat(self, messages: list[dict[str, str]], **kwargs) -> dict[str, Any]:
+    def chat(self, messages: List[Message], **kwargs) -> dict[str, Any]:
         """Generate mock LLM response."""
         last_user_message = ""
+        has_images = False
+
         for msg in reversed(messages):
             if msg.get("role") == "user":
-                last_user_message = msg.get("content", "")
+                content = msg.get("content", "")
+                # Handle complex content with images
+                if isinstance(content, list):
+                    text_parts = []
+                    for item in content:
+                        if item.get("type") == "text":
+                            text_parts.append(item.get("text", ""))
+                        elif item.get("type") == "image":
+                            has_images = True
+                    last_user_message = " ".join(text_parts)
+                else:
+                    last_user_message = content
                 break
 
         # Generate contextual mock response
-        if "analyze" in last_user_message.lower():
+        if has_images:
+            response_content = (
+                "I can see the image(s) you've provided. [Mock vision response]"
+            )
+        elif "analyze" in last_user_message.lower():
             response_content = "Based on the provided data and context, I can see several key patterns..."
         elif "create" in last_user_message.lower():
             response_content = "I'll help you create that. Based on the requirements..."
@@ -1259,10 +1469,7 @@ class MockProvider(UnifiedAIProvider):
             "tool_calls": [],
             "finish_reason": "stop",
             "usage": {
-                "prompt_tokens": len(
-                    " ".join(msg.get("content", "") for msg in messages)
-                )
-                // 4,
+                "prompt_tokens": 100,  # Mock value
                 "completion_tokens": len(response_content) // 4,
                 "total_tokens": 0,  # Will be calculated
             },

kailash/nodes/ai/llm_agent.py

@@ -1412,13 +1412,28 @@ class LLMAgentNode(Node):
     ) -> dict[str, Any]:
         """Generate mock LLM response for testing."""
         last_user_message = ""
+        has_images = False
+
         for msg in reversed(messages):
             if msg.get("role") == "user":
-                last_user_message = msg.get("content", "")
+                content = msg.get("content", "")
+                # Handle complex content with images
+                if isinstance(content, list):
+                    text_parts = []
+                    for item in content:
+                        if item.get("type") == "text":
+                            text_parts.append(item.get("text", ""))
+                        elif item.get("type") == "image":
+                            has_images = True
+                    last_user_message = " ".join(text_parts)
+                else:
+                    last_user_message = content
                 break
 
         # Generate contextual mock response
-        if "analyze" in last_user_message.lower():
+        if has_images:
+            response_content = "I can see the image(s) you've provided. Based on my analysis, [Mock vision response for testing]"
+        elif "analyze" in last_user_message.lower():
             response_content = "Based on the provided data and context, I can see several key patterns: 1) Customer engagement has increased by 15% this quarter, 2) Product A shows the highest conversion rate, and 3) There are opportunities for improvement in the onboarding process."
         elif (
             "create" in last_user_message.lower()
@@ -1458,7 +1473,18 @@ class LLMAgentNode(Node):
             "finish_reason": "stop" if not tool_calls else "tool_calls",
             "usage": {
                 "prompt_tokens": len(
-                    " ".join(msg.get("content", "") for msg in messages)
+                    " ".join(
+                        (
+                            msg.get("content", "")
+                            if isinstance(msg.get("content"), str)
+                            else " ".join(
+                                item.get("text", "")
+                                for item in msg.get("content", [])
+                                if item.get("type") == "text"
+                            )
+                        )
+                        for msg in messages
+                    )
                 )
                 // 4,
                 "completion_tokens": len(response_content) // 4,

kailash/nodes/ai/vision_utils.py

@@ -0,0 +1,148 @@
+"""Vision utilities for AI providers - lazy loaded to avoid overhead."""
+
+from pathlib import Path
+from typing import Optional, Tuple
+
+
+def encode_image(image_path: str) -> str:
+    """
+    Encode image file to base64 string.
+
+    Args:
+        image_path: Path to the image file
+
+    Returns:
+        Base64 encoded string of the image
+
+    Raises:
+        FileNotFoundError: If image file doesn't exist
+        IOError: If unable to read the image file
+    """
+    # Lazy import to avoid overhead when not using vision
+    import base64
+
+    image_path = Path(image_path).resolve()
+    if not image_path.exists():
+        raise FileNotFoundError(f"Image file not found: {image_path}")
+
+    try:
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode("utf-8")
+    except Exception as e:
+        raise IOError(f"Failed to read image file: {e}")
+
+
+def get_media_type(image_path: str) -> str:
+    """
+    Get media type from file extension.
+
+    Args:
+        image_path: Path to the image file
+
+    Returns:
+        Media type string (e.g., "image/jpeg")
+    """
+    ext = Path(image_path).suffix.lower()
+    media_types = {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".gif": "image/gif",
+        ".webp": "image/webp",
+        ".bmp": "image/bmp",
+        ".tiff": "image/tiff",
+        ".tif": "image/tiff",
+    }
+    return media_types.get(ext, "image/jpeg")
+
+
+def validate_image_size(
+    image_path: str, max_size_mb: float = 20.0
+) -> Tuple[bool, Optional[str]]:
+    """
+    Validate image file size.
+
+    Args:
+        image_path: Path to the image file
+        max_size_mb: Maximum allowed size in megabytes
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    import os
+
+    try:
+        size_bytes = os.path.getsize(image_path)
+        size_mb = size_bytes / (1024 * 1024)
+
+        if size_mb > max_size_mb:
+            return False, f"Image size {size_mb:.1f}MB exceeds maximum {max_size_mb}MB"
+
+        return True, None
+    except Exception as e:
+        return False, f"Failed to check image size: {e}"
+
+
+def resize_image_if_needed(
+    image_path: str, max_size_mb: float = 20.0, max_dimension: int = 4096
+) -> Optional[str]:
+    """
+    Resize image if it exceeds size or dimension limits.
+
+    Args:
+        image_path: Path to the image file
+        max_size_mb: Maximum file size in MB
+        max_dimension: Maximum width or height in pixels
+
+    Returns:
+        Base64 encoded resized image, or None if no resize needed
+    """
+    try:
+        # Lazy import to avoid PIL dependency when not using vision
+        import base64
+        import io
+
+        from PIL import Image
+
+        # Check if resize is needed
+        is_valid, _ = validate_image_size(image_path, max_size_mb)
+
+        with Image.open(image_path) as img:
+            # Check dimensions
+            needs_resize = (
+                not is_valid or img.width > max_dimension or img.height > max_dimension
+            )
+
+            if not needs_resize:
+                return None
+
+            # Calculate new size maintaining aspect ratio
+            ratio = min(max_dimension / img.width, max_dimension / img.height, 1.0)
+            new_size = (int(img.width * ratio), int(img.height * ratio))
+
+            # Resize image
+            img = img.resize(new_size, Image.Resampling.LANCZOS)
+
+            # Convert to RGB if necessary (for JPEG)
+            if img.mode not in ("RGB", "L"):
+                img = img.convert("RGB")
+
+            # Save to bytes
+            output = io.BytesIO()
+            img_format = (
+                "JPEG"
+                if Path(image_path).suffix.lower() in [".jpg", ".jpeg"]
+                else "PNG"
+            )
+            img.save(output, format=img_format, optimize=True, quality=85)
+
+            # Encode to base64
+            output.seek(0)
+            return base64.b64encode(output.read()).decode("utf-8")
+
+    except ImportError:
+        # PIL not available, skip resizing
+        return None
+    except Exception:
+        # Any error in resizing, return None to use original
+        return None

kailash/nodes/alerts/__init__.py

@@ -0,0 +1,26 @@
+"""Alert and notification nodes for the Kailash SDK.
+
+This module provides specialized nodes for sending alerts and notifications
+through various channels. Each alert node follows a consistent interface while
+providing channel-specific features and optimizations.
+
+The module includes:
+- Base alert node infrastructure
+- Discord webhook integration
+- (Future) Slack, email, webhook, and other integrations
+
+Design Philosophy:
+- Provide purpose-built nodes for common alert patterns
+- Abstract channel-specific complexity
+- Support both simple and advanced use cases
+- Enable consistent alert formatting across channels
+"""
+
+from .base import AlertNode, AlertSeverity
+from .discord import DiscordAlertNode
+
+__all__ = [
+    "AlertNode",
+    "AlertSeverity",
+    "DiscordAlertNode",
+]