pyagent-patterns 0.1.0__tar.gz → 0.2.0__tar.gz

pyagent_patterns-0.2.0/.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+*.whl
+
+# uv
+.uv/
+.venv/
+uv.lock
+
+# Environments
+.env
+.envrc
+*.env
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Type checking
+.mypy_cache/
+.dmypy.json
+
+# Docs
+site/
+.mkdocs_temp/
+
+# Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/PKG-INFO

@@ -1,7 +1,13 @@
 Metadata-Version: 2.4
 Name: pyagent-patterns
-Version: 0.1.0
+Version: 0.2.0
 Summary: 18 reusable multi-agent orchestration patterns for LLMs
+Project-URL: Homepage, https://github.com/pyagent-core/pyagent
+Project-URL: Source, https://github.com/pyagent-core/pyagent/tree/main/packages/pyagent-patterns
+Project-URL: Documentation, https://pyagent-core.github.io/pyagent
+Project-URL: Issues, https://github.com/pyagent-core/pyagent/issues
+Project-URL: Changelog, https://github.com/pyagent-core/pyagent/blob/main/CHANGELOG.md
+Author: PyAgent Contributors
 License: MIT
 Keywords: LLM,agents,multi-agent,orchestration,patterns
 Classifier: Development Status :: 3 - Alpha

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyagent-patterns"
-version = "0.1.0"
+version = "0.2.0"
 description = "18 reusable multi-agent orchestration patterns for LLMs"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -20,6 +20,16 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
     "Typing :: Typed",
 ]
+authors = [
+    {name = "PyAgent Contributors"},
+]
+
+[project.urls]
+Homepage      = "https://github.com/pyagent-core/pyagent"
+Source        = "https://github.com/pyagent-core/pyagent/tree/main/packages/pyagent-patterns"
+Documentation = "https://pyagent-core.github.io/pyagent"
+Issues        = "https://github.com/pyagent-core/pyagent/issues"
+Changelog     = "https://github.com/pyagent-core/pyagent/blob/main/CHANGELOG.md"
 
 [project.optional-dependencies]
 dev = ["pytest>=8.0", "pytest-asyncio>=0.23", "ruff>=0.5", "mypy>=1.10"]

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/advanced/__init__.py

@@ -5,4 +5,4 @@ from pyagent_patterns.advanced.react import ReAct
 from pyagent_patterns.advanced.swarm import Swarm
 from pyagent_patterns.advanced.talker_reasoner import TalkerReasoner
 
-__all__ = ["TalkerReasoner", "Swarm", "HumanInTheLoop", "ReAct"]
+__all__ = ["HumanInTheLoop", "ReAct", "Swarm", "TalkerReasoner"]

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/advanced/human_in_the_loop.py

@@ -8,7 +8,7 @@ LLM calls: 1 agent + optional revision calls
 
 from __future__ import annotations
 
-from typing import Callable
+from collections.abc import Callable
 
 from pyagent_patterns.base import Agent, Context, Message, Pattern, Result
 

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/advanced/react.py

@@ -9,11 +9,11 @@ LLM calls: 1 per step × max_steps
 
 from __future__ import annotations
 
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from pyagent_patterns.base import Agent, Context, Message, Pattern, Result
 
-
 # Tool function type: (action_input: str) -> str
 ToolFn = Callable[[str], str]
 

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/advanced/swarm.py

@@ -51,32 +51,32 @@ class Swarm(Pattern):
         # Round 0: each agent independently responds to the task
         init_tasks = [agent.run([Message.user(ctx.task)]) for agent in self._agents]
         init_results = await asyncio.gather(*init_tasks)
-        for agent, result in zip(self._agents, init_results):
+        for agent, result in zip(self._agents, init_results, strict=False):
             states[agent.name] = result.content
             messages.append(result)
 
         # Subsequent rounds: agents interact with random neighbors
-        for round_num in range(1, self._rounds + 1):
+        for _round_num in range(1, self._rounds + 1):
             new_states: dict[str, str] = {}
 
-            async def _update_agent(agent: Agent) -> tuple[str, str]:
+            async def _update_agent(
+                agent: Agent, _states: dict[str, str] = states
+            ) -> tuple[str, str]:
                 # Select random neighbors
                 others = [a for a in self._agents if a.name != agent.name]
                 neighbors = random.sample(others, min(self._neighbor_count, len(others)))
 
