init commit

.gitignore

@@ -0,0 +1,3 @@
+.python-version
+.env
+.task_files

README.md

@@ -1,13 +1,15 @@
 ---
-title: Learn Agent Unit4
-emoji: 🐢
-colorFrom: blue
-colorTo: yellow
+title: Template Final Assignment
+emoji: 🕵🏻‍♂️
+colorFrom: indigo
+colorTo: indigo
 sdk: gradio
-sdk_version: 5.29.0
+sdk_version: 5.25.2
 app_file: app.py
 pinned: false
-short_description: Submission of final assignment of agent course
+hf_oauth: true
+# optional, default duration is 8 hours/480 minutes. Max duration is 30 days/43200 minutes.
+hf_oauth_expiration_minutes: 480
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agent.py

@@ -0,0 +1,51 @@
+import os
+from typing import TypedDict, Annotated
+from dotenv import load_dotenv
+from langgraph.graph.message import add_messages
+from langchain_core.messages import AnyMessage
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+from langchain_anthropic import ChatAnthropic
+
+from utils.read_file import read_txt_file
+from tools import available_tools
+
+SYS_PROMPT_PATH = "./sys_prompt.txt"
+
+load_dotenv()
+api_key = os.getenv("ANTHROPIC_API_KEY")
+
+llm = ChatAnthropic(
+    model="claude-3-7-sonnet-20250219",
+    temperature=0.5,
+    api_key=api_key,
+    # max_tokens=5000,
+    # thinking={"type": "enabled", "budget_tokens": 2000}
+    )
+tools = available_tools
+llm_with_tools = llm.bind_tools(tools)
+
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]
+
+def assistant(state: AgentState):
+    return {
+        "messages": [llm_with_tools.invoke(state["messages"])],
+    }
+
+builder = StateGraph(AgentState)
+
+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")
+
+my_agent = builder.compile()
+
+SYSTEM_PROMPT = read_txt_file(SYS_PROMPT_PATH)

app.py

