Update app.py

app.py

@@ -35,28 +35,13 @@ class BasicAgent:
         Process a GAIA benchmark question and return the answer
         """
         try:
-            # Ensure question is a string
-            if not isinstance(question, str):
-                question = str(question)
-            
             if self.verbose:
                 print(f"Processing question: {question}")
-                print(f"Task file path type: {type(task_file_path)}, value: {task_file_path}")
-            
-            # CRITICAL FIX: Ensure task_file_path is a string or None
-            if task_file_path is not None:
-                if isinstance(task_file_path, list):
-                    task_file_path = task_file_path[0] if len(task_file_path) > 0 else None
-                    print(f"Converted list to string: {task_file_path}")
-                elif not isinstance(task_file_path, str):
-                    task_file_path = str(task_file_path)
-                    print(f"Converted to string: {task_file_path}")
-            
-            if self.verbose and task_file_path:
-                print(f"With associated file: {task_file_path}")
+                if task_file_path:
+                    print(f"With associated file: {task_file_path}")
             
             # Create a context with file information if available
-            context = str(question)  # Ensure it's a string
+            context = question
             
             # If there's a file, read it and include its content in the context
             if task_file_path:
@@ -77,10 +62,10 @@ You can still try to answer the question based on the information provided.
 """
             
             # Check for special cases that need specific formatting
-            if str(question).startswith(".") or ".rewsna eht sa" in str(question):
+            if question.startswith(".") or ".rewsna eht sa" in question:
                 context = f"""
 This question appears to be in reversed text. Here's the reversed version:
-{str(question)[::-1]}
+{question[::-1]}
 Now answer the question above. Remember to format your answer exactly as requested.
 """
             
@@ -92,48 +77,16 @@ Be direct and specific. GAIA benchmark requires exact matching answers.
 For example, if asked "What is the capital of France?", respond simply with "Paris".
 """
             
-            # Ensure full_prompt is definitely a string
-            full_prompt = str(full_prompt)
-            
-            if self.verbose:
-                print(f"Full prompt type: {type(full_prompt)}")
-                print(f"Full prompt length: {len(full_prompt)}")
-            
-            # *** FIXED AGENT CALL - Pass string to CodeAgent ***
+            # *** FIXED AGENT CALL - Handles all response formats ***
             try:
-                # CodeAgent.run expects a textual task (string), not a list of messages
-                # Passing a list causes internal `.strip()` calls on a list, which raises:
-                # "AttributeError: 'list' object has no attribute 'strip'"
                 raw_response = self.agent.run(full_prompt)
                 
                 if self.verbose:
                     print(f"Raw response type: {type(raw_response)}")
                     print(f"Raw response: {raw_response}")
                 
-                # Handle ALL possible response formats
-                if isinstance(raw_response, dict):
-                    answer = raw_response.get('choices', [{}])[0].get('message', {}).get('content', str(raw_response))
-                elif isinstance(raw_response, list):
-                    if len(raw_response) > 0:
-                        if isinstance(raw_response[0], dict):
-                            # Common format: [{"role": "assistant", "content": "..."}]
-                            answer = raw_response[0].get('content', str(raw_response[0]))
-                        elif isinstance(raw_response[0], list):
-                            # Nested list - dig deeper
-                            nested = raw_response[0]
-                            if isinstance(nested, list) and len(nested) > 0:
-                                if isinstance(nested[0], dict):
-                                    answer = nested[0].get('content', str(nested[0]))
-                                else:
-                                    answer = str(nested[0])
-                            else:
-                                answer = str(raw_response[0])
-                        else:
-                            answer = str(raw_response[0])
-                    else:
-                        answer = "No response"
-                else:
-                    answer = str(raw_response)
+                # Handle ALL possible response formats with recursive flattening
+                answer = self._extract_answer(raw_response)
                 
                 if self.verbose:
                     print(f"Extracted answer type: {type(answer)}")
@@ -145,13 +98,7 @@ For example, if asked "What is the capital of France?", respond simply with "Par
                 return f"Agent error: {agent_error}"
             
             # Clean the answer
-            try:
-                answer = self._clean_answer(answer)
-            except Exception as clean_error:
-                print(f"Error cleaning answer: {clean_error}")
-                traceback.print_exc()
-                # Just return the raw answer as string if cleaning fails
-                answer = str(answer) if answer else "Error cleaning answer"
+            answer = self._clean_answer(answer)
             
             if self.verbose:
                 print(f"Generated answer: {answer}")
@@ -165,28 +112,71 @@ For example, if asked "What is the capital of France?", respond simply with "Par
                 traceback.print_exc()  
             return error_msg
     
-    def _clean_answer(self, answer: any) -> str:
+    def _extract_answer(self, response):
         """
