Initial commit for Spaces

src/config.py

@@ -5,6 +5,8 @@ from langgraph.prebuilt import ToolNode
 from schemas import PlannerPlan
 from utils.utils import log_stage
 from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, ToolMessage
+from dotenv import load_dotenv
+load_dotenv()
 
 config = {"configurable": {"thread_id": "1"}, "recursion_limit" : 50}
 

src/main.py

@@ -0,0 +1,338 @@
+"""Ankelodon Agent Adapter for the Hugging Face Agents Course evaluator.
+
+This module exposes a simple Gradio-powered wrapper around the
+`ankelodon_multiagent_system` project. It follows the same high-level flow
+as the official GAIA template provided in the course materials: fetch
+evaluation questions from the GAIA API, run your agent to produce
+responses, and submit those responses back to the leaderboard.
+
+The key differences between this adapter and the GAIA template are:
+
+  * It imports and uses your multi‑agent system defined in the `src`
+    package (see `src/agent.py`) via the `build_workflow` function. This
+    function returns a `langgraph` state machine capable of planning,
+    reasoning and executing tools. The adapter calls into this workflow
+    with a properly initialised `AgentState` and extracts the final
+    answer from the resulting state.
+  * It automatically downloads any file attachments associated with a
+    task (via the `/files/{task_id}` endpoint exposed by the evaluation
+    server) and saves them into a temporary directory. The local file
+    paths are passed into the agent through the `files` field of the
+    state. Your existing file handling logic (e.g. `preprocess_files`
+    in `src/tools/tools.py`) will detect the file type and suggest
+    appropriate tools.
+  * It strips any leading ``Final answer:`` prefix from the agent's
+    response. The evaluation server performs an exact string match
+    against the ground truth answer【842261069842380†L108-L112】, so it is
+    important that the returned text contains only the answer and
+    nothing else.
+
+Before running this script yourself, make sure all dependencies in
+`requirements.txt` are installed. To use the Gradio interface locally,
+run `python ankelodon_adapter.py` from the project root. When deploying
+as a Hugging Face Space for leaderboard submission, ensure the
+`SPACE_ID` environment variable is set by the platform; it is used to
+construct a link back to your code for verification.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import Optional, List, Dict, Any
+
+import requests
+import gradio as gr
+import pandas as pd
+
+try:
+    # Import the multi‑agent system components. When running as a script
+    # within the project root, Python's module search path should
+    # already include the `src` directory. If you get import errors,
+    # ensure that the working directory is the repository root or
+    # append `src` to `sys.path` manually before these imports.
+    from agent import build_workflow
+    from config import config as WORKFLOW_CONFIG
+    from state import AgentState
+except Exception as import_err:
+    raise RuntimeError(
+        "Failed to import the Ankelodon multi-agent system. "
+        "Make sure you are running this script from the repository root "
+        "and that the project has been installed correctly."
+    ) from import_err
+
+DEFAULT_API_URL: str = "https://agents-course-unit4-scoring.hf.space"
+
+
+class AnkelodonAgent:
+    """Simple callable wrapper around the Ankelodon multi‑agent system.
+
+    Instances of this class can be called directly with a natural
+    language question and an optional task identifier. Under the hood it
+    builds a `langgraph` workflow using ``build_workflow()``, prepares
+    an initial state, fetches any file attachments associated with
+    the task, and invokes the workflow to compute a final answer.
+    """
+
+    def __init__(self) -> None:
+        # Initialise the workflow once per agent. Subsequent calls reuse
+        # the compiled state machine, which is more efficient than
+        # rebuilding it on every question.
+        self.workflow = build_workflow()
+
+    def _download_attachment(self, task_id: str) -> List[str]:
+        """Download a file attachment for the given task ID.
+
+        The evaluation API exposes a ``/files/{task_id}`` endpoint【842261069842380†L95-L107】.
+        This helper downloads the content, infers a file extension
+        from the HTTP ``Content-Type`` header and writes the bytes to a
+        temporary file. It returns a list of file paths (zero or one
+        element) to be included in the agent state.
+        """
+        files: List[str] = []
+        url = f"{DEFAULT_API_URL}/files/{task_id}"
+        try:
+            resp = requests.get(url, timeout=15, allow_redirects=True)
+            if resp.status_code == 200 and resp.content:
+                # Map common MIME substrings to file extensions. The
+                # multi‑agent system's file handling tools use the
+                # extension to determine how to process the file.
+                ctype = resp.headers.get("content-type", "").lower()
+                ext_map = {
+                    "excel": ".xlsx",
+                    "sheet": ".xlsx",
+                    "csv": ".csv",
+                    "python": ".py",
+                    "audio": ".mp3",
+                    "image": ".jpg",
+                }
+                extension = ""
+                for key, val in ext_map.items():
+                    if key in ctype:
+                        extension = val
+                        break
+                tmp_dir = tempfile.mkdtemp(prefix="ankelodon_task_")
+                filename = f"attachment{extension}"
+                path = os.path.join(tmp_dir, filename)
+                with open(path, "wb") as fh:
+                    fh.write(resp.content)
+                files.append(path)
+        except Exception as e:
+            # Log the error to console but don't fail the entire task.
+            print(f"[WARNING] Failed to fetch attachment for task {task_id}: {e}")
+        return files
+
+    def __call__(self, question: str, task_id: Optional[str] = None) -> str:
+        """Run the multi‑agent system to answer a question.
+
+        Parameters
+        ----------
+        question: str
+            The natural language query to answer.
+        task_id: Optional[str]
+            If provided, the ID used to fetch any associated file
+            attachment from the evaluation API. Attachments are stored
+            locally and passed into the agent via the ``files`` field.
+
+        Returns
+        -------
+        str
+            The final answer produced by the agent, with any "final
+            answer" prefix removed. If no answer is produced the empty
+            string is returned.
+        """
+        # Build the initial agent state. The AgentState type defines
+        # numerous fields, many of which the workflow populates
+        # internally. We set only the essentials here. Unrecognised
+        # keys are ignored by the underlying state machine.
+        state: Dict[str, Any] = {
+            "query": question,
+            "final_answer": "",
+            "plan": None,
+            "complexity_assessment": None,
+            "current_step": 0,
+            "reasoning_done": False,
+            "messages": [],
+            "files": [],
+            "file_contents": {},
+            "critique_feedback": None,
+            "iteration_count": 0,
+            "max_iterations": 3,
+            "execution_report": None,
+            "previous_tool_results": {},
+        }
+
+        # If a task ID is provided, attempt to download its attachment.
+        if task_id:
+            attachment_paths = self._download_attachment(task_id)
+            if attachment_paths:
+                state["files"] = attachment_paths
+
+        # Invoke the workflow. The `config` parameter defines runtime
+        # options such as recursion limits and thread identifiers. It is
+        # imported from `src.config`.
+        try:
+            result_state = self.workflow.invoke(state, config=WORKFLOW_CONFIG)
+        except Exception as e:
+            print(f"[ERROR] Failed to run workflow: {e}")
+            return ""
+
+        # Extract the final answer. Depending on the branch taken,
+        # either the ``final_answer`` key or a generic ``answer`` key may
+        # be present. Use whichever exists. Some nodes may prepend
+        # "final answer:"; remove it for exact match scoring【842261069842380†L108-L112】.
+        answer = ""
+        if isinstance(result_state, dict):
+            answer = result_state.get("final_answer") or result_state.get("answer") or ""
+        if answer:
+            answer = answer.replace("Final answer:", "").replace("final answer:", "").strip()
+        return answer
+
+
+def run_and_submit_all(profile: Optional[gr.OAuthProfile]) -> tuple[str, pd.DataFrame | None]:
+    """Fetch all questions, run the agent, and submit the answers.
+
+    This function replicates the behaviour of the GAIA template's
+    ``run_and_submit_all`` function【566837548679297†L247-L306】 but uses the
+    ``AnkelodonAgent`` class defined above. It is bound to a Gradio
+    button in the UI. On success it returns a status message and a
+    DataFrame of results; on failure it returns an error message and
+    ``None`` or an empty DataFrame.
+    """
+    # Require the user to be logged in so we can report the username.
+    if not profile:
+        return "Please Login to Hugging Face with the button.", None
+    username = getattr(profile, "username", "").strip()
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # Instantiate the agent once.
+    try:
+        agent = AnkelodonAgent()
+        print("Ankelodon agent initialised successfully")
+    except Exception as e:
+        err_msg = f"Error initialising agent: {e}"
+        print(err_msg)
+        return err_msg, None
+
+    # Fetch questions from the evaluation API.【566837548679297†L247-L268】
+    try:
+        print(f"Fetching questions from: {questions_url}")
+        resp = requests.get(questions_url, timeout=15)
+        resp.raise_for_status()
+        questions_data = resp.json()
+        if not questions_data:
+            return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except Exception as e:
+        err_msg = f"Error fetching questions: {e}"
+        print(err_msg)
+        return err_msg, None
+
+    # Run the agent on each question.
+    results_log: List[Dict[str, Any]] = []
+    answers_payload: List[Dict[str, str]] = []
+    print(f"Running agent on {len(questions_data)} questions…")
+    for item in questions_data:
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
+            continue
+        try:
+            answer = agent(question_text, task_id)
+            answers_payload.append({"task_id": task_id, "submitted_answer": answer})
+            results_log.append({
+                "Task ID": task_id,
+                "Question": question_text,
+                "Submitted Answer": answer,
+            })
+        except Exception as e:
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append({
+                "Task ID": task_id,
+                "Question": question_text,
+                "Submitted Answer": f"AGENT ERROR: {e}",
+            })
+
+    if not answers_payload:
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # Prepare submission payload. The leaderboard displays a link to your
+    # code; this is constructed from the SPACE_ID environment variable.
+    space_id = os.getenv("SPACE_ID", "")
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else ""
+    submission_data = {
+        "username": username,
+        "agent_code": agent_code,
+        "answers": answers_payload,
+    }
+
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        submission_resp = requests.post(submit_url, json=submission_data, timeout=60)
+        submission_resp.raise_for_status()
+        result_data = submission_resp.json()
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
+        )
+        print("Submission successful.")
+        return final_status, pd.DataFrame(results_log)
+    except Exception as e:
+        err_msg = f"Submission Failed: {e}"
+        print(err_msg)
+        return err_msg, pd.DataFrame(results_log)
+
+
+# Build the Gradio interface. This interface resembles the official
+# GAIA template【566837548679297†L372-L401】 but runs your Ankelodon agent.
+with gr.Blocks() as demo:
+    gr.Markdown("# Ankelodon Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions**
+        
+        1. Clone this repository or duplicate the associated Hugging Face Space.
+        2. Log in to your Hugging Face account using the button below. Your HF
+           username is used to attribute your submission on the leaderboard.
+        3. Click **Run Evaluation & Submit All Answers** to fetch the questions,
+           run the Ankelodon agent on each one, submit your answers, and display
+           the resulting score and answers.
+        
+        ---
+        This template is intentionally lightweight. Feel free to customise it –
+        add caching, parallel execution or additional logging as you see fit.
+        """
+    )
+    gr.LoginButton()
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
+
+
+if __name__ == "__main__":
+    # When running locally, print some information about the environment.
+    print("\n" + "-" * 30 + " Ankelodon Adapter Starting " + "-" * 30)
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+    if space_id_startup:
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+    print("-" * (60 + len(" Ankelodon Adapter Starting ")) + "\n")
+    # Launch the Gradio app.
+    demo.launch(debug=True, share=False)

