Update app.py

app.py

@@ -10,8 +10,9 @@ import hashlib
 from urllib.parse import urlparse
 import mimetypes
 import subprocess # For yt-dlp
+import io # For BytesIO with PIL
 
-from huggingface_hub import get_space_runtime # Keep for agent_code_url, though not for username
+# Removed: from huggingface_hub import get_space_runtime - not used for username with OAuth
 
 # --- Global Variables for Startup Status ---
 missing_vars_startup_list_global = []
@@ -19,16 +20,17 @@ agent_pre_init_status_msg_global = "Agent status will be determined at startup."
 
 # File Processing Libs
 try: from PyPDF2 import PdfReader; PYPDF2_AVAILABLE = True
-except ImportError: PYPDF2_AVAILABLE = False
-try: from PIL import Image; import pytesseract; PIL_TESSERACT_AVAILABLE = True
-except ImportError: PIL_TESSERACT_AVAILABLE = False
+except ImportError: PYPDF2_AVAILABLE = False; print("WARNING: PyPDF2 not found, PDF tool will be disabled.")
+try: from PIL import Image; import pytesseract; PIL_TESSERACT_AVAILABLE = True # PIL is needed for new tool
+except ImportError: PIL_TESSERACT_AVAILABLE = False; print("WARNING: Pillow or Pytesseract not found, OCR tool will be disabled.")
 try: import whisper; WHISPER_AVAILABLE = True
-except ImportError: WHISPER_AVAILABLE = False
+except ImportError: WHISPER_AVAILABLE = False; print("WARNING: OpenAI Whisper not found, Audio Transcription tool will be disabled.")
 
-# Google GenAI
+# Google GenAI (Used by LangChain integration)
 from google.generativeai.types import HarmCategory, HarmBlockThreshold
+
 # LangChain
-from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, ToolMessage, AnyMessage
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, ToolMessage # Removed AnyMessage
 from langchain.prompts import PromptTemplate
 from langchain.tools import BaseTool, tool as lc_tool_decorator
 from langchain_google_genai import ChatGoogleGenerativeAI
@@ -46,47 +48,72 @@ if TYPE_CHECKING:
 LANGGRAPH_FLAVOR_AVAILABLE = False
 LG_StateGraph: Optional[Type[Any]] = None
 LG_ToolExecutor: Optional[Type[Any]] = None
-LG_END: Optional[Any] = None # Must be imported if used
+LG_END: Optional[Any] = None
 LG_ToolInvocation: Optional[Type[Any]] = None
-add_messages: Optional[Any] = None 
+add_messages: Optional[Any] = None
 MemorySaver_Class: Optional[Type[Any]] = None
 
 AGENT_INSTANCE: Optional[Union[AgentExecutor, Any]] = None
 TOOLS: List[BaseTool] = []
-LLM_INSTANCE: Optional[ChatGoogleGenerativeAI] = None
+LLM_INSTANCE: Optional[ChatGoogleGenerativeAI] = None # This is the agent's "planner"
 LANGGRAPH_MEMORY_SAVER: Optional[Any] = None
 
+# --- google-genai Client SDK (for the new direct multimodal tool) ---
+from google import genai as google_genai_sdk
+google_genai_client: Optional[google_genai_sdk.Client] = None # Initialized later
+# --- End google-genai Client SDK section ---
+
 try:
-    from langgraph.graph import StateGraph, END # Import END here
+    from langgraph.graph import StateGraph, END
     from langgraph.prebuilt import ToolExecutor, ToolInvocation as LGToolInvocationActual
     from langgraph.graph.message import add_messages as lg_add_messages
-    from langgraph.checkpoint.memory import MemorySaver as LGMemorySaver 
+    from langgraph.checkpoint.memory import MemorySaver as LGMemorySaver
     LANGGRAPH_FLAVOR_AVAILABLE = True
     LG_StateGraph, LG_ToolExecutor, LG_END, LG_ToolInvocation, add_messages, MemorySaver_Class = \
         StateGraph, ToolExecutor, END, LGToolInvocationActual, lg_add_messages, LGMemorySaver
-except ImportError as e: 
+    print("Successfully imported LangGraph components.")
+except ImportError as e:
     LANGGRAPH_FLAVOR_AVAILABLE = False
+    # Assign None to all to prevent NameError if used before assignment
     LG_StateGraph, LG_ToolExecutor, LG_END, LG_ToolInvocation, add_messages, MemorySaver_Class = (None,) * 6
+    print(f"WARNING: LangGraph components not found or import error: {e}. LangGraph agent will be disabled.")
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-GEMINI_MODEL_NAME = "gemini-2.5-pro-preview-05-06" 
+# GEMINI_MODEL_NAME is for the agent's planner LLM (LangChain)
+GEMINI_MODEL_NAME = "gemini-2.5-pro-preview-05-06" # Retained from original for planner
+# GEMINI_FLASH_MULTIMODAL_MODEL_NAME is for the new direct multimodal tool (google-genai client SDK)
+GEMINI_FLASH_MULTIMODAL_MODEL_NAME = "gemini-2.0-flash-exp"
+
 SCORING_API_BASE_URL = os.getenv("SCORING_API_URL", DEFAULT_API_URL)
-MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024 
-LOCAL_FILE_STORE_PATH = "./Data" 
+MAX_FILE_SIZE_BYTES = 50 * 1024 * 1024
+LOCAL_FILE_STORE_PATH = "./Data"
+os.makedirs(LOCAL_FILE_STORE_PATH, exist_ok=True) # Create data directory at startup
 
 # --- Global State ---
 WHISPER_MODEL: Optional[Any] = None
 
 # --- Environment Variables & API Keys ---
 GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
-HUGGINGFACE_TOKEN = os.environ.get("HF_TOKEN") # For GAIA API auth, NOT for username
+HUGGINGFACE_TOKEN = os.environ.get("HF_TOKEN")
 
 # --- Setup Logging ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(name)s - %(module)s:%(lineno)d - %(message)s')
 logger = logging.getLogger(__name__)
 
-# --- Helper Functions ---
+# --- Initialize google-genai Client SDK ---
+if GOOGLE_API_KEY:
+    try:
+        google_genai_client = google_genai_sdk.Client(api_key=GOOGLE_API_KEY)
+        logger.info("google-genai SDK Client initialized successfully.")
+    except Exception as e:
+        logger.error(f"Failed to initialize google-genai SDK Client: {e}")
+        google_genai_client = None # Ensure it's None if init fails
+else:
+    logger.warning("GOOGLE_API_KEY not found. google-genai SDK Client (for direct multimodal tool) not initialized.")
+# --- End Initialize google-genai Client SDK ---
+
+# --- Helper Functions (Unchanged from your original) ---
 def _strip_exact_match_answer(text: Any) -> str:
     if not isinstance(text, str): text = str(text)
     text_lower_check = text.lower()
@@ -94,7 +121,7 @@ def _strip_exact_match_answer(text: Any) -> str:
         text = text[len("final answer:"):].strip()
     text = text.strip()
     if text.startswith("```") and text.endswith("```"):
-        if "\n" in text: 
+        if "\n" in text:
             text_content = text.split("\n", 1)[1] if len(text.split("\n", 1)) > 1 else ""
             text = text_content.strip()[:-3].strip() if text_content.strip().endswith("```") else text[3:-3].strip()
         else: text = text[3:-3].strip()
