simplified reasoning and prompts

app.py

@@ -131,19 +131,15 @@ class SlpMultiAgent:
                     lambda: manager_agent.run(f"""
                     Question: {short_question}
                     
-                    Answer this question step by step. When you need to write code, use this exact format:
+                    IMPORTANT: You must end with a final_answer() call containing ONLY the direct answer.
                     
-                    <code>
-                    # Your Python code here
-                    </code>
+                    Steps:
+                    1. Think through the problem
+                    2. Use search if needed with: <code>search_result = reliable_search("query")</code>
+                    3. End with: <code>final_answer("direct answer only")</code>
                     
-                    When you have the final answer, use:
-                    
-                    <code>
-                    final_answer("Your answer here")
-                    </code>
-                    
-                    Be precise and factual. Use search tools only when needed.
+                    Do NOT include thoughts, explanations, or reasoning in the final_answer().
+                    The final_answer() should contain only the specific answer requested.
                     """)
                 )
                 break  # Success, exit retry loop
@@ -165,49 +161,37 @@ class SlpMultiAgent:
             return "I apologize, but I'm currently experiencing technical difficulties. Please try again later."
         
         
+        # Extract clean answer from result
+        if result and isinstance(result, str):
+            # Look for final_answer pattern
+            import re
+            final_answer_match = re.search(r'final_answer\(["\']([^"\']*)["\'\])', result)
+            if final_answer_match:
+                clean_answer = final_answer_match.group(1)
+                return clean_answer
+            
+            # If no final_answer found, try to extract the last meaningful line
+            lines = result.strip().split('\n')
+            for line in reversed(lines):
+                line = line.strip()
+                if line and not line.startswith('#') and not line.startswith('###') and len(line) < 200:
+                    return line
+        
         # Return the result from the agent
-        return result
+        return result if result else "Unable to determine answer."
     
 def check_reasoning(final_answer, agent_memory):
     try:
-        multimodal_model = OpenAIServerModel(
-            model_id="gpt-3.5-turbo", 
-            max_tokens=100  # Reduced tokens for cost efficiency
-        )
-        
-        # More focused validation prompt
-        prompt = f"Rate answer quality 1-10: {final_answer[:200]}..."
-        
-        messages = [
-            {
-                "role": "user",
-                "content": prompt
-            }
-        ]
-        
-        # Add retry mechanism for rate limits
-        max_retries = 2  # Reduced retries
-        for attempt in range(max_retries):
-            try:
-                output = multimodal_model(messages)
-                if hasattr(output, 'content'):
-                    # Actually check the response instead of always returning True
-                    response = output.content.lower()
-                    # Look for quality indicators
-                    if any(word in response for word in ['7', '8', '9', '10', 'good', 'correct']):
-                        return True
-                    elif any(word in response for word in ['1', '2', '3', '4', 'poor', 'wrong']):
-                        return False
-                    return True  # Default to pass if unclear
-                break
-            except Exception as e:
-                if attempt < max_retries - 1:
-                    print(f"Retry {attempt+1}/{max_retries} due to: {e}")
-                    time.sleep(3)  # Reduced wait time
-                else:
-                    print(f"Final attempt failed: {e}")
+        # Simple validation - check if answer looks complete
+        if not final_answer or len(final_answer.strip()) < 2:
+            return False
         
-        return True  # Default to passing if we can't check properly
+        # Check if it's just thoughts/reasoning instead of an answer
+        bad_patterns = ['### Thought:', '### Code:', 'I will', 'Let me', 'First, I', 'Next, I']
+        if any(pattern in final_answer for pattern in bad_patterns):
+            return False
+            
+        return True  # Pass if it looks like a real answer
     except Exception as e:
         print(f"Error in reasoning check: {e}")
         return True  # Default to passing on errors