Update app.py

app.py

@@ -13,6 +13,7 @@ from smolagents import (
     LiteLLMModel,
     Tool,
     VisitWebpageTool,
+    WikipediaSearchTool,
 )
 
 
@@ -184,6 +185,10 @@ class BasicAgent:
             tools=[
                 DuckDuckGoSearchTool(max_results=8, rate_limit=1.0),
                 VisitWebpageTool(max_output_length=30_000),
+                WikipediaSearchTool(
+                    user_agent="GAIA-Course-Agent/1.0 (educational project)",
+                    language="en",
+                ),
                 InspectGaiaAttachmentTool(),
             ],
             model=self.model,
@@ -302,6 +307,174 @@ def readiness_summary(results_table) -> str:
         return f"Não foi possível calcular o índice de prontidão: {exc}"
 
 
+def review_dataframe(questions: list, answers: dict) -> pd.DataFrame:
+    rows = []
+    for item in questions or []:
+        task_id = str(item.get("task_id", "")).strip()
+        rows.append(
+            {
+                "Task ID": task_id,
+                "Question": str(item.get("question", "")),
+                "Submitted Answer": str((answers or {}).get(task_id, "")),
+            }
+        )
+    return pd.DataFrame(rows, columns=RESULT_COLUMNS)
+
+
+def progress_summary(questions: list, answers: dict) -> str:
+    total = len(questions or [])
+    answered = sum(
+        bool(str((answers or {}).get(str(item.get("task_id", "")), "")).strip())
+        for item in (questions or [])
+    )
+    return f"Progresso: {answered}/{total} questões respondidas."
+
+
+def load_evaluation_questions(profile: gr.OAuthProfile | None):
+    """Carrega as 20 questões, mas não executa o agente."""
+    if not profile:
+        return (
+            "Faça login no Hugging Face primeiro.",
+            [],
+            {},
+            gr.update(choices=[], value=None),
+            "",
+            "",
+            "",
+            "Progresso: 0/20 questões respondidas.",
+            "Índice de prontidão: 0%.",
+            empty_results(),
+        )
+
+    try:
+        response = requests.get(
+            f"{DEFAULT_API_URL}/questions", timeout=HTTP_TIMEOUT
+        )
+        response.raise_for_status()
+        questions = response.json()
+        questions = [
+            item
+            for item in questions
+            if item.get("task_id") and item.get("question") is not None
+        ]
+        if not questions:
+            raise ValueError("A API retornou uma lista vazia.")
+
+        answers = {}
+        choices = [
+            (
+                f"{index + 1:02d}. {str(item['question'])[:90]}",
+                str(item["task_id"]),
+            )
+            for index, item in enumerate(questions)
+        ]
+        first = questions[0]
+        dataframe = review_dataframe(questions, answers)
+        return (
+            f"{len(questions)} questões carregadas. Nenhuma foi executada ainda.",
+            questions,
+            answers,
+            gr.update(choices=choices, value=str(first["task_id"])),
+            str(first["question"]),
+            str(first["task_id"]),
+            "",
+            progress_summary(questions, answers),
+            readiness_summary(dataframe),
+            dataframe,
+        )
+    except Exception as exc:
+        return (
+            f"Erro ao carregar questões: {exc}",
+            [],
+            {},
+            gr.update(choices=[], value=None),
+            "",
+            "",
+            "",
+            "Progresso: 0/20 questões respondidas.",
+            "Índice de prontidão: 0%.",
+            empty_results(),
+        )
+
+
+def select_evaluation_question(task_id: str, questions: list, answers: dict):
+    for item in questions or []:
+        if str(item.get("task_id")) == str(task_id):
+            return (
+                str(item.get("question", "")),
+                str(item.get("task_id", "")),
+                str((answers or {}).get(str(task_id), "")),
+                "Questão selecionada. Execute o agente ou edite e salve a resposta.",
+            )
+    return "", "", "", "Questão não encontrada na sessão."
+
+
+def save_reviewed_answer(
+    task_id: str, answer: str, questions: list, answers: dict
+):
+    task_id = str(task_id or "").strip()
+    if not task_id:
+        dataframe = review_dataframe(questions, answers)
+        return (
+            answers or {},
+            "Nenhuma questão selecionada.",
+            progress_summary(questions, answers),
+            readiness_summary(dataframe),
+            dataframe,
+        )
+
+    updated = dict(answers or {})
+    updated[task_id] = str(answer or "").strip()
+    dataframe = review_dataframe(questions, updated)
+    return (
+        updated,
+        "Resposta revisada e salva nesta sessão.",
+        progress_summary(questions, updated),
+        readiness_summary(dataframe),
+        dataframe,
+    )
+
+
+def run_current_evaluation_question(
+    question: str, task_id: str, questions: list, answers: dict
+):
+    """Executa somente a questão atualmente selecionada."""
+    if not question or not task_id:
+        dataframe = review_dataframe(questions, answers)
+        return (
+            "",
+            answers or {},
+            "Carregue e selecione uma questão primeiro.",
+            progress_summary(questions, answers),
+            readiness_summary(dataframe),
+            dataframe,
+        )
+
+    try:
+        answer = BasicAgent()(question, task_id)
+        updated = dict(answers or {})
+        updated[str(task_id)] = answer
+        dataframe = review_dataframe(questions, updated)
+        return (
+            answer,
+            updated,
+            "Questão executada e resposta salva. Revise o conteúdo antes de avançar.",
+            progress_summary(questions, updated),
+            readiness_summary(dataframe),
+            dataframe,
+        )
+    except Exception as exc:
+        dataframe = review_dataframe(questions, answers)
+        return (
+            f"ERROR: {exc}",
+            answers or {},
+            f"Erro ao executar esta questão: {exc}",
+            progress_summary(questions, answers),
+            readiness_summary(dataframe),
+            dataframe,
+        )
+
+
 def fetch_random_question():
     """Busca somente uma questão oficial aleatória, sem executar ou enviar."""
     try:
