chuk-ai-session-manager 0.3__py3-none-any.whl → 0.4__py3-none-any.whl

chuk_ai_session_manager/__init__.py

@@ -15,7 +15,18 @@ Quick Start:
     await sm.ai_responds("It's sunny and 72°F", model="gpt-4")
 """
 
-# Simple API exports - the main things developers need
+# Import core models first (these have no circular dependencies)
+from chuk_ai_session_manager.models.event_source import EventSource
+from chuk_ai_session_manager.models.event_type import EventType
+
+# Import storage setup (this should work now with the fixed session_storage.py)
+from chuk_ai_session_manager.session_storage import setup_chuk_sessions_storage
+
+# Import other models (these might depend on storage being set up)
+from chuk_ai_session_manager.models.session import Session
+from chuk_ai_session_manager.models.session_event import SessionEvent
+
+# Import the simple API (this should work now that storage is fixed)
 from chuk_ai_session_manager.api.simple_api import (
     SessionManager,
     track_conversation,
@@ -24,15 +35,6 @@ from chuk_ai_session_manager.api.simple_api import (
     track_infinite_conversation
 )
 
-# Core models for advanced users
-from chuk_ai_session_manager.models.session import Session
-from chuk_ai_session_manager.models.session_event import SessionEvent
-from chuk_ai_session_manager.models.event_source import EventSource
-from chuk_ai_session_manager.models.event_type import EventType
-
-# Storage backend setup
-from chuk_ai_session_manager.session_storage import setup_chuk_sessions_storage
-
 __version__ = "0.1.0"
 
 # Main exports - keep it simple

chuk_ai_session_manager/models/token_usage.py

@@ -175,7 +175,7 @@ class TokenUsage(BaseModel):
         )
     
     @staticmethod
-    def _count_tokens_sync(text: Optional[str], model: str = "gpt-3.5-turbo") -> int:
+    def _count_tokens_sync(text: Optional[Union[str, Any]], model: str = "gpt-3.5-turbo") -> int:
         """
         Synchronous implementation of count_tokens.
         
@@ -188,6 +188,17 @@ class TokenUsage(BaseModel):
         """
         if text is None:
             return 0
+        
+        # Convert to string if not already a string
+        if not isinstance(text, str):
+            try:
+                text = str(text)
+            except Exception:
+                return 0
+        
+        # Empty string has 0 tokens
+        if not text:
+            return 0
             
         if TIKTOKEN_AVAILABLE:
             try:
@@ -206,7 +217,7 @@ class TokenUsage(BaseModel):
         return int(len(text) / 4)
     
     @staticmethod
-    async def count_tokens(text: Optional[str], model: str = "gpt-3.5-turbo") -> int:
+    async def count_tokens(text: Optional[Union[str, Any]], model: str = "gpt-3.5-turbo") -> int:
         """
         Async version of count_tokens.
         

chuk_ai_session_manager/sample_tools.py

@@ -1,4 +1,4 @@
-# sample_tools.py
+# chuk_ai_session_manager/sample_tools.py
 """
 Sample tools for chuk session manager demos - corrected version following registry example
 """

chuk_ai_session_manager/session_prompt_builder.py

