7 make tools configurable (#21)

* Make tools configurable via arguments.

- Make `mcp` optional, not used by default.
- Update examples to use `tools`.

* Update pyproject.tooml optional deps

* Make openai and smolagents imports lazy

* Update api.md with sections

* fix tests

* Add missing arize

.github/workflows/tests.yaml

@@ -28,7 +28,7 @@ jobs:
           cache: "pip"
 
       - name: Install
-        run: pip install -e '.[openai,tests]'
+        run: pip install -e '.[arize,smolagents,openai,tests]'
 
       - name: Run tests
         run: pytest -v tests

docs/api.md

@@ -4,17 +4,30 @@
 
 ::: surf_spot_finder.config.Config
 
+## Agents
+
 ::: surf_spot_finder.agents.RUNNERS
 
 ::: 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

examples/openai_single_agent.yaml

@@ -3,4 +3,7 @@ date: 2025-03-22 12:00
 max_driving_hours: 2
 model_id: o3-mini
 agent_type: openai
+tools:
+ - "surf_spot_finder.tools.search_web"
+ - "surf_spot_finder.tools.visit_webpage"
 # input_prompt_template:

examples/openai_single_agent_vertical.yaml

@@ -0,0 +1,15 @@
+location: Pontevedra
+date: 2025-03-22 12:00
+max_driving_hours: 2
+model_id: o3-mini
+agent_type: openai
+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.show_plan"
+ - "surf_spot_finder.tools.visit_webpage"
+# input_prompt_template:

examples/smolagents_single_agent.yaml

@@ -1,7 +1,7 @@
 location: Pontevedra
 date: 2025-03-22 12:00
 max_driving_hours: 2
-model_id: openai/gpt-3.5-turbo
+model_id: openai/o3-mini
 api_key_var: OPENAI_API_KEY
 agent_type: smolagents
 # input_prompt_template:

examples/smolagents_single_agent_mcp.yaml

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

mkdocs.yml

@@ -50,3 +50,4 @@ plugins:
       python:
         options:
           show_root_heading: true
+          heading_level: 3

pyproject.toml

@@ -9,20 +9,28 @@ license = {text = "Apache-2.0"}
 requires-python = ">=3.10"
 dynamic = ["version"]
 dependencies = [
-  "arize-phoenix>=8.12.1",
   "fire",
   "loguru",
-  "mcp==1.3.0",
+  "opentelemetry-exporter-otlp",
+  "opentelemetry-sdk",
   "pydantic",
-  "smolagents[litellm,mcp,telemetry]>=1.10.0",
 ]
 
 [project.optional-dependencies]
+smolagents = [
+  "smolagents[litellm]>=1.10.0",
+  "openinference-instrumentation-smolagents>=0.1.4"
+]
+
 openai = [
   "openai-agents",
   "openinference-instrumentation-openai"
 ]
 
+mcp = [
+  "mcp==1.3.0",
+]
+
 demo = [
   "gradio",
   "spaces"
@@ -41,7 +49,7 @@ tests = [
 ]
 
 # TODO maybe we don't want to keep this, or we want to swap this to Lumigator SDK
-tracing = [
+arize = [
   "arize-phoenix>=8.12.1",
 ]
 

src/surf_spot_finder/agents/openai.py

@@ -1,85 +1,27 @@
+import importlib
 import os
 from typing import Optional
 
-from agents import (
-    Agent,
-    AsyncOpenAI,
-    OpenAIChatCompletionsModel,
-    Runner,
-    RunResult,
-    function_tool,
-)
 from loguru import logger
-from smolagents import (
-    DuckDuckGoSearchTool,
-    VisitWebpageTool,
-    FinalAnswerTool,
-)
-
 
 from surf_spot_finder.prompts.openai import (
     SINGLE_AGENT_SYSTEM_PROMPT,
     MULTI_AGENT_SYSTEM_PROMPT,
 )
-from surf_spot_finder.tools.openmeteo import get_wave_forecast, get_wind_forecast
-from surf_spot_finder.tools.openstreetmap import (
-    driving_hours_to_meters,
-    get_area_lat_lon,
-    get_surfing_places,
-)
-
-driving_hours_to_meters = function_tool(driving_hours_to_meters)
-get_area_lat_lon = function_tool(get_area_lat_lon)
-get_surfing_places = function_tool(get_surfing_places)
-get_wave_forecast = function_tool(get_wave_forecast)
-get_wind_forecast = function_tool(get_wind_forecast)
-
-
-@function_tool
-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.
-    """
-    logger.debug(f"Calling search_web: {query}")
-    search_tool = DuckDuckGoSearchTool()
-    return search_tool.forward(query)
-
-
-@function_tool
-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.
-    """
-    logger.debug(f"Calling visit_webpage: {url}")
-    visit_tool = VisitWebpageTool()
-    return visit_tool.forward(url)
-
-
-@function_tool
-def final_answer(answer: str) -> str:
-    """Provides a final answer to the given problem.
-
-    Args:
-        answer: The answer to the problem.
-    """
-    logger.debug("Calling final_answer")
-    final_answer_tool = FinalAnswerTool()
-    return final_answer_tool.forward(answer)
-
 
-@function_tool
-def user_verification(query: str) -> str:
-    """Asks user to verify the given `query`.
+try:
+    from agents import (
+        Agent,
+        AsyncOpenAI,
+        OpenAIChatCompletionsModel,
+        Runner,
+        RunResult,
+        function_tool,
+    )
 
-    Args:
-        query: The question that requires verification.
-    """
-    logger.debug("Calling user_verification")
-    return input(f"{query} => Type your answer here:")
+    agents_available = True
+except ImportError:
+    agents_available = None
 
 
 @logger.catch(reraise=True)
@@ -89,7 +31,8 @@ def run_openai_agent(
     name: str = "surf-spot-finder",
     instructions: Optional[str] = SINGLE_AGENT_SYSTEM_PROMPT,
     api_key_var: Optional[str] = None,
-    base_url: Optional[str] = None,
+    api_base: Optional[str] = None,
+    tools: Optional[list[str]] = None,
 ) -> RunResult:
     """Runs an OpenAI agent with the given prompt and configuration.
 
@@ -109,19 +52,36 @@ def run_openai_agent(
         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.
-        base_url (Optional[str], optional): The base URL for the OpenAI API.
+        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 api_key_var and base_url:
+    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 = []
+    for tool in tools:
+        module, func = tool.rsplit(".", 1)
+        module = importlib.import_module(module)
+        tool = getattr(module, func)
+        imported_tools.append(function_tool(tool))
+
+    logger.info(f"Imported tools: {imported_tools}")
+    if api_key_var and api_base:
         external_client = AsyncOpenAI(
             api_key=os.environ[api_key_var],
-            base_url=base_url,
+            base_url=api_base,
         )
         agent = Agent(
             name=name,
@@ -130,22 +90,14 @@ def run_openai_agent(
                 model=model_id,
                 openai_client=external_client,
             ),
-            tools=[search_web, visit_webpage],
+            tools=imported_tools,
         )
     else:
         agent = Agent(
             model=model_id,
             instructions=instructions,
             name=name,
-            tools=[
-                search_web,
-                visit_webpage,
-                get_area_lat_lon,
-                get_surfing_places,
-                get_wave_forecast,
-                get_wind_forecast,
-                driving_hours_to_meters,
-            ],
+            tools=imported_tools,
         )
     result = Runner.run_sync(agent, prompt)
     logger.info(result.final_output)
@@ -158,6 +110,7 @@ def run_openai_multi_agent(
     prompt: str,
     name: str = "surf-spot-finder",
     instructions: Optional[str] = MULTI_AGENT_SYSTEM_PROMPT,
+    **kwargs,
 ) -> RunResult:
     """Runs multiple OpenAI agents orchestrated by a main agent.
 
@@ -179,25 +132,36 @@ def run_openai_multi_agent(
         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="Display the current output to the user, then ask for verification.",
+        instructions="Interact with the user by showing information and asking for verification.",
         name="user-verification-agent",
-        tools=[user_verification],
+        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 combining web searches with visiting webpages.",
+        instructions="Find relevant information about the provided task by using your tools.",
         name="search-web-agent",
-        tools=[search_web, visit_webpage],
+        tools=[function_tool(search_web), function_tool(visit_webpage)],
     )
 
     communication_agent = Agent(
         model=model_id,
-        instructions=None,
+        instructions="Communicate the final answer to the user.",
         name="communication-agent",
-        tools=[final_answer],
+        tools=[function_tool(show_final_answer)],
     )
 
     main_agent = Agent(

src/surf_spot_finder/agents/smolagents.py

@@ -1,17 +1,22 @@
+import importlib
 import os
 from typing import Optional
 
 from loguru import logger
 
-from smolagents import (
-    CodeAgent,
-    DuckDuckGoSearchTool,
-    LiteLLMModel,
-    ToolCollection,
-)
-from mcp import StdioServerParameters
 from surf_spot_finder.prompts.smolagents import SYSTEM_PROMPT
 
+try:
+    from smolagents import (
+        CodeAgent,
+        LiteLLMModel,
+        ToolCollection,
+    )
+
+    smolagents_available = True
+except ImportError:
+    smolagents_available = None
+
 
 @logger.catch(reraise=True)
 def run_smolagent(
@@ -19,6 +24,7 @@ def run_smolagent(
     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.
@@ -39,6 +45,26 @@ def run_smolagent(
         >>> 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",
+        ]
+
+    imported_tools = []
+    mcp_tool = None
+    for tool in tools:
+        if "mcp" in tool:
+            mcp_tool = tool
+        else:
+            module, func = tool.rsplit(".", 1)
+            module = importlib.import_module(module)
+            tool = getattr(module, func)
+            imported_tools.append(tool())
 
     model = LiteLLMModel(
         model_id=model_id,
@@ -46,24 +72,31 @@ def run_smolagent(
         api_key=os.environ[api_key_var] if api_key_var else None,
     )
 
-    # 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/fetch"],
-        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:
+    if mcp_tool:
+        from mcp import StdioServerParameters
+
+        # 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=[
-                *tool_collection.tools,
-                DuckDuckGoSearchTool(),
-            ],
+            tools=imported_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)
 

src/surf_spot_finder/cli.py

@@ -24,6 +24,7 @@ def find_surf_spot(
     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,
 ):
     """Find the best surf spot based on the given criteria.
@@ -82,6 +83,9 @@ def find_surf_spot(
             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,
     )
 
 

src/surf_spot_finder/config.py

@@ -30,3 +30,4 @@ class Config(BaseModel):
     api_key_var: Optional[str] = None
     json_tracer: bool = True
     api_base: Optional[str] = None
+    tools: Optional[list[str]] = None

src/surf_spot_finder/tools/__init__.py

@@ -0,0 +1,17 @@
+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,
+]

src/surf_spot_finder/tools/openstreetmap.py

@@ -59,10 +59,10 @@ def get_lat_lon_center(bounds: dict) -> tuple[float, float]:
     )
 
 
-def get_surfing_places(
+def get_surfing_spots(
     lat: float, lon: float, radius: int
 ) -> list[tuple[str, tuple[float, float]]]:
-    """Get surfing places around a given latitude and longitude.
+    """Get surfing spots around a given latitude and longitude.
 
     Uses the [Overpass API](https://wiki.openstreetmap.org/wiki/Overpass_API).
 

src/surf_spot_finder/tools/user_interaction.py

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,54 @@
+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/tracing.py

@@ -6,7 +6,6 @@ from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import SimpleSpanProcessor
 from opentelemetry.sdk.trace.export import SpanExporter
-from phoenix.otel import register
 
 
 class JsonFileSpanExporter(SpanExporter):
@@ -74,6 +73,8 @@ def get_tracer_provider(
         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
         )

tests/unit/agents/test_unit_openai.py

@@ -3,11 +3,14 @@ import pytest
 from unittest.mock import patch, MagicMock, ANY
 
 from surf_spot_finder.agents.openai import (
-    final_answer,
     run_openai_agent,
     run_openai_multi_agent,
+)
+from surf_spot_finder.tools import (
+    show_final_answer,
+    show_plan,
+    ask_user_verification,
     search_web,
-    user_verification,
     visit_webpage,
 )
 from surf_spot_finder.prompts.openai import (
@@ -46,7 +49,7 @@ def test_run_openai_agent_base_url_and_api_key_var():
         patch.dict(os.environ, {"TEST_API_KEY": "test-key-12345"}),
     ):
         run_openai_agent(
-            "gpt-4o", "Test prompt", base_url="FOO", api_key_var="TEST_API_KEY"
+            "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",
@@ -59,37 +62,42 @@ 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", base_url="FOO", api_key_var="MISSING_KEY"
+                "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="Display the current output to the user, then ask for verification.",
+            instructions="Interact with the user by showing information and asking for verification.",
             name="user-verification-agent",
-            tools=[user_verification],
+            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 combining web searches with visiting webpages.",
+            instructions="Find relevant information about the provided task by using your tools.",
             name="search-web-agent",
-            tools=[search_web, visit_webpage],
+            tools=[mock_function_tool(search_web), mock_function_tool(visit_webpage)],
         )
 
         mock_agent.assert_any_call(
             model="gpt-4o",
-            instructions=None,
+            instructions="Communicate the final answer to the user.",
             name="communication-agent",
-            tools=[final_answer],
+            tools=[mock_function_tool(show_final_answer)],
         )
 
         mock_agent.assert_any_call(

tests/unit/agents/test_unit_smolagents.py

@@ -11,31 +11,18 @@ def common_patches():
     litellm_model_mock = MagicMock()
     code_agent_mock = MagicMock()
     patch_context = contextlib.ExitStack()
-    mock_tool_collection = MagicMock()
-
-    mock_tool_collection.from_mcp.return_value.__enter__.return_value = (
-        mock_tool_collection
-    )
-    mock_tool_collection.from_mcp.return_value.__exit__.return_value = None
-    mock_tool_collection.tools = ["mock_tool"]
-    patch_context.enter_context(
-        patch("surf_spot_finder.agents.smolagents.StdioServerParameters", MagicMock())
-    )
     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)
     )
-    patch_context.enter_context(
-        patch("surf_spot_finder.agents.smolagents.ToolCollection", mock_tool_collection)
-    )
-    yield patch_context, litellm_model_mock, code_agent_mock, mock_tool_collection
+    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
+    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")

tests/unit/test_unit_tracing.py

@@ -14,7 +14,7 @@ def test_get_tracer_provider(tmp_path, json_tracer):
     with (
         patch("surf_spot_finder.tracing.trace", mock_trace),
         patch("surf_spot_finder.tracing.TracerProvider", mock_tracer_provider),
-        patch("surf_spot_finder.tracing.register", mock_register),
+        patch("phoenix.otel.register", mock_register),
     ):
         get_tracer_provider(
             project_name="test_project",

tests/unit/tools/test_unit_openstreetmap.py

@@ -29,7 +29,7 @@ def test_get_lat_lon_center():
     assert lon == -2.5
 
 
-def test_get_surfing_places():
+def test_get_surfing_spots():
     with patch("requests.get") as mock_get:
         mock_response = MagicMock()
         mock_response.status_code = 200
@@ -66,7 +66,7 @@ def test_get_surfing_places():
         }
         mock_get.return_value = mock_response
 
-        results = openstreetmap.get_surfing_places(lat=40.5, lon=-3.5, radius=10000)
+        results = openstreetmap.get_surfing_spots(lat=40.5, lon=-3.5, radius=10000)
         assert len(results) == 2
         assert results[0][0] == "Surf Spot 1"
         assert results[0][1] == (40.05, -2.95)