Upload 2 files

app.py

@@ -17,6 +17,8 @@ import pdfplumber
 import docx
 import speech_recognition as sr
 import base64
+import tempfile
+import re
 
 from io import BytesIO, StringIO
 from dotenv import load_dotenv
@@ -46,89 +48,124 @@ llm = AzureOpenAI(
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # File parsing tool
-def parse_file(file_url: str, file_type: str) -> str:
+def parse_file(file_url: str, file_name: str) -> str:
     try:
-        # Download file
-        resp = requests.get(file_url, timeout=30)
-        resp.raise_for_status()
-        content = resp.content
-
-        # --- XLSX ---
-        if file_type == ".xlsx":
-            df = pd.read_excel(BytesIO(content))
-            return f"Excel Sheet Content:\n{df.to_string(index=False)}"
-
-        # --- CSV ---
-        if file_type == ".csv":
-            df = pd.read_csv(StringIO(content.decode()))
-            return f"CSV File Content:\n{df.to_string(index=False)}"
-
-        # --- TXT ---
-        if file_type == ".txt":
-            text = content.decode(errors='ignore')
-            return f"Text File Content:\n{text[:3500]}"
-
-        # --- PDF ---
-        if file_type == ".pdf" and pdfplumber:
-            with pdfplumber.open(BytesIO(content)) as pdf:
-                text = "\n".join(page.extract_text() or "" for page in pdf.pages)
-            return f"PDF Content (first 3500 chars):\n{text[:3500]}"
-
-        # --- DOCX ---
-        if file_type == ".docx" and docx:
-            d = docx.Document(BytesIO(content))
-            text = "\n".join(p.text for p in d.paragraphs)
-            return f"DOCX Content (first 3500 chars):\n{text[:3500]}"
-
-        # --- MP3 (Audio to Text) ---
-        if file_type == ".mp3" and sr:
-            # Save MP3 to local
-            mp3_path = "temp.mp3"
-            with open(mp3_path, "wb") as f:
-                f.write(content)
-            try:
-                # Convert MP3 to WAV using pydub if available
-                wav_path = "temp.wav"
+        # Determine file type from file_name or URL
+        if len(file_name)>0:
+            file_type = Path(file_name).suffix.lower()
+            file_type = file_type.split("?")[0] 
+        else:
+            file_type = None
+         # Remove query params
+        if file_type:
+            resp = requests.get(file_url, timeout=30)
+            resp.raise_for_status()
+            content = resp.content
+
+            # --- Excel Files ---
+            if file_type in [".xlsx", ".xls"]:
                 try:
-                    from pydub import AudioSegment
-                    sound = AudioSegment.from_mp3(mp3_path)
-                    sound.export(wav_path, format="wav")
-                    audio_file = wav_path
-                except Exception:
-                    audio_file = mp3_path  # Try raw mp3 if conversion fails
-
-                recognizer = sr.Recognizer()
-                with sr.AudioFile(audio_file) as source:
-                    audio = recognizer.record(source)
-                transcript = recognizer.recognize_google(audio)
-                # Clean up
-                if os.path.exists(mp3_path): os.remove(mp3_path)
-                if os.path.exists(wav_path): os.remove(wav_path)
-                return f"Audio Transcript:\n{transcript}"
-            except Exception as e:
-                if os.path.exists(mp3_path): os.remove(mp3_path)
-                if os.path.exists("temp.wav"): os.remove("temp.wav")
-                return f"Could not transcribe audio: {e}"
-
-        # --- Python file ---
-        if file_type == ".py":
-            text = content.decode(errors='ignore')
-            return f"Python Script Content:\n{text[:3500]}"
-
-        # --- Fallback ---
-        return f"File type {file_type} is not supported yet, or required package is missing."
+                    df = pd.read_excel(BytesIO(content))
+                    return f"Excel Content:\n{df.head(5).to_string(index=False)}"  # Only first 5 rows
+                except Exception as e:
+                    return f"Excel parsing error: {str(e)}"
 
+            # --- CSV Files ---
+            elif file_type == ".csv":
+                try:
+                    df = pd.read_csv(BytesIO(content))
+                    return f"CSV Content:\n{df.head(5).to_string(index=False)}"  # Only first 5 rows
+                except Exception as e:
+                    return f"CSV parsing error: {str(e)}"
+
+            # --- Text Files ---
+            elif file_type == ".txt":
+                text = content.decode(errors='ignore')
+                return f"Text Content:\n{text[:3500]}"
+
+            # --- PDF Files ---
+            elif file_type == ".pdf":
+                try:
+                    with pdfplumber.open(BytesIO(content)) as pdf:
+                        text = "\n".join(page.extract_text() or "" for page in pdf.pages[:3])  # First 3 pages
+                    return f"PDF Content:\n{text[:3500]}"
+                except Exception as e:
+                    return f"PDF parsing error: {str(e)}"
+
+            # --- DOCX Files ---
+            elif file_type == ".docx":
+                try:
+                    d = docx.Document(BytesIO(content))
+                    text = "\n".join(p.text for p in d.paragraphs[:50])  # First 50 paragraphs
+                    return f"DOCX Content:\n{text[:3500]}"
+                except Exception as e:
+                    return f"DOCX parsing error: {str(e)}"
+
+            # --- MP3 Files ---
+            elif file_type == ".mp3":
+                return transcribe_audio(content)  # Use helper function
+
+            # --- Python Files ---
+            elif file_type == ".py":
+                text = content.decode(errors='ignore')
+                return f"Python Code:\n{text[:3500]}"
+
+            # --- Unsupported Types ---
+            else:
+                return f"Unsupported file type: {file_type}"
+        else:
+            return "No file type provided or file URL is invalid."
     except Exception as e:
-        return f"Failed to parse file: {e}"
+        print(f"[parse_file] ERROR: {e}")
+        return f"File parsing failed: {str(e)}"
+
+# Audio transcription helper
+def transcribe_audio(content: bytes) -> str:
+    try:
+        # Create temp files
+        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as mp3_tmp:
+            mp3_tmp.write(content)
+            mp3_path = mp3_tmp.name
+        
+        wav_path = mp3_path.replace(".mp3", ".wav")
+        
+        # Convert to WAV
+        try:
+            from pydub import AudioSegment
+            audio = AudioSegment.from_mp3(mp3_path)
+            audio.export(wav_path, format="wav")
+            audio_file = wav_path
+        except ImportError:
+            audio_file = mp3_path  # Fallback to MP3 if pydub not available
+        
+        # Transcribe audio
+        recognizer = sr.Recognizer()
+        with sr.AudioFile(audio_file) as source:
+            audio = recognizer.record(source)
+        transcript = recognizer.recognize_google(audio)
+        
+        # Cleanup
+        for path in [mp3_path, wav_path]:
+            if os.path.exists(path):
+                os.remove(path)
+                
+        return f"Audio Transcript:\n{transcript}"
     
+    except Exception as e:
+        print(f"Audio transcription error: {e}")
+        return "Could not transcribe audio"
+
 # YouTube transcript tool
 def get_youtube_transcript(url: str) -> str:
     try:
-        video_id = url.split("v=")[-1]
+        video_id = url.split("v=")[-1].split("&")[0]  # Clean video ID
         transcript = YouTubeTranscriptApi.get_transcript(video_id)
         return " ".join([e['text'] for e in transcript])
-    except Exception:
-        return "No transcript available."
+    except NoTranscriptFound:
+        return "No transcript available for this video"
+    except Exception as e:
+        return f"Error retrieving transcript: {str(e)}"
+
 
 # ------------ DuckDuckGo Search and Extract -------------------------
 def scrape_text_from_url(url: str, max_chars=4000) -> str:
@@ -142,35 +179,63 @@ def scrape_text_from_url(url: str, max_chars=4000) -> str:
     except Exception as e:
         return f"Could not scrape {url}: {e}"
 
-def duckduckgo_search_and_scrape(question: str) -> str:
+def duckduckgo_search_and_scrape(
+    question: str,
+    max_results: int = 10,
+    min_chars: int = 400,       # treat shorter pages as “unscrapable”
+    max_chars: int = 4000       # final truncate length
+) -> str:
     """
-    Performs a DuckDuckGo search, scrapes the top relevant link, and returns the scraped content for LLM-based answering.
+    DuckDuckGo → scrape → fallback.
+
+    1. Try up to max_results links; return the first page that gives
+       ≥ min_chars of visible text.
+    2. If none succeed, compose an answer from the DDG result metadata.
     """
-    # Step 1: Search
     ddg_spec = DuckDuckGoSearchToolSpec()
-    results = ddg_spec.duckduckgo_full_search(question)
-    if not results or not isinstance(results, list):
+    results = ddg_spec.duckduckgo_full_search(question) or []
+
+    if not isinstance(results, list):
         return "No search results found."
-    
-    # Step 2: Find first Wikipedia or Discogs or similar music data site
-    for entry in results:
+
+    cleaned_pages = []
+
+    for entry in results[:max_results]:
         href = entry.get("href", "")
-        if href:
-            text = scrape_text_from_url(href)
-            # Step 3: Compose output for LLM or direct answer
-            return (
-                f"Here is content scraped from {href}:\n\n"
-                f"{text}\n\n"
-                "Based on this, please answer the original question."
-            )
-    # If no "trusted" link found, fallback to first result
-    text = scrape_text_from_url(results[0]["href"])
+        if not href:
+            continue
+
+        # --- attempt to scrape ------------------------------------------------
+        text = scrape_text_from_url(href, max_chars=max_chars)
+        if text.startswith("Could not scrape") or len(text) < min_chars:
+            continue  # treat as failure – try next result
+        # success!
+        return (
+            f"Here is content scraped from {href}:\n\n"
+            f"{text}\n\n"
+            "Based on this, please answer the original question."
+        )
+
+    # ---------------- fallback: build summary from DDG metadata --------------
+    if not results:
+        return "No search results found."
+
+    summary_lines = []
+    for idx, entry in enumerate(results[:max_results], start=1):
+        title = entry.get("title") or "Untitled result"
+        snippet = (entry.get("body") or "").replace("\n", " ")[:160]
+        href = entry.get("href")
+        summary_lines.append(f"{idx}. {title} – {snippet}  ({href})")
+
     return (
-        f"Here is content scraped from {results[0]['href']}:\n\n"
-        f"{text}\n\n"
-        "Based on this, please answer the original question."
+        "I could not successfully scrape any of the top pages. "
+        "Here are the top DuckDuckGo results:\n\n"
+        + "\n".join(summary_lines)
+        + "\n\nPlease answer the original question using this list."
     )
 
+
+
 # ------------ Image Processing Tool Functions -------------------------
 # MIME type mapping for images
 MIME_MAP = {
@@ -226,9 +291,163 @@ def process_image(file_url: str, question: str) -> str:
     except Exception as e:
         return f"Vision API error: {e}"
 
+
+# ─── formatter.py  (or inline in your module) ─────────────────────────
+from pydantic import BaseModel, ValidationError
+from openai import AzureOpenAI
+
+FALLBACK = "ANSWER_NOT_FOUND"   # single source of truth, keep as plain text
+
+SYSTEM_PROMPT = (
+    "You are an answer-formatter. I will give you:\n"
+    "  • the user question\n"
+    "  • a raw multi-agent trace that may contain Thoughts, Actions, tool "
+    "   outputs, and possibly a FINAL ANSWER.\n\n"
+
+    "Your job:\n"
+    "1. Extract the true answer if it is present anywhere in the trace.\n"
+    "2. Output exactly one line in this template:\n"
+    "   FINAL ANSWER: <ANSWER>\n\n"
+    "If the trace contains no FINAL ANSWER **but the question itself already contains enough information**, deduce the answer on your own."
+    "Return a FINAL ANSWER line in the usual format.\n"
+
+
+    "Rules for <ANSWER>:\n"
+    "• Number → digits only, no commas, no currency/percent signs unless "
+    "  explicitly asked for.\n"
+    "• String → as short as possible, no articles unless required.\n"
+    "• List  → comma-separated values following the above rules; if no order "
+    "  is specified, sort alphabetically.\n"
+    "• If rounding or units are requested in the question, apply before "
+    "  formatting and include the unit with **no preceding space**.\n\n"
+    f"If you cannot find a valid answer, output:\n"
+    f"   FINAL ANSWER: {FALLBACK}\n\n"
+
+    "Examples (follow exactly)\n"
+    "###\n"
+    "Q: Reverse this word: elppa\n"
+    "Trace: (no FINAL ANSWER)\n"
+    "A: FINAL ANSWER: apple\n"
+    "Q: What is 2+3?\n"
+    "Trace: Thought: need a calculator\n"
+    "A: FINAL ANSWER: 5\n"
+    "Q: How many planets?  Trace: … FINAL ANSWER: 8\n"
+    "A: FINAL ANSWER: 8\n"
+    "###\n"
+    "Q: Give the colour.  Trace: … blue.\n"
+    "A: FINAL ANSWER: blue\n"
+    "###\n"
+    "Q: Name the three vowels. Trace: … a, e, i, o, u.\n"
+    "A: FINAL ANSWER: a,e,i,o,u\n"
+    "###\n"
+    "Q: What’s the speed? (units requested) Trace: … 3.0 m/s.\n"
+    "A: FINAL ANSWER: 3.0m/s\n"
+    "###\n"
+    "Q: Any answer? Trace: … tool failure …\n"
+    f"A: FINAL ANSWER: {FALLBACK}"
+)
+
+
+class Result(BaseModel):
+    final_answer: str
+
+
+def format_final_answer(question: str,
+                        raw_trace: str,
+                        *,
+                        api_key: str,
+                        api_version: str,
+                        endpoint: str,
+                        deployment: str,
+                        temperature: float = 0.0) -> str:
+    """
+    Second-pass LLM call that converts an unstructured agent trace into the
+    strict 'FINAL ANSWER: …' template.  On any error returns the FALLBACK.
+    """
+    try:
+        from openai import AzureOpenAI
+        client = AzureOpenAI(
+            api_key=api_key,
+            api_version=api_version,
+            azure_endpoint=endpoint,
+        )
+
+        messages = [
+            {"role": "system",    "content": SYSTEM_PROMPT},
+            {"role": "user",      "content": f"Question: {question}\nTrace: {raw_trace}"}
+        ]
+
+        rsp = client.chat.completions.create(
+            model=deployment,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=120,
+        )
+
+        out = rsp.choices[0].message.content.strip()
+
+        # Remove the label for downstream code (keep only the value)
+        if out.lower().startswith("final answer:"):
+            out = out.split(":", 1)[1].strip()
+
+        # basic schema check – non-empty string
+        Result(final_answer=out)
+        return out or FALLBACK
+
+    except (ValidationError, Exception):
+        return FALLBACK
+
 # ------------------------------
 # 2. BasicAgent Class Definition
 # ------------------------------
+REASONING_PROMPT = """
+        You are the Router-&-Reasoning-Agent.
+
+        NEVER output filler like “Could you please provide more context”.
+
+        If the answer is not already in the question, DELEGATE:
+
+        • Any external fact → WebSearch-Agent
+        • YouTube link      → YouTube-Agent
+        • File link (PDF…)  → File-Agent
+        • Image link        → Image-Agent
+
+        How to delegate
+        ───────────────
+        Call the special tool `handoff` **once** with JSON:
+            {"to_agent":"<agent_name>","reason":"<why>"}
+
+        When to answer directly
+        ───────────────────────
+        • The question already contains all information needed (e.g. reversed text,
+        Caesar cipher, mental arithmetic, pure logic).
+        • You are 100 % certain no external resource is required.
+
+        Output format
+        ─────────────
+        • If you delegate → return the tool call only; the delegated agent will finish.
+        • If you answer yourself → one line:
+            FINAL ANSWER: <clean answer>
+        Follow the global rules (digits only, short strings, comma-lists, etc.).
+
+        Never
+        ─────
+        • Never try to scrape the web or parse files yourself.
+        • Never add filler like “Thinking…” or “Awaiting response”.
+        • Never answer if the question clearly needs a specialised agent.
+
+        Example
+        ───────
+        Example (self-contained)
+        Q: .rewsna eht sa "tfel" …        ← reversed
+        A: FINAL ANSWER: right
+        Example (delegation)
+        Q: Who wrote the novel Dune?
+        A: Action: handoff
+        Action Input: {"to_agent":"websearch_agent","reason":"needs web"}
+    """
+
+
 class BasicAgent:
     def __init__(self):
         """Initialize the BasicAgent with all tools and agent workflow."""
@@ -246,29 +465,34 @@ class BasicAgent:
         
         # Define routing instruction
         self.routing_instruction = (
-            "You are a multi-agent AI system responsible for routing and answering diverse user questions.\n"
-            "You have access to the following specialized agents:\n"
-            "- File Parser Agent → handles structured documents like PDFs, DOCXs, CSVs, etc.\n"
-            "- YouTube Transcript Agent → answers questions about YouTube video content.\n"
-            "- Web Search Agent → retrieves general or real-time information using web search.\n"
-            "- Image Agent → analyzes image files and answer visual questions.\n\n"
-            "Your responsibilities:\n"
-            "1. Analyze the user question and any attached file if any.\n"
-            "2. Select and route the task to the most appropriate agent.\n"
-            "3. Return ONLY the final answer from the selected agent.\n"
-            "4. If the file type is image file(png,jpg,jpeg, webp, gif etc..), you must immediately forward the question and the provided image path to the Image Agent. Once you hand off to the Image Agent, that agent will call the image_processing tool to fetch and analyze the image.\n\n"
-            "5. For all other file types(pdf, docx, xlsx, txt, mp3, wav, mov etc..), use the File Parser Agent to extract content and answer the question.\n"
-            "Strict guidelines:\n"
-            "- NEVER reply with filler phrases like 'please wait', 'I will await Agent's response.' or 'awaiting response', wait until the response received from any agent.\n"
-            "- ALWAYS use the most appropriate agent based on the task.\n"
-            "- For ambiguous, encoded, or reversed questions, attempt to interpret and resolve them logically.\n"
-            "- Do NOT skip or ignore input unless it clearly violates safety policies.\n\n"
-            "Answer formatting:\n"
-            "- Final responses must end with: FINAL ANSWER: [your answer].\n"
-            "- The answer must be a clean string, number, or comma-separated list — no currency symbols, percentages, or unnecessary words.\n"
-            "- Do NOT include the phrase 'FINAL ANSWER:' in the output. Return only the final clean answer string.\n\n"
-            "Now analyze and respond to the user question appropriately."
+                    "You are a multi-agent AI system that routes questions **and** produces "
+                    "the final answer.\n\n"
+
+                    "– If the question already *contains* the needed information "
+                    "(e.g. encoded, reversed, maths puzzle), **answer directly** – "
+                    "no tools, no sub-agents.\n\n"     
+
+                    "You have four specialised agents:\n"
+                    "• File-Agent – files (PDF, DOCX, …)\n"
+                    "• YouTube-Agent – video transcripts\n"
+                    "• WebSearch-Agent – fresh/general web info\n"
+                    "• Image-Agent – vision questions\n\n"
+
+                    "When you delegate, do **not** add commentary such as "
+                    "'I will await the agent's response'.\n"
+                    "When you answer yourself, end with:\n"
+                    "    FINAL ANSWER: <clean answer>\n\n"
+
+                    "Example ➊  (self-contained)\n"
+                    'Q: "opposite of north"..."\n'
+                    "A: FINAL ANSWER: south\n\n"
+
+                    "Example ➋  (delegation)\n"
+                    "Q: Who wrote Dune?\n"
+                    "A: Action: handoff\n"
+                    'Action Input: {"to_agent":"websearch_agent","reason":"needs web"}\n'
         )
+
     
     def _setup_tools(self):
         """Initialize all the tools."""
@@ -278,7 +502,10 @@ class BasicAgent:
         self.ddg_tool = FunctionTool.from_defaults(
             fn=duckduckgo_search_and_scrape,
             name="web_search",
-            description="Performs a DuckDuckGo search and scrapes the top relevant link and fetch the webpage content of the link to answer the question."
+            description=(
+                "Performs a DuckDuckGo search, attempts to scrape each top result, "
+                "and falls back to result metadata if scraping fails."
+            )
         )
         
         self.image_processing_tool = FunctionTool.from_defaults(
@@ -289,16 +516,29 @@ class BasicAgent:
     
     def _setup_agents(self):
         """Initialize all the specialized agents."""
+
+        self.reasoning_agent = ReActAgent(
+            name="reasoning_agent",
+            description="Router and on-board reasoning.",
+            system_prompt=REASONING_PROMPT,
+            tools=[],                # no direct tools – only `handoff` is implicit
+            llm=self.llm,
+        )
+
         # File Parsing ReActAgent
         self.file_agent = ReActAgent(
             name="file_agent",
             description="Expert at reading and extracting info from files",
-            system_prompt="""You are a precise file analyst. 
-                                Steps to follow:
-                                1. Check if there's a file URL in the question
-                                2. Use parse_file tool to examine the file
-                                3. For all file types except images, extract content and answer
-                                4. Never attempt to analyze images yourself""",
+            system_prompt="""You are File-Agent.
+                            A router has already chosen you because the user’s question involves a
+                            non-image file (PDF, DOCX, XLSX, CSV, TXT, MP3, …).
+                            Rules
+                            1. ALWAYS call the tool `parse_file(file_url, file_type?)` **once** to read
+                            the file.
+                            2. Use ONLY the file content to answer the user.
+                            3. NEVER hand the task to another agent and NEVER mention you are using a tool.
+                            4. When you are done, reply with one line in this exact format:
+                            FINAL ANSWER: <clean answer text>""",
             tools=[self.file_parser_tool],
             llm=self.llm,
         )
@@ -307,7 +547,17 @@ class BasicAgent:
         self.youtube_agent = ReActAgent(
             name="youtube_agent",
             description="Expert at extracting info from YouTube videos by transcript.",
-            system_prompt="You are a video analyst. For YouTube questions, fetch and summarize or quote the video transcript.",
+            system_prompt="""
+                            You are YouTube-Agent.
+                            The router picked you because the question references a YouTube video.
+
+                            Rules
+                            1. ALWAYS call `get_youtube_transcript(url)` once.
+                            2. Base your answer ONLY on the transcript you receive.
+                            3. Do NOT search the web, do NOT invoke other tools.
+                            4. End with:
+                            FINAL ANSWER: <clean answer text>
+                        """,
             tools=[self.youtube_transcript_tool],
             llm=self.llm,
         )
@@ -315,26 +565,42 @@ class BasicAgent:
         # DuckDuckGo Web Search ReActAgent
         self.search_agent = ReActAgent(
             name="websearch_agent",
-            description="Web search expert. ALWAYS use the web search tool for any question you receive. Do NOT just say you are searching.",
+            description="Web search expert.",
             system_prompt=(
-                "You are a web researcher. For any question, always use the DuckDuckGo search tool to get an answer. "
-                "Never ask the user to wait. Do not simply state that you are searching. "
-                "Return the answer from the tool as your only reply."
+                "You are WebSearch-Agent.\n"
+                "1. ALWAYS call the tool `web_search` exactly once.\n"
+                "2. Read the text the tool returns and craft a concise answer to the user.\n"
+                "3. Do NOT quote the entire extract; use only the facts needed.\n"
+                "4. Finish with:\n"
+                "   FINAL ANSWER: <clean answer text>"
+                "...\n"
+                "Example\n"
+                "User: Who wrote the novel Dune?\n"
+                "Tool output: Here is content scraped from https://en.wikipedia.org/wiki/Dune_(novel): ... Frank Herbert ... Based on this, please answer the original question.\n"
+                "Assistant: FINAL ANSWER: Frank Herbert\n"
             ),
             tools=[self.ddg_tool],
             llm=self.llm,
         )
 
+
         # Image Agent
         self.image_agent = ReActAgent(
             name="image_agent",
             description="Analyzes images and answers questions using the image_processing tool.",
             system_prompt=(
-                "You are a vision specialist. For *every* user query involving an image, "
-                "you **must** issue exactly one tool call:\n\n"
-                "```\nAction: image_processing\n"
-                "Action Input: {\"file_url\": <url>, \"question\": <user question>}\n```"
-                "\nThen immediately return *only* the tool's output."
+                """
+                You are Image-Agent.
+                The router picked you because the question involves an image file.
+
+                Rules
+                1. ALWAYS call the tool `image_processing(file_url, question)` exactly once.
+                2. Use ONLY the image content to answer the user.
+                3. NEVER hand the task to another agent and NEVER mention you are using a tool.
+                4. When you are done, reply with one line in this exact format:
+                FINAL ANSWER: <clean answer text>
+                """
+
             ),
             tools=[self.image_processing_tool],
             llm=self.llm,
@@ -343,22 +609,29 @@ class BasicAgent:
     def _setup_workflow(self):
         """Initialize the agent workflow."""
         self.agentflow = AgentWorkflow(
-            agents=[self.file_agent, self.youtube_agent, self.search_agent, self.image_agent],
-            root_agent=self.file_agent.name,  # the file_agent will detect image types and delegate to image_agent
+            agents=[self.reasoning_agent,         
+                    self.file_agent,
+                    self.youtube_agent,
+                    self.search_agent,
+                    self.image_agent],
+            root_agent=self.reasoning_agent.name        # start with pure reasoning
         )
-    
-    def _extract_final_answer(self, response_text: str) -> str:
-        """Extract the final answer from the response, removing 'FINAL ANSWER:' prefix if present."""
-        # Look for FINAL ANSWER: pattern and extract what comes after
-        if "FINAL ANSWER:" in response_text:
-            parts = response_text.split("FINAL ANSWER:", 1)
-            if len(parts) > 1:
-                return parts[1].strip()
         
-        # If no FINAL ANSWER: pattern found, return the full response stripped
-        return response_text.strip()
     
-    def __call__(self, question: str, task_id: str = None) -> str:
+# ─── BasicAgent._extract_final_answer ──────────────────────────────────────────
+    def _extract_final_answer(self, question: str, agent_resp) -> str:
+        raw_trace = "\n".join(block.text for block in agent_resp.response.blocks)
+        return format_final_answer(
+            question,
+            raw_trace,
+            api_key=api_key,
+            api_version=azure_api_version,
+            endpoint=azure_endpoint,
+            deployment=azure_model_name,
+        )
+
+    
+    def __call__(self, question: str, task_id: str, file_name: str, file_type = None) -> str:
         """
         Main method to process a question and return an answer.
         This method will be called by the evaluation system.
@@ -366,7 +639,8 @@ class BasicAgent:
         Args:
             question (str): The question to answer
             task_id (str, optional): Task ID for file retrieval
-            
+            file_name (str, optional): Name of the file associated with the question
+            file_type (str, optional): Type of the file (e.g., .pdf, .docx, etc.)
         Returns:
             str: The answer to the question
         """
@@ -375,28 +649,56 @@ class BasicAgent:
             # The evaluation system should provide file info in the question or via task_id
             enhanced_question = question
             
-            # If task_id is provided, we might need to construct file URL
-            if task_id:
-                # This assumes the evaluation system follows the same pattern
-                file_url = f"{self.api_url}/files/{task_id}"
-                # You might need to adjust this logic based on how files are provided
-                enhanced_question += f"\nFile URL: {file_url}"
-            
-            # Construct the full prompt with routing instructions
-            full_prompt = f"{self.routing_instruction}\n\nUser Question:\n{enhanced_question}"
+            if len(file_name) > 0:
+                file_url = f"{DEFAULT_API_URL}/files/{task_id}"
+                print(f"Processing file: {file_name} with type {file_type} at URL {file_url}")
+                enhanced_question += f"\nThis question relates to the file at {file_url} (filename: {file_name} and file type: {file_type}). Please analyze its contents using the appropriate tool."
             
-            # Run the agent workflow
-            response = asyncio.run(self.agentflow.run(user_msg=full_prompt))
             
-            # Extract and clean the final answer
-            final_answer = self._extract_final_answer(response.response.blocks[0].text)
+            # Construct the full prompt with routing instructions
+            full_prompt = f"\n\nUser Question:\n{enhanced_question}"
             
+            # Run the agent workflow with proper async handling
+            agent_resp = self._run_async_workflow(full_prompt)
+            print(f"Agent response received:\n{question}\n---\n{agent_resp}")
+
+            # Extract & return
+            final_answer = self._extract_final_answer(question, agent_resp)
+            print("Final answer extracted:", final_answer)
+            print(f"Final answer extracted: {final_answer}")
+            print("------------------------------------------------------------------------------------------------")
+            print('****************************************************************************')
             return final_answer
             
         except Exception as e:
             print(f"Error in BasicAgent.__call__: {e}")
             return f"Error processing question: {str(e)}"
 
+# ─── keep just ONE runner ────────────────────────────────────────────
+    def _run_async_workflow(self, prompt: str):
+        """
+        Call `agentflow.run()` until the response STOPs containing an
+        Action/Thought line.  Works with older llama-index that has no
+        `.initialize() / .run_step()`.
+        """
+        async def _step(msg):
+            return await self.agentflow.run(user_msg=msg)
+
+        async def _inner():
+            rsp = await _step(prompt)             # first turn
+            # If the last block is still a tool-call, keep asking “continue”
+            while rsp.response.blocks[-1].text.lstrip().lower().startswith(("action:", "thought:")):
+                rsp = await _step("continue")
+            return rsp
+
+        try:
+            loop = asyncio.get_running_loop()     # running inside Gradio
+        except RuntimeError:                      # plain Python
+            return asyncio.run(_inner())
+        else:
+            return asyncio.run_coroutine_threadsafe(_inner(), loop).result()
+
+
 # ------------------------------
 # 3. Modified answer_questions_batch function (kept for reference)
 # ------------------------------
@@ -412,10 +714,11 @@ async def answer_questions_batch(questions_data):
         question = question_data.get("question", "")
         file_name = question_data.get("file_name", "")
         task_id = question_data.get("task_id", "")
+        file_type = Path(file_name).suffix.lower().split("?")[0] if len(file_name)> 0 else None
         
         try:
             # Let the BasicAgent handle the question processing
-            answer = agent(question, task_id)
+            answer = agent(question, task_id, file_name, file_type)
             
             answers.append({
                 "task_id": task_id,
@@ -504,13 +807,14 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         try:
             # Prepare enhanced question with file information if present
             enhanced_question = question_text
-            if file_name:
+            if len(file_name) > 0:
                 file_type = Path(file_name).suffix.lower().split("?")[0]
                 file_url = f"{api_url}/files/{task_id}"
                 enhanced_question += f"\nThis question relates to the file at {file_url} (filename: {file_name} and file type: {file_type}). Please analyze its contents using the appropriate tool."
-            
+            else:
+                file_type = None
             # Call the agent
-            submitted_answer = agent(enhanced_question, task_id)
+            submitted_answer = agent(enhanced_question, task_id, file_name, file_type)
             
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})

requirements.txt

@@ -13,4 +13,5 @@ docx==0.2.4
 llama-index-embeddings-azure-openai==0.3.5 
 llama-index-llms-azure-openai==0.3.2
 beautifulsoup4
-python-dotenv
+python-dotenv
+gradio[oauth]