-                neighbor_views = "\n".join(
-                    f"- {n.name}: {states[n.name]}" for n in neighbors
-                )
+                neighbor_views = "\n".join(f"- {n.name}: {_states[n.name]}" for n in neighbors)
                 prompt = Message.user(
                     f"Task: {ctx.task}\n\n"
-                    f"Your current response: {states[agent.name]}\n\n"
+                    f"Your current response: {_states[agent.name]}\n\n"
                     f"Neighbor responses:\n{neighbor_views}\n\n"
                     f"Update your response considering your neighbors' views."
                 )
                 result = await agent.run([prompt])
                 return agent.name, result.content
 
-            update_tasks = [_update_agent(agent) for agent in self._agents]
+            update_tasks = [_update_agent(agent, states) for agent in self._agents]
             updates = await asyncio.gather(*update_tasks)
             for name, content in updates:
                 new_states[name] = content

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/advisor.py

@@ -13,17 +13,17 @@ Decision factors:
 from __future__ import annotations
 
 from dataclasses import dataclass
-from enum import Enum
+from enum import StrEnum
 
 
-class Quality(str, Enum):
+class Quality(StrEnum):
     DRAFT = "draft"
     STANDARD = "standard"
     HIGH = "high"
     CRITICAL = "critical"
 
 
-class Latency(str, Enum):
+class Latency(StrEnum):
     REALTIME = "realtime"  # < 2s
     INTERACTIVE = "interactive"  # < 10s
     BATCH = "batch"  # minutes OK
@@ -68,15 +68,18 @@ class PatternAdvisor:
         # Decision tree based on Augment 2026 "Five Decision Rules"
 
         # Rule 1: Simple single-step tasks → Pipeline or single agent
-        if not c.multi_step and c.quality in (Quality.DRAFT, Quality.STANDARD):
-            if c.latency == Latency.REALTIME:
-                return Recommendation(
-                    pattern="pipeline",
-                    reason="Simple task with real-time latency → minimal sequential processing",
-                    estimated_calls=1,
-                    estimated_cost_range="$0.001-0.003",
-                    alternatives=["talker_reasoner"],
-                )
+        if (
+            not c.multi_step
+            and c.quality in (Quality.DRAFT, Quality.STANDARD)
+            and c.latency == Latency.REALTIME
+        ):
+            return Recommendation(
+                pattern="pipeline",
+                reason="Simple task with real-time latency → minimal sequential processing",
+                estimated_calls=1,
+                estimated_cost_range="$0.001-0.003",
+                alternatives=["talker_reasoner"],
+            )
 
         # Rule 2: Cost-sensitive → Route to cheapest viable model
         if c.max_cost_usd < 0.01:
@@ -101,7 +104,9 @@ class PatternAdvisor:
         # Rule 4: High quality → Reflection, Debate, or Evaluator
         if c.quality in (Quality.HIGH, Quality.CRITICAL):
             # Check for adversarial/debate keywords
-            if any(w in task_lower for w in ["compare", "pros and cons", "debate", "argue", "versus"]):
+            if any(
+                w in task_lower for w in ["compare", "pros and cons", "debate", "argue", "versus"]
+            ):
                 return Recommendation(
                     pattern="debate",
                     reason="High quality + adversarial task → structured debate with judge",
@@ -129,7 +134,9 @@ class PatternAdvisor:
             )
 
         # Rule 5: Multi-step/complex → Supervisor, Hierarchical, or Pipeline
