Deploy ArkAssistant smolagent (Hugging Face Agents Course Unit 1)

.agents/skills/deploy-space/SKILL.md

@@ -24,7 +24,7 @@ Always run these verification steps prior to deployment:
    ```
 
 3. **Dependency Check**:
-   Ensure all imported packages in `tools/` and `app.py` (e.g., `markdownify`, `smolagents`, `ddgs`, `litellm`) are declared in `requirements.txt`.
+   Ensure all imported packages in `tools/` and `app.py` (e.g., `markdownify`, `smolagents`, `ddgs`) are declared in `requirements.txt`.
 
 4. **Ignore Patterns**:
    Verify that sensitive files (`.env`), cache folders (`__pycache__`, `.gradio`), and the virtual environment (`.venv`) are listed in `deploy_space.py`'s `ignore_patterns`.

AGENTS.md

@@ -28,7 +28,16 @@ This workspace contains the complete implementation for the **Hugging Face Agent
 
 ## Environment & Commands
 
-- **Local Virtual Environment**: `.venv/bin/python`
+Cloud inference only. `HF_TOKEN` and `MODEL_ID` are configured in `.env`;
+local Ollama execution is intentionally disabled. Hugging Face Inference
+Providers require available credits or a PRO plan; without them the API returns
+HTTP 402 before the agent can start.
+
+- **Create the project virtual environment**:
+  ```bash
+  uv venv .venv
+  uv pip install --python .venv/bin/python -r requirements.txt
+  ```
 
 - **Sanity Check All Tools (Fast, No LLM)**:
   ```bash
@@ -40,11 +49,6 @@ This workspace contains the complete implementation for the **Hugging Face Agent
   .venv/bin/python test_agent.py "What is the capital of Japan and what is the weather there?"
   ```
 
-- **Run CLI Agent Query with Local Ollama (Offline)**:
-  ```bash
-  USE_OLLAMA=true .venv/bin/python test_agent.py "What is the time in UTC?"
-  ```
-
 - **Run Gradio Web UI Locally**:
   ```bash
   .venv/bin/python app.py

app.py

@@ -1,127 +1,61 @@
-import datetime
 import os
-from urllib.parse import quote
-import pytz
-import requests
+
 import yaml
 from dotenv import load_dotenv
+from smolagents import CodeAgent, InferenceClientModel, load_tool
 
-from smolagents import CodeAgent, DuckDuckGoSearchTool, load_tool, tool
+from Gradio_UI import GradioUI
 from tools.final_answer import FinalAnswerTool
+from tools.get_current_time_in_timezone import get_current_time_in_timezone
+from tools.get_weather import get_weather
+from tools.search_wikipedia import search_wikipedia
 from tools.visit_webpage import VisitWebpageTool
-from Gradio_UI import GradioUI
+from tools.web_search import DuckDuckGoSearchTool
 
 load_dotenv()
 
