steerdev 1.1.44__tar.gz → 1.1.46__tar.gz

{steerdev-1.1.44 → steerdev-1.1.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.1.44
+Version: 1.1.46
 Summary: Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting
 Project-URL: Homepage, https://github.com/pentoai/steerdev-agent
 Project-URL: Repository, https://github.com/pentoai/steerdev-agent

{steerdev-1.1.44 → steerdev-1.1.46}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerdev"
-version = "1.1.44"
+version = "1.1.46"
 description = "Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting"
 readme = "README.md"
 authors = [

{steerdev-1.1.44 → steerdev-1.1.46}/src/steerdev_agent/agent_loop.py

@@ -18,8 +18,9 @@ import asyncio
 import contextlib
 import signal
 import socket
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import httpx
 from loguru import logger
@@ -28,6 +29,7 @@ from rich.panel import Panel
 
 if TYPE_CHECKING:
     from steerdev_agent.api.agents import AgentsClient, ProjectAssignment
+    from steerdev_agent.prompt.builder import WaveContext
     from steerdev_agent.workspace.project_manager import ProjectManager
 
 from steerdev_agent.api.commands import CommandResponse, CommandsClient
@@ -54,6 +56,15 @@ class AgentLoopError(Exception):
     """Error during agent loop execution."""
 
 
+@dataclass
+class _WavePrTracking:
+    """Per-project wave PR safety-net state (mirrors Runner.run's tracking)."""
+
+    wave_ctx: WaveContext
+    completed_tasks: list[dict[str, Any]] = field(default_factory=list)
+    working_dir: str | None = None
+
+
 # ---------------------------------------------------------------------------
 # Shared execution logic
 # ---------------------------------------------------------------------------
@@ -92,6 +103,7 @@ class CommandExecutor:
     _commands_succeeded: int
     _commands_failed: int
     _is_busy: bool
+    _wave_pr_state: dict[str, _WavePrTracking]
 
     async def _execute_command(
         self,
@@ -273,6 +285,90 @@ class CommandExecutor:
             finally:
                 await runs_client.close()
 
+        # Wave PR safety net (mirrors Runner.run): once the wave has no more
+        # pending tasks, make sure its PR exists.
+        await self._maybe_ensure_wave_pr(
+            project_id,
+            task,
+            wave_ctx,
+            result,
+            fallback_working_dir=str(command.working_directory or working_directory),
+        )
+
+    async def _maybe_ensure_wave_pr(
+        self,
+        project_id: str,
+        task: dict[str, Any],
+        wave_ctx: WaveContext | None,
+        result: dict[str, Any],
+        fallback_working_dir: str,
+    ) -> None:
+        """Track completed wave tasks across commands and create the wave PR.
+
+        Command-driven counterpart of Runner.run's wave PR safety net: each
+        command executes a single task, so wave completion is detected by
+        peeking at the wave queue after every successful wave task — no task
+        left (or scheduling moved to a different wave) means the wave is done
+        and its PR must exist. Best-effort: never raises.
+        """
+        if wave_ctx is None or not result.get("success"):
+            return
+
+        from steerdev_agent.runner import extract_task_and_wave_context, wave_identity
+
+        try:
+            state = self._wave_pr_state.get(project_id)
+            if state is not None and wave_identity(state.wave_ctx) != wave_identity(wave_ctx):
+                # Scheduling moved on to a new wave: the tracked one completed.
+                self._flush_wave_pr(project_id, fallback_working_dir)
+                state = None
+            if state is None:
+                state = _WavePrTracking(wave_ctx=wave_ctx)
+                self._wave_pr_state[project_id] = state
+            state.completed_tasks.append({"id": task.get("id"), "title": task.get("title")})
+            if result.get("working_dir"):
+                state.working_dir = result["working_dir"]
+
+            try:
+                with TasksClient(api_key=self._api_key) as tasks_client:
+                    wave_response = tasks_client.get_next_wave(
+                        project_id=project_id, agent_id=self._agent_id
+                    )
+                next_task, next_wave_ctx, _ = extract_task_and_wave_context(wave_response)
+            except Exception:
+                logger.debug("Wave PR safety net: wave peek failed, skipping", exc_info=True)
+                return
+
+            if (
+                next_task is None
+                or next_wave_ctx is None
+                or wave_identity(next_wave_ctx) != wave_identity(wave_ctx)
+            ):
+                self._flush_wave_pr(project_id, fallback_working_dir)
+        except Exception:  # broad catch intentional: safety net must never break the loop
+            logger.warning("Wave PR safety net failed (non-fatal)", exc_info=True)
+
+    def _flush_wave_pr(self, project_id: str, fallback_working_dir: str) -> None:
+        """Create the tracked wave's PR if the agent didn't. Never raises."""
+        state = self._wave_pr_state.pop(project_id, None)
+        if state is None:
+            return
+        try:
+            from steerdev_agent.git.pr import ensure_wave_pr
+
+            status = ensure_wave_pr(
+                state.working_dir or fallback_working_dir,
+                state.wave_ctx,
+                state.completed_tasks,
+                api_key=self._api_key,
+            )
+            if status == "created":
+                console.print("[green]Wave PR created (safety net)[/green]")
+            else:
+                logger.info(f"Wave PR safety net: {status}")
+        except Exception:  # broad catch intentional: safety net must never break the loop
+            logger.warning("Wave PR safety net failed (non-fatal)", exc_info=True)
+
     async def _execute_prompt_command(
         self,
         command: CommandResponse,
@@ -530,6 +626,7 @@ class AgentLoop(CommandExecutor):
         self._commands_executed = 0
         self._commands_succeeded = 0
         self._commands_failed = 0
+        self._wave_pr_state: dict[str, _WavePrTracking] = {}
 
         # Components
         self._commands_client: CommandsClient | None = None
@@ -921,6 +1018,7 @@ class WorkspaceAgentLoop(CommandExecutor):
         self._commands_executed = 0
         self._commands_succeeded = 0
         self._commands_failed = 0
+        self._wave_pr_state: dict[str, _WavePrTracking] = {}
 
         # Components
         self._commands_client: CommandsClient | None = None

{steerdev-1.1.44 → steerdev-1.1.46}/src/steerdev_agent/cli.py

@@ -1654,6 +1654,18 @@ def run(
             envvar="STEERDEV_AGENT_ID",
         ),
     ] = None,
+    provider: Annotated[
+        str | None,
+        typer.Option(
+            "--provider",
+            help=(
+                "AI provider / executor type to run tasks with (e.g. claude)."
+                " Overrides steerdev.yaml executor.type."
+                " Reads from STEERDEV_PROVIDER env var."
+            ),
+            envvar="STEERDEV_PROVIDER",
+        ),
+    ] = None,
     model: Annotated[
         str | None,
         typer.Option(
@@ -1815,7 +1827,11 @@ def run(
         steerdev run --project-id abc123 --workflow-id wf-abc123
         steerdev run --config custom.yaml --project-id abc123
     """
-    from steerdev_agent.runner import resolve_max_tasks, run_agent
+    from steerdev_agent.runner import (
+        resolve_executor_config,
+        resolve_max_tasks,
+        run_agent,
+    )
 
     # Get config from context (loaded in app callback)
     config: SteerDevConfig = ctx.obj or SteerDevConfig()
@@ -1844,6 +1860,12 @@ def run(
     resolved_evidence_config = config.evidence.model_copy()
     if evidence is not None:
         resolved_evidence_config.enabled = evidence
+    # Resolve executor config: --provider/STEERDEV_PROVIDER overrides executor.type
+    try:
+        resolved_executor_config = resolve_executor_config(config.executor, provider)
+    except ValueError as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1) from e
 
     # API key: CLI > env (via envvar) > config env var
     resolved_api_key = api_key
@@ -1875,6 +1897,7 @@ def run(
             f"Project ID: {resolved_project_id}\n"
             f"Agent Name: {agent_name_display}\n"
             f"Working Directory: {working_dir or 'current'}\n"
+            f"Provider: {resolved_executor_config.type}\n"
             f"Model: {resolved_model or 'default'}\n"
             f"Max Tasks: {max_tasks_display}\n"
             f"Timeout: {resolved_timeout}s\n"
@@ -1921,6 +1944,7 @@ def run(
                 enable_canals=canals,
                 worktree_config=resolved_worktree_config,
                 evidence_config=resolved_evidence_config,
+                executor_config=resolved_executor_config,
                 force_workflow_id=resolved_workflow_id,
                 dry_run=dry_run,
                 retry_config=retry_config,

{steerdev-1.1.44 → steerdev-1.1.46}/src/steerdev_agent/executor/__init__.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from steerdev_agent.config.models import ExecutorConfig
 
 __all__ = [
+    "SUPPORTED_EXECUTOR_TYPES",
     "AgentExecutor",
     "ClaudeExecutor",
     "ExecutorFactory",
@@ -19,6 +20,10 @@ __all__ = [
     "StreamParser",
 ]
 
+# Executor types ExecutorFactory can build. `steerdev run --provider` and
+# steerdev.yaml's executor.type are validated against this.
+SUPPORTED_EXECUTOR_TYPES: tuple[str, ...] = ("claude",)
+
 
 class ExecutorFactory:
     """Factory for creating agent executors based on configuration."""
@@ -62,4 +67,7 @@ class ExecutorFactory:
                 extra_args=config.args or None,
             )
 
-        raise ValueError(f"Unsupported executor type: {config.type}")
+        raise ValueError(
+            f"Unsupported executor type: {config.type} "
+            f"(supported: {', '.join(SUPPORTED_EXECUTOR_TYPES)})"
+        )

{steerdev-1.1.44 → steerdev-1.1.46}/src/steerdev_agent/runner.py

@@ -26,7 +26,7 @@ from steerdev_agent.config.models import (
     RetryConfig,
     WorktreeConfig,
 )
-from steerdev_agent.executor import ExecutorFactory
+from steerdev_agent.executor import SUPPORTED_EXECUTOR_TYPES, ExecutorFactory
 from steerdev_agent.executor.base import AgentExecutor, EventType, StreamEvent
 from steerdev_agent.executor.claude import ClaudeExecutorError
 from steerdev_agent.git.commit import commit_task_boundary
@@ -165,6 +165,29 @@ def resolve_max_tasks(max_tasks: int | None, wave_id: str | None) -> int:
     return 0 if wave_id else 1
 
 
+def resolve_executor_config(
+    base: ExecutorConfig,
+    provider: str | None,
+) -> ExecutorConfig:
+    """Resolve the effective executor config for a run.
+
+    - `provider` (from --provider / STEERDEV_PROVIDER) overrides the config
+      file's executor.type; None keeps it.
+    - The resolved type is validated against SUPPORTED_EXECUTOR_TYPES so an
+      unsupported provider fails fast (before task claiming), not deep inside
+      ExecutorFactory mid-run.
+    """
+    resolved = base.model_copy()
+    if provider is not None:
+        resolved.type = provider
+    if resolved.type not in SUPPORTED_EXECUTOR_TYPES:
+        raise ValueError(
+            f"Unsupported provider: {resolved.type} "
+            f"(supported: {', '.join(SUPPORTED_EXECUTOR_TYPES)})"
+        )
+    return resolved
+
+
 def resolve_merge_flow(
     waves_enabled: bool,
     canals_enabled: bool,

steerdev-1.1.46/tests/test_agent_loop_wave_pr.py

@@ -0,0 +1,180 @@
+"""Tests for the agent loop's wave PR safety net (command-driven counterpart
+of the runner's Runner.run safety net)."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from steerdev_agent.agent_loop import AgentLoop, _WavePrTracking
+from tests.test_runner_merge_modes import _make_wave_context
+
+
+def _make_loop() -> AgentLoop:
+    return AgentLoop(project_id="p", agent_name="a", api_key="k")
+
+
+def _make_wave_response(wave_name: str = "wave-a1b2c3", next_task: dict | None = None) -> dict:
+    return {
+        "wave": {"wave_number": 3, "total_waves": 5, "name": wave_name},
+        "context": {"next_task": next_task},
+    }
+
+
+def _patch_wave_peek(wave_response):
+    """Patch TasksClient so get_next_wave returns the given response."""
+    client = MagicMock()
+    client.__enter__.return_value = client
+    client.get_next_wave.return_value = wave_response
+    return patch("steerdev_agent.agent_loop.TasksClient", return_value=client)
+
+
+class TestMaybeEnsureWavePr:
+    @pytest.mark.asyncio
+    async def test_noop_without_wave_context(self):
+        loop = _make_loop()
+        with patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure:
+            await loop._maybe_ensure_wave_pr("p", {"id": "t1"}, None, {"success": True}, "/repo")
+        ensure.assert_not_called()
+        assert loop._wave_pr_state == {}
+
+    @pytest.mark.asyncio
+    async def test_noop_on_failed_task(self):
+        loop = _make_loop()
+        with patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure:
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1"}, _make_wave_context(), {"success": False}, "/repo"
+            )
+        ensure.assert_not_called()
+        assert loop._wave_pr_state == {}
+
+    @pytest.mark.asyncio
+    async def test_accumulates_while_wave_has_pending_tasks(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        # Peek returns another task in the same wave → wave not done yet.
+        peek = _make_wave_response(next_task={"id": "t2", "title": "next"})
+        with (
+            _patch_wave_peek(peek),
+            patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "do work"}, ctx, {"success": True}, "/repo"
+            )
+        ensure.assert_not_called()
+        assert loop._wave_pr_state["p"].completed_tasks == [{"id": "t1", "title": "do work"}]
+
+    @pytest.mark.asyncio
+    async def test_creates_pr_when_wave_exhausted(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        with (
+            _patch_wave_peek(None),
+            patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p",
+                {"id": "t1", "title": "do work"},
+                ctx,
+                {"success": True, "working_dir": "/repo/.worktrees/wave-a1b2c3"},
+                "/repo",
+            )
+        ensure.assert_called_once_with(
+            "/repo/.worktrees/wave-a1b2c3",
+            ctx,
+            [{"id": "t1", "title": "do work"}],
+            api_key="k",
+        )
+        # State is reset so the next wave starts clean.
+        assert loop._wave_pr_state == {}
+
+    @pytest.mark.asyncio
+    async def test_creates_pr_when_scheduling_moves_to_next_wave(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        peek = _make_wave_response(wave_name="wave-next", next_task={"id": "t9"})
+        with (
+            _patch_wave_peek(peek),
+            patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "do work"}, ctx, {"success": True}, "/repo"
+            )
+        ensure.assert_called_once()
+        assert loop._wave_pr_state == {}
+
+    @pytest.mark.asyncio
+    async def test_flushes_previous_wave_when_new_wave_task_completes(self):
+        loop = _make_loop()
+        old_ctx = _make_wave_context()
+        new_ctx = _make_wave_context()
+        new_ctx.wave_name = "wave-next"
+        loop._wave_pr_state["p"] = _WavePrTracking(
+            wave_ctx=old_ctx, completed_tasks=[{"id": "t0", "title": "old"}]
+        )
+        # Peek says the new wave still has tasks → only the old wave flushes.
+        peek = _make_wave_response(wave_name="wave-next", next_task={"id": "t9"})
+        with (
+            _patch_wave_peek(peek),
+            patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "new work"}, new_ctx, {"success": True}, "/repo"
+            )
+        ensure.assert_called_once_with(
+            "/repo", old_ctx, [{"id": "t0", "title": "old"}], api_key="k"
+        )
+        assert loop._wave_pr_state["p"].wave_ctx is new_ctx
+        assert loop._wave_pr_state["p"].completed_tasks == [{"id": "t1", "title": "new work"}]
+
+    @pytest.mark.asyncio
+    async def test_peek_failure_keeps_state_and_skips(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        with (
+            patch("steerdev_agent.agent_loop.TasksClient", side_effect=RuntimeError("api down")),
+            patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure,
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "do work"}, ctx, {"success": True}, "/repo"
+            )
+        ensure.assert_not_called()
+        # Task is still tracked, so a later flush includes it.
+        assert loop._wave_pr_state["p"].completed_tasks == [{"id": "t1", "title": "do work"}]
+
+    @pytest.mark.asyncio
+    async def test_never_raises(self):
+        loop = _make_loop()
+        ctx = _make_wave_context()
+        with (
+            _patch_wave_peek(None),
+            patch("steerdev_agent.git.pr.ensure_wave_pr", side_effect=RuntimeError("boom")),
+        ):
+            await loop._maybe_ensure_wave_pr(
+                "p", {"id": "t1", "title": "do work"}, ctx, {"success": True}, "/repo"
+            )  # must not raise
+        assert loop._wave_pr_state == {}
+
+
+class TestFlushWavePr:
+    def test_noop_without_tracked_state(self):
+        loop = _make_loop()
+        with patch("steerdev_agent.git.pr.ensure_wave_pr") as ensure:
+            loop._flush_wave_pr("p", "/repo")
+        ensure.assert_not_called()
+
+    def test_falls_back_to_command_working_dir(self):
+        loop = _make_loop()
+        loop._wave_pr_state["p"] = _WavePrTracking(wave_ctx=_make_wave_context())
+        with patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created") as ensure:
+            loop._flush_wave_pr("p", "/repo")
+        assert ensure.call_args.args[0] == "/repo"
+        assert loop._wave_pr_state == {}
+
+    def test_state_is_per_project(self):
+        loop = _make_loop()
+        loop._wave_pr_state["p1"] = _WavePrTracking(wave_ctx=_make_wave_context())
+        loop._wave_pr_state["p2"] = _WavePrTracking(wave_ctx=_make_wave_context())
+        with patch("steerdev_agent.git.pr.ensure_wave_pr", return_value="created"):
+            loop._flush_wave_pr("p1", "/repo")
+        assert "p1" not in loop._wave_pr_state
+        assert "p2" in loop._wave_pr_state

steerdev-1.1.46/tests/test_resolve_executor_config.py

@@ -0,0 +1,85 @@
+"""Tests for resolve_executor_config: the `steerdev run --provider` override.
+
+The sandbox bootstrap passes --provider "$STEERDEV_PROVIDER" so the web app
+can choose the executor per dispatch. Resolution: CLI/env > config file >
+default ("claude"). Unsupported providers must fail fast with a clear error,
+before any network or agent work starts.
+"""
+
+import pytest
+from typer.testing import CliRunner
+
+from steerdev_agent.cli import app
+from steerdev_agent.config.models import ExecutorConfig
+from steerdev_agent.executor import SUPPORTED_EXECUTOR_TYPES
+from steerdev_agent.runner import resolve_executor_config
+
+runner = CliRunner()
+
+
+def test_no_provider_keeps_config_type():
+    # Without --provider, the config file's executor.type is preserved.
+    base = ExecutorConfig(type="claude", permission_mode="plan")
+    resolved = resolve_executor_config(base, None)
+    assert resolved.type == "claude"
+    assert resolved.permission_mode == "plan"
+
+
+def test_provider_overrides_config_type():
+    resolved = resolve_executor_config(ExecutorConfig(), "claude")
+    assert resolved.type == "claude"
+
+
+def test_does_not_mutate_base_config():
+    base = ExecutorConfig()
+    resolve_executor_config(base, "claude")
+    assert base.type == "claude"
+    resolved = resolve_executor_config(base, "claude")
+    assert resolved is not base
+
+
+def test_unsupported_provider_raises_with_supported_list():
+    with pytest.raises(ValueError, match="codex"):
+        resolve_executor_config(ExecutorConfig(), "codex")
+    with pytest.raises(ValueError, match="claude"):
+        # The error must name the supported types so the sandbox log is actionable.
+        resolve_executor_config(ExecutorConfig(), "nonsense")
+
+
+def test_unsupported_config_type_raises_even_without_provider():
+    # A bad executor.type in steerdev.yaml should fail fast too, not deep in
+    # ExecutorFactory after task claiming.
+    with pytest.raises(ValueError, match="nonsense"):
+        resolve_executor_config(ExecutorConfig(type="nonsense"), None)
+
+
+def test_supported_types_include_claude():
+    assert "claude" in SUPPORTED_EXECUTOR_TYPES
+
+
+def test_cli_run_help_lists_provider():
+    result = runner.invoke(app, ["run", "--help"])
+    assert result.exit_code == 0
+    assert "--provider" in result.output
+
+
+def test_cli_run_rejects_unsupported_provider_before_running():
+    # Must exit non-zero with an actionable message, without contacting the API.
+    result = runner.invoke(
+        app,
+        ["run", "--project-id", "proj-x", "--provider", "nonsense"],
+    )
+    assert result.exit_code == 1
+    assert "nonsense" in result.output
+    assert "claude" in result.output
+
+
+def test_cli_run_reads_provider_from_env():
+    # The sandbox exports STEERDEV_PROVIDER; the option must honor it.
+    result = runner.invoke(
+        app,
+        ["run", "--project-id", "proj-x"],
+        env={"STEERDEV_PROVIDER": "nonsense"},
+    )
+    assert result.exit_code == 1
+    assert "nonsense" in result.output