kader 0.1.5__py3-none-any.whl

kader/agent/logger.py

@@ -0,0 +1,170 @@
+"""
+Logger module for Kader agents.
+
+This module provides logging functionality for agents with memory sessions.
+Logs are written to files in ~/.kader/logs without affecting agent performance.
+Only agents with memory sessions will generate logs.
+"""
+
+import json
+from pathlib import Path
+from threading import Lock
+from typing import Any, Dict, Optional
+
+from loguru import logger
+
+
+class AgentLogger:
+    """
+    Logger class for Kader agents that logs to files with thread-safe operations.
+    Only agents with memory sessions will be logged.
+    """
+
+    def __init__(self):
+        self._loggers = {}
+        self._lock = Lock()
+
+    def setup_logger(
+        self, agent_name: str, session_id: Optional[str] = None
+    ) -> Optional[str]:
+        """
+        Set up logger for an agent with memory session.
+
+        Args:
+            agent_name: Name of the agent
+            session_id: Session ID for the agent
+
+        Returns:
+            Logger ID if successful, None otherwise
+        """
+        if not session_id:
+            # Only log agents with memory sessions
+            return None
+
+        # Create log file path
+        logs_dir = Path.home() / ".kader" / "logs"
+        logs_dir.mkdir(parents=True, exist_ok=True)
+
+        log_filename = f"{agent_name}_{session_id}.log"
+        log_file_path = logs_dir / log_filename
+
+        logger_id = f"{agent_name}_{session_id}"
+
+        # Add file sink with thread-safe configuration
+        with self._lock:
+            if logger_id not in self._loggers:
+                # Remove default handler to avoid console output
+                # We don't remove default handlers globally as other parts of the app might use them
+                # Instead, create a new logger instance for our file logging
+                new_logger = logger.bind(name=logger_id)
+
+                # Remove all existing handlers from this logger instance
+                new_logger.remove()
+
+                # Add file sink with rotation and compression - NO CONSOLE OUTPUT
+                handler_id = new_logger.add(
+                    log_file_path,
+                    format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}",
+                    level="INFO",
+                    rotation="10 MB",
+                    retention="7 days",
+                    compression="zip",
+                    enqueue=True,  # Enables thread-safe logging in a separate thread
+                    serialize=False,
+                    backtrace=True,
+                    diagnose=True,
+                )
+
+                self._loggers[logger_id] = (new_logger, handler_id)
+                return logger_id
+
+        return logger_id
+
+    def log_token_usage(
+        self,
+        logger_id: str,
+        prompt_tokens: int,
+        completion_tokens: int,
+        total_tokens: int,
+    ):
+        """Log token usage information."""
+        if logger_id in self._loggers:
+            logger_instance, _ = self._loggers[logger_id]
+            logger_instance.info(
+                f"TOKEN_USAGE | Prompt tokens: {prompt_tokens}, "
+                f"Completion tokens: {completion_tokens}, "
+                f"Total tokens: {total_tokens}"
+            )
+
+    def calculate_cost(
+        self,
+        logger_id: str,
+        total_cost: float,
+    ):
+        """Calculate and log cost based on token usage."""
+
+        self.log_cost(logger_id, total_cost)
+        return total_cost
+
+    def log_llm_response(self, logger_id: str, response: Any):
+        """Log LLM response."""
+        if logger_id in self._loggers:
+            logger_instance, _ = self._loggers[logger_id]
+            logger_instance.info(f"LLM_RESPONSE | Response: {response}")
+
+    def log_tool_usage(self, logger_id: str, tool_name: str, arguments: Dict[str, Any]):
+        """Log tool usage with arguments."""
+        if logger_id in self._loggers:
+            logger_instance, _ = self._loggers[logger_id]
+            logger_instance.info(
+                f"TOOL_USAGE | Tool: {tool_name}, Arguments: {json.dumps(arguments)}"
+            )
+
+    def log_cost(self, logger_id: str, cost: float):
+        """Log cost information."""
+        if logger_id in self._loggers:
+            logger_instance, _ = self._loggers[logger_id]
+            logger_instance.info(f"COST | Cost: ${cost:.6f}")
+
+    def log_interaction(
+        self,
+        logger_id: str,
+        input_msg: str,
+        output_msg: str,
+        token_usage: Optional[Dict[str, int]] = None,
+        cost: Optional[float] = None,
+        tools_used: Optional[Dict[str, Any]] = None,
+    ):
+        """Log a complete agent interaction with all relevant information."""
+        if logger_id in self._loggers:
+            logger_instance, _ = self._loggers[logger_id]
+
+            log_parts = [f"INTERACTION | Input: {input_msg}"]
+
+            if output_msg:
+                log_parts.append(f"Output: {output_msg}")
+
+            if token_usage:
+                log_parts.append(
+                    f"Tokens - Prompt: {token_usage.get('prompt_tokens', 0)}, "
+                    f"Completion: {token_usage.get('completion_tokens', 0)}, "
+                    f"Total: {token_usage.get('total_tokens', 0)}"
+                )
+
+            if cost is not None:
+                log_parts.append(f"Cost: ${cost:.6f}")
+
+            if tools_used:
+                log_parts.append(f"Tools: {json.dumps(tools_used)}")
+
+            logger_instance.info(" | ".join(log_parts))
+
+    def log_event(self, logger_id: str, event_type: str, data: Dict[str, Any]):
+        """Log a general event with custom data."""
+        if logger_id in self._loggers:
+            logger_instance, _ = self._loggers[logger_id]
+            logger_instance.info(f"{event_type.upper()} | {json.dumps(data)}")
+
+
+# Global logger instance
+agent_logger = AgentLogger()

kader/config.py

