Update app.py

app.py

@@ -1,251 +1,262 @@
 import os
+import logging
+
 import gradio as gr
 import requests
 import pandas as pd
-import re
-import json
-from datetime import datetime
-import tempfile
-import atexit
-import sys  # Für sys.exit bei Importfehlern
-
-# --- Smol Agents und HF Imports ---
-try:
-    from smolagents import CodeAgent, tool, HfApiModel
-    print("Successfully imported CodeAgent, tool, HfApiModel from 'smolagents'")
-except ImportError as e:
-    print(f"Error importing from smolagents: {e}")
-    print("Please ensure 'smolagents[huggingface]' is listed correctly in requirements.txt")
-    sys.exit(f"Fatal Error: Could not import smolagents components. Original error: {e}")
-
-from huggingface_hub import HfApi
-
-# --- Suchtool Imports ---
-USE_TAVILY = False
-USE_DUCKDUCKGO = True
-if USE_TAVILY:
-    try:
-        from tavily import TavilyClient
-    except ImportError:
-        print("WARNUNG: TavilyClient nicht installiert.")
-        USE_TAVILY = False
-        USE_DUCKDUCKGO = True
-if USE_DUCKDUCKGO:
-    try:
-        from duckduckgo_search import DDGS
-    except ImportError:
-        print("WARNUNG: duckduckgo-search nicht installiert.")
-        USE_DUCKDUCKGO = False
+# We still need the openai library, even if we change the endpoint
+from openai import OpenAI
+
+from smolagents import CodeAgent, DuckDuckGoSearchTool, tool
+from smolagents.models import OpenAIServerModel # Assuming this can handle base_url
+
+# --- Logging ---
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
 
-# --- PDF Reader Import ---
+# --- Constants ---
+DEFAULT_API_URL   = "https://agents-course-unit4-scoring.hf.space" # Keep this for submission
+
+# --- GitHub Models Configuration ---
+# Use GITHUB_TOKEN environment variable for authentication
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
+if not GITHUB_TOKEN:
+    # If running locally and GITHUB_TOKEN is not set, you might fall back
+    # to another mechanism or raise an error. For HF Spaces, secrets are needed.
+    raise RuntimeError("Please set GITHUB_TOKEN in your Space secrets.")
+
+# GitHub Models endpoint
+GITHUB_ENDPOINT = "https://models.github.ai/inference"
+
+# Specify the model ID compatible with the GitHub endpoint
+# Check GitHub Models documentation for available models. 'gpt-4.1' might not be the correct identifier.
+# Let's assume a common format like 'openai/gpt-4o' or similar, adjust as needed.
+# Using 'openai/gpt-4.1' as a placeholder based on your original code, VERIFY THIS with GitHub Models docs.
+MODEL_ID = os.getenv("MODEL_ID", "openai/gpt-4.1") # Renamed for clarity, adjust if needed
+
+# --- Configure OpenAI SDK (for tools if needed, now using GitHub endpoint) ---
+# This client might be used by tools OR potentially by OpenAIServerModel internally
+# depending on its implementation. Configuring it ensures consistency.
+# Note: If OpenAIServerModel directly instantiates its own client using the parameters
+# we provide later, this specific 'client' instance might not be used by the agent itself.
 try:
-    import PyPDF2
-    PDF_READER_AVAILABLE = True
-except ImportError:
-    PDF_READER_AVAILABLE = False
-    print("WARNUNG: PyPDF2 nicht installiert. PDF-Lesefunktion deaktiviert.")
-
-# --- Konstanten & Globals ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-HF_MODEL_ID = os.getenv("HF_MODEL_ID", "meta-llama/Meta-Llama-3-8B-Instruct")
-search_client = None
-agent_instance = None
-
-temp_files_to_clean = set()
-
-def cleanup_temp_files():
-    for path in list(temp_files_to_clean):
-        try:
-            if os.path.exists(path): os.remove(path)
-        except OSError:
-            pass
-        temp_files_to_clean.discard(path)
-atexit.register(cleanup_temp_files)
+    client = OpenAI(
+        base_url=GITHUB_ENDPOINT,
+        api_key=GITHUB_TOKEN,
+    )
+    # Optional: Test connection or a simple call here if needed during setup
+    # client.models.list() # Example call, might need adjustment for GitHub's API structure
+except Exception as e:
+    logger.error(f"Failed to initialize OpenAI client for GitHub Models: {e}")
+    # Decide how to handle this - raise error, log warning, etc.
+    raise RuntimeError(f"OpenAI client initialization failed for GitHub Models: {e}") from e
+
+
+# --- Tools ---
+# Tools remain the same, assuming they don't directly depend on the *specific* OpenAI API endpoint
+# unless they internally use the globally configured 'client' (which we just updated).
 
-# --- Tool Definitions ---
 @tool
-def search_web(query: str, max_results: int = 3) -> str:
+def summarize_query(query: str) -> str:
     """
-    Search the web for the given query and return a summary of the top results.
-
+    Reframes an unclear search query to improve relevance.
     Args:
-        query (str): The search query to look up online.
-        max_results (int): The maximum number of search results to retrieve.
-
+        query (str): The original search query.
     Returns:
-        str: A concatenated string summarizing the URLs and snippets of the results.
+        str: A concise, improved version.
     """
-    if not search_client:
-        return "Error: Search tool not configured."
-    try:
-        if USE_TAVILY and isinstance(search_client, TavilyClient):
-            res = search_client.search(query=query, search_depth="basic", max_results=max_results)
-            items = res.get('results', [])
-            if not items:
-                return "No search results found."
-            return "\n".join([f"URL: {i['url']}\nContent: {i.get('content','')[:200]}..." for i in items])
-        elif USE_DUCKDUCKGO and isinstance(search_client, DDGS):
-            results = search_client.text(query, max_results=max_results)
-            if not results:
-                return "No search results found."
-            return "\n".join([f"Title: {r['title']}\nURL: {r['href']}\nSnippet: {r['body'][:200]}..." for r in results])
-        else:
-            return "Error: No compatible search client available."
-    except Exception as e:
-        return f"Error during search: {e}"
+    # This tool currently doesn't use an LLM, so it's unaffected by the endpoint change.
+    # If it *did* use the 'client' instance, it would now point to GitHub Models.
+    return f"Summarize and reframe: {query}"
 
 @tool
-def download_task_file(task_id: str) -> str:
+def wikipedia_search(page: str) -> str:
     """
-    Download the file associated with a specific task ID from the evaluation server.
-
+    Fetches the summary extract of an English Wikipedia page.
     Args:
-        task_id (str): Unique identifier of the task whose file should be downloaded.
-
+        page (str): e.g. 'Mercedes_Sosa_discography'
     Returns:
-        str: Local filesystem path to the downloaded file, or an error message.
+        str: The page’s extract text.
     """
-    url = f"{DEFAULT_API_URL}/files/{task_id}"
     try:
-        response = requests.get(url, stream=True, timeout=30)
-        response.raise_for_status()
-        content_type = response.headers.get('content-type', '')
-        suffix = '.pdf' if 'pdf' in content_type else '.tmp'
-        tmp_dir = tempfile.gettempdir()
-        filename = f"task_{task_id}_{datetime.now().strftime('%Y%m%d%H%M%S')}{suffix}"
-        path = os.path.join(tmp_dir, filename)
-        with open(path, 'wb') as f:
-            for chunk in response.iter_content(8192): f.write(chunk)
-        temp_files_to_clean.add(path)
-        return path
+        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{page}"
+        r = requests.get(url, timeout=10)
+        r.raise_for_status()
+        return r.json().get("extract", "")
     except Exception as e:
-        return f"Error: {e}"
+        logger.exception("Wikipedia lookup failed")
+        return f"Wikipedia error: {e}"
 
