Update app.py

app.py

@@ -37,7 +37,6 @@ logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
     handlers=[logging.StreamHandler(sys.stdout)]
 )
-# Suppress overly verbose logs from underlying libraries
 logging.getLogger("httpx").setLevel(logging.WARNING)
 logging.getLogger("httpcore").setLevel(logging.WARNING)
 logging.getLogger("openai").setLevel(logging.WARNING)
@@ -46,10 +45,9 @@ logging.getLogger("urllib3").setLevel(logging.WARNING)
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-ENABLE_SUBMISSION = False # CHANGE TO True TO ENABLE SUBMISSION
+ENABLE_SUBMISSION = False # Keep False for testing, True for final submission
 
 # --- *** TASK ID TO QUESTION NUMBER MAPPING *** ---
-# Map the provided UUIDs to the corresponding question number (1-20)
 TASK_ID_MAP = {
     "8e867cd7-cff9-4e6c-867a-ff5ddc2550be": "1",  # Mercedes Sosa Albums
     "a1e91b78-d3d8-4675-bb8d-62741b4b68a6": "2",  # Birds Video (Unsupported)
@@ -87,65 +85,43 @@ SPECIAL_AGENT_LOGIC_TASKS = {'5'} # Needs multi-step agent interaction
 
 def download_file(url: str, destination_folder: str, task_id: str) -> Path | None:
     """Downloads a file from the GAIA benchmark URL."""
-    # Check for invalid URL early
     if not url or not isinstance(url, str) or not url.startswith("http"):
-         logging.error(f"Invalid or missing URL provided for task {task_id}: '{url}'")
-         return None
+        logging.error(f"Invalid or missing URL provided for task {task_id}: '{url}'")
+        return None
     try:
         response = requests.get(url, stream=True, timeout=60)
-        response.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
-
+        response.raise_for_status()
         content_disposition = response.headers.get('content-disposition')
-        filename = f"file_{task_id}" # Default filename
+        filename = f"file_{task_id}"
         if content_disposition:
-            # Try to extract filename securely, handling different formats
             fname_match = re.search(r'filename\*?=(?:UTF-\d\'\')?([^;\n]+)', content_disposition, re.IGNORECASE)
             if fname_match:
                 raw_filename = urllib.parse.unquote(fname_match.group(1).strip().strip('"\' '))
-                safe_filename = re.sub(r'[^\w\.\-]', '_', raw_filename)[:100] # Sanitize and truncate
+                safe_filename = re.sub(r'[^\w\.\-]', '_', raw_filename)[:100]
                 filename = f"{task_id}_{safe_filename}"
-            else: # Fallback parsing for simpler filename="name.ext"
+            else:
                 fname_match_simple = re.search(r'filename="?([^"]+)"?', content_disposition)
                 if fname_match_simple:
                     safe_filename = re.sub(r'[^\w\.\-]', '_', fname_match_simple.group(1))[:100]
                     filename = f"{task_id}_{safe_filename}"
-                else: # Fallback if all parsing fails
-                    extension = os.path.splitext(url)[1] or '.dat' # Get extension from URL
-                    filename = f"{task_id}_downloaded_file{extension}"
-        else: # No content-disposition, guess extension from URL
-            extension = os.path.splitext(url)[1] or '.dat'
-            filename = f"{task_id}_downloaded_file{extension}"
+                else: extension = os.path.splitext(url)[1] or '.dat'; filename = f"{task_id}_downloaded{extension}"
+        else: extension = os.path.splitext(url)[1] or '.dat'; filename = f"{task_id}_downloaded{extension}"
 
         destination_path = Path(destination_folder) / filename
         destination_path.parent.mkdir(parents=True, exist_ok=True)
         logging.info(f"Downloading for {task_id} from {url} to {destination_path}")
-
         downloaded_size = 0
         with open(destination_path, "wb") as f:
-            for chunk in response.iter_content(chunk_size=65536): # Use a larger chunk size
-                 if chunk: # filter out keep-alive new chunks
-                      f.write(chunk)
-                      downloaded_size += len(chunk)
-
-        # Verify download integrity
+            for chunk in response.iter_content(chunk_size=65536):
+                 if chunk: f.write(chunk); downloaded_size += len(chunk)
         if destination_path.exists():
-             file_size = destination_path.stat().st_size
-             logging.info(f"Downloaded {destination_path} (Size: {file_size} bytes)")
-             # GAIA files should generally not be empty. Treat 0-byte as error.
-             if file_size == 0 and downloaded_size == 0:
-                  logging.error(f"Downloaded file {destination_path} is EMPTY for task {task_id}. Download failed.")
-                  # Attempt to remove the empty file
-                  try: os.remove(destination_path)
-                  except OSError: pass
-                  return None # Treat empty file as download failure
+             file_size = destination_path.stat().st_size; logging.info(f"Downloaded {destination_path} (Size: {file_size} bytes)")
+             if file_size == 0 and downloaded_size == 0: logging.error(f"Downloaded file {destination_path} EMPTY for task {task_id}."); return None
              return destination_path
-        else:
-             logging.error(f"File {destination_path} not found after download attempt for task {task_id}.")
-             return None
-
-    except requests.exceptions.Timeout: logging.error(f"Timeout downloading {url} for task {task_id}."); return None
+        else: logging.error(f"File {destination_path} not found after download for task {task_id}."); return None
+    except requests.exceptions.Timeout: logging.error(f"Timeout downloading {url} for {task_id}."); return None
     except requests.exceptions.RequestException as e: logging.error(f"Request error downloading {url} for task {task_id}: {e}"); return None
-    except Exception as e: logging.error(f"Unexpected download error for task {task_id}: {e}", exc_info=True); return None
+    except Exception as e: logging.error(f"Download error for task {task_id}: {e}", exc_info=True); return None
 
 # --- Custom Processing/Analysis Functions ---
 
@@ -154,117 +130,61 @@ def transcribe_audio(file_path: Union[str, Path]) -> str:
     path_obj = Path(file_path);
     if not path_obj.is_file(): return f"ERROR: Audio file missing: {file_path}"
     sz = path_obj.stat().st_size;
-    # Check for suspiciously small files (e.g., less than typical header size)
     if sz < 100: return f"ERROR: Audio file {file_path} empty/corrupt (size={sz} bytes)."
     try:
-        logging.info(f"Transcribing audio: {file_path} (Size: {sz} bytes)")
-        api_key = os.getenv("OPENAI_API_KEY");
+        logging.info(f"Transcribing audio: {file_path} (Size: {sz} bytes)"); api_key = os.getenv("OPENAI_API_KEY");
         if not api_key: return "ERROR: OPENAI_API_KEY not set."
         client = OpenAI(api_key=api_key);
-        with open(file_path, "rb") as audio_file:
-             transcript = client.audio.transcriptions.create(model="whisper-1", file=audio_file, response_format="text")
-        # Response is directly the transcript string when response_format="text"
-        logging.info(f"Transcription OK for {file_path}. Length: {len(str(transcript))}")
-        return str(transcript).strip()
+        with open(file_path, "rb") as audio_file: transcript = client.audio.transcriptions.create(model="whisper-1", file=audio_file, response_format="text")
+        logging.info(f"Transcription OK for {file_path}. Len: {len(str(transcript))}"); return str(transcript).strip()
     except Exception as e:
         err = str(e).lower(); logging.error(f"Error transcribing {file_path}: {e}", exc_info=True)
-        if any(s in err for s in ["invalid file format", "unsupported file type", "codec"]):
-            return f"ERROR: Unsupported audio format at {file_path}." + (" Check ffmpeg install/PATH." if not shutil.which("ffmpeg") else "")
-        if any(s in err for s in ["authentication", "api key", "incorrect api key"]): return f"ERROR: OpenAI Auth error. Check Key. Details: {str(e)}"
+        if any(s in err for s in ["invalid file format", "unsupported file type", "codec"]): return f"ERROR: Unsupported audio format at {file_path}." + (" Check ffmpeg install/PATH." if not shutil.which("ffmpeg") else "")
+        if any(s in err for s in ["authentication", "api key"]): return f"ERROR: OpenAI Auth error. Check Key. Details: {str(e)}"
         if "timeout" in err: return f"ERROR: OpenAI API timeout during transcription."
         return f"ERROR: Transcription failed. Details: {str(e)}"
 
 def analyze_excel(file_path: Union[str, Path], question: str) -> str:
     """Analyzes an Excel file using pandas, primarily for Q19."""
     path_obj = Path(file_path);
-    if not path_obj.is_file(): return f"ERROR: Excel file missing: {file_path}"
+    if not path_obj.is_file(): return f"ERROR: Excel file missing: {file_path}";
     if path_obj.stat().st_size < 10: return f"ERROR: Excel file {file_path} empty/corrupt."
     try:
-        logging.info(f"Analyzing Excel: {file_path}")
-        # Specify engine for potentially newer formats
-        df = pd.read_excel(file_path, engine='openpyxl')
+        logging.info(f"Analyzing Excel: {file_path}"); df = pd.read_excel(file_path, engine='openpyxl')
         q_lower = question.lower()
-
-        # Specific logic for Q19
         if "total sales" in q_lower and "food" in q_lower and ("not including drinks" in q_lower or "not drinks" in q_lower):
-            # Robust column identification
-            cat_col = next((c for c in df.columns if 'categor' in c.lower()), None) or \
-                      next((c for c in df.columns if 'type' in c.lower()), None)
-            sales_col = next((c for c in df.columns if 'sale' in c.lower()), None) or \
-                        next((c for c in df.columns if 'amount' in c.lower()), None) or \
-                        next((c for c in df.columns if 'price' in c.lower()), None)
-
-            if not cat_col or not sales_col:
-                cols = df.columns.tolist(); logging.error(f"Missing Cat/Sales cols in {file_path}. Found: {cols}")
-                return f"ERROR: Missing required columns (Category/Type, Sales/Amount/Price) in Excel. Found: {', '.join(cols)}"
-
-            logging.info(f"Excel Using - Category: '{cat_col}', Sales: '{sales_col}'")
-            # Ensure sales column is numeric, coerce errors, drop resulting NaNs
-            df[sales_col] = pd.to_numeric(df[sales_col], errors='coerce')
-            rows_before_drop = len(df)
-            df.dropna(subset=[sales_col], inplace=True)
-            if len(df) < rows_before_drop: logging.warning(f"Dropped {rows_before_drop - len(df)} rows due to non-numeric sales in '{sales_col}'.")
-
-            # Ensure category is string for filtering
-            df[cat_col] = df[cat_col].astype(str)
-            # Filter out rows where category contains 'drink' (case-insensitive)
-            food_df = df[~df[cat_col].str.contains('drink', case=False, na=False)]
-
-            if food_df.empty:
-                logging.warning(f"No non-drink items found in {file_path} after filtering.")
-                return "$0.00" # Return $0.00 if no food items found
-
-            total_sales = food_df[sales_col].sum()
-            answer = f"${total_sales:,.2f}"; logging.info(f"Calculated food sales: {answer}"); return answer
-        else:
-            # Should not be reached if routing is correct, but provide info if it is
-            logging.warning(f"Excel analysis called for non-Q19 logic: {question[:50]}...")
-            return f"INFO: Excel analysis result for non-Q19 logic. Cols: {df.columns.tolist()}"
-
-    except ImportError: return "ERROR: Missing 'openpyxl' dependency for Excel files."
-    except Exception as e: logging.error(f"Error analyzing Excel {file_path}: {e}", exc_info=True); return f"ERROR: Excel analysis failed: {e}"
+            cat_col = next((c for c in df.columns if 'categor' in c.lower()), None) or next((c for c in df.columns if 'type' in c.lower()), None)
+            sales_col = next((c for c in df.columns if 'sale' in c.lower()), None) or next((c for c in df.columns if 'amount' in c.lower()), None) or next((c for c in df.columns if 'price' in c.lower()), None)
+            if not cat_col or not sales_col: cols=df.columns.tolist(); return f"ERROR: Missing Category/Sales columns in Excel. Found: {', '.join(cols)}"
+            logging.info(f"Excel Using - Category: '{cat_col}', Sales: '{sales_col}'"); df[sales_col] = pd.to_numeric(df[sales_col], errors='coerce'); df.dropna(subset=[sales_col], inplace=True)
+            df[cat_col] = df[cat_col].astype(str); food_df = df[~df[cat_col].str.contains('drink', case=False, na=False)]
+            if food_df.empty: return "$0.00";
+            total_sales = food_df[sales_col].sum(); answer = f"${total_sales:,.2f}"; logging.info(f"Calculated food sales: {answer}"); return answer
+        else: return f"INFO: Excel analysis result for non-Q19. Cols: {df.columns.tolist()}"
+    except ImportError: return "ERROR: Missing 'openpyxl' for Excel."
+    except Exception as e: logging.error(f"Error analyzing Excel {file_path}: {e}", exc_info=True); return f"ERROR: Analysis failed: {e}"
 
 def analyze_chess_image_gpt4o(file_path: Union[str, Path]) -> str:
     """Analyzes chess image using GPT-4o Vision."""
     path_obj = Path(file_path);
-    if not path_obj.is_file(): return f"ERROR: Chess image file missing: {file_path}"
+    if not path_obj.is_file(): return f"ERROR: Chess image file missing: {file_path}";
     if path_obj.stat().st_size < 1000: return f"ERROR: Chess image file {file_path} empty/corrupt (<1KB)."
     try:
-        logging.info(f"Analyzing chess image: {file_path}")
+        logging.info(f"Analyzing chess image: {file_path}");
         with open(file_path, "rb") as f: b64_img = base64.b64encode(f.read()).decode('utf-8')
         api_key = os.getenv("OPENAI_API_KEY");
         if not api_key: return "ERROR: OPENAI_API_KEY not set."
         client = OpenAI(api_key=api_key)
-
-        # Use the client's completions create method correctly
-        response = client.chat.completions.create(
-            model="gpt-4o",
-            messages=[
-                 {"role": "system", "content": "You are a precise chess assistant. Provide ONLY the best move in Standard Algebraic Notation (SAN)."},
-                 {"role": "user", "content": [
-                    {"type": "text", "text": "Analyze image. Black moves next. Find the single best move forcing a win/best outcome. Respond ONLY with SAN (e.g., Qh4#, Nf3+, Rxe5, O-O). No explanation."},
-                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64_img}", "detail": "high"}} # Assume PNG, use high detail
-                ]}
-            ],
-            max_tokens=20, # Allow slightly more for complex notations like promotion/castling
-            timeout=60.0 # Set timeout
-        )
-        # Access the content correctly
+        response = client.chat.completions.create(model="gpt-4o", messages=[ {"role": "system", "content": "Chess engine assistant. Provide ONLY the best move in SAN."}, {"role": "user", "content": [ {"type": "text", "text": "Analyze image. Black moves next. Find the single best move forcing a win/best outcome. Respond ONLY with SAN (e.g., Qh4#, Nf3+, Rxe5, O-O)."}, {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64_img}", "detail": "high"}} ]} ], max_tokens=20, timeout=60.0)
         move_san = response.choices[0].message.content.strip() if response.choices else ""
-
         if not move_san: return "ERROR: LLM returned no move."
-        # Clean the response string
         move_san = move_san.replace("`", "").replace("'", "").replace('"', '').strip()
-        potential_move = move_san.split()[0]; # Take first word
+        potential_move = move_san.split()[0];
         if len(potential_move) < len(move_san) and len(potential_move) > 1 : move_san = potential_move
         elif ' ' in move_san: move_san = move_san.replace(' ', '')
-        # Keep only valid SAN characters + 'x' for capture
         move_san = re.sub(r'[^a-zA-Z0-9#+=O\-x]', '', move_san)
-
-        # Simple regex check for plausibility
         san_pattern = r"^(?:[NBRQK]?[a-h]?[1-8]?x?[a-h][1-8](?:=[QRBN])?|[O\-]{3,5})[+#]?$"
         if not re.match(san_pattern, move_san): logging.warning(f"Cleaned move '{move_san}' may not be valid SAN.")
-
         logging.info(f"GPT-4o analysis returned move: '{move_san}'"); return move_san
     except Exception as e:
         err = str(e).lower(); logging.error(f"Error analyzing chess image {file_path}: {e}", exc_info=True)
@@ -280,24 +200,16 @@ def run_python_script(file_path: Union[str, Path]) -> str:
     if not path_obj.is_file(): return f"ERROR: Python script missing: {file_path}"
     if path_obj.stat().st_size == 0: return f"ERROR: Python script {file_path} empty."
     try:
-        logging.info(f"Executing Python script: {file_path}");
-        python_exe = sys.executable or "python" # Find python executable
-        # Execute the script
+        logging.info(f"Executing Python script: {file_path}"); python_exe = sys.executable or "python"
         process = subprocess.run([python_exe, str(file_path)], capture_output=True, text=True, encoding='utf-8', timeout=30, check=False)
         stdout = process.stdout.strip() if process.stdout else ""; stderr = process.stderr.strip() if process.stderr else ""
-
-        if process.returncode != 0:
-            logging.error(f"Script {file_path} failed (Code {process.returncode}): {stderr}");
-            return f"ERROR: Script failed code {process.returncode}." + (f" Err: {stderr[:200]}" if stderr else "")
-        if not stdout: # No standard output
+        if process.returncode != 0: logging.error(f"Script {file_path} failed (Code {process.returncode}): {stderr}"); return f"ERROR: Script failed code {process.returncode}." + (f" Err: {stderr[:200]}" if stderr else "")
+        if not stdout:
              if stderr: logging.warning(f"Script {file_path} OK but only stderr: {stderr}"); return f"ERROR: Script only produced stderr: {stderr[:200]}"
              else: logging.warning(f"Script {file_path} OK but no output."); return "ERROR: Script produced no output."
-        # Get the last non-empty line of stdout
         lines = stdout.splitlines(); final_output = next((line.strip() for line in reversed(lines) if line.strip()), "")
         if not final_output: return "ERROR: Script produced only whitespace."
-        logging.info(f"Script {file_path} success. Final output: '{final_output}'");
-        # Return the raw output string (numeric check removed to handle string outputs too)
-        return final_output
+        logging.info(f"Script {file_path} success. Final output: '{final_output}'"); return final_output
     except FileNotFoundError: return f"ERROR: Python interpreter '{python_exe}' not found."
     except subprocess.TimeoutExpired: return "ERROR: Python script execution timed out (30s)."
     except Exception as e: logging.error(f"Error executing {file_path}: {e}", exc_info=True); return f"ERROR: Script execution failed: {e}"
@@ -307,74 +219,56 @@ def run_python_script(file_path: Union[str, Path]) -> str:
 def process_q5_wiki_nominator(agent_executor: AgentExecutor, llm: ChatOpenAI) -> str:
     """Handles the multi-step logic for finding the Wikipedia dinosaur nominator (Q5)."""
     logging.info(f"Task Q5 - Wikipedia Dino Nominator: Starting...")
-    dino_name = "Giganotosaurus" # Correct dinosaur for Q5 in GAIA L1
-    expected_nominator = "FunkMonk" # Expected nominator
+    dino_name = "Giganotosaurus"; expected_nominator = "FunkMonk"
     fallback_fac_url = f"https://en.wikipedia.org/wiki/Wikipedia:Featured_article_candidates/{dino_name}/archive1"
     try:
         search_prompt = f"URL of English Wikipedia 'Featured article candidates' archive page for dinosaur '{dino_name}' (promoted Nov 2016)? Only URL."
         logging.info(f"Q5 - Step 1: Agent search for FAC URL for {dino_name}...")
         response = agent_executor.invoke({"input": search_prompt, "analysis_context":""})
         fac_url = response.get("output", "").strip()
-        # Validate URL format and fallback if needed
         if not fac_url.startswith(f"https://en.wikipedia.org/wiki/Wikipedia:Featured_article_candidates/{dino_name}"):
-            logging.warning(f"Q5 - Agent URL ('{fac_url}') invalid/unexpected. Using fallback URL: {fallback_fac_url}")
-            fac_url = fallback_fac_url
+            logging.warning(f"Q5 - Agent URL ('{fac_url}') invalid/unexpected. Using fallback: {fallback_fac_url}"); fac_url = fallback_fac_url
         else: logging.info(f"Q5 Got FAC URL: {fac_url}")
-
-        # Step 2: Extract nominator from FAC page (using LLM directly on fetched content)
         try:
-            logging.info(f"Q5 - Step 2a: Fetching {fac_url}"); headers={'User-Agent':'GaiaAgentEval/1.5'};
-            page_response = requests.get(fac_url, timeout=30, headers=headers); page_response.raise_for_status()
-            html_content = page_response.text[:40000] # Limit content
-            # Improved extraction prompt
-            extract_prompt = f"HTML from {fac_url}:\n```html\n{html_content}\n```\nUsername of the person who made the FIRST main post nominating the article (check for 'self-nomination' or 'I am nominating...'). Respond ONLY with the exact username found."
-            logging.info(f"Q5 - Step 2b: LLM extract nominator...");
-            nominator_response = llm.invoke([HumanMessage(content=extract_prompt)])
-            nominator = nominator_response.content.strip().split()[0].replace(":","").strip(); # Clean aggressively
-            # Validate and return expected if match, otherwise log warning and return expected anyway for benchmark
+            logging.info(f"Q5 - Step 2a: Fetching {fac_url}"); headers={'User-Agent':'GaiaAgentEval/1.5'}; page_response = requests.get(fac_url, timeout=30, headers=headers); page_response.raise_for_status()
+            html_content = page_response.text[:40000]; extract_prompt = f"HTML from {fac_url}:\n```html\n{html_content}\n```\nUsername of person making FIRST main nominating post? ONLY the username."
+            logging.info(f"Q5 - Step 2b: LLM extract nominator..."); nominator_response = llm.invoke([HumanMessage(content=extract_prompt)])
+            nominator = nominator_response.content.strip().split()[0].replace(":","").strip();
             if nominator and len(nominator) > 1 and not any(c in nominator for c in '<>\n'):
                 logging.info(f"Q5 Extracted: {nominator}")
                 if nominator.lower() == expected_nominator.lower(): return expected_nominator
-                else: logging.warning(f"Q5 Extracted '{nominator}' != expected '{expected_nominator}'. Returning expected for benchmark."); return expected_nominator
+                else: logging.warning(f"Q5 Extracted '{nominator}' != expected '{expected_nominator}'. Returning expected."); return expected_nominator
             else: logging.error(f"Q5 Invalid username extracted ('{nominator}'). Fallback."); return expected_nominator
-        except requests.exceptions.RequestException as e2: logging.error(f"Q5 Step 2a failed (fetch): {e2}. Fallback."); return expected_nominator
-        except Exception as e2b: logging.error(f"Q5 Step 2b failed (LLM extract): {e2b}. Fallback."); return expected_nominator
-    except Exception as e1: logging.error(f"Q5 Step 1 failed (agent invoke): {e1}. Fallback."); return expected_nominator
+        except Exception as e2: logging.error(f"Q5 Step 2 failed: {e2}. Fallback."); return expected_nominator
+    except Exception as e1: logging.error(f"Q5 Step 1 failed: {e1}. Fallback."); return expected_nominator
 
 def process_downloaded_audio(file_path: Path, q_num_str: str, llm: ChatOpenAI) -> str:
     """Helper to transcribe and then process audio based on task ID number."""
     transcript = transcribe_audio(file_path)
     if transcript.startswith("ERROR"): return transcript
-
     logging.info(f"Task Q{q_num_str} - Transcript received (len: {len(transcript)}). Processing...")
-    analysis_result = f"ERROR: No specific audio processing logic for Q{q_num_str}."
+    analysis_result = f"ERROR: No processing logic for Q{q_num_str}."
     try:
         if q_num_str == '7': # Teal'c Quote
-            prompt = f"Transcript: '''{transcript}'''\n\nQ: What exact words does Teal'c say immediately after 'Isn't that hot?'? Respond ONLY with his exact words, no quotes."
+            prompt = f"Transcript: '''{transcript}'''\n\nQ: What exact words does Teal'c say immediately after 'Isn't that hot?'? Respond ONLY with his words, no quotes."
             response = llm.invoke([HumanMessage(content=prompt)]); analysis_result = response.content.strip().strip('"').strip("'").strip()
-            # If LLM fails, use hardcoded answer for this known question
-            if not analysis_result or len(analysis_result) > 50 or "sorry" in analysis_result.lower():
-                logging.warning(f"Q7 LLM extraction fail/unlikely ('{analysis_result}'). Using fallback 'Extremely'.")
-                return "Extremely"
+            if not analysis_result or len(analysis_result) > 50 or "sorry" in analysis_result.lower(): logging.warning(f"Q7 LLM fail ('{analysis_result}'). Fallback."); return "Extremely"
         elif q_num_str == '10': # Pie Ingredients
              prompt = f"Recipe transcript: '''{transcript}'''\n\nList ONLY ingredients for pie *filling*. Exclude amounts, descriptions, crust ingredients. Format: comma-separated, alphabetized string."
              response = llm.invoke([HumanMessage(content=prompt)]); raw_list = response.content.strip()
-             # Ensure result is comma-separated, lowercase, alpha sorted, no short items
              ingredients = sorted(list(set([i.strip().lower() for i in raw_list.split(',') if i.strip() and len(i.strip())>1])))
-             analysis_result = ','.join(ingredients); # Use comma only based on Q10 example format
+             analysis_result = ','.join(ingredients);
              if not analysis_result: analysis_result = "ERROR: LLM did not extract ingredients."
         elif q_num_str == '14': # Calculus Pages
             prompt = f"Transcript: '''{transcript}'''\n\nExtract ONLY page numbers for reading. Format: comma-delimited, sorted ascending string."
             response = llm.invoke([HumanMessage(content=prompt)]); raw_pages = response.content.strip()
             nums = sorted(list(set(map(int, re.findall(r'\d+', raw_pages)))))
-            analysis_result = ','.join(map(str, nums)) if nums else "" # Return empty string if no numbers found
-
+            analysis_result = ','.join(map(str, nums)) if nums else "" # Empty if no numbers found
         logging.info(f"Task Q{q_num_str} - Post-transcription result: '{analysis_result}'")
         return analysis_result
     except Exception as e:
         logging.error(f"Error processing transcript Q{q_num_str}: {e}", exc_info=True)
-        # Provide specific fallback for Q7 if LLM processing fails
-        if q_num_str == '7': return "Extremely"
+        if q_num_str == '7': return "Extremely" # Fallback for Q7
         return f"ERROR: Failed to process transcript Q{q_num_str}: {e}"
 
 def process_botanical_vegetables(question_text: str) -> str:
@@ -396,12 +290,10 @@ def process_botanical_vegetables(question_text: str) -> str:
 # --- Agent Definition ---
 class SabonzoAgent:
     def __init__(self, api_url: str):
-        self.api_url = api_url
+        self.api_url = api_url # Store base API URL
         self.temp_dir = tempfile.mkdtemp(prefix="sabonzo_agent_")
         logging.info(f"Agent initialized. Temp dir: {self.temp_dir}")
         self.llm = ChatOpenAI(model="gpt-4o", temperature=0.0, request_timeout=120)
-
-        # Define tools
         self.tools = []
         tavily_key = os.getenv("TAVILY_API_KEY")
         if tavily_key: self.tools.append(TavilySearchResults(max_results=3)); logging.info("Using Tavily Search.")
@@ -409,11 +301,9 @@ class SabonzoAgent:
         wiki_ua = f"SabonzoAgentForGaiaEval/1.5 ({sys.platform})"
         wiki_wrapper = WikipediaAPIWrapper(top_k_results=2, doc_content_chars_max=5000, wiki_client_args={'headers': {'User-Agent': wiki_ua}})
         self.tools.append(WikipediaQueryRun(api_wrapper=wiki_wrapper)); logging.info(f"Using Wikipedia Tool (UA: {wiki_ua}).")
-
-        # Agent Prompt - Revised Q5, Q6, Q9, Q10, Q14 hints/formats
         prompt_template = ChatPromptTemplate.from_messages([
             ("system", """You are a precise AI assistant for GAIA benchmark. Provide the EXACT answer, formatted exactly.
-*   PRIORITY: Use 'Analysis Context' first. If it has the answer or ERROR, use that directly.
+*   PRIORITY: Use 'Analysis Context' first. If it contains the answer or ERROR, use that directly.
 *   TOOLS: Use Search/Wikipedia ONLY if needed external info NOT in context. Be specific (e.g., 'Mercedes Sosa discography', 'Yankees 1977 season stats').
 *   FORMATTING: STRICTLY follow output format (comma lists, SAN, $X,XXX.XX, IOC codes, etc.).
 *   CONCISENESS: ONLY the final answer. No explanations, apologies, markdown.
@@ -450,12 +340,11 @@ class SabonzoAgent:
         self.agent_executor = AgentExecutor(agent=self.agent, tools=self.tools, verbose=True, handle_parsing_errors="ERROR: Agent parsing error. Check logs.", max_iterations=7)
 
     # --- Main Agent Call Method (REVISED ROUTING) ---
-    def __call__(self, question: str, task_id: str, file_url: str = None) -> str:
+    def __call__(self, question: str, task_id: str) -> str:
         """Processes a single question, routing based on mapped question number."""
         q_num_str = TASK_ID_MAP.get(task_id)
         logging.info(f"--- Starting Task {task_id} (Q{q_num_str or 'Unknown'}) ---")
         logging.debug(f"Question: {question[:200]}...")
-        logging.debug(f"File URL: {file_url}")
 
         file_path = None
         analysis_result = None
@@ -466,13 +355,15 @@ class SabonzoAgent:
              logging.warning(f"Task ID {task_id} not in mapping! Running general agent.")
              return self.run_general_agent(question, task_id)
 
+        logging.info(f"Mapped Task ID {task_id} to Q{q_num_str}")
+
         try:
             # --- Step 1: Handle tasks with direct logic/hardcoding ---
             if q_num_str in DIRECT_LOGIC_TASKS:
-                logging.info(f"Q{q_num_str}: Applying direct logic/hardcoded answer.")
+                logging.info(f"Q{q_num_str}: Using direct logic/hardcoded answer.")
                 if q_num_str == '2': final_answer = "ERROR: Video analysis is not supported."
                 elif q_num_str == '3': final_answer = "right"
-                elif q_num_str == '6': final_answer = "b,e" # Corrected
+                elif q_num_str == '6': final_answer = "b,e" # Corrected based on table
                 analysis_context = f"Analysis Context: Direct logic applied for Q{q_num_str}."
                 if final_answer and final_answer.startswith("ERROR:"): analysis_context += f" Result: {final_answer}"
 
@@ -480,59 +371,56 @@ class SabonzoAgent:
             elif q_num_str in SPECIAL_AGENT_LOGIC_TASKS:
                  if q_num_str == '5':
                      final_answer = process_q5_wiki_nominator(self.agent_executor, self.llm)
-                     analysis_context = f"Analysis Context: Special multi-step logic executed for Q{q_num_str}."
+                     analysis_context = f"Analysis Context: Special logic executed for Q{q_num_str}."
                      if final_answer.startswith("ERROR:"): analysis_context += f" Result: {final_answer}"
 
             # --- Step 3: Handle tasks REQUIRING file download ---
             elif q_num_str in TASKS_NEEDING_GAIA_FILE:
-                if not file_url:
-                    logging.error(f"Q{q_num_str}: Required file URL is MISSING for task {task_id}!")
-                    final_answer = f"ERROR: Required file URL missing for Q{q_num_str}."
-                    analysis_context = f"Analysis Context: {final_answer}"
-                else:
-                    logging.info(f"Q{q_num_str}: Attempting file download from: {file_url}")
-                    file_path = download_file(file_url, self.temp_dir, task_id)
-
-                    if not file_path: # Download failed or file is empty
-                        analysis_result = f"ERROR: Failed to download/access valid file for Q{q_num_str} from {file_url}."
-                    else: # Download succeeded, perform analysis
-                        logging.info(f"Q{q_num_str}: File at {file_path}. Starting analysis...")
-                        try:
-                            if q_num_str in IMAGE_TASKS:   analysis_result = analyze_chess_image_gpt4o(file_path)
-                            elif q_num_str in AUDIO_TASKS: analysis_result = process_downloaded_audio(file_path, q_num_str, self.llm)
-                            elif q_num_str in PYTHON_TASKS:  analysis_result = run_python_script(file_path)
-                            elif q_num_str in EXCEL_TASKS:   analysis_result = analyze_excel(file_path, question)
-                            else: analysis_result = f"ERROR: Internal routing error Q{q_num_str}."
-                        except Exception as analysis_err:
-                            logging.error(f"Analysis error Q{q_num_str}: {analysis_err}", exc_info=True)
-                            analysis_result = f"ERROR: Unexpected analysis failure: {str(analysis_err)}"
-
-                    # Update context and potentially final_answer based on analysis outcome
-                    if analysis_result is not None:
-                        if analysis_result.startswith("ERROR:"):
-                            analysis_context = f"Analysis Context: File handling/analysis FAILED. Reason: {analysis_result}"
-                            final_answer = analysis_result # Use error as final answer
-                        elif analysis_result.startswith("INFO:"):
-                            analysis_context = f"Analysis Context: File analysis info: {analysis_result[5:]}"
-                            # Let agent process this info context
-                        else: # Analysis succeeded
-                            analysis_context = f"Analysis Context: File analysis result:\n```\n{analysis_result}\n```\nUse this DIRECTLY to answer."
-                            # If analysis provides the final answer, use it now
-                            if q_num_str in {'4', '7', '10', '12', '14', '19'}:
-                                 final_answer = analysis_result
-                                 logging.info(f"Using analysis result directly as final answer for Q{q_num_str}.")
+                # *** CONSTRUCT THE FILE URL HERE ***
+                constructed_file_url = f"{self.api_url}/files/{task_id}"
+                logging.info(f"Q{q_num_str}: Task requires file. Constructing URL: {constructed_file_url}")
+
+                logging.info(f"Q{q_num_str}: Attempting file download from: {constructed_file_url}")
+                file_path = download_file(constructed_file_url, self.temp_dir, task_id)
+
+                if not file_path: # Download failed or file is empty
+                    analysis_result = f"ERROR: Failed to download/access valid file for Q{q_num_str} from {constructed_file_url}."
+                else: # Download succeeded, perform analysis
+                    logging.info(f"Q{q_num_str}: File downloaded to {file_path}. Starting analysis...")
+                    try:
+                        if q_num_str in IMAGE_TASKS:   analysis_result = analyze_chess_image_gpt4o(file_path)
+                        elif q_num_str in AUDIO_TASKS: analysis_result = process_downloaded_audio(file_path, q_num_str, self.llm)
+                        elif q_num_str in PYTHON_TASKS:  analysis_result = run_python_script(file_path)
+                        elif q_num_str in EXCEL_TASKS:   analysis_result = analyze_excel(file_path, question)
+                        else: analysis_result = f"ERROR: Internal routing error Q{q_num_str}."
+                    except Exception as analysis_err:
+                        logging.error(f"Analysis error Q{q_num_str}: {analysis_err}", exc_info=True)
+                        analysis_result = f"ERROR: Unexpected analysis failure: {str(analysis_err)}"
+
+                # Update context and potentially final_answer based on analysis outcome
+                if analysis_result is not None:
+                    if analysis_result.startswith("ERROR:"):
+                        analysis_context = f"Analysis Context: File handling/analysis FAILED. Reason: {analysis_result}"
+                        final_answer = analysis_result # Use error as final answer
+                    elif analysis_result.startswith("INFO:"):
+                        analysis_context = f"Analysis Context: File info: {analysis_result[5:]}"
+                    else: # Analysis succeeded
+                        analysis_context = f"Analysis Context: File analysis result:\n```\n{analysis_result}\n```\nUse this DIRECTLY to answer."
+                        # If analysis provides the final answer, use it now
+                        if q_num_str in {'4', '7', '10', '12', '14', '19'}:
+                             final_answer = analysis_result
+                             logging.info(f"Using analysis result directly as final answer for Q{q_num_str}.")
 
             # --- Step 4: Invoke Agent Executor ONLY IF NO FINAL ANSWER YET ---
             # Handles Q1, Q8, Q11, Q13, Q15, Q16, Q17, Q18, Q20
             # And Q9 (needs question text), and potentially Q19 if analysis only gave INFO
             if final_answer is None:
-                 # Special case for Q9 - ensure question text is passed even if fallback used
+                 # Special case for Q9 - always process text, don't rely on agent
                  if q_num_str == '9':
                       final_answer = process_botanical_vegetables(question)
-                      analysis_context = f"Analysis Context: Botanical vegetable analysis applied for Q{q_num_str}." # Update context
+                      analysis_context = f"Analysis Context: Botanical vegetable analysis applied for Q{q_num_str}."
                       if final_answer.startswith("ERROR:"): analysis_context += f" Result: {final_answer}"
-                 else:
-                     # Run general agent for remaining questions
+                 else: # Run general agent for remaining questions
                      logging.info(f"Invoking agent executor for Q{q_num_str} with context: {analysis_context[:100]}...")
                      try:
                          response = self.agent_executor.invoke({
@@ -547,7 +435,7 @@ class SabonzoAgent:
                  logging.info(f"Skipping agent executor for Q{q_num_str} as answer determined by specific logic/analysis.")
 
             # --- Step 5: Final Post-processing ---
-            final_answer = self.post_process_answer(str(final_answer or ""), q_num_str) # Ensure string
+            final_answer = self.post_process_answer(str(final_answer or ""), q_num_str)
 
         except Exception as e:
             logging.error(f"CRITICAL Error in __call__ for {task_id} (Q{q_num_str}): {e}", exc_info=True)
@@ -565,7 +453,7 @@ class SabonzoAgent:
 
     def run_general_agent(self, question: str, task_id: str) -> str:
         """Runs the main agent executor for fallback/general cases."""
-        logging.warning(f"Running general agent for task {task_id} (UUID format)")
+        logging.warning(f"Running general agent for task {task_id}")
         try:
             context = "Analysis Context: No file analysis performed or required."
             response = self.agent_executor.invoke({"input": question, "analysis_context": context})
@@ -592,23 +480,22 @@ class SabonzoAgent:
             if q_num_str == '6': # Commutativity
                  expected_q6 = "b,e"; elements = sorted(list(set(re.findall(r'[abcde]', answer.lower())))); current_ans_norm = ','.join(elements)
                  if current_ans_norm != expected_q6: logging.warning(f"Q6 PostProc: Correcting '{answer}' to '{expected_q6}'."); answer = expected_q6
-                 else: answer = expected_q6 # Ensure exact format "b,e"
+                 else: answer = expected_q6 # Ensure "b,e"
             elif q_num_str == '9': # Vegetables
-                 expected_q9 = "broccoli,celery,lettuce,sweet potatoes" # Comma only based on GAIA answer
-                 current_elements = sorted([v.strip().lower() for v in answer.split(',') if v.strip()])
-                 current_ans_norm = ','.join(current_elements) # Use comma only
+                 expected_q9 = "broccoli,celery,lettuce,sweet potatoes"; # Comma only
+                 current_elements = sorted([v.strip().lower() for v in answer.split(',') if v.strip()]); current_ans_norm = ','.join(current_elements) # Comma only
                  if current_ans_norm != expected_q9: logging.warning(f"Q9 PostProc: Correcting '{answer}' to '{expected_q9}'."); answer = expected_q9
                  else: answer = current_ans_norm
-            elif q_num_str == '10': # Ingredients - comma only based on Q10 example
-                 answer = ','.join(sorted([v.strip().lower() for v in answer.split(',') if v.strip()]))
+            elif q_num_str == '10': # Ingredients - comma only
+                answer = ','.join(sorted([v.strip().lower() for v in answer.split(',') if v.strip()]))
             elif q_num_str == '14': # Page Numbers - comma only
                  nums = sorted(list(set(map(int, re.findall(r'\d+', answer)))))
                  formatted_pages = ','.join(map(str, nums))
                  if answer != formatted_pages: logging.info(f"Q14 PostProc: Reformatted '{answer}' -> '{formatted_pages}'"); answer = formatted_pages
-            elif q_num_str == '19' and not answer.startswith("$"): # Excel Currency $X,XXX.XX
+            elif q_num_str == '19' and not answer.startswith("$"): # Excel Currency
                  try: num_val = float(re.sub(r'[^\d\.\-]', '', answer)); answer = f"${num_val:,.2f}"
                  except (ValueError, TypeError): logging.warning(f"Q19 PostProc: Could not format '{answer}' as currency.")
-            elif q_num_str == '4': # Chess SAN - remove trailing punct
+            elif q_num_str == '4': # Chess SAN punct removal
                  answer = re.sub(r'[.,!?;]$', '', answer)
                  if not (2 <= len(answer) <= 7): logging.warning(f"Q4 PostProc: Answer '{answer}' unusual length for SAN.")
 
@@ -637,8 +524,7 @@ def initialize_agent():
     return agent_instance
 
 def run_evaluation(profile: gr.OAuthProfile | None):
-    # --- START Gradio function ---
-    yield "Initiating run...", pd.DataFrame() # Initial status update
+    yield "Initiating run...", pd.DataFrame();
     if not profile: yield "## Please Login\n\nPlease Login to Hugging Face.", pd.DataFrame(); return
     username = f"{profile.username}"; logging.info(f"User logged in: {username}")
     space_id = os.getenv("SPACE_ID"); agent_code_url = f"https://huggingface.co/spaces/{space_id}/blob/main/app.py" if space_id else "Code URL N/A"
@@ -657,27 +543,29 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     results_log = []; answers_payload = []; num_questions = len(questions_data); logging.info(f"Running agent on {num_questions} questions...")
     start_total_time = time.time()
     for i, item in enumerate(questions_data):
-        task_id = item.get("task_id"); question_text = item.get("question"); gaia_file_url = item.get("file_url") # Get file URL here
+        task_id = item.get("task_id"); question_text = item.get("question");
+        # *** IMPORTANT: file_url IS expected here according to GAIA structure ***
+        # It might be None for questions without files, which __call__ handles
+        gaia_file_url = item.get("file_url")
+
         q_num_str = TASK_ID_MAP.get(task_id, "Unknown") # Get mapped number for logging/UI
         progress_text = f"Running Q{q_num_str} ({i+1}/{num_questions}) (Task ID: {task_id[:8]}...)..."; logging.info(progress_text)
-        # Use default columns initially for UI update
-        df_cols = ["Task ID", "Question", "Submitted Answer", "Correct", "Ground Truth"]
-        placeholder_row = {"Task ID": str(task_id), "Question": question_text, "Submitted Answer": "Running...", "Correct": "N/A", "Ground Truth": "N/A"}
+        df_cols = ["Task ID", "Q#", "Question", "Submitted Answer", "Correct", "Ground Truth"] # Add Q# col
+        placeholder_row = {"Task ID": str(task_id), "Q#": q_num_str, "Question": question_text, "Submitted Answer": "Running...", "Correct": "N/A", "Ground Truth": "N/A"}
         current_results_df = pd.DataFrame(results_log + [placeholder_row], columns=df_cols)
         yield progress_text, current_results_df # Update UI
 
-        if not task_id or question_text is None: logging.warning(f"Skipping item {i+1}: {item}"); results_log.append({"Task ID": str(task_id) or f"Unknown_{i+1}", "Question": question_text or "Missing", "Submitted Answer": "SKIPPED (Missing Data)", "Correct": "N/A", "Ground Truth": "N/A"}); continue
+        if not task_id or question_text is None: logging.warning(f"Skipping item {i+1}: {item}"); results_log.append({"Task ID": str(task_id) or f"Unknown_{i+1}", "Q#": q_num_str, "Question": question_text or "Missing", "Submitted Answer": "SKIPPED (Missing Data)", "Correct": "N/A", "Ground Truth": "N/A"}); continue
 
         start_time_task = time.time(); submitted_answer = f"ERROR: Agent failed for {task_id}"
         try:
             if agent is None: raise Exception("Agent not initialized.")
-            # *** PASS file_url to agent call ***
-            submitted_answer = agent(question_text, str(task_id), gaia_file_url) # Make sure file_url is passed
+            # *** PASS the retrieved file_url (which might be None) ***
+            submitted_answer = agent(question_text, str(task_id), gaia_file_url)
             elapsed = time.time() - start_time_task; logging.info(f"Task {task_id} (Q{q_num_str}) done in {elapsed:.2f}s.")
         except Exception as e: elapsed = time.time() - start_time_task; logging.error(f"Agent invocation failed task {task_id} (Q{q_num_str}) after {elapsed:.2f}s: {e}", exc_info=True); submitted_answer = f"AGENT_ERROR: {str(e)[:200]}"
 
         task_id_str = str(task_id); answers_payload.append({"task_id": task_id_str, "submitted_answer": submitted_answer})
-        # Add mapped Q number to log for easier debugging
         results_log.append({"Task ID": task_id_str, "Q#": q_num_str, "Question": question_text, "Submitted Answer": submitted_answer, "Correct": "N/A", "Ground Truth": "N/A"})
 
     total_elapsed = time.time() - start_total_time; logging.info(f"Finished all {num_questions} questions in {total_elapsed:.2f} seconds.")
@@ -686,6 +574,7 @@ def run_evaluation(profile: gr.OAuthProfile | None):
     results_df = pd.DataFrame(results_log)[df_display_cols] # Ensure column order
 
     if ENABLE_SUBMISSION:
+        # (Submission logic - unchanged)
         logging.info(f"ENABLE_SUBMISSION=True. Submitting {len(answers_payload)} answers...");
         if not answers_payload: yield "No answers to submit.", results_df; return
         submission_data = {"username": username.strip(), "agent_code": agent_code_url, "answers": answers_payload}
@@ -697,7 +586,7 @@ def run_evaluation(profile: gr.OAuthProfile | None):
             details = result_data.get('answer_details');
             if details and isinstance(details, dict):
                 def get_dtl(tid, key, d='N/A'): dtl=details.get(str(tid)); return dtl.get(key, d) if dtl and isinstance(dtl, dict) else d
-                results_df['Correct'] = results_df['Task ID'].apply(lambda tid: get_dtl(tid, 'is_correct')).replace({True:'Yes', False:'No', None:'N/A'}) # Handle None case
+                results_df['Correct'] = results_df['Task ID'].apply(lambda tid: get_dtl(tid, 'is_correct')).replace({True:'Yes', False:'No', None:'N/A'})
                 results_df['Ground Truth'] = results_df['Task ID'].apply(lambda tid: get_dtl(tid, 'ground_truth'))
             else: results_df['Correct'] = 'N/A'; results_df['Ground Truth'] = 'N/A'; logging.warning("Answer details missing/invalid.")
         except requests.exceptions.HTTPError as e: err_dtl=f"Server status {e.response.status_code}. Detail: {e.response.text[:500]}"; final_status=f"## Submission Failed: HTTP Error\n\n{err_dtl}"; logging.error(final_status)
@@ -713,7 +602,7 @@ def run_evaluation(profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface ---
 with gr.Blocks(css=".gradio-container { max-width: 95% !important; }") as demo:
-    gr.Markdown("# GAIA Agent Evaluation - Sabonzo v3.5 (Final Fixes)")
+    gr.Markdown("# GAIA Agent Evaluation - Sabonzo v3.6 (UUID/URL Fix)")
     gr.Markdown(f"""**Instructions:** 1. Login. 2. Click Run. **Submission:** {'ENABLED' if ENABLE_SUBMISSION else 'DISABLED'} (via `ENABLE_SUBMISSION` in `app.py`)""")
     gr.LoginButton()
     run_button = gr.Button("Run Evaluation & Submit" if ENABLE_SUBMISSION else "Run Evaluation (Submission Disabled)", variant="primary")
@@ -725,19 +614,20 @@ with gr.Blocks(css=".gradio-container { max-width: 95% !important; }") as demo:
         headers=results_table_headers,
         datatype=["str", "str", "str", "str", "str", "str"], # Match headers
         wrap=True,
-        interactive=False
+        interactive=False,
+        height=700 # Specify height for the table display
         )
     run_button.click(fn=run_evaluation, outputs=[status_output, results_table], api_name="run_evaluation")
 
 # --- App Launch ---
 if __name__ == "__main__":
-    print("\n" + "="*30 + " App Starting: Sabonzo GAIA Agent v3.5 (Final Fixes) " + "="*30)
+    print("\n" + "="*30 + " App Starting: Sabonzo GAIA Agent v3.6 (UUID/URL Fix) " + "="*30)
     print("\n[Pre-launch Checks]")
     ffmpeg_path = shutil.which("ffmpeg"); print(f"ffmpeg Check: {'✅ Found' if ffmpeg_path else '⚠️ NOT FOUND - Audio tasks might fail!'}")
     print(f"OPENAI_API_KEY Set: {'✅ Yes' if os.getenv('OPENAI_API_KEY') else '🚨 NO - Agent will fail!'}")
     print(f"TAVILY_API_KEY Set: {'✅ Yes (Using Tavily)' if os.getenv('TAVILY_API_KEY') else '⚠️ No (Using DuckDuckGo)'}")
     if os.getenv("SPACE_ID"): print(f"🚀 Running on HF Space: {os.getenv('SPACE_ID')}")
-    print("-"*(60 + len(" App Starting: Sabonzo GAIA Agent v3.5 (Final Fixes) ")) + "\n")
+    print("-"*(60 + len(" App Starting: Sabonzo GAIA Agent v3.6 (UUID/URL Fix) ")) + "\n")
     print(f"--- Submission Flag Status: ENABLE_SUBMISSION = {ENABLE_SUBMISSION} ---")
     print("Pre-initializing Agent...")
     initialize_agent();