agent-relay 3.2.2 → 3.2.4

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

@@ -0,0 +1,285 @@
+"""Tests for communicate mode types (TDD - red phase).
+
+Tests cover:
+- Message dataclass (creation, immutability, defaults)
+- RelayConfig dataclass (defaults, env var resolution)
+- Exception types (RelayConnectionError, RelayConfigError, RelayAuthError)
+- MessageCallback type alias compatibility
+"""
+
+import asyncio
+import dataclasses
+
+import pytest
+
+from agent_relay.communicate.types import (
+    Message,
+    MessageCallback,
+    RelayAuthError,
+    RelayConfig,
+    RelayConfigError,
+    RelayConnectionError,
+)
+
+
+# ---------------------------------------------------------------------------
+# Message dataclass
+# ---------------------------------------------------------------------------
+
+
+class TestMessage:
+    """Tests for the Message frozen dataclass."""
+
+    def test_create_with_required_fields_only(self):
+        msg = Message(sender="Alice", text="Hello")
+        assert msg.sender == "Alice"
+        assert msg.text == "Hello"
+
+    def test_optional_fields_default_to_none(self):
+        msg = Message(sender="Alice", text="Hello")
+        assert msg.channel is None
+        assert msg.thread_id is None
+        assert msg.timestamp is None
+        assert msg.message_id is None
+
+    def test_create_with_all_fields(self):
+        msg = Message(
+            sender="Bob",
+            text="Hi there",
+            channel="general",
+            thread_id="thread-123",
+            timestamp=1710300000.0,
+            message_id="msg-456",
+        )
+        assert msg.sender == "Bob"
+        assert msg.text == "Hi there"
+        assert msg.channel == "general"
+        assert msg.thread_id == "thread-123"
+        assert msg.timestamp == 1710300000.0
+        assert msg.message_id == "msg-456"
+
+    def test_is_frozen_cannot_set_sender(self):
+        msg = Message(sender="Alice", text="Hello")
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            msg.sender = "Eve"  # type: ignore[misc]
+
+    def test_is_frozen_cannot_set_text(self):
+        msg = Message(sender="Alice", text="Hello")
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            msg.text = "Tampered"  # type: ignore[misc]
+
+    def test_is_frozen_cannot_set_optional_field(self):
+        msg = Message(sender="Alice", text="Hello")
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            msg.channel = "secret"  # type: ignore[misc]
+
+    def test_is_dataclass(self):
+        assert dataclasses.is_dataclass(Message)
+
+    def test_equality_same_values(self):
+        a = Message(sender="Alice", text="Hi")
+        b = Message(sender="Alice", text="Hi")
+        assert a == b
+
+    def test_equality_different_values(self):
+        a = Message(sender="Alice", text="Hi")
+        b = Message(sender="Bob", text="Hi")
+        assert a != b
+
+    def test_channel_none_means_dm(self):
+        """When channel is None, the message is a direct message."""
+        msg = Message(sender="Alice", text="DM content")
+        assert msg.channel is None
+
+    def test_channel_set_means_channel_message(self):
+        msg = Message(sender="Alice", text="Channel content", channel="general")
+        assert msg.channel == "general"
+
+
+# ---------------------------------------------------------------------------
+# RelayConfig dataclass
+# ---------------------------------------------------------------------------
+
+
+class TestRelayConfig:
+    """Tests for the RelayConfig dataclass with env var defaults."""
+
+    def test_all_defaults(self, monkeypatch):
+        monkeypatch.delenv("RELAY_WORKSPACE", raising=False)
+        monkeypatch.delenv("RELAY_API_KEY", raising=False)
+        monkeypatch.delenv("RELAY_BASE_URL", raising=False)
+
+        config = RelayConfig()
+        assert config.workspace is None
+        assert config.api_key is None
+        assert config.base_url is None
+        assert config.channels == ["general"]
+        assert config.poll_interval_ms == 1000
+        assert config.auto_cleanup is True
+
+    def test_explicit_values_override_defaults(self):
+        config = RelayConfig(
+            workspace="my-ws",
+            api_key="key-123",
+            base_url="https://custom.api.dev",
+            channels=["dev", "ops"],
+            poll_interval_ms=500,
+            auto_cleanup=False,
+        )
+        assert config.workspace == "my-ws"
+        assert config.api_key == "key-123"
+        assert config.base_url == "https://custom.api.dev"
+        assert config.channels == ["dev", "ops"]
+        assert config.poll_interval_ms == 500
+        assert config.auto_cleanup is False
+
+    def test_channels_default_is_independent_per_instance(self):
+        """Each RelayConfig gets its own channels list (no shared mutable default)."""
+        a = RelayConfig()
+        b = RelayConfig()
+        a.channels.append("extra")
+        assert "extra" not in b.channels
+
+    def test_env_var_workspace(self, monkeypatch):
+        monkeypatch.setenv("RELAY_WORKSPACE", "env-workspace")
+        config = RelayConfig()
+        assert config.workspace == "env-workspace"
+
+    def test_env_var_api_key(self, monkeypatch):
+        monkeypatch.setenv("RELAY_API_KEY", "env-key-abc")
+        config = RelayConfig()
+        assert config.api_key == "env-key-abc"
+
+    def test_env_var_base_url(self, monkeypatch):
+        monkeypatch.setenv("RELAY_BASE_URL", "https://env.api.dev")
+        config = RelayConfig()
+        assert config.base_url == "https://env.api.dev"
+
+    def test_base_url_default_when_no_env(self, monkeypatch):
+        """When RELAY_BASE_URL is not set, base_url defaults to the Relaycast cloud URL."""
+        monkeypatch.delenv("RELAY_BASE_URL", raising=False)
+        config = RelayConfig()
+        # base_url should resolve to the default cloud URL when accessed
+        # The exact resolution may happen at init or lazily; either None or the default is acceptable
+        # but the resolved value should be "https://api.relaycast.dev"
+        assert config.base_url is None or config.base_url == "https://api.relaycast.dev"
+
+    def test_explicit_value_overrides_env_var(self, monkeypatch):
+        monkeypatch.setenv("RELAY_WORKSPACE", "env-workspace")
+        config = RelayConfig(workspace="explicit-workspace")
+        assert config.workspace == "explicit-workspace"
+
+    def test_is_dataclass(self):
+        assert dataclasses.is_dataclass(RelayConfig)
+
+    def test_is_not_frozen(self):
+        """RelayConfig should be mutable (not frozen)."""
+        config = RelayConfig()
+        config.workspace = "updated"
+        assert config.workspace == "updated"
+
+
+# ---------------------------------------------------------------------------
+# Exception types
+# ---------------------------------------------------------------------------
+
+
+class TestRelayConnectionError:
+    """Tests for RelayConnectionError which stores status_code and message."""
+
+    def test_inherits_from_exception(self):
+        assert issubclass(RelayConnectionError, Exception)
+
+    def test_stores_status_code_and_message(self):
+        err = RelayConnectionError(status_code=500, message="Internal Server Error")
+        assert err.status_code == 500
+        assert err.message == "Internal Server Error"
+
+    def test_str_contains_status_and_message(self):
+        err = RelayConnectionError(status_code=503, message="Service Unavailable")
+        text = str(err)
+        assert "503" in text
+        assert "Service Unavailable" in text
+
+    def test_different_status_codes(self):
+        for code in [400, 404, 429, 500, 502, 503]:
+            err = RelayConnectionError(status_code=code, message=f"Error {code}")
+            assert err.status_code == code
+
+
+class TestRelayConfigError:
+    """Tests for RelayConfigError which signals missing configuration."""
+
+    def test_inherits_from_exception(self):
+        assert issubclass(RelayConfigError, Exception)
+
+    def test_has_descriptive_message(self):
+        err = RelayConfigError("RELAY_API_KEY environment variable is required")
+        assert "RELAY_API_KEY" in str(err)
+
+    def test_message_accessible(self):
+        msg = "Missing RELAY_WORKSPACE. Set the environment variable or pass workspace= to RelayConfig."
+        err = RelayConfigError(msg)
+        assert str(err) == msg
+
+
+class TestRelayAuthError:
+    """Tests for RelayAuthError which signals HTTP 401 responses."""
+
+    def test_inherits_from_exception(self):
+        assert issubclass(RelayAuthError, Exception)
+
+    def test_message(self):
+        err = RelayAuthError("Invalid API key")
+        assert "Invalid API key" in str(err)
+
+    def test_inherits_from_relay_connection_error_or_exception(self):
+        """RelayAuthError should be catchable as a general exception."""
+        err = RelayAuthError("Unauthorized")
+        assert isinstance(err, Exception)
+
+
+# ---------------------------------------------------------------------------
+# MessageCallback type alias
+# ---------------------------------------------------------------------------
+
+
+class TestMessageCallback:
+    """Tests that both sync and async callables satisfy MessageCallback."""
+
+    def test_sync_callable_is_valid(self):
+        """A synchronous function that takes a Message and returns None should be valid."""
+        received: list[Message] = []
+
+        def handler(msg: Message) -> None:
+            received.append(msg)
+
+        # Verify the callable works as expected
+        callback: MessageCallback = handler
+        msg = Message(sender="Alice", text="Test")
+        callback(msg)
+        assert len(received) == 1
+        assert received[0].sender == "Alice"
+
+    async def test_async_callable_is_valid(self):
+        """An async function that takes a Message and returns None should be valid."""
+        received: list[Message] = []
+
+        async def handler(msg: Message) -> None:
+            received.append(msg)
+
+        callback: MessageCallback = handler
+        msg = Message(sender="Bob", text="Async test")
+        result = callback(msg)
+        # If it returns a coroutine, await it
+        if asyncio.iscoroutine(result):
+            await result
+        assert len(received) == 1
+        assert received[0].sender == "Bob"
+
+    def test_lambda_callable_is_valid(self):
+        """A lambda that takes a Message should work as a callback."""
+        results: list[str] = []
+        callback: MessageCallback = lambda msg: results.append(msg.text)
+        callback(Message(sender="X", text="lambda-test"))
+        assert results == ["lambda-test"]

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

