Optional: Browser

def build_specialists(gateway: MCPClient, results: list[str]) -> list:
    """The data and weather specialists as tools; each searches the Gateway for its tools, then records its answer."""

    @tool
    def data_agent(query: str) -> str:
        """Query and analyze the DataStream Corp database (employees, departments, projects).

        Args:
            query: A database or data analysis question.
        """
        agent = Agent(
            model=make_model(),
            system_prompt=f"{DATA_PROMPT}\n{guardrail.prompt_hint()}",
            tools=search_tools(gateway, DATA_TOOLS),
            hooks=[ReadOnlyGuardHook(), *guardrail.hooks()],
            callback_handler=None,
        )
        return consult(agent, query, "data")

    @tool
    def weather_agent(query: str) -> str:
        """Get the weather forecast for a US location (National Weather Service); says so for non-US places.

        Args:
            query: A weather-related question, including the place.
        """
        agent = Agent(
            model=make_model(),
            system_prompt=nws_weather.WEATHER_PROMPT,
            hooks=guardrail.hooks(),
            tools=search_tools(gateway, WEATHER_TOOLS),
            callback_handler=None,
        )
        return consult(agent, query, "weather")

    @tool
    def research_agent(question: str) -> str:
        """Research public web pages (product pages, news, docs) and summarise them with their URL.

        Args:
            question: What to find out, including the URL if known.
        """
        from sandbox_tools import browse_web

        agent = Agent(
            model=make_model(),
            system_prompt="You research public web pages with browse_web. Cite the URL you used. Never guess content.",
            tools=[browse_web],
            hooks=guardrail.hooks(),
            callback_handler=None,
        )
        return consult(agent, question, "research")

    def consult(agent: Agent, query: str, specialist: str) -> str:
        """Ask a specialist; an exception (e.g. the gateway's 502 after its retries) becomes an explicit failure."""
        try:
            answer = str(agent(query))
        except Exception as error:
            answer = SPECIALIST_FAILED.format(specialist=specialist, reason=f"{type(error).__name__}: {error}")
        return remember(answer, specialist)

    def remember(answer: str, specialist: str = "requested") -> str:
        """Record a specialist's answer for `final_answer`; an empty one is recorded as an explicit failure."""
        answer = answer.strip() or SPECIALIST_FAILED.format(specialist=specialist, reason="it returned an empty answer")
        results.append(answer)
        return answer

    return [data_agent, weather_agent, research_agent]

def build_orchestrator(gateway: MCPClient, session_id: str, actor_id: str, specialist_results: list[str]) -> Agent:
    """The orchestrator with both specialists, any enabled sandbox tools and this actor's memory."""
    sandbox_tools = [t for t in optional_tools() if t.tool_name != "browse_web"]  # research_agent has it
    return Agent(
        name="Executive Assistant",
        model=make_model(),
        system_prompt=orchestrator_prompt(actor_id, sandbox_tools),
        hooks=guardrail.hooks(),
        tools=[*build_specialists(gateway, specialist_results), *sandbox_tools],
        session_manager=memory_session_manager(session_id, actor_id),
        callback_handler=None,
    )