agent-relay 3.2.2 → 3.2.4

package/packages/sdk-py/tests/communicate/adapters/e2e_test_openai_agents.py

@@ -0,0 +1,88 @@
+"""E2E test: OpenAI Agents Python adapter against live Relaycast."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import uuid
+import time
+from types import ModuleType
+from unittest.mock import MagicMock
+
+import pytest
+
+from agent_relay.communicate.core import Relay
+from agent_relay.communicate.types import RelayConfig
+
+
+def _install_agents_module(monkeypatch):
+    """Inject a fake 'agents' module so the adapter can import function_tool."""
+    agents_mod = ModuleType("agents")
+    agents_mod.Agent = type("Agent", (), {})
+    agents_mod.function_tool = MagicMock(side_effect=lambda func: func)
+    monkeypatch.setitem(sys.modules, "agents", agents_mod)
+    return agents_mod
+
+
+def _make_mock_agent(name: str):
+    agent = MagicMock()
+    agent.name = name
+    agent.tools = []
+    agent.instructions = "You are a helpful agent."
+    type(agent).__module__ = "agents"
+    return agent
+
+
+def _unique_name(prefix: str) -> str:
+    return f"{prefix}-{int(time.time() * 1000)}-{uuid.uuid4().hex[:6]}"
+
+
+@pytest.mark.asyncio
+async def test_openai_agents_e2e(monkeypatch):
+    """Full round-trip: real Relay, mock Agent, live Relaycast API."""
+    agents_mod = _install_agents_module(monkeypatch)
+
+    from agent_relay.communicate.adapters.openai_agents import on_relay
+
+    agent_name = _unique_name("oai-py-e2e")
+    config = RelayConfig.resolve(channels=["general"], auto_cleanup=False)
+
+    relay = Relay(agent_name, config)
+    mock_agent = _make_mock_agent(agent_name)
+
+    try:
+        # Step 1: wrap agent — tools should be injected
+        wrapped = on_relay(mock_agent, relay)
+        assert wrapped is mock_agent
+        assert agents_mod.function_tool.call_count == 4
+        tool_names = [c.args[0].__name__ for c in agents_mod.function_tool.call_args_list]
+        assert set(tool_names) == {"relay_send", "relay_inbox", "relay_post", "relay_agents"}
+        assert len(mock_agent.tools) == 4
+
+        # Step 2: list_agents against real API
+        agents_list = await relay.agents()
+        assert isinstance(agents_list, list)
+        assert agent_name in agents_list, f"{agent_name} not in {agents_list}"
+
+        # Step 3: post a message to the general channel
+        test_text = f"e2e-openai-py-{uuid.uuid4().hex[:8]}"
+        await relay.post("general", test_text)
+
+        # Step 4: invoke the relay_agents tool closure
+        relay_agents_fn = mock_agent.tools[3]
+        result = await relay_agents_fn()
+        assert isinstance(result, str)
+        assert agent_name in result
+
+        # Step 5: invoke the relay_post tool closure
+        relay_post_fn = mock_agent.tools[2]
+        post_result = await relay_post_fn("general", f"tool-post-{uuid.uuid4().hex[:6]}")
+        assert post_result == "Message posted"
+
+        # Step 6: instructions wrapper returns base instructions when no pending msgs
+        assert callable(mock_agent.instructions)
+        instr = await mock_agent.instructions()
+        assert "You are a helpful agent." in instr
+
+    finally:
+        await relay.close()

package/packages/sdk-py/tests/communicate/adapters/e2e_test_pi.py

@@ -0,0 +1,156 @@
+"""End-to-end tests for the Pi RPC Python adapter against live Relaycast.
+
+Reuses a small number of Relay connections across tests to stay within
+the 60 req/min rate limit of the free plan.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import time
+import uuid
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from agent_relay.communicate import Relay
+from agent_relay.communicate.adapters.pi import RELAY_TOOL_PREAMBLE, PiRpcSession, on_relay
+from agent_relay.communicate.types import Message, RelayConfig
+
+
+def _live_config() -> RelayConfig:
+    return RelayConfig.resolve(
+        workspace=os.environ.get("RELAY_WORKSPACE"),
+        api_key=os.environ.get("RELAY_API_KEY"),
+        base_url=os.environ.get("RELAY_BASE_URL"),
+        channels=[],
+        auto_cleanup=False,
+    )
+
+
+def _unique_name(prefix: str = "e2e-pi-py") -> str:
+    return f"{prefix}-{int(time.time() * 1000)}-{uuid.uuid4().hex[:8]}"
+
+
+def _make_mock_proc():
+    proc = MagicMock()
+    proc.stdin = MagicMock()
+    proc.stdout = iter([])
+    proc.stderr = MagicMock()
+    proc.poll = MagicMock(return_value=None)
+    proc.terminate = MagicMock()
+    proc.wait = MagicMock()
+    return proc
+
+
+@pytest.mark.asyncio
+async def test_pi_adapter_e2e():
+    """Comprehensive e2e test for the Pi adapter against live Relaycast.
+
+    Uses only 2 Relay connections to minimize API calls and stay within rate limits.
+    Tests cover:
+    1. PiRpcSession creation via on_relay() with a real Relay
+    2. RELAY_TOOL_PREAMBLE contents
+    3. Relay registration against live API (unique agent name with uuid suffix)
+    4. relay.agents() - live agent list
+    5. relay.send() + relay.inbox() - DM round-trip
+    6. relay.post() - channel posting
+    7. PiRpcSession relay message callback routing
+    8. Cleanup / disconnect
+    """
+    config = _live_config()
+    sender_name = _unique_name("e2e-pi-sender")
+    receiver_name = _unique_name("e2e-pi-recv")
+
+    sender = Relay(sender_name, config)
+    receiver = Relay(receiver_name, config)
+
+    try:
+        # --- 1. Registration: both agents connect and appear in agent list ---
+        agents = await sender.agents()
+        assert sender_name in agents, f"{sender_name} not in agents after connect"
+
+        await asyncio.sleep(1)
+        agents2 = await receiver.agents()
+        assert receiver_name in agents2, f"{receiver_name} not in agents after connect"
+        assert sender_name in agents2, f"{sender_name} not visible to receiver"
+
+        # --- 2. RELAY_TOOL_PREAMBLE has expected relay tool descriptions ---
+        assert "relay_send" in RELAY_TOOL_PREAMBLE
+        assert "relay_inbox" in RELAY_TOOL_PREAMBLE
+        assert "relay_agents" in RELAY_TOOL_PREAMBLE
+        assert "relay_post" in RELAY_TOOL_PREAMBLE
+
+        # --- 3. on_relay() creates a PiRpcSession backed by a real Relay ---
+        with patch("subprocess.Popen") as mock_popen:
+            proc = _make_mock_proc()
+            mock_popen.return_value = proc
+
+            session = on_relay(sender_name, relay=sender)
+
+            assert isinstance(session, PiRpcSession)
+            assert session._relay is sender
+            assert session._relay.agent_name == sender_name
+
+            # --- 4. Relay message callback routes to Pi subprocess ---
+            msg = Message(sender="test-lead", text="status update request")
+            callback = sender._callbacks[0]
+            callback(msg)
+
+            written = proc.stdin.write.call_args[0][0]
+            parsed = json.loads(written.strip())
+            assert "test-lead" in parsed["message"]
+            assert "status update request" in parsed["message"]
+            assert parsed["streamingBehavior"] == "followUp"
+
+            # Clean up session (subprocess mock only)
+            session.close()
+            proc.terminate.assert_called_once()
+            assert session._closed
+
+        await asyncio.sleep(1)
+
+        # --- 5. DM round-trip: send() + inbox() ---
+        text = f"pi-e2e-{uuid.uuid4().hex[:8]}"
+        await sender.send(receiver_name, text)
+
+        deadline = asyncio.get_event_loop().time() + 15.0
+        found = False
+        while asyncio.get_event_loop().time() < deadline:
+            messages = await receiver.inbox()
+            for m in messages:
+                if m.sender == sender_name and m.text == text:
+                    found = True
+                    break
+            if found:
+                break
+            await asyncio.sleep(1.0)
+
+        assert found, f"DM from {sender_name} not received within timeout"
+
+        await asyncio.sleep(1)
+
+        # --- 6. Post to channel ---
+        await sender.join("general")
+        await sender.post("general", f"pi-e2e-test-{uuid.uuid4().hex[:8]}")
+
+        # --- 7. Cleanup: close both relays ---
+        # Relaycast presence is eventually consistent -- agents may remain
+        # "online" in list_agents for a heartbeat window after disconnect.
+        # We verify that close() completes without error (same approach as
+        # the existing transport e2e tests).
+        await sender.close()
+        assert not sender._connected, "sender._connected should be False after close"
+        await receiver.close()
+        assert not receiver._connected, "receiver._connected should be False after close"
+
+    except Exception:
+        # Best-effort cleanup on failure
+        for r in (sender, receiver):
+            try:
+                await r.close()
+            except Exception:
+                pass
+        raise

