cache key error when user id changes -fixed task 1 31_10_2025 v7

app.py

@@ -525,6 +525,73 @@ def _update_skills_display(skills_html: str) -> Tuple[str, bool]:
     else:
         return "", False  # Hide skills display
 
+def process_with_metrics(message, session_id, user_id):
+    """Process message with detailed metrics"""
+    import json
+    import time
+    
+    metrics = {
+        'start_time': time.time(),
+        'context_size_before': 0,
+        'context_size_after': 0,
+        'llm_calls': [],
+        'cache_hits': 0,
+        'cache_misses': 0
+    }
+    
+    try:
+        global orchestrator
+        if orchestrator is None:
+            return None
+        
+        # Get initial context size
+        context = orchestrator.context_manager.get_or_create_session_context(session_id, user_id)
+        metrics['context_size_before'] = len(str(context))
+        
+        # Track LLM calls by wrapping the route_inference method
+        original_route = orchestrator.llm_router.route_inference
+        
+        async def tracked_route(*args, **kwargs):
+            start = time.time()
+            result = await original_route(*args, **kwargs)
+            metrics['llm_calls'].append({
+                'task': kwargs.get('task_type', 'unknown'),
+                'duration': time.time() - start,
+                'model': result.get('model', 'unknown') if isinstance(result, dict) else 'unknown'
+            })
+            return result
+        
+        # Temporarily replace route_inference (would need to restore after)
+        # Note: This is a simplified version - in production you'd use a decorator or wrapper
+        
+        # Process message
+        import asyncio
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        response = loop.run_until_complete(
+            orchestrator.process_request(
+                session_id=session_id,
+                user_input=message
+            )
+        )
+        
+        # Get final context size
+        context = orchestrator.context_manager.get_or_create_session_context(session_id, user_id)
+        metrics['context_size_after'] = len(str(context))
+        
+        # Calculate metrics
+        metrics['total_duration'] = time.time() - metrics['start_time']
+        metrics['context_growth'] = metrics['context_size_after'] - metrics['context_size_before']
+        
+        # Log metrics
+        logger.info(f"Processing Metrics: {json.dumps(metrics, indent=2)}")
+        
+        return response
+        
+    except Exception as e:
+        logger.error(f"Error in process_with_metrics: {e}", exc_info=True)
+        return None
+
 async def process_message_async(message: str, history: Optional[List], session_id: str, user_id: str = "Test_Any") -> Tuple[List, str, dict, dict, dict, str, str]:
     """
     Process message with full orchestration system

cache_implementation.py

@@ -1,6 +1,7 @@
 # cache_implementation.py
 import time
-from typing import Optional
+from typing import Optional, Dict
+from collections import OrderedDict
 
 class SessionCache:
     def __init__(self):
@@ -77,3 +78,51 @@ class SessionCache:
         # For now, return as-is
         return data
 
+class ContextCache:
+    """LRU cache for context management"""
+    
+    def __init__(self, max_size: int = 100):
+        self.cache = OrderedDict()
+        self.max_size = max_size
+        self.hit_count = 0
+        self.miss_count = 0
+    
+    def get(self, key: str) -> Optional[Dict]:
+        """Get from cache with LRU update"""
+        if key in self.cache:
+            self.hit_count += 1
+            # Move to end (most recently used)
+            self.cache.move_to_end(key)
+            return self.cache[key]
+        
+        self.miss_count += 1
+        return None
+    
+    def put(self, key: str, value: Dict):
+        """Add to cache with size management"""
+        if key in self.cache:
+            # Update existing
+            self.cache.move_to_end(key)
+        
+        self.cache[key] = value
+        
+        # Evict oldest if needed
+        if len(self.cache) > self.max_size:
+            self.cache.popitem(last=False)
+    
+    @property
+    def hit_rate(self) -> float:
+        """Calculate cache hit rate"""
+        total = self.hit_count + self.miss_count
+        return self.hit_count / total if total > 0 else 0.0
+    
+    def clear(self):
+        """Clear all cache entries"""
+        self.cache.clear()
+        self.hit_count = 0
+        self.miss_count = 0
+    
+    def size(self) -> int:
+        """Get current cache size"""
+        return len(self.cache)
+

config.py

@@ -41,3 +41,23 @@ class Settings(BaseSettings):
 
 settings = Settings()
 
+# Context configuration
+CONTEXT_CONFIG = {
+    'max_context_tokens': int(os.getenv("MAX_CONTEXT_TOKENS", "4000")),
+    'cache_ttl_seconds': int(os.getenv("CACHE_TTL_SECONDS", "300")),
+    'max_cache_size': int(os.getenv("MAX_CACHE_SIZE", "100")),
+    'parallel_processing': os.getenv("PARALLEL_PROCESSING", "True").lower() == "true",
+    'context_decay_factor': float(os.getenv("CONTEXT_DECAY_FACTOR", "0.8")),
+    'max_interactions_to_keep': int(os.getenv("MAX_INTERACTIONS_TO_KEEP", "10")),
+    'enable_metrics': os.getenv("ENABLE_METRICS", "True").lower() == "true",
+    'compression_enabled': os.getenv("COMPRESSION_ENABLED", "True").lower() == "true",
+    'summarization_threshold': int(os.getenv("SUMMARIZATION_THRESHOLD", "2000"))  # tokens
+}
+
+# Model selection for context operations
+CONTEXT_MODELS = {
+    'summarization': os.getenv("CONTEXT_SUMMARIZATION_MODEL", "Qwen/Qwen2.5-7B-Instruct"),
+    'intent': os.getenv("CONTEXT_INTENT_MODEL", "Qwen/Qwen2.5-7B-Instruct"),
+    'synthesis': os.getenv("CONTEXT_SYNTHESIS_MODEL", "Qwen/Qwen2.5-72B-Instruct")
+}
+

src/context_manager.py

@@ -7,6 +7,7 @@ import hashlib
 import threading
 from contextlib import contextmanager
 from datetime import datetime, timedelta
+from typing import Dict, Optional, List
 
 logger = logging.getLogger(__name__)
 
@@ -49,6 +50,7 @@ class TransactionManager:
 class EfficientContextManager:
     def __init__(self, llm_router=None):
         self.session_cache = {}  # In-memory for active sessions
+        self._session_cache = {}  # Enhanced in-memory cache with timestamps
         self.cache_config = {
             "max_session_size": 10,  # MB per session
             "ttl": 3600,  # 1 hour
@@ -1228,3 +1230,121 @@ Keep the summary concise (approximately 100 tokens)."""
         """
         # TODO: Implement summary generation
         return ""
+    
+    def get_or_create_session_context(self, session_id: str, user_id: Optional[str] = None) -> Dict:
+        """Enhanced context retrieval with caching"""
+        import time
+        
+        # In-memory cache check first
+        if session_id in self._session_cache:
+            cache_entry = self._session_cache[session_id]
+            if time.time() - cache_entry['timestamp'] < 300:  # 5 min cache
+                logger.debug(f"Cache hit for session {session_id}")
+                return cache_entry['context']
+        
+        # Batch database queries
+        conn = None
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            # Single query for all context data
+            query = """
+            SELECT 
+                s.session_data,
+                s.user_metadata,
+                s.last_activity,
+                u.user_profile,
+                i.interaction_data,
+                ic.context_summary
+            FROM sessions s
+            LEFT JOIN user_contexts u ON s.user_id = u.user_id
+            LEFT JOIN interactions i ON s.session_id = i.session_id
+            LEFT JOIN interaction_contexts ic ON i.session_id = ic.session_id
+            WHERE s.session_id = ?
+            ORDER BY i.created_at DESC
+            LIMIT 10
+            """
+            
+            cursor.execute(query, (session_id,))
+            results = cursor.fetchall()
+            
+            # Process results efficiently
+            context = self._build_context_from_results(results, session_id, user_id)
+            
+            # Update cache
+            self._session_cache[session_id] = {
+                'context': context,
+                'timestamp': time.time()
+            }
+            
+            return context
+            
+        except Exception as e:
+            logger.error(f"Error in get_or_create_session_context: {e}", exc_info=True)
+            # Return safe fallback
+            return {
+                "session_id": session_id,
+                "user_id": user_id or "Test_Any",
+                "interaction_contexts": [],
+                "session_context": None,
+                "preferences": {},
+                "active_tasks": [],
+                "user_context_loaded": False
+            }
+        finally:
+            if conn:
+                conn.close()
+    
+    def _build_context_from_results(self, results: list, session_id: str, user_id: Optional[str]) -> Dict:
+        """Build context dictionary from batch query results"""
+        context = {
+            "session_id": session_id,
+            "user_id": user_id or "Test_Any",
+            "interaction_contexts": [],
+            "session_context": None,
+            "user_context": "",
+            "preferences": {},
+            "active_tasks": [],
+            "user_context_loaded": False
+        }
+        
+        if not results:
+            return context
+        
+        # Process first row for session data
+        first_row = results[0]
+        if first_row[0]:  # session_data
+            try:
+                session_data = json.loads(first_row[0])
+                context["preferences"] = session_data.get("preferences", {})
+                context["active_tasks"] = session_data.get("active_tasks", [])
+            except:
+                pass
+        
+        if first_row[1]:  # user_metadata
+            try:
+                user_metadata = json.loads(first_row[1])
+                context["preferences"].update(user_metadata.get("preferences", {}))
+            except:
+                pass
+        
+        context["last_activity"] = first_row[2]  # last_activity
+        
+        if first_row[3]:  # user_profile
+            context["user_context"] = first_row[3]
+            context["user_context_loaded"] = True
+        
+        # Process interaction contexts
+        seen_interactions = set()
+        for row in results:
+            if row[5]:  # context_summary
+                # Deduplicate interactions
+                if row[5] not in seen_interactions:
+                    seen_interactions.add(row[5])
+                    context["interaction_contexts"].append({
+                        "summary": row[5],
+                        "timestamp": None  # Could extract from row if available
+                    })
+        
+        return context

src/llm_router.py

@@ -1,6 +1,7 @@
 # llm_router.py - FIXED VERSION
 import logging
 import asyncio
+from typing import Dict
 from .models_config import LLM_CONFIG
 
 logger = logging.getLogger(__name__)
@@ -256,3 +257,101 @@ class LLMRouter:
             }
         
         return health_status
+    
+    def prepare_context_for_llm(self, raw_context: Dict, max_tokens: int = 4000) -> str:
+        """Smart context windowing for LLM calls"""
+        
+        try:
+            from transformers import AutoTokenizer
+            
+            # Initialize tokenizer lazily
+            if not hasattr(self, 'tokenizer'):
+                try:
+                    self.tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-7B-Instruct")
+                except Exception as e:
+                    logger.warning(f"Could not load tokenizer: {e}, using character count estimation")
+                    self.tokenizer = None
+        except ImportError:
+            logger.warning("transformers library not available, using character count estimation")
+            self.tokenizer = None
+        
+        # Priority order for context elements
+        priority_elements = [
+            ('current_query', 1.0),
+            ('recent_interactions', 0.8),
+            ('user_preferences', 0.6),
+            ('session_summary', 0.4),
+            ('historical_context', 0.2)
+        ]
+        
+        formatted_context = []
+        total_tokens = 0
+        
+        for element, priority in priority_elements:
+            # Map element names to context keys
+            element_key_map = {
+                'current_query': raw_context.get('user_input', ''),
+                'recent_interactions': raw_context.get('interaction_contexts', []),
+                'user_preferences': raw_context.get('preferences', {}),
+                'session_summary': raw_context.get('session_context', {}),
+                'historical_context': raw_context.get('user_context', '')
+            }
+            
+            content = element_key_map.get(element, '')
+            
+            # Convert to string if needed
+            if isinstance(content, dict):
+                content = str(content)
+            elif isinstance(content, list):
+                content = "\n".join([str(item) for item in content[:10]])  # Limit to 10 items
+            
+            if not content:
+                continue
+            
+            # Estimate tokens
+            if self.tokenizer:
+                try:
+                    tokens = len(self.tokenizer.encode(content))
+                except:
+                    # Fallback to character-based estimation (rough: 1 token ≈ 4 chars)
+                    tokens = len(content) // 4
+            else:
+                # Character-based estimation (rough: 1 token ≈ 4 chars)
+                tokens = len(content) // 4
+            
+            if total_tokens + tokens <= max_tokens:
+                formatted_context.append(f"=== {element.upper()} ===\n{content}")
+                total_tokens += tokens
+            elif priority > 0.5:  # Critical elements - truncate if needed
+                available = max_tokens - total_tokens
+                if available > 100:  # Only truncate if we have meaningful space
+                    truncated = self._truncate_to_tokens(content, available)
+                    formatted_context.append(f"=== {element.upper()} (TRUNCATED) ===\n{truncated}")
+                break
+        
+        return "\n\n".join(formatted_context)
+    
+    def _truncate_to_tokens(self, content: str, max_tokens: int) -> str:
+        """Truncate content to fit within token limit"""
+        if not self.tokenizer:
+            # Simple character-based truncation
+            max_chars = max_tokens * 4
+            if len(content) <= max_chars:
+                return content
+            return content[:max_chars-3] + "..."
+        
+        try:
+            # Tokenize and truncate
+            tokens = self.tokenizer.encode(content)
+            if len(tokens) <= max_tokens:
+                return content
+            
+            truncated_tokens = tokens[:max_tokens-3]  # Leave room for "..."
+            truncated_text = self.tokenizer.decode(truncated_tokens)
+            return truncated_text + "..."
+        except Exception as e:
+            logger.warning(f"Error truncating with tokenizer: {e}, using character truncation")
+            max_chars = max_tokens * 4
+            if len(content) <= max_chars:
+                return content
+            return content[:max_chars-3] + "..."

src/orchestrator_engine.py

@@ -4,6 +4,8 @@ import logging
 import time
 import asyncio
 from datetime import datetime
+from typing import List, Dict, Optional
+from concurrent.futures import ThreadPoolExecutor
 import sys
 import os
 
@@ -199,39 +201,50 @@ class MVPOrchestrator:
                 "reasoning": f"Context analysis shows user is focused on {main_topic} with {interaction_contexts_count} previous interaction contexts and {'existing' if has_user_context else 'new'} user context"
             }
             
-            # Step 3: Intent recognition with enhanced CoT
-            logger.info("Step 3: Recognizing intent...")
-            self.execution_trace.append({
-                "step": "intent_recognition",
-                "agent": "intent_recognition",
-                "status": "executing"
-            })
-            intent_result = await self.agents['intent_recognition'].execute(
-                user_input=user_input,
-                context=context
-            )
-            self.execution_trace[-1].update({
-                "status": "completed",
-                "result": {"primary_intent": intent_result.get('primary_intent', 'unknown')}
-            })
-            logger.info(f"Intent detected: {intent_result.get('primary_intent', 'unknown')}")
+            # Step 3: Parallel Intent, Skills, and Safety Assessment
+            # Check if parallel processing is enabled (can be controlled via config)
+            use_parallel = getattr(self, '_parallel_processing_enabled', True)
             
-            # Step 3.5: Skills Identification
-            logger.info("Step 3.5: Identifying relevant skills...")
-            self.execution_trace.append({
-                "step": "skills_identification",
-                "agent": "skills_identification",
-                "status": "executing"
-            })
-            skills_result = await self.agents['skills_identification'].execute(
-                user_input=user_input,
-                context=context
-            )
-            self.execution_trace[-1].update({
-                "status": "completed",
-                "result": {"skills_count": len(skills_result.get('identified_skills', []))}
-            })
-            logger.info(f"Skills identified: {len(skills_result.get('identified_skills', []))} skills")
+            if use_parallel:
+                logger.info("Step 3: Processing intent, skills, and safety in parallel...")
+                parallel_results = await self.process_request_parallel(session_id, user_input, context)
+                intent_result = parallel_results.get('intent', {})
+                skills_result = parallel_results.get('skills', {})
+                # Safety will be checked later on the response
+            else:
+                # Sequential processing (fallback)
+                logger.info("Step 3: Recognizing intent...")
+                self.execution_trace.append({
+                    "step": "intent_recognition",
+                    "agent": "intent_recognition",
+                    "status": "executing"
+                })
+                intent_result = await self.agents['intent_recognition'].execute(
+                    user_input=user_input,
+                    context=context
+                )
+                self.execution_trace[-1].update({
+                    "status": "completed",
+                    "result": {"primary_intent": intent_result.get('primary_intent', 'unknown')}
+                })
+                logger.info(f"Intent detected: {intent_result.get('primary_intent', 'unknown')}")
+                
+                # Step 3.5: Skills Identification
+                logger.info("Step 3.5: Identifying relevant skills...")
+                self.execution_trace.append({
+                    "step": "skills_identification",
+                    "agent": "skills_identification",
+                    "status": "executing"
+                })
+                skills_result = await self.agents['skills_identification'].execute(
+                    user_input=user_input,
+                    context=context
+                )
+                self.execution_trace[-1].update({
+                    "status": "completed",
+                    "result": {"skills_count": len(skills_result.get('identified_skills', []))}
+                })
+                logger.info(f"Skills identified: {len(skills_result.get('identified_skills', []))} skills")
             
             # Add skills reasoning to chain
             reasoning_chain["chain_of_thought"]["step_2_5"] = {
@@ -680,6 +693,106 @@ This response has been flagged for potential safety concerns:
         
         return " | ".join(summary_parts) if summary_parts else "No prior context"
     
+    async def process_request_parallel(self, session_id: str, user_input: str, context: Dict) -> Dict:
+        """Process intent, skills, and safety in parallel"""
+        
+        # Run agents in parallel using asyncio.gather
+        try:
+            intent_task = self.agents['intent_recognition'].execute(
+                user_input=user_input,
+                context=context
+            )
+            
+            skills_task = self.agents['skills_identification'].execute(
+                user_input=user_input,
+                context=context
+            )
+            
+            # Safety check on user input (pre-check)
+            safety_task = self.agents['safety_check'].execute(
+                response=user_input,
+                context=context
+            )
+            
+            # Wait for all to complete
+            results = await asyncio.gather(
+                intent_task,
+                skills_task,
+                safety_task,
+                return_exceptions=True
+            )
+            
+            # Handle results
+            intent_result = results[0] if not isinstance(results[0], Exception) else {}
+            skills_result = results[1] if not isinstance(results[1], Exception) else {}
+            safety_result = results[2] if not isinstance(results[2], Exception) else {}
+            
+            # Log any exceptions
+            if isinstance(results[0], Exception):
+                logger.error(f"Intent recognition error: {results[0]}")
+            if isinstance(results[1], Exception):
+                logger.error(f"Skills identification error: {results[1]}")
+            if isinstance(results[2], Exception):
+                logger.error(f"Safety check error: {results[2]}")
+            
+            return {
+                'intent': intent_result,
+                'skills': skills_result,
+                'safety_precheck': safety_result
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in parallel processing: {e}", exc_info=True)
+            # Fallback to sequential processing
+            return {
+                'intent': await self.agents['intent_recognition'].execute(user_input=user_input, context=context),
+                'skills': await self.agents['skills_identification'].execute(user_input=user_input, context=context),
+                'safety_precheck': {}
+            }
+    
+    def _build_enhanced_context(self, session_id: str, prior_interactions: List[Dict]) -> Dict:
+        """Build enhanced context with memory accumulation"""
+        
+        # Intelligent context summarization
+        context = {
+            'session_memory': [],
+            'user_preferences': {},
+            'interaction_patterns': {},
+            'skills_used': set()
+        }
+        
+        # Process prior interactions with decay
+        for idx, interaction in enumerate(prior_interactions):
+            weight = 1.0 / (idx + 1)  # Recent interactions weighted more
+            
+            # Extract key information
+            if 'skills' in interaction:
+                for skill in interaction['skills']:
+                    if isinstance(skill, dict):
+                        context['skills_used'].add(skill.get('name', skill.get('skill', '')))
+                    elif isinstance(skill, str):
+                        context['skills_used'].add(skill)
+            
+            # Accumulate patterns
+            if 'intent' in interaction:
+                intent = interaction['intent']
+                if intent not in context['interaction_patterns']:
+                    context['interaction_patterns'][intent] = 0
+                context['interaction_patterns'][intent] += weight
+            
+            # Build memory summary
+            if idx < 3:  # Keep last 3 interactions in detail
+                context['session_memory'].append({
+                    'summary': interaction.get('summary', ''),
+                    'timestamp': interaction.get('timestamp'),
+                    'relevance': weight
+                })
+        
+        # Convert skills_used set to list for JSON serialization
+        context['skills_used'] = list(context['skills_used'])
+        
+        return context
+    
     def _build_task_prompts(self, user_input: str, context_summary: str, primary_intent: str) -> dict:
         """Build task-specific prompts for execution"""
         

test_context_flow.py

@@ -0,0 +1,163 @@
+"""
+Test script for context building across two turns
+"""
+import time
+import json
+import asyncio
+import sys
+import os
+
+# Add project paths
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'src'))
+
+try:
+    from src.orchestrator_engine import MVPOrchestrator
+    from src.context_manager import EfficientContextManager
+    from src.llm_router import LLMRouter
+    from src.agents.intent_agent import create_intent_agent
+    from src.agents.synthesis_agent import create_synthesis_agent
+    from src.agents.safety_agent import create_safety_agent
+    from src.agents.skills_identification_agent import create_skills_identification_agent
+except ImportError as e:
+    print(f"Error importing modules: {e}")
+    print("Please ensure all dependencies are installed and paths are correct.")
+    sys.exit(1)
+
+def test_two_turn_conversation():
+    """Test context building across two turns"""
+    
+    print("=" * 60)
+    print("TWO-TURN CONVERSATION CONTEXT TEST")
+    print("=" * 60)
+    
+    try:
+        # Initialize components
+        print("\n[1/4] Initializing components...")
+        hf_token = os.getenv('HF_TOKEN', '')
+        if not hf_token:
+            print("WARNING: HF_TOKEN not set. Some tests may fail.")
+        
+        llm_router = LLMRouter(hf_token)
+        
+        agents = {
+            'intent_recognition': create_intent_agent(llm_router),
+            'response_synthesis': create_synthesis_agent(llm_router),
+            'safety_check': create_safety_agent(llm_router),
+            'skills_identification': create_skills_identification_agent(llm_router)
+        }
+        
+        context_manager = EfficientContextManager(llm_router=llm_router)
+        
+        orchestrator = MVPOrchestrator(llm_router, context_manager, agents)
+        
+        session_id = "test_session_context"
+        user_id = "test_user"
+        
+        print(f"✓ Components initialized")
+        print(f"  Session ID: {session_id}")
+        print(f"  User ID: {user_id}")
+        
+        # Turn 1
+        print("\n[2/4] TURN 1 - Initial Query")
+        print("-" * 60)
+        turn1_input = "I have an AI Assistant for database queries"
+        print(f"User Input: {turn1_input}")
+        
+        start = time.time()
+        
+        try:
+            result1 = asyncio.run(orchestrator.process_request(
+                session_id=session_id,
+                user_input=turn1_input
+            ))
+            turn1_time = time.time() - start
+            
+            response1 = result1.get('response', result1.get('final_response', ''))
+            print(f"✓ Turn 1 completed in {turn1_time:.2f}s")
+            print(f"  Response length: {len(response1)} characters")
+            
+            # Check context
+            context1 = orchestrator.context_manager.get_or_create_session_context(session_id, user_id)
+            context1_size = len(str(context1))
+            print(f"  Context size after Turn 1: {context1_size} characters")
+            print(f"  Interaction contexts: {len(context1.get('interaction_contexts', []))}")
+            
+        except Exception as e:
+            print(f"✗ Turn 1 failed: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+        
+        # Turn 2
+        print("\n[3/4] TURN 2 - Follow-up Query")
+        print("-" * 60)
+        turn2_input = "Build a 15-day MVP and 2-month execution plan"
+        print(f"User Input: {turn2_input}")
+        
+        start = time.time()
+        
+        try:
+            result2 = asyncio.run(orchestrator.process_request(
+                session_id=session_id,
+                user_input=turn2_input
+            ))
+            turn2_time = time.time() - start
+            
+            response2 = result2.get('response', result2.get('final_response', ''))
+            print(f"✓ Turn 2 completed in {turn2_time:.2f}s")
+            print(f"  Response length: {len(response2)} characters")
+            
+            # Check context growth
+            context2 = orchestrator.context_manager.get_or_create_session_context(session_id, user_id)
+            context2_size = len(str(context2))
+            context_growth = context2_size - context1_size
+            print(f"  Context size after Turn 2: {context2_size} characters")
+            print(f"  Context growth: {context_growth} characters")
+            print(f"  Interaction contexts: {len(context2.get('interaction_contexts', []))}")
+            
+        except Exception as e:
+            print(f"✗ Turn 2 failed: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+        
+        # Verify context continuity
+        print("\n[4/4] Context Continuity Verification")
+        print("-" * 60)
+        
+        # Check that session_id is preserved
+        assert session_id in str(context2), "Session ID not found in context"
+        print("✓ Session ID preserved in context")
+        
+        # Check that interaction contexts accumulated
+        interaction_count = len(context2.get('interaction_contexts', []))
+        assert interaction_count >= 1, f"Expected at least 1 interaction context, got {interaction_count}"
+        print(f"✓ Interaction contexts accumulated: {interaction_count}")
+        
+        # Check context structure
+        assert 'session_id' in context2, "Session ID missing from context"
+        assert 'user_id' in context2, "User ID missing from context"
+        print("✓ Context structure valid")
+        
+        print("\n" + "=" * 60)
+        print("✓ ALL TESTS PASSED")
+        print("=" * 60)
+        print(f"\nSummary:")
+        print(f"  Turn 1 time: {turn1_time:.2f}s")
+        print(f"  Turn 2 time: {turn2_time:.2f}s")
+        print(f"  Context growth: {context_growth} characters")
+        print(f"  Total interactions: {interaction_count}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"\n✗ TEST FAILED: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    success = test_two_turn_conversation()
+    sys.exit(0 if success else 1)
+