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

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.4.dist-info/METADATA

@@ -0,0 +1,354 @@
+Metadata-Version: 2.4
+Name: chuk-ai-session-manager
+Version: 0.4
+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: 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!**

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

@@ -1,12 +1,12 @@
-chuk_ai_session_manager/__init__.py,sha256=0a8NezasrQJe2jm-1pZpzqPI-JCnrPNGTRLKDPRtyuk,11009
+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=N2Y0b7JkQsWLCvU1uGyAfYTGqyyCmG26X2PnKt3vux4,12040
+chuk_ai_session_manager/api/simple_api.py,sha256=RbHA2IAPUzIFZFvT6KpbgouAuonF-Q6GopKOeKej0rk,17795
 chuk_ai_session_manager/models/__init__.py,sha256=H1rRuDQDRf821JPUWUn5Zgwvc5BAqcEGekkHEmX-IgE,1167
 chuk_ai_session_manager/models/event_source.py,sha256=mn_D16sXMa6nAX-5BzssygJPz6VF24GRe-3IaH7bTnI,196
 chuk_ai_session_manager/models/event_type.py,sha256=TPPvAz-PlXVtrwXDNVFVnhdt1yEfgDGmKDGt8ArYcTk,275
@@ -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.2.1.dist-info/METADATA,sha256=2jeHA4T5WeDcDFTFOjEM19n3omLUV7b-fstAEEFSg9A,16435
-chuk_ai_session_manager-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-chuk_ai_session_manager-0.2.1.dist-info/top_level.txt,sha256=5RinqD0v-niHuLYePUREX4gEWTlrpgtUg0RfexVRBMk,24
-chuk_ai_session_manager-0.2.1.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,,