multiagentos 0.4.0__py3-none-any.whl

core/handoff.py

@@ -0,0 +1,68 @@
+"""Handoff and multi-review coordination."""
+
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+
+from core.contracts.agent import AgentContract
+from core.contracts.handoff import HandoffArtifact, ReviewContext, ReviewResult
+
+
+class HandoffManager:
+    def create(self, work_unit_id, from_agent, to_agent, summary, artifacts=None, findings=None):
+        return HandoffArtifact(
+            work_unit_id=work_unit_id,
+            from_agent=from_agent.id,
+            to_agent=to_agent.id,
+            summary=summary,
+            artifacts=tuple(artifacts or ()),
+            findings=tuple(findings or ()),
+        )
+
+
+@dataclass(frozen=True)
+class ReviewPanelResult:
+    approved: bool
+    reviews: tuple[ReviewResult, ...]
+    consensus: str
+
+
+class ReviewPanel:
+    def review(self, work_unit_id, reviewers, reviewer_runner, parallel=True, context=None):
+        def run(item):
+            reviewer, reviewer_context = item
+            merged_context = dict(reviewer_context or {})
+            if context is not None:
+                if isinstance(context, ReviewContext):
+                    merged_context.update({
+                        "work_unit_id": context.work_unit_id,
+                        "artifact_ids": context.artifact_ids,
+                        "findings": context.findings,
+                        "last_agent_id": context.last_agent_id,
+                        "review_cycle": context.review_cycle,
+                        "metadata": context.metadata,
+                    })
+                else:
+                    merged_context.update(dict(context))
+            result = reviewer_runner(
+                review_work_unit_id=work_unit_id,
+                reviewer=reviewer,
+                context=merged_context,
+            )
+            if hasattr(result, "reviewer_id"):
+                return result
+            return ReviewResult(
+                reviewer_id=reviewer.id,
+                approved=bool(result.approved),
+                feedback=str(getattr(result, "feedback", "")),
+            )
+        if parallel and len(reviewers) > 1:
+            with ThreadPoolExecutor(max_workers=len(reviewers)) as pool:
+                reviews = tuple(pool.map(run, reviewers))
+        else:
+            reviews = tuple(run(item) for item in reviewers)
+        approved = bool(reviews) and all(review.approved for review in reviews)
+        return ReviewPanelResult(
+            approved=approved,
+            reviews=reviews,
+            consensus="approved" if approved else "changes-requested",
+        )

core/lifecycle.py

@@ -0,0 +1,85 @@
+"""Execution lifecycle coordinator for VYRELON."""
+
+from core.contracts.agent import AgentContract
+from core.contracts.ai import ModelSpec
+from core.contracts.execution import AgentExecutor, ResultReviewer, ResultVerifier
+from core.contracts.work_unit import WorkStatus, WorkUnit
+from core.delegation import Delegation, DelegationEngine
+from core.routing import RoutingStrategy
+from collections.abc import Callable
+
+
+class LifecycleError(RuntimeError):
+    """Raised when execution, verification, or review cannot complete successfully."""
+
+
+class ExecutionInterrupted(LifecycleError):
+    """Raised when execution stops before completion and may be resumed."""
+
+
+class LifecycleCoordinator:
+    """Run delegated work through execution, verification, review, and completion."""
+
+    def __init__(self, delegation: DelegationEngine | None = None) -> None:
+        self.delegation = delegation or DelegationEngine()
+
+    def run(
+        self,
+        work_unit: WorkUnit,
+        agent: AgentContract,
+        models: list[ModelSpec],
+        executor: AgentExecutor,
+        verifier: ResultVerifier | None = None,
+        reviewer: ResultReviewer | None = None,
+        preferred_model_ids: list[str] | None = None,
+        routing_strategy: RoutingStrategy | str = RoutingStrategy.POOL,
+        checkpoint: Callable[[WorkUnit], None] | None = None,
+    ) -> tuple[Delegation, object]:
+        delegation = self.delegation.delegate(
+            work_unit, agent, models, preferred_model_ids, routing_strategy
+        )
+        try:
+            if checkpoint is not None:
+                checkpoint(work_unit)
+            output = executor.execute(
+                agent=agent,
+                model_id=delegation.assignment.model_id,
+                work_unit=work_unit,
+            )
+            if verifier is not None:
+                work_unit.transition(WorkStatus.VERIFYING)
+                if checkpoint is not None:
+                    checkpoint(work_unit)
+                if not verifier.verify(work_unit=work_unit, output=output):
+                    work_unit.transition(WorkStatus.FAILED)
+                    raise LifecycleError(f"Verification failed for work unit: {work_unit.id}")
+            if reviewer is not None:
+                if work_unit.status != WorkStatus.VERIFYING:
+                    work_unit.transition(WorkStatus.VERIFYING)
+                work_unit.transition(WorkStatus.REVIEWING)
+                if checkpoint is not None:
+                    checkpoint(work_unit)
+                decision = reviewer.review(work_unit=work_unit, output=output)
+                if not decision.approved:
+                    work_unit.transition(WorkStatus.FAILED)
+                    raise LifecycleError(f"Review rejected work unit: {work_unit.id}")
+            if verifier is not None or reviewer is not None:
+                work_unit.transition(WorkStatus.HANDOFF)
+                if checkpoint is not None:
+                    checkpoint(work_unit)
+                work_unit.transition(WorkStatus.COMPLETED)
+            else:
+                work_unit.transition(WorkStatus.COMPLETED)
+            if checkpoint is not None:
+                checkpoint(work_unit)
+            return delegation, output
+        except ExecutionInterrupted:
+            if checkpoint is not None:
+                checkpoint(work_unit)
+            raise
+        except Exception:
+            if work_unit.status not in {WorkStatus.FAILED, WorkStatus.COMPLETED}:
+                work_unit.transition(WorkStatus.FAILED)
+                if checkpoint is not None:
+                    checkpoint(work_unit)
+            raise