chuk-ai-session-manager 0.4.1__py3-none-any.whl → 0.7__py3-none-any.whl

chuk_ai_session_manager/__init__.py

@@ -29,184 +29,86 @@ Infinite Context Example:
     await sm.ai_responds("Machine learning is...", model="gpt-4")
     # Session will auto-segment when limits are reached
 
-Advanced Usage:
-    # Access the full Session model for detailed control
-    from chuk_ai_session_manager import Session, SessionEvent
+Storage Configuration:
+    # Default: Memory storage (no Redis required)
+    pip install chuk-ai-session-manager
     
-    session = await Session.create()
-    event = await SessionEvent.create_with_tokens(
-        message="Hello", prompt="Hello", model="gpt-4"
-    )
-    await session.add_event_and_save(event)
+    # 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)
 """
 
 import logging
-from typing import Optional
 
 # Package version
-__version__ = "0.4"
+__version__ = "0.5"
 
 # Set up package-level logger
 logger = logging.getLogger(__name__)
 
-# Core enums and constants (no dependencies)
-try:
-    from chuk_ai_session_manager.models.event_source import EventSource
-    from chuk_ai_session_manager.models.event_type import EventType
-except ImportError as e:
-    logger.warning(f"Could not import core enums: {e}")
-    EventSource = None
-    EventType = None
-
-# Storage setup function (no circular dependencies)
-try:
-    from chuk_ai_session_manager.session_storage import setup_chuk_sessions_storage
-except ImportError as e:
-    logger.warning(f"Could not import storage setup: {e}")
-    setup_chuk_sessions_storage = None
+# Core enums and constants
+from chuk_ai_session_manager.models.event_source import EventSource
+from chuk_ai_session_manager.models.event_type import EventType
 
 # Exception classes
-try:
-    from chuk_ai_session_manager.exceptions import (
-        SessionManagerError,
-        SessionNotFound,
-        SessionAlreadyExists,
-        InvalidSessionOperation,
-        TokenLimitExceeded,
-        StorageError,
-        ToolProcessingError
-    )
-except ImportError as e:
-    logger.warning(f"Could not import exceptions: {e}")
-    # Define minimal fallback exceptions
-    class SessionManagerError(Exception):
-        """Base exception for session manager errors."""
-        pass
-    
-    SessionNotFound = SessionManagerError
-    SessionAlreadyExists = SessionManagerError
-    InvalidSessionOperation = SessionManagerError
-    TokenLimitExceeded = SessionManagerError
-    StorageError = SessionManagerError
-    ToolProcessingError = SessionManagerError
-
-# Core models (may have some dependencies)
-Session = None
-SessionEvent = None
-SessionMetadata = None
-SessionRun = None
-RunStatus = None
-TokenUsage = None
-
-try:
-    from chuk_ai_session_manager.models.session_metadata import SessionMetadata
-except ImportError as e:
-    logger.debug(f"Could not import SessionMetadata: {e}")
-
-try:
-    from chuk_ai_session_manager.models.session_run import SessionRun, RunStatus
-except ImportError as e:
-    logger.debug(f"Could not import SessionRun: {e}")
-
-try:
-    from chuk_ai_session_manager.models.token_usage import TokenUsage, TokenSummary
-except ImportError as e:
-    logger.debug(f"Could not import TokenUsage: {e}")
-    TokenSummary = None
-
-try:
-    from chuk_ai_session_manager.models.session_event import SessionEvent
-except ImportError as e:
-    logger.debug(f"Could not import SessionEvent: {e}")
-
-try:
-    from chuk_ai_session_manager.models.session import Session
-except ImportError as e:
-    logger.debug(f"Could not import Session: {e}")
-
-# Simple API (highest level, most dependencies)
-SessionManager = None
-track_conversation = None
-track_llm_call = None
-quick_conversation = None
-track_infinite_conversation = None
+from chuk_ai_session_manager.exceptions import (
+    SessionManagerError,
+    SessionNotFound,
+    SessionAlreadyExists,
+    InvalidSessionOperation,
+    TokenLimitExceeded,
+    StorageError,
+    ToolProcessingError
+)
 
-try:
-    from chuk_ai_session_manager.api.simple_api import (
-        SessionManager,
-        track_conversation,
-        track_llm_call,
-        quick_conversation,
-        track_infinite_conversation
-    )
-except ImportError as e:
-    logger.warning(f"Could not import simple API: {e}")
-
-# Advanced components (optional)
-InfiniteConversationManager = None
-SessionAwareToolProcessor = None
-build_prompt_from_session = None
-PromptStrategy = None
-
-try:
-    from chuk_ai_session_manager.infinite_conversation import InfiniteConversationManager
-except ImportError as e:
-    logger.debug(f"Could not import InfiniteConversationManager: {e}")
-
-try:
-    from chuk_ai_session_manager.session_aware_tool_processor import SessionAwareToolProcessor
-except ImportError as e:
-    logger.debug(f"Could not import SessionAwareToolProcessor: {e}")
-
-try:
-    from chuk_ai_session_manager.session_prompt_builder import (
-        build_prompt_from_session,
-        PromptStrategy
-    )
-except ImportError as e:
-    logger.debug(f"Could not import prompt builder: {e}")
+# Core models
+from chuk_ai_session_manager.models.session_metadata import SessionMetadata
+from chuk_ai_session_manager.models.session_run import SessionRun, RunStatus
+from chuk_ai_session_manager.models.token_usage import TokenUsage, TokenSummary
+from chuk_ai_session_manager.models.session_event import SessionEvent
+from chuk_ai_session_manager.models.session import Session
+
+# Storage backend
+from chuk_ai_session_manager.session_storage import setup_chuk_sessions_storage
+
+# High-level session manager
+from chuk_ai_session_manager.session_manager import SessionManager
+
+# Simple API - The main interface most users will use
+from chuk_ai_session_manager.api.simple_api import (
+    track_conversation,
+    track_llm_call,
+    quick_conversation,
+    track_infinite_conversation,
+    track_tool_use,
+    get_session_stats,
+    get_conversation_history
+)
 
+# Advanced components
+from chuk_ai_session_manager.infinite_conversation import (
+    InfiniteConversationManager,
+    SummarizationStrategy
+)
 
-def _auto_setup_storage(sandbox_id: str = "chuk-ai-session-manager", 
-                       default_ttl_hours: int = 24) -> bool:
-    """
-    Auto-setup storage with sensible defaults if not already configured.
-    
-    Args:
-        sandbox_id: CHUK Sessions sandbox ID to use
-        default_ttl_hours: Default TTL for sessions
-        
-    Returns:
-        True if setup was successful, False otherwise
-    """
-    if setup_chuk_sessions_storage is None:
-        logger.warning("Storage setup not available - imports failed")
-        return False
-        
-    try:
-        # Try to get existing backend first
-        from chuk_ai_session_manager.session_storage import get_backend
-        get_backend()  # This will trigger setup if needed
-        logger.debug("Storage backend already configured")
-        return True
-    except Exception:
-        # Setup with defaults if not configured
-        try:
-            setup_chuk_sessions_storage(
-                sandbox_id=sandbox_id,
-                default_ttl_hours=default_ttl_hours
-            )
-            logger.info(f"Auto-configured storage with sandbox_id='{sandbox_id}'")
-            return True
-        except Exception as e:
-            logger.error(f"Failed to auto-setup storage: {e}")
-            return False
+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
+)
 
+# Configuration functions
 def configure_storage(sandbox_id: str = "chuk-ai-session-manager", 
                      default_ttl_hours: int = 24) -> bool:
     """
