Files
orchestration_engine/execution_engine/tools/toolkit.py

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