package/packages/sdk-py/tests/communicate/adapters/e2e_test_swarms.py

@@ -0,0 +1,239 @@
+"""E2E test: Swarms Python adapter against live Relaycast."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+from unittest.mock import MagicMock
+
+import pytest
+
+from agent_relay.communicate.core import Relay
+from agent_relay.communicate.types import Message, RelayConfig, RelayConnectionError
+
+
+def _live_config() -> RelayConfig:
+    return RelayConfig.resolve(channels=[], auto_cleanup=False)
+
+
+def _unique_name(prefix: str = "e2e-swarms-py") -> str:
+    return f"{prefix}-{int(time.time() * 1000)}-{uuid.uuid4().hex[:8]}"
+
+
+def _make_mock_agent(name: str):
+    agent = MagicMock()
+    agent.name = name
+    agent.tools = []
+    agent.receive_message = MagicMock()
+    type(agent).__module__ = "swarms"
+    return agent
+
+
+async def _retry_on_429(coro_fn, max_retries=5, base_delay=15.0):
+    """Call an async function, retrying on 429 rate limit errors."""
+    for attempt in range(max_retries):
+        try:
+            return await coro_fn()
+        except RelayConnectionError as e:
+            if e.status_code == 429 and attempt < max_retries - 1:
+                delay = base_delay * (attempt + 1)
+                await asyncio.sleep(delay)
+                continue
+            raise
+
+
+async def _make_connected_relay(name: str, config: RelayConfig) -> Relay:
+    """Create a Relay and connect with 429 retry."""
+    relay = Relay(name, config)
+    await _retry_on_429(relay.agents)
+    return relay
+
+
+class TestSwarmsToolInjection:
+    """Verify on_relay() injects tools (no API calls needed)."""
+
+    def test_on_relay_injects_four_tools(self):
+        from agent_relay.communicate.adapters.swarms import on_relay
+
+        mock_agent = _make_mock_agent("local-agent")
+        mock_relay = MagicMock()
+        mock_relay.on_message = MagicMock(return_value=lambda: None)
+
+        wrapped = on_relay(mock_agent, mock_relay)
+        assert wrapped is mock_agent
+        tool_names = [t.__name__ for t in mock_agent.tools]
+        assert set(tool_names) == {"relay_send", "relay_inbox", "relay_post", "relay_agents"}
+
+    def test_on_relay_registers_callback(self):
+        from agent_relay.communicate.adapters.swarms import on_relay
+
+        mock_agent = _make_mock_agent("cb-agent")
+        mock_relay = MagicMock()
+        mock_relay.on_message = MagicMock(return_value=lambda: None)
+
+        on_relay(mock_agent, mock_relay)
+        assert mock_relay.on_message.called
+
+        callback = mock_relay.on_message.call_args[0][0]
+        msg = Message(sender="test-lead", text="status check")
+        callback(msg)
+        mock_agent.receive_message.assert_called_once_with("test-lead", "status check")
+
+
+class TestSwarmsLiveAPI:
+    """Live API tests — consolidated to minimize requests."""
+
+    @pytest.mark.asyncio
+    async def test_registration_and_agents_tool(self):
+        """Agent registers and relay_agents tool returns its name."""
+        from agent_relay.communicate.adapters.swarms import on_relay
+
+        agent_name = _unique_name("swarms-reg")
+        config = _live_config()
+        relay = Relay(agent_name, config)
+        mock_agent = _make_mock_agent(agent_name)
+
+        try:
+            on_relay(mock_agent, relay)
+            agents = await _retry_on_429(relay.agents)
+            assert agent_name in agents
+
+            tools = {t.__name__: t for t in mock_agent.tools}
+            result = await tools["relay_agents"]()
+            assert isinstance(result, str)
+            assert agent_name in result
+        finally:
+            await relay.close()
+
+    @pytest.mark.asyncio
+    async def test_post_tool_and_channel(self):
+        """The relay_post tool posts to a channel without errors."""
+        from agent_relay.communicate.adapters.swarms import on_relay
+
+        agent_name = _unique_name("swarms-post")
+        config = _live_config()
+        relay = Relay(agent_name, config)
+        mock_agent = _make_mock_agent(agent_name)
+
+        try:
+            on_relay(mock_agent, relay)
+            await _retry_on_429(relay.agents)
+            await _retry_on_429(lambda: relay.join("general"))
+
+            tools = {t.__name__: t for t in mock_agent.tools}
+            result = await tools["relay_post"]("general", f"swarms-e2e-{uuid.uuid4().hex[:8]}")
+            assert result == "Message posted"
+        finally:
+            await relay.close()
+
+    @pytest.mark.asyncio
+    async def test_send_and_inbox_dm(self):
+        """relay_send delivers a DM that relay_inbox retrieves."""
+        from agent_relay.communicate.adapters.swarms import on_relay
+
+        config = _live_config()
+        sender_name = _unique_name("swarms-s")
+        receiver_name = _unique_name("swarms-r")
+        sender_relay = Relay(sender_name, config)
+        receiver_relay = Relay(receiver_name, config)
+        sender_agent = _make_mock_agent(sender_name)
+        receiver_agent = _make_mock_agent(receiver_name)
+        text = f"swarms-dm-{uuid.uuid4().hex[:8]}"
+
+        try:
+            on_relay(sender_agent, sender_relay)
+            on_relay(receiver_agent, receiver_relay)
+
+            await _retry_on_429(sender_relay.agents)
+            await _retry_on_429(receiver_relay.agents)
+
+            sender_tools = {t.__name__: t for t in sender_agent.tools}
+            result = await sender_tools["relay_send"](receiver_name, text)
+            assert result == "Message sent"
+
+            deadline = asyncio.get_event_loop().time() + 20.0
+            found = False
+            while asyncio.get_event_loop().time() < deadline:
+                try:
+                    messages = await receiver_relay.inbox()
+                except RelayConnectionError as e:
+                    if e.status_code == 429:
+                        await asyncio.sleep(15)
+                        continue
+                    raise
+                for msg in messages:
+                    if msg.sender == sender_name and msg.text == text:
+                        found = True
+                        break
+                if found:
+                    break
+                await asyncio.sleep(2.0)
+
+            assert found, f"DM from {sender_name} not received within timeout"
+        finally:
+            await asyncio.gather(sender_relay.close(), receiver_relay.close())
+
+    @pytest.mark.asyncio
+    async def test_callback_with_live_relay(self):
+        """on_message callback routes messages to agent.receive_message with a live relay."""
+        from agent_relay.communicate.adapters.swarms import on_relay
+
+        agent_name = _unique_name("swarms-cb")
+        config = _live_config()
+        relay = Relay(agent_name, config)
+        mock_agent = _make_mock_agent(agent_name)
+
+        try:
+            on_relay(mock_agent, relay)
+            await _retry_on_429(relay.agents)
+
+            assert len(relay._callbacks) >= 1
+            callback = relay._callbacks[0]
+            msg = Message(sender="test-lead", text="status check")
+            callback(msg)
+
+            mock_agent.receive_message.assert_called_once_with("test-lead", "status check")
+        finally:
+            await relay.close()
+
+    @pytest.mark.asyncio
+    async def test_cleanup_removes_agent(self):
+        """After relay.close(), agent disappears from the agent list."""
+        config = _live_config()
+        agent_name = _unique_name("swarms-cl")
+        relay = Relay(agent_name, config)
+        probe = Relay(_unique_name("swarms-pr"), config)
+
+        try:
+            agents = await _retry_on_429(relay.agents)
+            assert agent_name in agents
+
+            await relay.close()
+
+            # If close() silently failed to unregister (e.g. 429), retry manually
+            if relay.transport.agent_id is not None:
+                await asyncio.sleep(15)
+                try:
+                    await relay.transport.unregister_agent()
+                except Exception:
+                    pass
+
+            deadline = asyncio.get_event_loop().time() + 35.0
+            absent = False
+            while asyncio.get_event_loop().time() < deadline:
+                try:
+                    current = await probe.agents()
+                except RelayConnectionError as e:
+                    if e.status_code == 429:
+                        await asyncio.sleep(15)
+                        continue
+                    raise
+                if agent_name not in current:
+                    absent = True
+                    break
+                await asyncio.sleep(3.0)
+
+            assert absent, f"Agent {agent_name} still present after close"
+        finally:
+            await probe.close()

package/packages/sdk-py/tests/communicate/adapters/test_agno.py

@@ -0,0 +1,140 @@
+"""Tests for the Agno Python adapter."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+# Mock agno before it's imported in the adapter
+agno_mock = MagicMock()
+sys.modules["agno"] = agno_mock
+sys.modules["agno.agent"] = agno_mock.agent
+
+def _adapter_module():
+    import importlib
+    if "agent_relay.communicate.adapters.agno" in sys.modules:
+        importlib.reload(sys.modules["agent_relay.communicate.adapters.agno"])
+    return importlib.import_module("agent_relay.communicate.adapters.agno")
+
+@pytest.fixture
+def mock_relay():
+    relay = MagicMock()
+    relay.agent_name = "TestAgent"
+    relay.inbox = AsyncMock(return_value=[])
+    relay.peek = AsyncMock(return_value=[])
+    relay.send = AsyncMock()
+    relay.post = AsyncMock()
+    relay.agents = AsyncMock(return_value=[])
+    return relay
+
+@pytest.fixture
+def mock_agent():
+    agent = MagicMock()
+    agent.tools = []
+    agent.instructions = "Agno base instructions."
+    return agent
+
+def test_on_relay_adds_tools(mock_relay, mock_agent):
+    adapter = _adapter_module()
+    
+    adapter.on_relay(mock_agent, mock_relay)
+    
+    tools = {t.__name__: t for t in mock_agent.tools}
+    assert "relay_send" in tools
+    assert "relay_inbox" in tools
+    assert "relay_post" in tools
+    assert "relay_agents" in tools
+
+@pytest.mark.asyncio
+async def test_tool_execution(mock_relay, mock_agent):
+    adapter = _adapter_module()
+    adapter.on_relay(mock_agent, mock_relay)
+    tools = {t.__name__: t for t in mock_agent.tools}
+    
+    # Test relay_send
+    await tools["relay_send"]("Alice", "Hi")
+    mock_relay.send.assert_called_with("Alice", "Hi")
+    
+    # Test relay_inbox
+    from agent_relay.communicate.types import Message
+    mock_relay.inbox.return_value = [Message(sender="Bob", text="Hey")]
+    inbox_res = await tools["relay_inbox"]()
+    assert "From Bob: Hey" in inbox_res
+    
+    # Test relay_post
+    await tools["relay_post"]("general", "Update")
+    mock_relay.post.assert_called_with("general", "Update")
+    
+    # Test relay_agents
+    mock_relay.agents.return_value = ["Alice", "Bob"]
+    agents_res = await tools["relay_agents"]()
+    assert "Alice, Bob" in agents_res
+
+@pytest.mark.asyncio
+async def test_instructions_wrapping(mock_relay, mock_agent):
+    adapter = _adapter_module()
+    from agent_relay.communicate.types import Message
+    
+    mock_relay.peek.return_value = [
+        Message(sender="Other", text="Agno message", message_id="1")
+    ]
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    assert callable(mock_agent.instructions)
+
+    result = await mock_agent.instructions()
+    assert "Agno base instructions." in result
+    assert "Other: Agno message" in result
+
+@pytest.mark.asyncio
+async def test_instructions_wrapping_callable(mock_relay, mock_agent):
+    """Chaining: existing callable instructions are preserved."""
+    adapter = _adapter_module()
+
+    original_instructions = MagicMock(return_value="Dynamic context.")
+    mock_agent.instructions = original_instructions
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    result = await mock_agent.instructions()
+    assert "Dynamic context." in result
+    assert original_instructions.called
+
+
+@pytest.mark.asyncio
+async def test_instructions_wrapping_async_callable(mock_relay, mock_agent):
+    adapter = _adapter_module()
+    from agent_relay.communicate.types import Message
+
+    async def original_instructions():
+        return "Async context."
+
+    mock_agent.instructions = original_instructions
+    mock_relay.peek.return_value = [Message(sender="Other", text="Agno message", message_id="1")]
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    result = await mock_agent.instructions()
+    assert result.startswith("\n\nNew messages from other agents:\n  Other: Agno message\n")
+    assert result.endswith("\n\nAsync context.")
+
+@pytest.mark.asyncio
+async def test_instructions_no_messages(mock_relay, mock_agent):
+    """When inbox is empty, only base instructions returned."""
+    adapter = _adapter_module()
+    mock_relay.peek = AsyncMock(return_value=[])
+
+    adapter.on_relay(mock_agent, mock_relay)
+
+    result = await mock_agent.instructions()
+    assert result == "Agno base instructions."
+
+def test_on_relay_returns_agent(mock_relay, mock_agent):
+    """on_relay() returns the modified agent."""
+    adapter = _adapter_module()
+    result = adapter.on_relay(mock_agent, mock_relay)
+    assert result is mock_agent