@@ -0,0 +1,139 @@
+"""
+Kader configuration management module.
+
+This module handles the creation and management of the .kader directory
+in the user's home directory, including creating the required .env file
+with OLLAMA_API_KEY and loading environment variables.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+
+def load_env_file(env_file_path):
+    """
+    Load environment variables from a .env file.
+    This function reads the .env file and sets the variables in os.environ.
+    """
+    if not env_file_path.exists():
+        return False
+
+    try:
+        with open(env_file_path, "r", encoding="utf-8") as file:
+            for line in file:
+                line = line.strip()
+                # Skip comments and empty lines
+                if line and not line.startswith("#") and "=" in line:
+                    key, value = line.split("=", 1)
+                    key = key.strip()
+                    value = value.strip()
+
+                    # Remove surrounding quotes if present
+                    if value.startswith('"') and value.endswith('"'):
+                        value = value[1:-1]
+                    elif value.startswith("'") and value.endswith("'"):
+                        value = value[1:-1]
+
+                    # Set the environment variable if it's not already set
+                    if key not in os.environ:
+                        os.environ[key] = value
+        return True
+    except Exception as e:
+        print(f"Error loading .env file: {str(e)}")
+        return False
+
+
+def get_kader_directory():
+    """Get the path to the .kader directory in the user's home directory."""
+    return Path.home() / ".kader"
+
+
+def ensure_kader_directory():
+    """
+    Ensure that the .kader directory exists in the user's home directory.
+    Creates it if it doesn't exist.
+    """
+    kader_dir = get_kader_directory()
+
+    # Create the directory if it doesn't exist
+    kader_dir.mkdir(exist_ok=True)
+
+    # Ensure the directory has appropriate permissions on Unix-like systems
+    if not sys.platform.startswith("win"):
+        kader_dir.chmod(0o755)
+
+    return kader_dir
+
+
+def ensure_env_file(kader_dir):
+    """
+    Ensure that the .env file exists in the .kader directory with the
+    required OLLAMA_API_KEY configuration.
+    """
+    env_file = kader_dir / ".env"
+
+    # Create the .env file if it doesn't exist
+    if not env_file.exists():
+        env_file.write_text("OLLAMA_API_KEY=''\n", encoding="utf-8")
+
+        # Set appropriate permissions for the .env file on Unix-like systems
+        if not sys.platform.startswith("win"):
+            env_file.chmod(0o644)
+
+    return env_file
+
+
+def initialize_kader_config():
+    """
+    Initialize the .kader directory in the user's home directory with required configuration files.
+    This function creates the directory, sets up the .env file with OLLAMA_API_KEY,
+    and loads all environment variables from the .env file.
+    """
+    try:
+        # Ensure the .kader directory exists
+        kader_dir = ensure_kader_directory()
+
+        # Ensure the .env file exists with the required configuration
+        ensure_env_file(kader_dir)
+
+        # Load environment variables from the .env file
+        env_file_path = kader_dir / ".env"
+        load_env_file(env_file_path)
+
+        # Optionally add the .kader directory to the Python path so it can be accessed
+        kader_dir_str = str(kader_dir)
+        if kader_dir_str not in sys.path:
+            sys.path.insert(0, kader_dir_str)
+
+        return kader_dir, True
+
+    except PermissionError as e:
+        print(
+            f"Permission denied: Unable to create .kader directory in {Path.home()}. {str(e)}"
+        )
+        return None, False
+    except Exception as e:
+        print(f"Error initializing Kader config: {str(e)}")
+        return None, False
+
+
+# Initialize the configuration when the module is imported
+kader_dir, success = initialize_kader_config()
+
+if success:
+    # Define constants for other modules to use
+    KADER_DIR = kader_dir
+    ENV_FILE_PATH = kader_dir / ".env"
+
+__version__ = "0.1.0"
+__author__ = "Kader Project"
+__all__ = [
+    "KADER_DIR",
+    "ENV_FILE_PATH",
+    "initialize_kader_config",
+    "get_kader_directory",
+    "ensure_kader_directory",
+    "ensure_env_file",
+    "load_env_file",
+]

kader/memory/__init__.py

@@ -0,0 +1,66 @@
+"""
+Kader Memory Module
+
+Provides memory management for agents following the AWS Strands agents SDK hierarchy:
+- State Management: AgentState for persistent state, RequestState for request-scoped context
+- Session Management: FileSessionManager for filesystem-based persistence
+- Conversation Management: SlidingWindowConversationManager for context windowing
+
+Memory is stored locally in $HOME/.kader/memory as directories and JSON files.
+"""
+
+# Core types
+# Conversation management
+from .conversation import (
+    ConversationManager,
+    ConversationMessage,
+    NullConversationManager,
+    SlidingWindowConversationManager,
+)
+
+# Session management
+from .session import (
+    FileSessionManager,
+    Session,
+    SessionManager,
+)
+
+# State management
+from .state import (
+    AgentState,
+    RequestState,
+)
+from .types import (
+    MemoryConfig,
+    SessionType,
+    decode_bytes_values,
+    encode_bytes_values,
+    get_default_memory_dir,
+    get_timestamp,
+    load_json,
+    save_json,
+)
+
+__all__ = [
+    # Types
+    "SessionType",
+    "MemoryConfig",
+    "get_timestamp",
+    "get_default_memory_dir",
+    "save_json",
+    "load_json",
+    "encode_bytes_values",
+    "decode_bytes_values",
+    # State
+    "AgentState",
+    "RequestState",
+    # Session
+    "Session",
+    "SessionManager",
+    "FileSessionManager",
+    # Conversation
+    "ConversationMessage",
+    "ConversationManager",
+    "SlidingWindowConversationManager",
+    "NullConversationManager",
+]