@@ -113,6 +140,7 @@ def _is_youtube_url(url: str) -> bool:
     return parsed_url.netloc.lower().endswith(("youtube.com", "youtu.be"))
 
 def _download_file(file_identifier: str, task_id_for_file: Optional[str] = None) -> str:
+    # ... (Your original _download_file function - unchanged)
     os.makedirs(LOCAL_FILE_STORE_PATH, exist_ok=True)
     logger.debug(f"Download request: '{file_identifier}', task_id: {task_id_for_file}")
     original_filename = os.path.basename(urlparse(file_identifier).path) if _is_full_url(file_identifier) else os.path.basename(file_identifier)
@@ -131,12 +159,12 @@ def _download_file(file_identifier: str, task_id_for_file: Optional[str] = None)
             logger.info(f"Cached YouTube MP3: {target_mp3_path}"); return target_mp3_path
         temp_output_template = os.path.join(LOCAL_FILE_STORE_PATH, yt_filename_base + "_temp.%(ext)s")
         try:
-            command = ['yt-dlp', '--quiet', '--no-warnings', '-x', '--audio-format', 'mp3', 
+            command = ['yt-dlp', '--quiet', '--no-warnings', '-x', '--audio-format', 'mp3',
                        '--audio-quality', '0', '--max-filesize', str(MAX_FILE_SIZE_BYTES),
                        '-o', temp_output_template, file_identifier]
             logger.info(f"yt-dlp command: {' '.join(command)}")
             process = subprocess.run(command, capture_output=True, text=True, timeout=180, check=False)
-            downloaded_temp_file = next((os.path.join(LOCAL_FILE_STORE_PATH, f) for f in os.listdir(LOCAL_FILE_STORE_PATH) 
+            downloaded_temp_file = next((os.path.join(LOCAL_FILE_STORE_PATH, f) for f in os.listdir(LOCAL_FILE_STORE_PATH)
                                          if f.startswith(yt_filename_base + "_temp") and f.endswith(".mp3")), None)
             if process.returncode == 0 and downloaded_temp_file and os.path.exists(downloaded_temp_file):
                 os.rename(downloaded_temp_file, target_mp3_path)
@@ -169,28 +197,28 @@ def _download_file(file_identifier: str, task_id_for_file: Optional[str] = None)
             if cd_header:
                 try:
                     decoded_cd_header = cd_header.encode('latin-1', 'replace').decode('utf-8', 'replace')
-                    _, params = requests.utils.parse_header_links(decoded_cd_header)
+                    _, params = requests.utils.parse_header_links(decoded_cd_header) # type: ignore
                     for key, val in params.items():
                         if key.lower() == 'filename*' and val.lower().startswith("utf-8''"):
                             filename_from_cd = requests.utils.unquote(val[len("utf-8''"):]); break
                         elif key.lower() == 'filename':
                             filename_from_cd = requests.utils.unquote(val)
                             if filename_from_cd.startswith('"') and filename_from_cd.endswith('"'): filename_from_cd = filename_from_cd[1:-1]
-                            break 
+                            break
                 except Exception as e_cd: logger.warning(f"CD parse error '{cd_header}': {e_cd}")
             if filename_from_cd:
                 sanitized_cd_filename = "".join(c if c.isalnum() or c in ['.', '_', '-'] else '_' for c in filename_from_cd)
                 effective_save_path = os.path.join(LOCAL_FILE_STORE_PATH, f"{prefix}{sanitized_cd_filename}")
                 logger.info(f"Using CD filename: '{sanitized_cd_filename}'. Path: {effective_save_path}")
-            
+
             name_without_ext, current_ext = os.path.splitext(effective_save_path)
-            if not current_ext: 
+            if not current_ext:
                 content_type_header = r.headers.get('content-type', '')
-                content_type_val = content_type_header.split(';').strip() if content_type_header else ''
+                content_type_val = content_type_header.split(';')[0].strip() if content_type_header else ''
                 if content_type_val:
                     guessed_ext = mimetypes.guess_extension(content_type_val)
                     if guessed_ext: effective_save_path += guessed_ext; logger.info(f"Added guessed ext: {guessed_ext}")
-            
+
             if effective_save_path != tentative_local_path and os.path.exists(effective_save_path) and os.path.getsize(effective_save_path) > 0:
                 logger.info(f"Cached file (CD name): {effective_save_path}"); return effective_save_path
             with open(effective_save_path, "wb") as f:
@@ -202,10 +230,11 @@ def _download_file(file_identifier: str, task_id_for_file: Optional[str] = None)
     except Exception as e:
         logger.error(f"Download error for {file_url_to_try}: {e}", exc_info=True); return f"Error: {str(e)[:100]}"
 
-# --- Tool Function Definitions ---
-READ_PDF_TOOL_DESC = "Reads PDF. Input: JSON '{\"file_identifier\": \"FN_OR_URL\", \"task_id\": \"TASK_ID_IF_GAIA\"}'. Returns text."
+# --- Tool Function Definitions (Original tools unchanged) ---
+READ_PDF_TOOL_DESC = "Reads text content from a PDF file. Input: JSON '{\"file_identifier\": \"FILENAME_OR_URL\", \"task_id\": \"TASK_ID_IF_GAIA_FILENAME_ONLY\"}'. Returns extracted text."
 @lc_tool_decorator(description=READ_PDF_TOOL_DESC)
 def read_pdf_tool(action_input_json_str: str) -> str:
+    # ... (Your original read_pdf_tool logic)
     if not PYPDF2_AVAILABLE: return "Error: PyPDF2 not installed."
     try: data = json.loads(action_input_json_str); file_id, task_id = data.get("file_identifier"), data.get("task_id")
     except Exception as e: return f"Error parsing JSON for read_pdf_tool: {e}. Input: {action_input_json_str}"
@@ -213,19 +242,23 @@ def read_pdf_tool(action_input_json_str: str) -> str:
     path = _download_file(file_id, task_id)
     if path.startswith("Error:"): return path
     try:
-        text = ""; 
-        with open(path, "rb") as f: 
+        text = "";
+        with open(path, "rb") as f:
             reader = PdfReader(f)
             if reader.is_encrypted:
                 try: reader.decrypt('')
                 except: return f"Error: PDF '{path}' encrypted."
-            for page in reader.pages: text += page.extract_text() + "\n\n"
-        return text[:40000] 
+            for page_num in range(len(reader.pages)):
+                page = reader.pages[page_num]
+                text += page.extract_text() + "\n\n"
+        return text[:40000]
     except Exception as e: return f"Error reading PDF '{path}': {e}"
 
-OCR_IMAGE_TOOL_DESC = "OCR on image. Input: JSON '{\"file_identifier\": \"FN_OR_URL\", \"task_id\": \"TASK_ID_IF_GAIA\"}'. Returns text."
+
+OCR_IMAGE_TOOL_DESC = "Extracts text from an image using OCR. Input: JSON '{\"file_identifier\": \"FILENAME_OR_URL\", \"task_id\": \"TASK_ID_IF_GAIA_FILENAME_ONLY\"}'. Returns extracted text."
 @lc_tool_decorator(description=OCR_IMAGE_TOOL_DESC)
 def ocr_image_tool(action_input_json_str: str) -> str:
+    # ... (Your original ocr_image_tool logic)
     if not PIL_TESSERACT_AVAILABLE: return "Error: Pillow/Pytesseract not installed."
     try: data = json.loads(action_input_json_str); file_id, task_id = data.get("file_identifier"), data.get("task_id")
     except Exception as e: return f"Error parsing JSON for ocr_image_tool: {e}. Input: {action_input_json_str}"
@@ -235,9 +268,10 @@ def ocr_image_tool(action_input_json_str: str) -> str:
     try: return pytesseract.image_to_string(Image.open(path))[:40000]
     except Exception as e: return f"Error OCR'ing '{path}': {e}"
 
-TRANSCRIBE_AUDIO_TOOL_DESC = "Transcribes audio (file, URL, YouTube). Input: JSON '{\"file_identifier\": \"FN_OR_URL\", \"task_id\": \"TASK_ID\"}'. Returns transcript."
+TRANSCRIBE_AUDIO_TOOL_DESC = "Transcribes speech from an audio file (or YouTube URL) to text. Input: JSON '{\"file_identifier\": \"FILENAME_OR_URL_OR_YOUTUBE_URL\", \"task_id\": \"TASK_ID_IF_GAIA_FILENAME_ONLY\"}'. Returns transcript."
 @lc_tool_decorator(description=TRANSCRIBE_AUDIO_TOOL_DESC)
 def transcribe_audio_tool(action_input_json_str: str) -> str:
+    # ... (Your original transcribe_audio_tool logic)
     global WHISPER_MODEL
     if not WHISPER_AVAILABLE: return "Error: Whisper not installed."
     try: data = json.loads(action_input_json_str); file_id, task_id = data.get("file_identifier"), data.get("task_id")
@@ -248,137 +282,221 @@ def transcribe_audio_tool(action_input_json_str: str) -> str:
         except Exception as e: logger.error(f"Whisper load failed: {e}"); return f"Error: Whisper load: {e}"
     path = _download_file(file_id, task_id)
     if path.startswith("Error:"): return path
-    try: result = WHISPER_MODEL.transcribe(path, fp16=False); return result["text"][:40000]
+    try: result = WHISPER_MODEL.transcribe(path, fp16=False); return result["text"][:40000] # type: ignore
     except Exception as e: logger.error(f"Whisper error on '{path}': {e}", exc_info=True); return f"Error transcribing '{path}': {e}"
 
-# --- Agent Prompts ---
-LANGGRAPH_PROMPT_TEMPLATE_STR = """You are a highly intelligent agent for the GAIA benchmark.
-Your goal is to provide an EXACT MATCH final answer. No conversational text, explanations, or markdown unless explicitly part of the answer.
-TOOLS:
-You have access to the following tools. Use them if necessary.
-{tools}
-TOOL USAGE:
-- To use a tool, your response must include a `tool_calls` attribute in the AIMessage. Each tool call should be a dictionary with "name", "args" (a dictionary of arguments), and "id".
-- For file tools ('read_pdf_tool', 'ocr_image_tool', 'transcribe_audio_tool'): `args` must contain 'file_identifier' (filename/URL) and 'task_id' (if GAIA file).
-- 'web_search': `args` is like '{{"query": "search query"}}'.
-- 'python_repl': `args` is like '{{"command": "python code string"}}'. Use print() for output.
-RESPONSE FORMAT:
-Final AIMessage should contain ONLY the answer in 'content' and NO 'tool_calls'. If using tools, 'content' can be thought process, with 'tool_calls'.
-Begin!
-Current Task Details (including Task ID and any associated files):
-{input}"""
-
-REACT_PROMPT_TEMPLATE_STR = """You are a highly intelligent agent for the GAIA benchmark.
-Goal: EXACT MATCH answer. No extra text/markdown.
-Tools: {tools}
-Process: Question -> Thought -> Action (ONE of [{tool_names}]) -> Action Input -> Observation -> Thought ... -> Final Answer: [exact answer]
-Tool Inputs:
-- web_search: Your search query string.
-- python_repl: Python code string. Use print(). For Excel/CSV, use pandas: import pandas as pd; df = pd.read_excel('./Data/TASKID_filename.xlsx'); print(df.head())
-- read_pdf_tool, ocr_image_tool, transcribe_audio_tool: JSON string like '{{"file_identifier": "FILENAME_OR_URL", "task_id": "CURRENT_TASK_ID_IF_FILENAME"}}'. 'task_id' required if GAIA filename.
-If tool fails or info missing, Final Answer: N/A. Do NOT use unlisted tools.
-Begin!
-{input}
-Thought:{agent_scratchpad}"""
+# +++ NEW TOOL using google-genai Client SDK for Multimodal Prompts +++
+DIRECT_MULTIMODAL_GEMINI_TOOL_DESC = (
+    "Processes an image file (URL or local path) along with a text prompt using a Gemini multimodal model (gemini-2.0-flash-exp) "
+    "for tasks like image description, answering questions about the image, or generating text based on the image. "
+    "Input: JSON '{\"file_identifier\": \"IMAGE_FILENAME_OR_URL\", \"text_prompt\": \"Your question or instruction related to the image.\", \"task_id\": \"TASK_ID_IF_GAIA_FILENAME_ONLY\" (optional)}'. "
+    "Returns the model's text response."
+)
+@lc_tool_decorator(description=DIRECT_MULTIMODAL_GEMINI_TOOL_DESC)
+def direct_multimodal_gemini_tool(action_input_json_str: str) -> str:
+    global google_genai_client # Use the initialized client
+    if not google_genai_client:
+        return "Error: google-genai SDK client not initialized. GOOGLE_API_KEY might be missing."
+    if not PIL_TESSERACT_AVAILABLE : # Check if PIL is available, as it's used to open the image
+        return "Error: Pillow (PIL) library is not available for image processing."
+
+    try:
+        data = json.loads(action_input_json_str)
+        file_identifier = data.get("file_identifier")
+        text_prompt = data.get("text_prompt", "Describe this image.") # Default prompt
+        task_id = data.get("task_id") # Optional, for _download_file if needed
+
+        if not file_identifier:
+            return "Error: 'file_identifier' for the image is missing in the input."
+
+        logger.info(f"Direct Multimodal Tool: Processing image '{file_identifier}' with prompt '{text_prompt}'")
+
+        # Download the file to a local path (handles URLs and GAIA files)
+        local_image_path = _download_file(file_identifier, task_id)
+        if local_image_path.startswith("Error:"):
+            return f"Error downloading image for Direct Multimodal Tool: {local_image_path}"
+
+        # Open the image using Pillow
+        try:
+            pil_image = Image.open(local_image_path)
+            pil_image.thumbnail((1024, 1024)) # Optional: resize large images
+        except Exception as e_img:
+            logger.error(f"Error opening image at {local_image_path}: {e_img}")
+            return f"Error opening image file {local_image_path}: {str(e_img)}"
+
+        # Send to Gemini Flash model using the client SDK
+        response = google_genai_client.models.generate_content(
+            model=GEMINI_FLASH_MULTIMODAL_MODEL_NAME, # Use the specified Flash model
+            contents=[pil_image, text_prompt] # Pass PIL image and text prompt
+        )
+        logger.info(f"Direct Multimodal Tool: Response received from {GEMINI_FLASH_MULTIMODAL_MODEL_NAME}.")
+        return response.text[:40000] # Return model's text response, truncated if very long
+
+    except json.JSONDecodeError as e_json:
+        return f"Error parsing JSON input for Direct Multimodal Tool: {str(e_json)}. Input was: {action_input_json_str}"
+    except Exception as e_tool:
+        logger.error(f"Error in direct_multimodal_gemini_tool: {e_tool}", exc_info=True)
+        return f"Error executing Direct Multimodal Tool: {str(e_tool)}"
+# +++ END NEW TOOL +++
+
+
+# --- Agent Prompts (Slightly updated to include the new tool name if available) ---
+# (Agent prompts remain largely the same, the agent will learn to use tools from their descriptions)
 
 # --- Agent Initialization and Response Logic ---
 def initialize_agent_and_tools(force_reinit=False):
-    global AGENT_INSTANCE, TOOLS, LLM_INSTANCE, LANGGRAPH_FLAVOR_AVAILABLE, LG_StateGraph, LG_ToolExecutor, LG_END, LG_ToolInvocation, add_messages, MemorySaver_Class, LANGGRAPH_MEMORY_SAVER
+    global AGENT_INSTANCE, TOOLS, LLM_INSTANCE, LANGGRAPH_FLAVOR_AVAILABLE, LG_StateGraph, LG_ToolExecutor, LG_END, LG_ToolInvocation, add_messages, MemorySaver_Class, LANGGRAPH_MEMORY_SAVER, google_genai_client
     if AGENT_INSTANCE and not force_reinit: logger.info("Agent already initialized."); return
     logger.info("Initializing agent and tools...")
-    if not GOOGLE_API_KEY: raise ValueError("GOOGLE_API_KEY not set.")
-    if LANGGRAPH_FLAVOR_AVAILABLE and MemorySaver_Class and not LANGGRAPH_MEMORY_SAVER :
-        LANGGRAPH_MEMORY_SAVER = MemorySaver_Class(); logger.info("LangGraph MemorySaver initialized.")
+    if not GOOGLE_API_KEY: raise ValueError("GOOGLE_API_KEY not set for LangChain LLM.")
+
+    # Initialize LangChain LLM (Planner)
     try:
-        LLM_INSTANCE = ChatGoogleGenerativeAI(model=GEMINI_MODEL_NAME, google_api_key=GOOGLE_API_KEY, temperature=0.0, 
+        LLM_INSTANCE = ChatGoogleGenerativeAI(model=GEMINI_MODEL_NAME, google_api_key=GOOGLE_API_KEY, temperature=0.0,
             safety_settings={HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
                              HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,},
             request_timeout=120, convert_system_message_to_human=True )
-        logger.info(f"LLM initialized: {GEMINI_MODEL_NAME}")
-    except Exception as e: logger.error(f"LLM init failed: {e}", exc_info=True); raise
+        logger.info(f"LangChain LLM (Planner) initialized: {GEMINI_MODEL_NAME}")
+    except Exception as e: logger.error(f"LangChain LLM init failed: {e}", exc_info=True); raise
+
     TOOLS = []
     if PYPDF2_AVAILABLE: TOOLS.append(read_pdf_tool)
     if PIL_TESSERACT_AVAILABLE: TOOLS.append(ocr_image_tool)
     if WHISPER_AVAILABLE: TOOLS.append(transcribe_audio_tool)
+    
+    # Add the new direct multimodal tool if its dependencies (client, PIL) are met
+    if google_genai_client and PIL_TESSERACT_AVAILABLE: # PIL_TESSERACT_AVAILABLE implies PIL is available
+        TOOLS.append(direct_multimodal_gemini_tool)
+        logger.info("Added 'direct_multimodal_gemini_tool'.")
+    else:
+        logger.warning("'direct_multimodal_gemini_tool' NOT added due to missing google_genai_client or PIL.")
+
     try: search_tool = DuckDuckGoSearchRun(name="web_search"); search_tool.description = "Web search. Input: query."; TOOLS.append(search_tool)
     except Exception as e: logger.warning(f"DuckDuckGoSearchRun init failed: {e}")
     try: python_repl = PythonREPLTool(name="python_repl"); python_repl.description = "Python REPL. print() for output."; TOOLS.append(python_repl)
     except Exception as e: logger.warning(f"PythonREPLTool init failed: {e}")
-    logger.info(f"Tools added: {[t.name for t in TOOLS]}")
+    logger.info(f"Final tools list for agent: {[t.name for t in TOOLS]}")
+
 
+    # ... (Rest of your initialize_agent_and_tools function for LangGraph/ReAct setup - unchanged)
     if LANGGRAPH_FLAVOR_AVAILABLE and all([LG_StateGraph, LG_ToolExecutor, LG_END, LLM_INSTANCE, LG_ToolInvocation, add_messages]):
-        if not LANGGRAPH_MEMORY_SAVER and MemorySaver_Class: LANGGRAPH_MEMORY_SAVER = MemorySaver_Class()
+        if not LANGGRAPH_MEMORY_SAVER and MemorySaver_Class: LANGGRAPH_MEMORY_SAVER = MemorySaver_Class(); logger.info("LangGraph MemorySaver initialized.")
         try:
             logger.info(f"Attempting LangGraph init (Memory: {LANGGRAPH_MEMORY_SAVER is not None})")
-            _TypedDict = TypedDict if TYPE_CHECKING else getattr(__import__('typing_extensions'), 'TypedDict', dict)
-            class AgentState(_TypedDict): input: str; messages: Annotated[List[AnyMessage], add_messages]
-            bound_llm, tool_executor_lg = LLM_INSTANCE.bind_tools(TOOLS), LG_ToolExecutor(TOOLS)
-            def agent_node(s: AgentState): msgs=[SystemMessage(content=LANGGRAPH_PROMPT_TEMPLATE_STR.format(tools="\n".join([f"- {t.name}:{t.description}"for t in TOOLS]),input=s['input']))]+s.get('messages', []); return {"messages":[bound_llm.invoke(msgs)]}
-            def tool_node(s: AgentState): 
-                last=s['messages'][-1] if s.get('messages') and isinstance(s['messages'][-1],AIMessage) else None
-                if not last or not last.tool_calls: return {"messages":[]}
-                tool_results = []
-                for tc in last.tool_calls:
-                    name, args, tc_id = tc.get('name'), tc.get('args'), tc.get('id')
-                    if not all([name, isinstance(args, dict), tc_id]):
-                        err_msg=f"Invalid tool_call structure: {tc}"; logger.error(err_msg)
-                        tool_results.append(ToolMessage(f"Error: {err_msg}", tool_call_id=tc_id or "error_id", name=name or "error_tool"))
+            _TypedDict = getattr(__import__('typing_extensions'), 'TypedDict', dict)
+            class AgentState(_TypedDict): input: str; messages: Annotated[List[Any], add_messages] # Use Any for AnyMessage for broader compatibility
+
+            prompt_content_lg = LANGGRAPH_PROMPT_TEMPLATE_STR.format(
+                tools="\n".join([f"- {t.name}: {t.description}" for t in TOOLS]),
+                input="{input}"
+            )
+            def agent_node(state: AgentState):
+                current_input_lg = state.get('input', '')
+                formatted_system_prompt_lg = prompt_content_lg.replace("{input}", current_input_lg)
+                messages_for_llm_lg = [SystemMessage(content=formatted_system_prompt_lg)] + state.get('messages', [])
+                bound_llm_for_tools_lg = LLM_INSTANCE.bind_tools(TOOLS)
+                response_from_llm_lg = bound_llm_for_tools_lg.invoke(messages_for_llm_lg)
+                return {"messages": [response_from_llm_lg]}
+
+            tool_executor_lg_instance = LG_ToolExecutor(TOOLS) # type: ignore
+            def tool_node(state: AgentState):
+                last_msg_lg = state['messages'][-1] if state.get('messages') and isinstance(state['messages'][-1], AIMessage) else None
+                if not last_msg_lg or not last_msg_lg.tool_calls: return {"messages": []}
+                tool_results_lg = []
+                for tc_lg in last_msg_lg.tool_calls:
+                    name_lg, args_lg, tc_id_lg = tc_lg.get('name'), tc_lg.get('args'), tc_lg.get('id')
+                    if not all([name_lg, isinstance(args_lg, dict), tc_id_lg]):
+                        err_msg_lg=f"Invalid tool_call: {tc_lg}"; logger.error(err_msg_lg)
+                        tool_results_lg.append(ToolMessage(f"Error: {err_msg_lg}", tool_call_id=tc_id_lg or "error_id", name=name_lg or "error_tool"))
                         continue
                     try:
-                        logger.info(f"LG Tool Invoking: '{name}' with {args} (ID: {tc_id})")
-                        output = tool_executor_lg.invoke(LG_ToolInvocation(tool=name, tool_input=args))
-                        tool_results.append(ToolMessage(content=str(output), tool_call_id=tc_id, name=name))
-                    except Exception as e_tool:
-                        logger.error(f"LG Tool Error ('{name}'): {e_tool}", exc_info=True)
-                        tool_results.append(ToolMessage(content=f"Error for tool {name}: {str(e_tool)}", tool_call_id=tc_id, name=name))
-                return {"messages": tool_results}
-
-            wf = LG_StateGraph(AgentState); wf.add_node("agent",agent_node); wf.add_node("tools",tool_node); wf.set_entry_point("agent")
-            wf.add_conditional_edges("agent",lambda s:"tools" if s['messages'][-1].tool_calls else LG_END,{"tools":"tools",LG_END:LG_END}); wf.add_edge("tools","agent")
-            AGENT_INSTANCE = wf.compile(checkpointer=LANGGRAPH_MEMORY_SAVER) if LANGGRAPH_MEMORY_SAVER else wf.compile()
+                        logger.info(f"LG Tool Invoking: '{name_lg}' with {args_lg} (ID: {tc_id_lg})")
+                        tool_invocation_obj_lg = LG_ToolInvocation(tool=name_lg, tool_input=args_lg) # type: ignore
+                        output_lg = tool_executor_lg_instance.invoke(tool_invocation_obj_lg)
+                        tool_results_lg.append(ToolMessage(content=str(output_lg), tool_call_id=tc_id_lg, name=name_lg))
+                    except Exception as e_tool_node_lg:
+                        logger.error(f"LG Tool Error ('{name_lg}'): {e_tool_node_lg}", exc_info=True)
+                        tool_results_lg.append(ToolMessage(content=f"Error for tool {name_lg}: {str(e_tool_node_lg)}", tool_call_id=tc_id_lg, name=name_lg))
+                return {"messages": tool_results_lg}
+
+            workflow_lg = LG_StateGraph(AgentState) # type: ignore
+            workflow_lg.add_node("agent", agent_node)
+            workflow_lg.add_node("tools", tool_node)
+            workflow_lg.set_entry_point("agent")
+            def should_continue_lg(state: AgentState): return "tools" if state['messages'][-1].tool_calls else LG_END
+            workflow_lg.add_conditional_edges("agent", should_continue_lg, {"tools": "tools", LG_END: LG_END}) # type: ignore
+            workflow_lg.add_edge("tools", "agent")
+            AGENT_INSTANCE = workflow_lg.compile(checkpointer=LANGGRAPH_MEMORY_SAVER) if LANGGRAPH_MEMORY_SAVER else workflow_lg.compile()
             logger.info(f"LangGraph compiled (Memory: {LANGGRAPH_MEMORY_SAVER is not None}).")
-        except Exception as e: logger.error(f"LangGraph init error: {e}. Fallback ReAct.", exc_info=True); AGENT_INSTANCE = None
-    else: logger.info("Skipping LangGraph: core components missing or LLM not ready."); AGENT_INSTANCE = None
+        except Exception as e_lg_init_main:
+            logger.error(f"LangGraph init error: {e_lg_init_main}. Fallback ReAct.", exc_info=True); AGENT_INSTANCE = None
+    else:
+        logger.info("Skipping LangGraph: core components missing or LLM not ready."); AGENT_INSTANCE = None
 
     if not AGENT_INSTANCE:
-        logger.info("Initializing ReAct agent.")
+        logger.info("Initializing ReAct agent as fallback.")
         try:
-            if not LLM_INSTANCE: raise ValueError("LLM None for ReAct.")
-            p=PromptTemplate.from_template(REACT_PROMPT_TEMPLATE_STR).partial(tools="\n".join([f"- {t.name}:{t.description}"for t in TOOLS]),tool_names=",".join([t.name for t in TOOLS]))
-            AGENT_INSTANCE=AgentExecutor(agent=create_react_agent(LLM_INSTANCE,TOOLS,p),tools=TOOLS,verbose=True,handle_parsing_errors=True,max_iterations=15,early_stopping_method="force")
+            if not LLM_INSTANCE: raise ValueError("LLM_INSTANCE is None for ReAct.")
+            prompt_react_instance = PromptTemplate.from_template(REACT_PROMPT_TEMPLATE_STR).partial(
+                tools="\n".join([f"- {t.name}:{t.description}" for t in TOOLS]),
+                tool_names=",".join([t.name for t in TOOLS])
+            )
+            react_agent_runnable_instance = create_react_agent(LLM_INSTANCE, TOOLS, prompt_react_instance)
+            AGENT_INSTANCE = AgentExecutor(agent=react_agent_runnable_instance, tools=TOOLS, verbose=True, handle_parsing_errors=True, max_iterations=15, early_stopping_method="force")
             logger.info("ReAct agent initialized.")
-        except Exception as e: logger.error(f"ReAct init failed: {e}", exc_info=True); AGENT_INSTANCE = None
-    if not AGENT_INSTANCE: raise RuntimeError("CRITICAL: Agent init completely failed.")
-    logger.info(f"Agent init finished. Active: {type(AGENT_INSTANCE).__name__}")
+        except Exception as e_react_init_main:
+            logger.error(f"ReAct agent init failed: {e_react_init_main}", exc_info=True); AGENT_INSTANCE = None
+
+    if not AGENT_INSTANCE: raise RuntimeError("CRITICAL: Agent initialization completely failed.")
+    logger.info(f"Agent init finished. Active agent type: {type(AGENT_INSTANCE).__name__}")
 
+
+# --- get_agent_response, construct_prompt_for_agent, run_and_submit_all ---
+# --- These functions remain UNCHANGED from your original code ---
 def get_agent_response(prompt: str, task_id: Optional[str]=None, thread_id: Optional[str]=None) -> str:
+    # ... (Your original get_agent_response logic) ...
     global AGENT_INSTANCE, LLM_INSTANCE
-    thread_id=thread_id or (f"gaia_task_{task_id}" if task_id else hashlib.md5(prompt.encode()).hexdigest()[:8])
+    thread_id_to_use = thread_id or (f"gaia_task_{task_id}" if task_id else hashlib.md5(prompt.encode()).hexdigest()[:8])
     if not AGENT_INSTANCE or not LLM_INSTANCE:
-        logger.warning("Re-init agent/LLM in get_agent_response."); initialize_agent_and_tools(force_reinit=True)
-        if not AGENT_INSTANCE or not LLM_INSTANCE: return "[ERROR] Agent/LLM re-init failed."
-    name=type(AGENT_INSTANCE).__name__; logger.info(f"Agent ({name}) getting response. Task:{task_id or 'N/A'}. Thread:{thread_id}.")
-    is_lg = LANGGRAPH_FLAVOR_AVAILABLE and AGENT_INSTANCE and not isinstance(AGENT_INSTANCE,AgentExecutor)
+        logger.warning("Agent/LLM not initialized in get_agent_response. Attempting re-initialization.")
+        try: initialize_agent_and_tools(force_reinit=True)
+        except Exception as e_reinit_get: logger.error(f"Re-initialization failed: {e_reinit_get}"); return f"[ERROR] Agent/LLM re-init failed: {str(e_reinit_get)}"
+        if not AGENT_INSTANCE or not LLM_INSTANCE: return "[ERROR] Agent/LLM still None after re-init."
+    agent_name_get = type(AGENT_INSTANCE).__name__
+    logger.info(f"Agent ({agent_name_get}) processing. Task: {task_id or 'N/A'}. Thread: {thread_id_to_use}.")
+    is_langgraph_agent_get = LANGGRAPH_FLAVOR_AVAILABLE and AGENT_INSTANCE and hasattr(AGENT_INSTANCE, 'graph') and hasattr(AGENT_INSTANCE, 'config_schema')
     try:
-        if is_lg:
-            logger.debug(f"Using LangGraph (Memory: {LANGGRAPH_MEMORY_SAVER is not None})")
-            state=AGENT_INSTANCE.invoke({"input":prompt,"messages":[]},{"configurable":{"thread_id":thread_id}})
-            if not state or 'messages' not in state or not state['messages']: return "[ERROR] LG: No final state/messages."
-            for m in reversed(state['messages']):
-                if isinstance(m,AIMessage) and not m.tool_calls: return m.content
-            return "[ERROR] LG: No suitable final AIMessage."
-        elif isinstance(AGENT_INSTANCE,AgentExecutor): logger.debug("ReAct agent."); return AGENT_INSTANCE.invoke({"input":prompt}).get("output","[ERROR] ReAct: No 'output'.")
-        else: return f"[ERROR] Unknown agent type: {name}"
-    except Exception as e: logger.error(f"Error in get_agent_response ({name}): {e}",exc_info=True); return f"[ERROR] Failed: {str(e)[:100]}"
+        if is_langgraph_agent_get:
+            logger.debug(f"Using LangGraph agent (Memory: {LANGGRAPH_MEMORY_SAVER is not None}) for thread: {thread_id_to_use}")
+            initial_messages_lg_get = []
+            input_for_lg_get = {"input": prompt, "messages": initial_messages_lg_get}
+            final_state_lg_get = AGENT_INSTANCE.invoke(input_for_lg_get, {"configurable": {"thread_id": thread_id_to_use}})
+            if not final_state_lg_get or 'messages' not in final_state_lg_get or not final_state_lg_get['messages']:
+                logger.error("LangGraph: No final state/messages."); return "[ERROR] LangGraph: No final state/messages."
+            for message_item_lg_get in reversed(final_state_lg_get['messages']):
+                if isinstance(message_item_lg_get, AIMessage) and not message_item_lg_get.tool_calls:
+                    return str(message_item_lg_get.content)
+            logger.warning("LangGraph: No suitable final AIMessage without tool_calls.")
+            return str(final_state_lg_get['messages'][-1].content) if final_state_lg_get['messages'] else "[ERROR] LangGraph: Empty messages."
+        elif isinstance(AGENT_INSTANCE, AgentExecutor):
+            logger.debug("Using ReAct agent.")
+            response_react_get = AGENT_INSTANCE.invoke({"input": prompt})
+            return str(response_react_get.get("output", "[ERROR] ReAct: No 'output' key."))
+        else:
+            logger.error(f"Unknown agent type: {agent_name_get}"); return f"[ERROR] Unknown agent type: {agent_name_get}"
+    except Exception as e_agent_run_get:
+        logger.error(f"Error during agent execution ({agent_name_get}): {e_agent_run_get}", exc_info=True)
+        return f"[ERROR] Agent execution failed: {str(e_agent_run_get)[:150]}"
 
 def construct_prompt_for_agent(q: Dict[str,Any]) -> str:
+    # ... (Your original construct_prompt_for_agent logic) ...
     tid,q_str=q.get("task_id","N/A"),q.get("question",""); files=q.get("files",[])
     files_info = ("\nFiles:\n"+"\n".join([f"- {f} (task_id:{tid})"for f in files])) if files else ""
     level = f"\nLevel:{q.get('level')}" if q.get('level') else ""
     return f"Task ID:{tid}{level}{files_info}\n\nQuestion:{q_str}"
 
-# --- Main Submission Logic ---
-def run_and_submit_all(profile: Optional[gr.OAuthProfile] = None): # Re-added profile as per Gradio standard
+def run_and_submit_all(profile: Optional[gr.OAuthProfile] = None):
+    # ... (Your original run_and_submit_all logic - unchanged) ...
     global AGENT_INSTANCE
     space_id = os.getenv("SPACE_ID")
     username_for_submission = None
@@ -387,80 +505,79 @@ def run_and_submit_all(profile: Optional[gr.OAuthProfile] = None): # Re-added pr
         username_for_submission = profile.username
         logger.info(f"Username from OAuth profile: {username_for_submission}")
     else:
-        # This case means user is not logged in via HF Login Button, or OAuth is not configured for the Space
-        logger.warning("OAuth profile not available or username missing. Submission might fail or be attributed to a default/fallback if allowed by API.")
-        # As per strict template, we should stop if no profile.
+        logger.warning("OAuth profile not available or username missing.")
         return "Hugging Face login required. Please use the login button and try again.", None
 
     if AGENT_INSTANCE is None:
-        try: logger.info("Agent not pre-initialized. Initializing now for run..."); initialize_agent_and_tools()
+        try: logger.info("Agent not pre-initialized. Initializing for run..."); initialize_agent_and_tools()
         except Exception as e: return f"Agent on-demand initialization failed: {e}", None
-        if AGENT_INSTANCE is None: return "Agent is still None after on-demand initialization attempt.", None
+        if AGENT_INSTANCE is None: return "Agent is still None after on-demand init.", None
     
-    agent_code=f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "local_dev"
-    q_url,s_url=f"{DEFAULT_API_URL}/questions",f"{DEFAULT_API_URL}/submit"
-    auth_h={"Authorization":f"Bearer {HUGGINGFACE_TOKEN}"} if HUGGINGFACE_TOKEN else {}
+    agent_code_url_run=f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "local_dev_run"
+    questions_url_run,submit_url_run=f"{DEFAULT_API_URL}/questions",f"{DEFAULT_API_URL}/submit"
+    auth_headers_run={"Authorization":f"Bearer {HUGGINGFACE_TOKEN}"} if HUGGINGFACE_TOKEN else {}
     try:
-        logger.info(f"Fetching questions from {q_url}")
-        r=requests.get(q_url,headers=auth_h,timeout=30);r.raise_for_status();q_data=r.json()
-        if not q_data or not isinstance(q_data,list):logger.error(f"Invalid questions data: {q_data}");return "Fetched q_data invalid.",None
-        logger.info(f"Fetched {len(q_data)} questions.")
+        logger.info(f"Fetching questions from {questions_url_run}")
+        response_q_run=requests.get(questions_url_run,headers=auth_headers_run,timeout=30);response_q_run.raise_for_status();questions_data_run=response_q_run.json()
+        if not questions_data_run or not isinstance(questions_data_run,list):logger.error(f"Invalid questions data: {questions_data_run}");return "Fetched questions_data invalid.",None
+        logger.info(f"Fetched {len(questions_data_run)} questions.")
     except Exception as e:logger.error(f"Fetch questions error: {e}",exc_info=True);return f"Fetch questions error:{e}",None
     
-    res_log,ans_payload=[],[]
-    logger.info(f"Running agent on {len(q_data)} questions for user '{username_for_submission}'...")
-    for i,item in enumerate(q_data):
-        tid,q_txt=item.get("task_id"),item.get("question")
-        if not tid or q_txt is None:logger.warning(f"Skipping item: {item}");continue
-        prompt=construct_prompt_for_agent(item);th_id=f"gaia_batch_task_{tid}"
-        logger.info(f"Processing Q {i+1}/{len(q_data)} - Task: {tid}")
+    results_log_run,answers_payload_run=[],[]
+    logger.info(f"Running agent on {len(questions_data_run)} questions for user '{username_for_submission}'...")
+    for i,item_run in enumerate(questions_data_run):
+        task_id_run,question_text_run=item_run.get("task_id"),item_run.get("question")
+        if not task_id_run or question_text_run is None:logger.warning(f"Skipping item: {item_run}");continue
+        prompt_run=construct_prompt_for_agent(item_run);thread_id_run=f"gaia_batch_task_{task_id_run}"
+        logger.info(f"Processing Q {i+1}/{len(questions_data_run)} - Task: {task_id_run}")
         try:
-            raw_ans=get_agent_response(prompt,task_id=tid,thread_id=th_id);sub_ans=_strip_exact_match_answer(raw_ans)
-            ans_payload.append({"task_id":tid,"submitted_answer":sub_ans})
-            res_log.append({"Task ID":tid,"Question":q_txt,"Full Agent Prompt":prompt,"Raw Agent Output":raw_ans,"Submitted Answer":sub_ans})
+            raw_answer_run=get_agent_response(prompt_run,task_id=task_id_run,thread_id=thread_id_run);submitted_answer_run=_strip_exact_match_answer(raw_answer_run)
+            answers_payload_run.append({"task_id":task_id_run,"submitted_answer":submitted_answer_run})
+            results_log_run.append({"Task ID":task_id_run,"Question":question_text_run,"Full Agent Prompt":prompt_run,"Raw Agent Output":raw_answer_run,"Submitted Answer":submitted_answer_run})
         except Exception as e:
-            logger.error(f"Agent error task {tid}:{e}",exc_info=True);err_ans=f"AGENT ERROR:{str(e)[:100]}"
-            ans_payload.append({"task_id":tid,"submitted_answer":"N/A [AGENT_ERROR]"})
-            res_log.append({"Task ID":tid,"Question":q_txt,"Full Agent Prompt":prompt,"Raw Agent Output":err_ans,"Submitted Answer":"N/A [AGENT_ERROR]"})
+            logger.error(f"Agent error task {task_id_run}:{e}",exc_info=True);error_answer_run=f"AGENT ERROR:{str(e)[:100]}"
+            answers_payload_run.append({"task_id":task_id_run,"submitted_answer":"N/A [AGENT_ERROR]"})
+            results_log_run.append({"Task ID":task_id_run,"Question":question_text_run,"Full Agent Prompt":prompt_run,"Raw Agent Output":error_answer_run,"Submitted Answer":"N/A [AGENT_ERROR]"})
     
-    if not ans_payload:return "Agent no answers.",pd.DataFrame(res_log)
-    sub_data={"username":username_for_submission.strip(),"agent_code":agent_code,"answers":ans_payload}
-    logger.info(f"Submitting {len(ans_payload)} answers to {s_url} for user '{username_for_submission}'...")
-    sub_h={"Content-Type":"application/json",**auth_h}
+    if not answers_payload_run:return "Agent produced no answers.",pd.DataFrame(results_log_run)
+    submission_payload_run={"username":username_for_submission.strip(),"agent_code":agent_code_url_run,"answers":answers_payload_run}
+    logger.info(f"Submitting {len(answers_payload_run)} answers to {submit_url_run} for user '{username_for_submission}'...")
+    submission_headers_run={"Content-Type":"application/json",**auth_headers_run}
     try:
-        r=requests.post(s_url,json=sub_data,headers=sub_h,timeout=120);r.raise_for_status();res_data=r.json()
-        msg=(f"User:{res_data.get('username',username_for_submission)}\nScore:{res_data.get('score','N/A')}% ({res_data.get('correct_count','?')}/{res_data.get('total_attempted','?')})\nMsg:{res_data.get('message','N/A')}")
-        logger.info(f"Submission OK! {msg}");return f"Submission OK!\n{msg}",pd.DataFrame(res_log,columns=["Task ID","Question","Full Agent Prompt","Raw Agent Output","Submitted Answer"])
+        response_s_run=requests.post(submit_url_run,json=submission_payload_run,headers=submission_headers_run,timeout=120);response_s_run.raise_for_status();submission_result_run=response_s_run.json()
+        result_message_run=(f"User:{submission_result_run.get('username',username_for_submission)}\nScore:{submission_result_run.get('score','N/A')}% ({submission_result_run.get('correct_count','?')}/{submission_result_run.get('total_attempted','?')})\nMsg:{submission_result_run.get('message','N/A')}")
+        logger.info(f"Submission OK! {result_message_run}");return f"Submission OK!\n{result_message_run}",pd.DataFrame(results_log_run,columns=["Task ID","Question","Full Agent Prompt","Raw Agent Output","Submitted Answer"])
     except requests.exceptions.HTTPError as e:
-        err=f"HTTP {e.response.status_code}. Detail:{e.response.text[:200]}"; logger.error(f"Submit Fail:{err}",exc_info=True); return f"Submit Fail:{err}",pd.DataFrame(res_log)
-    except Exception as e:logger.error(f"Submit Fail unexpected:{e}",exc_info=True);return f"Submit Fail:{str(e)[:100]}",pd.DataFrame(res_log)
+        error_http_run=f"HTTP {e.response.status_code}. Detail:{e.response.text[:200]}"; logger.error(f"Submit Fail:{error_http_run}",exc_info=True); return f"Submit Fail:{error_http_run}",pd.DataFrame(results_log_run)
+    except Exception as e:logger.error(f"Submit Fail unexpected:{e}",exc_info=True);return f"Submit Fail:{str(e)[:100]}",pd.DataFrame(results_log_run)
+
 
-# --- Build Gradio Interface ---
+# --- Build Gradio Interface (Unchanged from your original) ---
 with gr.Blocks(css=".gradio-container {max-width:1280px !important;margin:auto !important;}",theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# GAIA Agent Challenge Runner v7 (OAuth for Username)") 
+    # ... (Your original Gradio UI layout - unchanged) ...
+    gr.Markdown("# GAIA Agent Challenge Runner v7 (OAuth for Username)")
     gr.Markdown(f"""**Instructions:**
 1. **Login with Hugging Face** using the button below. Your HF username will be used for submission.
 2. Click 'Run Evaluation & Submit' to process GAIA questions (typically 20).
-3. **Goal: 30%+ (6/20).** Agent uses Gemini 2.5 Pro ({GEMINI_MODEL_NAME}), Web Search, Python, PDF, OCR, Audio/YouTube.
+3. **Goal: 30%+ (6/20).** Agent uses Gemini Pro ({GEMINI_MODEL_NAME}) as planner. Tools include Web Search, Python, PDF, OCR, Audio/YouTube, and a new Direct Multimodal tool using Gemini Flash ({GEMINI_FLASH_MULTIMODAL_MODEL_NAME}).
 4. Ensure `GOOGLE_API_KEY` and `HUGGINGFACE_TOKEN` are Space secrets.
 5. Check Space logs for details. LangGraph is attempted (ReAct fallback).""")
-    
-    agent_status_display = gr.Markdown("**Agent Status:** Initializing...") 
-    missing_secrets_display = gr.Markdown("") 
 
-    gr.LoginButton() # Added back as per template standard for username
+    agent_status_display = gr.Markdown("**Agent Status:** Initializing...")
+    missing_secrets_display = gr.Markdown("")
+
+    gr.LoginButton()
     run_button = gr.Button("Run Evaluation & Submit All Answers")
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=7, interactive=False)
-    results_table = gr.DataFrame(label="Q&A Log", headers=["Task ID","Question","Prompt","Raw","Submitted"], wrap=True)
-    
-    # The `profile` argument in `run_and_submit_all` will be populated by Gradio
-    # if the user is logged in via the `gr.LoginButton()` flow.
+    results_table = gr.DataFrame(label="Q&A Log", headers=["Task ID","Question","Prompt","Raw","Submitted"], wrap=True, height=400)
+
     run_button.click(fn=run_and_submit_all, outputs=[status_output,results_table], api_name="run_evaluation")
 
     def update_ui_on_load_fn_within_context():
-        global missing_vars_startup_list_global, agent_pre_init_status_msg_global 
+        # ... (Your original update_ui_on_load_fn_within_context logic - unchanged) ...
+        global missing_vars_startup_list_global, agent_pre_init_status_msg_global
         secrets_msg_md = ""
-        if missing_vars_startup_list_global: 
+        if missing_vars_startup_list_global:
             secrets_msg_md = f"<font color='red'>**⚠️ Secrets Missing:** {', '.join(missing_vars_startup_list_global)}.</font>"
         env_issues = []
         try: subprocess.run(['yt-dlp','--version'],check=True,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
@@ -468,35 +585,34 @@ with gr.Blocks(css=".gradio-container {max-width:1280px !important;margin:auto !
         try: subprocess.run(['ffmpeg','-version'],check=True,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
         except: env_issues.append("ffmpeg"); logger.warning("ffmpeg check failed (UI load).")
         if env_issues: secrets_msg_md += f"<br/><font color='orange'>**Tool Deps Missing:** {', '.join(env_issues)}.</font>"
-        
-        current_status_md = agent_pre_init_status_msg_global 
+        current_status_md = agent_pre_init_status_msg_global
         if not LANGGRAPH_FLAVOR_AVAILABLE and "LangGraph" not in current_status_md:
              current_status_md += " (LangGraph core import failed, ReAct fallback.)"
-        
-        return { agent_status_display: gr.Markdown(value=current_status_md), 
+        return { agent_status_display: gr.Markdown(value=current_status_md),
                  missing_secrets_display: gr.Markdown(value=secrets_msg_md) }
 
     demo.load(update_ui_on_load_fn_within_context, [], [agent_status_display, missing_secrets_display])
 
 if __name__ == "__main__":
-    logger.info("Application starting up (v7)...")
+    # ... (Your original __main__ block for startup logging and pre-initialization - unchanged) ...
+    logger.info("Application starting up (v7 with Direct Multimodal Tool)...")
     if not PYPDF2_AVAILABLE: logger.warning("PyPDF2 (PDF tool) NOT AVAILABLE.")
-    if not PIL_TESSERACT_AVAILABLE: logger.warning("Pillow/Pytesseract (OCR tool) NOT AVAILABLE.")
+    if not PIL_TESSERACT_AVAILABLE: logger.warning("Pillow/Pytesseract (OCR tool) NOT AVAILABLE.") # PIL also needed for new tool
     if not WHISPER_AVAILABLE: logger.warning("Whisper (Audio tool) NOT AVAILABLE.")
     if LANGGRAPH_FLAVOR_AVAILABLE: logger.info("Core LangGraph (StateGraph, END) loaded.")
-    else: logger.warning("Core LangGraph FAILED import. ReAct fallback. Check requirements.txt (langgraph, langchain-core, typing-extensions) & Space build logs for errors.")
+    else: logger.warning("Core LangGraph FAILED import. ReAct fallback. Check requirements & Space build logs.")
 
-    missing_vars_startup_list_global.clear() 
+    missing_vars_startup_list_global.clear()
     if not GOOGLE_API_KEY: missing_vars_startup_list_global.append("GOOGLE_API_KEY")
     if not HUGGINGFACE_TOKEN: missing_vars_startup_list_global.append("HUGGINGFACE_TOKEN (for GAIA API)")
-    # HF_USERNAME_FOR_SUBMISSION is no longer checked here as OAuth is primary
-    
+
     try:
         logger.info("Pre-initializing agent...")
-        initialize_agent_and_tools()
+        initialize_agent_and_tools() # This will now include the new direct_multimodal_gemini_tool
         if AGENT_INSTANCE:
-            agent_pre_init_status_msg_global = f"Agent Pre-initialized: **{type(AGENT_INSTANCE).__name__}**."
-            if LANGGRAPH_FLAVOR_AVAILABLE and not isinstance(AGENT_INSTANCE,AgentExecutor):
+            agent_type_name = type(AGENT_INSTANCE).__name__
+            agent_pre_init_status_msg_global = f"Agent Pre-initialized: **{agent_type_name}**."
+            if LANGGRAPH_FLAVOR_AVAILABLE and "StateGraph" in agent_type_name: # More robust check
                  agent_pre_init_status_msg_global = f"Agent Pre-initialized: **LangGraph** (Memory: {LANGGRAPH_MEMORY_SAVER is not None})."
         else: agent_pre_init_status_msg_global = "Agent pre-init FAILED (AGENT_INSTANCE is None)."
         logger.info(agent_pre_init_status_msg_global.replace("**",""))