-@tool
-def read_file_content(file_path: str) -> str:
-    """
-    Read the text content of a previously downloaded file (PDF or plain text).
+search_tool    = DuckDuckGoSearchTool()
+wiki_tool      = wikipedia_search
+summarize_tool = summarize_query
 
-    Args:
-        file_path (str): Absolute local path to the file to read (from download_task_file).
+# --- ReACT Prompt ---
+# The prompt itself doesn't need to change as it describes the agent's *behavior*
+instruction_prompt = """
+You are a ReACT agent with three tools:
+ • DuckDuckGoSearchTool(query: str)
+ • wikipedia_search(page: str)
+ • summarize_query(query: str)
+Internally, for each question:
+1. Thought: decide which tool to call.
+2. Action: call the chosen tool.
+3. Observation: record the result.
+4. If empty/irrelevant:
+   Thought: retry with summarize_query + DuckDuckGoSearchTool.
+   Record new Observation.
+5. Thought: integrate observations.
+Finally, output your answer with the following template:
+FINAL ANSWER: [YOUR FINAL ANSWER].
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings.
+If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise.
+If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise.
+If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+"""
 
-    Returns:
-        str: Extracted text content truncated if necessary, or an error message.
-    """
-    if not file_path.startswith(tempfile.gettempdir()):
-        return "Error: Invalid file path."
-    if not os.path.exists(file_path):
-        return "Error: File does not exist."
+# --- Build the Agent with OpenAIServerModel pointing to GitHub Models ---
+
+# *** Key Change Here ***
+# We configure OpenAIServerModel to use the GitHub endpoint and token.
+# We assume OpenAIServerModel accepts 'api_base' or 'base_url' and passes it
+# to the underlying OpenAI client it creates. 'base_url' is the modern parameter.
+# If this doesn't work, you might need to check the smolagents documentation
+# or source for how to specify a custom endpoint, or potentially subclass/modify it.
+try:
+    model = OpenAIServerModel(
+        model_id=MODEL_ID,         # Use the model ID for GitHub
+        api_key=GITHUB_TOKEN,      # Use the GitHub token as the API key
+        api_base=GITHUB_ENDPOINT   # Specify the GitHub endpoint *** Use api_base or base_url ***
+        # Try base_url if api_base doesn't work:
+        # base_url=GITHUB_ENDPOINT
+        # Add any other necessary parameters required by OpenAIServerModel or the underlying client
+        # e.g., model_kwargs if needed
+    )
+    logger.info(f"Configured OpenAIServerModel with GitHub endpoint: {GITHUB_ENDPOINT} and model: {MODEL_ID}")
+except TypeError as te:
+    logger.error(f"TypeError configuring OpenAIServerModel: {te}. Trying with 'base_url' instead of 'api_base'.")
+    # Fallback attempt using base_url if api_base caused a TypeError
     try:
-        if file_path.lower().endswith('.pdf'):
-            if not PDF_READER_AVAILABLE:
-                return "Error: PyPDF2 not installed."
-            text = ''
-            with open(file_path, 'rb') as f:
-                reader = PyPDF2.PdfReader(f)
-                for page in reader.pages:
-                    text += page.extract_text() or ''
-                    if len(text) > 7000:
-                        text = text[:7000] + '\n... (truncated)'
-                        break
-            return text
-        else:
-            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
-                return f.read(7000)
+        model = OpenAIServerModel(
+            model_id=MODEL_ID,
+            api_key=GITHUB_TOKEN,
+            base_url=GITHUB_ENDPOINT # Use base_url
+        )
+        logger.info(f"Successfully configured OpenAIServerModel with GitHub endpoint using 'base_url'.")
     except Exception as e:
