Update agent.py

agent.py

@@ -1,452 +1,385 @@
-BROWSE_PROMPT = """
-You are the GAIA Web Query Planner.
-Given:
-  • task: a GAIA question requiring factual lookup
-  • content: a list of any snippets or context already gathered (may be empty)
-Your job is to propose 2–3 concise search queries that will help answer the task.
-Output **only** a JSON object matching this schema:
-```json
-{ "queries": ["first query", "second query", …] }
-Do not include any other text or explanations.
-"""
-
-
-SYSTEM_PROMPT = """You are a helpful assistant tasked with answering questions using a set of tools.
-Now, I will ask you a question. Report your thoughts, and finish 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 rules above for each element (number or string), ensure there is exactly one space after each comma.
-Your answer should only start with "FINAL ANSWER: ", then follows with the answer. """
-
-import os
-import json
-import torch
-import base64
-import requests
-import mimetypes
-from PIL import Image
-from langchain_core.tools import tool
-from tavily import TavilyClient
-from langchain_groq import ChatGroq
-from dataclasses import dataclass, field
-from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, START, END, MessagesState
-from langchain_experimental.utilities import PythonREPL
-from langchain_core.messages import SystemMessage, HumanMessage
-from typing import TypedDict, List, Dict, Any, Optional, Annotated
-from transformers import Blip2Processor, Blip2ForConditionalGeneration
-from langchain_community.document_loaders import WikipediaLoader
-from langchain_community.document_loaders import ArxivLoader
-from langgraph.prebuilt import ToolNode, tools_condition
-from langchain_core.messages import SystemMessage, HumanMessage
-
-# GPT_4o_API_KEY  = os.environ["GPT_4o_API_KEY"]
-GPT_4o_API_KEY    = os.environ["META_LLAMA_4_MAVERICK"]
-GROQ_API_KEY      = os.environ["GROQ_API_KEY"]
-TAVILY_API_KEY    = os.environ["TAVILY_API_KEY"]
-Pixtral12B_API    = os.environ["Pixtral12B_API"]
-
-API_URL   = "https://openrouter.ai/api/v1/chat/completions"
-tavily = TavilyClient(api_key=TAVILY_API_KEY)
-
-
-
-# ===  TOOL STUBS ===
-@tool
-def python_repl_tool(query: str) -> str:
-    """
-    Execute Python query like calculations; return printed output.
-
-    Args:
-      query: The calculation formula.
-
-    Returns:
-      The result of the code exacuation
-    """
-    python_repl = PythonREPL()
-    return python_repl.run(query)
-
-@tool
-def web_search_with_LLM(query: str) -> List[str]:
-  """
-  Use the LLM model to learn more about the query then
-  Search the web for `query`, return top‐3 text snippets.
-
-  Args:
-    query: The search query.
-
-  Returns:
-      A concise details about the query from internet.
-  """
-  model = ChatOpenAI(openai_api_key=GPT_4o_API_KEY,
-                          base_url="https://openrouter.ai/api/v1",
-                          # model_name="gpt-4o",
-                          temperature=0,
-                          max_tokens=512)
-  resp = model.invoke([
-    SystemMessage(content=BROWSE_PROMPT),
-    HumanMessage(content=json.dumps({"task": query}))
-  ])
-  raw = resp.content.strip()
-  try:
-      queries = json.loads(raw)["queries"]
-  except Exception:
-      # fallback: just use the raw task as a single query
-      queries = [query]
-
-  #go through the queries we generted and search for them in Tavily
-  content = []
-  for q in queries:
-    response = tavily.search(query=q, max_results=3)
-    #append the new content to the old contetnt and return it
-    for doc in response['results']:
-      print(doc.keys())
-      content.append(f'<Document source="{doc["url"]}" confidence score="{doc["score"]}"/>\n{doc["content"]}\n</Document>')
-  return {"web_results": content}
-
-
-@tool
-def web_search(query: str) -> str:
-    """Search Tavily for a query and return maximum 3 results.
-    Args:
-        query: The search query.
-    Returns:
-        A concise details about the query from internet."""
-    # search_docs = TavilySearchResults(max_results=3).invoke(query=query)
-    response = tavily.search(query=query, max_results=3)
-    content = []
-    for doc in response['results']:
-      content.append(f'<Document source="{doc["url"]}" confidence score="{doc["score"]}"/>\n{doc["content"]}\n</Document>')
-    return {"web_results": formatted_search_docs}
-
-
-
-# === 1. Initialize the BLIP‑2 model & processor once ===
-# You can choose a smaller or larger BLIP‑2 variant as needed.
-MODEL_NAME = "Salesforce/blip2-opt-2.7b"
-MODEL_NAME = "Salesforce/blip2-flan-t5-xl"  # much smaller, still strong
-processor = Blip2Processor.from_pretrained(MODEL_NAME)
-model_blip2 = Blip2ForConditionalGeneration.from_pretrained(MODEL_NAME).to("cuda" if torch.cuda.is_available() else "cpu")
-
-
-@tool
-def vision_caption_with_LLM(image_path: str, max_length: Optional[int] = 64) -> str:
-    """
-    Generate a natural‑language caption for the image at `image_path`.
-    Args:
-      image_path: Local filesystem path (or URL fetched locally) to an image file.
-      max_length: Maximum number of tokens in the generated caption (default: 64).
-    Returns:
-      A concise, human‑readable caption describing the image content.
-    """
-    headers = {
-        "Authorization": f"Bearer {os.getenv('Pixtral12B_API')}",
-        "Content-Type": "application/json"
-    }
-
-    # Read and encode the image
-    with open(image_path, "rb") as image_file:
-        base64_image = base64.b64encode(image_file.read()).decode('utf-8')
-
-    messages = [
-        {
-          "role": "user",
-          "content": [
-              {
-                "type": "text",
-                "text": "What's in this image?"
-              },
-              {
-                "type": "image_url",
-                "image_url": {
-                    "url": f"data:image/jpeg;base64,{base64_image}"
-                }
-              }
-            ]
-        }
-    ]
-
-    payload = {
-        "model": "google/gemini-2.0-flash-001",
-        "messages": messages
-    }
-
-    response = requests.post(API_URL, headers=headers, json=payload)
-    response.raise_for_status()
-
-    # The HF endpoint returns JSON like {"generated_text": "...caption..."}
-    result = response.json()
-    # Some endpoints return a list of dicts, e.g. [{"generated_text": "..."}]
-    if isinstance(result, list) and "generated_text" in result[0]:
-        return result[0]["generated_text"]
-    elif "generated_text" in result:
-        return result["generated_text"]
-    else:
-        # fallback: return raw text
-        return str(result)
-
-
-
-@tool
-def vision_caption(image_path: str) -> str:
-    """
-    Extract text from an image using OCR library pytesseract (if available).
-    Args:
-        image_path (str): the path to the image file.
-    Returns:
-      A concise, human‑readable caption describing the image content.
-    """
-    try:
-        # Open the image
-        image = Image.open(image_path)
-
-        # Extract text from the image
-        text = pytesseract.image_to_string(image)
-
-        return f"Extracted text from image:\n\n{text}"
-    except Exception as e:
-        return f"Error extracting text from image: {str(e)}"
-
-
-@tool
-def wiki_search(query: str) -> str:
-    """Search Wikipedia for a query and return maximum 2 results.
-
-    Args:
-        query: The search query.
-    Returns:
-        Search results about the query from the Wikipedia website
-    """
-    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
-    formatted_search_docs = "\n\n---\n\n".join(
-        [
-            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
-            for doc in search_docs
-        ])
-    return {"wiki_results": formatted_search_docs}
-
-
-@tool
-def arvix_search(query: str) -> str:
-    """Search Arxiv for a query and return maximum 3 result.
-
-    Args:
-        query: The search query.
-    Returns:
-        Search results about the query from the Arxiv website
-        """
-    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
-    formatted_search_docs = "\n\n---\n\n".join(
-        [
-            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
-            for doc in search_docs
-        ])
-    return {"arvix_results": formatted_search_docs}
-
-
-
-@tool
-def download_file_from_url(url: str, filename: Optional[str] = None) -> str:
-    """
-    Download a file from a URL and save it to a temporary location.
-    Args:
-        url (str): the URL of the file to download.
-        filename (str, optional): the name of the file. If not provided, a random name file will be created.
-    Returns:
-      Nothing
-    """
-    try:
-        # Parse URL to get filename if not provided
-        if not filename:
-            path = urlparse(url).path
-            filename = os.path.basename(path)
-            if not filename:
-                filename = f"downloaded_{uuid.uuid4().hex[:8]}"
-
-        # Create temporary file
-        temp_dir = tempfile.gettempdir()
-        filepath = os.path.join(temp_dir, filename)
-
-        # Download the file
-        response = requests.get(url, stream=True)
-        response.raise_for_status()
-
-        # Save the file
-        with open(filepath, "wb") as f:
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
-
-        return f"File downloaded to {filepath}. You can read this file to process its contents."
-    except Exception as e:
-        return f"Error downloading file: {str(e)}"
-
-
-
-@tool
-def file_reader_with_LLM(file_path: str) -> str:
-    """
-    Sends a PDF or a text file to OpenRouter’s chat API and returns the model’s answer.
-
-    Args:
-        file_path (str): the path to the CSV file.
-    Returns:
-        The conetent inside the PDF/Text file
-    """
-    b64 = base64.b64encode(open(file_path,"rb").read()).decode()
-    payload = {
-      "model": "gpt-4o-mini",
-      "messages": [
-        {"role":"system","content":"You are a GAIA‑style document assistant."},
-        {"role":"user","content":[
-            {"type":"file","file":{"filename":os.path.basename(file_path),"file_data":f"data:application/pdf;base64,{b64}"}}
-        ]}
-      ]
-    }
-    headers = {"Authorization":f"Bearer {os.getenv('GPT_4o_API_KEY')}"}
-    res = requests.post(API_URL, json=payload, headers=headers)
-    res.raise_for_status()
-    content = res.json()["choices"][0]["message"]["content"]
-    # Extract FINAL ANSWER:
-    for line in content.splitlines():
-        if line.startswith("FINAL ANSWER:"):
-            return line.split(":",1)[1].strip()
-    return content
-
-
-
-@tool
-def file_reader(file_path: str) -> str:
-    """
-    Analyze a text file using pandas and answer a question about it.
-    The file can be any of excel, csv, tsv, xls, json, txt or log.
-    Args:
-        file_path (str): the path to the CSV file.
-    Returns:
-      The conetent inside the PDF/Text file
-    """
-    try:
-        _, ext = os.path.splitext(file_path.lower())
-        if ext in {".csv", ".tsv"}:
-            sep = "\t" if ext == ".tsv" else ","
-            data = pd.read_csv(file_path, sep=sep)
-        if ext in {".xls", ".xlsx"}:
-            data = pd.read_excel(file_path)
-        if ext == ".json":
-            data = pd.read_json(file_path)
-        if ext in {".txt", ".log"}:
-            with open(file_path, "r", encoding="utf-8") as f:
-                data = f.read()
-
-        # Run various analyses based on the query
-        result = f"text file loaded with {len(data)} rows and {len(data.columns)} columns.\n"
-        result += f"Columns: {', '.join(data.columns)}\n\n"+\
-                    "Summary statistics:\n" + str(data.describe())
-        # Add summary statistics
-        return result
-
-    except Exception as e:
-        return f"Error analyzing text file: {str(e)}"
-
-
-
-
-
-
-
-
-
-tools = [python_repl_tool,
-          # web_search_with_LLM,
-          web_search,
-          vision_caption,
-          # vision_caption_with_LLM,
-          arvix_search,
-          wiki_search,
-          download_file_from_url,
-          # file_reader_with_LLM,
-          file_reader]
-
-
-
-class EsiAgent:
-    def __init__(self, level=1):
-        # 1) Instantiate the LLM
-        llm = ChatOpenAI(
-            base_url="https://api.groq.com/openai/v1",  # Groq's endpoint
-            openai_api_key=GROQ_API_KEY,
-            # model_name='qwen-qwq-32b',
-            # model_name="mixtral-8x7b-32768", 
-            model_name="meta-llama/llama-4-scout-17b-16e-instruct", #, llama3-70b-8192, etc.
-            # or gemma-7b-it, llama3-70b-8192, etc.
-            temperature=0,
-            # max_tokens=128
-            max_tokens=512
-        )
-        # 2) Bind your tools
-        llm_with_tools = llm.bind_tools(tools)
-
-        # 3) Single system message
-        self.sys_msg = SystemMessage(content=SYSTEM_PROMPT)
-
-        # 4) Assistant node
-        self.tool_numbers = level * 3
-        def assistant(state):
-            print(333333333333333333333333333333333333333333, self.tool_numbers)
-            if self.tool_numbers <= 0:
-              return {"messages": state["messages"]}
-            self.tool_numbers -= 1
-            return {"messages": [llm_with_tools.invoke(state["messages"])]}
-
-              
-        # 5) Build the graph
-        builder = StateGraph(MessagesState)
-        builder.add_node("assistant", assistant)
-        builder.add_node("tools", ToolNode(tools))
-        builder.add_edge(START, "assistant")
-        builder.add_conditional_edges("assistant", tools_condition)
-        builder.add_edge("tools", "assistant")
+# BROWSE_PROMPT = """
+# You are the GAIA Web Query Planner.
+# Given:
+#   • task: a GAIA question requiring factual lookup
+#   • content: a list of any snippets or context already gathered (may be empty)
+# Your job is to propose 2–3 concise search queries that will help answer the task.
+# Output **only** a JSON object matching this schema:
+# ```json
+# { "queries": ["first query", "second query", …] }
+# Do not include any other text or explanations.
+# """
+
+
+# SYSTEM_PROMPT = """You are a helpful assistant tasked with answering questions using a set of tools.
+# Now, I will ask you a question. Report your thoughts, and finish 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 rules above for each element (number or string), ensure there is exactly one space after each comma.
+# Your answer should only start with "FINAL ANSWER: ", then follows with the answer. """
+
+# import os
+# import json
+# import torch
+# import base64
+# import requests
+# import mimetypes
+# from PIL import Image
+# from langchain_core.tools import tool
+# from tavily import TavilyClient
+# from langchain_groq import ChatGroq
+# from dataclasses import dataclass, field
+# from langchain_openai import ChatOpenAI
+# from langgraph.graph import StateGraph, START, END, MessagesState
+# from langchain_experimental.utilities import PythonREPL
+# from langchain_core.messages import SystemMessage, HumanMessage
+# from typing import TypedDict, List, Dict, Any, Optional, Annotated
+# from transformers import Blip2Processor, Blip2ForConditionalGeneration
+# from langchain_community.document_loaders import WikipediaLoader
+# from langchain_community.document_loaders import ArxivLoader
+# from langgraph.prebuilt import ToolNode, tools_condition
+# from langchain_core.messages import SystemMessage, HumanMessage
+
+# # GPT_4o_API_KEY  = os.environ["GPT_4o_API_KEY"]
+# GPT_4o_API_KEY    = os.environ["META_LLAMA_4_MAVERICK"]
+# GROQ_API_KEY      = os.environ["GROQ_API_KEY"]
+# TAVILY_API_KEY    = os.environ["TAVILY_API_KEY"]
+# Pixtral12B_API    = os.environ["Pixtral12B_API"]
+
+# API_URL   = "https://openrouter.ai/api/v1/chat/completions"
+# tavily = TavilyClient(api_key=TAVILY_API_KEY)
+
+
+
+# # ===  TOOL STUBS ===
+# @tool
+# def python_repl_tool(query: str) -> str:
+#     """
+#     Execute Python query like calculations; return printed output.
+
+#     Args:
+#       query: The calculation formula.
+
+#     Returns:
+#       The result of the code exacuation
+#     """
+#     python_repl = PythonREPL()
+#     return python_repl.run(query)
+
+# @tool
+# def web_search_with_LLM(query: str) -> List[str]:
+#   """
+#   Use the LLM model to learn more about the query then
+#   Search the web for `query`, return top‐3 text snippets.
+
+#   Args:
+#     query: The search query.
+
+#   Returns:
+#       A concise details about the query from internet.
+#   """
+#   model = ChatOpenAI(openai_api_key=GPT_4o_API_KEY,
+#                           base_url="https://openrouter.ai/api/v1",
+#                           # model_name="gpt-4o",
+#                           temperature=0,
+#                           max_tokens=512)
+#   resp = model.invoke([
+#     SystemMessage(content=BROWSE_PROMPT),
+#     HumanMessage(content=json.dumps({"task": query}))
+#   ])
+#   raw = resp.content.strip()
+#   try:
+#       queries = json.loads(raw)["queries"]
+#   except Exception:
+#       # fallback: just use the raw task as a single query
+#       queries = [query]
+
+#   #go through the queries we generted and search for them in Tavily
+#   content = []
+#   for q in queries:
+#     response = tavily.search(query=q, max_results=3)
+#     #append the new content to the old contetnt and return it
+#     for doc in response['results']:
+#       print(doc.keys())
+#       content.append(f'<Document source="{doc["url"]}" confidence score="{doc["score"]}"/>\n{doc["content"]}\n</Document>')
+#   return {"web_results": content}
+
+
+# @tool
+# def web_search(query: str) -> str:
+#     """Search Tavily for a query and return maximum 3 results.
+#     Args:
+#         query: The search query.
+#     Returns:
+#         A concise details about the query from internet."""
+#     # search_docs = TavilySearchResults(max_results=3).invoke(query=query)
+#     response = tavily.search(query=query, max_results=3)
+#     content = []
+#     for doc in response['results']:
+#       content.append(f'<Document source="{doc["url"]}" confidence score="{doc["score"]}"/>\n{doc["content"]}\n</Document>')
+#     return {"web_results": formatted_search_docs}
+
+
+
+# # === 1. Initialize the BLIP‑2 model & processor once ===
+# # You can choose a smaller or larger BLIP‑2 variant as needed.
+# MODEL_NAME = "Salesforce/blip2-opt-2.7b"
+# MODEL_NAME = "Salesforce/blip2-flan-t5-xl"  # much smaller, still strong
+# processor = Blip2Processor.from_pretrained(MODEL_NAME)
+# model_blip2 = Blip2ForConditionalGeneration.from_pretrained(MODEL_NAME).to("cuda" if torch.cuda.is_available() else "cpu")
+
+
+# @tool
+# def vision_caption_with_LLM(image_path: str, max_length: Optional[int] = 64) -> str:
+#     """
+#     Generate a natural‑language caption for the image at `image_path`.
+#     Args:
+#       image_path: Local filesystem path (or URL fetched locally) to an image file.
+#       max_length: Maximum number of tokens in the generated caption (default: 64).
+#     Returns:
+#       A concise, human‑readable caption describing the image content.
+#     """
+#     headers = {
+#         "Authorization": f"Bearer {os.getenv('Pixtral12B_API')}",
+#         "Content-Type": "application/json"
+#     }
+
+#     # Read and encode the image
+#     with open(image_path, "rb") as image_file:
+#         base64_image = base64.b64encode(image_file.read()).decode('utf-8')
+
+#     messages = [
+#         {
+#           "role": "user",
+#           "content": [
+#               {
+#                 "type": "text",
+#                 "text": "What's in this image?"
+#               },
+#               {
+#                 "type": "image_url",
+#                 "image_url": {
+#                     "url": f"data:image/jpeg;base64,{base64_image}"
+#                 }
+#               }
+#             ]
+#         }
+#     ]
+
+#     payload = {
+#         "model": "google/gemini-2.0-flash-001",
+#         "messages": messages
+#     }
+
+#     response = requests.post(API_URL, headers=headers, json=payload)
+#     response.raise_for_status()
+
+#     # The HF endpoint returns JSON like {"generated_text": "...caption..."}
+#     result = response.json()
+#     # Some endpoints return a list of dicts, e.g. [{"generated_text": "..."}]
+#     if isinstance(result, list) and "generated_text" in result[0]:
+#         return result[0]["generated_text"]
+#     elif "generated_text" in result:
+#         return result["generated_text"]
+#     else:
+#         # fallback: return raw text
+#         return str(result)
+
+
+
+# @tool
+# def vision_caption(image_path: str) -> str:
+#     """
+#     Extract text from an image using OCR library pytesseract (if available).
+#     Args:
+#         image_path (str): the path to the image file.
+#     Returns:
+#       A concise, human‑readable caption describing the image content.
+#     """
+#     try:
+#         # Open the image
+#         image = Image.open(image_path)
+
+#         # Extract text from the image
+#         text = pytesseract.image_to_string(image)
+
+#         return f"Extracted text from image:\n\n{text}"
+#     except Exception as e:
+#         return f"Error extracting text from image: {str(e)}"
+
+
+# @tool
+# def wiki_search(query: str) -> str:
+#     """Search Wikipedia for a query and return maximum 2 results.
+
+#     Args:
+#         query: The search query.
+#     Returns:
+#         Search results about the query from the Wikipedia website
+#     """
+#     search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
+#     formatted_search_docs = "\n\n---\n\n".join(
+#         [
+#             f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+#             for doc in search_docs
+#         ])
+#     return {"wiki_results": formatted_search_docs}
+
+
+# @tool
+# def arvix_search(query: str) -> str:
+#     """Search Arxiv for a query and return maximum 3 result.
+
+#     Args:
+#         query: The search query.
+#     Returns:
+#         Search results about the query from the Arxiv website
+#         """
+#     search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+#     formatted_search_docs = "\n\n---\n\n".join(
+#         [
+#             f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+#             for doc in search_docs
+#         ])
+#     return {"arvix_results": formatted_search_docs}
+
+
+
+# @tool
+# def download_file_from_url(url: str, filename: Optional[str] = None) -> str:
+#     """
+#     Download a file from a URL and save it to a temporary location.
+#     Args:
+#         url (str): the URL of the file to download.
+#         filename (str, optional): the name of the file. If not provided, a random name file will be created.
+#     Returns:
+#       Nothing
+#     """
+#     try:
+#         # Parse URL to get filename if not provided
+#         if not filename:
+#             path = urlparse(url).path
+#             filename = os.path.basename(path)
+#             if not filename:
+#                 filename = f"downloaded_{uuid.uuid4().hex[:8]}"
+
+#         # Create temporary file
+#         temp_dir = tempfile.gettempdir()
+#         filepath = os.path.join(temp_dir, filename)
+
+#         # Download the file
+#         response = requests.get(url, stream=True)
+#         response.raise_for_status()
+
+#         # Save the file
+#         with open(filepath, "wb") as f:
+#             for chunk in response.iter_content(chunk_size=8192):
+#                 f.write(chunk)
+
+#         return f"File downloaded to {filepath}. You can read this file to process its contents."
+#     except Exception as e:
+#         return f"Error downloading file: {str(e)}"
+
+
+
+# @tool
+# def file_reader_with_LLM(file_path: str) -> str:
+#     """
+#     Sends a PDF or a text file to OpenRouter’s chat API and returns the model’s answer.
+
+#     Args:
+#         file_path (str): the path to the CSV file.
+#     Returns:
+#         The conetent inside the PDF/Text file
+#     """
+#     b64 = base64.b64encode(open(file_path,"rb").read()).decode()
+#     payload = {
+#       "model": "gpt-4o-mini",
+#       "messages": [
+#         {"role":"system","content":"You are a GAIA‑style document assistant."},
+#         {"role":"user","content":[
+#             {"type":"file","file":{"filename":os.path.basename(file_path),"file_data":f"data:application/pdf;base64,{b64}"}}
+#         ]}
+#       ]
+#     }
+#     headers = {"Authorization":f"Bearer {os.getenv('GPT_4o_API_KEY')}"}
+#     res = requests.post(API_URL, json=payload, headers=headers)
+#     res.raise_for_status()
+#     content = res.json()["choices"][0]["message"]["content"]
+#     # Extract FINAL ANSWER:
+#     for line in content.splitlines():
+#         if line.startswith("FINAL ANSWER:"):
+#             return line.split(":",1)[1].strip()
+#     return content
+
+
+
+# @tool
+# def file_reader(file_path: str) -> str:
+#     """
+#     Analyze a text file using pandas and answer a question about it.
+#     The file can be any of excel, csv, tsv, xls, json, txt or log.
+#     Args:
+#         file_path (str): the path to the CSV file.
+#     Returns:
+#       The conetent inside the PDF/Text file
+#     """
+#     try:
+#         _, ext = os.path.splitext(file_path.lower())
+#         if ext in {".csv", ".tsv"}:
+#             sep = "\t" if ext == ".tsv" else ","
+#             data = pd.read_csv(file_path, sep=sep)
+#         if ext in {".xls", ".xlsx"}:
+#             data = pd.read_excel(file_path)
+#         if ext == ".json":
+#             data = pd.read_json(file_path)
+#         if ext in {".txt", ".log"}:
+#             with open(file_path, "r", encoding="utf-8") as f:
+#                 data = f.read()
+
+#         # Run various analyses based on the query
+#         result = f"text file loaded with {len(data)} rows and {len(data.columns)} columns.\n"
+#         result += f"Columns: {', '.join(data.columns)}\n\n"+\
+#                     "Summary statistics:\n" + str(data.describe())
+#         # Add summary statistics
+#         return result
+
+#     except Exception as e:
+#         return f"Error analyzing text file: {str(e)}"
+
+
+
+
+
+
+
+
+
+# tools = [python_repl_tool,
+#           # web_search_with_LLM,
+#           web_search,
+#           vision_caption,
+#           # vision_caption_with_LLM,
+#           arvix_search,
+#           wiki_search,
+#           download_file_from_url,
+#           # file_reader_with_LLM,
+#           file_reader]
 