@@ -37,7 +37,8 @@ async def build_prompt_from_session(
     max_tokens: Optional[int] = None,
     model: str = "gpt-3.5-turbo",
     include_parent_context: bool = False,
-    current_query: Optional[str] = None
+    current_query: Optional[str] = None,
+    max_history: int = 5  # Add this parameter for conversation strategy
 ) -> List[Dict[str, str]]:
     """
     Build a prompt for the next LLM call from a Session asynchronously.
@@ -49,6 +50,7 @@ async def build_prompt_from_session(
         model: Model to use for token counting
         include_parent_context: Whether to include context from parent sessions
         current_query: Current user query for relevance-based context selection
+        max_history: Maximum number of messages to include for conversation strategy
         
     Returns:
         A list of message dictionaries suitable for LLM API calls
@@ -72,7 +74,7 @@ async def build_prompt_from_session(
     elif strategy == PromptStrategy.TOOL_FOCUSED:
         return await _build_tool_focused_prompt(session)
     elif strategy == PromptStrategy.CONVERSATION:
-        return await _build_conversation_prompt(session, max_history=5)
+        return await _build_conversation_prompt(session, max_history)
     elif strategy == PromptStrategy.HIERARCHICAL:
         return await _build_hierarchical_prompt(session, include_parent_context)
     else:
@@ -112,7 +114,7 @@ async def _build_minimal_prompt(session: Session) -> List[Dict[str, str]]:
     
     if assistant_msg is None:
         # Only the user message exists so far
-        return [{"role": "user", "content": first_user.message}] if first_user else []
+        return [{"role": "user", "content": _extract_content(first_user.message)}] if first_user else []
 
     # Children of that assistant
     children = [
@@ -126,11 +128,7 @@ async def _build_minimal_prompt(session: Session) -> List[Dict[str, str]]:
     # Assemble prompt
     prompt: List[Dict[str, str]] = []
     if first_user:
-        # Handle both string messages and dict messages
-        user_content = first_user.message
-        if isinstance(user_content, dict) and "content" in user_content:
-            user_content = user_content["content"]
-        prompt.append({"role": "user", "content": user_content})
+        prompt.append({"role": "user", "content": _extract_content(first_user.message)})
 
     # ALWAYS add the assistant marker - but strip its free text
     prompt.append({"role": "assistant", "content": None})
@@ -166,6 +164,24 @@ async def _build_minimal_prompt(session: Session) -> List[Dict[str, str]]:
     return prompt
 
 
+def _extract_content(message: Any) -> str:
+    """
+    Extract content string from a message that could be a string or dict.
+    
+    Args:
+        message: The message content (string, dict, or other)
+        
+    Returns:
+        The extracted content as a string
+    """
+    if isinstance(message, str):
+        return message
+    elif isinstance(message, dict) and "content" in message:
+        return message["content"]
+    else:
+        return str(message)
+
+
 async def _build_task_focused_prompt(session: Session) -> List[Dict[str, str]]:
     """
     Build a task-focused prompt.
@@ -201,17 +217,11 @@ async def _build_task_focused_prompt(session: Session) -> List[Dict[str, str]]:
     prompt = []
     
     # Always include the first user message (the main task)
-    first_content = first_user.message
-    if isinstance(first_content, dict) and "content" in first_content:
-        first_content = first_content["content"]
-    prompt.append({"role": "user", "content": first_content})
+    prompt.append({"role": "user", "content": _extract_content(first_user.message)})
     
     # Include the latest user message if different from the first
     if latest_user and latest_user.id != first_user.id:
-        latest_content = latest_user.message
-        if isinstance(latest_content, dict) and "content" in latest_content:
-            latest_content = latest_content["content"]
-        prompt.append({"role": "user", "content": latest_content})
+        prompt.append({"role": "user", "content": _extract_content(latest_user.message)})
     
     # Include assistant response placeholder
     if assistant_msg:
@@ -274,10 +284,7 @@ async def _build_tool_focused_prompt(session: Session) -> List[Dict[str, str]]:
     prompt = []
     
     # Include user message
-    user_content = latest_user.message
-    if isinstance(user_content, dict) and "content" in user_content:
-        user_content = user_content["content"]
-    prompt.append({"role": "user", "content": user_content})
+    prompt.append({"role": "user", "content": _extract_content(latest_user.message)})
     
     # Include assistant placeholder
     if assistant_msg:
