Harden GAIA agent: provider fallback, rate-limit pacing, context trimming

Scored 45% (9/20) on the official scoring API, up from a baseline that could
not complete a run at all. All changes stay within the existing single-file
CodeAgent architecture; no framework or tooling was swapped.

Model access
- Pin the model id explicitly instead of relying on the smolagents default,
which changes between releases and made Space rebuilds non-reproducible.
- Support any OpenAI-compatible endpoint via GAIA_BASE_URL/GAIA_API_KEY, since
HF's free monthly credits return 402 on every call once depleted, failing all
20 questions at once.
- GAIA_MODEL_ID accepts a comma-separated chain; exhausting one model's daily
token quota switches to the next rather than ending the run.

Rate limits
- Pace requests below the provider ceiling (GAIA_RPM) instead of discovering it
through 429s.
- Honour the provider's own retry hint; a blind doubling backoff was routinely
shorter than the interval the server asked for.
- Disable smolagents' internal retryer. Its 3 attempts at 60s base, doubling and
jittered, ran inside our own attempts, so one throttled call could sleep for
over half an hour.
- Fail fast on daily-quota and 413 errors. Both arrive dressed as rate limits
but no backoff clears them, and retrying burned the wall-clock left for the
remaining questions.
- Retry the 400 "Tool choice is none, but model called a tool" rejection; it is
a sampling artifact that clears on resample.

Context growth
- Trim older steps' observations and model output via a step callback. Every
past step is replayed into every later call, so trajectories grew until a
single request exceeded the per-minute token limit outright.
- Give web_search and visit_webpage smaller output budgets than the library
defaults for the same reason.

Correctness and robustness
- Send a descriptive User-Agent from visit_webpage; the stock tool sends none
and Wikipedia answers 403.
- Tell the agent explicitly when an attachment could not be retrieved, so it
stops inventing file contents. All five attachments 404 server-side.
- Retry transient web_search failures rather than burning an agent step.
- Raise max_steps and authorise a few more stdlib imports for multi-hop
research questions.
- Add a dev-only single-question runner to the UI; it submits nothing.
- Fix a startup log line that double-appended .hf.space to SPACE_HOST.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,4 @@
+.venv/
+__pycache__/
+*.pyc
+.gaia_env

app.py

@@ -1,7 +1,9 @@
 import spaces  # must be the first import — required by ZeroGPU Spaces
 
 import os
+import re
 import tempfile
+import time
 from pathlib import Path
 from typing import Optional
 
@@ -9,11 +11,17 @@ import gradio as gr
 import requests
 import pandas as pd
 
-from smolagents import CodeAgent, InferenceClientModel
+from smolagents import CodeAgent, InferenceClientModel, OpenAIServerModel
+from smolagents.default_tools import DuckDuckGoSearchTool, VisitWebpageTool
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+# Pinned explicitly rather than relying on InferenceClientModel's own default,
+# which changes between smolagents releases. The GAIA_MODEL_ID env var still
+# overrides this if a different model is ever needed.
+DEFAULT_MODEL_ID = "meta-llama/Llama-3.3-70B-Instruct"
+
 # This Space's free-tier hardware is ZeroGPU, which refuses to start unless
 # at least one function is decorated with @spaces.GPU. The agent itself never
 # touches a GPU (it only calls HF Inference Providers over HTTP), so this
@@ -22,6 +30,12 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 def _zerogpu_startup_check():
     return None
 
+# Free provider tiers cap requests per minute (Google's Gemini free tier
+# reports "limit: 20" for gemini-2.5-flash). Pacing our own calls below that
+# ceiling is far cheaper than discovering it via 429s and backoff. Override
+# with GAIA_RPM when moving to a tier with a different budget.
+DEFAULT_REQUESTS_PER_MINUTE = 15.0
+
 # Instructions appended to every question so the CodeAgent behaves like a
 # GAIA-solving agent rather than a free-form chatbot. Kept as plain task
 # framing (not a tool) to avoid adding moving parts.
@@ -34,22 +48,223 @@ Rules:
    sorting, filtering, or any data processing rather than doing it in your head.
 4. If an attachment path is given below, open and inspect it with Python
    before answering — never guess its contents.