-        # 6) Compile once
-        self.graph = builder.compile()
 
 
-    def run(self, question: str, files=None, level: int = 1) -> str:
-        """
-        Wraps graph.invoke to run end-to-end on a plain question.
-        """
-        # Build a minimal GAIA payload (if your MessagesState expects more, adjust here)
-        print(33333333333333333333333333333333333333333333333333333333333)
-        # print(self.sys_msg)
-        # print(question)
-        # print(type(self.sys_msg))
-        # print(type(question))
-        initial_state = {
-            # "messages": [self.sys_msg]+[HumanMessage(content=question)],
-            # "messages": [HumanMessage(content=question)] + [self.sys_msg],
-            
-            "messages": [self.sys_msg, HumanMessage(content=question)],
-            # "messages": [self.sys_msg] + [question],
-            # "messages": [self.sys_msg, question],
-        }
-         
-        final_state = self.graph.invoke(initial_state)
-        # Extract final assistant message
-        last_msg = final_state["messages"][-1].content
-        print("GROQ_KEY:", bool(os.getenv("GROQ_API_KEY")))
-        print("LLM resp:", last_msg[:100])
-
-        # If you need to strip off "FINAL ANSWER: " prefix, do it here:
-        if last_msg.startswith("FINAL ANSWER:"):
-            return last_msg[len("FINAL ANSWER:"):].strip()
-        return last_msg.strip()
-        
 # class EsiAgent:
