@baimingtao/lbs-agent 1.0.0

package/runtime/orchestration/runtime/arbiter.py

@@ -0,0 +1,85 @@
+"""Multi-Agent Arbiter — 合并多个 worker 结果（对标 LBS arbiter）。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class MergedResult:
+    status: str  # "completed" | "needs_review" | "failed"
+    summary: str
+    evidence: list[Any] = field(default_factory=list)
+    blocking_issues: list[str] = field(default_factory=list)
+    confidence: float = 0.0
+    child_results: list[Any] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "status": self.status,
+            "summary": self.summary,
+            "evidence": self.evidence,
+            "blocking_issues": self.blocking_issues,
+            "confidence": self.confidence,
+            "child_results": self.child_results,
+        }
+
+
+class Arbiter:
+    """合并 worker_result 列表，产出 MergedResult。
+
+    策略：
+      - 全部 success 且 evidence 充分 → completed
+      - 有 blocking_issues → failed
+      - 部分失败但有足够 evidence → needs_review
+    """
+
+    def __init__(self, min_evidence_count: int = 1, min_confidence: float = 0.6):
+        self.min_evidence_count = min_evidence_count
+        self.min_confidence = min_confidence
+
+    def merge(self, results: list[Any]) -> MergedResult:
+        if not results:
+            return MergedResult(status="failed", summary="no results", evidence=[], blocking_issues=["empty"], confidence=0.0)
+
+        all_evidence: list[Any] = []
+        all_blocking: list[str] = []
+        all_summaries: list[str] = []
+        confidences: list[float] = []
+        statuses: list[str] = []
+
+        for r in results:
+            evidence = getattr(r, "evidence", None) or []
+            blocking = getattr(r, "blocking_issues", None) or []
+            summary = getattr(r, "summary", "") or ""
+            confidence = float(getattr(r, "confidence", 1.0) or 0.0)
+            status = getattr(r, "status", "unknown")
+
+            all_evidence.extend(evidence)
+            all_blocking.extend(blocking)
+            all_summaries.append(summary)
+            confidences.append(confidence)
+            statuses.append(status)
+
+        # Determine status
+        success_count = sum(1 for s in statuses if s == "success")
+        if success_count == len(statuses) and not all_blocking:
+            status = "completed"
+        elif success_count == 0:
+            status = "failed"
+        else:
+            status = "needs_review"
+
+        confidence = sum(confidences) / len(confidences) if confidences else 0.0
+        if status == "completed" and len(all_evidence) < self.min_evidence_count:
+            status = "needs_review"
+
+        return MergedResult(
+            status=status,
+            summary=" | ".join(s for s in all_summaries if s)[:2000],
+            evidence=all_evidence,
+            blocking_issues=all_blocking,
+            confidence=confidence,
+            child_results=list(results),
+        )

package/runtime/orchestration/runtime/checkpoint.py

@@ -0,0 +1,148 @@
+"""Checkpoint / Resume — 持久化 AgentLoop 中断点状态。
+
+设计要点（对标 LBS resume 能力）：
+  1. LoopState 快照：messages + 迭代计数 + 当前任务
+  2. 持久化到 SessionStore 的 task 记录
+  3. 恢复时重建 AgentLoop，从 checkpoint 继续
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class Checkpoint:
+    """完整 Loop 状态快照，支持崩溃后断点恢复。"""
+    task_id: str
+    iteration: int
+    messages: list[dict[str, Any]]
+    current_step: str
+    created_at: str
+    metadata: dict[str, Any] = field(default_factory=dict)
+    # P0-5: 完整 Loop 状态
+    steps: list[dict[str, Any]] = field(default_factory=list)
+    tool_call_count: int = 0
+    current_model: str = ""
+    model_attempts: list[dict[str, Any]] = field(default_factory=list)
+    compression_results: list[dict[str, Any]] = field(default_factory=list)
+    run_trace: list[dict[str, Any]] = field(default_factory=list)
+    stall_count: int = 0
+    last_progress_signature: str = ""
+    context_snapshot: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "task_id": self.task_id,
+            "iteration": self.iteration,
+            "messages": self.messages,
+            "current_step": self.current_step,
+            "created_at": self.created_at,
+            "metadata": self.metadata,
+            "steps": self.steps,
+            "tool_call_count": self.tool_call_count,
+            "current_model": self.current_model,
+            "model_attempts": self.model_attempts,
+            "compression_results": self.compression_results,
+            "run_trace": self.run_trace,
+            "stall_count": self.stall_count,
+            "last_progress_signature": self.last_progress_signature,
+            "context_snapshot": self.context_snapshot,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "Checkpoint":
+        return cls(
+            task_id=d.get("task_id", ""),
+            iteration=int(d.get("iteration", 0) or 0),
+            messages=list(d.get("messages", []) or []),
+            current_step=d.get("current_step", ""),
+            created_at=d.get("created_at", ""),
+            metadata=dict(d.get("metadata", {}) or {}),
+            steps=list(d.get("steps", []) or []),
+            tool_call_count=int(d.get("tool_call_count", 0) or 0),
+            current_model=d.get("current_model", ""),
+            model_attempts=list(d.get("model_attempts", []) or []),
+            compression_results=list(d.get("compression_results", []) or []),
+            run_trace=list(d.get("run_trace", []) or []),
+            stall_count=int(d.get("stall_count", 0) or 0),
+            last_progress_signature=d.get("last_progress_signature", ""),
+            context_snapshot=(
+                dict(d.get("context_snapshot", {}) or {})
+                if isinstance(d.get("context_snapshot", {}) or {}, dict)
+                else {}
+            ),
+        )
+
+
+class CheckpointStore:
+    """基于 SessionStore 持久化 checkpoint。"""
+
+    def __init__(self, session_store):
+        self.session_store = session_store
+        self._lock = threading.RLock()
+
+    def save(self, checkpoint: Checkpoint) -> Path | None:
+        store = self.session_store
+        if store is None or not hasattr(store, "_atomic_write"):
+            return None
+        try:
+            path = store._find_path_by_task_id(checkpoint.task_id)
+        except Exception:
+            return None
+        if path is None:
+            return None
+        try:
+            payload = store._load_path(path) or {}
+        except Exception:
+            return None
+        payload["checkpoint"] = checkpoint.to_dict()
+        try:
+            store._atomic_write(path, payload)
+            return path
+        except Exception:
+            return None
+
+    def load(self, task_id: str) -> Checkpoint | None:
+        store = self.session_store
+        if store is None or not hasattr(store, "_atomic_write"):
+            return None
+        try:
+            path = store._find_path_by_task_id(task_id)
+        except Exception:
+            return None
+        if path is None:
+            return None
+        try:
+            payload = store._load_path(path) or {}
+        except Exception:
+            return None
+        cp = payload.get("checkpoint")
+        if not cp:
+            return None
+        return Checkpoint.from_dict(cp)
+
+    def clear(self, task_id: str) -> bool:
+        store = self.session_store
+        if store is None or not hasattr(store, "_atomic_write"):
+            return False
+        try:
+            path = store._find_path_by_task_id(task_id)
+        except Exception:
+            return False
+        if path is None:
+            return False
+        try:
+            payload = store._load_path(path) or {}
+        except Exception:
+            return False
+        payload.pop("checkpoint", None)
+        try:
+            store._atomic_write(path, payload)
+            return True
+        except Exception:
+            return False