-    Explicitly configure the storage backend.
+    Configure the storage backend.
     
     Args:
         sandbox_id: CHUK Sessions sandbox ID to use
@@ -214,8 +116,22 @@ def configure_storage(sandbox_id: str = "chuk-ai-session-manager",
         
     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
+        - redis: Persistent, requires pip install chuk-ai-session-manager[redis]
     """
-    return _auto_setup_storage(sandbox_id, default_ttl_hours)
+    try:
+        setup_chuk_sessions_storage(
+            sandbox_id=sandbox_id,
+            default_ttl_hours=default_ttl_hours
+        )
+        logger.info(f"Storage configured with sandbox_id='{sandbox_id}'")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to configure storage: {e}")
+        return False
 
 
 def get_version() -> str:
@@ -230,32 +146,80 @@ def is_available() -> dict:
     Returns:
         Dictionary showing availability of each component
     """
+    # Check if Redis is available
+    redis_available = False
+    try:
+        import redis
+        redis_available = True
+    except ImportError:
+        pass
+    
+    # Check if tiktoken is available for enhanced token counting
+    tiktoken_available = False
+    try:
+        import tiktoken
+        tiktoken_available = True
+    except ImportError:
+        pass
+    
     return {
-        "core_enums": EventSource is not None and EventType is not None,
-        "core_models": Session is not None and SessionEvent is not None,
-        "simple_api": SessionManager is not None,
-        "storage": setup_chuk_sessions_storage is not None,
-        "infinite_context": InfiniteConversationManager is not None,
-        "tool_processor": SessionAwareToolProcessor is not None,
-        "prompt_builder": build_prompt_from_session is not None,
-        "token_tracking": TokenUsage is not None,
-        "exceptions": True,  # Always available (fallbacks defined)
+        "core_enums": True,
+        "core_models": True,
+        "simple_api": True,
+        "storage": True,
+        "infinite_context": True,
+        "tool_processor": True,
+        "prompt_builder": True,
+        "token_tracking": True,
+        "exceptions": True,
+        "session_manager": True,
+        "redis_support": redis_available,
+        "enhanced_token_counting": tiktoken_available,
     }
 
 
-# Main exports - prioritize what works
-__all__ = []
-
-# Always available
-__all__.extend([
+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
+        }
+    except Exception as e:
+        return {
+            "provider": os.getenv("SESSION_PROVIDER", "memory"),
+            "error": str(e)
+        }
+
+
+# Main exports - everything should be available
+__all__ = [
+    # Version and utilities
     "__version__",
     "get_version", 
     "is_available",
     "configure_storage",
-])
-
-# Add exception classes (always available)
-__all__.extend([
+    "get_storage_info",
+    
+    # Core enums
+    "EventSource",
+    "EventType",
+    
+    # Exception classes
     "SessionManagerError",
     "SessionNotFound", 
     "SessionAlreadyExists",
@@ -263,67 +227,49 @@ __all__.extend([
     "TokenLimitExceeded",
     "StorageError",
     "ToolProcessingError",
-])
-
-# Add available components conditionally
-if EventSource is not None:
-    __all__.append("EventSource")
-if EventType is not None:
-    __all__.append("EventType")
-
-if setup_chuk_sessions_storage is not None:
-    __all__.append("setup_chuk_sessions_storage")
-
-# Simple API (most important for users)
-if SessionManager is not None:
-    __all__.extend([
-        "SessionManager",
-        "track_conversation", 
-        "track_llm_call",
-        "quick_conversation",
-        "track_infinite_conversation",
-    ])
-
-# Core models
-if Session is not None:
-    __all__.append("Session")
-if SessionEvent is not None:
-    __all__.append("SessionEvent")
-if SessionMetadata is not None:
-    __all__.append("SessionMetadata")
-if SessionRun is not None:
-    __all__.extend(["SessionRun", "RunStatus"])
-if TokenUsage is not None:
-    __all__.append("TokenUsage")
-if TokenSummary is not None:
-    __all__.append("TokenSummary")
-
-# Advanced components
-if InfiniteConversationManager is not None:
-    __all__.append("InfiniteConversationManager")
-if SessionAwareToolProcessor is not None:
-    __all__.append("SessionAwareToolProcessor")
-if build_prompt_from_session is not None:
-    __all__.extend(["build_prompt_from_session", "PromptStrategy"])
-
-# Auto-setup on import (with error handling)
+    
+    # Core models
+    "Session",
+    "SessionEvent",
+    "SessionMetadata",
+    "SessionRun",
+    "RunStatus",
+    "TokenUsage",
+    "TokenSummary",
+    
+    # Storage
+    "setup_chuk_sessions_storage",
+    
+    # Primary interfaces - what most users will use
+    "SessionManager",
+    "track_conversation", 
+    "track_llm_call",
+    "quick_conversation",
+    "track_infinite_conversation",
+    "track_tool_use",
+    "get_session_stats",
+    "get_conversation_history",
+    
+    # Advanced components
+    "InfiniteConversationManager",
+    "SummarizationStrategy",
+    "SessionAwareToolProcessor",
+    "build_prompt_from_session",
+    "PromptStrategy",
+    "truncate_prompt_to_token_limit",
+]
+
+# Auto-setup storage on import
 try:
-    _auto_setup_storage()
+    configure_storage()
+    logger.debug("Auto-configured storage backend")
 except Exception as e:
-    logger.debug(f"Auto-setup failed (this is normal on first import): {e}")
+    logger.debug(f"Auto-setup skipped: {e}")
 
-# Log successful import
-available = is_available()
-available_count = sum(available.values())
-total_count = len(available)
-logger.debug(f"CHUK AI Session Manager imported successfully "
-            f"({available_count}/{total_count} components available)")
-
-# Show warning if core components are missing
-if not available.get("simple_api", False):
-    logger.warning(
-        "Simple API not available - you may need to install missing dependencies. "
-        "Check the logs above for specific import errors."
-    )
-elif available_count == total_count:
-    logger.debug("All components loaded successfully")
+# Log successful import with storage info
+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})")
+except Exception:
+    logger.debug(f"CHUK AI Session Manager v{__version__} imported successfully")

