pyagent-patterns 0.1.0__py3-none-any.whl

pyagent_patterns/structural/topology.py

@@ -0,0 +1,123 @@
+"""Topology pattern: configurable communication graph — Chain, Star, or Mesh.
+
+Controls which agents can communicate with which, affecting information
+flow, overhead, and result quality.
+
+- Chain: A→B→C (sequential, low overhead)
+- Star: Hub↔{A,B,C} (centralized, easy to trace)
+- Mesh: A↔B↔C↔A (rich but expensive)
+"""
+
+from __future__ import annotations
+
+import asyncio
+from enum import Enum
+
+from pyagent_patterns.base import Agent, Context, Message, Pattern, Result
+
+
+class TopologyType(str, Enum):
+    CHAIN = "chain"
+    STAR = "star"
+    MESH = "mesh"
+
+
+class Topology(Pattern):
+    """Configurable agent communication topology.
+
+    Args:
+        agents: List of agents participating in the topology.
+        topology: The communication structure (chain, star, mesh).
+        hub_index: For star topology, the index of the hub agent. Defaults to 0.
+        rounds: For mesh topology, number of communication rounds.
+    """
+
+    def __init__(
+        self,
+        agents: list[Agent],
+        topology: TopologyType = TopologyType.CHAIN,
+        hub_index: int = 0,
+        rounds: int = 1,
+    ) -> None:
+        if len(agents) < 2:
+            raise ValueError("Topology requires at least 2 agents")
+        self._agents = agents
+        self._topology = topology
+        self._hub_index = hub_index
+        self._rounds = rounds
+
+    @property
+    def pattern_type(self) -> str:
+        return f"topology_{self._topology.value}"
+
+    async def _execute(self, ctx: Context) -> Result:
+        if self._topology == TopologyType.CHAIN:
+            return await self._chain(ctx)
+        elif self._topology == TopologyType.STAR:
+            return await self._star(ctx)
+        else:
+            return await self._mesh(ctx)
+
+    async def _chain(self, ctx: Context) -> Result:
+        """A→B→C: sequential processing."""
+        messages: list[Message] = []
+        current = ctx.task
+
+        for agent in self._agents:
+            result = await agent.run([Message.user(current)])
+            messages.append(result)
+            current = result.content
+
+        return Result(output=current, messages=messages, metadata={"topology": "chain"})
+
+    async def _star(self, ctx: Context) -> Result:
+        """Hub↔{spokes}: hub collects from all spokes."""
+        messages: list[Message] = []
+        hub = self._agents[self._hub_index]
+        spokes = [a for i, a in enumerate(self._agents) if i != self._hub_index]
+
+        # Spokes process in parallel
+        tasks = [spoke.run([Message.user(ctx.task)]) for spoke in spokes]
+        spoke_results = await asyncio.gather(*tasks)
+        messages.extend(spoke_results)
+
+        # Hub synthesizes
+        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}"
+        )])
+        messages.append(hub_result)
+
+        return Result(output=hub_result.content, messages=messages, metadata={"topology": "star"})
+
+    async def _mesh(self, ctx: Context) -> Result:
+        """Full mesh: every agent sees every other agent's output per round."""
+        messages: list[Message] = []
+        outputs = {a.name: "" for a in self._agents}
+
+        # 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):
+            outputs[agent.name] = result.content
+            messages.append(result)
+
+        # Subsequent mesh rounds
+        for _ in range(1, self._rounds + 1):
+            for agent in self._agents:
+                peer_outputs = "\n".join(
+                    f"- {name}: {content}"
+                    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."
+                )])
+                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})

