chuk-ai-session-manager 0.7.1__py3-none-any.whl → 0.8__py3-none-any.whl

chuk_ai_session_manager/__init__.py

@@ -4,7 +4,7 @@ CHUK AI Session Manager - Simple Developer API
 
 A powerful session management system for AI applications that provides:
 - Automatic conversation tracking
-- Token usage monitoring  
+- Token usage monitoring
 - Tool call logging
 - Infinite context support with automatic summarization
 - Hierarchical session relationships
@@ -32,12 +32,12 @@ Infinite Context Example:
 Storage Configuration:
     # Default: Memory storage (no Redis required)
     pip install chuk-ai-session-manager
-    
+
     # Redis: For production persistence
     pip install chuk-ai-session-manager[redis]
     export SESSION_PROVIDER=redis
     export SESSION_REDIS_URL=redis://localhost:6379/0
-    
+
     # Environment variables:
     SESSION_PROVIDER=memory (default - fast, no persistence)
     SESSION_PROVIDER=redis  (persistent - requires [redis] extra)
@@ -46,7 +46,7 @@ Storage Configuration:
 import logging
 
 # Package version
-__version__ = "0.5"
+__version__ = "0.8"
 
 # Set up package-level logger
 logger = logging.getLogger(__name__)
@@ -63,7 +63,7 @@ from chuk_ai_session_manager.exceptions import (
     InvalidSessionOperation,
     TokenLimitExceeded,
     StorageError,
-    ToolProcessingError
+    ToolProcessingError,
 )
 
 # Core models
@@ -87,36 +87,66 @@ from chuk_ai_session_manager.api.simple_api import (
     track_infinite_conversation,
     track_tool_use,
     get_session_stats,
-    get_conversation_history
+    get_conversation_history,
 )
 
 # Advanced components
 from chuk_ai_session_manager.infinite_conversation import (
     InfiniteConversationManager,
-    SummarizationStrategy
+    SummarizationStrategy,
 )
 
-from chuk_ai_session_manager.session_aware_tool_processor import SessionAwareToolProcessor
+from chuk_ai_session_manager.session_aware_tool_processor import (
+    SessionAwareToolProcessor,
+)
 
 from chuk_ai_session_manager.session_prompt_builder import (
     build_prompt_from_session,
     PromptStrategy,
-    truncate_prompt_to_token_limit
+    truncate_prompt_to_token_limit,
 )
 
+# Procedural memory
+from chuk_ai_session_manager.procedural_memory import (
+    ToolMemoryManager,
+    ToolOutcome,
+    ToolLogEntry,
+    ToolPattern,
+    ProceduralMemory,
+    ProceduralContextFormatter,
+    FormatterConfig,
+)
+
+# Guards and state management
+from chuk_ai_session_manager.guards import (
+    ToolStateManager,
+    get_tool_state,
+    reset_tool_state,
+    BindingManager,
+    ResultCache,
+    UngroundedGuard,
+    UngroundedGuardConfig,
+    RuntimeLimits,
+    RuntimeMode,
+    ValueBinding,
+    ToolClassification,
+)
+
+
 # Configuration functions
-def configure_storage(sandbox_id: str = "chuk-ai-session-manager", 
-                     default_ttl_hours: int = 24) -> bool:
+def configure_storage(
+    sandbox_id: str = "chuk-ai-session-manager", default_ttl_hours: int = 24
+) -> bool:
     """
     Configure the storage backend.
-    
+
     Args:
         sandbox_id: CHUK Sessions sandbox ID to use
         default_ttl_hours: Default TTL for sessions
-        
+
     Returns:
         True if configuration was successful, False otherwise
-        
+
     Note:
         Storage provider is controlled by SESSION_PROVIDER environment variable:
         - memory (default): Fast, no persistence, no extra dependencies
@@ -124,8 +154,7 @@ def configure_storage(sandbox_id: str = "chuk-ai-session-manager",
     """
     try:
         setup_chuk_sessions_storage(
-            sandbox_id=sandbox_id,
-            default_ttl_hours=default_ttl_hours
+            sandbox_id=sandbox_id, default_ttl_hours=default_ttl_hours
         )
         logger.info(f"Storage configured with sandbox_id='{sandbox_id}'")
         return True
