loopy-loop 0.2.0__py3-none-any.whl

loopy_loop/harness_runner.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Iterable
+import inspect
+import json
+from pathlib import Path
+import traceback
+from typing import Callable
+from typing import Protocol
+
+from team_harness import TeamHarness
+from team_harness import TeamHarnessError
+from team_harness import TeamHarnessResult
+
+from loopy_loop.config import ConfigError
+from loopy_loop.config import normalize_api_base
+from loopy_loop.config import resolve_api_key
+from loopy_loop.config import RootConfig
+from loopy_loop.models import IterationResult
+from loopy_loop.models import RootConfigSnapshot
+from loopy_loop.sessions import HARNESS_RUN_ID_FILENAME
+from loopy_loop.sessions import PROMPT_FILENAME
+from loopy_loop.sessions import RESULT_FILENAME
+from loopy_loop.sessions import RESULT_TEXT_FILENAME
+
+
+class TeamHarnessLike(Protocol):
+    async def run(self, task: str) -> TeamHarnessResult: ...
+
+
+def run_harness_iteration(
+    *,
+    repo_root: Path,
+    config_snapshot: RootConfigSnapshot,
+    rendered_prompt: str,
+    harness_output_root: Path | None = None,
+    harness_factory: Callable[..., TeamHarnessLike] = TeamHarness,
+) -> IterationResult:
+    root_config = RootConfig.model_validate(
+        config_snapshot.model_dump(exclude={"goal_hash"})
+    )
+    resolved_api_key = resolve_api_key(config=root_config)
+    harness_kwargs = _build_harness_kwargs(
+        repo_root=repo_root,
+        config_snapshot=config_snapshot,
+        resolved_api_key=resolved_api_key,
+        harness_output_root=harness_output_root,
+        harness_factory=harness_factory,
+    )
+    harness = harness_factory(**harness_kwargs)
+    try:
+        result = asyncio.run(harness.run(task=rendered_prompt))
+    except ConfigError:
+        raise
+    except TeamHarnessError as exc:
+        traceback.print_exc()
+        harness_run_id, harness_output_dir = _failure_harness_paths(
+            detail=exc.detail, harness_output_root=harness_output_root
+        )
+        return IterationResult(
+            success=False,
+            text=None,
+            error=str(exc),
+            error_detail=exc.detail,
+            harness_run_id=harness_run_id,
+            harness_output_dir=harness_output_dir,
+        )
+    except Exception as exc:
+        traceback.print_exc()
+        return IterationResult(
+            success=False, text=None, error=str(exc), harness_run_id=""
+        )
+    return _normalize_harness_result(
+        result=result, harness_output_root=harness_output_root
+    )
+
+
+def _build_harness_kwargs(
+    *,
+    repo_root: Path,
+    config_snapshot: RootConfigSnapshot,
+    resolved_api_key: str | None,
+    harness_output_root: Path | None,
+    harness_factory: Callable[..., TeamHarnessLike],
+) -> dict[str, object]:
+    kwargs: dict[str, object] = {
+        "provider": config_snapshot.team_harness_provider,
+        "model": config_snapshot.team_harness_model,
+        "api_base": normalize_api_base(value=config_snapshot.team_harness_api_base),
+        "api_key": resolved_api_key,
+        "agents": config_snapshot.team_harness_agents,
+        "system_prompt": config_snapshot.team_harness_system_prompt_extension,
+        "cwd": str(repo_root),
+        "console_mode": "silent",
+    }
+    retry_kwargs = {
+        "max_retries": config_snapshot.team_harness_max_retries,
+        "retry_base_delay_s": config_snapshot.team_harness_retry_base_delay_s,
+        "retry_max_delay_s": config_snapshot.team_harness_retry_max_delay_s,
+    }
+    configured_retry_kwargs = {
+        key: value for key, value in retry_kwargs.items() if value is not None
+    }
+    if configured_retry_kwargs:
+        if _supports_kwargs(
+            harness_factory=harness_factory, names=configured_retry_kwargs.keys()
+        ):
+            kwargs.update(configured_retry_kwargs)
+        else:
+            raise ConfigError(
+                "Installed team-harness does not support coordinator retry "
+                "controls; upgrade team-harness or remove "
+                "team_harness_max_retries, team_harness_retry_base_delay_s, "
+                "and team_harness_retry_max_delay_s from loopy_loop_config.yaml."
+            )
+    agent_override_kwargs = {
+        "agent_models": config_snapshot.team_harness_agent_models,
+        "agent_reasoning_efforts": config_snapshot.team_harness_agent_reasoning_efforts,
+    }
+    if _supports_kwargs(
+        harness_factory=harness_factory, names=agent_override_kwargs.keys()
+    ):
+        kwargs.update(agent_override_kwargs)
+    elif any(agent_override_kwargs.values()):
+        raise ConfigError(
+            "Installed team-harness does not support per-agent model overrides; "
+            "upgrade team-harness or remove team_harness_agent_models and "
+            "team_harness_agent_reasoning_efforts from loopy_loop_config.yaml."
+        )
+    if harness_output_root is not None:
+        if _supports_kwargs(harness_factory=harness_factory, names=["output_dir"]):
+            kwargs["output_dir"] = str(harness_output_root)
+        else:
+            raise ConfigError(
+                "Installed team-harness does not support SDK output_dir; "
+                "upgrade team-harness."
+            )
+    return kwargs
+
+
+def _supports_kwargs(
+    *, harness_factory: Callable[..., TeamHarnessLike], names: Iterable[str]
+) -> bool:
+    signature = inspect.signature(harness_factory)
+    parameters = signature.parameters.values()
+    if any(parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in parameters):
+        return True
+    return all(name in signature.parameters for name in names)
+
+
+def _failure_harness_paths(
+    *, detail: dict[str, object] | None, harness_output_root: Path | None
+) -> tuple[str, str]:
+    if not detail:
+        return "", ""
+    run_id_value = detail.get("run_id")
+    output_dir_value = detail.get("session_output_dir")
+    run_id = run_id_value if isinstance(run_id_value, str) else ""
+    output_dir = output_dir_value if isinstance(output_dir_value, str) else ""
+    if not output_dir and run_id and harness_output_root is not None:
+        output_dir = str(harness_output_root / run_id)
+    return run_id, output_dir
+
+
+def write_iteration_artifacts(
+    *, iteration_dir: Path, rendered_prompt: str, iteration_result: IterationResult
+) -> None:
+    iteration_dir.mkdir(parents=True, exist_ok=True)
+    (iteration_dir / PROMPT_FILENAME).write_text(rendered_prompt, encoding="utf-8")
+    (iteration_dir / RESULT_TEXT_FILENAME).write_text(
+        iteration_result.text or "", encoding="utf-8"
+    )
+    (iteration_dir / HARNESS_RUN_ID_FILENAME).write_text(
+        iteration_result.harness_run_id, encoding="utf-8"
+    )
+    payload = iteration_result.model_dump()
+    (iteration_dir / RESULT_FILENAME).write_text(
+        json.dumps(payload, indent=2), encoding="utf-8"
+    )
+
+
+def _normalize_harness_result(
+    *, result: TeamHarnessResult, harness_output_root: Path | None = None
+) -> IterationResult:
+    harness_output_dir = ""
+    if harness_output_root is not None and result.run_id:
+        harness_output_dir = str(harness_output_root / result.run_id)
+    return IterationResult(
+        success=True,
+        text=result.text,
+        error=None,
+        harness_run_id=result.run_id,
+        harness_output_dir=harness_output_dir,
+    )

