steerdev 1.0.57__tar.gz → 1.0.59__tar.gz

{steerdev-1.0.57 → steerdev-1.0.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.0.57
+Version: 1.0.59
 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.0.57 → steerdev-1.0.59}/pyproject.toml

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

{steerdev-1.0.57 → steerdev-1.0.59}/src/steerdev_agent/agent_loop.py

@@ -126,6 +126,8 @@ class CommandExecutor:
                 await self._execute_task_command(command, project_id, working_directory)
             elif command.command_type == "prompt":
                 await self._execute_prompt_command(command, project_id, working_directory)
+            elif command.command_type == "merger":
+                await self._execute_merger_command(command, project_id, working_directory)
             else:
                 await self._commands_client.mark_failed(
                     command.id, error=f"Unknown command type: {command.command_type}"
@@ -403,6 +405,59 @@ class CommandExecutor:
         finally:
             await events_client.close()
 
+    async def _execute_merger_command(
+        self,
+        command: CommandResponse,
+        project_id: str,
+        working_directory: Path,
+    ) -> None:
+        """Execute a merger command - triggers merger run and polls for completion."""
+        from steerdev_agent.api.merger import MergerClient
+
+        assert self._commands_client is not None
+
+        merger_run_id = command.metadata.get("mergerRunId")
+        if not merger_run_id:
+            raise ValueError("merger command missing mergerRunId in metadata")
+
+        merger_client = MergerClient(api_key=self._api_key)
+
+        logger.info(f"Starting merger run: {merger_run_id}")
+
+        # Mark command as executing
+        await self._commands_client.mark_executing(command.id)
+
+        # Trigger execution
+        result = merger_client.execute_merger_run(merger_run_id)
+        if not result:
+            raise RuntimeError(f"Failed to trigger merger run {merger_run_id}")
+
+        # Poll for completion
+        max_polls = 60  # 30 minutes at 30s intervals
+        for _ in range(max_polls):
+            run = merger_client.get_merger_run(merger_run_id)
+            if not run:
+                raise RuntimeError("Failed to get merger run status")
+
+            if run.status in ("completed", "failed", "partial"):
+                logger.info(f"Merger run {merger_run_id} finished: {run.status}")
+                if run.status == "failed":
+                    raise RuntimeError(f"Merger run failed: {run.error_message}")
+                await self._commands_client.mark_completed(
+                    command.id,
+                    result=f"Merger run {merger_run_id} {run.status}",
+                )
+                self._commands_succeeded += 1
+                return
+
+            if self._shutdown_event.is_set():
+                logger.info("Shutdown during merger polling, aborting")
+                raise RuntimeError("Shutdown requested during merger run")
+
+            await asyncio.sleep(30)
+
+        raise RuntimeError(f"Merger run {merger_run_id} timed out")
+
 
 # ---------------------------------------------------------------------------
 # Project-scoped agent (original)

{steerdev-1.0.57 → steerdev-1.0.59}/src/steerdev_agent/api/commands.py

@@ -13,7 +13,7 @@ from steerdev_agent.api.client import get_agent_id, get_api_endpoint, get_api_ke
 
 console = Console()
 
-CommandType = Literal["task", "prompt", "control"]
+CommandType = Literal["task", "prompt", "control", "merger"]
 CommandStatus = Literal[
     "pending", "claimed", "executing", "completed", "failed", "cancelled", "expired"
 ]

steerdev-1.0.59/src/steerdev_agent/api/merger.py

@@ -0,0 +1,71 @@
+"""Merger API client for merger agent operations."""
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from steerdev_agent.api.client import SteerDevClient
+
+
+class MergerRunResponse(BaseModel):
+    id: str
+    status: str
+    wave_ids: list[str] = []
+    task_ids: list[str] = []
+    pr_ids: list[str] = []
+    evidence_report_ids: list[str] = []
+    summary: str | None = None
+    merged_branches: list[str] | None = None
+    error_message: str | None = None
+    started_at: str | None = None
+    completed_at: str | None = None
+
+
+class GateResponse(BaseModel):
+    id: str
+    merger_run_id: str
+    canal_id: str
+    gate_number: int
+    status: str
+    started_at: str | None = None
+    completed_at: str | None = None
+    details: dict[str, Any] | None = None
+    error_message: str | None = None
+
+
+class MergerClient(SteerDevClient):
+    """Client for merger agent API operations."""
+
+    def execute_merger_run(self, merger_run_id: str) -> dict[str, Any] | None:
+        """Trigger execution of a full merger run."""
+        response = self.post(f"/merger-runs/{merger_run_id}/execute")
+        if response and response.status_code == 200:
+            return response.json()
+        return None
+
+    def get_merger_run(self, merger_run_id: str) -> MergerRunResponse | None:
+        """Get merger run status."""
+        response = self.get(f"/merger-runs/{merger_run_id}")
+        if response and response.status_code == 200:
+            return MergerRunResponse(**response.json())
+        return None
+
+    def get_merger_gates(self, merger_run_id: str) -> list[GateResponse]:
+        """Get gate statuses for a merger run."""
+        response = self.get(f"/merger-runs/{merger_run_id}/gates")
+        if response and response.status_code == 200:
+            data = response.json()
+            return [GateResponse(**g) for g in data.get("gates", [])]
+        return []
+
+    def execute_gate(
+        self, canal_id: str, gate_number: int, merger_run_id: str, merge_id: str | None = None
+    ) -> dict[str, Any] | None:
+        """Trigger execution of a specific gate."""
+        payload: dict[str, Any] = {"merger_run_id": merger_run_id}
+        if merge_id:
+            payload["merge_id"] = merge_id
+        response = self.post(f"/canals/{canal_id}/gates/{gate_number}", json=payload)
+        if response and response.status_code == 200:
+            return response.json()
+        return None

steerdev-1.0.59/tests/test_workflow_runs_api.py

@@ -0,0 +1,358 @@
+"""Tests for workflow runs API client — models, start_workflow, and disabled-workflow handling."""
+
+import os
+from typing import Any
+from unittest.mock import AsyncMock, patch
+
+import httpx
+import pytest
+
+from steerdev_agent.api.workflow_runs import (
+    PhaseRunResponse,
+    WorkflowRunResponse,
+    WorkflowRunsClient,
+)
+
+# ── Shared fixtures ───────────────────────────────────────────────────────
+
+NOW = "2026-01-01T00:00:00Z"
+
+
+def _make_workflow_run_json(
+    *,
+    workflow_id: str = "wf-1",
+    workflow_name: str = "Feature Dev",
+    status: str = "running",
+    total_phases: int = 3,
+    **extra: Any,
+) -> dict[str, Any]:
+    return {
+        "id": "wr-1",
+        "workflow_id": workflow_id,
+        "workflow_name": workflow_name,
+        "status": status,
+        "total_phases": total_phases,
+        "created_at": NOW,
+        "updated_at": NOW,
+        **extra,
+    }
+
+
+# ── Model tests ───────────────────────────────────────────────────────────
+
+
+class TestWorkflowRunModels:
+    """Tests for Pydantic models in workflow_runs.py."""
+
+    def test_workflow_run_response_minimal(self):
+        resp = WorkflowRunResponse(
+            id="wr-1",
+            workflow_id="wf-1",
+            workflow_name="Test",
+            status="running",
+            created_at=NOW,
+            updated_at=NOW,
+        )
+        assert resp.id == "wr-1"
+        assert resp.project_id is None
+        assert resp.phase_runs is None
+        assert resp.phases_completed == 0
+        assert resp.total_phases == 0
+
+    def test_workflow_run_response_full(self):
+        resp = WorkflowRunResponse(
+            id="wr-1",
+            workflow_id="wf-1",
+            workflow_name="Feature Dev",
+            project_id="proj-1",
+            run_id="run-1",
+            linear_issue_id="LIN-123",
+            status="completed",
+            current_phase_id="p3",
+            current_phase_name="Verify",
+            context={"key": "value"},
+            phases_completed=3,
+            total_phases=3,
+            started_at=NOW,
+            completed_at=NOW,
+            created_at=NOW,
+            updated_at=NOW,
+        )
+        assert resp.phases_completed == 3
+        assert resp.context == {"key": "value"}
+        assert resp.linear_issue_id == "LIN-123"
+
+    def test_phase_run_response_minimal(self):
+        resp = PhaseRunResponse(
+            id="pr-1",
+            workflow_run_id="wr-1",
+            phase_id="p-1",
+            phase_name="Plan",
+            phase_type="plan",
+            status="pending",
+            created_at=NOW,
+            updated_at=NOW,
+        )
+        assert resp.attempt_number == 1
+        assert resp.input_context == {}
+        assert resp.result_summary is None
+
+    def test_phase_run_response_full(self):
+        resp = PhaseRunResponse(
+            id="pr-1",
+            workflow_run_id="wr-1",
+            phase_id="p-1",
+            phase_name="Implement",
+            phase_type="implement",
+            status="completed",
+            attempt_number=2,
+            input_context={"spec": "build API"},
+            output_context={"files": ["main.py"]},
+            result_summary="Implementation complete",
+            started_at=NOW,
+            completed_at=NOW,
+            created_at=NOW,
+            updated_at=NOW,
+        )
+        assert resp.attempt_number == 2
+        assert resp.output_context["files"] == ["main.py"]
+
+
+# ── Client tests ──────────────────────────────────────────────────────────
+
+
+class TestWorkflowRunsClient:
+    """Tests for WorkflowRunsClient."""
+
+    def test_init_with_api_key(self):
+        client = WorkflowRunsClient(api_key="test-key")
+        assert client.api_key == "test-key"
+
+    def test_init_from_env(self):
+        with patch.dict(os.environ, {"STEERDEV_API_KEY": "env-key"}):
+            client = WorkflowRunsClient()
+            assert client.api_key == "env-key"
+
+    def test_headers(self):
+        client = WorkflowRunsClient(api_key="test-key")
+        assert client.headers["Authorization"] == "Bearer test-key"
+
+    @pytest.mark.asyncio
+    async def test_context_manager(self):
+        async with WorkflowRunsClient(api_key="key") as client:
+            assert client.api_key == "key"
+        assert client._client is None
+
+    @pytest.mark.asyncio
+    async def test_close_without_client(self):
+        client = WorkflowRunsClient(api_key="key")
+        await client.close()  # Should not raise
+
+
+class TestStartWorkflow:
+    """Tests for start_workflow — including disabled-workflow (409) handling."""
+
+    @pytest.mark.asyncio
+    async def test_start_workflow_success(self):
+        """201 → returns WorkflowRunResponse."""
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(201, json=_make_workflow_run_json())
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.start_workflow("wf-1", run_id="run-1")
+        assert result is not None
+        assert result.id == "wr-1"
+        assert result.workflow_id == "wf-1"
+
+    @pytest.mark.asyncio
+    async def test_start_workflow_with_initial_context(self):
+        """Initial context is passed in the payload."""
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(201, json=_make_workflow_run_json())
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.start_workflow(
+            "wf-1",
+            initial_context={"task_title": "Fix login bug"},
+        )
+        assert result is not None
+        # Verify payload included initial_context
+        call_kwargs = mock_http.post.call_args
+        payload = call_kwargs.kwargs.get("json") or call_kwargs[1].get("json")
+        assert payload["initial_context"] == {"task_title": "Fix login bug"}
+
+    @pytest.mark.asyncio
+    async def test_start_workflow_server_error(self):
+        """500 → returns None."""
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(500, text="Internal Server Error")
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.start_workflow("wf-1")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_start_workflow_not_found(self):
+        """404 → returns None."""
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(
+            404,
+            json={"error": "Not Found", "message": "Workflow not found"},
+        )
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.start_workflow("wf-nonexistent")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_start_workflow_request_error(self):
+        """Network error → returns None."""
+        client = WorkflowRunsClient(api_key="key")
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(side_effect=httpx.RequestError("connection refused"))
+        client._client = mock_http
+
+        result = await client.start_workflow("wf-1")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_start_workflow_disabled_409_returns_none(self):
+        """409 with NO_ACTIVE_WORKFLOW → returns None (agent should proceed without workflow)."""
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(
+            409,
+            json={
+                "error": "Workflow disabled",
+                "message": "The requested workflow is disabled and no suitable active workflow was found.",
+                "code": "NO_ACTIVE_WORKFLOW",
+            },
+        )
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.start_workflow("wf-disabled")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_start_workflow_disabled_409_reassigned(self):
+        """409 that re-triaged to a different workflow → 201 with new workflow_id.
+
+        This tests the server-side behavior: the API transparently re-assigns
+        to the best active workflow. The client receives a normal 201 with the
+        new workflow's run.
+        """
+        client = WorkflowRunsClient(api_key="key")
+        # Server re-triaged to a different workflow
+        mock_response = httpx.Response(
+            201,
+            json=_make_workflow_run_json(
+                workflow_id="wf-fallback",
+                workflow_name="Bug Fix Workflow",
+            ),
+        )
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.start_workflow("wf-disabled-original")
+        assert result is not None
+        # The returned workflow_id is the re-assigned one, not the original
+        assert result.workflow_id == "wf-fallback"
+        assert result.workflow_name == "Bug Fix Workflow"
+
+
+class TestAdvancePhase:
+    """Tests for advance_phase."""
+
+    @pytest.mark.asyncio
+    async def test_advance_success(self):
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(
+            200,
+            json=_make_workflow_run_json(status="running"),
+        )
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.advance_phase("wr-1", output_context={"files": ["a.py"]})
+        assert result is not None
+        assert result.status == "running"
+
+    @pytest.mark.asyncio
+    async def test_advance_failure(self):
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(500, text="error")
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.advance_phase("wr-1")
+        assert result is None
+
+
+class TestFailPhase:
+    """Tests for fail_phase."""
+
+    @pytest.mark.asyncio
+    async def test_fail_phase_success(self):
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(
+            200,
+            json=_make_workflow_run_json(status="running"),
+        )
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.fail_phase("wr-1", error_message="compilation failed")
+        assert result is not None
+
+    @pytest.mark.asyncio
+    async def test_fail_phase_network_error(self):
+        client = WorkflowRunsClient(api_key="key")
+        mock_http = AsyncMock()
+        mock_http.post = AsyncMock(side_effect=httpx.RequestError("timeout"))
+        client._client = mock_http
+
+        result = await client.fail_phase("wr-1", error_message="oops")
+        assert result is None
+
+
+class TestCancelWorkflowRun:
+    """Tests for cancel_workflow_run."""
+
+    @pytest.mark.asyncio
+    async def test_cancel_success(self):
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(
+            200,
+            json=_make_workflow_run_json(status="cancelled"),
+        )
+        mock_http = AsyncMock()
+        mock_http.delete = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.cancel_workflow_run("wr-1")
+        assert result is not None
+        assert result.status == "cancelled"
+
+    @pytest.mark.asyncio
+    async def test_cancel_failure(self):
+        client = WorkflowRunsClient(api_key="key")
+        mock_response = httpx.Response(404, text="Not found")
+        mock_http = AsyncMock()
+        mock_http.delete = AsyncMock(return_value=mock_response)
+        client._client = mock_http
+
+        result = await client.cancel_workflow_run("wr-nonexistent")
+        assert result is None