@@ -142,26 +171,28 @@ def get_version() -> str:
 def is_available() -> dict:
     """
     Check which components are available.
-    
+
     Returns:
         Dictionary showing availability of each component
     """
     # Check if Redis is available
     redis_available = False
     try:
-        import redis
+        import redis  # noqa: F401
+
         redis_available = True
     except ImportError:
         pass
-    
+
     # Check if tiktoken is available for enhanced token counting
     tiktoken_available = False
     try:
-        import tiktoken
+        import tiktoken  # noqa: F401
+
         tiktoken_available = True
     except ImportError:
         pass
-    
+
     return {
         "core_enums": True,
         "core_models": True,
@@ -181,53 +212,47 @@ def is_available() -> dict:
 def get_storage_info() -> dict:
     """
     Get information about the current storage configuration.
-    
+
     Returns:
         Dictionary with storage configuration details
     """
     import os
     from chuk_ai_session_manager.session_storage import get_backend
-    
+
     try:
         backend = get_backend()
         stats = backend.get_stats()
-        
+
         return {
             "provider": os.getenv("SESSION_PROVIDER", "memory"),
             "backend": stats.get("backend", "unknown"),
             "sandbox_id": stats.get("sandbox_id", "unknown"),
             "redis_url": os.getenv("SESSION_REDIS_URL", "not_set"),
-            "stats": stats
+            "stats": stats,
         }
     except Exception as e:
-        return {
-            "provider": os.getenv("SESSION_PROVIDER", "memory"),
-            "error": str(e)
-        }
+        return {"provider": os.getenv("SESSION_PROVIDER", "memory"), "error": str(e)}
 
 
 # Main exports - everything should be available
 __all__ = [
     # Version and utilities
     "__version__",
-    "get_version", 
+    "get_version",
     "is_available",
     "configure_storage",
     "get_storage_info",
-    
     # Core enums
     "EventSource",
     "EventType",
-    
     # Exception classes
     "SessionManagerError",
-    "SessionNotFound", 
+    "SessionNotFound",
     "SessionAlreadyExists",
     "InvalidSessionOperation",
     "TokenLimitExceeded",
     "StorageError",
     "ToolProcessingError",
-    
     # Core models
     "Session",
     "SessionEvent",
@@ -236,20 +261,17 @@ __all__ = [
     "RunStatus",
     "TokenUsage",
     "TokenSummary",
-    
     # Storage
     "setup_chuk_sessions_storage",
-    
     # Primary interfaces - what most users will use
     "SessionManager",
-    "track_conversation", 
+    "track_conversation",
     "track_llm_call",
     "quick_conversation",
     "track_infinite_conversation",
     "track_tool_use",
     "get_session_stats",
     "get_conversation_history",
-    
     # Advanced components
     "InfiniteConversationManager",
     "SummarizationStrategy",
@@ -257,6 +279,26 @@ __all__ = [
     "build_prompt_from_session",
     "PromptStrategy",
     "truncate_prompt_to_token_limit",
+    # Procedural memory
+    "ToolMemoryManager",
+    "ToolOutcome",
+    "ToolLogEntry",
+    "ToolPattern",
+    "ProceduralMemory",
+    "ProceduralContextFormatter",
+    "FormatterConfig",
+    # Guards and state management
+    "ToolStateManager",
+    "get_tool_state",
+    "reset_tool_state",
+    "BindingManager",
+    "ResultCache",
+    "UngroundedGuard",
+    "UngroundedGuardConfig",
+    "RuntimeLimits",
+    "RuntimeMode",
+    "ValueBinding",
+    "ToolClassification",
 ]
 
 # Auto-setup storage on import
@@ -270,6 +312,8 @@ except Exception as e:
 try:
     storage_info = get_storage_info()
     provider = storage_info.get("provider", "unknown")
-    logger.debug(f"CHUK AI Session Manager v{__version__} imported successfully (storage: {provider})")
+    logger.debug(
+        f"CHUK AI Session Manager v{__version__} imported successfully (storage: {provider})"
+    )
 except Exception:
-    logger.debug(f"CHUK AI Session Manager v{__version__} imported successfully")
+    logger.debug(f"CHUK AI Session Manager v{__version__} imported successfully")

chuk_ai_session_manager/api/__init__.py

@@ -1 +1 @@
-# chuk_ai_session_manager/api/__init__.py
+# chuk_ai_session_manager/api/__init__.py

chuk_ai_session_manager/api/simple_api.py

@@ -7,10 +7,10 @@ building on top of the SessionManager class.
 
 Usage:
     from chuk_ai_session_manager import track_conversation
-    
+
     # Quick tracking
     await track_conversation("Hello!", "Hi there!")
-    
+
     # Track with model info
     await track_conversation(
         "What's the weather?",
@@ -18,7 +18,7 @@ Usage:
         model="gpt-4",
         provider="openai"
     )
-    
+
     # Infinite context
     await track_infinite_conversation(
         "Tell me a long story",
@@ -43,14 +43,14 @@ async def track_conversation(
     provider: str = "unknown",
     session_id: Optional[str] = None,
     infinite_context: bool = False,
-    token_threshold: int = 4000
+    token_threshold: int = 4000,
 ) -> str:
     """
     Quick way to track a single conversation turn.
-    
+
     This is the simplest way to track a conversation exchange between
     a user and an AI assistant.
-    
+
     Args:
         user_message: What the user said.
         ai_response: What the AI responded.
@@ -59,10 +59,10 @@ async def track_conversation(
         session_id: Optional existing session ID to continue.
         infinite_context: Enable infinite context support.
         token_threshold: Token limit for infinite context segmentation.
-        
+
     Returns:
         The session ID (useful for continuing the conversation).
-        
+
     Example:
         ```python
         session_id = await track_conversation(
@@ -76,7 +76,7 @@ async def track_conversation(
     sm = SessionManager(
         session_id=session_id,
         infinite_context=infinite_context,
-        token_threshold=token_threshold
+        token_threshold=token_threshold,
     )
     await sm.user_says(user_message)
     session_id = await sm.ai_responds(ai_response, model=model, provider=provider)
@@ -91,14 +91,14 @@ async def track_llm_call(
     session_manager: Optional[SessionManager] = None,
     session_id: Optional[str] = None,
     infinite_context: bool = False,
-    token_threshold: int = 4000
+    token_threshold: int = 4000,
 ) -> tuple[str, str]:
     """
     Track an LLM call automatically.
-    
+
     This function wraps your LLM call and automatically tracks both the
     input and output in a session.
-    
+
     Args:
         user_input: The user's input to the LLM.
         llm_function: Function that calls the LLM (sync or async).
@@ -108,16 +108,16 @@ async def track_llm_call(
         session_id: Optional session ID if not using session_manager.
         infinite_context: Enable infinite context support.
         token_threshold: Token limit for infinite context.
-        
+
     Returns:
         Tuple of (response_text, session_id).
-        
+
     Example:
         ```python
         async def call_openai(prompt):
             # Your OpenAI call here
             return response.choices[0].message.content
-            
+
         response, session_id = await track_llm_call(
             "Explain quantum computing",
             call_openai,
@@ -130,17 +130,17 @@ async def track_llm_call(
         session_manager = SessionManager(
             session_id=session_id,
             infinite_context=infinite_context,
-            token_threshold=token_threshold
+            token_threshold=token_threshold,
         )
-    
+
     await session_manager.user_says(user_input)
-    
+
     # Call the LLM function
     if asyncio.iscoroutinefunction(llm_function):
         ai_response = await llm_function(user_input)
     else:
         ai_response = llm_function(user_input)
-    
+
     # Handle different response formats
     if isinstance(ai_response, dict) and "choices" in ai_response:
         # OpenAI format
@@ -151,11 +151,11 @@ async def track_llm_call(
     else:
         # Plain string or other
         response_text = str(ai_response)
-    
+
     session_id = await session_manager.ai_responds(
         response_text, model=model, provider=provider
     )
-    
+
     return response_text, session_id
 
 
@@ -164,24 +164,24 @@ async def quick_conversation(
     ai_response: str,
     model: str = "unknown",
     provider: str = "unknown",
-    infinite_context: bool = False
+    infinite_context: bool = False,
 ) -> Dict[str, Any]:
     """
     Quickest way to track a conversation and get basic stats.
-    
+
     This is perfect for one-off tracking where you want immediate
     statistics about the conversation.
-    
+
     Args:
         user_message: What the user said.
         ai_response: What the AI responded.
         model: The model used.
         provider: The provider used.
         infinite_context: Enable infinite context support.
-        
+
     Returns:
         Dictionary with conversation statistics.
-        
+
     Example:
         ```python
         stats = await quick_conversation(
@@ -195,11 +195,11 @@ async def quick_conversation(
     """
     # Create a new session manager
     sm = SessionManager(infinite_context=infinite_context)
-    
+
     # Track the conversation
     await sm.user_says(user_message)
     await sm.ai_responds(ai_response, model=model, provider=provider)
-    
+
     # Return stats directly
     return await sm.get_stats()
 
@@ -211,15 +211,15 @@ async def track_infinite_conversation(
     provider: str = "unknown",
     session_id: Optional[str] = None,
     token_threshold: int = 4000,
-    max_turns: int = 20
+    max_turns: int = 20,
 ) -> str:
     """
     Track a conversation with infinite context support.
-    
+
     This automatically handles long conversations by creating new
     session segments when limits are reached, maintaining context
     through summaries.
-    
+
     Args:
         user_message: What the user said.
         ai_response: What the AI responded.
@@ -228,10 +228,10 @@ async def track_infinite_conversation(
         session_id: Optional existing session ID to continue.
         token_threshold: Create new segment after this many tokens.
         max_turns: Create new segment after this many turns.
-        
+
     Returns:
         The current session ID (may be different if segmented).
-        
+
     Example:
         ```python
         # First message
@@ -240,7 +240,7 @@ async def track_infinite_conversation(
             "Computing history begins with...",
             model="gpt-4"
         )
-        
+
         # Continue the conversation
         session_id = await track_infinite_conversation(
             "What about quantum computers?",
@@ -251,13 +251,13 @@ async def track_infinite_conversation(
         ```
     """
     return await track_conversation(
-        user_message, 
-        ai_response, 
-        model=model, 
+        user_message,
+        ai_response,
+        model=model,
         provider=provider,
         session_id=session_id,
-        infinite_context=True, 
-        token_threshold=token_threshold
+        infinite_context=True,
+        token_threshold=token_threshold,
     )
 
 
@@ -267,11 +267,11 @@ async def track_tool_use(
     result: Any,
     session_id: Optional[str] = None,
     error: Optional[str] = None,
-    **metadata
+    **metadata,
 ) -> str:
     """
     Track a tool/function call in a session.
-    
+
     Args:
         tool_name: Name of the tool that was called.
         arguments: Arguments passed to the tool.
@@ -279,10 +279,10 @@ async def track_tool_use(
         session_id: Optional existing session ID.
         error: Optional error if the tool failed.
         **metadata: Additional metadata to store.
-        
+
     Returns:
         The session ID.
-        
+
     Example:
         ```python
         session_id = await track_tool_use(
@@ -295,28 +295,23 @@ async def track_tool_use(
     """
     sm = SessionManager(session_id=session_id)
     return await sm.tool_used(
-        tool_name=tool_name,
-        arguments=arguments,
-        result=result,
-        error=error,
-        **metadata
+        tool_name=tool_name, arguments=arguments, result=result, error=error, **metadata
     )
 
 
 async def get_session_stats(
-    session_id: str,
-    include_all_segments: bool = False
+    session_id: str, include_all_segments: bool = False
 ) -> Dict[str, Any]:
     """
     Get statistics for an existing session.
-    
+
     Args:
         session_id: The session ID to get stats for.
         include_all_segments: For infinite context sessions, include all segments.
-        
+
     Returns:
         Dictionary with session statistics.
-        
+
     Example:
         ```python
         stats = await get_session_stats("session-123")
@@ -329,19 +324,18 @@ async def get_session_stats(
 
 
 async def get_conversation_history(
-    session_id: str,
-    include_all_segments: bool = False
+    session_id: str, include_all_segments: bool = False
 ) -> List[Dict[str, Any]]:
     """
     Get the conversation history for a session.
-    
+
     Args:
         session_id: The session ID to get history for.
         include_all_segments: For infinite context sessions, include all segments.
-        
+
     Returns:
         List of conversation turns.
-        
+
     Example:
         ```python
         history = await get_conversation_history("session-123")
@@ -355,4 +349,4 @@ async def get_conversation_history(
 
 # Backwards compatibility aliases
 track_llm_interaction = track_llm_call
-quick_stats = quick_conversation
+quick_stats = quick_conversation