-        Ultra-safe answer extraction and cleaning
+        Recursively extract the answer from any nested structure.
+        This handles dict, list, and nested combinations.
         """
-        # Force to string immediately with extra safety
-        try:
-            if answer is None:
+        if response is None:
+            return ""
+        
+        # If it's already a string, return it
+        if isinstance(response, str):
+            return response
+        
+        # If it's a dict, try to get 'content' or 'message'
+        if isinstance(response, dict):
+            # Try common keys
+            for key in ['content', 'message', 'text', 'answer']:
+                if key in response:
+                    return self._extract_answer(response[key])
+            # Try OpenAI-style format
+            if 'choices' in response:
+                choices = response['choices']
+                if choices and len(choices) > 0:
+                    return self._extract_answer(choices[0])
+            # If nothing found, convert to string
+            return str(response)
+        
+        # If it's a list, recursively process elements
+        if isinstance(response, list):
+            if len(response) == 0:
                 return ""
-            if isinstance(answer, list):
-                # If it's a list, try to extract meaningful content
-                if len(answer) == 0:
-                    return ""
-                # Try to get content from first element
-                answer = answer[0] if len(answer) > 0 else ""
-            if isinstance(answer, dict):
-                # If it's a dict, try to get 'content' or convert to string
-                answer = answer.get('content', str(answer))
+            # Try to extract from first element
+            first_element = self._extract_answer(response[0])
+            # If first element is empty or None, try other elements
+            if not first_element and len(response) > 1:
+                for element in response[1:]:
+                    extracted = self._extract_answer(element)
+                    if extracted:
+                        return extracted
+            return first_element
+        
+        # For any other type, convert to string
+        return str(response)
+    
+    def _clean_answer(self, answer) -> str:
+        """
+        Ultra-safe answer extraction and cleaning.
+        Ensures the answer is always a string.
+        """
+        # First, ensure we have a string
+        try:
+            # Recursively extract if needed
+            if not isinstance(answer, str):
+                answer = self._extract_answer(answer)
+            
+            # At this point, answer should be a string
             if not isinstance(answer, str):
                 answer = str(answer)
+            
         except Exception as e:
             print(f"Error in initial conversion: {e}")
-            return str(answer) if answer else ""
+            traceback.print_exc()
+            try:
+                return str(answer) if answer else ""
+            except:
+                return ""
         
         # Now answer should definitely be a string
         try:
@@ -211,23 +201,21 @@ For example, if asked "What is the capital of France?", respond simply with "Par
             
             return answer
         except Exception as e:
-            print(f"Error in answer cleaning: {e}, returning raw string")
-            return str(answer) if answer else ""
+            print(f"Error in answer cleaning: {e}")
+            traceback.print_exc()
+            try:
+                return str(answer) if answer else ""
+            except:
+                return ""
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
-    space_id = os.getenv("SPACE_ID")
-
-    if profile:
-        username = f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
-        print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
-
+    if profile is None:
+        return "Please log in with your Hugging Face account first.", None
+    username = profile.username
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
@@ -286,6 +274,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e:
             print(f"Error running agent on task {task_id}: {e}")
+            traceback.print_exc()
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
@@ -337,6 +326,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     except Exception as e:
         status_message = f"An unexpected error occurred during submission: {e}"
         print(status_message)
+        traceback.print_exc()
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
@@ -392,7 +382,7 @@ class Tee:
 
 if __name__ == "__main__":
     # Redirect stdout and stderr
-    log_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    log_timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
     log_file = f"./logs/output_{log_timestamp}.log"
     tee = Tee(log_file)
     sys.stdout = tee