@@ -558,13 +731,46 @@ with gr.Blocks(theme=gr.themes.Soft(), title="GAIA Agent Evaluation") as demo:
 
         with gr.Tab("2. Executar e revisar"):
             gr.Markdown(
-                "Gere as respostas das 20 questões. Você pode editar a coluna "
-                "'Submitted Answer' antes do envio."
+                "Carregue as 20 questões e execute apenas a questão selecionada. "
+                "As respostas ficam reunidas para uma única submissão final."
+            )
+            evaluation_questions = gr.State([])
+            evaluation_answers = gr.State({})
+            current_task_id = gr.State("")
+
+            load_questions_button = gr.Button(
+                "Carregar as 20 questões", variant="secondary"
             )
-            run_button = gr.Button(
-                "Executar avaliação sem enviar", variant="secondary"
+            question_selector = gr.Dropdown(
+                label="Escolha a questão",
+                choices=[],
+                interactive=True,
+            )
+            current_question = gr.Textbox(
+                label="Questão selecionada",
+                lines=6,
+                interactive=False,
             )
+            current_answer = gr.Textbox(
+                label="Resposta da questão selecionada",
+                lines=4,
+                interactive=True,
+                placeholder=(
+                    "Execute o agente ou digite/corrija a resposta e clique em salvar."
+                ),
+            )
+            with gr.Row():
+                run_current_button = gr.Button(
+                    "Executar somente esta questão", variant="primary"
+                )
+                save_answer_button = gr.Button("Salvar resposta revisada")
+
             run_status = gr.Textbox(label="Status", lines=4, interactive=False)
+            evaluation_progress = gr.Textbox(
+                label="Progresso",
+                value="Progresso: 0/20 questões respondidas.",
+                interactive=False,
+            )
             evaluation_readiness = gr.Textbox(
                 label="Avaliação antes do envio",
                 lines=4,
@@ -577,19 +783,70 @@ with gr.Blocks(theme=gr.themes.Soft(), title="GAIA Agent Evaluation") as demo:
                 value=empty_results(),
                 label="Respostas para revisão",
                 wrap=True,
-                interactive=True,
+                interactive=False,
+            )
+
+            load_questions_button.click(
+                fn=load_evaluation_questions,
+                outputs=[
+                    run_status,
+                    evaluation_questions,
+                    evaluation_answers,
+                    question_selector,
+                    current_question,
+                    current_task_id,
+                    current_answer,
+                    evaluation_progress,
+                    evaluation_readiness,
+                    results_table,
+                ],
             )
-            recalculate_button = gr.Button(
-                "Recalcular índice após editar respostas"
+            question_selector.change(
+                fn=select_evaluation_question,
+                inputs=[
+                    question_selector,
+                    evaluation_questions,
+                    evaluation_answers,
+                ],
+                outputs=[
+                    current_question,
+                    current_task_id,
+                    current_answer,
+                    run_status,
+                ],
             )
-            run_button.click(
-                fn=run_agent_only,
-                outputs=[run_status, results_table, evaluation_readiness],
+            run_current_button.click(
+                fn=run_current_evaluation_question,
+                inputs=[
+                    current_question,
+                    current_task_id,
+                    evaluation_questions,
+                    evaluation_answers,
+                ],
+                outputs=[
+                    current_answer,
+                    evaluation_answers,
+                    run_status,
+                    evaluation_progress,
+                    evaluation_readiness,
+                    results_table,
+                ],
             )
-            recalculate_button.click(
-                fn=readiness_summary,
-                inputs=[results_table],
-                outputs=[evaluation_readiness],
+            save_answer_button.click(
+                fn=save_reviewed_answer,
+                inputs=[
+                    current_task_id,
+                    current_answer,
+                    evaluation_questions,
+                    evaluation_answers,
+                ],
+                outputs=[
+                    evaluation_answers,
+                    run_status,
+                    evaluation_progress,
+                    evaluation_readiness,
+                    results_table,
+                ],
             )
 
         with gr.Tab("3. Enviar resultado"):