chuk_ai_session_manager-0.7.dist-info/METADATA

@@ -0,0 +1,262 @@
+Metadata-Version: 2.4
+Name: chuk-ai-session-manager
+Version: 0.7
+Summary: Session manager for AI applications
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: chuk-sessions>=0.4.1
+Requires-Dist: chuk-tool-processor>=0.4.1
+Requires-Dist: pydantic>=2.11.3
+Provides-Extra: redis
+Requires-Dist: chuk-sessions[redis]>=0.4.1; extra == "redis"
+Requires-Dist: redis>=4.0.0; extra == "redis"
+Provides-Extra: tiktoken
+Requires-Dist: tiktoken>=0.9.0; extra == "tiktoken"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Provides-Extra: all
+Requires-Dist: chuk-sessions[redis]>=0.4; extra == "all"
+Requires-Dist: redis>=4.0.0; extra == "all"
+Requires-Dist: tiktoken>=0.9.0; extra == "all"
+
+# CHUK AI Session Manager
+
+**A powerful session management system for AI applications**
+
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Automatic conversation tracking, token usage monitoring, tool call logging, infinite context support with automatic summarization, and hierarchical session relationships. Perfect for AI applications that need reliable session management.
+
+## 🚀 Quick Start
+
+### Installation Options
+
+```bash
+# Basic installation (memory storage only)
+pip install chuk-ai-session-manager
+
+# With Redis support for production
+pip install chuk-ai-session-manager[redis]
+
+# With enhanced token counting
+pip install chuk-ai-session-manager[tiktoken]
+
+# Full installation with all optional features
+pip install chuk-ai-session-manager[all]
+
+# Development installation
+pip install chuk-ai-session-manager[dev]
+```
+
+### Quick Example
+
+```python
+from chuk_ai_session_manager import track_conversation
+
+# Track any conversation automatically
+session_id = await track_conversation(
+    user_message="What's the weather like?",
+    ai_response="I don't have access to real-time weather data.",
+    model="gpt-3.5-turbo",
+    provider="openai"
+)
+
+print(f"Conversation tracked in session: {session_id}")
+```
+
+That's it! Zero configuration required.
+
+## ⚡ Major Features
+
+### 🎯 **Zero-Configuration Tracking**
+```python
+from chuk_ai_session_manager import SessionManager
+
+# Just start using it
+sm = SessionManager()
+await sm.user_says("Hello!")
+await sm.ai_responds("Hi there!", model="gpt-4")
+
+# Get stats instantly
+stats = await sm.get_stats()
+print(f"Tokens: {stats['total_tokens']}, Cost: ${stats['estimated_cost']:.4f}")
+```
+
+### 🔄 **Infinite Context**
+```python
+# Automatically handles conversations longer than token limits
+sm = SessionManager(infinite_context=True, token_threshold=4000)
+await sm.user_says("Tell me about the history of computing...")
+await sm.ai_responds("Computing history begins with...", model="gpt-4")
+# Session will auto-segment when limits are reached
+```
+
+### ⚙️ **Storage Backends**
+
+| Installation | Storage | Use Case | Performance |
+|-------------|---------|----------|-------------|
+| `pip install chuk-ai-session-manager` | Memory | Development, testing | 1.8M ops/sec |
+| `pip install chuk-ai-session-manager[redis]` | Redis | Production, persistence | 20K ops/sec |
+
+### 🛠️ **Tool Integration**
+```python
+# Automatic tool call tracking
+await sm.tool_used(
+    tool_name="calculator",
+    arguments={"operation": "add", "a": 5, "b": 3},
+    result={"result": 8}
+)
+```
+
+## 💡 Common Use Cases
+
+### Web App Conversation Tracking
+```python
+from chuk_ai_session_manager import track_conversation
+
+# In your chat endpoint
+session_id = await track_conversation(
+    user_message=request.message,
+    ai_response=ai_response,
+    model="gpt-4",
+    provider="openai",
+    session_id=request.session_id  # Continue existing conversation
+)
+```
+
+### LLM Wrapper with Automatic Tracking
+```python
+from chuk_ai_session_manager import track_llm_call
+import openai
+
+async def my_openai_call(prompt):
+    response = await openai.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return response.choices[0].message.content
+
+# Automatically tracked
+response, session_id = await track_llm_call(
+    user_input="Explain machine learning",
+    llm_function=my_openai_call,
+    model="gpt-3.5-turbo",
+    provider="openai"
+)
+```
+
+### Long Conversations with Auto-Segmentation
+```python
+from chuk_ai_session_manager import track_infinite_conversation
+
+# Start a conversation
+session_id = await track_infinite_conversation(
+    user_message="Tell me about the history of computing",
+    ai_response="Computing history begins with ancient calculating devices...",
+    model="gpt-4",
+    token_threshold=4000  # Auto-segment after 4000 tokens
+)
+
+# Continue the conversation - will auto-segment if needed
+session_id = await track_infinite_conversation(
+    user_message="What about quantum computers?",
+    ai_response="Quantum computing represents a fundamental shift...",
+    session_id=session_id,
+    model="gpt-4"
+)
+```
+
+## 🔧 Configuration
+
+### Storage Configuration
+
+```bash
+# Memory provider (default) - fast, no persistence
+export SESSION_PROVIDER=memory
+
+# Redis provider - persistent, production-ready (requires redis extra)
+export SESSION_PROVIDER=redis
+export SESSION_REDIS_URL=redis://localhost:6379/0
+```
+
+### Installation Matrix
+
+| Command | Memory | Redis | Token Counting | Use Case |
+|---------|--------|-------|----------------|----------|
+| `pip install chuk-ai-session-manager` | ✅ | ❌ | Basic | Development |
+| `pip install chuk-ai-session-manager[redis]` | ✅ | ✅ | Basic | Production |
+| `pip install chuk-ai-session-manager[tiktoken]` | ✅ | ❌ | Enhanced | Better accuracy |
+| `pip install chuk-ai-session-manager[all]` | ✅ | ✅ | Enhanced | Full features |
+
+## 📊 Monitoring & Analytics
+
+```python
+# Get comprehensive session analytics
+stats = await sm.get_stats(include_all_segments=True)
+
+print(f"""
+🚀 Session Analytics Dashboard
+============================
+Session ID: {stats['session_id']}
+Total Messages: {stats['total_messages']}
+User Messages: {stats['user_messages']}
+AI Messages: {stats['ai_messages']}
+Tool Calls: {stats['tool_calls']}
+Total Tokens: {stats['total_tokens']}
+Total Cost: ${stats['estimated_cost']:.6f}
+Session Segments: {stats.get('session_segments', 1)}
+""")
+```
+
+## 🏗️ Why CHUK AI Session Manager?
+
+- **Zero Configuration**: Start tracking conversations in 3 lines of code
+- **Infinite Context**: Never worry about token limits again
+- **Universal**: Works with any LLM provider (OpenAI, Anthropic, etc.)
+- **Production Ready**: Built-in persistence, monitoring, and error handling
+- **Token Aware**: Automatic cost tracking across all providers
+- **Tool Friendly**: Seamless tool call logging and retry mechanisms
+
+## 🛡️ Error Handling
+
+```python
+from chuk_ai_session_manager import (
+    SessionManagerError,
+    SessionNotFound,
+    TokenLimitExceeded
+)
+
+try:
+    session_id = await track_conversation("Hello", "Hi there")
+except SessionNotFound as e:
+    print(f"Session not found: {e}")
+except TokenLimitExceeded as e:
+    print(f"Token limit exceeded: {e}")
+except SessionManagerError as e:
+    print(f"General session error: {e}")
+```
+
+## 🔄 Dependencies
+
+- **Required**: `chuk-sessions` (session storage), `pydantic` (data models), `chuk-tool-processor` (tool integration)
+- **Optional**: `redis` (Redis storage), `tiktoken` (accurate token counting)
+
+## 📄 License
+
+MIT License - build amazing AI applications with confidence!
+
+---
+
+**Ready to build better AI applications?**
+
+```bash
+pip install chuk-ai-session-manager
+```
+
+**Start tracking conversations in 30 seconds!**