-        return f"Error: {e}"
-
-# --- Agent Setup ---
-def initialize_agent():
-    global search_client, agent_instance
-    if search_client is None:
-        if USE_TAVILY:
-            key = os.getenv('TAVILY_API_KEY')
-            search_client = TavilyClient(api_key=key) if key else False
-        elif USE_DUCKDUCKGO:
-            try:
-                search_client = DDGS()
-            except:
-                search_client = False
-        else:
-            search_client = False
-    token = os.getenv('HUGGINGFACE_TOKEN')
-    if not token:
-        raise ValueError("HUGGINGFACE_TOKEN environment variable is required.")
-    hf_model = HfApiModel()
-    tools = [search_web, download_task_file, read_file_content]
-    if not search_client:
-        tools.remove(search_web)
-    agent_instance = CodeAgent(tools=tools, model=hf_model)
-
-# --- Main Logic ---
-def run_and_submit_all(profile, progress=gr.Progress(track_tqdm=True)):
-    # Parse profile if passed as JSON string
-    if isinstance(profile, str):
+        logger.error(f"Failed to configure OpenAIServerModel with both 'api_base' and 'base_url': {e}")
+        raise RuntimeError(f"Could not configure SmolAgents model for GitHub endpoint: {e}") from e
+except Exception as e:
+    logger.error(f"Failed to configure OpenAIServerModel: {e}")
+    raise RuntimeError(f"Could not configure SmolAgents model for GitHub endpoint: {e}") from e
+
+
+smart_agent = CodeAgent(
+    tools=[search_tool, wiki_tool, summarize_tool],
+    model=model # Pass the configured model instance
+)
+
+# --- Gradio Wrapper ---
+
+class BasicAgent:
+    def __init__(self):
+        # Updated log message
+        logger.info(f"Initialized SmolAgent with GitHub Model: {MODEL_ID} via {GITHUB_ENDPOINT}")
+
+    def __call__(self, question: str) -> str:
+        if not question.strip():
+            return "AGENT ERROR: empty question"
+        prompt = instruction_prompt.strip() + "\n\nQUESTION: " + question.strip()
         try:
-            profile = json.loads(profile)
-        except json.JSONDecodeError:
-            return "Error: Invalid profile format.", None
-    if not profile or 'username' not in profile:
-        return "Bitte zuerst einloggen.", None
-    username = profile['username']
+            # The agent uses the 'model' instance we configured above
+            return smart_agent.run(prompt)
+        except Exception as e:
+            logger.exception("Agent run error")
+            # Provide more specific error if possible, e.g., AuthenticationError from OpenAI client
+            return f"AGENT ERROR: {e}"
+
+# --- Submission Logic ---
+# This part remains largely the same, as it interacts with the external scoring service (DEFAULT_API_URL)
+# It just uses the 'agent' which now internally calls GitHub Models.
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    if not profile:
+        return "Please log in to Hugging Face.", None
 
+    username   = profile.username
+    space_id   = os.getenv("SPACE_ID", "")
+    # Link to the code, unchanged
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    # Instantiate the agent wrapper, which now uses the GitHub-configured model
+    agent      = BasicAgent()
+
+    # fetch questions (unchanged)
     try:
-        initialize_agent()
+        resp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
+        resp.raise_for_status()
+        questions = resp.json() or []
     except Exception as e:
-        return f"Initialization Error: {e}", None
-
-    # Fetch questions
-    resp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=30)
-    resp.raise_for_status()
-    questions = resp.json()
+        logger.exception("Failed fetch")
+        return f"Error fetching questions: {e}", None
 
     logs, payload = [], []
-    for item in progress.tqdm(questions, desc="Bearbeite Fragen"):
-        task_id = item.get('task_id')
-        question = item.get('question')
-        if not task_id or question is None:
+    for item in questions:
+        tid = item.get("task_id")
+        q   = item.get("question")
+        if not tid or not q:
             continue