-# --- Custom Tools ---
-
-@tool
-def get_current_time_in_timezone(timezone: str) -> str:
-    """A tool that fetches the current local time in a specified timezone.
-    Args:
-        timezone: A string representing a valid IANA timezone (e.g., 'America/New_York', 'Europe/Paris', 'Asia/Kolkata', 'UTC').
-    """
-    try:
-        import datetime
-        import pytz
-        tz = pytz.timezone(timezone)
-        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-        return f"The current local time in {timezone} is: {local_time}"
-    except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
-
-@tool
-def get_weather(location: str) -> str:
-    """Fetches the current live weather report and temperature for a given city or location.
-    Args:
-        location: The name of the city or location (e.g., 'Paris', 'Tokyo', 'San Francisco').
-    """
-    try:
-        import requests
-        from urllib.parse import quote
-        encoded_loc = quote(location)
-        url = f"https://wttr.in/{encoded_loc}?format=%C+%t+(feels+like+%f)+wind:+%w"
-        headers = {"User-Agent": "HF-Agents-Course-ArkAssistant/1.0"}
-        resp = requests.get(url, headers=headers, timeout=10)
-        if resp.status_code == 200 and resp.text:
-            return f"Weather for {location}: {resp.text.strip()}"
-        return f"Could not retrieve weather for {location} (status code {resp.status_code})."
-    except Exception as e:
-        return f"Error fetching weather for '{location}': {str(e)}"
-
-@tool
-def search_wikipedia(query: str) -> str:
-    """Fetches an encyclopedic summary of a topic from Wikipedia.
-    Args:
-        query: The subject or topic name to search on Wikipedia (e.g., 'Alan Turing', 'Artificial intelligence').
-    """
-    try:
-        import requests
-        from urllib.parse import quote
-        encoded_query = quote(query)
-        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{encoded_query}"
-        headers = {"User-Agent": "HF-Agents-Course-ArkAssistant/1.0"}
-        resp = requests.get(url, headers=headers, timeout=10)
-        if resp.status_code == 200:
-            data = resp.json()
-            extract = data.get("extract", "")
-            title = data.get("title", query)
-            if extract:
-                return f"**{title}**: {extract}"
-            return f"No extract available for '{query}'."
-        elif resp.status_code == 404:
-            return f"No Wikipedia article found for '{query}'."
-        else:
-            return f"Wikipedia query returned status code {resp.status_code}."
-    except Exception as e:
-        return f"Error querying Wikipedia for '{query}': {str(e)}"
-
 # --- Core Tools & Agent Setup ---
 
 final_answer = FinalAnswerTool()
 web_search = DuckDuckGoSearchTool()
 visit_webpage = VisitWebpageTool()
 
+hf_token = os.getenv("HF_TOKEN")
+if not hf_token:
+    raise RuntimeError(
+        "HF_TOKEN is required. Local model execution is disabled in this project."
+    )
+
 # Image generation tool from Hugging Face Hub
 image_generation_tool = None
 try:
-    hf_token = os.getenv("HF_TOKEN")
     image_generation_tool = load_tool(
         "agents-course/text-to-image",
         trust_remote_code=True,
-        token=hf_token
+        token=hf_token,
     )
 except Exception as e:
     print(f"Notice: text-to-image tool could not be loaded: {e}")
 
-# Model Configuration
-try:
-    from smolagents import HfApiModel as HfModel
-except ImportError:
-    from smolagents import InferenceClientModel as HfModel
-
-hf_token = os.getenv("HF_TOKEN")
-use_ollama = os.getenv("USE_OLLAMA", "").lower() in ("true", "1")
-
-if use_ollama or (not hf_token and os.getenv("OLLAMA_ENABLED", "").lower() in ("true", "1")):
-    print("Using local Ollama model for agent execution...")
+# Model configuration (cloud by default; Ollama supported for local learning/testing)
+model_id = os.getenv("MODEL_ID", "Qwen/Qwen2.5-Coder-32B-Instruct")
+if "ollama" in model_id.lower():
     from smolagents import LiteLLMModel
+
     model = LiteLLMModel(
-        model_id=os.getenv("OLLAMA_MODEL", "ollama_chat/qwen2.5-coder:3b"),
+        model_id=model_id,
         api_base=os.getenv("OLLAMA_API_BASE", "http://127.0.0.1:11434"),
-        num_ctx=8192
+        num_ctx=int(os.getenv("OLLAMA_NUM_CTX", "8192")),
+        temperature=0.5,
     )
 else:
-    model_id = os.getenv("MODEL_ID", "Qwen/Qwen2.5-Coder-32B-Instruct")
-    model_kwargs = {
-        "max_tokens": 2096,
-        "temperature": 0.5,
-        "model_id": model_id,
-        "custom_role_conversions": None,
-    }
-    if hf_token:
-        model_kwargs["token"] = hf_token
-    model = HfModel(**model_kwargs)
+    model = InferenceClientModel(
+        model_id=model_id,
+        token=hf_token,
+        max_tokens=2096,
+        temperature=0.5,
+        custom_role_conversions=None,
+    )
 
 # Load prompt templates
 prompts_file = os.path.join(os.path.dirname(__file__), "prompts.yaml")