@@ -0,0 +1,118 @@
+"""Tests for deterministic and worktree step support in the Python workflow builder."""
+
+import pytest
+from agent_relay import workflow, VerificationCheck
+
+
+def test_deterministic_step_emits_correct_config():
+    config = (
+        workflow("test")
+        .agent("worker", cli="claude")
+        .step("read-files", type="deterministic", command="cat src/index.ts",
+              verification=VerificationCheck(type="exit_code", value="0"))
+        .step("build", agent="worker", task="Build the project")
+        .to_config()
+    )
+
+    steps = config["workflows"][0]["steps"]
+    assert len(steps) == 2
+
+    # Deterministic step
+    assert steps[0]["name"] == "read-files"
+    assert steps[0]["type"] == "deterministic"
+    assert steps[0]["command"] == "cat src/index.ts"
+    assert "agent" not in steps[0]
+    assert "task" not in steps[0]
+    assert steps[0]["verification"] == {"type": "exit_code", "value": "0"}
+
+    # Agent step
+    assert steps[1]["name"] == "build"
+    assert steps[1]["agent"] == "worker"
+    assert steps[1]["task"] == "Build the project"
+    assert "type" not in steps[1]
+
+
+def test_deterministic_step_with_all_options():
+    config = (
+        workflow("test")
+        .agent("worker", cli="claude")
+        .step("run-cmd", type="deterministic", command="npm test",
+              capture_output=True, fail_on_error=False,
+              depends_on=["build"], timeout_ms=30000)
+        .step("final", agent="worker", task="Finalize")
+        .to_config()
+    )
+
+    step = config["workflows"][0]["steps"][0]
+    assert step["captureOutput"] is True
+    assert step["failOnError"] is False
+    assert step["dependsOn"] == ["build"]
+    assert step["timeoutMs"] == 30000
+
+
+def test_worktree_step_emits_correct_config():
+    config = (
+        workflow("test")
+        .agent("worker", cli="claude")
+        .step("setup-worktree", type="worktree", branch="feature/new",
+              base_branch="main", path=".worktrees/feature-new", create_branch=True)
+        .step("work", agent="worker", task="Do work", depends_on=["setup-worktree"])
+        .to_config()
+    )
+
+    step = config["workflows"][0]["steps"][0]
+    assert step["type"] == "worktree"
+    assert step["branch"] == "feature/new"
+    assert step["baseBranch"] == "main"
+    assert step["path"] == ".worktrees/feature-new"
+    assert step["createBranch"] is True
+    assert "agent" not in step
+    assert "command" not in step
+
+
+def test_deterministic_only_workflow_no_agents_required():
+    config = (
+        workflow("infra")
+        .step("lint", type="deterministic", command="npm run lint")
+        .step("test", type="deterministic", command="npm test", depends_on=["lint"])
+        .to_config()
+    )
+
+    assert config["agents"] == []
+    assert len(config["workflows"][0]["steps"]) == 2
+
+
+def test_deterministic_step_without_command_raises():
+    with pytest.raises(ValueError, match="deterministic steps must have a command"):
+        workflow("test").step("bad", type="deterministic")
+
+
+def test_deterministic_step_with_agent_raises():
+    with pytest.raises(ValueError, match="deterministic steps must not have agent or task"):
+        workflow("test").step("bad", type="deterministic", command="ls", agent="x", task="y")
+
+
+def test_agent_step_without_agent_task_raises():
+    with pytest.raises(ValueError, match="Agent steps must have both agent and task"):
+        workflow("test").step("bad")
+
+
+def test_agent_steps_without_agent_definition_raises():
+    with pytest.raises(ValueError, match="Workflow must have at least one agent when using agent steps"):
+        workflow("test").step("work", agent="worker", task="Do work").to_config()
+
+
+def test_worktree_step_without_branch_raises():
+    with pytest.raises(ValueError, match="worktree steps must have a branch"):
+        workflow("test").step("bad", type="worktree")
+
+
+def test_to_yaml_includes_deterministic_steps():
+    yaml_str = (
+        workflow("test")
+        .step("check", type="deterministic", command="echo hello")
+        .to_yaml()
+    )
+
+    assert "type: deterministic" in yaml_str
+    assert "command: echo hello" in yaml_str

