Update app.py

app.py

@@ -13,70 +13,102 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 import os
 from huggingface_hub import InferenceClient
-from langchain_core.tools import Tool
-from ddgs import DDGS
 from langchain_core.prompts import PromptTemplate
+from ddgs import DDGS
 import re
 
 class BasicAgent:
     def __init__(self):
+        print("BasicAgent initialized with Llama-3.1-70B-Instruct + DDGS search")
         self.client = InferenceClient(
             model="meta-llama/Meta-Llama-3.1-70B-Instruct",
             token=os.getenv("HF_TOKEN")
         )
-        # Define tools
-        self.search = DuckDuckGoSearchRun()  # Web search tool
-        self.tools = {
-            "web_search": Tool(
-                name="web_search",
-                func=self.search.run,
-                description="Search the web for current or historical facts. Input: query string."
-            )
-        }
-        self.tool_names = list(self.tools.keys())
+
+    def search_web(self, query: str) -> str:
+        """Simple DuckDuckGo search helper"""
+        try:
+            with DDGS() as ddgs:
+                results = list(ddgs.text(query, max_results=5))
+                if not results:
+                    return "No results found."
+                formatted = []
+                for r in results:
+                    title = r.get("title", "N/A")
+                    body = r.get("body", "N/A")
+                    href = r.get("href", "N/A")
+                    formatted.append(f"{title}\n{body}\n{href}")
+                return "\n\n".join(formatted)
+        except Exception as e:
+            return f"Search error: {str(e)[:400]}"
 
     def __call__(self, question: str) -> str:
-        # ReAct prompt: Guides model to think, act, observe
-        react_prompt = PromptTemplate.from_template("""
-You are an AI agent solving GAIA questions. Answer exactly, no extra text.
+        prompt_template = PromptTemplate.from_template("""
+You are solving a GAIA Level 1 question. Your goal is to give **only** the exact final answer — no extra words.
 
 Rules:
-- Think step-by-step: Thought, Action (if needed), Observation, then repeat until Final Answer.
-- Use tools only if necessary: Available tools: {tool_names}.
-- For Action: Output 'Action: tool_name [input]'.
-- Stop with 'Final Answer: <exact answer>'.
-- Be precise, no punctuation unless needed.
+- Think step by step using format: Thought: ... → Action: web_search[query] → Observation: ... → Thought: ...
+- Use the tool **only** when you need external information or verification.
+- Tool format must be exactly: Action: web_search[your precise query]
+- When confident → output exactly: Final Answer: <short exact answer>
+- No punctuation at the end unless part of the answer.
+- Keep observations short when reasoning.
+
+Available tool: web_search
 
 Question: {question}
 
 Thought:
 """)
-        prompt = react_prompt.format(question=question, tool_names=", ".join(self.tool_names))
-        
-        max_steps = 5  # Limit for Level 1
-        response = ""
-        for _ in range(max_steps):
-            # Generate next step
-            gen = self.client.text_generation(prompt + response, max_new_tokens=200, temperature=0.1)
-            response += gen
-            
-            # Parse Action if present
-            action_match = re.search(r"Action: (\w+) \[(.*)\]", response)
-            if action_match:
-                tool_name, tool_input = action_match.groups()
-                if tool_name in self.tools:
-                    obs = self.tools[tool_name].func(tool_input)
-                    response += f"\nObservation: {obs[:1000]}...\nThought: "  # Truncate long obs
-                else:
-                    response += "\nObservation: Invalid tool.\nThought: "
-            # Check for Final Answer
-            if "Final Answer:" in response:
-                answer = response.split("Final Answer:")[-1].strip().split("\n")[0].strip()
-                return answer.replace(".", "").replace(",", "").strip()  # Normalize as in your code
-        
-        return "Unable to answer"  # Fallback
 
+        full_prompt_start = prompt_template.format(question=question)
+
+        max_steps = 6
+        history = ""
+
+        for step in range(max_steps):
+            current_prompt = full_prompt_start + history
+
+            try:
+                generation = self.client.text_generation(
+                    current_prompt,
+                    max_new_tokens=320,
+                    temperature=0.12,
+                    stop_sequences=["Final Answer:", "Observation:"]
+                )
+            except Exception as e:
+                print(f"Generation failed: {e}")
+                return "Generation error"
+
+            new_text = generation.strip()
+            history += new_text + "\n"
+
+            # Look for tool call
+            action_match = re.search(
+                r"Action:\s*web_search\s*\[([^\]]+)\]",
+                history,
+                re.IGNORECASE | re.DOTALL
+            )
 
+            if action_match:
+                query = action_match.group(1).strip()
+                print(f"Tool call → {query}")
+                observation = self.search_web(query)
+                obs_short = observation[:1400] + "..." if len(observation) > 1400 else observation
+                history += f"\nObservation: {obs_short}\nThought: "
+
+            # Look for final answer
+            if "Final Answer:" in history:
+                parts = history.split("Final Answer:")
+                answer_part = parts[-1].strip()
+                # Take first clean line, remove trailing punctuation if not needed
+                answer = answer_part.split("\n")[0].strip()
+                answer = answer.replace(".", "").replace(",", "").strip()
+                print(f"→ Final answer: {answer}")
+                return answer
+
+        print("Max steps reached - no final answer")
+        return "Unable to answer"
 
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):