@@ -137,7 +71,7 @@ research_agent = CodeAgent(
     max_steps=5,
     verbosity_level=1,
     name="web_researcher",
-    description="A specialist researcher that searches DuckDuckGo, queries Wikipedia, and reads webpage content to gather accurate facts and summaries.",
+    description="A specialist researcher that searches DuckDuckGo, queries Wikipedia, and reads webpage content to gather accurate facts and summaries. ALWAYS call this agent with a 'task' argument, e.g. web_researcher(task='Find the capital of Japan').",
     prompt_templates=prompt_templates
 )
 
@@ -148,10 +82,31 @@ local_info_agent = CodeAgent(
     max_steps=4,
     verbosity_level=1,
     name="local_info_specialist",
-    description="A specialist agent that fetches real-time live weather reports and calculates current time in timezones worldwide.",
+    description="A specialist agent that fetches real-time live weather reports and calculates current time in timezones worldwide. ALWAYS call this agent with a 'task' argument, e.g. local_info_specialist(task='Get current weather in Tokyo'). Never call weather() or get_weather() directly from the manager.",
     prompt_templates=prompt_templates
 )
 
+# Make managed agents tolerant of common argument names (query/question/etc.)
+def _adapt_managed_agent(agent):
+    original_call = agent.__call__
+
+    def _call(task=None, **kwargs):
+        if task is None:
+            for key in ("task", "query", "question", "request", "prompt"):
+                if key in kwargs:
+                    task = kwargs.pop(key)
+                    break
+            if task is None and kwargs:
+                task = list(kwargs.values())[0]
+                kwargs = {}
+        return original_call(task, **kwargs)
+
+    agent.__call__ = _call
+    return agent
+
+research_agent = _adapt_managed_agent(research_agent)
+local_info_agent = _adapt_managed_agent(local_info_agent)
+
 # Manager Agent: Coordinates specialists and synthesizes the final response
 manager_tools = [final_answer]
 if image_generation_tool is not None:

prompts.yaml

@@ -219,8 +219,8 @@
 
     {%- if managed_agents and managed_agents.values() | list %}
     You can also give tasks to team members.
-    Calling a team member works the same as for calling a tool: simply, the only argument you can give in the call is 'request', a long string explaining your request.
-    Given that this team member is a real human, you should be very verbose in your request.
+    Calling a team member works the same as for calling a tool: simply, the only argument you can give in the call is 'task', a long string explaining your task.
+    Given that this team member is a real human, you should be very verbose in your task.
     Here is a list of the team members that you can call:
     {%- for agent in managed_agents.values() %}
     - {{ agent.name }}: {{ agent.description }}

requirements.txt

@@ -1,10 +1,10 @@
+ddgs
+gradio>=5.23,<7
+huggingface_hub
 markdownify
-smolagents
-requests
-duckduckgo_search
 pandas
-pytz
-python-dotenv
 pillow
-litellm
-ddgs
+python-dotenv
+pytz
+requests
+smolagents>=1.26,<2

test_agent.py

@@ -1,94 +1,101 @@
 #!/usr/bin/env python3
-"""
-CLI Test Runner for ArkAssistant smolagent
+"""CLI test runner for ArkAssistant.
+
 Usage:
     # Run a test query against the manager agent:
     .venv/bin/python test_agent.py "What is the capital of France and what is the current time there?"
 
-    # Run with local Ollama offline model:
-    USE_OLLAMA=true .venv/bin/python test_agent.py "What is the weather in London?"
-
     # Sanity check all tools without calling the LLM:
     .venv/bin/python test_agent.py --test-tools