src/workflow_test.ipynb

@@ -46,19 +46,19 @@
       "=== COMPLEXITY ASSESSMENT ===\n",
       "Complexity: simple\n",
       "Needs planning: False\n",
-      "Reasoning: Initial state: 200 coins, all but 30 are face-up → 30 face-down (tails). He takes 30 coins; if x of those were face-down, the remaining pile has 30−x face-down. Flipping the 30-coin pile turns its face-down count into 30−x as well, so both piles have equal face-down coins. The larger pile was observed to have 14 face-down coins, so his pile also has 14 face-down coins. His reward is 2 gold coins per face-down coin in his pile: 14×2 = 28.\n",
+      "Reasoning: This is a single-step arithmetic question (2+2). Although calculations technically require a tool per the special considerations, this is trivial and requires only one immediate operation, so it is SIMPLE.\n",
       "=== SIMPLE EXECUTION ===\n",
       "Response generated for simple query.\n",
       "=== GENERATING EXECUTION REPORT ===\n",
       "Report generated - Confidence: high\n",
-      "Key findings: 5\n",
+      "Key findings: 3\n",
       "Data sources: 2\n",
-      "query_summary='Riddle: 200 coins where all but 30 are face-up (so 30 face-down). The adventurer removed 30 coins as his pile (unknown orientations), flipped each coin in that pile, then observed the larger pile contained 14 face-down coins. Determine whether he succeeded and how many coins he won (2 gold per face-down coin in his pile).' approach_used=\"Algebraic reasoning with simple variables: let x = number of face-down coins initially in the 30-coin pile removed. Use conservation of face-down coins to compute final counts after flipping, then compute reward = 2 * (final face-downs in adventurer's pile).\" tools_executed=[] key_findings=['Total coins = 200. Initially face-down coins = 30 (since all but 30 are face-up).', 'Let x = number of face-down coins among the 30 coins removed. After flipping those 30 coins, that pile has (30 - x) face-down coins.', 'The remaining (larger) pile has initial face-down coins = 30 - x, which matches (30 - x) after the flip, so both piles have equal face-down counts.', 'Given the larger pile was observed to have 14 face-down coins, 30 - x = 14 => x = 16.', \"Therefore the adventurer's pile also has 14 face-down coins after flipping, yielding a reward of 14 * 2 = 28 coins.\"] data_sources=['Problem statement provided in the query', 'Basic arithmetic/algebra reasoning'] assumptions_made=[\"Interpretation 'all but 30 are face-up' means exactly 30 coins are face-down initially.\", \"The adventurer's pile is the 30-coin pile he removed and flipped; the 'larger pile' refers to the remaining 170-coin pile.\", \"Reward is exactly 2 gold coins per face-down coin in the adventurer's pile, as stated.\"] confidence_level='high' limitations=['Solution depends on standard interpretation of the riddle wording; if alternative interpretations were intended, results could differ.', 'No external references were used; reasoning is self-contained.'] final_answer='28'\n",
+      "query_summary=\"User asked for the numeric result of the arithmetic expression '2+2'.\" approach_used=\"Direct evaluation using basic arithmetic: interpreted '+' as standard integer addition and computed the sum mentally without invoking external tools or files.\" tools_executed=[] key_findings=[\"The expression '2+2' was interpreted as standard integer addition.\", 'Computed result is 4.', 'No external tools or data were required to compute the result.'] data_sources=['Basic arithmetic rules (internal knowledge)', 'Conversation history confirming the query and an earlier direct answer'] assumptions_made=[\"The '+' operator denotes standard arithmetic addition on integers.\", 'Numbers are in the usual base-10 system and no special context (e.g., modular arithmetic or symbolic manipulation) was intended.'] confidence_level='high' limitations=['If the user intended a nonstandard context (modulo arithmetic, different base, or overloaded operator semantics), the answer could differ.', 'Extremely simple query; few realistic limitations beyond contextual ambiguity.'] final_answer='4'\n",
       "=== ENHANCED ANSWER CRITIQUE ===\n",
       "Quality Score: 8/10\n",
       "Complete: True\n",
       "Accurate: True\n",
