Use `any-agent`. (#38)

* Cleanup config

* Use any_agent lib

* Add SSH step

* Move ssh inside install

* Fix

* fix docs and tests

.github/workflows/docs.yaml

@@ -36,8 +36,11 @@ jobs:
           git config user.name 'github-actions[bot]'
           git config user.email 'github-actions[bot]@users.noreply.github.com'
 
-      - name: Install requirements
-        run: pip install -e '.[docs]'
+      - name: Install requirements  # TODO: Remove SSF_SSH_TOKEN when repo becomes public
+        run: |
+          eval `ssh-agent -s`
+          ssh-add - <<< '${{ secrets.SSF_SSH_TOKEN }}'
+          pip install -e '.[docs]'
 
       - name: Build docs
         if: github.event_name == 'pull_request'

.github/workflows/tests.yaml

@@ -26,11 +26,13 @@ jobs:
         with:
           python-version: '3.11'
           cache: "pip"
-      - name: Install
+
+      - name: Install  # TODO: Remove when repo becomes public
         run: |
           eval `ssh-agent -s`
           ssh-add - <<< '${{ secrets.SSF_SSH_TOKEN }}'
-          pip install -e '.[arize,langchain,smolagents,openai,tests]'
+          pip install -e '.[tests]'
+
 
       - name: Run tests
         run: pytest -v tests

.gitignore

@@ -168,3 +168,4 @@ cython_debug/
 .vscode/
 
 output
+telemetry_output

docs/api.md

@@ -4,34 +4,8 @@
 
 ::: surf_spot_finder.config.Config
 
-## Agents
-
-::: surf_spot_finder.agents.RUNNERS
-
-::: surf_spot_finder.agents.langchain
-
-::: surf_spot_finder.agents.openai
-
-::: surf_spot_finder.agents.smolagents
-
 ## Tools
 
 ::: surf_spot_finder.tools.openmeteo
 
 ::: surf_spot_finder.tools.openstreetmap
-
-::: surf_spot_finder.tools.user_interaction
-
-::: surf_spot_finder.tools.web_browsing
-
-## Tracing
-
-::: surf_spot_finder.tracing
-
-## Prompts
-
-::: surf_spot_finder.prompts.openai.SINGLE_AGENT_SYSTEM_PROMPT
-
-::: surf_spot_finder.prompts.openai.MULTI_AGENT_SYSTEM_PROMPT
-
-::: surf_spot_finder.prompts.shared.INPUT_PROMPT

examples/langchain_single_agent.yaml

@@ -1,11 +1,8 @@
-input:
-  location: Pontevedra
-  date: 2025-03-27 12:00
-  max_driving_hours: 2
-  # input_prompt_template:
-agent:
+location: Pontevedra
+date: 2025-04-02 12:00
+max_driving_hours: 2
+
+framework: langchain
+
+main_agent:
   model_id: o3-mini
-  agent_type: langchain
-  tools:
-  - "surf_spot_finder.tools.search_web"
-  - "surf_spot_finder.tools.visit_webpage"

examples/langchain_single_agent_vertical.yaml

@@ -1,17 +1,16 @@
-input:
-  location: Pontevedra
-  date: 2025-03-27 12:00
-  max_driving_hours: 2
-  # input_prompt_template:
-agent:
+location: Pontevedra
+date: 2025-04-02 12:00
+max_driving_hours: 2
+
+framework: langchain
+
+main_agent:
   model_id: o3-mini
-  # model_id: ollama/llama3.2:3b
-  agent_type: langchain
   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"
-  - "surf_spot_finder.tools.search_web"
-  - "surf_spot_finder.tools.visit_webpage"
+  - "any_agent.tools.search_web"
+  - "any_agent.tools.visit_webpage"

examples/openai_multi_agent.yaml

@@ -1,8 +1,38 @@
-input:
-  location: Pontevedra
-  date: 2025-03-27 12:00
-  max_driving_hours: 2
-agent:
+location: Pontevedra
+date: 2025-04-02 12:00
+max_driving_hours: 2
+
+framework: openai
+
+main_agent:
+  name: main_agent
   model_id: o3-mini
-  agent_type: openai_multi_agent
-# input_prompt_template:
+  instructions: >
+    # System context\n
+    You are part of a multi-agent system called the Agents SDK, 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>`.
+    Transfers between agents are handled seamlessly in the background; do not mention or draw attention to these transfers in your conversation with the user.\n
+
+managed_agents:
+
+  - name: user-verifiaction-agent
+    model_id: gpt-4o-mini
+    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
+    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
+    instructions: Communicates to the user
+    handoff: True
+    tools:
+      - any_agent.tools.show_final_answer

examples/openai_single_agent.yaml

@@ -1,11 +1,8 @@
-input:
-  location: Pontevedra
-  date: 2025-03-27 12:00
-  max_driving_hours: 2
-  # input_prompt_template:
-agent:
+location: Pontevedra
+date: 2025-04-02 12:00
+max_driving_hours: 2
+
+framework: openai
+
+main_agent:
   model_id: o3-mini
-  agent_type: openai
-  tools:
-  - "surf_spot_finder.tools.search_web"
-  - "surf_spot_finder.tools.visit_webpage"

examples/openai_single_agent_vertical.yaml

@@ -1,11 +1,11 @@
-input:
-  location: Pontevedra
-  date: 2025-03-26 12:00
-  max_driving_hours: 2
-  # input_prompt_template:
-agent:
+location: Pontevedra
+date: 2025-04-02 12:00
+max_driving_hours: 2
+
+framework: openai
+
+main_agent:
   model_id: o3-mini
-  agent_type: openai
   tools:
   - "surf_spot_finder.tools.driving_hours_to_meters"
   - "surf_spot_finder.tools.get_area_lat_lon"

examples/smolagents_single_agent.yaml

@@ -1,9 +1,9 @@
-input:
-  location: Pontevedra
-  date: 2025-03-27 12:00
-  max_driving_hours: 2
-  # input_prompt_template:
-agent:
+location: Pontevedra
+date: 2025-04-02 12:00
+max_driving_hours: 2
+
+framework: smolagents
+
+main_agent:
   model_id: openai/o3-mini
   api_key_var: OPENAI_API_KEY
-  agent_type: smolagents

examples/smolagents_single_agent_mcp.yaml

@@ -1,12 +0,0 @@
-input:
-  location: Pontevedra
-  date: 2025-03-27 12:00
-  max_driving_hours: 2
-  # input_prompt_template:
-agent:
-  model_id: openai/gpt-3.5-turbo
-  api_key_var: OPENAI_API_KEY
-  agent_type: smolagents
-  tools:
-    - "smolagents.DuckDuckGoSearchTool"
-    - "mcp/fetch"

examples/smolagents_single_agent_vertical.yaml

@@ -1,19 +1,19 @@
-input:
-  location: Pontevedra
-  date: 2025-03-27 12:00
-  max_driving_hours: 2
-  # input_prompt_template:
-agent:
-  model_id: openai/o1
+location: Pontevedra
+date: 2025-04-02 12:00
+max_driving_hours: 2
+
+framework: smolagents
+
+main_agent:
+  model_id: openai/o3-mini
   api_key_var: OPENAI_API_KEY
-  agent_type: smolagents
   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"
-  - "surf_spot_finder.tools.search_web"
-  - "surf_spot_finder.tools.visit_webpage"
+  - "any_agent.tools.search_web"
+  - "any_agent.tools.visit_webpage"
   - "smolagents.PythonInterpreterTool"
   - "smolagents.FinalAnswerTool"

pyproject.toml

@@ -13,30 +13,10 @@ dependencies = [
   "fire",
   "loguru",
   "pydantic",
+  "pyyaml",
 ]
 
 [project.optional-dependencies]
-langchain = [
-  "langchain",
-  "langgraph",
-  "langchain-openai>=0.3.9",
-  "langchain-ollama>=0.3.0",
-  "openinference-instrumentation-langchain"
-]
-smolagents = [
-  "smolagents[litellm]>=1.10.0",
-  "openinference-instrumentation-smolagents>=0.1.4"
-]
-
-openai = [
-  "openai-agents",
-  "openinference-instrumentation-openai-agents>=0.1.2"
-]
-
-mcp = [
-  "mcp==1.3.0",
-]
-
 demo = [
   "gradio",
   "spaces"
@@ -55,11 +35,6 @@ tests = [
   "evaluate>=0.4.3",
 ]
 
-# TODO maybe we don't want to keep this, or we want to swap this to Lumigator SDK
-arize = [
-  "arize-phoenix>=8.12.1",
-]
-
 [project.urls]
 Documentation = "https://mozilla-ai.github.io/surf-spot-finder/"
 Issues = "https://github.com/mozilla-ai/surf-spot-finder/issues"

src/surf_spot_finder/agents/__init__.py

@@ -1,30 +0,0 @@
-from enum import Enum
-from .langchain import run_lanchain_agent
-from .openai import run_openai_agent, run_openai_multi_agent
-from .smolagents import run_smolagent
-
-
-# Define the available agent type enums
-class AgentType(str, Enum):
-    LANGCHAIN = "langchain"
-    OPENAI = "openai"
-    OPENAI_MULTI_AGENT = "openai_multi_agent"
-    SMOLAGENTS = "smolagents"
-
-
-RUNNERS = {
-    AgentType.LANGCHAIN: run_lanchain_agent,
-    AgentType.OPENAI: run_openai_agent,
-    AgentType.SMOLAGENTS: run_smolagent,
-    AgentType.OPENAI_MULTI_AGENT: run_openai_multi_agent,
-}
-
-
-def validate_agent_type(value: str) -> str:
-    try:
-        agent_type = AgentType(value)
-        if agent_type not in RUNNERS:
-            raise ValueError(f"agent_type {value} is valid but has no runner")
-        return value
-    except ValueError:
-        raise ValueError(f"agent_type must be one of {[e.value for e in AgentType]}")

src/surf_spot_finder/agents/langchain.py

@@ -1,70 +0,0 @@
-import inspect
-import importlib
-
-from loguru import logger
-
-try:
-    from langchain.chat_models import init_chat_model
-    from langchain_core.messages import HumanMessage
-    from langchain_core.tools import BaseTool, tool
-    from langgraph.checkpoint.memory import MemorySaver
-    from langgraph.prebuilt import create_react_agent
-
-    langchain_available = True
-except ImportError:
-    langchain_available = False
-
-DEFAULT_RECURSION_LIMIT = 50
-
-
-@logger.catch(reraise=True)
-def run_lanchain_agent(
-    model_id: str, prompt: str, tools: list[str] | None = None, **kwargs
-):
-    """Runs an langchain ReAct agent with the given prompt and configuration.
-
-    Uses [create_react_agent](https://langchain-ai.github.io/langgraph/reference/prebuilt/#langgraph.prebuilt.chat_agent_executor.create_react_agent).
-
-    Args:
-        model_id: The ID of the model to use.
-            See [init_chat_model](https://python.langchain.com/api_reference/langchain/chat_models/langchain.chat_models.base.init_chat_model.html).
-        prompt: The prompt to be given to the agent.
-    """
-    if not langchain_available:
-        raise ImportError(
-            "You need to `pip install langchain langgraph` to use this agent"
-        )
-
-    if tools is None:
-        tools = [
-            "surf_spot_finder.tools.search_web",
-            "surf_spot_finder.tools.visit_webpage",
-        ]
-
-    imported_tools = []
-    for imported_tool in tools:
-        module, func = imported_tool.rsplit(".", 1)
-        module = importlib.import_module(module)
-        imported_tool = getattr(module, func)
-        if inspect.isclass(imported_tool):
-            imported_tool = imported_tool()
-        if not isinstance(imported_tool, BaseTool):
-            imported_tool = tool(imported_tool)
-        imported_tools.append((imported_tool))
-    if "/" in model_id:
-        model_provider, model_id = model_id.split("/")
-        model = init_chat_model(model_id, model_provider=model_provider)
-    else:
-        model = init_chat_model(model_id)
-    agent = create_react_agent(
-        model=model, tools=imported_tools, checkpointer=MemorySaver()
-    )
-    for step in agent.stream(
-        {"messages": [HumanMessage(content=prompt)]},
-        {
-            "configurable": {"thread_id": "abc123"},
-            "recursion_limit": DEFAULT_RECURSION_LIMIT,
-        },
-        stream_mode="values",
-    ):
-        step["messages"][-1].pretty_print()

src/surf_spot_finder/agents/openai.py

@@ -1,187 +0,0 @@
-import os
-from typing import Optional
-
-from loguru import logger
-
-from surf_spot_finder.prompts.openai import (
-    SINGLE_AGENT_SYSTEM_PROMPT,
-    MULTI_AGENT_SYSTEM_PROMPT,
-)
-from surf_spot_finder.tools.wrappers import import_and_wrap_tools, wrap_tool_openai
-
-
-try:
-    from agents import (
-        Agent,
-        AsyncOpenAI,
-        OpenAIChatCompletionsModel,
-        Runner,
-        RunResult,
-        function_tool,
-    )
-
-    agents_available = True
-except ImportError:
-    agents_available = None
-
-DEFAULT_MAX_TURNS = 20
-
-
-@logger.catch(reraise=True)
-def run_openai_agent(
-    model_id: str,
-    prompt: str,
-    name: str = "surf-spot-finder",
-    instructions: Optional[str] = SINGLE_AGENT_SYSTEM_PROMPT,
-    api_key_var: Optional[str] = None,
-    api_base: Optional[str] = None,
-    tools: Optional[list[str]] = None,
-    max_turns: Optional[int] = DEFAULT_MAX_TURNS,
-) -> RunResult:
-    """Runs an OpenAI agent with the given prompt and configuration.
-
-    It leverages the 'agents' library to create and manage the agent
-    execution.
-
-    See https://openai.github.io/openai-agents-python/ref/agent/ for more details.
-
-
-    Args:
-        model_id (str): The ID of the OpenAI model to use (e.g., "gpt4o").
-            See https://platform.openai.com/docs/api-reference/models.
-        prompt (str): The prompt to be given to the agent.
-        name (str, optional): The name of the agent. Defaults to "surf-spot-finder".
-        instructions (Optional[str], optional): Initial instructions to give the agent.
-            Defaults to [SINGLE_AGENT_SYSTEM_PROMPT][surf_spot_finder.prompts.openai.SINGLE_AGENT_SYSTEM_PROMPT].
-        api_key_var (Optional[str], optional): The name of the environment variable
-            containing the OpenAI API key. If provided, along with `base_url`, an
-            external OpenAI client will be used. Defaults to None.
-        api_base (Optional[str], optional): The base URL for the OpenAI API.
-            Required if `api_key_var` is provided to use an external OpenAI client.
-            Defaults to None.
-
-
-    Returns:
-        RunResult: A RunResult object containing the output of the agent run.
-            See https://openai.github.io/openai-agents-python/ref/result/#agents.result.RunResult.
-    """
-    if not agents_available:
-        raise ImportError("You need to `pip install openai-agents` to use this agent")
-
-    if tools is None:
-        tools = [
-            "surf_spot_finder.tools.search_web",
-            "surf_spot_finder.tools.visit_webpage",
-        ]
-
-    imported_tools = import_and_wrap_tools(tools, wrap_tool_openai)
-
-    if api_key_var and api_base:
-        external_client = AsyncOpenAI(
-            api_key=os.environ[api_key_var],
-            base_url=api_base,
-        )
-        agent = Agent(
-            name=name,
-            instructions=instructions,
-            model=OpenAIChatCompletionsModel(
-                model=model_id,
-                openai_client=external_client,
-            ),
-            tools=imported_tools,
-        )
-    else:
-        agent = Agent(
-            model=model_id,
-            instructions=instructions,
-            name=name,
-            tools=imported_tools,
-        )
-    result = Runner.run_sync(starting_agent=agent, input=prompt, max_turns=max_turns)
-    logger.info(result.final_output)
-    return result
-
-
-@logger.catch(reraise=True)
-def run_openai_multi_agent(
-    model_id: str,
-    prompt: str,
-    name: str = "surf-spot-finder",
-    instructions: Optional[str] = MULTI_AGENT_SYSTEM_PROMPT,
-    max_turns: Optional[int] = DEFAULT_MAX_TURNS,
-    **kwargs,
-) -> RunResult:
-    """Runs multiple OpenAI agents orchestrated by a main agent.
-
-    It leverages the 'agents' library to create and manage the agent
-    execution.
-
-    See https://openai.github.io/openai-agents-python/ref/agent/ for more details.
-
-
-    Args:
-        model_id (str): The ID of the OpenAI model to use (e.g., "gpt4o").
-            See https://platform.openai.com/docs/api-reference/models.
-        prompt (str): The prompt to be given to the agent.
-        name (str, optional): The name of the main agent. Defaults to "surf-spot-finder".
-        instructions (Optional[str], optional): Initial instructions to give the agent.
-            Defaults to [MULTI_AGENT_SYSTEM_PROMPT][surf_spot_finder.prompts.openai.MULTI_AGENT_SYSTEM_PROMPT].
-
-    Returns:
-        RunResult: A RunResult object containing the output of the agent run.
-            See https://openai.github.io/openai-agents-python/ref/result/#agents.result.RunResult.
-    """
-    if not agents_available:
-        raise ImportError("You need to `pip install openai-agents` to use this agent")
-
-    from surf_spot_finder.tools import (
-        ask_user_verification,
-        show_final_answer,
-        show_plan,
-        search_web,
-        visit_webpage,
-    )
-
-    user_verification_agent = Agent(
-        model=model_id,
-        instructions="Interact with the user by showing information and asking for verification.",
-        name="user-verification-agent",
-        tools=[function_tool(ask_user_verification), function_tool(show_plan)],
-    )
-
-    search_web_agent = Agent(
-        model=model_id,
-        instructions="Find relevant information about the provided task by using your tools.",
-        name="search-web-agent",
-        tools=[function_tool(search_web), function_tool(visit_webpage)],
-    )
-
-    communication_agent = Agent(
-        model=model_id,
-        instructions="Communicate the final answer to the user.",
-        name="communication-agent",
-        tools=[function_tool(show_final_answer)],
-    )
-
-    main_agent = Agent(
-        model=model_id,
-        instructions=instructions,
-        name=name,
-        handoffs=[communication_agent],
-        tools=[
-            search_web_agent.as_tool(
-                tool_name="search_web_with_agent",
-                tool_description=search_web_agent.instructions,
-            ),
-            user_verification_agent.as_tool(
-                tool_name="ask_user_verification_with_agent",
-                tool_description=user_verification_agent.instructions,
-            ),
-        ],
-    )
-
-    result = Runner.run_sync(
-        starting_agent=main_agent, input=prompt, max_turns=max_turns
-    )
-    logger.info(result.final_output)
-    return result

src/surf_spot_finder/agents/smolagents.py

@@ -1,100 +0,0 @@
-import os
-from typing import Optional
-
-from loguru import logger
-
-from surf_spot_finder.prompts.smolagents import SYSTEM_PROMPT
-from surf_spot_finder.tools.wrappers import import_and_wrap_tools, wrap_tool_smolagents
-
-
-try:
-    from smolagents import (
-        CodeAgent,
-        LiteLLMModel,
-    )
-
-    smolagents_available = True
-except ImportError:
-    smolagents_available = None
-
-
-@logger.catch(reraise=True)
-def run_smolagent(
-    model_id: str,
-    prompt: str,
-    api_key_var: Optional[str] = None,
-    api_base: Optional[str] = None,
-    tools: Optional[list[str]] = None,
-) -> CodeAgent:
-    """
-    Create and configure a Smolagents CodeAgent with the specified model.
-
-    See https://docs.litellm.ai/docs/providers for details on available LiteLLM providers.
-
-    Args:
-        model_id (str): Model identifier using LiteLLM syntax (e.g., 'openai/o1', 'anthropic/claude-3-sonnet')
-        prompt (str): Prompt to provide to the model
-        api_key_var (Optional[str]): Name of environment variable containing the API key
-        api_base (Optional[str]): Custom API base URL, if needed for non-default endpoints
-
-    Returns:
-        CodeAgent: Configured agent ready to process requests
-
-    Example:
-
-        >>> agent = run_smolagent("anthropic/claude-3-haiku", "my prompt here", "ANTHROPIC_API_KEY", None, None)
-        >>> agent.run("Find surf spots near San Diego")
-    """
-    if not smolagents_available:
-        raise ImportError("You need to `pip install smolagents` to use this agent")
-
-    if tools is None:
-        tools = [
-            "smolagents.DuckDuckGoSearchTool",
-            "smolagents.VisitWebpageTool",
-            "smolagents.PythonInterpreterTool",
-        ]
-
-    mcp_tool = None
-    for tool in tools:
-        if "mcp" in tool:
-            mcp_tool = tool
-            tools.remove(tool)
-    imported_tools = import_and_wrap_tools(tools, wrap_tool_smolagents)
-
-    model = LiteLLMModel(
-        model_id=model_id,
-        api_base=api_base if api_base else None,
-        api_key=os.environ[api_key_var] if api_key_var else None,
-    )
-
-    if mcp_tool:
-        from mcp import StdioServerParameters
-        from smolagents import ToolCollection
-
-        # We could easily use any of the MCPs at https://github.com/modelcontextprotocol/servers
-        # or at https://glama.ai/mcp/servers
-        # or at https://smithery.ai/
-        server_parameters = StdioServerParameters(
-            command="docker",
-            args=["run", "-i", "--rm", mcp_tool],
-            env={**os.environ},
-        )
-        # https://huggingface.co/docs/smolagents/v1.10.0/en/reference/tools#smolagents.ToolCollection.from_mcp
-        with ToolCollection.from_mcp(server_parameters) as tool_collection:
-            agent = CodeAgent(
-                tools=imported_tools + tool_collection.tools,
-                prompt_templates={"system_prompt": SYSTEM_PROMPT},
-                model=model,
-                add_base_tools=False,  # Turn this on if you want to let it run python code as it sees fit
-            )
-            agent.run(prompt)
-    else:
-        agent = CodeAgent(
-            tools=imported_tools,
-            prompt_templates={"system_prompt": SYSTEM_PROMPT},
-            model=model,
-        )
-        agent.run(prompt)
-
-    return agent

src/surf_spot_finder/cli.py

@@ -1,4 +1,5 @@
-from typing import Optional
+import yaml
+from pathlib import Path
 
 from fire import Fire
 from loguru import logger
@@ -6,88 +7,46 @@ from loguru import logger
 from surf_spot_finder.config import (
     Config,
 )
-from surf_spot_finder.agents import RUNNERS
-from surf_spot_finder.prompts.shared import INPUT_PROMPT
-from surf_spot_finder.tracing import get_tracer_provider, setup_tracing
+from any_agent import load_agent, run_agent
+from any_agent.tracing import get_tracer_provider, setup_tracing
 
 
 @logger.catch(reraise=True)
 def find_surf_spot(
-    location: Optional[str] = None,
-    date: Optional[str] = None,
-    max_driving_hours: Optional[int] = None,
-    model_id: Optional[str] = None,
-    agent_type: str = "smolagents",
-    api_key_var: Optional[str] = None,
-    input_prompt_template: str = INPUT_PROMPT,
-    json_tracer: bool = True,
-    api_base: Optional[str] = None,
-    tools: Optional[list[dict]] = None,
-    from_config: Optional[str] = None,
+    config_file: str,
 ) -> str:
     """Find the best surf spot based on the given criteria.
 
     Args:
-        location (str): The location to search around.
-            Required if `from_config` is not provided.
-        date (str): The date to search for.
-            Required if `from_config` is not provided.
-        max_driving_hours (int): The maximum driving hours from the location.
-            Required if `from_config` is not provided.
-        model_id (str): The ID of the model to use.
-            Required if `from_config` is not provided.
+        config_file: Path to a YAML config file.
+            See [Config][surf_spot_finder.config.Config]
 
-            If using `agent_type=smolagents`, use LiteLLM syntax (e.g., 'openai/o1', 'anthropic/claude-3-sonnet').
-            If using `agent_type={openai,openai_multi_agent}`, use OpenAI syntax (e.g., 'o1').
-        agent_type (str, optional): The type of agent to use.
-            Must be one of the supported types in [RUNNERS][surf_spot_finder.agents.RUNNERS].
-        api_key_var (Optional[str], optional): The name of the environment variable containing the API key.
-        input_prompt_template (str, optional): The template for the imput_prompt.
-
-            Must contain the following placeholders: `{LOCATION}`, `{MAX_DRIVING_HOURS}`, and `{DATE}`.
-        json_tracer (bool, optional): Whether to use the custom JSON file exporter.
-        api_base (Optional[str], optional): The base URL for the API.
-        from_config (Optional[str], optional): Path to a YAML config file.
-
-            If provided, all other arguments will be ignored.
     """
-    if from_config:
-        logger.info(f"Loading {from_config}")
-        config = Config.from_yaml(from_config)
-    else:
-        config = Config(
-            location=location,
-            date=date,
-            max_driving_hours=max_driving_hours,
-            model_id=model_id,
-            agent_type=agent_type,
-            api_key_var=api_key_var,
-            prompt=input_prompt_template,
-            json_tracer=json_tracer,
-            api_base=api_base,
-            tools=tools,
-        )
+    logger.info(f"Loading {config_file}")
+    config = Config.model_validate(yaml.safe_load(Path(config_file).read_text()))
 
     logger.info("Setting up tracing")
-    tracer_provider, tracing_path = get_tracer_provider(
-        project_name="surf-spot-finder",
-        json_tracer=config.json_tracer,
-        agent_type=config.agent_type,
+    tracer_provider, tracing_path = get_tracer_provider(project_name="surf-spot-finder")
+    setup_tracing(tracer_provider, config.framework)
+
+    logger.info(f"Loading {config.framework} agent")
+    logger.info(f"{config.managed_agents}")
+    agent = load_agent(
+        framework=config.framework,
+        main_agent=config.main_agent,
+        managed_agents=config.managed_agents,
     )
-    setup_tracing(tracer_provider, config.agent_type)
 
-    logger.info(f"Running {config.agent_type} agent")
-    RUNNERS[config.agent_type](
-        model_id=config.model_id,
-        prompt=config.input_prompt_template.format(
-            LOCATION=config.location,
-            MAX_DRIVING_HOURS=config.max_driving_hours,
-            DATE=config.date,
-        ),
-        api_base=config.api_base,
-        api_key_var=config.api_key_var,
-        tools=config.tools,
+    query = config.input_prompt_template.format(
+        LOCATION=config.location,
+        MAX_DRIVING_HOURS=config.max_driving_hours,
+        DATE=config.date,
     )
+    logger.info(f"Running agent with query:\n{query}")
+    run_agent(agent, query)
+
+    logger.success("Done!")
+
     return tracing_path
 
 

src/surf_spot_finder/config.py

@@ -1,8 +1,14 @@
-from typing import Annotated, Optional
+from typing import Annotated
+
+from any_agent.schema import AgentSchema
 from pydantic import AfterValidator, BaseModel, FutureDatetime, PositiveInt
-import yaml
 
-from surf_spot_finder.prompts.shared import INPUT_PROMPT
+
+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}?"
+""".strip()
 
 
 def validate_prompt(value) -> str:
@@ -12,50 +18,15 @@ def validate_prompt(value) -> str:
     return value
 
 
-def validate_agent_type(value) -> str:
-    from surf_spot_finder.agents import validate_agent_type
-
-    validate_agent_type(value)
-    return value
-
-
 class Config(BaseModel):
-    input_prompt_template: Annotated[str, AfterValidator(validate_prompt)] = (
-        INPUT_PROMPT
-    )
     location: str
     max_driving_hours: PositiveInt
     date: FutureDatetime
-    model_id: str
-    agent_type: Annotated[str, AfterValidator(validate_agent_type)]
-    api_key_var: Optional[str] = None
-    json_tracer: bool = True
-    api_base: Optional[str] = None
-    tools: Optional[list[str]] = None
-
-    @classmethod
-    def from_yaml(cls, yaml_path: str) -> "Config":
-        """
-        Create a Config instance from a YAML file.
-
-        Args:
-            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)
-
-        # Extract and flatten the nested structure
-        config_dict = {}
-
-        # Add input parameters
-        if "input" in data:
-            config_dict.update(data["input"])
-
-        # Add agent parameters
-        if "agent" in data:
-            config_dict.update(data["agent"])
-        # Create instance from the flattened dictionary
-        return cls(**config_dict)
+    input_prompt_template: Annotated[str, AfterValidator(validate_prompt)] = (
+        INPUT_PROMPT_TEMPLATE
+    )
+
+    framework: str
+
+    main_agent: AgentSchema
+    managed_agents: list[AgentSchema] | None = None

src/surf_spot_finder/prompts/shared.py

@@ -1,5 +0,0 @@
-INPUT_PROMPT = """
-According to the forecast, what will be the best spot to surf around {LOCATION},
-in a {MAX_DRIVING_HOURS} hour driving radius,
-at {DATE}?"
-""".strip()

src/surf_spot_finder/tools/__init__.py

@@ -1,17 +1,10 @@
 from .openmeteo import get_wave_forecast, get_wind_forecast
 from .openstreetmap import driving_hours_to_meters, get_area_lat_lon, get_surfing_spots
-from .user_interaction import show_final_answer, show_plan, ask_user_verification
-from .web_browsing import search_web, visit_webpage
 
 __all__ = [
-    driving_hours_to_meters,
-    get_area_lat_lon,
-    get_surfing_spots,
-    get_wave_forecast,
-    get_wind_forecast,
-    search_web,
-    show_final_answer,
-    show_plan,
-    ask_user_verification,
-    visit_webpage,
+    "driving_hours_to_meters",
+    "get_area_lat_lon",
+    "get_surfing_spots",
+    "get_wave_forecast",
+    "get_wind_forecast",
 ]

src/surf_spot_finder/tools/user_interaction.py

@@ -1,30 +0,0 @@
-from loguru import logger
-
-
-def show_plan(plan: str) -> None:
-    """Show the current plan to the user.
-
-    Args:
-        plan: The current plan.
-    """
-    logger.info(f"Current plan: {plan}")
-    return plan
-
-
-def show_final_answer(answer: str) -> None:
-    """Show the final answer to the user.
-
-    Args:
-        answer: The final answer.
-    """
-    logger.info(f"Final answer: {answer}")
-    return answer
-
-
-def ask_user_verification(query: str) -> str:
-    """Asks user to verify the given `query`.
-
-    Args:
-        query: The question that requires verification.
-    """
-    return input(f"{query} => Type your answer here:")

src/surf_spot_finder/tools/web_browsing.py

@@ -1,54 +0,0 @@
-import re
-
-import requests
-from duckduckgo_search import DDGS
-from markdownify import markdownify
-from requests.exceptions import RequestException
-
-
-def _truncate_content(content: str, max_length: int) -> str:
-    if len(content) <= max_length:
-        return content
-    else:
-        return (
-            content[: max_length // 2]
-            + f"\n..._This content has been truncated to stay below {max_length} characters_...\n"
-            + content[-max_length // 2 :]
-        )
-
-
-def search_web(query: str) -> str:
-    """Performs a duckduckgo web search based on your query (think a Google search) then returns the top search results.
-
-    Args:
-        query: The search query to perform.
-
-    Returns:
-        The top search results.
-    """
-    ddgs = DDGS()
-    results = ddgs.text(query, max_results=10)
-    return "\n".join(
-        f"[{result['title']}]({result['href']})\n{result['body']}" for result in results
-    )
-
-
-def visit_webpage(url: str) -> str:
-    """Visits a webpage at the given url and reads its content as a markdown string. Use this to browse webpages.
-
-    Args:
-        url: The url of the webpage to visit.
-    """
-    try:
-        response = requests.get(url)
-        response.raise_for_status()
-
-        markdown_content = markdownify(response.text).strip()
-
-        markdown_content = re.sub(r"\n{2,}", "\n", markdown_content)
-
-        return _truncate_content(markdown_content, 10000)
-    except RequestException as e:
-        return f"Error fetching the webpage: {str(e)}"
-    except Exception as e:
-        return f"An unexpected error occurred: {str(e)}"

src/surf_spot_finder/tools/wrappers.py

@@ -1,41 +0,0 @@
-import inspect
-import importlib
-from collections.abc import Callable
-
-
-def import_and_wrap_tools(tools: list[str], wrapper: Callable) -> list[Callable]:
-    imported_tools = []
-    for tool in tools:
-        module, func = tool.rsplit(".", 1)
-        module = importlib.import_module(module)
-        imported_tool = getattr(module, func)
-        if inspect.isclass(imported_tool):
-            imported_tool = imported_tool()
-        imported_tools.append(wrapper(imported_tool))
-    return imported_tools
-
-
-def wrap_tool_openai(tool):
-    from agents import function_tool, FunctionTool
-
-    if not isinstance(tool, FunctionTool):
-        return function_tool(tool)
-    return tool
-
-
-def wrap_tool_langchain(tool):
-    from langchain_core.tools import BaseTool
-    from langchain_core.tools import tool as langchain_tool
-
-    if not isinstance(tool, BaseTool):
-        return langchain_tool(tool)
-    return tool
-
-
-def wrap_tool_smolagents(tool):
-    from smolagents import Tool, tool as smolagents_tool
-
-    if not isinstance(tool, Tool):
-        return smolagents_tool(tool)
-
-    return tool

src/surf_spot_finder/tracing.py

@@ -1,114 +0,0 @@
-import os
-import json
-from datetime import datetime
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor, SpanExporter
-
-from surf_spot_finder.agents import AgentType
-
-
-class JsonFileSpanExporter(SpanExporter):
-    def __init__(self, file_name: str):
-        self.file_name = file_name
-        # Initialize with an empty array if file doesn't exist
-        if not os.path.exists(self.file_name):
-            with open(self.file_name, "w") as f:
-                json.dump([], f)
-
-    def export(self, spans) -> None:
-        # Read existing spans
-        try:
-            with open(self.file_name, "r") as f:
-                all_spans = json.load(f)
-        except (json.JSONDecodeError, FileNotFoundError):
-            all_spans = []
-
-        # Add new spans
-        for span in spans:
-            try:
-                # Try to parse the span data from to_json() if it returns a string
-                span_data = json.loads(span.to_json())
-            except (json.JSONDecodeError, TypeError, AttributeError):
-                # If span.to_json() doesn't return valid JSON string
-                span_data = {"error": "Could not serialize span", "span_str": str(span)}
-
-            all_spans.append(span_data)
-
-        # Write all spans back to the file as a proper JSON array
-        with open(self.file_name, "w") as f:
-            json.dump(all_spans, f, indent=2)
-
-    def shutdown(self):
-        pass
-
-
-def get_tracer_provider(
-    project_name: str,
-    json_tracer: bool,
-    agent_type: AgentType,
-    output_dir: str = "output",
-) -> tuple[TracerProvider, str | None]:
-    """
-    Create a tracer_provider based on the selected mode.
-
-    Args:
-        project_name: Name of the project for tracing
-        json_tracer: Whether to use the custom JSON file exporter (True) or Phoenix (False)
-        agent_type: The type of agent being used.
-        output_dir: The directory where the telemetry output will be stored.
-            Only used if `json_tracer=True`.
-            Defaults to "output".
-
-    Returns:
-        tracer_provider: The configured tracer provider
-        file_name: The name of the JSON file where telemetry will be stored
-    """
-    if json_tracer:
-        if not os.path.exists(output_dir):
-            os.makedirs(output_dir)
-        timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
-
-        tracer_provider = TracerProvider()
-        file_name = f"{output_dir}/{agent_type}-{project_name}-{timestamp}.json"
-        json_file_exporter = JsonFileSpanExporter(file_name=file_name)
-        span_processor = SimpleSpanProcessor(json_file_exporter)
-        tracer_provider.add_span_processor(span_processor)
-    else:
-        from phoenix.otel import register
-
-        tracer_provider = register(
-            project_name=project_name, set_global_tracer_provider=True
-        )
-        file_name = None
-
-    return tracer_provider, file_name
-
-
-def setup_tracing(tracer_provider: TracerProvider, agent_type: str) -> None:
-    """Setup tracing for `agent_type` by instrumenting `trace_provider`.
-
-    Args:
-        tracer_provider (TracerProvider): The configured tracer provider from
-            [get_tracer_provider][surf_spot_finder.tracing.get_tracer_provider].
-        agent_type (str): The type of agent being used.
-            Must be one of the supported types in [RUNNERS][surf_spot_finder.agents.RUNNERS].
-    """
-    from surf_spot_finder.agents import validate_agent_type
-
-    validate_agent_type(agent_type)
-
-    if "openai" in agent_type:
-        from openinference.instrumentation.openai_agents import (
-            OpenAIAgentsInstrumentor as Instrumentor,
-        )
-    elif agent_type == "smolagents":
-        from openinference.instrumentation.smolagents import (
-            SmolagentsInstrumentor as Instrumentor,
-        )
-    elif agent_type == "langchain":
-        from openinference.instrumentation.langchain import (
-            LangChainInstrumentor as Instrumentor,
-        )
-    else:
-        raise ValueError(f"Unsupported agent type: {agent_type}")
-    Instrumentor().instrument(tracer_provider=tracer_provider)

tests/integration/agents/test_integration_openai.py

@@ -1,34 +0,0 @@
-import os
-import pytest
-
-from surf_spot_finder.agents.openai import run_openai_agent
-
-INTEGRATION_MODEL = "gpt-4o-mini"
-API_KEY_VAR = "OPENAI_API_KEY"
-
-
-@pytest.mark.skipif(
-    "INTEGRATION_TESTS" not in os.environ,
-    reason="Integration tests require INTEGRATION_TESTS env var",
-)
-def test_openai_real_execution():
-    """
-    Tests the actual execution of the agent against real APIs.
-
-    WARNING: This will make actual API calls and incur costs.
-    Only run when explicitly needed for full system testing.
-
-    Requires:
-    - OPENAI_API_KEY in environment variables
-    - INTEGRATION_TESTS env var to be set
-    """
-    from agents import RunResult, ToolCallItem
-
-    result = run_openai_agent(
-        INTEGRATION_MODEL,
-        "What will be the best surf spot around Vigo, in a 2 hour driving radius, tomorrow?",
-        api_key_var=API_KEY_VAR,
-    )
-
-    assert isinstance(result, RunResult)
-    assert any(isinstance(item, ToolCallItem) for item in result.new_items)

tests/integration/agents/test_integration_smolagents.py

@@ -1,67 +0,0 @@
-import os
-import pytest
-from unittest.mock import patch
-
-from surf_spot_finder.agents.smolagents import run_smolagent
-
-# TODO I'd rather not use openai
-INTEGRATION_MODEL = "openai/gpt-3.5-turbo"
-API_KEY_VAR = "OPENAI_API_KEY"
-
-
-@pytest.mark.skipif(
-    "INTEGRATION_TESTS" not in os.environ,
-    reason="Integration tests require INTEGRATION_TESTS env var",
-)
-def test_smolagent_integration():
-    """
-    Full integration test of the smolagent functionality.
-
-    Requires:
-    - Docker to be running
-    - OPENAI_API_KEY in environment variables
-    - INTEGRATION_TESTS env var to be set
-    """
-    with patch("smolagents.CodeAgent") as MockCodeAgent:
-        # Create a mock agent that returns itself from run()
-        mock_agent = MockCodeAgent.return_value
-        mock_agent.run.return_value = mock_agent
-
-        # Run the agent
-        result = run_smolagent(
-            INTEGRATION_MODEL,
-            "Find popular surf spots in California",
-            api_key_var=API_KEY_VAR,
-        )
-
-        # Verify the agent was created and run
-        MockCodeAgent.assert_called_once()
-        mock_agent.run.assert_called_once_with("Find popular surf spots in California")
-        assert result is mock_agent
-
-
-@pytest.mark.skipif(
-    "INTEGRATION_TESTS" not in os.environ,
-    reason="Full integration tests require INTEGRATION_TESTS env var",
-)
-def test_smolagent_real_execution():
-    """
-    Tests the actual execution of the agent against real APIs.
-
-    WARNING: This will make actual API calls and incur costs.
-    Only run when explicitly needed for full system testing.
-
-    Requires:
-    - Docker to be running
-    - OPENAI_API_KEY in environment variables
-    - INTEGRATION_TESTS env var to be set
-    """
-    # Run with a simple, inexpensive request
-    agent = run_smolagent(
-        INTEGRATION_MODEL,
-        "What are three popular surf spots in California?",
-        api_key_var=API_KEY_VAR,
-    )
-
-    # Basic verification that we got an agent back
-    assert agent is not None

tests/unit/agents/test_unit_langchain.py

@@ -1,33 +0,0 @@
-from unittest.mock import patch, MagicMock
-
-from surf_spot_finder.agents.langchain import (
-    run_lanchain_agent,
-)
-from surf_spot_finder.tools import (
-    search_web,
-    visit_webpage,
-)
-
-
-def test_run_langchain_agent_default():
-    model_mock = MagicMock()
-    create_mock = MagicMock()
-    agent_mock = MagicMock()
-    create_mock.return_value = agent_mock
-    memory_mock = MagicMock()
-    tool_mock = MagicMock()
-
-    with (
-        patch("surf_spot_finder.agents.langchain.create_react_agent", create_mock),
-        patch("surf_spot_finder.agents.langchain.init_chat_model", model_mock),
-        patch("surf_spot_finder.agents.langchain.MemorySaver", memory_mock),
-        patch("surf_spot_finder.agents.langchain.tool", tool_mock),
-    ):
-        run_lanchain_agent("gpt-4o", "Test prompt")
-        model_mock.assert_called_once_with("gpt-4o")
-        create_mock.assert_called_once_with(
-            model=model_mock.return_value,
-            tools=[tool_mock(search_web), tool_mock(visit_webpage)],
-            checkpointer=memory_mock.return_value,
-        )
-        agent_mock.stream.assert_called_once()

tests/unit/agents/test_unit_openai.py

@@ -1,110 +0,0 @@
-import os
-import pytest
-from unittest.mock import patch, MagicMock, ANY
-
-from surf_spot_finder.agents.openai import (
-    run_openai_agent,
-    run_openai_multi_agent,
-)
-from surf_spot_finder.tools import (
-    show_final_answer,
-    show_plan,
-    ask_user_verification,
-    search_web,
-    visit_webpage,
-)
-from surf_spot_finder.prompts.openai import (
-    SINGLE_AGENT_SYSTEM_PROMPT,
-    MULTI_AGENT_SYSTEM_PROMPT,
-)
-
-
-def test_run_openai_agent_default():
-    mock_agent = MagicMock()
-
-    with (
-        patch("surf_spot_finder.agents.openai.Agent", mock_agent),
-        patch("surf_spot_finder.agents.openai.Runner", MagicMock()),
-    ):
-        run_openai_agent("gpt-4o", "Test prompt")
-        mock_agent.assert_called_once_with(
-            model="gpt-4o",
-            instructions=SINGLE_AGENT_SYSTEM_PROMPT,
-            name="surf-spot-finder",
-            tools=ANY,
-        )
-
-
-def test_run_openai_agent_base_url_and_api_key_var():
-    async_openai_mock = MagicMock()
-    openai_chat_completions_model = MagicMock()
-    with (
-        patch("surf_spot_finder.agents.openai.Agent", MagicMock()),
-        patch("surf_spot_finder.agents.openai.Runner", MagicMock()),
-        patch("surf_spot_finder.agents.openai.AsyncOpenAI", async_openai_mock),
-        patch(
-            "surf_spot_finder.agents.openai.OpenAIChatCompletionsModel",
-            openai_chat_completions_model,
-        ),
-        patch.dict(os.environ, {"TEST_API_KEY": "test-key-12345"}),
-    ):
-        run_openai_agent(
-            "gpt-4o", "Test prompt", api_base="FOO", api_key_var="TEST_API_KEY"
-        )
-        async_openai_mock.assert_called_once_with(
-            api_key="test-key-12345",
-            base_url="FOO",
-        )
-        openai_chat_completions_model.assert_called_once()
-
-
-def test_run_openai_environment_error():
-    with patch.dict(os.environ, {}, clear=True):
-        with pytest.raises(KeyError, match="MISSING_KEY"):
-            run_openai_agent(
-                "test-model", "Test prompt", api_base="FOO", api_key_var="MISSING_KEY"
-            )
-
-
-def test_run_openai_multiagent():
-    mock_agent = MagicMock()
-    mock_function_tool = MagicMock()
-
-    with (
-        patch("surf_spot_finder.agents.openai.Agent", mock_agent),
-        patch("surf_spot_finder.agents.openai.Runner", MagicMock()),
-        patch("surf_spot_finder.agents.openai.function_tool", mock_function_tool),
-    ):
-        run_openai_multi_agent("gpt-4o", "Test prompt")
-        mock_agent.assert_any_call(
-            model="gpt-4o",
-            instructions="Interact with the user by showing information and asking for verification.",
-            name="user-verification-agent",
-            tools=[
-                mock_function_tool(show_plan),
-                mock_function_tool(ask_user_verification),
-            ],
-        )
-
-        mock_agent.assert_any_call(
-            model="gpt-4o",
-            instructions="Find relevant information about the provided task by using your tools.",
-            name="search-web-agent",
-            tools=[mock_function_tool(search_web), mock_function_tool(visit_webpage)],
-        )
-
-        mock_agent.assert_any_call(
-            model="gpt-4o",
-            instructions="Communicate the final answer to the user.",
-            name="communication-agent",
-            tools=[mock_function_tool(show_final_answer)],
-        )
-
-        mock_agent.assert_any_call(
-            model="gpt-4o",
-            instructions=MULTI_AGENT_SYSTEM_PROMPT,
-            name="surf-spot-finder",
-            # TODO: add more elaborated checks
-            handoffs=ANY,
-            tools=ANY,
-        )

tests/unit/agents/test_unit_smolagents.py

@@ -1,71 +0,0 @@
-import os
-import pytest
-from unittest.mock import patch, MagicMock
-import contextlib
-
-from surf_spot_finder.agents.smolagents import run_smolagent
-
-
-@pytest.fixture
-def common_patches():
-    litellm_model_mock = MagicMock()
-    code_agent_mock = MagicMock()
-    patch_context = contextlib.ExitStack()
-    patch_context.enter_context(
-        patch("surf_spot_finder.agents.smolagents.CodeAgent", code_agent_mock)
-    )
-    patch_context.enter_context(
-        patch("surf_spot_finder.agents.smolagents.LiteLLMModel", litellm_model_mock)
-    )
-    yield patch_context, litellm_model_mock, code_agent_mock
-    patch_context.close()
-
-
-def test_run_smolagent_with_api_key_var(common_patches):
-    patch_context, litellm_model_mock, code_agent_mock = common_patches
-
-    with patch_context, patch.dict(os.environ, {"TEST_API_KEY": "test-key-12345"}):
-        run_smolagent("openai/gpt-4", "Test prompt", api_key_var="TEST_API_KEY")
-
-        litellm_model_mock.assert_called()
-        model_call_kwargs = litellm_model_mock.call_args[1]
-        assert model_call_kwargs["model_id"] == "openai/gpt-4"
-        assert model_call_kwargs["api_key"] == "test-key-12345"
-        assert model_call_kwargs["api_base"] is None
-
-        code_agent_mock.assert_called_once()
-        code_agent_mock.return_value.run.assert_called_once_with("Test prompt")
-
-
-def test_run_smolagent_with_custom_api_base(common_patches):
-    patch_context, litellm_model_mock, *_ = common_patches
-
-    with patch_context, patch.dict(os.environ, {"TEST_API_KEY": "test-key-12345"}):
-        run_smolagent(
-            "anthropic/claude-3-sonnet",
-            "Test prompt",
-            api_key_var="TEST_API_KEY",
-            api_base="https://custom-api.example.com",
-        )
-        last_call = litellm_model_mock.call_args_list[-1]
-
-        assert last_call[1]["model_id"] == "anthropic/claude-3-sonnet"
-        assert last_call[1]["api_key"] == "test-key-12345"
-        assert last_call[1]["api_base"] == "https://custom-api.example.com"
-
-
-def test_run_smolagent_without_api_key(common_patches):
-    patch_context, litellm_model_mock, *_ = common_patches
-
-    with patch_context:
-        run_smolagent("ollama_chat/deepseek-r1", "Test prompt")
-
-    last_call = litellm_model_mock.call_args_list[-1]
-    assert last_call[1]["model_id"] == "ollama_chat/deepseek-r1"
-    assert last_call[1]["api_key"] is None
-
-
-def test_run_smolagent_environment_error():
-    with patch.dict(os.environ, {}, clear=True):
-        with pytest.raises(KeyError, match="MISSING_KEY"):
-            run_smolagent("test-model", "Test prompt", api_key_var="MISSING_KEY")

tests/unit/test_unit_tracing.py

@@ -1,47 +0,0 @@
-from unittest.mock import patch, MagicMock
-
-import pytest
-
-from surf_spot_finder.agents import AgentType
-from surf_spot_finder.tracing import get_tracer_provider, setup_tracing
-
-
-@pytest.mark.parametrize("json_tracer", [True, False])
-def test_get_tracer_provider(tmp_path, json_tracer):
-    mock_tracer_provider = MagicMock()
-    mock_register = MagicMock()
-
-    with (
-        patch("surf_spot_finder.tracing.TracerProvider", mock_tracer_provider),
-        patch("phoenix.otel.register", mock_register),
-    ):
-        get_tracer_provider(
-            project_name="test_project",
-            json_tracer=json_tracer,
-            agent_type=AgentType.SMOLAGENTS,
-            output_dir=tmp_path / "telemetry",
-        )
-        assert (tmp_path / "telemetry").exists() == json_tracer
-        if not json_tracer:
-            mock_register.assert_called_once_with(
-                project_name="test_project", set_global_tracer_provider=True
-            )
-
-
-@pytest.mark.parametrize(
-    "agent_type,instrumentor",
-    [
-        ("openai", "openai_agents.OpenAIAgentsInstrumentor"),
-        ("openai_multi_agent", "openai_agents.OpenAIAgentsInstrumentor"),
-        ("smolagents", "smolagents.SmolagentsInstrumentor"),
-    ],
-)
-def test_setup_tracing(agent_type, instrumentor):
-    with patch(f"openinference.instrumentation.{instrumentor}") as mock_instrumentor:
-        setup_tracing(MagicMock(), agent_type)
-        mock_instrumentor.assert_called_once()
-
-
-def test_invalid_agent_type():
-    with pytest.raises(ValueError, match="agent_type must be one of"):
-        setup_tracing(MagicMock(), "invalid_agent_type")