-#     def __init__(self):
+#     def __init__(self, level=1):
 #         # 1) Instantiate the LLM
 #         llm = ChatOpenAI(
-#             openai_api_key=GPT_4o_API_KEY,
-#             base_url="https://openrouter.ai/api/v1",
+#             base_url="https://api.groq.com/openai/v1",  # Groq's endpoint
+#             openai_api_key=GROQ_API_KEY,
+#             # model_name='qwen-qwq-32b',
+#             # model_name="mixtral-8x7b-32768", 
+#             model_name="meta-llama/llama-4-scout-17b-16e-instruct", #, llama3-70b-8192, etc.
+#             # or gemma-7b-it, llama3-70b-8192, etc.
 #             temperature=0,
-#             max_tokens=256
+#             # max_tokens=128
+#             max_tokens=512
 #         )
 #         # 2) Bind your tools
 #         llm_with_tools = llm.bind_tools(tools)
@@ -455,10 +388,15 @@ class EsiAgent:
 #         self.sys_msg = SystemMessage(content=SYSTEM_PROMPT)
 
 #         # 4) Assistant node
+#         self.tool_numbers = level * 3
 #         def assistant(state):
-#             # Prepend sys_msg only if it's not already there
+#             print(333333333333333333333333333333333333333333, self.tool_numbers)
+#             if self.tool_numbers <= 0:
+#               return {"messages": state["messages"]}
+#             self.tool_numbers -= 1
 #             return {"messages": [llm_with_tools.invoke(state["messages"])]}
 
+              
 #         # 5) Build the graph
 #         builder = StateGraph(MessagesState)
 #         builder.add_node("assistant", assistant)
@@ -476,22 +414,331 @@ class EsiAgent:
 #         Wraps graph.invoke to run end-to-end on a plain question.
 #         """
 #         # Build a minimal GAIA payload (if your MessagesState expects more, adjust here)
+#         print(33333333333333333333333333333333333333333333333333333333333)
+#         # print(self.sys_msg)
+#         # print(question)
+#         # print(type(self.sys_msg))
+#         # print(type(question))
 #         initial_state = {
-#             "messages": [HumanMessage(content=question)] + [self.sys_msg]
-
+#             # "messages": [self.sys_msg]+[HumanMessage(content=question)],
+#             # "messages": [HumanMessage(content=question)] + [self.sys_msg],
+            
+#             "messages": [self.sys_msg, HumanMessage(content=question)],
+#             # "messages": [self.sys_msg] + [question],
+#             # "messages": [self.sys_msg, question],
 #         }
-
+         
 #         final_state = self.graph.invoke(initial_state)
 #         # Extract final assistant message
 #         last_msg = final_state["messages"][-1].content
+#         print("GROQ_KEY:", bool(os.getenv("GROQ_API_KEY")))
+#         print("LLM resp:", last_msg[:100])
 
 #         # If you need to strip off "FINAL ANSWER: " prefix, do it here:
 #         if last_msg.startswith("FINAL ANSWER:"):
 #             return last_msg[len("FINAL ANSWER:"):].strip()
 #         return last_msg.strip()