package/runtime/orchestration/runtime/error_policy.py

@@ -0,0 +1,55 @@
+"""错误策略 —— 集中管理 fail/retry/escalate/continue 决策。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+class ErrorAction(str, Enum):
+    FAIL = "fail"  # 中止
+    RETRY = "retry"  # 重试
+    ESCALATE = "escalate"  # 升级到父级
+    CONTINUE = "continue"  # 跳过本步
+
+
+@dataclass
+class ErrorContext:
+    error_class: str
+    error_message: str
+    consecutive_failures: int
+    attempt: int
+    max_attempts: int
+
+
+@dataclass
+class ErrorDecision:
+    action: ErrorAction
+    delay_seconds: float = 0.0
+    reason: str = ""
+
+
+class ErrorPolicy:
+    """决定遇到错误时的下一步动作。"""
+
+    def __init__(self, strategy: str = "fail", max_retries: int = 2, base_delay: float = 1.0):
+        self.strategy = strategy
+        self.max_retries = max_retries
+        self.base_delay = base_delay
+
+    def decide(self, ctx: ErrorContext) -> ErrorDecision:
+        if self.strategy == "fail":
+            return ErrorDecision(ErrorAction.FAIL, reason="strategy=fail")
+        if self.strategy == "continue":
+            return ErrorDecision(ErrorAction.CONTINUE, reason="strategy=continue")
+        if self.strategy == "escalate":
+            if ctx.consecutive_failures >= 1:
+                return ErrorDecision(ErrorAction.ESCALATE, reason="escalate after first failure")
+            return ErrorDecision(ErrorAction.RETRY, delay_seconds=self.base_delay, reason="first failure → retry before escalate")
+        if self.strategy == "retry":
+            if ctx.attempt >= ctx.max_attempts:
+                return ErrorDecision(ErrorAction.FAIL, reason=f"max_attempts {ctx.max_attempts} reached")
+            delay = self.base_delay * (2 ** ctx.attempt)
+            return ErrorDecision(ErrorAction.RETRY, delay_seconds=delay, reason=f"attempt {ctx.attempt+1}/{ctx.max_attempts}")
+        return ErrorDecision(ErrorAction.FAIL, reason=f"unknown strategy {self.strategy}")

package/runtime/orchestration/runtime/events.py

@@ -0,0 +1,92 @@
+"""Runtime event bus for Supervisor/Worker observability."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Callable
+import uuid
+
+
+@dataclass
+class RuntimeEvent:
+    type: str
+    source: str
+    payload: dict[str, Any] = field(default_factory=dict)
+    event_id: str = field(default_factory=lambda: uuid.uuid4().hex)
+    created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "event_id": self.event_id,
+            "created_at": self.created_at,
+            "type": self.type,
+            "source": self.source,
+            "payload": dict(self.payload or {}),
+        }
+
+
+def runtime_events_to_dicts(events: list[Any] | None) -> list[dict[str, Any]]:
+    result: list[dict[str, Any]] = []
+    for event in events or []:
+        if hasattr(event, "to_dict"):
+            result.append(event.to_dict())
+        elif isinstance(event, dict):
+            result.append(dict(event))
+    return result
+
+
+class RuntimeEventBus:
+    def __init__(self):
+        self._events: list[RuntimeEvent] = []
+        self._subscribers: list[Callable[[RuntimeEvent], None]] = []
+
+    def publish(self, event_type: str, source: str, **payload: Any) -> RuntimeEvent:
+        event = RuntimeEvent(type=event_type, source=source, payload=payload)
+        self._events.append(event)
+        for subscriber in list(self._subscribers):
+            subscriber(event)
+        return event
+
+    def subscribe(self, callback: Callable[[RuntimeEvent], None], run_id: str | None = None) -> Callable[[], None]:
+        """订阅事件；传入 run_id 时只接收该运行的事件。"""
+        subscribed_callback = callback
+        if run_id:
+            def subscribed_callback(event: RuntimeEvent) -> None:
+                if event.payload.get("run_id") == run_id:
+                    callback(event)
+        self._subscribers.append(subscribed_callback)
+        removed = False
+
+        def unsubscribe() -> None:
+            nonlocal removed
+            if removed:
+                return
+            removed = True
+            try:
+                self._subscribers.remove(subscribed_callback)
+            except ValueError:
+                pass
+
+        return unsubscribe
+
+    def unsubscribe(self, callback: Callable[[RuntimeEvent], None]) -> None:
+        try:
+            self._subscribers.remove(callback)
+        except ValueError:
+            pass
+
+    def list_events(self) -> list[RuntimeEvent]:
+        return list(self._events)
+
+    def replay(self, callback: Callable[[RuntimeEvent], None], run_id: str | None = None) -> None:
+        """向后续加入的订阅者回放历史事件，可按 run_id 隔离。"""
+        for event in list(self._events):
+            if not run_id or event.payload.get("run_id") == run_id:
+                callback(event)
+
+    def list_events(self, run_id: str | None = None) -> list[RuntimeEvent]:
+        """返回事件；指定 run_id 时隔离不同运行。"""
+        if not run_id:
+            return list(self._events)
+        return [event for event in self._events if event.payload.get("run_id") == run_id]