@@ -0,0 +1,331 @@
+import os
+import gradio as gr
+import requests
+import inspect
+import base64
+import pandas as pd
+from langchain_core.messages import HumanMessage, SystemMessage
+
+from utils.final_answer import extract_final_answer
+from utils.handle_file import handle_attachment
+from agent import my_agent, SYSTEM_PROMPT
+from assignment_api import get_all_questions, get_one_random_question, submit
+
+
+
+
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+# class BasicAgent:
+#     def __init__(self):
+#         print("BasicAgent initialized.")
+#     def __call__(self, question: str) -> str:
+#         print(f"Agent received question (first 50 chars): {question[:50]}...")
+#         fixed_answer = "This is a default answer."
+#         print(f"Agent returning fixed answer: {fixed_answer}")
+#         return fixed_answer
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the agent on them, submits all answers,
+    and displays the results. Handles attachments if present.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+    
+    # 1. Instantiate Agent (modify this part to create your agent)
+    try:
+        agent = my_agent
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    
+    # In the case of an app running as a hugging Face space, this link points toward your codebase (useful for others so please keep it public)
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+    
+    # 2. Fetch Questions
+    questions_data = get_all_questions()
+    
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    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
+        
+        # 2.2 Handle attachment if present
+        attachment_info = None
+        if "file_name" in item and item["file_name"]:
+            file_name = item.get("file_name")
+            attachment_info = handle_attachment(task_id, file_name)
+            print(f"Attachment handling result: {attachment_info['status']}")
+        
+        try:
+            # Prepare messages based on attachment handling
+            messages = [
+                SystemMessage(content=SYSTEM_PROMPT),
+                SystemMessage(content=f"Current task id: {task_id}")
+            ]
+            
+            # If we have an attachment that Claude can process directly
+            if attachment_info and attachment_info["status"] == "success" and attachment_info["handling"] == "direct":
+                # Encode content for direct inclusion
+                encoded_content = base64.b64encode(attachment_info["raw_content"]).decode('utf-8')
+                content_type = attachment_info["content_type"]
+                
+                # Create multimodal message
+                if content_type.startswith('image/'):
+                    multimodal_content = [
+                        {"type": "text", "text": question_text},
+                        {
+                            "type": "image", 
+                            "source": {
+                                "type": "base64", 
+                                "media_type": content_type,
+                                "data": encoded_content
+                            }
+                        }
+                    ]
+                elif content_type == "application/pdf" or "spreadsheet" in content_type or "excel" in content_type or "csv" in content_type:
+                    multimodal_content = [
+                        {"type": "text", "text": question_text},
+                        {
+                            "type": "file", 
+                            "source": {
+                                "type": "base64", 
+                                "media_type": content_type,
+                                "data": encoded_content
+                            },
+                            "name": attachment_info["file_name"]
+                        }
+                    ]
+                
+                messages.append(HumanMessage(content=multimodal_content))
+                
+            # If we have an attachment that needs tool processing
+            elif attachment_info and attachment_info["status"] == "success" and attachment_info["handling"] == "tool":
+                # Add info about the file to the question
+                file_info = (
+                    f"{question_text}\n\n"
+                    f"Note: This task has an attached file that can be accessed at: {attachment_info['file_path']}\n"
+                    f"File type: {attachment_info['content_type']}"
+                )
+                messages.append(HumanMessage(content=file_info))
+                
+            # If no attachment or error with attachment
+            else:
+                messages.append(HumanMessage(content=question_text))
+            
+            # Invoke the agent with the prepared messages
+            agent_answer = agent.invoke({"messages": messages})
+            submitted_answer = extract_final_answer(agent_answer['messages'][-1].content)
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+            
+        except Exception as e:
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+    
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+    
+    # 4. Prepare Submission 
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+    
+    # 5. Submit
+    return submit(submission_data, results_log)
+
+def run_and_submit_one( profile: gr.OAuthProfile | None):
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+    
+    # 1. Instantiate Agent ( modify this part to create your agent)
+    try:
+        agent = my_agent
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+
+    # 2. Fetch Questions
+    questions_data = get_one_random_question()
+    print("questions_data:", questions_data)
+    
+    # 2.2 Handle attachment if present
+    attachment_info = None
+    if "file_name" in questions_data and questions_data["file_name"]:
+        task_id = questions_data.get("task_id")
+        file_name = questions_data.get("file_name")
+        attachment_info = handle_attachment(task_id, file_name)
+        print(f"Attachment handling result: {attachment_info['status']}")
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
+
+    task_id = questions_data.get("task_id")
+    question_text = questions_data.get("question")
+
+    if not task_id or question_text is None:
+        print(f"Skipping item with missing task_id or question")
+    try:
+            # Prepare messages based on attachment handling
+            messages = [
+                SystemMessage(content=SYSTEM_PROMPT),
+                SystemMessage(content=f"Current task id: {task_id}")
+            ]
+            
+            # If we have an attachment that Claude can process directly
+            if attachment_info and attachment_info["status"] == "success" and attachment_info["handling"] == "direct":
+                # Encode content for direct inclusion
+                encoded_content = base64.b64encode(attachment_info["raw_content"]).decode('utf-8')
+                content_type = attachment_info["content_type"]
+                
+                # Create multimodal message
+                if content_type.startswith('image/'):
+                    multimodal_content = [
+                        {"type": "text", "text": question_text},
+                        {
+                            "type": "image", 
+                            "source": {
+                                "type": "base64", 
+                                "media_type": content_type,
+                                "data": encoded_content
+                            }
+                        }
+                    ]
+                elif content_type == "application/pdf" or "spreadsheet" in content_type or "excel" in content_type or "csv" in content_type:
+                    multimodal_content = [
+                        {"type": "text", "text": question_text},
+                        {
+                            "type": "file", 
+                            "source": {
+                                "type": "base64", 
+                                "media_type": content_type,
+                                "data": encoded_content
+                            },
+                            "name": attachment_info["file_name"]
+                        }
+                    ]
+                
+                messages.append(HumanMessage(content=multimodal_content))
+                
+            # If we have an attachment that needs tool processing
+            elif attachment_info and attachment_info["status"] == "success" and attachment_info["handling"] == "tool":
+                # Add info about the file to the question
+                file_info = (
+                    f"{question_text}\n\n"
+                    f"Note: This task has an attached file that can be accessed at: {attachment_info['file_path']}\n"
+                    f"File type: {attachment_info['content_type']}"
+                )
+                messages.append(HumanMessage(content=file_info))
+                
+            # If no attachment or error with attachment
+            else:
+                messages.append(HumanMessage(content=question_text))
+            
+            # Invoke the agent with the prepared messages
+            agent_answer = agent.invoke({"messages": messages})
+            submitted_answer = extract_final_answer(agent_answer['messages'][-1].content)
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+    except Exception as e:
+            print(f"Error running agent on task {task_id}: {e}")
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission 
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    return submit(submission_data, results_log)
+
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks() as demo:
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+
+        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+
+        ---
+        **Disclaimers:**
+        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
+        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
+        """
+    )
+
+    gr.LoginButton()
+
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    run_one_button = gr.Button("Run one question and submit")
+
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    # Removed max_rows=10 from DataFrame constructor
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
+    run_one_button.click(
+        fn=run_and_submit_one,
+        outputs=[status_output, results_table]
+    )
+
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+
+    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 repo URLs if SPACE_ID is found
+        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(" App Starting ")) + "\n")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)

assignment_api.py

@@ -0,0 +1,122 @@
+from typing import Any
+import pandas as pd
+import requests
+import mimetypes
+
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+def get_files_by_task_id(id: str):
+    files_url = f"{DEFAULT_API_URL}/files/{id}"
+    print(f"Fetching files for task {id} from: {files_url}")
+    try:
+        response = requests.get(files_url, timeout=30)
+        response.raise_for_status()
+        
+        # Return the raw response and content type
+        return {
+            "content": response.content,
+            "content_type": response.headers.get('Content-Type', ''),
+            "status": "success"
+        }
+        
+    except requests.exceptions.RequestException as e:
+        error_message = f"Error fetching file: {e}"
+        print(error_message)
+        return {
+            "status": "error",
+            "error": error_message
+        }
+
+def get_one_random_question():
+    questions_url = f"{DEFAULT_API_URL}/random-question"
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+        return questions_data
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text: {response.text[:500]}")
+        return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+# 2. Fetch Questions
+def get_all_questions():
+    questions_url = f"{DEFAULT_API_URL}/questions"
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+        return questions_data
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text: {response.text[:500]}")
+        return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+# 5. Submit
+def submit(submission_data:dict[str, Any], results_log:list):
+    submit_url = f"{DEFAULT_API_URL}/submit"
+    print(f"Submitting {len(submission_data["answers"])} answers to: {submit_url}")
+    try:
+        print(f"Submitting:", submission_data)
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.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.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except Exception as e:
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df

requirements.txt

@@ -0,0 +1,149 @@
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.11.18
+aiosignal==1.3.2
+annotated-types==0.7.0
+anthropic==0.50.0
+anyio==4.9.0
+attrs==25.3.0
+audioop-lts==0.2.1
+Authlib==1.5.2
+beautifulsoup4==4.13.4
+certifi==2025.1.31
+cffi==1.17.1
+charset-normalizer==3.4.1
+chess==1.11.2
+click==8.1.8
+cryptography==44.0.2
+dataclasses-json==0.6.7
+datasets==3.5.0
+defusedxml==0.7.1
+dill==0.3.8
+distro==1.9.0
+duckduckgo_search==8.0.1
+et_xmlfile==2.0.0
+fastapi==0.115.12
+ffmpy==0.5.0
+filelock==3.18.0
+frozenlist==1.6.0
+fsspec==2024.12.0
+gradio==5.27.0
+gradio_client==1.9.0
+greenlet==3.2.1
+groovy==0.1.2
+h11==0.16.0
+httpcore==1.0.9
+httpx==0.28.1
+httpx-sse==0.4.0
+huggingface-hub==0.30.2
+idna==3.10
+itsdangerous==2.2.0
+Jinja2==3.1.6
+jiter==0.9.0
+joblib==1.4.2
+jsonpatch==1.33
+jsonpointer==3.0.0
+langchain==0.3.24
+langchain-anthropic==0.3.12
+langchain-community==0.3.22
+langchain-core==0.3.56
+langchain-experimental==0.3.4
+langchain-huggingface==0.1.2
+langchain-text-splitters==0.3.8
+langgraph==0.3.34
+langgraph-checkpoint==2.0.24
+langgraph-prebuilt==0.1.8
+langgraph-sdk==0.1.63
+langsmith==0.3.34
+llvmlite==0.44.0
+lxml==5.4.0
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+marshmallow==3.26.1
+mdurl==0.1.2
+more-itertools==10.7.0
+mpmath==1.3.0
+multidict==6.4.3
+multiprocess==0.70.16
+mypy_extensions==1.1.0
+networkx==3.4.2
+numba==0.61.2
+numpy==2.2.5
+nvidia-cublas-cu12==12.6.4.1
+nvidia-cuda-cupti-cu12==12.6.80
+nvidia-cuda-nvrtc-cu12==12.6.77
+nvidia-cuda-runtime-cu12==12.6.77
+nvidia-cudnn-cu12==9.5.1.17
+nvidia-cufft-cu12==11.3.0.4
+nvidia-cufile-cu12==1.11.1.6
+nvidia-curand-cu12==10.3.7.77
+nvidia-cusolver-cu12==11.7.1.2
+nvidia-cusparse-cu12==12.5.4.2
+nvidia-cusparselt-cu12==0.6.3
+nvidia-nccl-cu12==2.26.2
+nvidia-nvjitlink-cu12==12.6.85
+nvidia-nvtx-cu12==12.6.77
+openai-whisper @ git+https://github.com/openai/whisper.git@517a43ecd132a2089d85f4ebc044728a71d49f6e
+openpyxl==3.1.5
+orjson==3.10.16
+ormsgpack==1.9.1
+packaging==24.2
+pandas==2.2.3
+pillow==11.2.1
+primp==0.15.0
+propcache==0.3.1
+pyarrow==19.0.1
+pycparser==2.22
+pydantic==2.11.3
+pydantic-settings==2.9.1
+pydantic_core==2.33.1
+pydub==0.25.1
+Pygments==2.19.1
+python-chess==1.999
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.0
+python-multipart==0.0.20
+pytube==15.0.0
+pytz==2025.2
+PyYAML==6.0.2
+rank-bm25==0.2.2
+regex==2024.11.6
+requests==2.32.3
+requests-toolbelt==1.0.0
+rich==14.0.0
+ruff==0.11.7
+safehttpx==0.1.6
+safetensors==0.5.3
+scikit-learn==1.6.1
+scipy==1.15.2
+semantic-version==2.10.0
+sentence-transformers==4.1.0
+setuptools==79.0.1
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.7
+SQLAlchemy==2.0.40
+starlette==0.46.2
+sympy==1.13.3
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tiktoken==0.9.0
+tokenizers==0.21.1
+tomlkit==0.13.2
+torch==2.7.0
+tqdm==4.67.1
+transformers==4.51.3
+triton==3.3.0
+typer==0.15.2
+typing-inspect==0.9.0
+typing-inspection==0.4.0
+typing_extensions==4.13.2
+tzdata==2025.2
+urllib3==2.4.0
+uvicorn==0.34.2
+websockets==15.0.1
+xxhash==3.5.0
+yarl==1.20.0
+youtube-transcript-api==1.0.3
+zstandard==0.23.0

sys_prompt.txt

@@ -0,0 +1,7 @@
+You are a general AI assistant with tools.
+I will ask you a question. Use your tools, and 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 with spavec after the comma.
+If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise.
+If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise.
+If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+If you use the python_repl tool (code interpreter), always end your code with `print(...)` to see the output.

tools.py

@@ -0,0 +1,235 @@
+import os
+import whisper
+import mimetypes
+import json
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.tools import BraveSearch
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_community.document_loaders import ArxivLoader
+from langchain.tools import Tool, tool
+from youtube_transcript_api import YouTubeTranscriptApi
+from pytube import extract
+from pydantic import BaseModel, Field
+from langchain_experimental.utilities import PythonREPL
+
+@tool
+def get_youtube_transcript(page_url: str) -> str:
+    """Get the transcript of a YouTube video
+    Args:
+        page_url (str): YouTube URL of the video
+    """
+    try:
+        # get video ID from URL
+        video_id = extract.video_id(page_url)
+
+        # get transcript
+        ytt_api = YouTubeTranscriptApi()
+        transcript = ytt_api.fetch(video_id)
+
+        # keep only text
+        txt = '\n'.join([s.text for s in transcript.snippets])
+        return txt
+    except Exception as e:
+        return f"get_youtube_transcript failed: {e}"
+
+@tool
+def multiply(a: float, b: float) -> float:
+    """Multiplies two numbers.
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
+    return a * b
+
+
+@tool
+def add(a: float, b: float) -> float:
+    """Adds two numbers.
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
+    return a + b
+
+
+@tool
+def subtract(a: float, b: float) -> int:
+    """Subtracts two numbers.
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
+    return a - b
+
+
+@tool
+def divide(a: float, b: float) -> float:
+    """Divides two numbers.
+    Args:
+        a (float): the first float number
+        b (float): the second float number
+    """
+    if b == 0:
+        raise ValueError("Cannot divided by zero.")
+    return a / b
+
+
+@tool
+def modulus(a: int, b: int) -> int:
+    """Get the modulus of two numbers.
+    Args:
+        a (int): the first number
+        b (int): the second number
+    """
+    return a % b
+
+
+@tool
+def power(a: float, b: float) -> float:
+    """Get the power of two numbers.
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
+    return a**b
+
+@tool
+def get_web_search_result(query:str):
+    """Fetches information on the web based on quey.
+    
+    Args:
+        query: The search query.
+
+    Returns:
+    """
+    print("get_web_search_result")
+    search_tool = DuckDuckGoSearchRun()
+    results = search_tool.invoke(query)
+    return results
+
+@tool
+def wiki_search(query: str) -> str:
+    """Search Wikipedia for a query and return maximum 5 results.
+    
+    Args:
+        query: The search query.
+
+    Returns:
+        An array documents
+    """
+    print("wiki_search")
+    search_docs = WikipediaLoader(query=query, load_max_docs=5).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:
+        An array documents
+    """
+    print("arvix_search")
+    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 transcribe_audio(file_path: str):
+    """
+    Transcribes an audio file to text using local Whisper model.
+    
+    Args:
+        file_path: Path to the audio file
+    
+    Returns:
+        A dictionary containing the transcription and metadata
+    """
+    try:
+        print(f"Transcribing audio file: {file_path}")
+        
+        # Validate file exists
+        if not os.path.exists(file_path):
+            return {
+                "status": "error",
+                "message": f"File not found: {file_path}"
+            }
+        
+        # Load a Whisper model - we'll use the small model for better performance
+        # Options include: tiny, base, small, medium, large
+        model = whisper.load_model("small")
+        
+        # Transcribe the audio
+        result = model.transcribe(file_path)
+        print({
+            "status": "success",
+            "transcription": result["text"],
+            "language": result.get("language", "unknown"),
+            "file_path": file_path
+        })
+        
+        # Return the transcription and metadata
+        return {
+            "status": "success",
+            "transcription": result["text"],
+            "language": result.get("language", "unknown"),
+            "file_path": file_path
+        }
+        
+    except Exception as e:
+        print({
+            "status": "error",
+            "message": f"Error transcribing audio: {str(e)}"
+        })
+        return {
+            "status": "error",
+            "message": f"Error transcribing audio: {str(e)}"
+        }
+
+class PythonREPLInput(BaseModel):
+    code: str = Field(description="The Python code string to execute.")
+
+python_repl = PythonREPL()
+
+python_repl_tool = Tool(
+    name="python_repl",
+    description="""A Python REPL shell (Read-Eval-Print Loop).
+Use this to execute single or multi-line python commands.
+Input should be syntactically valid Python code.
+Always end your code with `print(...)` to see the output.
+Do NOT execute code that could be harmful to the host system.
+You are allowed to download files from URLs.
+Do NOT send commands that block indefinitely (e.g., `input()`).""",
+    func=python_repl.run,
+    args_schema=PythonREPLInput
+)
+
+available_tools = [
+    get_web_search_result,
+    wiki_search,
+    arvix_search,
+    transcribe_audio,
+    python_repl_tool,
+    multiply,
+    add,
+    subtract,
+    divide,
+    modulus,
+    power,
+    get_youtube_transcript,
+    BraveSearch.from_api_key(
+        api_key=os.getenv("BRAVE_SEARCH_API_KEY"),
+        search_kwargs={"count": 5}
+        )
+]