-      "Issues found: [\"Minor imprecise phrasing: the report mentions 'conservation of face-down coins' which is misleading — flipping changes the total number of face-down coins. The correct point is that after flipping the removed 30 coins, the removed pile ends up with (30 - x) face-down coins, which equals the remaining pile's unchanged count of (30 - x).\", 'No explicit, single-sentence statement answering the two parts of the query (Did he succeed? How many gold coins did he win?). The final numeric answer is present but the success statement is implicit.']\n",
+      "Issues found: [\"Performed the calculation mentally rather than using an external computational tool (triggers the evaluation framework's manual-calculation penalty).\"]\n",
       "=== REPLAN DECISION ===\n",
       "Iteration: 1/10\n",
       "Quality score: 8\n",
@@ -68,7 +68,7 @@
     }
    ],
    "source": [
-    "query = \"Here's a fun riddle that I'd like you to try.\\n\\nAn adventurer exploring an ancient tomb came across a horde of gold coins, all neatly stacked in columns. As he reached to scoop them into his backpack, a mysterious voice filled the room. \\\"You have fallen for my trap adventurer,\\\" the voice began, and suddenly the doorway to the chamber was sealed by a heavy rolling disk of stone. The adventurer tried to move the stone disk but was unable to budge the heavy stone. Trapped, he was startled when the voice again spoke. \\n\\n\\\"If you solve my riddle, I will reward you with a portion of my riches, but if you are not clever, you will never leave this treasure chamber. Before you are 200 gold coins. I pose a challenge to you, adventurer. Within these stacks of coins, all but 30 are face-up. You must divide the coins into two piles, one is yours, and one is mine. You may place as many coins as you like in either pile. You may flip any coins over, but you may not balance any coins on their edges. For every face-down coin in your pile, you will be rewarded with two gold coins. But be warned, if both piles do not contain the same number of face-down coins, the door will remain sealed for all eternity!\\\"\\n\\nThe adventurer smiled, as this would be an easy task. All he had to do was flip over every coin so it was face down, and he would win the entire treasure! As he moved to the columns of coins, however, the light suddenly faded, and he was left in total darkness. The adventurer reached forward and picked up one of the coins, and was shocked when he realized that both sides felt almost the same. Without the light, he was unable to determine which side of the coin was heads and which side was tails. He carefully replaced the coin in its original orientation and tried to think of a way to solve the puzzle. Finally, out of desperation, the adventurer removed 30 coins to create his pile. He then carefully flipped over each coin in his pile, so its orientation was inverted from its original state.\\n\\n\\\"I've finished,\\\" he said, and the lights returned. Looking at the two piles, he noticed that the larger pile contained 14 face-down coins.\\n\\nWhat was the outcome for the adventurer? If he failed the challenge, please respond with \\\"The adventurer died.\\\" Otherwise, please provide the number of coins the adventurer won at the conclusion of the riddle. If the adventurer won any coins, provide your response as the number of coins, with no other text.\"\n",
+    "query = \"What is 2+2\"\n",
     "result = graph.invoke({\"query\" : query, \"current_step\": 0, \"reasoning_done\": False, \"files\" : [], \"files_contents\" : {}, \"iteration_count\" : 0, \"max_iterations\" : 10, \"plan\" : None} , config = config)"
    ]
   },
