agentpanel 0.1.0__tar.gz

agentpanel-0.1.0/.gitignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+venv/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# secrets: never commit real keys
+.env
+
+# generated harnesses
+shakedown-output/
+
+.idea/
+.vscode/
+.DS_Store

agentpanel-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anzar Ahsan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentpanel-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.5
+Name: agentpanel
+Version: 0.1.0
+Summary: Domain-agnostic multi-agent orchestration core (LangGraph) with pluggable local/cloud LLM providers.
+Project-URL: Homepage, https://github.com/anzar-ahsan-commits/api-shakedown/tree/main/packages/agentpanel
+Project-URL: Source, https://github.com/anzar-ahsan-commits/api-shakedown
+Project-URL: Issues, https://github.com/anzar-ahsan-commits/api-shakedown/issues
+Author: Anzar Ahsan
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,langgraph,llm,multi-agent,ollama,structured-output
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: langchain-core>=1.0
+Requires-Dist: langchain-ollama>=1.0
+Requires-Dist: langgraph>=1.0
+Requires-Dist: pydantic-settings>=2.4
+Requires-Dist: pydantic>=2.7
+Provides-Extra: anthropic
+Requires-Dist: langchain-anthropic>=1.0; extra == 'anthropic'
+Provides-Extra: cloud
+Requires-Dist: langchain-anthropic>=1.0; extra == 'cloud'
+Requires-Dist: langchain-openai>=1.0; extra == 'cloud'
+Provides-Extra: openai
+Requires-Dist: langchain-openai>=1.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# agentpanel
+
+A small, domain-agnostic core for multi-agent LLM workflows on
+[LangGraph](https://github.com/langchain-ai/langgraph):
+
+- **Specialists** produce artifacts in parallel.
+- **Reviewers** judge each other's artifacts; rejections send the author back to revise,
+  with the feedback, for a bounded number of rounds.
+- A **coordinator** assembles the result, including anything still unresolved.
+
+It runs on local models by default ([Ollama](https://ollama.com)), with bring-your-own-key
+OpenAI and Anthropic support, and gets reliable structured output from small models.
+
+```bash
+pip install agentpanel            # Ollama only
+pip install "agentpanel[cloud]"   # plus OpenAI and Anthropic
+```
+
+## Example
+
+```python
+import asyncio
+from agentpanel import AgentContext, LLMReviewer, LLMSpecialist, Workflow
+from agentpanel.config import LLMSettings
+from agentpanel.llm import create_chat_model
+
+model = create_chat_model(LLMSettings())  # qwen3:8b on local Ollama by default
+
+
+class Join:
+    async def assemble(self, ctx: AgentContext) -> str:
+        return ctx.artifacts["writer"].content
+
+
+workflow = Workflow(
+    specialists=[
+        LLMSpecialist(
+            name="writer",
+            kind="product description",
+            model=model,
+            instructions="You write concise product descriptions.",
+            render=lambda ctx: f"Describe {ctx.inputs['product']} in two sentences.",
+        )
+    ],
+    reviewers=[LLMReviewer("editor", model, "You edit marketing copy for accuracy.")],
+    coordinator=Join(),
+    max_revisions=1,
+)
+result = asyncio.run(workflow.run({"product": "a solar-powered kettle"}))
+print(result.result, result.unresolved)
+```
+
+## Pieces
+
+| Module | What it gives you |
+|---|---|
+| `agentpanel.graph` | `Workflow`: parallel specialists, cross-review, bounded revision, progress callbacks |
+| `agentpanel.agents` | `Specialist`, `Reviewer`, `Coordinator` protocols: bring any implementation |
+| `agentpanel.llm_agents` | `LLMSpecialist`, `LLMReviewer`: prompt-driven agents with revision handling |
+| `agentpanel.structured` | `ainvoke_structured`: pydantic-validated output with error feedback and domain `check`s; constrained decoding on Ollama |
+| `agentpanel.llm` | `create_chat_model`, `check_provider`: provider factory and health checks |
+| `agentpanel.config` | `LLMSettings`: env/.env settings, per-agent model and reasoning overrides |
+| `agentpanel.testing` | `ScriptedChatModel`: a deterministic fake chat model for tests |
+
+## Configuration
+
+`LLMSettings` reads `AGENTPANEL_*` environment variables (subclass it to use your own
+prefix): `PROVIDER` (`ollama`, `openai`, `anthropic`), `MODEL`, `BASE_URL`, `TIMEOUT`,
+`REASONING`, `CONTEXT_WINDOW`, `AGENT_MODELS`, `AGENT_REASONING`. Cloud keys use the
+standard `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`.
+
+Built for and used by [API Shakedown](https://github.com/anzar-ahsan-commits/api-shakedown), where the
+source lives. Issues and contributions: see that repository.
+
+## License
+
+MIT

agentpanel-0.1.0/README.md

@@ -0,0 +1,77 @@
+# agentpanel
+
+A small, domain-agnostic core for multi-agent LLM workflows on
+[LangGraph](https://github.com/langchain-ai/langgraph):
+
+- **Specialists** produce artifacts in parallel.
+- **Reviewers** judge each other's artifacts; rejections send the author back to revise,
+  with the feedback, for a bounded number of rounds.
+- A **coordinator** assembles the result, including anything still unresolved.
+
+It runs on local models by default ([Ollama](https://ollama.com)), with bring-your-own-key
+OpenAI and Anthropic support, and gets reliable structured output from small models.
+
+```bash
+pip install agentpanel            # Ollama only
+pip install "agentpanel[cloud]"   # plus OpenAI and Anthropic
+```
+
+## Example
+
+```python
+import asyncio
+from agentpanel import AgentContext, LLMReviewer, LLMSpecialist, Workflow
+from agentpanel.config import LLMSettings
+from agentpanel.llm import create_chat_model
+
+model = create_chat_model(LLMSettings())  # qwen3:8b on local Ollama by default
+
+
+class Join:
+    async def assemble(self, ctx: AgentContext) -> str:
+        return ctx.artifacts["writer"].content
+
+
+workflow = Workflow(
+    specialists=[
+        LLMSpecialist(
+            name="writer",
+            kind="product description",
+            model=model,
+            instructions="You write concise product descriptions.",
+            render=lambda ctx: f"Describe {ctx.inputs['product']} in two sentences.",
+        )
+    ],
+    reviewers=[LLMReviewer("editor", model, "You edit marketing copy for accuracy.")],
+    coordinator=Join(),
+    max_revisions=1,
+)
+result = asyncio.run(workflow.run({"product": "a solar-powered kettle"}))
+print(result.result, result.unresolved)
+```
+
+## Pieces
+
+| Module | What it gives you |
+|---|---|
+| `agentpanel.graph` | `Workflow`: parallel specialists, cross-review, bounded revision, progress callbacks |
+| `agentpanel.agents` | `Specialist`, `Reviewer`, `Coordinator` protocols: bring any implementation |
+| `agentpanel.llm_agents` | `LLMSpecialist`, `LLMReviewer`: prompt-driven agents with revision handling |
+| `agentpanel.structured` | `ainvoke_structured`: pydantic-validated output with error feedback and domain `check`s; constrained decoding on Ollama |
+| `agentpanel.llm` | `create_chat_model`, `check_provider`: provider factory and health checks |
+| `agentpanel.config` | `LLMSettings`: env/.env settings, per-agent model and reasoning overrides |
+| `agentpanel.testing` | `ScriptedChatModel`: a deterministic fake chat model for tests |
+
+## Configuration
+
+`LLMSettings` reads `AGENTPANEL_*` environment variables (subclass it to use your own
+prefix): `PROVIDER` (`ollama`, `openai`, `anthropic`), `MODEL`, `BASE_URL`, `TIMEOUT`,
+`REASONING`, `CONTEXT_WINDOW`, `AGENT_MODELS`, `AGENT_REASONING`. Cloud keys use the
+standard `OPENAI_API_KEY` / `ANTHROPIC_API_KEY`.
+
+Built for and used by [API Shakedown](https://github.com/anzar-ahsan-commits/api-shakedown), where the
+source lives. Issues and contributions: see that repository.
+
+## License
+
+MIT

agentpanel-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agentpanel"
+dynamic = ["version"]
+description = "Domain-agnostic multi-agent orchestration core (LangGraph) with pluggable local/cloud LLM providers."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Anzar Ahsan" }]
+keywords = ["llm", "agents", "multi-agent", "langgraph", "ollama", "structured-output"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = [
+    "langgraph>=1.0",
+    "langchain-core>=1.0",
+    "langchain-ollama>=1.0",   # Ollama is the default provider, so it is not optional
+    "pydantic>=2.7",
+    "pydantic-settings>=2.4",
+    "httpx>=0.27",
+]
+
+[project.urls]
+Homepage = "https://github.com/anzar-ahsan-commits/api-shakedown/tree/main/packages/agentpanel"
+Source = "https://github.com/anzar-ahsan-commits/api-shakedown"
+Issues = "https://github.com/anzar-ahsan-commits/api-shakedown/issues"
+
+[project.optional-dependencies]
+openai = ["langchain-openai>=1.0"]
+anthropic = ["langchain-anthropic>=1.0"]
+cloud = ["agentpanel[openai,anthropic]"]
+
+[tool.hatch.version]
+path = "src/agentpanel/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agentpanel"]

agentpanel-0.1.0/src/agentpanel/__init__.py

@@ -0,0 +1,22 @@
+"""Domain-agnostic multi-agent orchestration core."""
+
+from agentpanel.agents import Coordinator, Reviewer, Specialist
+from agentpanel.graph import Workflow, WorkflowResult
+from agentpanel.llm_agents import LLMReviewer, LLMSpecialist
+from agentpanel.state import AgentContext, Artifact, Review, Verdict
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AgentContext",
+    "Artifact",
+    "Coordinator",
+    "LLMReviewer",
+    "LLMSpecialist",
+    "Review",
+    "Reviewer",
+    "Specialist",
+    "Verdict",
+    "Workflow",
+    "WorkflowResult",
+]

agentpanel-0.1.0/src/agentpanel/agents.py

@@ -0,0 +1,38 @@
+"""Agent contracts: specialists, reviewers, and coordinators.
+
+Agents return plain values; the workflow stamps authorship and round numbers.
+One object may implement several roles, e.g. a specialist that also peer-reviews.
+"""
+
+from typing import Any, Protocol
+
+from agentpanel.state import AgentContext, Artifact, Verdict
+
+
+class Specialist(Protocol):
+    """Produces one artifact per round. On revision rounds, `ctx.feedback_for(self.name)`
+    holds the rejections to address and `ctx.artifacts[self.name]` the previous attempt."""
+
+    @property
+    def name(self) -> str: ...
+
+    @property
+    def kind(self) -> str: ...
+
+    async def produce(self, ctx: AgentContext) -> Any: ...
+
+
+class Reviewer(Protocol):
+    """Judges another agent's artifact. Never asked to review its own."""
+
+    @property
+    def name(self) -> str: ...
+
+    async def review(self, artifact: Artifact, ctx: AgentContext) -> Verdict: ...
+
+
+class Coordinator(Protocol):
+    """Assembles the final result once reviews are settled. `ctx.unresolved` lists
+    artifacts that still had rejections when the revision budget ran out."""
+
+    async def assemble(self, ctx: AgentContext) -> Any: ...

agentpanel-0.1.0/src/agentpanel/config.py

@@ -0,0 +1,126 @@
+"""Settings loaded from environment variables and an optional `.env` file.
+
+Applications subclass `LLMSettings` to use their own env prefix, e.g.::
+
+    class MyAppSettings(LLMSettings):
+        model_config = SettingsConfigDict(env_prefix="MY_APP_")
+"""
+
+from typing import Literal, Self, get_args
+
+from pydantic import Field, SecretStr
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+Provider = Literal["ollama", "openai", "anthropic"]
+
+DEFAULT_MODELS: dict[Provider, str] = {
+    "ollama": "qwen3:8b",
+    "openai": "gpt-5-mini",
+    "anthropic": "claude-sonnet-5-5",
+}
+DEFAULT_OLLAMA_URL = "http://localhost:11434"
+
+# Cloud keys use each vendor's standard variable name, not the app prefix,
+# so keys users already have in their environment just work.
+API_KEY_ENV_VARS: dict[Provider, str] = {
+    "openai": "OPENAI_API_KEY",
+    "anthropic": "ANTHROPIC_API_KEY",
+}
+
+
+class LLMSettings(BaseSettings):
+    """Which LLM to talk to and how."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="AGENTPANEL_",
+        env_file=".env",
+        extra="ignore",
+        populate_by_name=True,
+    )
+
+    provider: Provider = "ollama"
+    model: str | None = Field(default=None, description="Defaults per provider if unset.")
+    base_url: str | None = Field(
+        default=None,
+        description="Endpoint override for the selected provider, e.g. an "
+        "OpenAI-compatible server. Wins over ollama_url.",
+    )
+    ollama_url: str = Field(
+        default=DEFAULT_OLLAMA_URL,
+        description="Where Ollama runs. Only used when the provider is ollama, so it is "
+        "safe to set globally (e.g. in a container).",
+    )
+    temperature: float | None = Field(
+        default=None, description="Unset means the provider's default."
+    )
+    timeout: float | None = Field(
+        default=None,
+        description="Per-request timeout in seconds. Unset: 600 for Ollama (local models are "
+        "slow and serve one request at a time), 120 for cloud providers.",
+    )
+    context_window: int = Field(
+        default=16_384,
+        description="Ollama only: tokens of context. Ollama's own default is small and "
+        "silently truncates long prompts.",
+    )
+
+    reasoning: bool | None = Field(
+        default=None,
+        description="Ollama only: True/False turns a reasoning model's thinking on/off; "
+        "unset uses the model's default. Off is much faster for structured generation.",
+    )
+
+    agent_models: dict[str, str] = Field(
+        default_factory=dict,
+        description='Per-agent overrides as JSON, e.g. {"reviewer": "anthropic:claude-sonnet-5-5"} '
+        'or {"stubs": "qwen3:14b"}. A known provider prefix switches provider.',
+    )
+    agent_reasoning: dict[str, bool] = Field(
+        default_factory=dict,
+        description='Per-agent `reasoning` overrides as JSON, e.g. {"reviewer": true}.',
+    )
+
+    openai_api_key: SecretStr | None = Field(default=None, validation_alias="OPENAI_API_KEY")
+    anthropic_api_key: SecretStr | None = Field(default=None, validation_alias="ANTHROPIC_API_KEY")
+
+    def for_agent(self, name: str) -> Self:
+        """Settings for one agent, applying any `agent_models` / `agent_reasoning` override."""
+        update: dict[str, object] = {}
+        if name in self.agent_reasoning:
+            update["reasoning"] = self.agent_reasoning[name]
+        spec = self.agent_models.get(name)
+        if spec is not None:
+            provider, sep, model = spec.partition(":")
+            if sep and provider in get_args(Provider):
+                update["model"] = model
+                if provider != self.provider:
+                    # base_url belongs to the original provider; don't leak it to another one
+                    update |= {"provider": provider, "base_url": None}
+            else:
+                update["model"] = spec
+        return self.model_copy(update=update) if update else self
+
+    @property
+    def resolved_model(self) -> str:
+        return self.model or DEFAULT_MODELS[self.provider]
+
+    @property
+    def resolved_timeout(self) -> float:
+        if self.timeout is not None:
+            return self.timeout
+        return 600.0 if self.provider == "ollama" else 120.0
+
+    @property
+    def resolved_base_url(self) -> str | None:
+        if self.base_url:
+            return self.base_url.rstrip("/")
+        return self.ollama_url.rstrip("/") if self.provider == "ollama" else None
+
+    @property
+    def api_key(self) -> SecretStr | None:
+        """The key for the selected provider (None for Ollama)."""
+        if self.provider == "openai":
+            return self.openai_api_key
+        if self.provider == "anthropic":
+            return self.anthropic_api_key
+        return None

agentpanel-0.1.0/src/agentpanel/graph.py

@@ -0,0 +1,180 @@
+"""Builds the LangGraph workflow: parallel specialists, cross-review, bounded revision
+rounds, then coordinator assembly.
+
+    START -> specialists (parallel) -> gather -> review (one task per reviewer x artifact)
+          -> decide -> [rejected specialists revise | coordinator] -> END
+"""
+
+import re
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, Protocol, TypedDict, cast
+
+from langchain_core.runnables import RunnableConfig
+from langgraph.graph import END, START, StateGraph
+from langgraph.types import Send
+
+from agentpanel.agents import Coordinator, Reviewer, Specialist
+from agentpanel.state import AgentContext, Artifact, Review, WorkflowState
+
+RESERVED_NAMES = frozenset({"gather", "review", "decide", "coordinator"})
+_NAME_PATTERN = re.compile(r"^[a-z][a-z0-9_]*$")
+_STEPS_PER_ROUND = 4  # specialists, gather, review, decide
+
+UpdateCallback = Callable[[str, dict[str, Any]], None]
+
+
+class _Node(Protocol):
+    async def __call__(self, state: WorkflowState) -> dict[str, Any]: ...
+
+
+class _ReviewTask(TypedDict):
+    reviewer: str
+    target: str
+    context: AgentContext
+
+
+@dataclass(frozen=True)
+class WorkflowResult:
+    result: Any
+    artifacts: dict[str, Artifact]
+    reviews: list[Review]
+    rounds: int  # revision rounds used
+    unresolved: list[str]
+
+
+class Workflow:
+    def __init__(
+        self,
+        *,
+        specialists: Sequence[Specialist],
+        coordinator: Coordinator,
+        reviewers: Sequence[Reviewer] = (),
+        max_revisions: int = 1,
+    ) -> None:
+        if not specialists:
+            raise ValueError("A workflow needs at least one specialist.")
+        if max_revisions < 0:
+            raise ValueError("max_revisions must be >= 0.")
+        _validate_names([s.name for s in specialists], "specialist")
+        _validate_names([r.name for r in reviewers], "reviewer")
+
+        self._specialists = {s.name: s for s in specialists}
+        self._reviewers = {r.name: r for r in reviewers}
+        self._coordinator = coordinator
+        self.max_revisions = max_revisions
+        self.graph = self._build().compile()
+
+    async def run(
+        self, inputs: Mapping[str, Any], on_update: UpdateCallback | None = None
+    ) -> WorkflowResult:
+        """Run to completion. `on_update(node, update)` is called as each node finishes,
+        e.g. ("stubs", {"artifacts": ...}) or ("review", {"reviews": [Review]})."""
+        initial: WorkflowState = {
+            "inputs": dict(inputs),
+            "artifacts": {},
+            "reviews": [],
+            "round": 0,
+            "revise": [],
+            "result": None,
+        }
+        config: RunnableConfig = {
+            "recursion_limit": _STEPS_PER_ROUND * (self.max_revisions + 1) + 5
+        }
+        final: Any = None
+        async for mode, chunk in self.graph.astream(
+            initial, config, stream_mode=["updates", "values"]
+        ):
+            if mode == "values":
+                final = chunk
+            elif on_update is not None:
+                for node, update in cast(dict[str, Any], chunk).items():
+                    on_update(node, update or {})
+        final = cast(WorkflowState, final)
+        return WorkflowResult(
+            result=final["result"],
+            artifacts=final["artifacts"],
+            reviews=final["reviews"],
+            rounds=final["round"],
+            unresolved=AgentContext.from_state(final).unresolved,
+        )
+
+    def _build(self) -> StateGraph[WorkflowState]:
+        graph = StateGraph(WorkflowState)
+        for name, specialist in self._specialists.items():
+            graph.add_node(name, self._specialist_node(specialist))
+            graph.add_edge(START, name)
+            graph.add_edge(name, "gather")
+        graph.add_node("gather", _noop)
+        graph.add_node("review", self._review, input_schema=_ReviewTask)
+        graph.add_node("decide", self._decide)
+        graph.add_node("coordinator", self._assemble)
+
+        graph.add_conditional_edges("gather", self._route_reviews, ["review", "decide"])
+        graph.add_edge("review", "decide")
+        graph.add_conditional_edges(
+            "decide", _route_after_decide, [*self._specialists, "coordinator"]
+        )
+        graph.add_edge("coordinator", END)
+        return graph
+
+    def _specialist_node(self, specialist: Specialist) -> _Node:
+        async def node(state: WorkflowState) -> dict[str, Any]:
+            content = await specialist.produce(AgentContext.from_state(state))
+            artifact = Artifact(
+                author=specialist.name, kind=specialist.kind, content=content, round=state["round"]
+            )
+            return {"artifacts": {specialist.name: artifact}}
+
+        return node
+
+    def _route_reviews(self, state: WorkflowState) -> list[Send] | str:
+        context = AgentContext.from_state(state)
+        fresh = [a for a in state["artifacts"].values() if a.round == state["round"]]
+        tasks = [
+            Send("review", _ReviewTask(reviewer=name, target=artifact.author, context=context))
+            for artifact in fresh
+            for name in self._reviewers
+            if name != artifact.author
+        ]
+        return tasks or "decide"
+
+    async def _review(self, state: _ReviewTask) -> dict[str, Any]:
+        artifact = state["context"].artifacts[state["target"]]
+        verdict = await self._reviewers[state["reviewer"]].review(artifact, state["context"])
+        review = Review(
+            reviewer=state["reviewer"],
+            target=artifact.author,
+            round=artifact.round,
+            approved=verdict.approved,
+            comments=verdict.comments,
+        )
+        return {"reviews": [review]}
+
+    async def _decide(self, state: WorkflowState) -> dict[str, Any]:
+        rejected = AgentContext.from_state(state).unresolved
+        if rejected and state["round"] < self.max_revisions:
+            return {"round": state["round"] + 1, "revise": rejected}
+        return {"revise": []}
+
+    async def _assemble(self, state: WorkflowState) -> dict[str, Any]:
+        return {"result": await self._coordinator.assemble(AgentContext.from_state(state))}
+
+
+async def _noop(state: WorkflowState) -> dict[str, Any]:
+    return {}
+
+
+def _route_after_decide(state: WorkflowState) -> list[str] | str:
+    return state["revise"] or "coordinator"
+
+
+def _validate_names(names: list[str], role: str) -> None:
+    for name in names:
+        if not _NAME_PATTERN.match(name):
+            raise ValueError(f"Invalid {role} name {name!r}: use lowercase letters, digits, _.")
+        if name in RESERVED_NAMES:
+            raise ValueError(f"{role.capitalize()} name {name!r} is reserved.")
+    duplicates = sorted({n for n in names if names.count(n) > 1})
+    if duplicates:
+        raise ValueError(f"Duplicate {role} names: {duplicates}")