agent-relay 3.2.21 → 4.0.0

package/packages/sdk-py/src/agent_relay/protocol.py

@@ -1,110 +1,16 @@
-"""Wire protocol types for the Agent Relay broker communication.
+"""Wire protocol types for the Agent Relay broker.
 
 Matches the TypeScript definitions in packages/sdk/src/protocol.ts.
 """
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-from typing import Any, Literal, Optional
-
-PROTOCOL_VERSION = 1
+from typing import Any, Literal
 
 AgentRuntime = Literal["pty", "headless"]
 HeadlessProvider = Literal["claude", "opencode"]
 MessageInjectionMode = Literal["wait", "steer"]
 
-
-@dataclass
-class RestartPolicy:
-    enabled: bool = False
-    max_restarts: int = 3
-    cooldown_ms: int = 1000
-    max_consecutive_failures: int = 3
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "enabled": self.enabled,
-            "max_restarts": self.max_restarts,
-            "cooldown_ms": self.cooldown_ms,
-            "max_consecutive_failures": self.max_consecutive_failures,
-        }
-
-
-@dataclass
-class AgentSpec:
-    """Specification for spawning an agent."""
-
-    name: str
-    runtime: AgentRuntime = "pty"
-    provider: Optional[HeadlessProvider] = None
-    cli: Optional[str] = None
-    args: list[str] = field(default_factory=list)
-    channels: list[str] = field(default_factory=list)
-    model: Optional[str] = None
-    cwd: Optional[str] = None
-    team: Optional[str] = None
-    shadow_of: Optional[str] = None
-    shadow_mode: Optional[str] = None
-    restart_policy: Optional[RestartPolicy] = None
-
-    def to_dict(self) -> dict[str, Any]:
-        d: dict[str, Any] = {
-            "name": self.name,
-            "runtime": self.runtime,
-        }
-        if self.provider is not None:
-            d["provider"] = self.provider
-        if self.cli is not None:
-            d["cli"] = self.cli
-        if self.args:
-            d["args"] = self.args
-        if self.channels:
-            d["channels"] = self.channels
-        if self.model is not None:
-            d["model"] = self.model
-        if self.cwd is not None:
-            d["cwd"] = self.cwd
-        if self.team is not None:
-            d["team"] = self.team
-        if self.shadow_of is not None:
-            d["shadow_of"] = self.shadow_of
-        if self.shadow_mode is not None:
-            d["shadow_mode"] = self.shadow_mode
-        if self.restart_policy is not None:
-            d["restart_policy"] = self.restart_policy.to_dict()
-        return d
-
-
-@dataclass
-class ProtocolEnvelope:
-    """JSON envelope for all broker communication."""
-
-    v: int
-    type: str
-    payload: dict[str, Any]
-    request_id: Optional[str] = None
-
-    def to_dict(self) -> dict[str, Any]:
-        d: dict[str, Any] = {
-            "v": self.v,
-            "type": self.type,
-            "payload": self.payload,
-        }
-        if self.request_id is not None:
-            d["request_id"] = self.request_id
-        return d
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> ProtocolEnvelope:
-        return cls(
-            v=data.get("v", 0),
-            type=data.get("type", ""),
-            payload=data.get("payload", {}),
-            request_id=data.get("request_id"),
-        )
-
-
 # BrokerEvent is a dict with a 'kind' field discriminator.
 # Event kinds: agent_spawned, agent_released, agent_exit, agent_exited,
 # relay_inbound, worker_stream, worker_ready, worker_error,

package/packages/sdk-py/src/agent_relay/relay.py

@@ -424,8 +424,6 @@ class AgentRelay:
             "channels": self._default_channels,
             "cwd": cwd,
             "env": env,
-            "request_timeout_ms": request_timeout_ms,
-            "shutdown_timeout_ms": shutdown_timeout_ms,
         }
 
         self._client: Optional[AgentRelayClient] = None
@@ -477,8 +475,7 @@ class AgentRelay:
 
             # Remove None values to use defaults
             kwargs = {k: v for k, v in self._client_kwargs.items() if v is not None}
-            client = AgentRelayClient(**kwargs)
-            await client.start_client()
+            client = await AgentRelayClient.spawn(**kwargs)
 
             self._client = client
             if client.workspace_key:

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

@@ -0,0 +1,92 @@
+"""Tests for _wait_for_api_url."""
+
+import asyncio
+from unittest.mock import AsyncMock, PropertyMock
+
+import pytest
+
+from agent_relay.client import AgentRelayProcessError, _wait_for_api_url
+
+
+def _make_process(lines: list[str], returncode: int | None = 0):
+    """Create a mock asyncio.subprocess.Process with canned stdout lines."""
+    remaining = list(lines)
+
+    async def readline() -> bytes:
+        if remaining:
+            return (remaining.pop(0) + "\n").encode("utf-8")
+        return b""
+
+    process = AsyncMock()
+    process.stdout = AsyncMock()
+    process.stdout.readline = readline
+    type(process).returncode = PropertyMock(return_value=returncode)
+    return process
+
+
+class TestWaitForApiUrl:
+    async def test_parses_default_loopback(self):
+        process = _make_process([
+            "[agent-relay] API listening on http://127.0.0.1:3889",
+        ])
+        url = await _wait_for_api_url(process, 5000)
+        assert url == "http://127.0.0.1:3889"
+
+    async def test_parses_wildcard_bind(self):
+        process = _make_process([
+            "[agent-relay] API listening on http://0.0.0.0:4000",
+        ])
+        url = await _wait_for_api_url(process, 5000)
+        assert url == "http://0.0.0.0:4000"
+
+    async def test_parses_custom_ip(self):
+        process = _make_process([
+            "[agent-relay] API listening on http://10.0.1.5:8080",
+        ])
+        url = await _wait_for_api_url(process, 5000)
+        assert url == "http://10.0.1.5:8080"
+
+    async def test_parses_https(self):
+        process = _make_process([
+            "[agent-relay] API listening on https://broker.example.com:443",
+        ])
+        url = await _wait_for_api_url(process, 5000)
+        assert url == "https://broker.example.com:443"
+
+    async def test_skips_non_matching_lines(self):
+        process = _make_process([
+            "[agent-relay] Starting broker...",
+            "[agent-relay] Loading config",
+            "[agent-relay] API listening on http://127.0.0.1:5555",
+        ])
+        url = await _wait_for_api_url(process, 5000)
+        assert url == "http://127.0.0.1:5555"
+
+    async def test_raises_on_process_exit_before_ready(self):
+        process = _make_process(
+            ["[agent-relay] Starting broker..."],
+            returncode=1,
+        )
+        with pytest.raises(AgentRelayProcessError, match="exited with code 1"):
+            await _wait_for_api_url(process, 5000)
+
+    async def test_raises_on_timeout(self):
+        async def slow_readline() -> bytes:
+            await asyncio.sleep(10)
+            return b""
+
+        process = AsyncMock()
+        process.stdout = AsyncMock()
+        process.stdout.readline = slow_readline
+        type(process).returncode = PropertyMock(return_value=None)
+
+        with pytest.raises(AgentRelayProcessError, match="did not report API URL"):
+            await _wait_for_api_url(process, 50)
+
+    async def test_ignores_lines_with_colon_but_no_url(self):
+        process = _make_process([
+            "[agent-relay] config: loaded from /etc/relay.conf",
+            "[agent-relay] API listening on http://127.0.0.1:9999",
+        ])
+        url = await _wait_for_api_url(process, 5000)
+        assert url == "http://127.0.0.1:9999"