+        
+# # class EsiAgent:
+# #     def __init__(self):
+# #         # 1) Instantiate the LLM
+# #         llm = ChatOpenAI(
+# #             openai_api_key=GPT_4o_API_KEY,
+# #             base_url="https://openrouter.ai/api/v1",
+# #             temperature=0,
+# #             max_tokens=256
+# #         )
+# #         # 2) Bind your tools
+# #         llm_with_tools = llm.bind_tools(tools)
+
+# #         # 3) Single system message
+# #         self.sys_msg = SystemMessage(content=SYSTEM_PROMPT)
+
+# #         # 4) Assistant node
+# #         def assistant(state):
+# #             # Prepend sys_msg only if it's not already there
+# #             return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+# #         # 5) Build the graph
+# #         builder = StateGraph(MessagesState)
+# #         builder.add_node("assistant", assistant)
+# #         builder.add_node("tools", ToolNode(tools))
+# #         builder.add_edge(START, "assistant")
+# #         builder.add_conditional_edges("assistant", tools_condition)
+# #         builder.add_edge("tools", "assistant")
+
+# #         # 6) Compile once
+# #         self.graph = builder.compile()
+
+
+# #     def run(self, question: str, files=None, level: int = 1) -> str:
+# #         """
+# #         Wraps graph.invoke to run end-to-end on a plain question.
+# #         """
+# #         # Build a minimal GAIA payload (if your MessagesState expects more, adjust here)
+# #         initial_state = {
+# #             "messages": [HumanMessage(content=question)] + [self.sys_msg]
+
+# #         }
+
+# #         final_state = self.graph.invoke(initial_state)
+# #         # Extract final assistant message
+# #         last_msg = final_state["messages"][-1].content
+
+# #         # If you need to strip off "FINAL ANSWER: " prefix, do it here:
+# #         if last_msg.startswith("FINAL ANSWER:"):
+# #             return last_msg[len("FINAL ANSWER:"):].strip()
+# #         return last_msg.strip()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+PLANNER_PROMPT = """You are a helpful assistant tasked with answering the question. When formulating your response, make sure that:
+
+1. You follow the necessary steps to solve the problem, using available tools where required.
+2. Once the final result is known, return that result in a clear and concise manner without further elaboration.
+
+You have full access to these tools:
+
+• python_repl_tool(query)  
+  – For any Python query: math, data processing, unit conversions, file parsing (pandas, chess, etc.)  
+  – Always wrap query in `print(...)` so PythonREPL returns the result.
+
+• web_search(query, max_results)  
+  – General factual lookup, definitions, current/historical data.
+
+• wiki_search(query)  
+  – Encyclopedic facts from Wikipedia.
+
+• vision_caption(image_path)  
+  – Describe images, diagrams, or board positions.
+
+• arxiv_search(query)  
+  – Locate scholarly PDF URLs on arXiv.
+
+• download_file_from_url(url)  
+  – Retrieve any PDF, text, or CSV file.
+
+• file_reader(file_path)  
+  – Load CSV/Excel/text into DataFrames or raw strings.
 