@@ -334,17 +341,17 @@ async def _build_conversation_prompt(
     
     # Build the conversation history
     prompt = []
-    for msg in recent_messages:
+    for i, msg in enumerate(recent_messages):
         role = "user" if msg.source == EventSource.USER else "assistant"
-        content = msg.message
+        content = _extract_content(msg.message)
         
-        # Handle different message formats
-        if isinstance(content, dict) and "content" in content:
-            content = content["content"]
-        
-        # For the last assistant message, set content to None
-        if role == "assistant" and msg == recent_messages[-1] and msg.source != EventSource.USER:
-            content = None
+        # For the last assistant message, set content to None and add tool calls
+        if (role == "assistant" and 
+            msg == recent_messages[-1] and 
+            msg.source != EventSource.USER):
+            
+            # Add the message first with None content
+            prompt.append({"role": role, "content": None})
             
             # Add tool call results for this assistant message
             tool_calls = [
@@ -352,9 +359,6 @@ async def _build_conversation_prompt(
                 if e.type == EventType.TOOL_CALL and e.metadata.get("parent_event_id") == msg.id
             ]
             
-            # Add the message first, then tools
-            prompt.append({"role": role, "content": content})
-            
             # Add tool results
             for tc in tool_calls:
                 if isinstance(tc.message, dict):
@@ -366,11 +370,9 @@ async def _build_conversation_prompt(
                         "name": tool_name,
                         "content": json.dumps(tool_result, default=str),
                     })
-                    
-            # Skip adding this message again
-            continue
-            
-        prompt.append({"role": role, "content": content})
+        else:
+            # Regular message
+            prompt.append({"role": role, "content": content})
     
     return prompt
 
@@ -391,32 +393,38 @@ async def _build_hierarchical_prompt(
     
     # If parent context is enabled and session has a parent
     if include_parent_context and session.parent_id:
-        # Get the storage backend and create store
-        backend = get_backend()
-        store = ChukSessionsStore(backend)
-        parent = await store.get(session.parent_id)
-        
-        if parent:
-            # Find the most recent summary in parent
-            summary_event = next(
-                (e for e in reversed(parent.events) 
-                 if e.type == EventType.SUMMARY),
-                None
-            )
+        try:
+            # Get the storage backend and create store
+            backend = get_backend()
+            store = ChukSessionsStore(backend)
+            parent = await store.get(session.parent_id)
             
-            if summary_event:
-                # Extract summary content
-                summary_content = summary_event.message
-                if isinstance(summary_content, dict) and "note" in summary_content:
-                    summary_content = summary_content["note"]
-                elif isinstance(summary_content, dict) and "content" in summary_content:
-                    summary_content = summary_content["content"]
-                    
-                # Add parent context at the beginning
-                prompt.insert(0, {
-                    "role": "system",
-                    "content": f"Context from previous conversation: {summary_content}"
-                })
+            if parent:
+                # Find the most recent summary in parent
+                summary_event = next(
+                    (e for e in reversed(parent.events) 
+                     if e.type == EventType.SUMMARY),
+                    None
+                )
+                
+                if summary_event:
+                    # Extract summary content
+                    summary_content = summary_event.message
+                    if isinstance(summary_content, dict) and "note" in summary_content:
+                        summary_content = summary_content["note"]
+                    elif isinstance(summary_content, dict) and "content" in summary_content:
+                        summary_content = summary_content["content"]
+                    else:
+                        summary_content = str(summary_content)
+                        
+                    # Add parent context at the beginning
+                    prompt.insert(0, {
+                        "role": "system",
+                        "content": f"Context from previous conversation: {summary_content}"
+                    })
+        except Exception as e:
+            # If we can't load parent context, just continue with minimal prompt
+            logger.warning(f"Could not load parent context for session {session.parent_id}: {e}")
     
     return prompt
 

{chuk_ai_session_manager-0.3.dist-info → chuk_ai_session_manager-0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chuk-ai-session-manager
-Version: 0.3
+Version: 0.4
 Summary: Session manager for AI applications
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -311,36 +311,6 @@ pip install chuk-ai-session-manager
 | **Production Ready** | Requires additional work | Built for production |
 | **Learning Curve** | Steep | 5 minutes to productivity |
 
-## 🚀 Migration Guides
-
-### From LangChain Memory
-```python
-# Old LangChain way
-from langchain.memory import ConversationBufferMemory
-memory = ConversationBufferMemory()
-memory.save_context({"input": "Hi"}, {"output": "Hello"})
-
-# New CHUK way (much simpler!)
-from chuk_ai_session_manager import track_conversation
-await track_conversation("Hi", "Hello")
-```
-
-### From Manual Session Management
-```python
-# Old manual way
-conversations = {}
-def save_conversation(user_id, message, response):
-    if user_id not in conversations:
-        conversations[user_id] = []
-    conversations[user_id].append({"user": message, "ai": response})
-
-# New CHUK way
-from chuk_ai_session_manager import SessionManager
-sm = SessionManager(session_id=user_id)
-await sm.user_says(message)
-await sm.ai_responds(response)
-```
-
 ## 📖 More Examples
 
 Check out the `/examples` directory for complete working examples:
@@ -362,16 +332,9 @@ Check out the `/examples` directory for complete working examples:
 - ✅ Complete conversation analytics and observability
 - ✅ Framework-agnostic solution that works with any LLM library
 
-**Consider alternatives if you:**
-- ❌ Only need basic in-memory conversation history
-- ❌ Are locked into a specific framework (LangChain, etc.)
-- ❌ Don't need cost tracking or analytics
-- ❌ Are building simple, stateless AI applications
-
 ## 🤝 Community & Support
 
 - 📖 **Documentation**: [Full docs with tutorials](link-to-docs)
-- 💬 **Discord**: Join our community for help and discussions
 - 🐛 **Issues**: Report bugs on GitHub
 - 💡 **Feature Requests**: Suggest new features
 - 📧 **Support**: enterprise@chuk.dev for production support

{chuk_ai_session_manager-0.3.dist-info → chuk_ai_session_manager-0.4.dist-info}/RECORD

@@ -1,9 +1,9 @@
-chuk_ai_session_manager/__init__.py,sha256=h98D5FhFE-WhkWwwRMcF5AXqThxi_SGoYImZtqDniZ0,2038
+chuk_ai_session_manager/__init__.py,sha256=gWpNM9IKH9iOrzwum-4smLmkkSF78t0aPGa583u889M,2208
 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=yZDM-ast5lv0YVHcd3GTxBMcJd7zuNkUhZPVIb06G0c,8155
+chuk_ai_session_manager/sample_tools.py,sha256=U-jTGveTJ95uSnA4jB30fJQJG3K-TGxN9jcOY6qVHZQ,8179
 chuk_ai_session_manager/session_aware_tool_processor.py,sha256=iVe3d-qfp5QGkdNrgfZeRYoOjd8nLZ0g6K7HW1thFE8,7274
-chuk_ai_session_manager/session_prompt_builder.py,sha256=-ZTUczYh5emToInp4TRCj9FvF4CECyn45YHYKoWzmxE,17328
+chuk_ai_session_manager/session_prompt_builder.py,sha256=Jeg_MWses_hFtHtDL7ZQl6EdSNVmVIIrLDrWEoPumfM,17613
 chuk_ai_session_manager/session_storage.py,sha256=HqzYDtwx4zN5an1zJmSZc56BpyD3KjT3IWonIpmnVXQ,5790
 chuk_ai_session_manager/api/__init__.py,sha256=Lo_BoDW2rSn0Zw-CbjahOxc6ykjjTpucxHZo5FA2Gnc,41
 chuk_ai_session_manager/api/simple_api.py,sha256=RbHA2IAPUzIFZFvT6KpbgouAuonF-Q6GopKOeKej0rk,17795
@@ -14,10 +14,8 @@ chuk_ai_session_manager/models/session.py,sha256=Txnmqd5SmiMz6acur_zL5MiFHJjKqU2
 chuk_ai_session_manager/models/session_event.py,sha256=YPDbymduF42LLHtAv_k_kqlWF68vnth5J_HM4q-bOyI,5896
 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=pnsNDMew9ToUqkRCIz1TADnHC5aKnautdLD4trCA6Zg,11121
-chuk_ai_session_manager/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-chuk_ai_session_manager/utils/status_display_utils.py,sha256=id4TIE0VSq3thvDd4wKIyk3kBr_bUMqrtXmOI9CD8r8,19231
-chuk_ai_session_manager-0.3.dist-info/METADATA,sha256=1uqP6Syo-Su4OZW97WeiQnxdOmRRgKwaUekwEpacfXg,12197
-chuk_ai_session_manager-0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_ai_session_manager-0.3.dist-info/top_level.txt,sha256=5RinqD0v-niHuLYePUREX4gEWTlrpgtUg0RfexVRBMk,24
-chuk_ai_session_manager-0.3.dist-info/RECORD,,
+chuk_ai_session_manager/models/token_usage.py,sha256=M9Qwmeb2woILaSRwA2SIAiG-sIwC3cL_1H-y3NjW5Ik,11436
+chuk_ai_session_manager-0.4.dist-info/METADATA,sha256=QjyLv5-42g82rYOJhYT6_tDomd0wD1L39xibv1OXi-4,11080
+chuk_ai_session_manager-0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chuk_ai_session_manager-0.4.dist-info/top_level.txt,sha256=5RinqD0v-niHuLYePUREX4gEWTlrpgtUg0RfexVRBMk,24
+chuk_ai_session_manager-0.4.dist-info/RECORD,,

chuk_ai_session_manager/utils/status_display_utils.py

@@ -1,474 +0,0 @@
-#!/usr/bin/env python3
-"""
-examples/retry_prompt_demo_fixed.py
-──────────────────────────────────
-Demonstrates LLM-level retry patterns with chuk_ai_session_manager.
-
-This shows:
-• Retrying LLM calls until they produce valid tool calls
-• Using chuk_tool_processor's built-in reliability features
-• Session tracking of the entire retry process
-• Proper separation: LLM retries vs tool execution reliability
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import pprint
-import sys
-import os
-from typing import Dict, List
-
-# Add current directory to path
-sys.path.insert(0, os.getcwd())
-
-logging.basicConfig(level=logging.INFO, format="%(levelname)s | %(message)s")
-
-# Session imports - FIXED import paths
-from chuk_ai_session_manager.session_storage import get_backend, ChukSessionsStore, setup_chuk_sessions_storage
-from chuk_ai_session_manager.models.session import Session
-from chuk_ai_session_manager.models.session_event import SessionEvent
-from chuk_ai_session_manager.models.event_source import EventSource
-from chuk_ai_session_manager.models.event_type import EventType
-from chuk_ai_session_manager.session_prompt_builder import build_prompt_from_session
-
-# Status display utilities
-def format_status(success: bool, success_msg: str = "SUCCESS", failure_msg: str = "FAILED") -> str:
-    """Format status with correct emoji."""
-    if success:
-        return f"✅ {success_msg}"
-    else:
-        return f"❌ {failure_msg}"
-
-# Import from chuk_tool_processor (using the working pattern)
-from chuk_tool_processor.registry import initialize, get_default_registry
-from chuk_tool_processor.models.tool_call import ToolCall
-from chuk_tool_processor.execution.strategies.inprocess_strategy import InProcessStrategy
-from chuk_tool_processor.execution.tool_executor import ToolExecutor
-
-# Import sample tools - this will trigger registration
-import sample_tools
-
-##############################################################################
-# Custom Tool Processor (based on working OpenAI demo pattern)
-##############################################################################
-
-class CustomSessionAwareToolProcessor:
-    """Custom tool processor that properly integrates with chuk_tool_processor."""
-    
-    def __init__(self, session_id: str, registry, executor):
-        self.session_id = session_id
-        self.registry = registry
-        self.executor = executor
-    
-    @classmethod
-    async def create(cls, session_id: str):
-        """Create a custom session-aware tool processor."""
-        # Get the registry
-        registry = await get_default_registry()
-        
-        # Create execution strategy and executor
-        strategy = InProcessStrategy(registry)
-        executor = ToolExecutor(registry=registry, strategy=strategy)
-        
-        return cls(session_id, registry, executor)
-    
-    async def process_llm_message(self, llm_msg: dict) -> list:
-        """Process tool calls from an LLM message."""
-        # Get the session
-        backend = get_backend()
-        store = ChukSessionsStore(backend)
-        session = await store.get(self.session_id)
-        if not session:
-            raise ValueError(f"Session {self.session_id} not found")
-        
-        # Add the LLM message as an event
-        llm_event = await SessionEvent.create_with_tokens(
-            message=llm_msg,
-            prompt="",
-            completion=json.dumps(llm_msg, ensure_ascii=False),
-            model="gpt-4o-mini",
-            source=EventSource.LLM,
-            type=EventType.MESSAGE,
-        )
-        await session.add_event_and_save(llm_event)
-        
-        # Extract tool calls
-        tool_calls = llm_msg.get('tool_calls', [])
-        if not tool_calls:
-            return []
-        
-        # Convert to ToolCall objects
-        chuk_tool_calls = []
-        for call in tool_calls:
-            func = call.get('function', {})
-            tool_name = func.get('name', '')
-            try:
-                arguments = json.loads(func.get('arguments', '{}'))
-            except json.JSONDecodeError:
-                arguments = {}
-            
-            chuk_tool_calls.append(ToolCall(
-                tool=tool_name,
-                arguments=arguments
-            ))
-        
-        # Execute the tools
-        print(f"🔧 Executing {len(chuk_tool_calls)} tools...")
-        results = await self.executor.execute(chuk_tool_calls)
-        
-        # Log each result as a session event
-        for result in results:
-            # Convert result to string for session storage
-            result_str = str(result.result) if result.result is not None else "null"
-            
-            tool_event = await SessionEvent.create_with_tokens(
-                message={
-                    "tool": result.tool,
-                    "arguments": getattr(result, "arguments", None),
-                    "result": result.result,
-                    "error": result.error,
-                },
-                prompt=f"{result.tool}({json.dumps(getattr(result, 'arguments', None), default=str)})",
-                completion=result_str,
-                model="tool-execution",
-                source=EventSource.SYSTEM,
-                type=EventType.TOOL_CALL,
-            )
-            await tool_event.set_metadata("parent_event_id", llm_event.id)
-            await session.add_event_and_save(tool_event)
-        
-        return results
-
-##############################################################################
-# LLM Simulation: Unreliable at first, then cooperative
-##############################################################################
-
-class UnreliableLLM:
-    """Simulates an LLM that sometimes doesn't follow tool-calling instructions."""
-    
-    def __init__(self):
-        self.call_count = 0
-        self.scenarios = [
-            # Scenario 1: Refuses to use tools
-            {
-                "role": "assistant", 
-                "content": "I don't need to use any tools. The weather in London is probably fine!",
-                "tool_calls": []
-            },
-            # Scenario 2: Tries to use non-existent tool
-            {
-                "role": "assistant",
-                "content": None,
-                "tool_calls": [
-                    {
-                        "id": "call_1",
-                        "type": "function", 
-                        "function": {
-                            "name": "nonexistent_weather_api",
-                            "arguments": '{"city": "London"}'
-                        }
-                    }
-                ]
-            },
-            # Scenario 3: Invalid JSON in arguments
-            {
-                "role": "assistant",
-                "content": None,
-                "tool_calls": [
-                    {
-                        "id": "call_2",
-                        "type": "function",
-                        "function": {
-                            "name": "weather", 
-                            "arguments": '{"location": London}'  # Missing quotes - invalid JSON
-                        }
-                    }
-                ]
-            },
-            # Scenario 4: Finally cooperates correctly
-            {
-                "role": "assistant",
-                "content": None,
-                "tool_calls": [
-                    {
-                        "id": "call_3",
-                        "type": "function",
-                        "function": {
-                            "name": "weather",
-                            "arguments": '{"location": "London"}'
-                        }
-                    }
-                ]
-            }
-        ]
-    
-    async def chat_completion(self, messages: List[Dict], **kwargs) -> Dict:
-        """Simulate OpenAI chat completion with unreliable behavior."""
-        self.call_count += 1
-        
-        if self.call_count <= len(self.scenarios):
-            response = self.scenarios[self.call_count - 1]
-            print(f"   📞 LLM Call {self.call_count}: {self._describe_response(response)}")
-            return response
-        else:
-            # After all scenarios, always cooperate
-            return self.scenarios[-1]
-    
-    def _describe_response(self, response: Dict) -> str:
-        """Describe what the LLM response contains."""
-        if response.get("tool_calls"):
-            tool_calls = response["tool_calls"]
-            if len(tool_calls) == 1:
-                func_name = tool_calls[0].get("function", {}).get("name", "unknown")
-                return f"Wants to call '{func_name}'"
-            else:
-                return f"Wants to call {len(tool_calls)} tools"
-        elif response.get("content"):
-            return f"Text response: '{response['content'][:50]}...'"
-        else:
-            return "Empty response"
-
-##############################################################################
-# Retry Logic for LLM Cooperation
-##############################################################################
-
-class LLMRetryManager:
-    """Manages retrying LLM calls until they produce valid, executable tool calls."""
-    
-    def __init__(self, session_id: str, max_attempts: int = 5):
-        self.session_id = session_id
-        self.max_attempts = max_attempts
-    
-    async def get_valid_tool_calls(self, llm, messages: List[Dict], processor: CustomSessionAwareToolProcessor) -> tuple[Dict, List]:
-        """
-        Keep calling the LLM until it produces valid, executable tool calls.
-        
-        Returns:
-            Tuple of (successful_llm_response, tool_results)
-        """
-        backend = get_backend()
-        store = ChukSessionsStore(backend)
-        session = await store.get(self.session_id)
-        
-        for attempt in range(1, self.max_attempts + 1):
-            print(f"\n🔄 LLM Attempt {attempt}/{self.max_attempts}")
-            
-            # Call LLM
-            response = await llm.chat_completion(messages)
-            
-            # Log the LLM response attempt
-            attempt_event = SessionEvent(
-                message={
-                    "attempt": attempt,
-                    "response": response,
-                    "success": False  # Will update if successful
-                },
-                type=EventType.MESSAGE,
-                source=EventSource.LLM,
-            )
-            await session.add_event_and_save(attempt_event)
-            
-            # Check if response has tool calls
-            tool_calls = response.get("tool_calls", [])
-            if not tool_calls:
-                print(f"   {format_status(False, failure_msg='No tool calls in response')}")
-                continue
-            
-            # Try to execute the tool calls
-            try:
-                print(f"   🔧 Attempting to execute {len(tool_calls)} tool calls...")
-                
-                # Check what tools are available vs requested
-                registry = await get_default_registry()
-                tools_list = await registry.list_tools()
-                available_tools = [name for namespace, name in tools_list]
-                requested_tool = tool_calls[0].get("function", {}).get("name", "unknown")
-                print(f"   🔍 Requested tool: {requested_tool}")
-                print(f"   🔍 Available tools: {available_tools}")
-                
-                tool_results = await processor.process_llm_message(response)
-                
-                # Check if all tools executed successfully
-                failed_tools = [r for r in tool_results if r.error]
-                if failed_tools:
-                    print(f"   {format_status(False, failure_msg=f'{len(failed_tools)} tools failed:')}")
-                    for failed in failed_tools:
-                        print(f"      • {failed.tool}: {failed.error}")
-                    continue
-                
-                # Success! All tools executed
-                print(f"   {format_status(True, success_msg=f'All {len(tool_results)} tools executed successfully')}")
-                
-                # Update the last event to mark success
-                session = await store.get(self.session_id)
-                if session.events:
-                    # Find the most recent LLM attempt event
-                    for event in reversed(session.events):
-                        if (event.type == EventType.MESSAGE and 
-                            event.source == EventSource.LLM and
-                            isinstance(event.message, dict) and
-                            "attempt" in event.message):
-                            event.message["success"] = True
-                            await store.save(session)
-                            break
-                
-                return response, tool_results
-                
-            except Exception as e:
-                print(f"   {format_status(False, failure_msg=f'Tool execution failed: {e}')}")
-                continue
-        
-        # If we get here, all attempts failed
-        raise RuntimeError(f"Failed to get valid tool calls after {self.max_attempts} attempts")
-
-##############################################################################
-# Demo Flow
-##############################################################################
-
-async def main() -> None:
-    print("🚀 Starting LLM Retry Demo")
-    print("   (Demonstrates retry logic for uncooperative LLMs)")
-    print("   (Tool execution uses chuk_tool_processor's built-in reliability)")
-    
-    # Setup session storage - FIXED
-    setup_chuk_sessions_storage(sandbox_id="retry-prompt-demo", default_ttl_hours=1)
-    backend = get_backend()
-    store = ChukSessionsStore(backend)
-    
-    # Initialize tool registry first
-    print("\n🔧 Initializing tool registry...")
-    registry = await initialize()
-    tools_list = await registry.list_tools()
-    print(f"📋 Found {len(tools_list)} registered tools:")
-    for namespace, tool_name in tools_list:
-        print(f"   • {namespace}.{tool_name}")
-    
-    # Create session
-    session = await Session.create()
-    await session.metadata.set_property("demo", "retry_prompt")
-    await store.save(session)
-    
-    # Add user request
-    user_prompt = "What's the weather like in London? I need to know if I should bring an umbrella."
-    user_event = await SessionEvent.create_with_tokens(
-        message=user_prompt,
-        prompt=user_prompt,
-        model="gpt-4o-mini",
-        source=EventSource.USER,
-        type=EventType.MESSAGE
-    )
-    await session.add_event_and_save(user_event)
-    print(f"\n👤 User: {user_prompt}")
-    
-    # Create components
-    llm = UnreliableLLM()
-    processor = await CustomSessionAwareToolProcessor.create(session_id=session.id)
-    retry_manager = LLMRetryManager(session_id=session.id, max_attempts=6)
-    
-    # Build initial messages for LLM
-    messages = [
-        {"role": "system", "content": "You are a helpful assistant. When users ask about weather, use the weather tool to get current information."},
-        {"role": "user", "content": user_prompt}
-    ]
-    
-    # Attempt to get valid tool calls with retries
-    try:
-        print(f"\n🎯 Attempting to get valid tool calls (max {retry_manager.max_attempts} attempts)...")
-        final_response, tool_results = await retry_manager.get_valid_tool_calls(llm, messages, processor)
-        
-        print(f"\n{'='*60}")
-        print("🎉 SUCCESS! LLM cooperated and tools executed successfully")
-        print(f"{'='*60}")
-        
-        # Show tool results
-        print("\n🛠️ Tool Results:")
-        for i, result in enumerate(tool_results, 1):
-            print(f"\n   Tool {i}: {result.tool}")
-            if result.error:
-                print(f"   ❌ Error: {result.error}")
-            elif isinstance(result.result, dict):
-                print(f"   📊 Result:")
-                for key, value in result.result.items():
-                    print(f"      {key}: {value}")
-            else:
-                print(f"   📊 Result: {result.result}")
-        
-    except RuntimeError as e:
-        print(f"\n❌ FAILED: {e}")
-        
-        # Still show the session events for debugging
-        print("\n🔍 Debugging: Session events created:")
-        session = await store.get(session.id)
-        for i, event in enumerate(session.events, 1):
-            print(f"   {i}. {event.type.value}/{event.source.value}: {str(event.message)[:100]}...")
-        return
-    
-    # Show session event tree
-    session = await store.get(session.id)
-    print(f"\n{'='*60}")
-    print("📊 Session Event Tree (Complete Retry History):")
-    print(f"{'='*60}")
-    
-    for i, event in enumerate(session.events, 1):
-        event_id = event.id[:8] + "..."
-        if event.type == EventType.MESSAGE and event.source == EventSource.USER:
-            print(f"{i}. USER MESSAGE [{event_id}]")
-            print(f"   Content: {event.message}")
-        elif event.type == EventType.MESSAGE and event.source == EventSource.LLM:
-            if isinstance(event.message, dict) and "attempt" in event.message:
-                attempt = event.message["attempt"]
-                success = event.message.get("success", False)
-                status = "✅ SUCCESS" if success else "❌ FAILED"
-                print(f"{i}. LLM ATTEMPT {attempt} [{event_id}] - {status}")
-            else:
-                print(f"{i}. LLM MESSAGE [{event_id}]")
-        elif event.type == EventType.TOOL_CALL:
-            tool_msg = event.message or {}
-            tool_name = tool_msg.get("tool", "unknown")
-            error = tool_msg.get("error")
-            print(f"{i}. TOOL CALL [{event_id}] - {tool_name}")
-            if error:
-                print(f"   ❌ Error: {error}")
-            else:
-                print(f"   ✅ Success")
-    
-    # Show final prompt for next turn
-    print(f"\n{'='*60}")
-    print("🔄 Final Prompt for Next LLM Turn:")
-    print(f"{'='*60}")
-    next_prompt = await build_prompt_from_session(session)
-    pprint.pp(next_prompt, width=80)
-    
-    # Show session statistics
-    print(f"\n{'='*60}")
-    print("📈 Session Statistics:")
-    print(f"{'='*60}")
-    print(f"   Session ID: {session.id}")
-    print(f"   Total events: {len(session.events)}")
-    print(f"   Total tokens: {session.total_tokens}")
-    print(f"   Estimated cost: ${session.total_cost:.6f}")
-    
-    # Event breakdown
-    event_types = {}
-    for event in session.events:
-        event_type = f"{event.source.value}:{event.type.value}"
-        event_types[event_type] = event_types.get(event_type, 0) + 1
-    
-    print(f"   Event breakdown:")
-    for event_type, count in event_types.items():
-        print(f"     {event_type}: {count}")
-    
-    print(f"\n{'='*60}")
-    print("🎯 Key Takeaways:")
-    print("   • LLM retries handled at application level")
-    print("   • Tool execution reliability handled by chuk_tool_processor")
-    print("   • Complete audit trail in session events")
-    print("   • Separation of concerns: LLM cooperation vs tool reliability")
-    print("   • Session tracks all attempts for debugging and analytics")
-    print(f"{'='*60}")
-
-if __name__ == "__main__":
-    asyncio.run(main())