-        if c.multi_step or any(w in task_lower for w in ["steps", "process", "workflow", "pipeline"]):
+        if c.multi_step or any(
+            w in task_lower for w in ["steps", "process", "workflow", "pipeline"]
+        ):
             if any(w in task_lower for w in ["team", "delegate", "manage", "coordinate"]):
                 return Recommendation(
                     pattern="hierarchical",

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/base.py

@@ -7,11 +7,14 @@ import time
 import uuid
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, AsyncIterator, Callable, Protocol, runtime_checkable
+from enum import StrEnum
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
 
-class Role(str, Enum):
+
+class Role(StrEnum):
     """Well-known agent roles."""
 
     SYSTEM = "system"

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/composite.py

@@ -8,11 +8,10 @@ EscalationChain is a pre-built composite: Reflection → Debate → Voting → H
 
 from __future__ import annotations
 
-from typing import Callable
+from collections.abc import Callable
 
 from pyagent_patterns.base import Context, Pattern, Result
 
-
 # Quality check: returns True if the result is acceptable
 QualityCheckFn = Callable[[Result], bool]
 
@@ -68,11 +67,13 @@ class CompositePattern(Pattern):
 
             result = await pattern._execute(child_ctx)
             all_messages.extend(result.messages)
-            escalation_log.append({
-                "pattern": pattern.pattern_type,
-                "output_length": len(result.output),
-                "metadata": result.metadata,
-            })
+            escalation_log.append(
+                {
+                    "pattern": pattern.pattern_type,
+                    "output_length": len(result.output),
+                    "metadata": result.metadata,
+                }
+            )
 
             if self._quality_check(result):
                 return Result(

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/guardrails.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import re
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
+from typing import ClassVar
 
 
 @dataclass
@@ -71,7 +72,7 @@ class PIIGuard(Guardrail):
         redact: If True, redact PII and pass. If False, reject on detection.
     """
 
-    _PATTERNS = {
+    _PATTERNS: ClassVar[dict[str, str]] = {
         "email": r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b",
         "phone": r"\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b",
         "ssn": r"\b\d{3}[-]?\d{2}[-]?\d{4}\b",

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/orchestration/__init__.py

@@ -6,4 +6,4 @@ from pyagent_patterns.orchestration.orchestrator_workers import OrchestratorWork
 from pyagent_patterns.orchestration.pipeline import Pipeline
 from pyagent_patterns.orchestration.supervisor import Supervisor
 
-__all__ = ["Supervisor", "Pipeline", "FanOutFanIn", "Hierarchical", "OrchestratorWorkers"]
+__all__ = ["FanOutFanIn", "Hierarchical", "OrchestratorWorkers", "Pipeline", "Supervisor"]

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/orchestration/fan_out_fan_in.py

@@ -10,10 +10,13 @@ Wall-clock latency: max(agent latencies) + aggregator
 from __future__ import annotations
 
 import asyncio
-from typing import AsyncIterator
+from typing import TYPE_CHECKING
 
 from pyagent_patterns.base import Agent, Context, Message, Pattern, Result
 
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
 
 class FanOutFanIn(Pattern):
     """Parallel execution with result aggregation.
@@ -43,8 +46,7 @@ class FanOutFanIn(Pattern):
 
         # Fan-in: aggregate results
         combined = "\n\n".join(
-            f"--- {self._agents[i].name} ---\n{r.content}"
-            for i, r in enumerate(parallel_results)
+            f"--- {self._agents[i].name} ---\n{r.content}" for i, r in enumerate(parallel_results)
         )
         agg_prompt = Message.user(
             f"Combine the following analyses into a unified response:\n\n{combined}"

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/orchestration/hierarchical.py

@@ -75,9 +75,7 @@ class Hierarchical(Pattern):
             worker_summary = "\n".join(
                 f"- {team.workers[i].name}: {r.content}" for i, r in enumerate(worker_results)
             )
-            lead_msg = Message.user(
-                f"Synthesize your team's work:\n{worker_summary}"
-            )
+            lead_msg = Message.user(f"Synthesize your team's work:\n{worker_summary}")
             lead_result = await team.lead.run([lead_msg])
             team_msgs.append(lead_result)
             return lead_result.content, team_msgs

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/orchestration/orchestrator_workers.py

@@ -38,7 +38,7 @@ class OrchestratorWorkers(Pattern):
         plan_prompt = Message.user(
             f"You have these workers available: {', '.join(worker_names)}.\n"
             f"Plan how to accomplish this task by assigning subtasks to workers.\n"
-            f"Respond as JSON: {{\"assignments\": [{{\"worker\": \"name\", \"subtask\": \"description\"}}]}}\n\n"
+            f'Respond as JSON: {{"assignments": [{{"worker": "name", "subtask": "description"}}]}}\n\n'
             f"Task: {ctx.task}"
         )
         plan_msg = await self._orchestrator.run([plan_prompt])

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/orchestration/pipeline.py

@@ -8,10 +8,13 @@ LLM calls: N (one per stage)
 
 from __future__ import annotations
 
-from typing import AsyncIterator
+from typing import TYPE_CHECKING
 
 from pyagent_patterns.base import Agent, Context, Message, Pattern, Result
 
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
 
 class Pipeline(Pattern):
     """Sequential stage chain — output of stage N becomes input of stage N+1.
@@ -33,7 +36,7 @@ class Pipeline(Pattern):
         messages: list[Message] = []
         current_input = ctx.task
 
-        for i, stage in enumerate(self._stages):
+        for _i, stage in enumerate(self._stages):
             stage_msg = Message.user(current_input)
             response = await stage.run([stage_msg])
             messages.append(response)
@@ -47,7 +50,7 @@ class Pipeline(Pattern):
 
     async def stream(self, task: str, context: Context | None = None) -> AsyncIterator[str]:
         """Stream stage completions as they finish."""
-        ctx = context or Context(task=task)
+        context or Context(task=task)
         current_input = task
 
         for i, stage in enumerate(self._stages):

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/recovery.py

@@ -11,14 +11,13 @@ from __future__ import annotations
 
 import asyncio
 import time
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any
+from dataclasses import dataclass
+from enum import StrEnum
 
 from pyagent_patterns.base import Context, Pattern, Result
 
 
-class CircuitState(str, Enum):
+class CircuitState(StrEnum):
     CLOSED = "closed"  # Normal operation
     OPEN = "open"  # Failing, rejecting requests
     HALF_OPEN = "half_open"  # Testing if recovered
@@ -69,10 +68,12 @@ class BoundedExecution:
                     result.metadata["attempts"] = attempt
                     return result
                 # Token limit exceeded — try next level
-                last_error = Exception(f"Token limit exceeded: {result.token_estimate}/{self.max_tokens}")
+                last_error = Exception(
+                    f"Token limit exceeded: {result.token_estimate}/{self.max_tokens}"
+                )
                 break
-            except asyncio.TimeoutError:
-                last_error = asyncio.TimeoutError(f"Timeout after {self.timeout_seconds}s")
+            except TimeoutError:
+                last_error = TimeoutError(f"Timeout after {self.timeout_seconds}s")
                 break
             except Exception as e:
                 last_error = e
@@ -131,9 +132,11 @@ class CircuitBreaker:
 
     @property
     def state(self) -> CircuitState:
-        if self._state == CircuitState.OPEN:
-            if time.time() - self._last_failure_time > self._reset_timeout:
-                self._state = CircuitState.HALF_OPEN
+        if (
+            self._state == CircuitState.OPEN
+            and time.time() - self._last_failure_time > self._reset_timeout
+        ):
+            self._state = CircuitState.HALF_OPEN
         return self._state
 
     async def execute(self, pattern: Pattern, task: str, context: Context | None = None) -> Result:

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/registry.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING
 
-from pyagent_patterns.base import Pattern
+if TYPE_CHECKING:
+    from pyagent_patterns.base import Pattern
 
 _REGISTRY: dict[str, type[Pattern]] = {}
 

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/resolution/__init__.py

@@ -6,4 +6,4 @@ from pyagent_patterns.resolution.evaluator_optimizer import EvaluatorOptimizer
 from pyagent_patterns.resolution.self_reflection import SelfReflection
 from pyagent_patterns.resolution.voting import Voting
 
-__all__ = ["SelfReflection", "CrossReflection", "Debate", "Voting", "EvaluatorOptimizer"]
+__all__ = ["CrossReflection", "Debate", "EvaluatorOptimizer", "SelfReflection", "Voting"]

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/resolution/cross_reflection.py

@@ -40,6 +40,7 @@ class CrossReflection(Pattern):
     async def _execute(self, ctx: Context) -> Result:
         messages: list[Message] = []
         current_output = ""
+        review_text = ""
 
         for round_num in range(1, self._max_rounds + 1):
             # Generate or revise

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/resolution/debate.py

@@ -43,6 +43,7 @@ class Debate(Pattern):
     async def _execute(self, ctx: Context) -> Result:
         messages: list[Message] = []
         debate_log: list[dict[str, str]] = []
+        round_args_prev: list[str] = []
 
         for round_num in range(1, self._rounds + 1):
             round_args: list[str] = []
@@ -69,12 +70,14 @@ class Debate(Pattern):
                 arg_result = await debater.run([prompt])
                 messages.append(arg_result)
                 round_args.append(arg_result.content)
-                debate_log.append({
-                    "round": round_num,
-                    "debater": debater.name,
-                    "position": position,
-                    "argument": arg_result.content,
-                })
+                debate_log.append(
+                    {
+                        "round": round_num,
+                        "debater": debater.name,
+                        "position": position,
+                        "argument": arg_result.content,
+                    }
+                )
 
             round_args_prev = round_args
 

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/resolution/evaluator_optimizer.py

@@ -44,6 +44,7 @@ class EvaluatorOptimizer(Pattern):
         messages: list[Message] = []
         current_output = ""
         scores: list[int] = []
+        eval_text = ""
 
         criteria_text = "\n".join(f"- {c}" for c in self._criteria)
 

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/resolution/self_reflection.py

@@ -40,6 +40,7 @@ class SelfReflection(Pattern):
     async def _execute(self, ctx: Context) -> Result:
         messages: list[Message] = []
         current_output = ""
+        critique_text = ""
 
         for round_num in range(1, self._max_rounds + 1):
             # Generate (or refine)

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/resolution/voting.py

@@ -10,12 +10,12 @@ from __future__ import annotations
 
 import asyncio
 from collections import Counter
-from enum import Enum
+from enum import StrEnum
 
 from pyagent_patterns.base import Agent, Context, Message, Pattern, Result
 
 
-class VotingStrategy(str, Enum):
+class VotingStrategy(StrEnum):
     MAJORITY = "majority"
     WEIGHTED = "weighted"
 
@@ -55,12 +55,12 @@ class Voting(Pattern):
 
         suffix = ""
         if self._normalize:
-            suffix = "\n\nRespond with a concise answer (one word or short phrase) first, then explain."
+            suffix = (
+                "\n\nRespond with a concise answer (one word or short phrase) first, then explain."
+            )
 
         # All voters run in parallel
-        tasks = [
-            voter.run([Message.user(ctx.task + suffix)]) for voter in self._voters
-        ]
+        tasks = [voter.run([Message.user(ctx.task + suffix)]) for voter in self._voters]
         votes = await asyncio.gather(*tasks)
         messages.extend(votes)
 
@@ -75,7 +75,7 @@ class Voting(Pattern):
         else:
             # Weighted voting
             weighted_counts: dict[str, float] = {}
-            for label, weight in zip(vote_labels, self._weights):
+            for label, weight in zip(vote_labels, self._weights, strict=False):
                 weighted_counts[label] = weighted_counts.get(label, 0.0) + weight
             winner = max(weighted_counts, key=weighted_counts.get)  # type: ignore[arg-type]
             tally = weighted_counts

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/streaming.py

@@ -12,9 +12,12 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass, field
-from typing import Any, AsyncIterator
+from typing import TYPE_CHECKING, Any
 
-from pyagent_patterns.base import Pattern, Result
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from pyagent_patterns.base import Pattern
 
 
 @dataclass
@@ -36,8 +39,8 @@ async def stream_pattern(pattern: Pattern, task: str) -> AsyncIterator[StreamChu
     For Pipeline patterns, yields after each stage completes.
     For Fan-Out, yields as each parallel agent completes.
     """
-    from pyagent_patterns.orchestration.pipeline import Pipeline
     from pyagent_patterns.orchestration.fan_out_fan_in import FanOutFanIn
+    from pyagent_patterns.orchestration.pipeline import Pipeline
 
     if isinstance(pattern, Pipeline):
         async for chunk in _stream_pipeline(pattern, task):
@@ -87,12 +90,14 @@ async def _stream_fanout(fanout: Pattern, task: str) -> AsyncIterator[StreamChun
         if agent.system_prompt:
             messages.insert(0, Message(role=Role.SYSTEM, content=agent.system_prompt))
         response = await agent.llm.generate(messages)
-        await queue.put(StreamChunk(
-            content=response,
-            agent_name=agent.name,
-            chunk_type="stage_complete",
-            metadata={"agent_index": idx},
-        ))
+        await queue.put(
+            StreamChunk(
+                content=response,
+                agent_name=agent.name,
+                chunk_type="stage_complete",
+                metadata={"agent_index": idx},
+            )
+        )
 
     tasks = [asyncio.create_task(run_agent(a, i)) for i, a in enumerate(fanout._agents)]
     done_count = 0
@@ -107,9 +112,7 @@ async def _stream_fanout(fanout: Pattern, task: str) -> AsyncIterator[StreamChun
     await asyncio.gather(*tasks)
 
     # Aggregate
-    aggregated_input = "\n".join(
-        f"[{a.name}]: (see prior chunks)" for a in fanout._agents
-    )
+    "\n".join(f"[{a.name}]: (see prior chunks)" for a in fanout._agents)
     result = await fanout.run(task)
     yield StreamChunk(
         content=result.output,

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/structural/__init__.py

@@ -5,4 +5,4 @@ from pyagent_patterns.structural.layered import Layered
 from pyagent_patterns.structural.role_based import RoleBased
 from pyagent_patterns.structural.topology import Topology, TopologyType
 
-__all__ = ["RoleBased", "Layered", "Topology", "TopologyType", "Blackboard"]
+__all__ = ["Blackboard", "Layered", "RoleBased", "Topology", "TopologyType"]

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/structural/blackboard.py

@@ -103,7 +103,7 @@ class Blackboard(Pattern):
         for key, value in self._initial_state.items():
             board.write(key, value, "system")
 
-        for round_num in range(1, self._rounds + 1):
+        for _round_num in range(1, self._rounds + 1):
             for ba in self._agents:
                 # Build prompt from readable keys
                 readable = {k: board.read(k) for k in ba.reads if board.read(k) is not None}

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/structural/layered.py

@@ -42,11 +42,9 @@ class Layered(Pattern):
         messages: list[Message] = []
         layer_input = ctx.task
 
-        for i, layer in enumerate(self._layers):
+        for _i, layer in enumerate(self._layers):
             # Run all agents in this layer in parallel
-            tasks = [
-                agent.run([Message.user(layer_input)]) for agent in layer.agents
-            ]
+            tasks = [agent.run([Message.user(layer_input)]) for agent in layer.agents]
             layer_results = await asyncio.gather(*tasks)
             messages.extend(layer_results)
 
@@ -55,8 +53,7 @@ class Layered(Pattern):
                 layer_input = layer_results[0].content
             else:
                 layer_input = "\n\n".join(
-                    f"[{layer.agents[j].name}]: {r.content}"
-                    for j, r in enumerate(layer_results)
+                    f"[{layer.agents[j].name}]: {r.content}" for j, r in enumerate(layer_results)
                 )
 
         return Result(
@@ -64,7 +61,7 @@ class Layered(Pattern):
             messages=messages,
             metadata={
                 "layer_count": len(self._layers),
-                "layer_names": [l.name for l in self._layers],
-                "agents_per_layer": [len(l.agents) for l in self._layers],
+                "layer_names": [layer_.name for layer_ in self._layers],
+                "agents_per_layer": [len(layer_.agents) for layer_ in self._layers],
             },
         )

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/structural/role_based.py

@@ -39,7 +39,7 @@ class RoleBased(Pattern):
         messages: list[Message] = []
         conversation: list[Message] = [Message.user(ctx.task)]
 
-        for round_num in range(1, self._rounds + 1):
+        for _round_num in range(1, self._rounds + 1):
             for agent in self._agents:
                 if self._shared_context:
                     input_msgs = list(conversation)

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/structural/topology.py

@@ -11,12 +11,12 @@ flow, overhead, and result quality.
 from __future__ import annotations
 
 import asyncio
-from enum import Enum
+from enum import StrEnum
 
 from pyagent_patterns.base import Agent, Context, Message, Pattern, Result
 
 
-class TopologyType(str, Enum):
+class TopologyType(StrEnum):
     CHAIN = "chain"
     STAR = "star"
     MESH = "mesh"
@@ -82,12 +82,10 @@ class Topology(Pattern):
         messages.extend(spoke_results)
 
         # Hub synthesizes
-        summary = "\n".join(
-            f"- {spokes[i].name}: {r.content}" for i, r in enumerate(spoke_results)
+        summary = "\n".join(f"- {spokes[i].name}: {r.content}" for i, r in enumerate(spoke_results))
+        hub_result = await hub.run(
+            [Message.user(f"Synthesize these inputs:\n{summary}\n\nOriginal task: {ctx.task}")]
         )
-        hub_result = await hub.run([Message.user(
-            f"Synthesize these inputs:\n{summary}\n\nOriginal task: {ctx.task}"
-        )])
         messages.append(hub_result)
 
         return Result(output=hub_result.content, messages=messages, metadata={"topology": "star"})
@@ -100,7 +98,7 @@ class Topology(Pattern):
         # Initial round
         tasks = [a.run([Message.user(ctx.task)]) for a in self._agents]
         initial = await asyncio.gather(*tasks)
-        for agent, result in zip(self._agents, initial):
+        for agent, result in zip(self._agents, initial, strict=False):
             outputs[agent.name] = result.content
             messages.append(result)
 
@@ -112,12 +110,18 @@ class Topology(Pattern):
                     for name, content in outputs.items()
                     if name != agent.name
                 )
-                result = await agent.run([Message.user(
-                    f"Task: {ctx.task}\n\nPeer outputs:\n{peer_outputs}\n\nProvide your updated response."
-                )])
+                result = await agent.run(
+                    [
+                        Message.user(
+                            f"Task: {ctx.task}\n\nPeer outputs:\n{peer_outputs}\n\nProvide your updated response."
+                        )
+                    ]
+                )
                 outputs[agent.name] = result.content
                 messages.append(result)
 
         # Final output is concatenation of all agent outputs
         final = "\n\n".join(f"[{name}]: {content}" for name, content in outputs.items())
-        return Result(output=final, messages=messages, metadata={"topology": "mesh", "rounds": self._rounds})
+        return Result(
+            output=final, messages=messages, metadata={"topology": "mesh", "rounds": self._rounds}
+        )

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/tests/test_advanced.py

@@ -3,10 +3,9 @@
 from __future__ import annotations
 
 import pytest
-
-from pyagent_patterns.base import Agent, MockLLM
 from pyagent_patterns.advanced import HumanInTheLoop, ReAct, Swarm, TalkerReasoner
 from pyagent_patterns.advanced.human_in_the_loop import HumanDecision
+from pyagent_patterns.base import Agent, MockLLM
 
 
 @pytest.mark.asyncio

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/tests/test_composite.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import pytest
-
 from pyagent_patterns.base import Agent, MockLLM
 from pyagent_patterns.composite import CompositePattern, min_length_check
 from pyagent_patterns.resolution import SelfReflection, Voting
@@ -32,10 +31,12 @@ async def test_composite_escalation():
     reflection = SelfReflection(agent=Agent("coder", short_llm), max_rounds=1)
 
     # Second pattern produces adequate output
-    vote_llm = MockLLM(responses=[
-        "A much longer and more detailed response that passes the length check",
-        "A much longer and more detailed response that passes the length check",
-    ])
+    vote_llm = MockLLM(
+        responses=[
+            "A much longer and more detailed response that passes the length check",
+            "A much longer and more detailed response that passes the length check",
+        ]
+    )
     voting = Voting(voters=[Agent("a", vote_llm), Agent("b", vote_llm)])
 
     composite = CompositePattern(

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/tests/test_orchestration.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import pytest
-
 from pyagent_patterns.base import Agent, MockLLM
 from pyagent_patterns.orchestration import (
     FanOutFanIn,
@@ -39,11 +38,13 @@ async def test_supervisor_routes_correctly():
 async def test_pipeline_sequential_stages():
     stage_llm = MockLLM(responses=["extracted text", "summarized text", "translated text"])
 
-    pipeline = Pipeline(stages=[
-        Agent("extract", stage_llm),
-        Agent("summarize", stage_llm),
-        Agent("translate", stage_llm),
-    ])
+    pipeline = Pipeline(
+        stages=[
+            Agent("extract", stage_llm),
+            Agent("summarize", stage_llm),
+            Agent("translate", stage_llm),
+        ]
+    )
 
     result = await pipeline.run("Process this document")
     assert result.metadata["stages"] == 3
@@ -90,10 +91,12 @@ async def test_hierarchical_delegation():
 
 @pytest.mark.asyncio
 async def test_orchestrator_workers_dynamic():
-    orch_llm = MockLLM(responses=[
-        '{"assignments": [{"worker": "researcher", "subtask": "Find data"}]}',
-        "Synthesized: research complete",
-    ])
+    orch_llm = MockLLM(
+        responses=[
+            '{"assignments": [{"worker": "researcher", "subtask": "Find data"}]}',
+            "Synthesized: research complete",
+        ]
+    )
     worker_llm = MockLLM(responses=["Data found on topic X"])
 
     orch = OrchestratorWorkers(

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/tests/test_resolution.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import pytest
-
 from pyagent_patterns.base import Agent, MockLLM
 from pyagent_patterns.resolution import (
     CrossReflection,
@@ -25,7 +24,16 @@ async def test_self_reflection_early_stop():
 
 @pytest.mark.asyncio
 async def test_self_reflection_max_rounds():
-    llm = MockLLM(responses=["Draft 1", "Needs work", "Draft 2", "Still needs work", "Draft 3", "More feedback"])
+    llm = MockLLM(
+        responses=[
+            "Draft 1",
+            "Needs work",
+            "Draft 2",
+            "Still needs work",
+            "Draft 3",
+            "More feedback",
+        ]
+    )
     pattern = SelfReflection(agent=Agent("coder", llm), max_rounds=3)
     result = await pattern.run("Write code")
     assert result.metadata["rounds"] == 3
@@ -69,11 +77,13 @@ async def test_voting_majority():
     llm_b = MockLLM(responses=["YES\nBecause of Y"])
     llm_c = MockLLM(responses=["NO\nBecause of Z"])
 
-    pattern = Voting(voters=[
-        Agent("voter_a", llm_a),
-        Agent("voter_b", llm_b),
-        Agent("voter_c", llm_c),
-    ])
+    pattern = Voting(
+        voters=[
+            Agent("voter_a", llm_a),
+            Agent("voter_b", llm_b),
+            Agent("voter_c", llm_c),
+        ]
+    )
     result = await pattern.run("Is this a good idea?")
     assert result.metadata["winner"] == "YES"
     assert result.metadata["tally"]["YES"] == 2

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/tests/test_structural.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import pytest
-
 from pyagent_patterns.base import Agent, MockLLM
 from pyagent_patterns.structural import Blackboard, Layered, RoleBased, Topology, TopologyType
 from pyagent_patterns.structural.blackboard import BlackboardAgent
@@ -29,11 +28,13 @@ async def test_role_based_shared_context():
 async def test_layered_multi_layer():
     llm = MockLLM(responses=["Raw data", "Analysis result", "Final synthesis"])
 
-    pattern = Layered(layers=[
-        Layer(name="gather", agents=[Agent("gatherer", llm)]),
-        Layer(name="analyze", agents=[Agent("analyst", llm)]),
-        Layer(name="synthesize", agents=[Agent("synthesizer", llm)]),
-    ])
+    pattern = Layered(
+        layers=[
+            Layer(name="gather", agents=[Agent("gatherer", llm)]),
+            Layer(name="analyze", agents=[Agent("analyst", llm)]),
+            Layer(name="synthesize", agents=[Agent("synthesizer", llm)]),
+        ]
+    )
     result = await pattern.run("Analyze the market")
     assert result.metadata["layer_count"] == 3
     assert result.output == "Final synthesis"

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/tests/test_valueadd.py

@@ -3,16 +3,15 @@
 from __future__ import annotations
 
 import pytest
-
 from pyagent_patterns.advisor import Constraints, Latency, PatternAdvisor, Quality
 from pyagent_patterns.base import Agent, MockLLM
 from pyagent_patterns.guardrails import ContentGuard, GuardrailChain, LengthGuard, PIIGuard
 from pyagent_patterns.orchestration import Pipeline
 from pyagent_patterns.recovery import BoundedExecution, CircuitBreaker, CircuitState
 
-
 # --- Recovery Tests ---
 
+
 @pytest.mark.asyncio
 async def test_bounded_execution_success():
     llm = MockLLM(responses=["Success output"])
@@ -50,6 +49,7 @@ def test_circuit_breaker_resets():
     cb._on_failure()
     assert cb.state == CircuitState.OPEN
     import time
+
     time.sleep(0.02)
     assert cb.state == CircuitState.HALF_OPEN
     cb._on_success()
@@ -58,6 +58,7 @@ def test_circuit_breaker_resets():
 
 # --- Guardrail Tests ---
 
+
 def test_length_guard_pass():
     guard = LengthGuard(max_chars=100)
     result = guard.check("Short text")
@@ -98,10 +99,12 @@ def test_content_guard_deny_words():
 
 
 def test_guardrail_chain():
-    chain = GuardrailChain([
-        LengthGuard(max_chars=1000),
-        PIIGuard(redact=True),
-    ])
+    chain = GuardrailChain(
+        [
+            LengthGuard(max_chars=1000),
+            PIIGuard(redact=True),
+        ]
+    )
     result = chain.check("Email: test@test.com. This is fine otherwise.")
     assert result.passed is True
     assert "REDACTED" in result.sanitized_content
@@ -109,6 +112,7 @@ def test_guardrail_chain():
 
 # --- Advisor Tests ---
 
+
 def test_advisor_simple_task():
     advisor = PatternAdvisor()
     rec = advisor.recommend(

pyagent_patterns-0.1.0/.gitignore

@@ -1,18 +0,0 @@
-__pycache__/
-*.py[cod]
-*$py.class
-*.egg-info/
-dist/
-build/
-.eggs/
-*.egg
-.venv/
-venv/
-.mypy_cache/
-.ruff_cache/
-.pytest_cache/
-.coverage
-htmlcov/
-site/
-.env
-*.log

{pyagent_patterns-0.1.0 → pyagent_patterns-0.2.0}/src/pyagent_patterns/__init__.py

@@ -6,8 +6,8 @@ from pyagent_patterns.registry import get_pattern_class, list_patterns, register
 
 __all__ = [
     "Agent",
-    "Context",
     "CompositePattern",
+    "Context",
     "Message",
     "MockLLM",
     "Pattern",