+### Your Task
 
+You will receive one JSON payload:
 
+```json
+{ "message": "<message>", "input_files": […]}
+
+
+
+Your job is to plan, execute, reflect, and refine iteratively until you can confidently answer the question:
+
+Plan Stage
+
+Emit exactly one JSON array of step objects. Do not call any tools yet; this is just your plan.
+
+Example plan:
+
+- Emit exactly one JSON array of step objects, e.g.:
+  ```json
+  [
+    {"tool":"web_search","args":{"query":"…","max_results":3}},
+  ]
+  ```
+
+- Do **not** call any tools yet—this is just your plan.
+
+Do not perform any tool calls within the planning stage. Simply structure your plan, ensuring it aligns with the best approach to answer the question.
+
+Iterative Plan Review
+
+After the initial plan, start executing the tools.
+
+Review the results of each tool call. If the results are unsatisfactory, refine your plan, adjust arguments, and ensure you are on the right path.
+
+Always analyze the results carefully, and if necessary, revise the plan or tools based on the insights you gather at each step.
+
+Revisions Based on Results
+
+If the previous step didn’t provide the expected results, revise the plan. Look at the question, tools used, and results from previous steps to improve your approach.
+
+If the plan isn't generating the correct result after five iterations, pass the current plan to the next node (e.g., validator) for further review.
+
+Final Answer Handling
+
+Ensure that FINAL ANSWER is included in the result. If no solution is reached, provide the steps you have taken so far along with the tools used.
+
+Your response should only contain the FINAL ANSWER. Do not include intermediate steps or re-plans once a solution has been found.
+
+If the Answer Cannot Be Found
+
+If the tools and plans fail to deliver a final answer, inform the user. Acknowledge that a solution could not be found and explain the steps taken.
+
+Example message: "I couldn't solve this problem. Here's the sequence of steps I took: ..."
+
+Answer Format
+
+When returning the FINAL ANSWER, ensure it follows this format:
+
+FINAL ANSWER: [Your final answer here]
+
+Use minimal words or a number. If necessary, a comma-separated list is allowed.
+
+Do not include units, unnecessary details, or explanations unless specifically requested.
+
+Key Focus Areas
+The assistant should not merely perform tool calls but should critically evaluate its process at every step.
+
+Keep the overall approach flexible so that if errors or issues arise, the model can adapt and improve its strategy in real-time.
+
+Prioritize efficiency. Once the correct answer is found, avoid unnecessary further actions.
+
+Your answer must always start with "FINAL ANSWER:".
+
+
+### Key Improvements:
+1. **Clearer Instructions for Iteration**: The prompt now emphasizes revising the plan based on results and ensuring that each step is critically evaluated.
+2. **Final Answer Verification**: We ensure that only the final answer is provided in the correct format, and intermediate steps are excluded.
+3. **Revised Plan if Initial Attempt Fails**: If the initial plan doesn't work or if the results don't meet expectations, the plan is revised and tools are adjusted accordingly.
+4. **Error Handling and Clarification**: If a solution can't be found, the model now acknowledges the steps taken and explains why the answer couldn't be solved, improving transparency.
+
+This updated prompt should make your planner node more efficient and capable of adapting to complex scenarios while keeping the process structured and robust.
+
+if you want to return FINAL ANSWER, finish 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 rules above for each element (number or string), ensure there is exactly one space after each comma.
+Your answer should only start with "FINAL ANSWER: ", then follows with the answer.
+
+**Return exactly** either a `FINAL ANSWER:` line or a JSON array of tool calls—nothing else.
+"""
+
+
+
+
+
+
+
+
+
+
+
+class MessagesState(TypedDict):
+    input_file: Optional[str]
+    messages: Annotated[list[AnyMessage], add_messages]
+    final_answer: Optional[str]
+    is_done: Optional[bool]
+    assist_iter: Optional[int]
+
+class EsiAgent:
+    def __init__(self):
+        llm = ChatOpenAI(
+            base_url="https://api.groq.com/openai/v1",
+            openai_api_key=GPT_4o_API_KEY,
+            # model_name="meta-llama/llama-4-scout-17b-16e-instruct",
+            temperature=0,
+            max_tokens=128
+            # max_tokens=256
+        )
+
+        llm_with_tools = llm.bind_tools(tools)
+
+        # 2) Bind your tools
+        llm_with_tools = llm.bind_tools(tools)
+
+        # 3) Single system message
+        self.sys_msg = SystemMessage(content=PLANNER_PROMPT)
+
+        # 4) Assistant node
+        def assistant(state: MessagesState) -> dict:
+          """
+          Assistant node: Validates if a final answer exists or generates the plan.
+          If a final answer is found, it returns it, otherwise, it generates a plan and iterates.
+          """
+
+          resutls_dict = {"tool_names":[],"tool_args":[],"tool_results":[]}
+          # Check if the final answer exists already in previous steps
+          for msg in state["messages"]:
+            if isinstance(msg, ToolMessage):
+              resutls_dict['tool_results'].append(msg.content)
+            elif isinstance(msg, AIMessage) and hasattr(msg, "tool_calls"):
+              for call in msg.tool_calls:
+                resutls_dict['tool_names'].append(call['name'])
+                resutls_dict['tool_args'].append(call['args'])
+
+
+          llm_input = [SystemMessage(content=PLANNER_PROMPT)] + state["messages"]
+
+          ai_resp: AIMessage = llm_with_tools.invoke(llm_input)
+          content = ai_resp.content.strip()
+
+          # Ensure that the FINAL ANSWER is correctly returned
+          s1=len(list(set(resutls_dict['tool_names'])))
+          s2=len(list(set(resutls_dict['tool_names'])))
+          s3=len(list(set(resutls_dict['tool_names'])))
+
+          if s1==s2==s3:
+            state['assist_iter'] += 1
+
+          if "FINAL ANSWER:" in content and (state['assist_iter']>=2 or state['assist_iter']<=5):
+              final_answer = content
+              is_done = True
+          else:
+              final_answer = None
+              is_done = False
+
+          return {
+              "messages": state["messages"] + [ai_resp],
+              "input_file": state.get("input_file", None),
+              "final_answer": final_answer,
+              'assist_iter': state['assist_iter'] + 1,
+              "is_done": is_done,
+          }
+
+
+        # 5) Build the graph
+        builder = StateGraph(MessagesState)
+        builder.add_node("assistant", assistant)
+        builder.add_node("tools",     ToolNode(tools))
+        builder.add_edge(START, "assistant")
+        builder.add_conditional_edges(
+            source="assistant",
+            path=lambda s: s.get("is_done", False),
+            path_map={False: "tools", True: END})
+
+        builder.add_edge("tools", "assistant")
+        self.graph = builder.compile()
+
+
+    def run(self, question: str, files=None) -> str:
+        """
+        Wraps graph.invoke to run end-to-end on a plain question.
+        """
+        # Build a minimal GAIA payload (if your MessagesState expects more, adjust here)
+        initial_state = {
+            "messages": [HumanMessage(content=question)]
+            "input_file": files,
+            "final_answer": "",
+            'is_done': False,
+            'assist_iter': 0
+        }
+
+        final_state = self.graph.invoke(initial_state)
+        return final_state['FINAL ANSWER']
 
 if __name__ == "__main__":
     # question = "Where is the capital of the Iran?"