-        prompt = f"Task {task_id}: {question}"
-        try:
-            result = agent_instance.run(prompt=prompt)
-            answer = re.sub(r"^(Answer:|Final Answer:)", "", result or "").strip()
-        except Exception as e:
-            answer = f"ERROR: {e}"
-        logs.append({'Task ID': task_id, 'Question': question, 'Submitted Answer': answer})
-        payload.append({'task_id': task_id, 'submitted_answer': answer})
+        # Run the agent (now using GitHub Models)
+        ans = agent(q)
+        logs.append({"Task ID": tid, "Question": q, "Submitted Answer": ans})
+        payload.append({"task_id": tid, "submitted_answer": ans})
 
-    df = pd.DataFrame(logs)
+    if not payload:
+        return "Agent did not produce any answers.", pd.DataFrame(logs)
 
-    # Submit answers
-    submission = {'username': username, 'agent_code': '...', 'answers': payload}
+    # submit answers (unchanged)
     try:
-        post = requests.post(f"{DEFAULT_API_URL}/submit", json=submission, timeout=180)
+        post = requests.post(
+            f"{DEFAULT_API_URL}/submit",
+            json={"username": username, "agent_code": agent_code, "answers": payload},
+            timeout=60
+        )
         post.raise_for_status()
-        score = post.json().get('score', 0)
-        status = f"Erfolg! Score: {score:.2f}%"
+        result = post.json()
+        status = (
+            f"Submission Successful!\n"
+            f"User: {result.get('username')}\n"
+            f"Score: {result.get('score','N/A')}%\n"
+            f"({result.get('correct_count','?')}/"
+            f"{result.get('total_attempted','?')})\n"
+            f"Message: {result.get('message','')}"
+        )
+        return status, pd.DataFrame(logs)
     except Exception as e:
-        status = f"Submission Error: {e}"
+        logger.exception("Submit failed")
+        return f"Submission Failed: {e}", pd.DataFrame(logs)
 
-    cleanup_temp_files()
-    return status, df
+# --- Gradio App ---
 
-# --- Gradio UI ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Smol CodeAgent Evaluation Runner")
-    gr.Markdown("Bitte einloggen und dann auf "Run Evaluation & Submit All Answers" klicken.")
-    with gr.Row():
-        login_btn = gr.LoginButton()
-    run_btn = gr.Button("Run Evaluation & Submit All Answers")
-    out_status = gr.Textbox(label="Status", lines=5)
-    out_table = gr.DataFrame(label="Ergebnisse")
-
-    run_btn.click(
-        fn=run_and_submit_all,
-        inputs=[login_btn],
-        outputs=[out_status, out_table],
-        api_name="run_evaluation_smol_codeagent"
-    )
+    gr.Markdown("# SmolAgent GAIA Runner (using GitHub Models) 🚀") # Updated title
+    gr.Markdown("""
+**Instructions:**
+1. Clone this space.
+2. In Settings → Secrets, add `GITHUB_TOKEN` (your GitHub access token with appropriate permissions for GitHub Models).
+3. Optionally, set `MODEL_ID` if you want to use a model other than the default (e.g., `openai/gpt-4o`). Verify the correct model identifier for GitHub Models.
+4. Log in to Hugging Face.
+5. Click **Run Evaluation & Submit All Answers**.
+""") # Updated instructions
+    gr.LoginButton()
+    btn = gr.Button("Run Evaluation & Submit All Answers")
+    out_status = gr.Textbox(label="Status", lines=5, interactive=False)
+    out_table  = gr.DataFrame(label="Questions & Answers", wrap=True)
+    btn.click(run_and_submit_all, outputs=[out_status, out_table])
 
-if __name__ == '__main__':
-    demo.queue().launch(debug=False, share=False)
+if __name__ == "__main__":
+    # Check GITHUB_TOKEN presence before launching
+    if not GITHUB_TOKEN:
+        logger.error("GITHUB_TOKEN environment variable not set. Cannot start.")
+    else:
+        logger.info("Launching Gradio App...")
+        demo.launch(debug=True, share=False) # Set debug=False for production