utils/final_answer.py

@@ -0,0 +1,6 @@
+def extract_final_answer(text):
+    if "FINAL ANSWER:" in text:
+        start_index = text.find("FINAL ANSWER:") + len("FINAL ANSWER:")
+        return text[start_index:].strip()
+    else:
+        return None

utils/handle_file.py

@@ -0,0 +1,76 @@
+import os
+import mimetypes
+from langchain_core.messages import HumanMessage, SystemMessage
+from pathlib import Path
+from assignment_api import get_files_by_task_id
+
+# Function to handle attachments based on file type
+def handle_attachment(task_id, file_name):
+    """
+    Handles file attachments for a task.
+    
+    Args:
+        task_id: The ID of the task
+        file_name: The name of the attachment file
+    
+    Returns:
+        Dictionary with attachment details, including how it should be handled
+    """
+    if not file_name or file_name.strip() == "":
+        return {"status": "no_attachment"}
+    
+    # Get file content using existing function
+    file_data = get_files_by_task_id(task_id)
+    
+    if file_data["status"] == "error":
+        print(f"Error fetching attachment: {file_data.get('error')}")
+        return {"status": "error", "message": file_data.get("error")}
+    
+    content_type = file_data["content_type"]
+    raw_content = file_data["content"]
+    
+    # Determine if this file type can be directly processed by Claude
+    # Images, spreadsheets, and PDFs can be processed directly
+    direct_process = (
+        content_type.startswith("image/") or 
+        "spreadsheet" in content_type or 
+        "excel" in content_type or
+        content_type == "application/pdf" or
+        "csv" in content_type
+    )
+    
+    if direct_process:
+        # For files that Claude can handle directly, return content for direct inclusion
+        print(f"Attachment {file_name} (type: {content_type}) will be passed directly to Claude")
+        return {
+            "status": "success",
+            "handling": "direct",
+            "content_type": content_type,
+            "raw_content": raw_content,
+            "file_name": file_name
+        }
+    else:
+        # For other files, save to disk and return path
+        save_dir = os.path.join(os.getcwd(), "task_files")
+        os.makedirs(save_dir, exist_ok=True)
+        
+        # Determine file extension
+        file_extension = Path(file_name).suffix
+        if not file_extension:
+            extension = mimetypes.guess_extension(content_type) or ".bin"
+            file_path = os.path.join(save_dir, f"{task_id}{extension}")
+        else:
+            file_path = os.path.join(save_dir, file_name)
+            
+        # Save the file
+        with open(file_path, 'wb') as f:
+            f.write(raw_content)
+            
+        print(f"Attachment {file_name} (type: {content_type}) saved to {file_path}")
+        return {
+            "status": "success",
+            "handling": "tool",
+            "content_type": content_type,
+            "file_path": file_path,
+            "file_name": file_name
+        }

utils/read_file.py

@@ -0,0 +1,8 @@
+def read_txt_file(file_path):
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            system_prompt = file.read()
+        return system_prompt
+    except Exception as e:
+        print(f"Error while reading file: {e}")
+        return ""