loopy_loop/models.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from datetime import datetime
+from datetime import UTC
+from typing import Literal
+from typing import Self
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from pydantic import Field
+from pydantic import field_validator
+from pydantic import model_validator
+
+DEFAULT_LOCK_TIMEOUT_SECONDS = 30.0
+CONTROL_SCHEMA_VERSION = 1
+GOAL_CHECK_SCHEMA_VERSION = 1
+RUN_ACTION = "run"
+STOP_ACTION = "stop"
+
+
+def utc_now() -> datetime:
+    return datetime.now(UTC).replace(microsecond=0)
+
+
+class RootConfigSnapshot(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    goal: str = Field(...)
+    goal_hash: str = Field(...)
+    workflow_set: str = Field(...)
+    completion_criteria: list[str] = Field(...)
+    stop_criteria: list[str] = Field(...)
+    max_turns: int = Field(...)
+    goal_check_consecutive_failures_cap: int = Field(...)
+    team_harness_provider: str = Field(...)
+    team_harness_model: str = Field(...)
+    team_harness_agents: list[str] = Field(...)
+    team_harness_agent_models: dict[str, str] = Field(default_factory=dict)
+    team_harness_agent_reasoning_efforts: dict[str, str] = Field(default_factory=dict)
+    team_harness_max_retries: int | None = Field(default=None)
+    team_harness_retry_base_delay_s: float | None = Field(default=None)
+    team_harness_retry_max_delay_s: float | None = Field(default=None)
+    team_harness_api_base: str = Field(...)
+    team_harness_api_key_env: str = Field(...)
+    team_harness_system_prompt_extension: str = Field(...)
+
+
+class CurrentTask(BaseModel):
+    workflow_set: str = Field(...)
+    workflow_id: str = Field(...)
+    session_id: str = Field(...)
+    iteration: int = Field(...)
+    started_at: datetime = Field(...)
+
+
+class TaskResponse(BaseModel):
+    action: Literal["run", "stop"] = Field(...)
+    workflow_set: str | None = Field(default=None)
+    workflow_id: str | None = Field(default=None)
+    session_id: str | None = Field(default=None)
+    iteration: int | None = Field(default=None)
+    config_snapshot: RootConfigSnapshot | None = Field(default=None)
+    stop_reason: str | None = Field(default=None)
+
+
+class HistoryEntry(BaseModel):
+    iteration: int = Field(...)
+    workflow_set: str = Field(...)
+    workflow_id: str = Field(...)
+    session_id: str = Field(...)
+    success: bool = Field(...)
+    error: str | None = Field(default=None)
+    started_at: datetime = Field(...)
+    finished_at: datetime = Field(...)
+
+
+class LoopState(BaseModel):
+    status: Literal["running", "stopped", "goal_met", "failed", "max_turns"] = Field(
+        default="running"
+    )
+    goal_hash: str = Field(...)
+    workflow_set: str = Field(...)
+    parent_session_id: str | None = Field(default=None)
+    max_turns: int = Field(...)
+    active_session_id: str = Field(...)
+    goal_met: bool = Field(default=False)
+    stop_requested: bool = Field(default=False)
+    unresolvable_error: bool = Field(default=False)
+    stop_reason: str | None = Field(default=None)
+    iteration_count: int = Field(default=0)
+    goal_check_consecutive_failures: int = Field(default=0)
+    current_task: CurrentTask | None = Field(default=None)
+    history: list[HistoryEntry] = Field(default_factory=list)
+    config_snapshot: RootConfigSnapshot = Field(...)
+
+
+class FinishedRequest(BaseModel):
+    workflow_id: str = Field(...)
+    session_id: str = Field(...)
+    iteration: int = Field(...)
+    success: bool = Field(...)
+    text: str | None = Field(default=None)
+    error: str | None = Field(default=None)
+
+
+class ControlSignal(BaseModel):
+    state: Literal["running", "stopped"] = Field(...)
+    reason: str = Field(...)
+    stop_reason: Literal["goal_met", "unresolvable_error"] | None = Field(default=None)
+    schema_version: int = Field(...)
+
+    @field_validator("schema_version")
+    @classmethod
+    def validate_schema_version(cls, value: int) -> int:
+        if value != CONTROL_SCHEMA_VERSION:
+            raise ValueError(f"schema_version must equal {CONTROL_SCHEMA_VERSION}")
+        return value
+
+    @model_validator(mode="after")
+    def validate_stop_reason(self) -> Self:
+        if self.state == "running" and self.stop_reason is not None:
+            raise ValueError("running control state must not set stop_reason")
+        if self.state == "stopped" and self.stop_reason is None:
+            raise ValueError("stopped control state must set stop_reason")
+        return self
+
+
+class GoalCheckSignal(BaseModel):
+    goal_met: bool = Field(...)
+    reason: str = Field(...)
+    schema_version: int = Field(default=GOAL_CHECK_SCHEMA_VERSION)
+
+
+class IterationResult(BaseModel):
+    success: bool = Field(...)
+    text: str | None = Field(default=None)
+    error: str | None = Field(default=None)
+    error_detail: dict[str, object] | None = Field(default=None)
+    harness_run_id: str = Field(default="")
+    harness_output_dir: str = Field(default="")
+
+
+class ChildSessionRequest(BaseModel):
+    workflow_set: str = Field(...)
+    goal: str = Field(...)
+    schema_version: int = Field(default=1)
+
+    @field_validator("schema_version")
+    @classmethod
+    def validate_schema_version(cls, value: int) -> int:
+        if value != 1:
+            raise ValueError("schema_version must equal 1")
+        return value
+
+
+class ChildSessionRecord(BaseModel):
+    session_id: str = Field(...)
+    workflow_set: str = Field(...)
+    goal_hash: str = Field(...)
+    status: str = Field(...)
+    created_at: datetime = Field(...)
+    completed_at: datetime | None = Field(default=None)
+    stop_reason: str | None = Field(default=None)

loopy_loop/scheduler.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+from loopy_loop.config import WorkflowDefinition
+from loopy_loop.models import HistoryEntry
+
+
+def choose_next_workflow(
+    *,
+    workflows: list[WorkflowDefinition],
+    history: list[HistoryEntry],
+    iteration_count: int,
+) -> WorkflowDefinition | None:
+    eligible: list[tuple[int, int, WorkflowDefinition]] = []
+    last_successful_workflow_id = _last_successful_workflow_id(history=history)
+    has_successful_history = any(entry.success for entry in history)
+    has_successful_non_goal_check = any(
+        entry.success and entry.workflow_id != "goal_check" for entry in history
+    )
+
+    for workflow in workflows:
+        if not _workflow_eligible(
+            workflow=workflow,
+            history=history,
+            iteration_count=iteration_count,
+            last_successful_workflow_id=last_successful_workflow_id,
+            has_successful_history=has_successful_history,
+            has_successful_non_goal_check=has_successful_non_goal_check,
+            ignore_run_every=False,
+        ):
+            continue
+        eligible.append(
+            (
+                workflow.priority,
+                _workflow_score(
+                    workflow_id=workflow.id,
+                    history=history,
+                    iteration_count=iteration_count,
+                    run_every=workflow.run_every,
+                ),
+                workflow,
+            )
+        )
+
+    if not eligible:
+        return _failed_workflow_retry(
+            workflows=workflows,
+            history=history,
+            iteration_count=iteration_count,
+            last_successful_workflow_id=last_successful_workflow_id,
+            has_successful_history=has_successful_history,
+            has_successful_non_goal_check=has_successful_non_goal_check,
+        )
+    return max(eligible, key=lambda item: (item[0], item[1], item[2].id))[2]
+
+
+def _workflow_eligible(
+    *,
+    workflow: WorkflowDefinition,
+    history: list[HistoryEntry],
+    iteration_count: int,
+    last_successful_workflow_id: str | None,
+    has_successful_history: bool,
+    has_successful_non_goal_check: bool,
+    ignore_run_every: bool,
+) -> bool:
+    if not workflow.enabled:
+        return False
+    if iteration_count < workflow.not_before_iteration:
+        return False
+    if workflow.id == "goal_check" and not has_successful_non_goal_check:
+        return False
+    if (
+        workflow.must_follow is not None
+        and workflow.must_follow != last_successful_workflow_id
+    ):
+        return False
+    is_run_on_start = workflow.run_on_start and not has_successful_history
+    if (
+        workflow.run_after_successes is not None
+        and not is_run_on_start
+        and not _run_after_successes_satisfied(workflow=workflow, history=history)
+    ):
+        return False
+    if ignore_run_every:
+        return True
+    return _run_every_satisfied(
+        workflow_id=workflow.id,
+        history=history,
+        iteration_count=iteration_count,
+        run_every=workflow.run_every,
+    )
+
+
+def _failed_workflow_retry(
+    *,
+    workflows: list[WorkflowDefinition],
+    history: list[HistoryEntry],
+    iteration_count: int,
+    last_successful_workflow_id: str | None,
+    has_successful_history: bool,
+    has_successful_non_goal_check: bool,
+) -> WorkflowDefinition | None:
+    """Retry the latest failed workflow only when normal scheduling is stuck.
+
+    A failed run should not unlock downstream must_follow workflows, but it also
+    should not consume its own cadence slot so completely that the loop has no
+    recoverable next workflow. This fallback preserves the normal scheduling
+    pass and bypasses only run_every for the same workflow that just failed.
+    """
+    if not history or history[-1].success:
+        return None
+    workflow = next(
+        (
+            candidate
+            for candidate in workflows
+            if candidate.id == history[-1].workflow_id
+        ),
+        None,
+    )
+    if workflow is None:
+        return None
+    if not _workflow_eligible(
+        workflow=workflow,
+        history=history,
+        iteration_count=iteration_count,
+        last_successful_workflow_id=last_successful_workflow_id,
+        has_successful_history=has_successful_history,
+        has_successful_non_goal_check=has_successful_non_goal_check,
+        ignore_run_every=True,
+    ):
+        return None
+    return workflow
+
+
+def _last_successful_workflow_id(*, history: list[HistoryEntry]) -> str | None:
+    for entry in reversed(history):
+        if entry.success:
+            return entry.workflow_id
+    return None
+
+
+def _workflow_score(
+    *,
+    workflow_id: str,
+    history: list[HistoryEntry],
+    iteration_count: int,
+    run_every: int,
+) -> int:
+    last_entry = _last_entry_for_workflow(workflow_id=workflow_id, history=history)
+    if last_entry is None:
+        return 10**9
+    return (
+        _steps_since_last_run(
+            workflow_id=workflow_id, history=history, iteration_count=iteration_count
+        )
+        - run_every
+    )
+
+
+def _run_every_satisfied(
+    *,
+    workflow_id: str,
+    history: list[HistoryEntry],
+    iteration_count: int,
+    run_every: int,
+) -> bool:
+    last_entry = _last_entry_for_workflow(workflow_id=workflow_id, history=history)
+    if last_entry is None:
+        return True
+    return (
+        _steps_since_last_run(
+            workflow_id=workflow_id, history=history, iteration_count=iteration_count
+        )
+        >= run_every
+    )
+
+
+def _run_after_successes_satisfied(
+    *, workflow: WorkflowDefinition, history: list[HistoryEntry]
+) -> bool:
+    rule = workflow.run_after_successes
+    if rule is None:
+        return True
+    target_success_count = _successful_workflow_count(
+        workflow_id=rule.workflow_id, history=history
+    )
+    previous_target_success_count = _successful_target_count_at_last_candidate_success(
+        candidate_workflow_id=workflow.id,
+        target_workflow_id=rule.workflow_id,
+        history=history,
+    )
+    return target_success_count - previous_target_success_count >= rule.every
+
+
+def _successful_workflow_count(*, workflow_id: str, history: list[HistoryEntry]) -> int:
+    return sum(
+        1 for entry in history if entry.success and entry.workflow_id == workflow_id
+    )
+
+
+def _successful_target_count_at_last_candidate_success(
+    *, candidate_workflow_id: str, target_workflow_id: str, history: list[HistoryEntry]
+) -> int:
+    last_candidate_index: int | None = None
+    for index, entry in enumerate(history):
+        if entry.success and entry.workflow_id == candidate_workflow_id:
+            last_candidate_index = index
+    if last_candidate_index is None:
+        return 0
+    return sum(
+        1
+        for entry in history[: last_candidate_index + 1]
+        if entry.success and entry.workflow_id == target_workflow_id
+    )
+
+
+def _steps_since_last_run(
+    *, workflow_id: str, history: list[HistoryEntry], iteration_count: int
+) -> int:
+    last_entry = _last_entry_for_workflow(workflow_id=workflow_id, history=history)
+    if last_entry is None:
+        return iteration_count
+    return iteration_count - last_entry.iteration
+
+
+def _last_entry_for_workflow(
+    *, workflow_id: str, history: list[HistoryEntry]
+) -> HistoryEntry | None:
+    for entry in reversed(history):
+        if entry.workflow_id == workflow_id:
+            return entry
+    return None