-5. Where practical, verify an important intermediate result a second way
+5. If web_search fails or comes back empty, do not give up on the step: retry
+   with a differently worded query, or call visit_webpage directly on a likely
+   source URL (for example
+   https://en.wikipedia.org/w/index.php?search=YOUR+QUERY, or the article URL
+   itself). Do not try to import external packages such as wikipedia,
+   requests-html, bs4 or googlesearch — they are not installed, and attempting
+   them only wastes a step.
+6. Where practical, verify an important intermediate result a second way
    before finalizing.
-6. Call final_answer(...) with ONLY the exact value requested:
+7. Call final_answer(...) with ONLY the exact value requested:
    - a bare number (no commas, no units unless the question asks for units)
    - a bare string (no "The answer is", no trailing period, no quotes)
-   - a comma-separated list only if asked for a list, formatted exactly as
-     requested (spacing, order, etc.)
+   - a comma-separated list only if asked for a list, in exactly the order the
+     question asks for; separate elements with a comma and a single space
+     unless the question specifies a different separator
    Do not include your reasoning or the words "FINAL ANSWER" in that value.
 """
 
-MAX_STEPS = 10
+MAX_STEPS = 12
 ADDITIONAL_IMPORTS = [
     "pandas", "numpy", "csv", "json", "re", "math", "statistics",
     "datetime", "itertools", "collections", "io", "os", "pypdf", "openpyxl",
+    "requests", "unicodedata", "time",
 ]
 
+# Every past step's observations are replayed into every later model call, so a
+# trajectory grows quadratically and eventually exceeds what a free tier will
+# accept in one request — Groq returns HTTP 413 "Request too large ... Limit
+# 12000, Requested 12396" and no amount of waiting fixes it, because a single
+# call already exceeds the whole per-minute budget. Recent observations are what
+# the agent is reasoning about; older ones only need to stay recognizable.
+RECENT_STEPS_KEPT_FULL = 2
+RECENT_OBSERVATION_CHARS = 8000
+OLDER_OBSERVATION_CHARS = 1500
+# The model's own output is replayed as an assistant message too, and reasoning
+# models are verbose enough that untrimmed history alone can breach the limit.
+# The code it wrote is the part worth keeping, so older steps keep only a head.
+RECENT_OUTPUT_CHARS = 4000
+OLDER_OUTPUT_CHARS = 1000
+
+
+def trim_observations(memory_step, agent=None) -> None:
+    """Step callback: shrink observations of all but the newest few steps.
+
+    Registered on ActionStep, so it runs after each action and keeps the next
+    request inside the provider's per-request ceiling.
+    """
+    def _clip(text, budget):
+        if not isinstance(text, str) or len(text) <= budget:
+            return text
+        return (
+            text[:budget]
+            + f"\n...[{len(text) - budget} characters truncated to stay within "
+              f"the model's request size limit]"
+        )
+
+    steps = [s for s in getattr(agent, "memory", None).steps if hasattr(s, "observations")]
+    for index, step in enumerate(steps):
+        is_recent = index >= len(steps) - RECENT_STEPS_KEPT_FULL
+        if step.observations:
+            step.observations = _clip(
+                step.observations,
+                RECENT_OBSERVATION_CHARS if is_recent else OLDER_OBSERVATION_CHARS,
+            )
+        if step.model_output:
+            step.model_output = _clip(
+                step.model_output,
+                RECENT_OUTPUT_CHARS if is_recent else OLDER_OUTPUT_CHARS,
+            )
+
+
+class RetryingWebSearchTool(DuckDuckGoSearchTool):
+    """Same tool the base toolkit provides, but a rate-limited or flaky
+    DuckDuckGo response is retried instead of burning one of the agent's
+    steps. Name/description/signature are inherited unchanged, so the agent's
+    system prompt is identical to the stock tool's."""
+
+    max_attempts = 3
+    backoff_seconds = 3.0
+
+    def forward(self, query: str) -> str:
+        last_error = None
+        for attempt in range(self.max_attempts):
+            try:
+                return super().forward(query)
+            except Exception as e:
+                last_error = e
+                print(f"web_search attempt {attempt + 1}/{self.max_attempts} failed: {e}")
+                if attempt < self.max_attempts - 1:
+                    time.sleep(self.backoff_seconds * (attempt + 1))
+        raise RuntimeError(
+            f"web_search failed after {self.max_attempts} attempts: {last_error}. "
+            "Try visit_webpage on a likely source URL instead."
+        )
+
+
+class _RetryOnThrottleMixin:
+    """Retries transient rate-limit / server errors from the inference endpoint.
+    Free provider tiers throttle aggressively, and without this a single 429
+    aborts the whole question. Non-transient errors (401, 402 out of credits,
+    400 bad request) are re-raised immediately — retrying those is pointless.
+
+    Both model classes below are constructed with retry=False, which disables
+    smolagents' own retryer. Leaving it on nests two exponential backoffs: its
+    3 attempts (60s base, doubling, jittered) run inside each of our attempts,
+    so one throttled call can sleep for over half an hour. This layer replaces
+    it because it can read the provider's own retry hint instead of guessing."""
+
+    max_attempts = 6
+    backoff_seconds = 20.0
+    RETRYABLE = (
+        "429", "500", "502", "503", "504", "rate limit", "too many requests", "timeout",
+        # Some models occasionally emit a tool call where CodeAgent expects a
+        # code block, and the provider rejects the request outright with
+        # 400 "Tool choice is none, but model called a tool". It is a sampling
+        # artifact rather than a bad prompt, so re-asking usually succeeds.
+        "tool_use_failed",
+    )
+    # A per-day quota and an over-sized single request both arrive dressed as
+    # rate limits, but neither clears within any backoff we would sit through:
+    # the daily bucket refills hours later, and a request that alone exceeds the
+    # per-minute ceiling will be exactly as large on the next attempt. Failing
+    # this question immediately leaves budget and wall-clock for the rest.
+    FATAL = ("tokens per day", "tpd", "request too large", "413")
+    # Providers usually say how long to wait; obeying that beats guessing.
+    # Gemini phrases it "Please retry in 32.290648364s", OpenAI-style APIs
+    # "retry after 12 seconds".
+    _RETRY_HINT = re.compile(r"retry(?:\s+after)?\s+in\s+([0-9.]+)\s*s|retry after ([0-9.]+)")
+
+    # Filled in by GAIAAgent when GAIA_MODEL_ID lists more than one model.
+    fallback_model_ids: list = []
+
+    def generate(self, *args, **kwargs):
+        last_error = None
+        for attempt in range(self.max_attempts):
+            try:
+                return super().generate(*args, **kwargs)
+            except Exception as e:
+                message = str(e).lower()
+                if any(token in message for token in self.FATAL):
+                    # Daily quotas are per-model, so a sibling model on the same
+                    # account usually still has budget. Switching costs one call
+                    # and rescues every remaining question; without it the run
+                    # ends here no matter how much wall-clock is left.
+                    if "tokens per day" in message and self.fallback_model_ids:
+                        self.model_id = self.fallback_model_ids.pop(0)
+                        print(
+                            f"Daily token quota exhausted; switching to "
+                            f"fallback model {self.model_id}"
+                        )
+                        continue
+                    raise
+                if not any(token in message for token in self.RETRYABLE):
+                    raise
+                last_error = e
+                # A malformed generation clears on the next sample, so re-ask
+                # straight away rather than serving a rate-limit-sized backoff.
+                if "tool_use_failed" in message:
+                    wait = 1.0
+                else:
+                    wait = self.backoff_seconds * (attempt + 1)
+                hint = self._RETRY_HINT.search(message)
+                if hint:
+                    # +2s of slack so we come back after the window, not on its edge
+                    wait = max(wait, float(hint.group(1) or hint.group(2)) + 2.0)
+                print(
+                    f"Model call attempt {attempt + 1}/{self.max_attempts} failed "
+                    f"({type(e).__name__}: {str(e)[:200]}); retrying in {wait:.0f}s"
+                )
+                if attempt < self.max_attempts - 1:
+                    time.sleep(wait)
+        raise last_error
+
+
+class RetryingInferenceClientModel(_RetryOnThrottleMixin, InferenceClientModel):
+    """HF Inference Providers, with throttle retries."""
+
+
+class RetryingOpenAIServerModel(_RetryOnThrottleMixin, OpenAIServerModel):
+    """Any OpenAI-compatible endpoint, with throttle retries. InferenceClient
+    itself cannot take a model name and a base_url together, so custom
+    endpoints go through this class instead."""
+
+
+class IdentifiedVisitWebpageTool(VisitWebpageTool):
+    """The stock tool calls requests.get() with no User-Agent, so Wikipedia and
+    several other sources answer 403 Forbidden — verified against
+    en.wikipedia.org. Sending a descriptive User-Agent (as Wikimedia's bot
+    policy asks for) is the whole fix; everything else is inherited."""
+
+    USER_AGENT = (
+        "GAIA-Agent/1.0 (HF Agents Course Unit 4 final assignment; "
+        "+https://huggingface.co/spaces/sumit1703/Final_Assignment_Sumit)"
+    )
+
+    def forward(self, url: str) -> str:
+        import re
+
+        import requests as _requests
+        from markdownify import markdownify
+        from requests.exceptions import RequestException
+
+        try:
+            response = _requests.get(
+                url, timeout=20, headers={"User-Agent": self.USER_AGENT}
+            )
+            response.raise_for_status()
+            markdown_content = markdownify(response.text).strip()
+            markdown_content = re.sub(r"\n{3,}", "\n\n", markdown_content)
+            return self._truncate_content(markdown_content, self.max_output_length)
+        except _requests.exceptions.Timeout:
+            return "The request timed out. Please try again later or check the URL."
+        except RequestException as e:
+            return f"Error fetching the webpage: {str(e)}"
+        except Exception as e:
+            return f"An unexpected error occurred: {str(e)}"
+
 
 class GAIAAgent:
     """
@@ -62,35 +277,103 @@ class GAIAAgent:
         hf_token = os.environ.get("HF_TOKEN")
         model_id = os.environ.get("GAIA_MODEL_ID")  # optional override
         provider = os.environ.get("GAIA_PROVIDER")  # optional override; unset = library default ("auto")
-
-        # Fail fast and loud instead of letting all 20 questions die silently
-        # at Step 1 with a generic "api_key" error from deep inside smolagents.
-        print(f"HF_TOKEN present: {bool(hf_token)}")
-        if not hf_token:
-            raise RuntimeError(
-                "HF_TOKEN is not set in this process. Go to Space Settings > "
-                "Variables and secrets and confirm a secret named exactly "
-                "HF_TOKEN exists, then restart the Space (adding a secret does "
-                "not always hot-reload a running container)."
+        base_url = os.environ.get("GAIA_BASE_URL")  # optional OpenAI-compatible endpoint
+        api_key = os.environ.get("GAIA_API_KEY")    # key for that endpoint
+        rpm = float(os.environ.get("GAIA_RPM") or DEFAULT_REQUESTS_PER_MINUTE)
+
+        # GAIA_MODEL_ID may list several models, best first. Later entries are
+        # used only when an earlier one exhausts its daily token quota.
+        model_ids = [m.strip() for m in (model_id or "").split(",") if m.strip()]
+        model_id = model_ids[0] if model_ids else None
+        fallback_model_ids = model_ids[1:]
+
+        # Two ways to reach a model, both through the same InferenceClientModel:
+        #   1. (default) HF Inference Providers, billed to HF_TOKEN's account.
+        #   2. any OpenAI-compatible endpoint, when GAIA_BASE_URL is set. This
+        #      exists because HF's free monthly credits are small and a
+        #      depleted account returns 402 on every single call, which fails
+        #      all 20 questions at once.
+        # Fail fast and loud either way, instead of letting all 20 questions die
+        # silently at Step 1 with a generic error from deep inside smolagents.
+        if base_url:
+            print(f"Using custom OpenAI-compatible endpoint: {base_url}")
+            print(f"GAIA_API_KEY present: {bool(api_key)}")
+            if not api_key:
+                raise RuntimeError(
+                    "GAIA_BASE_URL is set but GAIA_API_KEY is not. Add a secret "
+                    "named exactly GAIA_API_KEY holding the key for that endpoint."
+                )
+            if not model_id:
+                raise RuntimeError(
+                    "GAIA_BASE_URL is set but GAIA_MODEL_ID is not. A custom "
+                    "endpoint needs its own model name (for example "
+                    "'llama-3.3-70b-versatile' on Groq), since provider model "
+                    "ids differ from Hugging Face repo ids."
+                )
+            # Bound each HTTP call: the openai SDK otherwise waits up to 10
+            # minutes and silently retries, so one throttled call can stall a
+            # whole question. Our own retry loop handles the backoff instead.
+            model = RetryingOpenAIServerModel(
+                model_id=model_id,
+                api_base=base_url,
+                api_key=api_key,
+                requests_per_minute=rpm,
+                retry=False,
+                client_kwargs={"timeout": 90, "max_retries": 0},
+            )
+            model_kwargs = {"model_id": model_id}
+        else:
+            print(f"HF_TOKEN present: {bool(hf_token)}")
+            if not hf_token:
+                raise RuntimeError(
+                    "HF_TOKEN is not set in this process. Go to Space Settings > "
+                    "Variables and secrets and confirm a secret named exactly "
+                    "HF_TOKEN exists, then restart the Space (adding a secret does "
+                    "not always hot-reload a running container)."
+                )
+            model_kwargs = {"token": hf_token, "model_id": model_id or DEFAULT_MODEL_ID}
+            if provider:
+                model_kwargs["provider"] = provider
+            model = RetryingInferenceClientModel(
+                requests_per_minute=rpm, retry=False, **model_kwargs
             )
 
-        model_kwargs = {"token": hf_token}
-        if provider:
-            model_kwargs["provider"] = provider
-        if model_id:
-            model_kwargs["model_id"] = model_id
-        model = InferenceClientModel(**model_kwargs)
+        # Instance attribute, so exhausting one model's quota never mutates the
+        # class-level default shared by every other agent in the process.
+        model.fallback_model_ids = list(fallback_model_ids)
+
+        print(f"Model: {model_kwargs['model_id']} (paced at {rpm:g} requests/minute)")
+        if fallback_model_ids:
+            print(f"Fallback models on daily quota exhaustion: {', '.join(fallback_model_ids)}")
 
         self.agent = CodeAgent(
             tools=[],
             model=model,
-            add_base_tools=True,  # gives web search + python interpreter + friends
+            add_base_tools=True,  # gives web_search + visit_webpage
             additional_authorized_imports=ADDITIONAL_IMPORTS,
             max_steps=MAX_STEPS,
+            step_callbacks=[trim_observations],
+        )
+        # add_base_tools installs the stock tools last, so swap in the hardened
+        # subclasses afterwards rather than passing them via tools=[].
+        # Both are given smaller output budgets than the library defaults
+        # (10 results, 40000 characters). Every tool result is replayed into the
+        # next model call, so a single stock visit_webpage is roughly 10k tokens
+        # — most of a free tier's whole per-minute allowance, spent on page
+        # boilerplate. Trimming keeps trajectories inside the budget and makes
+        # each step cheaper without losing the part of the page that matters.
+        self.agent.tools["web_search"] = RetryingWebSearchTool(max_results=6)
+        self.agent.tools["visit_webpage"] = IdentifiedVisitWebpageTool(
+            max_output_length=20000
         )
         print("GAIAAgent initialized (smolagents CodeAgent).")
 
-    def __call__(self, question: str, file_path: Optional[str] = None) -> str:
+    def __call__(
+        self,
+        question: str,
+        file_path: Optional[str] = None,
+        file_name: Optional[str] = None,
+    ) -> str:
         task = question + "\n\n" + TASK_RULES
         if file_path:
             task += (
@@ -98,6 +381,16 @@ class GAIAAgent:
                 f"path: {file_path}\nOpen it with Python and inspect its "
                 f"contents before answering.\n"
             )
+        elif file_name:
+            # The question ships an attachment but the scoring API could not
+            # serve it. Say so, otherwise the agent invents file contents.
+            task += (
+                f"\nNOTE: this task references an attachment ({file_name}) but "
+                f"it could not be retrieved from the evaluation server, so you "
+                f"do not have it. Do not pretend to open or read it. Answer "
+                f"from the question text and web research alone if that is "
+                f"possible; otherwise give your best supported answer.\n"
+            )
         raw_answer = self.agent.run(task)
         return clean_final_answer(raw_answer)
 
@@ -122,17 +415,75 @@ def download_task_file(api_url: str, task_id: str, file_name: str) -> Optional[s
         return None
     try:
         resp = requests.get(f"{api_url}/files/{task_id}", timeout=30)
+        if resp.status_code == 404:
+            # Distinguish "the evaluation server has no file mapped for this
+            # task" from a transport failure — they need different follow-ups.
+            print(
+                f"Attachment unavailable for task {task_id} ({file_name}): "
+                f"server returned 404 ({resp.text[:200]})"
+            )
+            return None
         resp.raise_for_status()
         out_dir = Path(tempfile.gettempdir()) / "gaia_files"
         out_dir.mkdir(exist_ok=True)
         out_path = out_dir / file_name
         out_path.write_bytes(resp.content)
+        print(f"Downloaded attachment for task {task_id}: {out_path} ({len(resp.content)} bytes)")
         return str(out_path)
     except Exception as e:
-        print(f"Could not download file for task {task_id}: {e}")
+        print(f"Could not download file for task {task_id}: {type(e).__name__}: {e}")
         return None
 
 
+def run_single_question(task_id: str = ""):
+    """Development helper: pull one task (a specific task_id, or a random one
+    from /random-question when left blank), run the agent on it, and show the
+    result. Submits nothing — this exists so individual tasks can be debugged
+    without spending a full 20-question submission."""
+    api_url = DEFAULT_API_URL
+    try:
+        task_id = (task_id or "").strip()
+        if task_id:
+            resp = requests.get(f"{api_url}/questions", timeout=15)
+            resp.raise_for_status()
+            matches = [q for q in resp.json() if q.get("task_id") == task_id]
+            if not matches:
+                return f"No question found with task_id {task_id}.", ""
+            item = matches[0]
+        else:
+            resp = requests.get(f"{api_url}/random-question", timeout=15)
+            resp.raise_for_status()
+            item = resp.json()
+    except Exception as e:
+        return f"Error fetching question: {type(e).__name__}: {e}", ""
+
+    task_id = item.get("task_id")
+    question_text = item.get("question")
+    file_name = item.get("file_name")
+
+    file_path = download_task_file(api_url, task_id, file_name) if file_name else None
+    if not file_name:
+        attachment_status = "none"
+    elif file_path:
+        attachment_status = f"{file_name} -> {file_path}"
+    else:
+        attachment_status = f"{file_name} (UNAVAILABLE - server returned no file)"
+
+    header = f"Task ID: {task_id}\nAttachment: {attachment_status}\n\nQuestion:\n{question_text}"
+
+    try:
+        agent = GAIAAgent()
+    except Exception as e:
+        return f"{header}\n\nError initializing agent: {e}", ""
+
+    try:
+        answer = agent(question_text, file_path=file_path, file_name=file_name)
+        return header, answer
+    except Exception as e:
+        print(f"Error running agent on task {task_id}: {type(e).__name__}: {e}")
+        return header, f"AGENT ERROR: {type(e).__name__}: {e}"
+
+
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the GAIAAgent on them (downloading any
@@ -196,11 +547,11 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             file_path = download_task_file(api_url, task_id, file_name)
 
         try:
-            submitted_answer = agent(question_text, file_path=file_path)
+            submitted_answer = agent(question_text, file_path=file_path, file_name=file_name)
             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})
         except Exception as e:
-            print(f"Error running agent on task {task_id}: {e}")
+            print(f"Error running agent on task {task_id}: {type(e).__name__}: {e}")
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
@@ -283,6 +634,22 @@ with gr.Blocks() as demo:
         outputs=[status_output, results_table]
     )
 
+    with gr.Accordion("Developer: test a single question (no submission)", open=False):
+        gr.Markdown(
+            "Leave the box empty to pull a random task from `/random-question`, "
+            "or paste a specific `task_id` from `/questions`."
+        )
+        single_task_id = gr.Textbox(label="task_id (optional)", placeholder="leave blank for a random question")
+        single_button = gr.Button("Test One Question")
+        single_question_output = gr.Textbox(label="Task / Question", lines=8, interactive=False)
+        single_answer_output = gr.Textbox(label="Agent Answer (cleaned)", lines=3, interactive=False)
+
+        single_button.click(
+            fn=run_single_question,
+            inputs=[single_task_id],
+            outputs=[single_question_output, single_answer_output],
+        )
+
 if __name__ == "__main__":
     print("\n" + "-" * 30 + " App Starting " + "-" * 30)
     space_host_startup = os.getenv("SPACE_HOST")
@@ -290,7 +657,7 @@ if __name__ == "__main__":
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+        print(f"   Runtime URL: https://{space_host_startup}")
     else:
         print("ℹ️ SPACE_HOST environment variable not found (running locally?).")
 

requirements.txt

@@ -2,6 +2,7 @@ gradio
 spaces
 requests
 pandas
-smolagents[toolkit]
+smolagents[toolkit]==1.26.0
+openai
 pypdf
-openpyxl
+openpyxl