Solution architecture outcome pattern: agent and its MCP servers
Some checks failed
check agents / check (push) Failing after 13s

The cp1-solution-architecture-agent and the sa-aws/azure/gcp-cloud MCP servers, a separate
stream from the individual and sub-agent patterns.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-05 22:13:25 +00:00
parent 8bb62a4a42
commit bc84ee4df6
267 changed files with 44287 additions and 45 deletions

View File

@@ -0,0 +1,95 @@
"""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, for the design advisor, the pillar consultation.
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 app.engine.roles import PILLAR_ADVISOR
from app.engine.runtime import (
AgentRuntime,
Decider,
RoleSpec,
RunLimiter,
ToolFactory,
ToolSpec,
)
from app.engine.guardrail import guard_all
from app.mcp_tools import McpCatalog
from app.engine.pillars import pillar_consultation_tool
from app.engine.working_copy import working_files
from app.core.deliverables import DEPENDENCY_GRAPH, DeliverableKind
# 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(
runtime: AgentRuntime,
roles: Mapping[str, RoleSpec],
pillar_skills: Mapping[str, str],
*,
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)
advisor = roles.get(PILLAR_ADVISOR)
# Pillar advisors can't ask for permission, so they get general-tier tools only.
advisor_tools = (
[tool for tool in mcp_tools(advisor) if tool.tier == "general"]
if advisor
else []
)
def tools_for(
role: RoleSpec, deliverable: str | None, working: MutableMapping[str, Any]
) -> Sequence[ToolSpec]:
has_working_copy = any(
kind.value == deliverable and spec.working_copy is not None
for kind, spec in DEPENDENCY_GRAPH.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 (
pillar_skills
and advisor
and deliverable == DeliverableKind.DESIGN_RECOMMENDATIONS.value
):
tools.append(
pillar_consultation_tool(
runtime,
advisor,
pillar_skills,
extra_tools=advisor_tools,
memory=working,
limiter=limiter,
)
)
return tools
return tools_for