@@ -81,7 +81,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "FINAL ANSWER: 28\n"
+      "FINAL ANSWER: 4\n"
      ]
     }
    ],
@@ -97,20 +97,20 @@
     {
      "data": {
       "text/plain": [
-       "{'messages': [SystemMessage(content='You are a COMPLEXITY ASSESSOR for a multi-tool agent system.\\nYour job is to analyze user queries and determine their complexity level and processing requirements.\\n\\nCOMPLEXITY LEVELS:\\n1. SIMPLE: Direct questions that can be answered immediately without tools or with single tool use\\n   - Examples: \"What is photosynthesis?\", \"Define machine learning\", \"What\\'s the capital of France?\"\\n   - NOTE: Simple math like \"2+2\" still requires calculator tool but counts as SIMPLE\\n\\n   !ALSO: It can be a logical reasoning or explanation task that does not require tools.\\n   \\n2. MODERATE: Questions requiring 2-4 tool calls or basic multi-step analysis\\n   - Examples: \"Search for recent news about AI\", \"Analyze this CSV file for trends\", \"Calculate ROI from this data\"\\n   - \"Compare two datasets\", \"Summarize multiple documents\"\\n   \\n3. COMPLEX: Multi-step problems requiring planning, multiple tools, and sophisticated reasoning\\n   - Examples: \"Research market trends and create investment strategy\", \"Analyze multiple data sources and predict outcomes\"\\n   - \"Build comprehensive report from various inputs\", \"Multi-stage data processing with validation\"\\n\\nMOST OF THE LOGICAL TASKS ARE SIMPLE, UNLESS THEY REQUIRE TOOLS.\\n\\nASSESSMENT CRITERIA:\\n- Number of distinct steps likely needed (1 = Simple, 2-4 = Moderate, 5+ = Complex)\\n- Tool complexity and dependencies between steps\\n- Data processing requirements and validation needs\\n- Need for intermediate reasoning and synthesis\\n- Risk of failure without proper step-by-step planning\\n- Presence of calculations (automatically requires tool usage)\\n\\nSPECIAL CONSIDERATIONS:\\n- Any calculation/counting task requires tools (affects complexity assessment)\\n- File analysis tasks usually need multiple steps (load + analyze + calculate)\\n- Research tasks typically need search + fetch + synthesis steps\\n- Comparison tasks need separate analysis steps for each item being compared\\n\\nRULES:\\n- SIMPLE queries may bypass planning for non-calculation tasks\\n- MODERATE queries benefit from lightweight planning\\n- COMPLEX queries require full planning with fallbacks\\n- When in doubt, err toward higher complexity\\n- Calculation tasks are never truly \"simple\" due to mandatory tool usage\\n\\nAnalyze the query and respond with your assessment.', additional_kwargs={}, response_metadata={}, id='26e46b0a-44ea-4f15-be78-dd9e141ac21b'),\n",
-       "  HumanMessage(content='Query: Here\\'s a fun riddle that I\\'d like you to try.\\n\\nAn adventurer exploring an ancient tomb came across a horde of gold coins, all neatly stacked in columns. As he reached to scoop them into his backpack, a mysterious voice filled the room. \"You have fallen for my trap adventurer,\" the voice began, and suddenly the doorway to the chamber was sealed by a heavy rolling disk of stone. The adventurer tried to move the stone disk but was unable to budge the heavy stone. Trapped, he was startled when the voice again spoke. \\n\\n\"If you solve my riddle, I will reward you with a portion of my riches, but if you are not clever, you will never leave this treasure chamber. Before you are 200 gold coins. I pose a challenge to you, adventurer. Within these stacks of coins, all but 30 are face-up. You must divide the coins into two piles, one is yours, and one is mine. You may place as many coins as you like in either pile. You may flip any coins over, but you may not balance any coins on their edges. For every face-down coin in your pile, you will be rewarded with two gold coins. But be warned, if both piles do not contain the same number of face-down coins, the door will remain sealed for all eternity!\"\\n\\nThe adventurer smiled, as this would be an easy task. All he had to do was flip over every coin so it was face down, and he would win the entire treasure! As he moved to the columns of coins, however, the light suddenly faded, and he was left in total darkness. The adventurer reached forward and picked up one of the coins, and was shocked when he realized that both sides felt almost the same. Without the light, he was unable to determine which side of the coin was heads and which side was tails. He carefully replaced the coin in its original orientation and tried to think of a way to solve the puzzle. Finally, out of desperation, the adventurer removed 30 coins to create his pile. He then carefully flipped over each coin in his pile, so its orientation was inverted from its original state.\\n\\n\"I\\'ve finished,\" he said, and the lights returned. Looking at the two piles, he noticed that the larger pile contained 14 face-down coins.\\n\\nWhat was the outcome for the adventurer? If he failed the challenge, please respond with \"The adventurer died.\" Otherwise, please provide the number of coins the adventurer won at the conclusion of the riddle. If the adventurer won any coins, provide your response as the number of coins, with no other text.', additional_kwargs={}, response_metadata={}, id='85bfac92-7cdb-48f0-b211-9593a6dfc851'),\n",
-       "  AIMessage(content='28', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 970, 'prompt_tokens': 2706, 'total_tokens': 3676, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 960, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-5-mini-2025-08-07', 'system_fingerprint': None, 'id': 'chatcmpl-CIbxZ2RCMWUu7YmfpqFUpa2eMG39g', 'service_tier': 'default', 'finish_reason': 'stop', 'logprobs': None}, id='run--fd1c06e8-0aa2-49db-8693-33ac60a1b382-0', usage_metadata={'input_tokens': 2706, 'output_tokens': 970, 'total_tokens': 3676, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 960}})],\n",
-       " 'query': 'Here\\'s a fun riddle that I\\'d like you to try.\\n\\nAn adventurer exploring an ancient tomb came across a horde of gold coins, all neatly stacked in columns. As he reached to scoop them into his backpack, a mysterious voice filled the room. \"You have fallen for my trap adventurer,\" the voice began, and suddenly the doorway to the chamber was sealed by a heavy rolling disk of stone. The adventurer tried to move the stone disk but was unable to budge the heavy stone. Trapped, he was startled when the voice again spoke. \\n\\n\"If you solve my riddle, I will reward you with a portion of my riches, but if you are not clever, you will never leave this treasure chamber. Before you are 200 gold coins. I pose a challenge to you, adventurer. Within these stacks of coins, all but 30 are face-up. You must divide the coins into two piles, one is yours, and one is mine. You may place as many coins as you like in either pile. You may flip any coins over, but you may not balance any coins on their edges. For every face-down coin in your pile, you will be rewarded with two gold coins. But be warned, if both piles do not contain the same number of face-down coins, the door will remain sealed for all eternity!\"\\n\\nThe adventurer smiled, as this would be an easy task. All he had to do was flip over every coin so it was face down, and he would win the entire treasure! As he moved to the columns of coins, however, the light suddenly faded, and he was left in total darkness. The adventurer reached forward and picked up one of the coins, and was shocked when he realized that both sides felt almost the same. Without the light, he was unable to determine which side of the coin was heads and which side was tails. He carefully replaced the coin in its original orientation and tried to think of a way to solve the puzzle. Finally, out of desperation, the adventurer removed 30 coins to create his pile. He then carefully flipped over each coin in his pile, so its orientation was inverted from its original state.\\n\\n\"I\\'ve finished,\" he said, and the lights returned. Looking at the two piles, he noticed that the larger pile contained 14 face-down coins.\\n\\nWhat was the outcome for the adventurer? If he failed the challenge, please respond with \"The adventurer died.\" Otherwise, please provide the number of coins the adventurer won at the conclusion of the riddle. If the adventurer won any coins, provide your response as the number of coins, with no other text.',\n",
-       " 'final_answer': 'FINAL ANSWER: 28',\n",
+       "{'messages': [SystemMessage(content='You are a COMPLEXITY ASSESSOR for a multi-tool agent system.\\nYour job is to analyze user queries and determine their complexity level and processing requirements.\\n\\nCOMPLEXITY LEVELS:\\n1. SIMPLE: Direct questions that can be answered immediately without tools or with single tool use\\n   - Examples: \"What is photosynthesis?\", \"Define machine learning\", \"What\\'s the capital of France?\"\\n   - NOTE: Simple math like \"2+2\" still requires calculator tool but counts as SIMPLE\\n\\n   !ALSO: It can be a logical reasoning or explanation task that does not require tools.\\n   \\n2. MODERATE: Questions requiring 2-4 tool calls or basic multi-step analysis\\n   - Examples: \"Search for recent news about AI\", \"Analyze this CSV file for trends\", \"Calculate ROI from this data\"\\n   - \"Compare two datasets\", \"Summarize multiple documents\"\\n   \\n3. COMPLEX: Multi-step problems requiring planning, multiple tools, and sophisticated reasoning\\n   - Examples: \"Research market trends and create investment strategy\", \"Analyze multiple data sources and predict outcomes\"\\n   - \"Build comprehensive report from various inputs\", \"Multi-stage data processing with validation\"\\n\\nMOST OF THE LOGICAL TASKS ARE SIMPLE, UNLESS THEY REQUIRE TOOLS.\\n\\nASSESSMENT CRITERIA:\\n- Number of distinct steps likely needed (1 = Simple, 2-4 = Moderate, 5+ = Complex)\\n- Tool complexity and dependencies between steps\\n- Data processing requirements and validation needs\\n- Need for intermediate reasoning and synthesis\\n- Risk of failure without proper step-by-step planning\\n- Presence of calculations (automatically requires tool usage)\\n\\nSPECIAL CONSIDERATIONS:\\n- Any calculation/counting task requires tools (affects complexity assessment)\\n- File analysis tasks usually need multiple steps (load + analyze + calculate)\\n- Research tasks typically need search + fetch + synthesis steps\\n- Comparison tasks need separate analysis steps for each item being compared\\n\\nRULES:\\n- SIMPLE queries may bypass planning for non-calculation tasks\\n- MODERATE queries benefit from lightweight planning\\n- COMPLEX queries require full planning with fallbacks\\n- When in doubt, err toward higher complexity\\n- Calculation tasks are never truly \"simple\" due to mandatory tool usage\\n\\nAnalyze the query and respond with your assessment.', additional_kwargs={}, response_metadata={}, id='db109164-6e6e-4c1f-82bb-93d6d9b64e6a'),\n",
+       "  HumanMessage(content='Query: What is 2+2', additional_kwargs={}, response_metadata={}, id='6b9afadb-3463-40a2-989b-19f8a237f7fc'),\n",
+       "  AIMessage(content='2 + 2 = 4', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 80, 'prompt_tokens': 1638, 'total_tokens': 1718, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 64, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-5-mini-2025-08-07', 'system_fingerprint': None, 'id': 'chatcmpl-CId3zSwgGIoDxYMuwG2xJfCLDiVuM', 'service_tier': 'default', 'finish_reason': 'stop', 'logprobs': None}, id='run--210d298d-a542-4458-8933-93ebf4c7bac0-0', usage_metadata={'input_tokens': 1638, 'output_tokens': 80, 'total_tokens': 1718, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 64}})],\n",
+       " 'query': 'What is 2+2',\n",
+       " 'final_answer': 'FINAL ANSWER: 4',\n",
        " 'plan': None,\n",
-       " 'complexity_assessment': ComplexityLevel(level='simple', reasoning='Initial state: 200 coins, all but 30 are face-up → 30 face-down (tails). He takes 30 coins; if x of those were face-down, the remaining pile has 30−x face-down. Flipping the 30-coin pile turns its face-down count into 30−x as well, so both piles have equal face-down coins. The larger pile was observed to have 14 face-down coins, so his pile also has 14 face-down coins. His reward is 2 gold coins per face-down coin in his pile: 14×2 = 28.', needs_planning=False, suggested_approach='Use simple counting: compute initial number of face-down coins (30), let x be face-down among the 30 taken, show flipping yields equal counts, then multiply the final face-down count in his pile by 2 to get the reward.'),\n",
+       " 'complexity_assessment': ComplexityLevel(level='simple', reasoning='This is a single-step arithmetic question (2+2). Although calculations technically require a tool per the special considerations, this is trivial and requires only one immediate operation, so it is SIMPLE.', needs_planning=False, suggested_approach='Perform the basic arithmetic (2+2) and return the result (4). No detailed planning or multi-step processing needed.'),\n",
        " 'current_step': 0,\n",
        " 'reasoning_done': False,\n",
        " 'files': [],\n",
-       " 'critique_feedback': CritiqueFeedback(quality_score=8, is_complete=True, is_accurate=True, missing_elements=[], errors_found=[\"Minor imprecise phrasing: the report mentions 'conservation of face-down coins' which is misleading — flipping changes the total number of face-down coins. The correct point is that after flipping the removed 30 coins, the removed pile ends up with (30 - x) face-down coins, which equals the remaining pile's unchanged count of (30 - x).\", 'No explicit, single-sentence statement answering the two parts of the query (Did he succeed? How many gold coins did he win?). The final numeric answer is present but the success statement is implicit.'], suggested_improvements=[\"Clarify the flipping logic and avoid the word 'conservation' for face-down coins; explicitly show how removed-pile face-down count transforms from x to (30 - x).\", \"Add an explicit conclusion sentence: e.g., 'Yes — he succeeded; his pile has 14 face-down coins after flipping, so he wins 14 * 2 = 28 gold.'\", 'Add a brief sanity check (optional): pick an example x (like x = 16) and show counts before and after flipping to demonstrate consistency.', 'If following strict tooling policies, note that no external tools were required for this simple algebraic reasoning. If automated-tool usage is mandatory in your environment, run a quick symbolic/numeric check with the chosen tool and cite it.'], needs_replanning=False, replan_instructions=None),\n",
+       " 'critique_feedback': CritiqueFeedback(quality_score=8, is_complete=True, is_accurate=True, missing_elements=[], errors_found=[\"Performed the calculation mentally rather than using an external computational tool (triggers the evaluation framework's manual-calculation penalty).\"], suggested_improvements=['Use a computational tool or explicitly show the calculation steps even for trivial arithmetic to avoid the manual-calculation policy violation (e.g., evaluate with a calculator tool or print the operation and result).', \"Explicitly state assumptions up front (that '+' is standard integer addition in base 10) and, when relevant, ask a clarifying question if the user might have meant a nonstandard interpretation (modular arithmetic, different base, operator overloading).\", 'For transparency, include a short note citing the arithmetic rule used (e.g., basic integer addition) when delivering the result, even though the operation is trivial.'], needs_replanning=False, replan_instructions=None),\n",
        " 'iteration_count': 1,\n",
        " 'max_iterations': 10,\n",
-       " 'execution_report': ExecutionReport(query_summary='Riddle: 200 coins where all but 30 are face-up (so 30 face-down). The adventurer removed 30 coins as his pile (unknown orientations), flipped each coin in that pile, then observed the larger pile contained 14 face-down coins. Determine whether he succeeded and how many coins he won (2 gold per face-down coin in his pile).', approach_used=\"Algebraic reasoning with simple variables: let x = number of face-down coins initially in the 30-coin pile removed. Use conservation of face-down coins to compute final counts after flipping, then compute reward = 2 * (final face-downs in adventurer's pile).\", tools_executed=[], key_findings=['Total coins = 200. Initially face-down coins = 30 (since all but 30 are face-up).', 'Let x = number of face-down coins among the 30 coins removed. After flipping those 30 coins, that pile has (30 - x) face-down coins.', 'The remaining (larger) pile has initial face-down coins = 30 - x, which matches (30 - x) after the flip, so both piles have equal face-down counts.', 'Given the larger pile was observed to have 14 face-down coins, 30 - x = 14 => x = 16.', \"Therefore the adventurer's pile also has 14 face-down coins after flipping, yielding a reward of 14 * 2 = 28 coins.\"], data_sources=['Problem statement provided in the query', 'Basic arithmetic/algebra reasoning'], assumptions_made=[\"Interpretation 'all but 30 are face-up' means exactly 30 coins are face-down initially.\", \"The adventurer's pile is the 30-coin pile he removed and flipped; the 'larger pile' refers to the remaining 170-coin pile.\", \"Reward is exactly 2 gold coins per face-down coin in the adventurer's pile, as stated.\"], confidence_level='high', limitations=['Solution depends on standard interpretation of the riddle wording; if alternative interpretations were intended, results could differ.', 'No external references were used; reasoning is self-contained.'], final_answer='28')}"
+       " 'execution_report': ExecutionReport(query_summary=\"User asked for the numeric result of the arithmetic expression '2+2'.\", approach_used=\"Direct evaluation using basic arithmetic: interpreted '+' as standard integer addition and computed the sum mentally without invoking external tools or files.\", tools_executed=[], key_findings=[\"The expression '2+2' was interpreted as standard integer addition.\", 'Computed result is 4.', 'No external tools or data were required to compute the result.'], data_sources=['Basic arithmetic rules (internal knowledge)', 'Conversation history confirming the query and an earlier direct answer'], assumptions_made=[\"The '+' operator denotes standard arithmetic addition on integers.\", 'Numbers are in the usual base-10 system and no special context (e.g., modular arithmetic or symbolic manipulation) was intended.'], confidence_level='high', limitations=['If the user intended a nonstandard context (modulo arithmetic, different base, or overloaded operator semantics), the answer could differ.', 'Extremely simple query; few realistic limitations beyond contextual ambiguity.'], final_answer='4')}"
       ]
      },
      "execution_count": 5,
@@ -129,10 +129,10 @@
    "outputs": [],
    "source": [
     "#TO-DO\n",
-    "#1. Check routing with REPLANNER -> может придумывать несуществующие инструменты\n",
-    "#2. Add crawling tool\n",
-    "#3. Enhance description of coder tool and прописать более четко в промпте важность вывода через print() или return или result/_\n",
-    "#4. Смягчить критика"
+    "#1. Check routing with REPLANNER -> может придумывать несуществующие инструменты -> PARTIALLY COMPLETED\n",
+    "#2. Add crawling tool \n",
+    "#3. Enhance description of coder tool and прописать более четко в промпте важность вывода через print() или return или result/_ -> COMPLETED?\n",
+    "#4. Смягчить критика COMPLETED"
    ]
   }
  ],