83 lines
2.9 KiB
Python
83 lines
2.9 KiB
Python
"""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
|