Make location/framework/date/distance be inputs rather than config controlled by default (#55)

* Simplify configs so that selecting framework, time location etc is a game-time decision with defaults

* bad getter

* more cleanup and handling of MCP params

examples/langchain_single_agent.yaml

@@ -1,8 +0,0 @@
-location: Pontevedra
-date: 2025-04-02 12:00
-max_driving_hours: 2
-
-framework: langchain
-
-main_agent:
-  model_id: o3-mini

examples/langchain_single_agent_vertical.yaml

@@ -1,17 +0,0 @@
-location: Pontevedra
-date: 2025-04-10 12:00
-max_driving_hours: 2
-
-framework: langchain
-
-main_agent:
-  model_id: o3-mini
-  tools:
-  - "surf_spot_finder.tools.driving_hours_to_meters"
-  - "surf_spot_finder.tools.get_area_lat_lon"
-  - "surf_spot_finder.tools.get_surfing_spots"
-  - "surf_spot_finder.tools.get_wave_forecast"
-  - "surf_spot_finder.tools.get_wind_forecast"
-  - "any_agent.tools.search_web"
-  - "any_agent.tools.show_plan"
-  - "any_agent.tools.visit_webpage"

examples/llama_index_single_agent.yaml

@@ -1,8 +0,0 @@
-location: Pontevedra
-date: 2025-04-02 12:00
-max_driving_hours: 2
-
-framework: llama_index
-
-main_agent:
-  model_id: o3-mini

examples/llama_index_single_agent_vertical.yaml

@@ -1,17 +0,0 @@
-location: Pontevedra
-date: 2025-04-10 12:00
-max_driving_hours: 2
-
-framework: llama_index
-
-main_agent:
-  model_id: o3-mini
-  tools:
-  - "surf_spot_finder.tools.driving_hours_to_meters"
-  - "surf_spot_finder.tools.get_area_lat_lon"
-  - "surf_spot_finder.tools.get_surfing_spots"
-  - "surf_spot_finder.tools.get_wave_forecast"
-  - "surf_spot_finder.tools.get_wind_forecast"
-  - "any_agent.tools.search_web"
-  - "any_agent.tools.show_plan"
-  - "any_agent.tools.visit_webpage"

examples/{openai_multi_agent.yaml → multi_agent.yaml}

@@ -1,15 +1,9 @@
-location: Pontevedra
-date: 2025-04-02 12:00
-max_driving_hours: 2
-
-framework: openai
-
 main_agent:
   name: main_agent
-  model_id: o3-mini
+  model_id: # optional, will prompt for it if not provided
   instructions: >
     # System context\n
-    You are part of a multi-agent system called the Agents SDK, designed to make agent coordination and execution easy.
+    You are part of a multi-agent system, designed to make agent coordination and execution easy.
     Agents uses two primary abstraction: **Agents** and **Handoffs**.
     An agent encompasses instructions and tools and can hand off a conversation to another agent when appropriate.
     Handoffs are achieved by calling a handoff function, generally named `transfer_to_<agent_name>`.
@@ -17,22 +11,21 @@ main_agent:
 
 managed_agents:
 
-  - name: user-verifiaction-agent
-    model_id: gpt-4o-mini
+  - name: user-verification-agent
+    model_id: # optional, will prompt for it if not provided
     instructions: Ask users to verify a step, plan or answer.
     tools:
       - any_agent.tools.ask_user_verification
 
   - name: general-web-search-agent
-    model_id: gpt-4o-mini
+    model_id: # optional, will prompt for it if not provided
     instructions: Search the web and visit webpages to find answers.
     tools:
       - any_agent.tools.search_web
       - any_agent.tools.visit_webpage
 
   - name: user-communication-agent
-    model_id: gpt-4o-mini
+    model_id: # optional, will prompt for it if not provided
     instructions: Communicates to the user
-    handoff: True
     tools:
-      - any_agent.tools.show_final_answer
+      - any_agent.tools.show_final_output

examples/openai_single_agent.yaml

@@ -1,8 +0,0 @@
-location: Pontevedra
-date: 2025-04-02 12:00
-max_driving_hours: 2
-
-framework: openai
-
-main_agent:
-  model_id: o3-mini

examples/openai_single_agent_user_confirmation.yaml

@@ -1,36 +0,0 @@
-
-location: Pontevedra
-date: 2025-04-10 12:00
-max_driving_hours: 2
-input_prompt_template: |
-  According to the forecast, what will be the best spot to surf around {LOCATION},
-  in a {MAX_DRIVING_HOURS} hour driving radius, at {DATE}?
-  Find a few options and then discuss it with David de la Iglesia Castro. You should recommend him some choices,
-  and then confirm the final selection with him.
-  Once he gives the final selection, save a detailed description of the weather at the chosen location into a file
-  named "final_answer.txt". Also save a file called "history.txt" which has a list of your thought process in the choice.
-framework: openai
-
-main_agent:
-  model_id: gpt-4o
-  tools:
-  - "surf_spot_finder.tools.driving_hours_to_meters"
-  - "surf_spot_finder.tools.get_area_lat_lon"
-  - "surf_spot_finder.tools.get_surfing_spots"
-  - "surf_spot_finder.tools.get_wave_forecast"
-  - "surf_spot_finder.tools.get_wind_forecast"
-  - "any_agent.tools.send_console_message"
-  - command: "docker"
-    args:
-      - "run"
-      - "-i"
-      - "--rm"
-      - "--mount"
-      - "type=bind,src=/tmp/surf-spot-finder,dst=/projects"
-      - "mcp/filesystem"
-      - "/projects"
-    tools:
-      - "read_file"
-      - "write_file"
-      - "directory_tree"
-      - "list_allowed_directories"

examples/{langchain_single_agent_user_confirmation.yaml → single_agent_user_confirmation.yaml}

@@ -1,19 +1,14 @@
 
-location: Pontevedra
-date: 2025-04-05 12:00
-max_driving_hours: 2
 input_prompt_template: |
   According to the forecast, what will be the best spot to surf around {LOCATION},
   in a {MAX_DRIVING_HOURS} hour driving radius, at {DATE}?
-  Find a few options and then discuss it with David de la Iglesia Castro. You should recommend him some choices,
-  and then confirm the final selection with him.
+  Find a few options and then discuss it with a friend using the send_console_message any_agent.tools.ask_user_verification
+  You should recommend some choices to them and then confirm the final selection with him.
   Once he gives the final selection, save a detailed description of the weather at the chosen location into a file
   named "final_answer.txt". Also save a file called "history.txt" which has a list of your thought process in the choice.
 
-framework: langchain
-
 main_agent:
-  model_id: openai/gpt-4o
+  model_id: # optional, will prompt for it if not provided
   tools:
   - "surf_spot_finder.tools.driving_hours_to_meters"
   - "surf_spot_finder.tools.get_area_lat_lon"
@@ -27,7 +22,7 @@ main_agent:
       - "-i"
       - "--rm"
       - "--mount"
-      - "type=bind,src=/tmp/surf-spot-finder,dst=/projects"
+      - "type=bind,src={{ path_variable }},dst=/projects" # this is the custom part where for demo purposes we will check this in config.py
       - "mcp/filesystem"
       - "/projects"
     tools:

examples/{openai_single_agent_vertical.yaml → single_agent_with_tools.yaml}

@@ -1,11 +1,5 @@
-location: Lisbon
-date: 2025-04-08 19:00
-max_driving_hours: 1
-
-framework: openai
-
 main_agent:
-  model_id: gpt-4o
+  model_id: # optional, will prompt for it if not provided
   tools:
   - "surf_spot_finder.tools.driving_hours_to_meters"
   - "surf_spot_finder.tools.get_area_lat_lon"

examples/smolagents_single_agent.yaml

@@ -1,8 +0,0 @@
-location: Pontevedra
-date: 2025-04-02 12:00
-max_driving_hours: 2
-
-framework: smolagents
-
-main_agent:
-  model_id: openai/o3-mini

examples/smolagents_single_agent_user_confirmation.yaml

@@ -1,37 +0,0 @@
-location: Pontevedra
-date: 2025-04-05 12:00
-max_driving_hours: 2
-input_prompt_template: |
-  According to the forecast, what will be the best spot to surf around {LOCATION},
-  in a {MAX_DRIVING_HOURS} hour driving radius, at {DATE}?
-  Find a few options and then discuss it with David de la Iglesia Castro. You should recommend him some choices,
-  and then confirm the final selection with him.
-  Once he gives the final selection, save a detailed description of the weather at the chosen location into a file
-  named "final_answer.txt". Also save a file called "history.txt" which has a list of your thought process in the choice.
-
-framework: smolagents
-
-main_agent:
-  model_id: openai/gpt-4o
-  tools:
-  - "surf_spot_finder.tools.driving_hours_to_meters"
-  - "surf_spot_finder.tools.get_area_lat_lon"
-  - "surf_spot_finder.tools.get_surfing_spots"
-  - "surf_spot_finder.tools.get_wave_forecast"
-  - "surf_spot_finder.tools.get_wind_forecast"
-  - "any_agent.tools.send_console_message"
-  - "smolagents.FinalAnswerTool"
-  - command: "docker"
-    args:
-      - "run"
-      - "-i"
-      - "--rm"
-      - "--mount"
-      - "type=bind,src=/tmp/surf-spot-finder,dst=/projects"
-      - "mcp/filesystem"
-      - "/projects"
-    tools:
-      - "read_file"
-      - "write_file"
-      - "directory_tree"
-      - "list_allowed_directories"

examples/smolagents_single_agent_vertical.yaml

@@ -1,19 +0,0 @@
-location: Pontevedra
-date: 2025-04-10 12:00
-max_driving_hours: 2
-
-framework: smolagents
-
-main_agent:
-  model_id: openai/o3-mini
-  tools:
-  - "surf_spot_finder.tools.driving_hours_to_meters"
-  - "surf_spot_finder.tools.get_area_lat_lon"
-  - "surf_spot_finder.tools.get_surfing_spots"
-  - "surf_spot_finder.tools.get_wave_forecast"
-  - "surf_spot_finder.tools.get_wind_forecast"
-  - "any_agent.tools.search_web"
-  - "any_agent.tools.show_plan"
-  - "any_agent.tools.visit_webpage"
-  - "smolagents.PythonInterpreterTool"
-  - "smolagents.FinalAnswerTool"

pyproject.toml

@@ -11,10 +11,11 @@ dynamic = ["version"]
 dependencies = [
   "any-agent[all]",
   "fire",
-  "loguru",
   "pydantic",
   "pyyaml",
   "litellm",
+  "geocoder>=1.38.1",
+  "rich>=14.0.0",
 ]
 
 [project.optional-dependencies]

src/surf_spot_finder/cli.py

@@ -1,6 +1,10 @@
+import datetime
+import os
+from pathlib import Path
+
 from any_agent import AgentFramework, AnyAgent, TracingConfig
 from fire import Fire
-from loguru import logger
+from any_agent.logging import logger
 
 from surf_spot_finder.config import (
     Config,
@@ -10,9 +14,8 @@ from surf_spot_finder.instructions.openai import SINGLE_AGENT_SYSTEM_PROMPT
 from surf_spot_finder.instructions.smolagents import SYSTEM_PROMPT
 
 
-@logger.catch(reraise=True)
 async def find_surf_spot(
-    config_file: str,
+    config_file: str | None = None,
 ) -> str:
     """Find the best surf spot based on the given criteria.
 
@@ -21,8 +24,11 @@ async def find_surf_spot(
             See [Config][surf_spot_finder.config.Config]
 
     """
-    logger.info(f"Loading {config_file}")
-    config = Config.from_yaml(config_file)
+    if config_file is None:
+        config = Config.from_dict({})
+    else:
+        logger.info(f"Loading {config_file}")
+        config = Config.from_yaml(config_file)
 
     if not config.main_agent.instructions:
         if config.framework == AgentFramework.SMOLAGENTS:
@@ -47,7 +53,15 @@ async def find_surf_spot(
     logger.info(f"Running agent with query:\n{query}")
     agent_trace = await agent.run_async(query)
 
-    logger.info(f"Final result:\n{agent_trace.final_output}")
+    logger.info(f"Final output from agent:\n{agent_trace.final_output}")
+
+    # dump the trace in the "output" directory
+    output_dir = "output"
+    os.makedirs(output_dir, exist_ok=True)
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    file_path = Path(output_dir) / f"{timestamp}_trace.json"
+    with open(file_path, "w") as f:
+        f.write(agent_trace.model_dump_json(indent=2))
 
 
 def main():

src/surf_spot_finder/config.py

@@ -1,10 +1,17 @@
+import os
+import tempfile
 from typing import Annotated
-
+from datetime import datetime, timedelta
 from any_agent import AgentFramework
 from any_agent.config import AgentConfig
 from pydantic import AfterValidator, BaseModel, ConfigDict, FutureDatetime, PositiveInt
 import yaml
-
+from rich.prompt import Prompt
+from any_agent.logging import logger
+import geocoder
+from litellm.litellm_core_utils.get_llm_provider_logic import (
+    get_llm_provider,
+)
 
 INPUT_PROMPT_TEMPLATE = """
 According to the forecast, what will be the best spot to surf around {LOCATION},
@@ -20,6 +27,112 @@ def validate_prompt(value) -> str:
     return value
 
 
+def ask_framework() -> AgentFramework:
+    """
+    Ask the user which framework they would like to use. They must select one of the Agent Frameworks
+    """
+    frameworks = [framework.name for framework in AgentFramework]
+    frameworks_str = "\n".join(
+        [f"{i}: {framework}" for i, framework in enumerate(frameworks)]
+    )
+    prompt = f"Select the agent framework to use:\n{frameworks_str}\n"
+    choice = Prompt.ask(prompt, default="3")
+    try:
+        choice = int(choice)
+        if choice < 0 or choice >= len(frameworks):
+            raise ValueError("Invalid choice")
+        return AgentFramework[frameworks[choice]]
+    except ValueError:
+        raise ValueError("Invalid choice")
+
+
+def date_picker() -> FutureDatetime:
+    """
+    Ask the user to select a date in the future. The date must be at least 1 day in the future.
+    """
+    prompt = "Select a date in the future (YYYY-MM-DD-HH)"
+    # the default should be the current date + 1 day
+    now = datetime.now()
+    default_val = (now + timedelta(days=1)).strftime("%Y-%m-%d-%H")
+    date_str = Prompt.ask(prompt, default=default_val)
+    try:
+        year, month, day, hour = map(int, date_str.split("-"))
+        date = datetime(year, month, day, hour)
+        return date
+    except ValueError:
+        raise ValueError("Invalid date format. Please use YYYY-MM-DD-HH.")
+
+
+def location_picker() -> str:
+    """
+    Ask the user to input a location. By default use the current location based on the IP address.
+    """
+    prompt = "Enter a location"
+    g = geocoder.ip("me")
+    default_val = f"{g.city} {g.state}, {g.country}"
+    location = Prompt.ask(prompt, default=default_val)
+    if not location:
+        raise ValueError("location cannot be empty")
+    return location
+
+
+def max_driving_hours_picker() -> int:
+    """
+    Ask the user to input the maximum driving hours. The default is 2 hours.
+    """
+    prompt = "Enter the maximum driving hours"
+    default_val = str(2)
+    max_driving_hours = Prompt.ask(prompt, default=default_val)
+    try:
+        max_driving_hours = int(max_driving_hours)
+        if max_driving_hours <= 0:
+            raise ValueError("Invalid choice")
+        return max_driving_hours
+    except ValueError:
+        raise ValueError("Invalid choice")
+
+
+def get_litellm_model_id(agent_name) -> str:
+    """
+    Ask the user to input a model_id string. Validate it using the litellm.validate_environment function
+    """
+    from litellm.utils import validate_environment
+
+    prompt = f"Enter a valid model_id for agent {agent_name} using LiteLLM syntax"
+    default_val = "openai/gpt-4o"
+    model_id = Prompt.ask(prompt, default=default_val)
+    # make a call to validate the model id: this will throw an error if the model id is not valid
+    get_llm_provider(model=model_id)
+    # make a call to validate that the environment is correct for the model id
+    env_check = validate_environment(model_id)
+    if not env_check["keys_in_environment"]:
+        msg = f"{env_check['missing_keys']} needed for {model_id}"
+        raise ValueError(msg)
+    return model_id
+
+
+def set_mcp_settings(tool):
+    logger.info(
+        f"This MCP uses {tool['command']}. If you don't have this set up this will not work"
+    )
+    if "mcp/filesystem" not in tool["args"]:
+        msg = "The only MCP that this demo supports is the filesystem MCP"
+        raise ValueError(msg)
+    if not any("{{ path_variable }}" in arg for arg in tool["args"]):
+        msg = "The filesystem MCP must have { path_variable } in the args list"
+        raise ValueError(msg)
+    for idx, item in enumerate(tool["args"]):
+        if "{{ path_variable }}" in item:
+            default_val = os.path.join(tempfile.gettempdir(), "surf_spot_finder")
+            answer = Prompt.ask(
+                "Please enter the path you'd like the Filesystem MCP to access",
+                default=default_val,
+            )
+            os.makedirs(answer, exist_ok=True)
+            tool["args"][idx] = item.replace("{{ path_variable }}", answer)
+    return tool
+
+
 class Config(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -36,41 +149,81 @@ class Config(BaseModel):
     managed_agents: list[AgentConfig] | None = None
 
     @classmethod
-    def from_yaml(cls, yaml_path: str) -> "Config":
+    def from_dict(cls, data: dict) -> "Config":
         """
-        with open(yaml_path, "r") as f:
-            data = yaml.safe_load(f)
-        return cls(**data)    yaml_path: Path to the YAML configuration file
+        Create a Config instance from a dictionary.
+        Args:
+            data (dict): A dictionary containing the configuration data.
 
         Returns:
-            Config: A new Config instance populated with values from the YAML file
+            Config: A new Config instance populated with values from the dictionary.
         """
-        with open(yaml_path, "r") as f:
-            data = yaml.safe_load(f)
         # for each tool listed in main_agent.tools, use import lib to import it and replace the str with the callable
         callables = []
-        for tool in data["main_agent"]["tools"]:
+        if data.get("main_agent") is None:
+            data["main_agent"] = {}
+        if not data["main_agent"].get("model_id"):
+            data["main_agent"]["model_id"] = get_litellm_model_id("main_agent")
+        else:
+            logger.info(f"Main agent using model_id {data['main_agent']['model_id']}")
+        for tool in data["main_agent"].get("tools", []):
             if isinstance(tool, str):
                 module_name, func_name = tool.rsplit(".", 1)
                 module = __import__(module_name, fromlist=[func_name])
-                print(f"Importing {tool}")
                 callables.append(getattr(module, func_name))
             else:
                 # this means it must be an MCPStdioParams
-                callables.append(tool)
+                # For the purposes of this demo, currently we just look for the filesystem MCP which we have a placeholder
+                # for the path variable (which controls which dirs the MCP will have access to).
+                mcp_tool = set_mcp_settings(tool)
+                callables.append(mcp_tool)
         data["main_agent"]["tools"] = callables
         for agent in data.get("managed_agents", []):
+            if agent.get("model_id") is None:
+                agent["model_id"] = get_litellm_model_id(
+                    agent.get("name", "managed_agent")
+                )
+            else:
+                logger.info(f"Agent {agent['name']} using model_id {agent['model_id']}")
             callables = []
             for tool in agent.get("tools", []):
                 if isinstance(tool, str):
                     module_name, func_name = tool.rsplit(".", 1)
                     module = __import__(module_name, fromlist=[func_name])
-                    print(f"Importing {tool}")
                     callables.append(getattr(module, func_name))
                 else:
                     # this means it must be an MCPStdioParams
-                    callables.append(tool)
+                    mcp_tool = set_mcp_settings(tool)
+                    callables.append(mcp_tool)
             agent["tools"] = callables
-
-        data["framework"] = AgentFramework[data["framework"]]
+        if not data.get("framework"):
+            data["framework"] = ask_framework()
+        else:
+            logger.info(f"Using framework {data['framework']}")
+        if not data.get("location"):
+            data["location"] = location_picker()
+        else:
+            logger.info(f"Using location {data['location']}")
+        if not data.get("max_driving_hours"):
+            data["max_driving_hours"] = max_driving_hours_picker()
+        else:
+            logger.info(f"Using max driving hours {data['max_driving_hours']}")
+        if not data.get("date"):
+            data["date"] = date_picker()
+        else:
+            logger.info(f"Using date {data['date']}")
         return cls(**data)
+
+    @classmethod
+    def from_yaml(cls, yaml_path: str) -> "Config":
+        """
+        with open(yaml_path, "r") as f:
+            data = yaml.safe_load(f)
+        return cls(**data)    yaml_path: Path to the YAML configuration file
+
+        Returns:
+            Config: A new Config instance populated with values from the YAML file
+        """
+        with open(yaml_path, "r") as f:
+            data = yaml.safe_load(f)
+        return cls.from_dict(data)

src/surf_spot_finder/no_framework.py

@@ -3,7 +3,7 @@ from datetime import datetime
 
 from fire import Fire
 from litellm import completion
-from loguru import logger
+from any_agent.logging import logger
 from pydantic import BaseModel
 
 from any_agent.tools.web_browsing import search_web, visit_webpage
@@ -23,7 +23,6 @@ class SpotScore(BaseModel):
     reason: str
 
 
-@logger.catch(reraise=True)
 def find_surf_spot_no_framework(
     location: str, max_driving_hours: int, date: datetime, model_id: str
 ) -> list[SpotScore]: