safety agent upgrades to enable creative freedom, loops fixed v2

app.py

@@ -514,28 +514,37 @@ async def process_message_async(message: str, history: Optional[List], session_i
         
         new_history = list(history) if isinstance(history, list) else []
         
-        # Check if this is a safety choice response
+        # Check if this is a safety choice response (BEFORE normal processing)
         message_upper = message.strip().upper()
         is_safety_choice = message_upper in ['YES', 'NO', 'APPLY', 'KEEP', 'Y', 'N']
         
         # Check if we have a pending safety choice for this session
-        if is_safety_choice and orchestrator is not None and hasattr(orchestrator, '_pending_choices'):
-            pending_choice = orchestrator._pending_choices.get(session_id)
-            if pending_choice:
-                logger.info(f"Processing safety choice: {message_upper}")
+        if is_safety_choice and orchestrator is not None:
+            # Check both _pending_choices (from app.py) and awaiting_safety_response (from orchestrator)
+            pending_choice = getattr(orchestrator, '_pending_choices', {}).get(session_id)
+            awaiting_response = getattr(orchestrator, 'awaiting_safety_response', {}).get(session_id, False)
+            
+            if pending_choice or awaiting_response:
+                logger.info(f"Processing safety choice response: {message_upper} (session: {session_id})")
                 
                 # Determine user decision
                 user_decision = message_upper in ['YES', 'APPLY', 'Y']
                 
-                # Process the safety choice
-                choice_result = await orchestrator.handle_user_safety_decision(
-                    pending_choice['choice_id'],
-                    user_decision,
-                    session_id
-                )
-                
-                # Clean up pending choice
-                del orchestrator._pending_choices[session_id]
+                # Process the safety choice directly (bypasses normal safety checks)
+                if pending_choice:
+                    choice_result = await orchestrator.handle_user_safety_decision(
+                        pending_choice['choice_id'],
+                        user_decision,
+                        session_id
+                    )
+                    
+                    # Clean up pending choice
+                    if hasattr(orchestrator, '_pending_choices'):
+                        orchestrator._pending_choices.pop(session_id, None)
+                else:
+                    # Fallback: if no pending choice but flag is set, skip safety check
+                    logger.warning(f"Safety response flag set but no pending choice found - bypassing safety check")
+                    return new_history, "", {}, {}, {}, session_id, ""
                 
                 # Add user message
                 new_history.append({"role": "user", "content": message.strip()})
@@ -559,6 +568,10 @@ async def process_message_async(message: str, history: Optional[List], session_i
                     "session_id": session_id
                 }
                 
+                # Ensure flags are cleared
+                if hasattr(orchestrator, 'awaiting_safety_response'):
+                    orchestrator.awaiting_safety_response.pop(session_id, None)
+                
                 return new_history, "", reasoning_data, performance_data, context_data, session_id, ""
         
         # Add user message (normal flow)
@@ -578,11 +591,18 @@ async def process_message_async(message: str, history: Optional[List], session_i
             try:
                 logger.info("Attempting full orchestration...")
                 # First, try normal processing to check for user choice
+                # NOTE: Binary safety responses are already handled above, so this won't process them
                 result = await orchestrator.process_request(
                     session_id=session_id,
                     user_input=message.strip()
                 )
                 
+                # Check if result indicates this was a safety response (should have been handled above)
+                if result.get('is_safety_response', False):
+                    logger.warning("Safety response detected in normal processing - should have been handled earlier")
+                    # Skip further processing
+                    return new_history, "", {}, {}, {}, session_id, ""
+                
                 # Check if user choice is required
                 if result.get('requires_user_choice', False):
                     logger.info("User choice required for safety concerns")
@@ -610,6 +630,11 @@ async def process_message_async(message: str, history: Optional[List], session_i
                         'safety_analysis': result.get('safety_analysis', {})
                     }
                     
+                    # Ensure awaiting_safety_response flag is also set in orchestrator
+                    if not hasattr(orchestrator, 'awaiting_safety_response'):
+                        orchestrator.awaiting_safety_response = {}
+                    orchestrator.awaiting_safety_response[session_id] = True
+                    
                     # Add assistant message with choice prompt
                     new_history.append({
                         "role": "assistant", 

src/orchestrator_engine.py

@@ -41,6 +41,11 @@ class MVPOrchestrator:
         }
         self.max_revision_attempts = 2
         self.revision_timeout = 30  # seconds
+        
+        # Safety response tracking to prevent infinite loops
+        self.awaiting_safety_response = {}  # session_id -> True/False
+        self._pending_choices = {}  # session_id -> choice_data
+        
         logger.info("MVPOrchestrator initialized with safety revision thresholds")
         
     async def process_request(self, session_id: str, user_input: str) -> dict:
@@ -50,6 +55,23 @@ class MVPOrchestrator:
         logger.info(f"Processing request for session {session_id}")
         logger.info(f"User input: {user_input[:100]}")
         
+        # Safety context bypass: Skip safety checks for binary responses to safety prompts
+        user_input_upper = user_input.strip().upper()
+        is_binary_response = user_input_upper in ['YES', 'NO', 'APPLY', 'KEEP', 'Y', 'N']
+        
+        if is_binary_response and self.awaiting_safety_response.get(session_id, False):
+            logger.info(f"Binary safety response detected ({user_input_upper}) - bypassing safety check to prevent loop")
+            # Clear the flag immediately to prevent re-triggering
+            self.awaiting_safety_response[session_id] = False
+            
+            # Return a signal that this should be handled by the choice handler, not normal processing
+            return {
+                'is_safety_response': True,
+                'response': user_input_upper,
+                'requires_user_choice': False,
+                'skip_safety_check': True
+            }
+        
         # Clear previous trace for new request
         self.execution_trace = []
         start_time = time.time()
@@ -231,6 +253,9 @@ class MVPOrchestrator:
                     logger.info(f"Safety concerns detected for intent '{intent_class}' - requiring user choice")
                     processing_time = time.time() - start_time
                     
+                    # Set flag to indicate we're awaiting safety response for this session
+                    self.awaiting_safety_response[session_id] = True
+                    
                     return {
                         'requires_user_choice': True,
                         'choice_prompt': choice_prompt,
@@ -401,6 +426,10 @@ class MVPOrchestrator:
             dict: Final response based on user choice
         """
         try:
+            # Clear the awaiting safety response flag immediately to prevent loops
+            if session_id:
+                self.awaiting_safety_response[session_id] = False
+            
             if not SAFETY_CHOICE_AVAILABLE:
                 logger.warning("Safety choice modules not available")
                 return {'error': 'Safety choice system not available'}