"""Which tools each role gets beyond the Execution tools. A role gets the local tools its role file names, the tools of the remote MCP servers the provider bundle assigns it, and whatever its Workflow adds for the Deliverable it is working on. When the Deliverable has a working copy, the local tools are built on it. Cloud-read gating is applied later, per Execution, by `specialist_tools`. """ from __future__ import annotations from collections.abc import Callable, Mapping, MutableMapping, Sequence from typing import Any from execution_engine.adk.runtime import ( AgentRuntime, Decider, RoleSpec, RunLimiter, ToolFactory, ToolSpec, ) from execution_engine.tools.guardrail import guard_all from execution_engine.tools.mcp import McpCatalog from execution_engine.tools.workspace import working_files from execution_engine.workflows.workflow import RoleTools, Workflow # The local tools, built on a working copy of files when the Deliverable has one. LocalToolBuilder = Callable[[MutableMapping[str, str] | None], Sequence[ToolSpec]] def make_tool_factory( workflow: Workflow, runtime: AgentRuntime, roles: Mapping[str, RoleSpec], *, local_tools: Sequence[ToolSpec] | LocalToolBuilder = (), catalog: McpCatalog | None = None, limiter: RunLimiter | None = None, guard: Decider | None = None, withhold_at: float = 0.75, ) -> ToolFactory: def build_local( working_copy: MutableMapping[str, str] | None, ) -> Sequence[ToolSpec]: return local_tools(working_copy) if callable(local_tools) else local_tools def mcp_tools(role: RoleSpec) -> list[ToolSpec]: # A remote server's reply is text nobody here wrote: it is checked for # instructions addressed to the agent before a Specialist reads it. tools = catalog.tools_for(role.mcp_servers) if catalog else [] return guard_all(tools, guard, withhold_at) def tools_for( role: RoleSpec, deliverable: str | None, working: MutableMapping[str, Any] ) -> Sequence[ToolSpec]: has_working_copy = any( kind == deliverable and spec.working_copy is not None for kind, spec in workflow.deliverables.items() ) local_by_name = { tool.name: tool for tool in build_local( working_files(working) if has_working_copy else None ) } tools = [local_by_name[name] for name in role.tools if name in local_by_name] tools += mcp_tools(role) if workflow.role_tools: tools += workflow.role_tools( RoleTools( runtime=runtime, roles=roles, role=role, deliverable=deliverable, working=working, limiter=limiter, mcp_tools=mcp_tools, ) ) return tools return tools_for