+
+The project uses the Hugging Face Inference API and requires HF_TOKEN in .env.
 """
 
-import os
 import sys
 
-def run_tools_sanity():
+from tools.get_current_time_in_timezone import get_current_time_in_timezone
+from tools.get_weather import get_weather
+from tools.search_wikipedia import search_wikipedia
+from tools.visit_webpage import VisitWebpageTool
+from tools.web_search import DuckDuckGoSearchTool
+
+
+def _require_result(result: str) -> str:
+    text = str(result).strip()
+    if not text:
+        raise RuntimeError("tool returned an empty result")
+    if text.lower().startswith("error"):
+        raise RuntimeError(text)
+    return text
+
+
+def run_tools_sanity() -> int:
     print("=" * 60)
     print("🔬 Running Sanity Check on ArkAssistant Tools (No LLM Calls)")
     print("=" * 60)
-    
-    # 1. Weather
-    try:
-        from app import get_weather
-        w = get_weather("London")
-        print(f"✅ Weather Tool: {w[:80]}...")
-    except Exception as e:
-        print(f"❌ Weather Tool Failed: {e}")
 
-    # 2. Timezone
-    try:
-        from app import get_current_time_in_timezone
-        t = get_current_time_in_timezone("UTC")
-        print(f"✅ Timezone Tool: {t}")
-    except Exception as e:
-        print(f"❌ Timezone Tool Failed: {e}")
+    visit_webpage = VisitWebpageTool()
+    web_search = DuckDuckGoSearchTool()
+    failures: list[str] = []
 
-    # 3. Wikipedia
-    try:
-        from app import search_wikipedia
-        wiki = search_wikipedia("Alan Turing")
-        print(f"✅ Wikipedia Tool: {wiki[:80]}...")
-    except Exception as e:
-        print(f"❌ Wikipedia Tool Failed: {e}")
+    checks = [
+        ("Weather", lambda: get_weather("London")),
+        ("Timezone", lambda: get_current_time_in_timezone("UTC")),
+        ("Wikipedia", lambda: search_wikipedia("Alan Turing")),
+        ("Visit Webpage", lambda: visit_webpage("https://httpbin.org/html")),
+        ("Web Search", lambda: web_search("smolagents Hugging Face")),
+    ]
 
-    # 4. Visit Webpage
-    try:
-        from app import visit_webpage
-        res = visit_webpage("https://httpbin.org/html")
-        print(f"✅ Visit Webpage Tool: Extracted {len(res)} characters.")
-    except Exception as e:
-        print(f"❌ Visit Webpage Tool Failed: {e}")
-
-    # 5. DuckDuckGo Web Search
-    try:
-        from app import web_search
-        sr = web_search("smolagents Hugging Face")
-        print(f"✅ Web Search Tool: {sr[:80]}...")
-    except Exception as e:
-        print(f"❌ Web Search Tool Failed: {e}")
+    for name, check in checks:
+        try:
+            result = _require_result(check())
+            preview = result.replace("\n", " ")[:100]
+            print(f"✅ {name} Tool: {preview}")
+        except Exception as exc:
+            failures.append(f"{name}: {exc}")
+            print(f"❌ {name} Tool Failed: {exc}")
 
     print("=" * 60)
-    print("All tool sanity checks complete.")
-    print("=" * 60)
+    if failures:
+        print(f"❌ {len(failures)} tool check(s) failed.")
+        for failure in failures:
+            print(f"  - {failure}")
+        return 1
+    print("✅ All tool sanity checks passed.")
+    return 0
+
 
-def main():
+def main() -> int:
     args = sys.argv[1:]
-    
+
     if "--test-tools" in args:
-        run_tools_sanity()
-        return
+        return run_tools_sanity()
 
-    # Check for prompt argument
-    prompt = " ".join([a for a in args if not a.startswith("--")])
+    prompt = " ".join(arg for arg in args if not arg.startswith("--"))
     if not prompt:
         prompt = "What is the current time in UTC and what is the weather in Paris?"
         print(f"No prompt provided. Using default test prompt:\n  '{prompt}'\n")
 
-    print(f"🚀 Initializing ArkAssistant Agent...")
-    from app import agent
-
-    print(f"🤖 Running Agent Task: \"{prompt}\"")
-    print("-" * 60)
+    print("🚀 Initializing ArkAssistant Agent...")
     try:
+        from app import agent
+
+        print(f"🤖 Running Agent Task: \"{prompt}\"")
+        print("-" * 60)
         response = agent.run(prompt)
         print("-" * 60)
         print(f"\n🎯 Agent Final Answer:\n{response}")
-    except Exception as e:
-        print(f"\n❌ Error during agent execution: {e}")
-        sys.exit(1)
+        return 0
+    except Exception as exc:
+        message = str(exc)
+        print(f"\n❌ Error during agent execution: {message}")
+        if "402" in message or "Payment Required" in message:
+            print(
+                "Hint: Hugging Face Inference has no available credits. "
+                "Add credits/PRO or configure another cloud provider in .env."
+            )
+        return 1
+
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())

tools/get_current_time_in_timezone.py

@@ -1,22 +1,19 @@
-from smolagents import Tool
-from typing import Any, Optional
+import datetime
 
-class SimpleTool(Tool):
-    name = "get_current_time_in_timezone"
-    description = "A tool that fetches the current local time in a specified timezone."
-    inputs = {'timezone': {'type': 'string', 'description': "A string representing a valid IANA timezone (e.g., 'America/New_York', 'Europe/Paris', 'Asia/Kolkata', 'UTC')."}}
-    output_type = "string"
+import pytz
+from smolagents import tool
 
-    def forward(self, timezone: str) -> str:
-        """A tool that fetches the current local time in a specified timezone.
-        Args:
-            timezone: A string representing a valid IANA timezone (e.g., 'America/New_York', 'Europe/Paris', 'Asia/Kolkata', 'UTC').
-        """
-        try:
-            import datetime
-            import pytz
-            tz = pytz.timezone(timezone)
-            local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-            return f"The current local time in {timezone} is: {local_time}"
-        except Exception as e:
-            return f"Error fetching time for timezone '{timezone}': {str(e)}"
+
+@tool
+def get_current_time_in_timezone(timezone: str) -> str:
+    """A tool that fetches the current local time in a specified timezone.
+
+    Args:
+        timezone: A valid IANA timezone (e.g., 'America/New_York', 'Europe/Paris', 'Asia/Kolkata', 'UTC').
+    """
+    try:
+        tz = pytz.timezone(timezone)
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        return f"The current local time in {timezone} is: {local_time}"
+    except Exception as e:
+        return f"Error fetching time for timezone '{timezone}': {str(e)}"

tools/get_weather.py

@@ -1,26 +1,23 @@
-from smolagents import Tool
-from typing import Any, Optional
+from urllib.parse import quote
 
-class SimpleTool(Tool):
-    name = "get_weather"
-    description = "Fetches the current live weather report and temperature for a given city or location."
-    inputs = {'location': {'type': 'string', 'description': "The name of the city or location (e.g., 'Paris', 'Tokyo', 'San Francisco')."}}
-    output_type = "string"
+import requests
+from smolagents import tool
 
-    def forward(self, location: str) -> str:
-        """Fetches the current live weather report and temperature for a given city or location.
-        Args:
-            location: The name of the city or location (e.g., 'Paris', 'Tokyo', 'San Francisco').
-        """
-        try:
-            import requests
-            from urllib.parse import quote
-            encoded_loc = quote(location)
-            url = f"https://wttr.in/{encoded_loc}?format=%C+%t+(feels+like+%f)+wind:+%w"
-            headers = {"User-Agent": "HF-Agents-Course-ArkAssistant/1.0"}
-            resp = requests.get(url, headers=headers, timeout=10)
-            if resp.status_code == 200 and resp.text:
-                return f"Weather for {location}: {resp.text.strip()}"
-            return f"Could not retrieve weather for {location} (status code {resp.status_code})."
-        except Exception as e:
-            return f"Error fetching weather for '{location}': {str(e)}"
+
+@tool
+def get_weather(location: str) -> str:
+    """Fetches the current live weather report and temperature for a given city or location.
+
+    Args:
+        location: The name of the city or location (e.g., 'Paris', 'Tokyo', 'San Francisco').
+    """
+    try:
+        encoded_loc = quote(location)
+        url = f"https://wttr.in/{encoded_loc}?format=%C+%t+(feels+like+%f)+wind:+%w"
+        headers = {"User-Agent": "HF-Agents-Course-ArkAssistant/1.0"}
+        resp = requests.get(url, headers=headers, timeout=10)
+        if resp.status_code == 200 and resp.text:
+            return f"Weather for {location}: {resp.text.strip()}"
+        return f"Could not retrieve weather for {location} (status code {resp.status_code})."
+    except Exception as e:
+        return f"Error fetching weather for '{location}': {str(e)}"

tools/search_wikipedia.py

@@ -1,34 +1,30 @@
-from smolagents import Tool
-from typing import Any, Optional
+from urllib.parse import quote
 
-class SimpleTool(Tool):
-    name = "search_wikipedia"
-    description = "Fetches an encyclopedic summary of a topic from Wikipedia."
-    inputs = {'query': {'type': 'string', 'description': "The subject or topic name to search on Wikipedia (e.g., 'Alan Turing', 'Artificial intelligence')."}}
-    output_type = "string"
+import requests
+from smolagents import tool
 
-    def forward(self, query: str) -> str:
-        """Fetches an encyclopedic summary of a topic from Wikipedia.
-        Args:
-            query: The subject or topic name to search on Wikipedia (e.g., 'Alan Turing', 'Artificial intelligence').
-        """
-        try:
-            import requests
-            from urllib.parse import quote
-            encoded_query = quote(query)
-            url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{encoded_query}"
-            headers = {"User-Agent": "HF-Agents-Course-ArkAssistant/1.0"}
-            resp = requests.get(url, headers=headers, timeout=10)
-            if resp.status_code == 200:
-                data = resp.json()
-                extract = data.get("extract", "")
-                title = data.get("title", query)
-                if extract:
-                    return f"**{title}**: {extract}"
-                return f"No extract available for '{query}'."
-            elif resp.status_code == 404:
-                return f"No Wikipedia article found for '{query}'."
-            else:
-                return f"Wikipedia query returned status code {resp.status_code}."
-        except Exception as e:
-            return f"Error querying Wikipedia for '{query}': {str(e)}"
+
+@tool
+def search_wikipedia(query: str) -> str:
+    """Fetches an encyclopedic summary of a topic from Wikipedia.
+
+    Args:
+        query: The subject or topic name to search on Wikipedia (e.g., 'Alan Turing', 'Artificial intelligence').
+    """
+    try:
+        encoded_query = quote(query)
+        url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{encoded_query}"
+        headers = {"User-Agent": "HF-Agents-Course-ArkAssistant/1.0"}
+        resp = requests.get(url, headers=headers, timeout=10)
+        if resp.status_code == 200:
+            data = resp.json()
+            extract = data.get("extract", "")
+            title = data.get("title", query)
+            if extract:
+                return f"**{title}**: {extract}"
+            return f"No extract available for '{query}'."
+        if resp.status_code == 404:
+            return f"No Wikipedia article found for '{query}'."
+        return f"Wikipedia query returned status code {resp.status_code}."
+    except Exception as e:
+        return f"Error querying Wikipedia for '{query}': {str(e)}"