package/packages/telemetry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/telemetry",
-  "version": "3.2.2",
+  "version": "3.2.4",
   "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.2",
+  "version": "3.2.4",
   "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.2"
+    "@agent-relay/config": "3.2.4"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/user-directory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/user-directory",
-  "version": "3.2.2",
+  "version": "3.2.4",
   "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.2"
+    "@agent-relay/utils": "3.2.4"
   },
   "devDependencies": {
     "@types/node": "^22.19.3",

package/packages/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/utils",
-  "version": "3.2.2",
+  "version": "3.2.4",
   "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.2",
+    "@agent-relay/config": "3.2.4",
     "compare-versions": "^6.1.1"
   },
   "publishConfig": {

package/packages/sdk/dist/__tests__/completion-pipeline.test.d.ts

@@ -1,14 +0,0 @@
-/**
- * Completion Pipeline tests for Point-Person-Led Completion spec.
- *
- * Validates:
- * 1. Evidence-based completion (verification passes without marker)
- * 2. Owner decision parsing (OWNER_DECISION: COMPLETE/INCOMPLETE_RETRY/INCOMPLETE_FAIL)
- * 3. Tolerant review parsing (accepts semantic equivalents)
- * 4. Channel evidence contributions (WORKER_DONE signals)
- * 5. Backward compatibility with marker-based workflows
- * 6. Codex/Gemini/Supervisor pattern compatibility
- * 7. Map-reduce workflows remain unaffected
- */
-export {};
-//# sourceMappingURL=completion-pipeline.test.d.ts.map

package/packages/sdk/dist/__tests__/completion-pipeline.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"completion-pipeline.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/completion-pipeline.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}