ref(app.py, prompts.yaml, final_answer_tool.py): adapt the code to submission requirements

app.py

@@ -244,11 +244,21 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         
         try:
             submitted_answer = agent(question_text)
+            # Ensure submitted_answer is a simple string/number/float
+            if isinstance(submitted_answer, dict):
+                # Extract meaningful value or convert to string
+                if len(submitted_answer) == 1:
+                    submitted_answer = list(submitted_answer.values())[0]
+                else:
+                    submitted_answer = str(submitted_answer)
+            elif not isinstance(submitted_answer, (str, int, float)):
+                submitted_answer = str(submitted_answer)
+            
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             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}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
         print("Agent did not produce any answers to submit.")

prompts.yaml

@@ -1,6 +1,6 @@
 system_prompt:
   main: |-
-    You are an expert assistant who can solve any task using code blobs. You will be given a task to solve as best you can.
+    You are a general AI assistant who can solve any task using code blobs. You will be given a task to solve as best you can.
     To do so, you have been given access to a list of tools: these tools are basically Python functions which you can call with code.
     To solve the task, you must plan forward to proceed in a series of steps, in a cycle of 'Thought:', 'Code:', and 'Observation:' sequences.
 
@@ -10,6 +10,13 @@ system_prompt:
     These print outputs will then appear in the 'Observation:' field, which will be available as input for the next step.
     In the end you have to return a final answer using the `final_answer` tool.
 
+    IMPORTANT FORMATTING RULES for final answers:
+    - YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings
+    - If asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise
+    - If asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise
+    - If asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string
+    - Return ONLY the direct answer, not a dictionary or complex object
+
     You have access to these tools:
     {%- for tool in tools.values() %}
     - {{ tool.name }}: {{ tool.description }}

src/final_answer_tool.py

@@ -1,14 +1,69 @@
 from typing import Any, Optional
 from smolagents.tools import Tool
+import re
 
 class FinalAnswerTool(Tool):
     name = "final_answer"
-    description = "Provides a final answer to the given problem."
+    description = "Provides a final answer to the given problem in GAIA benchmark format."
     inputs = {'answer': {'type': 'any', 'description': 'The final answer to the problem'}}
     output_type = "any"
 
-    def forward(self, answer: Any) -> Any:
-        return answer
+    def forward(self, answer: Any) -> str:
+        """
+        Process the answer to ensure it follows GAIA benchmark formatting rules.
+        Returns a clean string that matches expected format.
+        """
+        # Convert complex objects to simple strings
+        if isinstance(answer, dict):
+            # Try to extract meaningful value from dictionary
+            if len(answer) == 1:
+                answer = list(answer.values())[0]
+            elif 'answer' in answer:
+                answer = answer['answer']
+            elif 'result' in answer:
+                answer = answer['result']
+            elif 'value' in answer:
+                answer = answer['value']
+            else:
+                # Join values as comma-separated list
+                values = [str(v) for v in answer.values() if v is not None]
+                answer = ", ".join(values)
+        
+        elif isinstance(answer, list):
+            # Convert list to comma-separated string
+            answer = ", ".join(str(item) for item in answer if item is not None)
+        
+        # Convert to string and apply GAIA formatting rules
+        answer_str = str(answer).strip()
+        
+        # Remove common formatting issues
+        answer_str = self._clean_gaia_format(answer_str)
+        
+        return answer_str
+    
+    def _clean_gaia_format(self, text: str) -> str:
+        """Apply GAIA benchmark formatting rules."""
+        # Remove "FINAL ANSWER:" prefix if present
+        text = re.sub(r'^(FINAL\s*ANSWER\s*:\s*)', '', text, flags=re.IGNORECASE).strip()
+        
+        # Remove quotes if they wrap the entire answer
+        if (text.startswith('"') and text.endswith('"')) or (text.startswith("'") and text.endswith("'")):
+            text = text[1:-1]
+        
+        # Remove articles for strings (a, an, the) at the beginning
+        text = re.sub(r'^(a|an|the)\s+', '', text, flags=re.IGNORECASE)
+        
+        # Remove units symbols unless they might be part of the answer
+        # Be conservative - only remove obvious currency and percent
+        if not any(char.isalpha() for char in text.replace('$', '').replace('%', '')):
+            text = text.replace('$', '').replace('%', '')
+        
+        # Remove commas from numbers (but not from lists)
+        if re.match(r'^\d{1,3}(,\d{3})+(\.\d+)?$', text):
+            text = text.replace(',', '')
+        
+        return text.strip()
 
     def __init__(self, *args, **kwargs):
-        self.is_initialized = False
+        super().__init__(*args, **kwargs)
+        self.is_initialized = True