{chuk_ai_session_manager-0.4.1.dist-info → chuk_ai_session_manager-0.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-chuk_ai_session_manager/__init__.py,sha256=Kg8_fqwkV88b0f9H8Q45MDqaZdHHTo3Wf0Oko89DhHg,10217
+chuk_ai_session_manager/__init__.py,sha256=r24MtKySdzvUgK8psNHYHiTRzOUAEXPOBmaNg2cjyFw,7882
 chuk_ai_session_manager/exceptions.py,sha256=WqrrUZuOAiUmz7tKnSnk0y222U_nV9a8LyaXLayn2fg,4420
 chuk_ai_session_manager/infinite_conversation.py,sha256=7j3caMnsX27M5rjj4oOkqiy_2AfcupWwsAWRflnKiSo,12092
 chuk_ai_session_manager/sample_tools.py,sha256=U-jTGveTJ95uSnA4jB30fJQJG3K-TGxN9jcOY6qVHZQ,8179
@@ -16,7 +16,7 @@ chuk_ai_session_manager/models/session_event.py,sha256=RTghC9_sDHzD8qdgEYCoclJzp
 chuk_ai_session_manager/models/session_metadata.py,sha256=KFG7lc_E0BQTP2OD9Y529elVGJXppDUMqz8vVONW0rw,1510
 chuk_ai_session_manager/models/session_run.py,sha256=uhMM4-WSrqOUsiWQPnyakInd-foZhxI-YnSHSWiZZwE,4369
 chuk_ai_session_manager/models/token_usage.py,sha256=M9Qwmeb2woILaSRwA2SIAiG-sIwC3cL_1H-y3NjW5Ik,11436
-chuk_ai_session_manager-0.4.1.dist-info/METADATA,sha256=0PvxzwOw2HG8XujmXkMInNVAlrhF149rxyLzXTUROAg,11136
-chuk_ai_session_manager-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_ai_session_manager-0.4.1.dist-info/top_level.txt,sha256=5RinqD0v-niHuLYePUREX4gEWTlrpgtUg0RfexVRBMk,24
-chuk_ai_session_manager-0.4.1.dist-info/RECORD,,
+chuk_ai_session_manager-0.7.dist-info/METADATA,sha256=dyL99WC_86DIPfkjLr-q4Dw2kKi-J7olpyaOfyFEsgM,7910
+chuk_ai_session_manager-0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_ai_session_manager-0.7.dist-info/top_level.txt,sha256=5RinqD0v-niHuLYePUREX4gEWTlrpgtUg0RfexVRBMk,24
+chuk_ai_session_manager-0.7.dist-info/RECORD,,

chuk_ai_session_manager-0.4.1.dist-info/METADATA

@@ -1,355 +0,0 @@
-Metadata-Version: 2.4
-Name: chuk-ai-session-manager
-Version: 0.4.1
-Summary: Session manager for AI applications
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-Requires-Dist: chuk-sessions>=0.3
-Requires-Dist: chuk-tool-processor>=0.4.1
-Requires-Dist: pydantic>=2.11.3
-Provides-Extra: tiktoken
-Requires-Dist: tiktoken>=0.9.0; extra == "tiktoken"
-Provides-Extra: redis
-Requires-Dist: redis>=4.0.0; extra == "redis"
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
-Requires-Dist: redis>=4.0.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: isort>=5.12.0; extra == "dev"
-Requires-Dist: mypy>=1.0.0; extra == "dev"
-Provides-Extra: full
-
-# chuk-ai-session-manager
-
-[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-**The easiest way to add conversation tracking to any AI application.**
-
-Track conversations, monitor costs, and manage infinite context with just 3 lines of code. Built for production, designed for simplicity.
-
-## 🚀 30-Second Start
-
-```bash
-uv add chuk-ai-session-manager
-```
-
-```python
-from chuk_ai_session_manager import track_conversation
-
-# Track any AI conversation in one line
-await track_conversation("Hello!", "Hi there! How can I help?")
-```
-
-That's it! 🎉 Your conversation is now tracked with full observability.
-
-## ✨ Why Choose CHUK?
-
-- **🔥 Stupidly Simple**: 3 lines to track any conversation
-- **💰 Cost Smart**: Automatic token counting and cost tracking
-- **♾️ Infinite Context**: No more "conversation too long" errors
-- **🔧 Any LLM**: Works with OpenAI, Anthropic, local models, anything
-- **📊 Full Observability**: See exactly what's happening in your AI app
-- **🚀 Production Ready**: Used in real applications, not just demos
-
-## 🎯 Perfect For
-
-- **Building chatbots** that remember conversations
-- **Tracking LLM costs** across your entire application  
-- **Managing long conversations** without hitting token limits
-- **Debugging AI applications** with complete audit trails
-- **Production AI systems** that need reliable session management
-
-## 📱 Quick Examples
-
-### Track Any Conversation
-```python
-from chuk_ai_session_manager import track_conversation
-
-# Works with any LLM response
-session_id = await track_conversation(
-    user_message="What's the weather like?",
-    ai_response="It's sunny and 75°F in your area.",
-    model="gpt-4",
-    provider="openai"
-)
-```
-
-### Persistent Conversations
-```python
-from chuk_ai_session_manager import SessionManager
-
-# Create a conversation that remembers context
-sm = SessionManager()
-
-await sm.user_says("My name is Alice")
-await sm.ai_responds("Nice to meet you, Alice!")
-
-await sm.user_says("What's my name?")
-await sm.ai_responds("Your name is Alice!")
-
-# Get conversation stats
-stats = await sm.get_stats()
-print(f"Cost: ${stats['estimated_cost']:.6f}")
-print(f"Tokens: {stats['total_tokens']}")
-```
-
-### Infinite Context (Never Run Out of Space)
-```python
-# Automatically handles conversations of any length
-sm = SessionManager(
-    infinite_context=True,          # 🔥 Magic happens here
-    token_threshold=4000           # When to create new segment
-)
-
-# Keep chatting forever - context is preserved automatically
-for i in range(100):  # This would normally hit token limits
-    await sm.user_says(f"Question {i}: Tell me about AI")
-    await sm.ai_responds("AI is fascinating...")
-
-# Still works! Automatic summarization keeps context alive
-conversation = await sm.get_conversation()
-print(f"Full conversation: {len(conversation)} exchanges")
-```
-
-### Cost Tracking (Know What You're Spending)
-```python
-# Automatic cost monitoring across all interactions
-sm = SessionManager()
-
-await sm.user_says("Write a long story about dragons")
-await sm.ai_responds("Once upon a time..." * 500)  # Long response
-
-stats = await sm.get_stats()
-print(f"💰 That story cost: ${stats['estimated_cost']:.6f}")
-print(f"📊 Used {stats['total_tokens']} tokens")
-print(f"📈 {stats['user_messages']} user messages, {stats['ai_messages']} AI responses")
-```
-
-### Multi-Provider Support
-```python
-# Works with any LLM provider
-import openai
-import anthropic
-
-sm = SessionManager()
-
-# OpenAI
-await sm.user_says("Hello!")
-openai_response = await openai.chat.completions.create(...)
-await sm.ai_responds(openai_response.choices[0].message.content, model="gpt-4", provider="openai")
-
-# Anthropic
-await sm.user_says("How are you?")
-anthropic_response = await anthropic.messages.create(...)
-await sm.ai_responds(anthropic_response.content[0].text, model="claude-3", provider="anthropic")
-
-# See costs across all providers
-stats = await sm.get_stats()
-print(f"Total cost across all providers: ${stats['estimated_cost']:.6f}")
-```
-
-## 🛠️ Advanced Features
-
-### Conversation Analytics
-```python
-# Get detailed insights into your conversations
-conversation = await sm.get_conversation()
-stats = await sm.get_stats()
-
-print(f"📊 Conversation Analytics:")
-print(f"   Messages: {stats['user_messages']} user, {stats['ai_messages']} AI")
-print(f"   Average response length: {stats['avg_response_length']}")
-print(f"   Most expensive response: ${stats['max_response_cost']:.6f}")
-print(f"   Session duration: {stats['duration_minutes']:.1f} minutes")
-```
-
-### Tool Integration
-```python
-# Track tool usage alongside conversations
-await sm.tool_used(
-    tool_name="web_search",
-    arguments={"query": "latest AI news"},
-    result={"articles": ["AI breakthrough...", "New model released..."]},
-    cost=0.001
-)
-
-stats = await sm.get_stats()
-print(f"Tool calls: {stats['tool_calls']}")
-```
-
-### Session Export/Import
-```python
-# Export conversations for analysis
-conversation_data = await sm.export_conversation()
-with open('conversation.json', 'w') as f:
-    json.dump(conversation_data, f)
-
-# Import previous conversations
-sm = SessionManager()
-await sm.import_conversation('conversation.json')
-```
-
-## 🎨 Real-World Examples
-
-### Customer Support Bot
-```python
-async def handle_support_ticket(user_message: str, ticket_id: str):
-    # Each ticket gets its own session
-    sm = SessionManager(session_id=ticket_id)
-    
-    await sm.user_says(user_message)
-    
-    # Your AI logic here
-    ai_response = await your_ai_model(user_message)
-    await sm.ai_responds(ai_response, model="gpt-4", provider="openai")
-    
-    # Automatic cost tracking per ticket
-    stats = await sm.get_stats()
-    print(f"Ticket {ticket_id} cost: ${stats['estimated_cost']:.6f}")
-    
-    return ai_response
-```
-
-### AI Assistant with Memory
-```python
-async def ai_assistant():
-    sm = SessionManager(infinite_context=True)
-    
-    while True:
-        user_input = input("You: ")
-        if user_input.lower() == 'quit':
-            break
-            
-        await sm.user_says(user_input)
-        
-        # Get conversation context for AI
-        conversation = await sm.get_conversation()
-        context = "\n".join([f"{turn['role']}: {turn['content']}" for turn in conversation[-5:]])
-        
-        # Your AI call with context
-        ai_response = await your_ai_model(f"Context:\n{context}\n\nUser: {user_input}")
-        await sm.ai_responds(ai_response)
-        
-        print(f"AI: {ai_response}")
-    
-    # Show final stats
-    stats = await sm.get_stats()
-    print(f"\n💰 Total conversation cost: ${stats['estimated_cost']:.6f}")
-```
-
-### Multi-User Chat Application
-```python
-class ChatApplication:
-    def __init__(self):
-        self.user_sessions = {}
-    
-    async def handle_message(self, user_id: str, message: str):
-        # Each user gets their own session
-        if user_id not in self.user_sessions:
-            self.user_sessions[user_id] = SessionManager(infinite_context=True)
-        
-        sm = self.user_sessions[user_id]
-        await sm.user_says(message)
-        
-        # AI processes with user's personal context
-        ai_response = await self.generate_response(sm, message)
-        await sm.ai_responds(ai_response)
-        
-        return ai_response
-    
-    async def get_user_stats(self, user_id: str):
-        if user_id in self.user_sessions:
-            return await self.user_sessions[user_id].get_stats()
-        return None
-```
-
-## 📊 Monitoring Dashboard
-
-```python
-# Get comprehensive analytics across all sessions
-from chuk_ai_session_manager import get_global_stats
-
-stats = await get_global_stats()
-print(f"""
-🚀 AI Application Dashboard
-==========================
-Total Sessions: {stats['total_sessions']}
-Total Messages: {stats['total_messages']}
-Total Cost: ${stats['total_cost']:.2f}
-Average Session Length: {stats['avg_session_length']:.1f} messages
-Most Active Hour: {stats['peak_hour']}
-Top Models Used: {', '.join(stats['top_models'])}
-""")
-```
-
-## 🔧 Installation Options
-
-```bash
-# Basic installation
-uv add chuk-ai-session-manager
-
-# With Redis support (for production)
-uv add chuk-ai-session-manager[redis]
-
-# Full installation (all features)
-uv add chuk-ai-session-manager[full]
-
-# Or with pip
-pip install chuk-ai-session-manager
-```
-
-## 🌟 What Makes CHUK Special?
-
-| Feature | Other Libraries | CHUK AI Session Manager |
-|---------|----------------|------------------------|
-| **Setup Complexity** | Complex configuration | 3 lines of code |
-| **Cost Tracking** | Manual calculation | Automatic across all providers |
-| **Long Conversations** | Token limit errors | Infinite context with auto-segmentation |
-| **Multi-Provider** | Provider-specific code | Works with any LLM |
-| **Production Ready** | Requires additional work | Built for production |
-| **Learning Curve** | Steep | 5 minutes to productivity |
-
-## 📖 More Examples
-
-Check out the `/examples` directory for complete working examples:
-
-- `simple_tracking.py` - Basic conversation tracking
-- `openai_integration.py` - OpenAI API integration
-- `infinite_context.py` - Handling long conversations
-- `cost_monitoring.py` - Cost tracking and analytics
-- `multi_provider.py` - Using multiple LLM providers
-- `production_app.py` - Production-ready application
-
-## 🎯 Quick Decision Guide
-
-**Choose CHUK AI Session Manager if you want:**
-- ✅ Simple conversation tracking with zero configuration
-- ✅ Automatic cost monitoring across all LLM providers
-- ✅ Infinite conversation length without token limit errors
-- ✅ Production-ready session management out of the box
-- ✅ Complete conversation analytics and observability
-- ✅ Framework-agnostic solution that works with any LLM library
-
-## 🤝 Community & Support
-
-- 📖 **Documentation**: [Full docs with tutorials](link-to-docs)
-- 🐛 **Issues**: Report bugs on GitHub
-- 💡 **Feature Requests**: Suggest new features
-- 📧 **Support**: enterprise@chuk.dev for production support
-
-## 📝 License
-
-MIT License - build amazing AI applications with confidence!
-
----
-
-**🎉 Ready to build better AI applications?**
-
-```bash
-uv add chuk-ai-session-manager
-```
-
-**Get started in 30 seconds with one line of code!**