pyagent_patterns-0.1.0.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: pyagent-patterns
+Version: 0.1.0
+Summary: 18 reusable multi-agent orchestration patterns for LLMs
+License: MIT
+Keywords: LLM,agents,multi-agent,orchestration,patterns
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pyagent-patterns
+
+**18 reusable multi-agent orchestration patterns for LLMs** — zero dependencies, async-first, fully typed.
+
+## Install
+
+```bash
+pip install pyagent-patterns
+```
+
+## Patterns
+
+| Tier | Patterns |
+|------|----------|
+| Orchestration | Supervisor, Pipeline, Fan-Out/Fan-In, Hierarchical, Orchestrator-Workers |
+| Resolution | Self-Reflection, Cross-Reflection, Debate, Voting, Evaluator-Optimizer |
+| Structural | Role-Based, Layered, Topology, Blackboard |
+| Advanced | Talker-Reasoner, Swarm, Human-in-the-Loop, ReAct |
+
+Plus: CompositePattern (escalation chains), PatternAdvisor, GuardrailChain, BoundedExecution, CircuitBreaker.
+
+## Quick Example
+
+```python
+import asyncio
+from pyagent_patterns.base import Agent, MockLLM
+from pyagent_patterns.resolution import SelfReflection
+
+llm = MockLLM(responses=["Draft code", "Needs error handling", "Improved code", "APPROVED"])
+pattern = SelfReflection(agent=Agent("coder", llm), max_rounds=3)
+result = asyncio.run(pattern.run("Write a sorting function"))
+print(result.output)
+```
+
+## Documentation
+
+Full docs: [pyagent.dev](https://pyagent.dev)

pyagent_patterns-0.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+pyagent_patterns/__init__.py,sha256=c-lC-NmHEuWSQnKHe0FCFiqkWzFTCqKpS13hwIGaByI,550
+pyagent_patterns/advisor.py,sha256=w6q9wbyjxqUw-7qtlnijDrltaI1IYEunF1RmNWEu0sw,6437
+pyagent_patterns/base.py,sha256=n3zcIPm9JoVGu94408Q3crQMh0318avVO7ot4Ajwexo,6808
+pyagent_patterns/composite.py,sha256=dPjMQpmrE9Me8mo_regUcKCkXHuKwdBtt39-fYjAKkM,3602
+pyagent_patterns/guardrails.py,sha256=0ONWPu3hoevaSp4b1O5W53LuCsJrBUWUtNnl57PUE6s,5230
+pyagent_patterns/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyagent_patterns/recovery.py,sha256=huhtK2v6qs7UvD6zRP-t1vaU0VKQy-6ilQ0YoOsg7x8,6310
+pyagent_patterns/registry.py,sha256=cYjewpD0Aqv4bEUYc65IYTrQQWWlcNvfLaSrkOgJdx4,2679
+pyagent_patterns/streaming.py,sha256=stmnBF1fNiC47-0-WTYeZPm1JzzStZGvcw8TeWdLcY0,4012
+pyagent_patterns/advanced/__init__.py,sha256=Po2aJhSG1a-K2yHGVkpbTqVNz_8XYqlC5HQ8ImjQvfE,398
+pyagent_patterns/advanced/human_in_the_loop.py,sha256=oNHCpolttYQ9xCbfKbZVuwnUvwYY_UpPcIL7Qu0JkGo,3378
+pyagent_patterns/advanced/react.py,sha256=TVFy97D9hprJzElADN-bJ_gW8XjT-fgdT4yO9AGTr7c,4786
+pyagent_patterns/advanced/swarm.py,sha256=bAtJLEr3Dan_UWm0JJUCsOoRwh-IulBVxBmi8GrbBTQ,3895
+pyagent_patterns/advanced/talker_reasoner.py,sha256=U3i0QqksGiVo4jS-Z1oyArVy3ccdeJNW-G1b8BOTbQQ,3247
+pyagent_patterns/orchestration/__init__.py,sha256=Sem1TXl34eUuiZMnMGdDLGcK8krLwXVuEZi7ZDLJ9k8,548
+pyagent_patterns/orchestration/fan_out_fan_in.py,sha256=YWBPHPuI4rlp0jq6EpQXUa_Of3-B-pqJaoAizN3nhEI,2621
+pyagent_patterns/orchestration/hierarchical.py,sha256=jENVb_8OYp-fouZM_e1mxYzft5TJ4VXvEZLdJ2WnUBg,3694
+pyagent_patterns/orchestration/orchestrator_workers.py,sha256=yivBAKTvZD2wphuwIr15IEntB-V7yDoVmkU0S-_J9KQ,3764
+pyagent_patterns/orchestration/pipeline.py,sha256=NfXWFhixC2ubCj9ZECe8eaQGSx-SNBS2TwC3CwOnAcU,1920
+pyagent_patterns/orchestration/supervisor.py,sha256=xxrefRH7uyl93er8zZpHTHB953o9-YRIHo2L593sxv4,3015
+pyagent_patterns/resolution/__init__.py,sha256=ZkLGVyx4P8Lw5NeXpl_L7YqKWKlOTE5HBpn-z-QF8rY,526
+pyagent_patterns/resolution/cross_reflection.py,sha256=N-VFWQaKcljyL991HorjT5sWEPcUK8YLvf7mnNm23AU,2700
+pyagent_patterns/resolution/debate.py,sha256=ZPlM3HUdkZ94AkIM0OVbPErmy7N_ZPgP7Gvju4tnrdU,3776
+pyagent_patterns/resolution/evaluator_optimizer.py,sha256=Iri1F7HbYCEd5wlRJVlHL8Uj-uan_-8FASwfl5lGlDU,3906
+pyagent_patterns/resolution/self_reflection.py,sha256=_nFx76VvDW4xviwaMirloXLkEi2ln-UoZgO0vNnS_ck,2809
+pyagent_patterns/resolution/voting.py,sha256=Ry6nx4m7bcoiJRbjBPJ1p5ivF0jFI8FUyZAlbvvZ8Gg,3038
+pyagent_patterns/structural/__init__.py,sha256=g-pxDMgh9rnXBkO0UshNc5NgvxP6rmkOrAo9u0Y5XdI,410
+pyagent_patterns/structural/blackboard.py,sha256=urWX4U0FS8tq1QQcBVnUGZ7gusCzRzUBdVIv2Kd4KCg,4556
+pyagent_patterns/structural/layered.py,sha256=j1YiKDulDlzFebI4fHFsNuqiS0c9xg6xRPkZTGTscdc,2138
+pyagent_patterns/structural/role_based.py,sha256=DjYwlEIM1ypVBy8HWqBRre3_No-5QEVz4qZlywLmKIg,1978
+pyagent_patterns/structural/topology.py,sha256=mtLGle7fww28oC0SRZ6Wg1wvwPtDLcQfy9q9Bo3pIqY,4444
+pyagent_patterns-0.1.0.dist-info/METADATA,sha256=yCNmtR6oin-irZGLx5rpt-f4xSOhFJofHZhf2MGRr6c,1960
+pyagent_patterns-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pyagent_patterns-0.1.0.dist-info/RECORD,,

pyagent_patterns-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any