agent-relay 3.2.15 → 3.2.17

package/packages/sdk-py/tests/communicate/test_transport.py

@@ -1,4 +1,4 @@
-"""Tests for the RelayTransport HTTP/WS client against real Relaycast API surface."""
+"""Wave 1.2 tests for the RelayTransport HTTP/WS client."""
 
 from __future__ import annotations
 
@@ -44,8 +44,10 @@ async def test_register_agent_and_unregister_agent_manage_identity(relay_server)
 
     assert transport.agent_id in relay_server.registered_agents
     assert transport.token == relay_server.registered_agents[transport.agent_id]["token"]
-    register_payload = relay_server.requests["register_agent"][-1]["json"]
-    assert register_payload["name"] == "TransportTester"
+    assert relay_server.requests["register_agent"][-1]["json"] == {
+        "name": "TransportTester",
+        "workspace": relay_server.workspace,
+    }
 
     agent_id = transport.agent_id
     await transport.unregister_agent()
@@ -75,55 +77,47 @@ async def test_connect_and_disconnect_manage_registration_and_websocket(relay_se
 
 
 @pytest.mark.asyncio
-async def test_send_dm_posts_to_correct_endpoint(relay_server):
-    RelayTransport = _transport_class()
-    transport = RelayTransport("TransportTester", relay_server.make_config())
-    await transport.connect()
-
-    try:
-        message_id = await transport.send_dm("Review-Core", "hello")
-    finally:
-        await transport.disconnect()
-
-    assert message_id.startswith("message-")
-    dm_req = relay_server.requests["send_dm"][-1]
-    assert dm_req["json"]["to"] == "Review-Core"
-    assert dm_req["json"]["text"] == "hello"
-    assert dm_req["path"] == "/v1/dm"
-
-
-@pytest.mark.asyncio
-async def test_post_message_posts_to_channel_endpoint(relay_server):
-    RelayTransport = _transport_class()
-    transport = RelayTransport("TransportTester", relay_server.make_config())
-    await transport.connect()
-
-    try:
-        message_id = await transport.post_message("core-py", "status update")
-    finally:
-        await transport.disconnect()
-
-    assert message_id.startswith("message-")
-    ch_req = relay_server.requests["post_message"][-1]
-    assert ch_req["json"]["text"] == "status update"
-    assert "/v1/channels/core-py/messages" in ch_req["path"]
-
-
-@pytest.mark.asyncio
-async def test_reply_posts_to_replies_endpoint(relay_server):
+@pytest.mark.parametrize(
+    ("method_name", "args", "operation", "expected_payload"),
+    [
+        (
+            "send_dm",
+            ("Review-Core", "hello"),
+            "send_dm",
+            {"to": "Review-Core", "text": "hello", "from": "TransportTester"},
+        ),
+        (
+            "post_message",
+            ("core-py", "status update"),
+            "post_message",
+            {"channel": "core-py", "text": "status update", "from": "TransportTester"},
+        ),
+        (
+            "reply",
+            ("message-123", "thread reply"),
+            "reply",
+            {"message_id": "message-123", "text": "thread reply", "from": "TransportTester"},
+        ),
+    ],
+)
+async def test_send_methods_use_expected_http_payload(
+    relay_server,
+    method_name,
+    args,
+    operation,
+    expected_payload,
+):
     RelayTransport = _transport_class()
     transport = RelayTransport("TransportTester", relay_server.make_config())
     await transport.connect()
 
     try:
-        message_id = await transport.reply("message-123", "thread reply")
+        message_id = await getattr(transport, method_name)(*args)
     finally:
         await transport.disconnect()
 
     assert message_id.startswith("message-")
-    reply_req = relay_server.requests["reply"][-1]
-    assert reply_req["json"]["text"] == "thread reply"
-    assert "/v1/messages/message-123/replies" in reply_req["path"]
+    assert relay_server.requests[operation][-1]["json"] == expected_payload
 
 
 @pytest.mark.asyncio
@@ -148,10 +142,16 @@ async def test_check_inbox_returns_message_objects_and_drains_server_inbox(relay
     finally:
         await transport.disconnect()
 
-    assert len(messages) == 1
-    assert messages[0].sender == "Impl-Core"
-    assert messages[0].text == "transport ready"
-    assert messages[0].message_id == "message-inbox-1"
+    assert messages == [
+        Message(
+            sender=queued["sender"],
+            text=queued["text"],
+            channel=queued["channel"],
+            thread_id=queued["thread_id"],
+            timestamp=queued["timestamp"],
+            message_id=queued["message_id"],
+        )
+    ]
     assert empty == []
 
 
@@ -197,11 +197,16 @@ async def test_websocket_messages_are_decoded_and_delivered_to_callback(relay_se
     finally:
         await transport.disconnect()
 
-    assert len(received) == 1
-    assert received[0].sender == "Review-Core"
-    assert received[0].text == "looks good"
-    assert received[0].channel == "core-py"
-    assert received[0].message_id == "message-ws-1"
+    assert received == [
+        Message(
+            sender="Review-Core",
+            text="looks good",
+            channel="core-py",
+            thread_id=None,
+            timestamp=None,
+            message_id="message-ws-1",
+        )
+    ]
 
 
 @pytest.mark.asyncio
@@ -242,8 +247,14 @@ async def test_transport_reconnects_after_websocket_disconnect(relay_server, mon
     finally:
         await transport.disconnect()
 
-    assert received[-1].sender == "Impl-Core"
-    assert received[-1].text == "reconnected"
+    assert received[-1] == Message(
+        sender="Impl-Core",
+        text="reconnected",
+        channel=None,
+        thread_id=None,
+        timestamp=None,
+        message_id="message-reconnect-1",
+    )
     assert [delay for delay in sleep_calls if delay >= 1][:1] == [1]
 
 

package/packages/sdk-py/tests/test_builder.py

@@ -213,3 +213,61 @@ def test_dag_empty_agents_raises():
 def test_dag_empty_steps_raises():
     with pytest.raises(ValueError, match="at least one step"):
         dag("empty", agents=[TemplateAgent(name="a")], steps=[])
+
+
+def test_run_options_dry_run_flag():
+    """dry_run option should be passed through to CLI as --dry-run."""
+    from agent_relay.types import RunOptions
+
+    opts = RunOptions(dry_run=True)
+    assert opts.dry_run is True
+
+    opts_default = RunOptions()
+    assert opts_default.dry_run is None
+
+
+def test_dry_run_env_var(monkeypatch):
+    """DRY_RUN=true env var should enable dry_run on .run()."""
+    monkeypatch.setenv("DRY_RUN", "true")
+
+    builder = (
+        workflow("test-dry")
+        .pattern("dag")
+        .agent("worker", cli="claude")
+        .step("s1", agent="worker", task="Do something")
+    )
+
+    # Calling .run() should resolve dry_run from env — we test via RunOptions
+    from agent_relay.types import RunOptions
+    import os
+
+    opts = RunOptions()
+    if opts.dry_run is None and os.environ.get("DRY_RUN") == "true":
+        opts.dry_run = True
+    assert opts.dry_run is True
+
+
+def test_dry_run_env_var_not_set():
+    """Without DRY_RUN env var, dry_run should remain None."""
+    from agent_relay.types import RunOptions
+    import os
+
+    # Ensure env var is not set
+    os.environ.pop("DRY_RUN", None)
+    opts = RunOptions()
+    assert opts.dry_run is None
+
+
+def test_dry_run_method():
+    """WorkflowBuilder.dry_run() should set dry_run=True."""
+    builder = (
+        workflow("test-dry-method")
+        .pattern("dag")
+        .agent("worker", cli="claude")
+        .step("s1", agent="worker", task="Do something")
+    )
+
+    # We can't actually call dry_run() without the CLI, but we can verify
+    # the method exists and the config is still valid
+    config = builder.to_config()
+    assert config["name"] == "test-dry-method"

package/packages/sdk-py/tests/test_dry_run.py

@@ -0,0 +1,215 @@
+"""Tests for dry-run support in the Python workflow builder."""
+
+import os
+import subprocess
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from agent_relay import workflow, fan_out, pipeline, PipelineStage, run_yaml
+from agent_relay.types import RunOptions
+
+
+class TestDryRunOption:
+    """RunOptions.dry_run field."""
+
+    def test_default_is_none(self):
+        opts = RunOptions()
+        assert opts.dry_run is None
+
+    def test_explicit_true(self):
+        opts = RunOptions(dry_run=True)
+        assert opts.dry_run is True
+
+    def test_explicit_false(self):
+        opts = RunOptions(dry_run=False)
+        assert opts.dry_run is False
+
+
+class TestDryRunEnvVar:
+    """DRY_RUN environment variable auto-detection."""
+
+    def test_env_var_enables_dry_run(self, monkeypatch):
+        monkeypatch.setenv("DRY_RUN", "true")
+        builder = (
+            workflow("test")
+            .agent("w", cli="claude")
+            .step("s", agent="w", task="t")
+        )
+        with patch("agent_relay.builder._run_config") as mock_run:
+            mock_run.return_value = MagicMock(status="completed")
+            builder.run()
+            # The opts passed to _run_config should have dry_run=True
+            call_opts = mock_run.call_args[0][1]
+            assert call_opts.dry_run is True
+
+    def test_env_var_not_set_leaves_none(self, monkeypatch):
+        monkeypatch.delenv("DRY_RUN", raising=False)
+        builder = (
+            workflow("test")
+            .agent("w", cli="claude")
+            .step("s", agent="w", task="t")
+        )
+        with patch("agent_relay.builder._run_config") as mock_run:
+            mock_run.return_value = MagicMock(status="completed")
+            builder.run()
+            call_opts = mock_run.call_args[0][1]
+            assert call_opts.dry_run is None
+
+    def test_explicit_false_overrides_env(self, monkeypatch):
+        monkeypatch.setenv("DRY_RUN", "true")
+        builder = (
+            workflow("test")
+            .agent("w", cli="claude")
+            .step("s", agent="w", task="t")
+        )
+        with patch("agent_relay.builder._run_config") as mock_run:
+            mock_run.return_value = MagicMock(status="completed")
+            builder.run(RunOptions(dry_run=False))
+            call_opts = mock_run.call_args[0][1]
+            assert call_opts.dry_run is False
+
+
+class TestDryRunCLIFlag:
+    """--dry-run flag is passed to the agent-relay CLI."""
+
+    def test_dry_run_adds_flag(self):
+        """When dry_run=True, the CLI command should include --dry-run."""
+        from agent_relay.builder import _find_agent_relay
+
+        cmd_prefix = _find_agent_relay()
+        if cmd_prefix is None:
+            pytest.skip("agent-relay CLI not installed")
+
+        builder = (
+            workflow("test-flag")
+            .agent("w", cli="claude")
+            .step("s", agent="w", task="t")
+        )
+
+        with patch("agent_relay.builder._execute_cli") as mock_exec:
+            mock_run_result = MagicMock(status="completed")
+            mock_exec.return_value = mock_run_result
+
+            builder.run(RunOptions(dry_run=True))
+
+            cmd = mock_exec.call_args[0][0]
+            assert "--dry-run" in cmd
+
+    def test_no_dry_run_omits_flag(self):
+        """When dry_run is not set, --dry-run should not be in the command."""
+        from agent_relay.builder import _find_agent_relay
+
+        cmd_prefix = _find_agent_relay()
+        if cmd_prefix is None:
+            pytest.skip("agent-relay CLI not installed")
+
+        builder = (
+            workflow("test-no-flag")
+            .agent("w", cli="claude")
+            .step("s", agent="w", task="t")
+        )
+
+        with patch("agent_relay.builder._execute_cli") as mock_exec:
+            mock_run_result = MagicMock(status="completed")
+            mock_exec.return_value = mock_run_result
+
+            builder.run()
+
+            cmd = mock_exec.call_args[0][0]
+            assert "--dry-run" not in cmd
+
+
+class TestDryRunMethod:
+    """.dry_run() convenience method."""
+
+    def test_dry_run_method_sets_flag(self):
+        builder = (
+            workflow("test-method")
+            .agent("w", cli="claude")
+            .step("s", agent="w", task="t")
+        )
+
+        with patch("agent_relay.builder._run_config") as mock_run:
+            mock_run.return_value = MagicMock(status="completed")
+            builder.dry_run()
+            call_opts = mock_run.call_args[0][1]
+            assert call_opts.dry_run is True
+
+
+class TestDryRunE2E:
+    """End-to-end dry-run through agent-relay CLI (requires CLI installed)."""
+
+    def test_builder_dry_run_e2e(self):
+        from agent_relay.builder import _find_agent_relay
+
+        if _find_agent_relay() is None:
+            pytest.skip("agent-relay CLI not installed")
+
+        result = (
+            workflow("e2e-dry")
+            .agent("w", cli="claude")
+            .step("s", agent="w", task="Do something")
+            .dry_run()
+        )
+
+        assert result.status == "completed"
+
+    def test_fan_out_dry_run_e2e(self):
+        from agent_relay.builder import _find_agent_relay
+
+        if _find_agent_relay() is None:
+            pytest.skip("agent-relay CLI not installed")
+
+        result = (
+            fan_out("e2e-fan", tasks=["task A", "task B"], worker_cli="claude")
+            .dry_run()
+        )
+
+        assert result.status == "completed"
+
+    def test_pipeline_dry_run_e2e(self):
+        from agent_relay.builder import _find_agent_relay
+
+        if _find_agent_relay() is None:
+            pytest.skip("agent-relay CLI not installed")
+
+        result = pipeline(
+            "e2e-pipe",
+            stages=[
+                PipelineStage(name="s1", task="First"),
+                PipelineStage(name="s2", task="Second"),
+            ],
+        ).dry_run()
+
+        assert result.status == "completed"
+
+
+class TestRunYamlDryRun:
+    """run_yaml() respects dry_run and DRY_RUN env var."""
+
+    def test_run_yaml_env_var(self, monkeypatch, tmp_path):
+        monkeypatch.setenv("DRY_RUN", "true")
+
+        yaml_file = tmp_path / "test.yaml"
+        yaml_file.write_text("""
+version: "1.0"
+name: yaml-dry-test
+swarm:
+  pattern: dag
+agents:
+  - name: w
+    cli: claude
+workflows:
+  - name: wf
+    steps:
+      - name: s
+        agent: w
+        task: do something
+""")
+
+        with patch("agent_relay.builder._run_yaml_path") as mock_run:
+            mock_run.return_value = MagicMock(status="completed")
+            run_yaml(str(yaml_file))
+            call_opts = mock_run.call_args[0][1]
+            assert call_opts.dry_run is True

package/packages/sdk-py/tests/test_send_message_mode.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from agent_relay.client import AgentRelayClient
+from agent_relay.relay import AgentRelay, HumanHandle
+
+
+@pytest.mark.asyncio
+async def test_client_send_message_includes_mode_in_payload():
+    client = AgentRelayClient(binary_path="agent-relay-broker")
+    client.start_client = AsyncMock()
+
+    payloads: list[dict] = []
+
+    async def fake_request_ok(type_: str, payload: dict):
+        assert type_ == "send_message"
+        payloads.append(payload)
+        return {"event_id": "evt-1", "targets": ["Worker"]}
+
+    client._request_ok = fake_request_ok  # type: ignore[method-assign]
+
+    result = await client.send_message(
+        to="Worker",
+        text="hello",
+        from_="system",
+        thread_id="thread-1",
+        priority=5,
+        data={"k": "v"},
+        mode="steer",
+    )
+
+    assert result["event_id"] == "evt-1"
+    assert payloads == [
+        {
+            "to": "Worker",
+            "text": "hello",
+            "from": "system",
+            "thread_id": "thread-1",
+            "priority": 5,
+            "data": {"k": "v"},
+            "mode": "steer",
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_human_send_message_passes_mode_and_sets_message_mode():
+    relay = AgentRelay()
+    client = AsyncMock()
+    client.send_message = AsyncMock(return_value={"event_id": "evt-2"})
+    relay._ensure_started = AsyncMock(return_value=client)
+
+    human = HumanHandle("system", relay)
+    msg = await human.send_message(to="Worker", text="status?", mode="wait")
+
+    assert msg.mode == "wait"
+    client.send_message.assert_awaited_once_with(
+        to="Worker",
+        text="status?",
+        from_="system",
+        thread_id=None,
+        priority=None,
+        data=None,
+        mode="wait",
+    )
+
+
+@pytest.mark.asyncio
+async def test_agent_send_message_passes_mode_and_sets_message_mode():
+    relay = AgentRelay()
+    client = AsyncMock()
+    client.spawn_pty = AsyncMock(return_value={"name": "Worker", "runtime": "pty"})
+    client.send_message = AsyncMock(return_value={"event_id": "evt-3"})
+    relay._ensure_started = AsyncMock(return_value=client)
+
+    agent = await relay.spawn("Worker", "claude")
+    msg = await agent.send_message(to="Reviewer", text="ready", mode="steer")
+
+    assert msg.mode == "steer"
+    client.send_message.assert_awaited_with(
+        to="Reviewer",
+        text="ready",
+        from_="Worker",
+        thread_id=None,
+        priority=None,
+        data=None,
+        mode="steer",
+    )

package/packages/telemetry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/telemetry",
-  "version": "3.2.15",
+  "version": "3.2.17",
   "description": "Anonymous telemetry for Agent Relay usage analytics",
   "type": "module",
   "main": "dist/index.js",

package/packages/trajectory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/trajectory",
-  "version": "3.2.15",
+  "version": "3.2.17",
   "description": "Trajectory integration utilities (trail/PDERO) for Relay",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/config": "3.2.15"
+    "@agent-relay/config": "3.2.17"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/user-directory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/user-directory",
-  "version": "3.2.15",
+  "version": "3.2.17",
   "description": "User directory service for agent-relay (per-user credential storage)",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@agent-relay/utils": "3.2.15"
+    "@agent-relay/utils": "3.2.17"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/utils",
-  "version": "3.2.15",
+  "version": "3.2.17",
   "description": "Shared utilities for agent-relay: logging, name generation, command resolution, update checking",
   "type": "module",
   "main": "dist/cjs/index.js",
@@ -112,7 +112,7 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@agent-relay/config": "3.2.15",
+    "@agent-relay/config": "3.2.17",
     "compare-versions": "^6.1.1"
   },
   "publishConfig": {