open-agent-protocol 0.2.0__tar.gz → 0.2.2__tar.gz

{open_agent_protocol-0.2.0 → open_agent_protocol-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-agent-protocol
-Version: 0.2.0
+Version: 0.2.2
 Summary: Open Agent Protocol — a routing layer for inter-agent task handoff
 Project-URL: Repository, https://github.com/Adam-Abinsha-vahab-Baker/OAP
 Project-URL: Issues, https://github.com/Adam-Abinsha-vahab-Baker/OAP/issues
@@ -64,20 +64,55 @@ print(result.memory["last_result"])
 # Create a new task envelope
 oap init "research the best vector databases" --output task.json
 
-# Route it to an HTTP agent
-oap register research-agent http://localhost:9000 --capabilities "research,search" task.json --output result.json
+# Register an HTTP agent in the local registry
+oap register research-agent http://localhost:9000 --capabilities "research,search,find"
 
-# Inspect the result
+# Route the envelope to the best matching agent
+oap route task.json --output result.json
+
+# Automatically follow handoffs until the task is complete
+oap chain task.json --output final.json
+
+# Inspect an envelope
 oap inspect result.json
 
 # Validate envelope structure
 oap validate result.json
 
-# Route using built-in demo agents
-oap route task.json
-
-# List demo agents
+# List all registered agents
 oap agents
+
+# Remove an agent from the registry
+oap unregister research-agent
+```
+
+## Chaining agents
+
+When an agent sets a `handoff.next_agent` on its response, `oap chain` automatically routes to the next agent and keeps going until the task is complete or a hop limit is reached.
+
+```python
+# Python API
+result, visited = await router.chain(envelope, max_hops=10)
+print(" → ".join(visited))  # e.g. research-agent → summarise-agent
+```
+
+```bash
+# CLI — follows handoffs automatically, prints each hop
+oap chain task.json --output final.json --max-hops 5
+```
+
+The chain stops when:
+- An agent returns a response with no `handoff` set, or
+- `max_hops` is reached (default: 10)
+
+## Registry
+
+Agents are stored in `~/.oap/agents.json` and persist across commands.
+
+```bash
+oap register my-agent http://localhost:9000 --capabilities "research,find"
+oap agents       # list all registered agents
+oap unregister my-agent
 ```
 
 ## Concepts

{open_agent_protocol-0.2.0 → open_agent_protocol-0.2.2}/README.md

@@ -34,20 +34,55 @@ print(result.memory["last_result"])
 # Create a new task envelope
 oap init "research the best vector databases" --output task.json
 
-# Route it to an HTTP agent
-oap register research-agent http://localhost:9000 --capabilities "research,search" task.json --output result.json
+# Register an HTTP agent in the local registry
+oap register research-agent http://localhost:9000 --capabilities "research,search,find"
 
-# Inspect the result
+# Route the envelope to the best matching agent
+oap route task.json --output result.json
+
+# Automatically follow handoffs until the task is complete
+oap chain task.json --output final.json
+
+# Inspect an envelope
 oap inspect result.json
 
 # Validate envelope structure
 oap validate result.json
 
-# Route using built-in demo agents
-oap route task.json
-
-# List demo agents
+# List all registered agents
 oap agents
+
+# Remove an agent from the registry
+oap unregister research-agent
+```
+
+## Chaining agents
+
+When an agent sets a `handoff.next_agent` on its response, `oap chain` automatically routes to the next agent and keeps going until the task is complete or a hop limit is reached.
+
+```python
+# Python API
+result, visited = await router.chain(envelope, max_hops=10)
+print(" → ".join(visited))  # e.g. research-agent → summarise-agent
+```
+
+```bash
+# CLI — follows handoffs automatically, prints each hop
+oap chain task.json --output final.json --max-hops 5
+```
+
+The chain stops when:
+- An agent returns a response with no `handoff` set, or
+- `max_hops` is reached (default: 10)
+
+## Registry
+
+Agents are stored in `~/.oap/agents.json` and persist across commands.
+
+```bash
+oap register my-agent http://localhost:9000 --capabilities "research,find"
+oap agents       # list all registered agents
+oap unregister my-agent
 ```
 
 ## Concepts

{open_agent_protocol-0.2.0 → open_agent_protocol-0.2.2}/oap/cli.py

@@ -1,8 +1,9 @@
 import asyncio
-import json
+import time
 from pathlib import Path
 from typing import Optional
 
+import httpx
 import typer
 from rich.console import Console
 from rich.syntax import Syntax
@@ -11,6 +12,7 @@ from rich.table import Table
 from oap.envelope import TaskEnvelope
 from oap.router import OAPRouter, RoutingError
 from oap import registry
+from oap.transport.http import HTTPTransport
 
 app = typer.Typer(
     name="oap",
@@ -93,12 +95,14 @@ def register(
     agent_id: str = typer.Argument(..., help="Unique name for this agent"),
     url: str = typer.Argument(..., help="Base URL of the agent's HTTP server"),
     capabilities: str = typer.Option(..., "--capabilities", "-c", help="Comma-separated capability keywords"),
+    timeout: float = typer.Option(60.0, "--timeout", "-t", help="Request timeout in seconds"),
 ):
     """Register an HTTP agent in the local registry (~/.oap/agents.json)."""
     caps = [c.strip() for c in capabilities.split(",")]
-    registry.add(agent_id, url, caps)
+    registry.add(agent_id, url, caps, timeout=timeout)
     console.print(f"[green]Registered[/green] [cyan]{agent_id}[/cyan] → {url}")
     console.print(f"[dim]Capabilities:[/dim] {', '.join(caps)}")
+    console.print(f"[dim]Timeout:[/dim] {timeout}s")
 
 
 @app.command()
@@ -158,8 +162,12 @@ def chain(
     file: Path = typer.Argument(..., help="Path to a TaskEnvelope JSON file"),
     output: Optional[Path] = typer.Option(None, "--output", "-o", help="Save final envelope to file"),
     max_hops: int = typer.Option(10, "--max-hops", help="Maximum number of agent hops before stopping"),
+    pipeline: Optional[str] = typer.Option(None, "--pipeline", help="Comma-separated list of agent IDs to invoke in order, bypassing capability matching"),
 ):
-    """Route a TaskEnvelope, automatically following handoffs until the task is complete."""
+    """Route a TaskEnvelope, automatically following handoffs until the task is complete.
+
+    Use --pipeline to force a fixed sequence of agents regardless of handoffs.
+    """
     if not file.exists():
         console.print(f"[red]File not found: {file}[/red]")
         raise typer.Exit(1)
@@ -172,12 +180,26 @@ def chain(
 
     router = registry.load_router()
 
-    def on_hop(hop: int, agent_id: str) -> None:
-        console.print(f"  [dim]hop {hop}:[/dim] [cyan]{agent_id}[/cyan]")
-
     try:
-        console.print(f"[bold]Chaining[/bold] (max {max_hops} hops)...")
-        result, visited = asyncio.run(router.chain(envelope, max_hops=max_hops, on_hop=on_hop))
+        if pipeline:
+            agent_ids = [a.strip() for a in pipeline.split(",")]
+            total = len(agent_ids)
+
+            def on_pipeline_hop(hop: int, tot: int, agent_id: str) -> None:
+                console.print(f"  [dim]hop {hop}/{tot}[/dim] → [cyan]{agent_id}[/cyan]")
+
+            console.print(f"[bold]Pipeline[/bold] ({total} agent(s))...")
+            result, visited = asyncio.run(
+                router.run_pipeline(envelope, agent_ids, on_hop=on_pipeline_hop)
+            )
+        else:
+            def on_hop(hop: int, agent_id: str) -> None:
+                console.print(f"  [dim]hop {hop}:[/dim] [cyan]{agent_id}[/cyan]")
+
+            console.print(f"[bold]Chaining[/bold] (max {max_hops} hops)...")
+            result, visited = asyncio.run(
+                router.chain(envelope, max_hops=max_hops, on_hop=on_hop)
+            )
     except RoutingError as e:
         console.print(f"[red]Routing failed:[/red] {e}")
         raise typer.Exit(1)
@@ -192,6 +214,62 @@ def chain(
         console.print(f"\n[green]Saved to {output}[/green]")
 
 
+@app.command()
+def ping():
+    """Check reachability of all registered agents."""
+    entries = registry.list_all()
+
+    if not entries:
+        console.print("[dim]No agents registered.[/dim]")
+        return
+
+    async def check(entry: dict) -> dict:
+        transport = HTTPTransport(base_url=entry["url"], timeout=5.0)
+        start = time.monotonic()
+        try:
+            response = await transport.get("/")
+            elapsed = int((time.monotonic() - start) * 1000)
+            if response.status_code < 400:
+                return {"id": entry["id"], "status": "alive", "ms": elapsed, "ok": True}
+            return {"id": entry["id"], "status": "no health endpoint", "ms": elapsed, "ok": True}
+        except (httpx.ConnectError, httpx.ReadTimeout, httpx.ConnectTimeout):
+            elapsed = int((time.monotonic() - start) * 1000)
+            return {"id": entry["id"], "status": "dead", "ms": elapsed, "ok": False}
+
+    async def run_all() -> list[dict]:
+        return await asyncio.gather(*[check(e) for e in entries])
+
+    results = asyncio.run(run_all())
+
+    table = Table(show_header=True, header_style="bold dim")
+    table.add_column("Agent ID")
+    table.add_column("URL")
+    table.add_column("Status")
+    table.add_column("ms", justify="right")
+
+    any_dead = False
+    for res, entry in zip(results, entries):
+        if res["status"] == "alive":
+            status_str = "[green]alive[/green]"
+        elif res["status"] == "dead":
+            status_str = "[red]dead[/red]"
+            any_dead = True
+        else:
+            status_str = "[dim]no health endpoint[/dim]"
+
+        table.add_row(
+            f"[cyan]{res['id']}[/cyan]",
+            entry["url"],
+            status_str,
+            str(res["ms"]),
+        )
+
+    console.print(table)
+
+    if any_dead:
+        raise typer.Exit(1)
+
+
 @app.command()
 def agents():
     """List all agents in the local registry."""
@@ -205,12 +283,14 @@ def agents():
     table.add_column("Agent ID")
     table.add_column("URL")
     table.add_column("Capabilities")
+    table.add_column("Timeout")
 
     for entry in entries:
         table.add_row(
             f"[cyan]{entry['id']}[/cyan]",
             entry["url"],
             ", ".join(entry["capabilities"]),
+            f"{entry['timeout']}s",
         )
 
     console.print(table)

{open_agent_protocol-0.2.0 → open_agent_protocol-0.2.2}/oap/registry.py

@@ -7,6 +7,7 @@ from oap.adapters.http import HTTPAdapter
 from oap.router import OAPRouter
 
 _REGISTRY_PATH = Path.home() / ".oap" / "agents.json"
+_DEFAULT_TIMEOUT = 60.0
 
 
 def _load_raw() -> dict[str, dict]:
@@ -20,9 +21,14 @@ def _save_raw(data: dict[str, dict]) -> None:
     _REGISTRY_PATH.write_text(json.dumps(data, indent=2))
 
 
-def add(agent_id: str, url: str, capabilities: list[str]) -> None:
+def add(
+    agent_id: str,
+    url: str,
+    capabilities: list[str],
+    timeout: float = _DEFAULT_TIMEOUT,
+) -> None:
     data = _load_raw()
-    data[agent_id] = {"url": url, "capabilities": capabilities}
+    data[agent_id] = {"url": url, "capabilities": capabilities, "timeout": timeout}
     _save_raw(data)
 
 
@@ -37,7 +43,12 @@ def remove(agent_id: str) -> bool:
 
 def list_all() -> list[dict]:
     return [
-        {"id": agent_id, "url": entry["url"], "capabilities": entry["capabilities"]}
+        {
+            "id": agent_id,
+            "url": entry["url"],
+            "capabilities": entry["capabilities"],
+            "timeout": entry.get("timeout", _DEFAULT_TIMEOUT),
+        }
         for agent_id, entry in _load_raw().items()
     ]
 
@@ -45,9 +56,10 @@ def list_all() -> list[dict]:
 def load_router() -> OAPRouter:
     router = OAPRouter()
     for agent_id, entry in _load_raw().items():
+        timeout = entry.get("timeout", _DEFAULT_TIMEOUT)
         router.register(
             agent_id,
-            HTTPAdapter(agent_id=agent_id, base_url=entry["url"]),
+            HTTPAdapter(agent_id=agent_id, base_url=entry["url"], timeout=timeout),
             entry["capabilities"],
         )
     return router

{open_agent_protocol-0.2.0 → open_agent_protocol-0.2.2}/oap/router.py

@@ -124,4 +124,49 @@ class OAPRouter:
             # Exited loop because max_hops was reached without handoff clearing
             pass
 
-        return current, visited
+        return current, visited
+
+    async def run_pipeline(
+        self,
+        envelope: TaskEnvelope,
+        agent_ids: list[str],
+        on_hop: object = None,
+    ) -> tuple[TaskEnvelope, list[str]]:
+        """Route through a fixed ordered list of agents, ignoring capability matching and handoffs.
+
+        Args:
+            envelope: The starting TaskEnvelope.
+            agent_ids: Ordered list of agent IDs to invoke in sequence.
+            on_hop: Optional callable(hop_number, total, agent_id) invoked after each hop.
+
+        Raises:
+            RoutingError: If any agent_id is not registered.
+
+        Returns:
+            A tuple of (final_envelope, agent_ids).
+        """
+        missing = [aid for aid in agent_ids if aid not in self._agents]
+        if missing:
+            raise RoutingError(
+                f"Pipeline agent(s) not found in registry: {', '.join(missing)}"
+            )
+
+        current = envelope
+        total = len(agent_ids)
+
+        for hop, agent_id in enumerate(agent_ids, 1):
+            adapter = self._agents[agent_id]
+            agent_input = adapter.to_agent_format(current)
+            agent_output = await adapter.invoke(agent_input)
+            current = adapter.to_envelope(agent_output, current)
+            current.handoff = None  # pipeline ignores handoffs
+            current.add_step(
+                agent_id=agent_id,
+                action=f"Pipeline hop {hop}/{total}: {agent_id}",
+                result=agent_output,
+            )
+
+            if on_hop:
+                on_hop(hop, total, agent_id)  # type: ignore[operator]
+
+        return current, agent_ids

open_agent_protocol-0.2.2/oap/transport/http.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import asyncio
+
+import httpx
+
+from oap.envelope import TaskEnvelope
+
+_RETRY_DELAYS = [1.0, 2.0, 4.0]  # seconds between attempts 1→2, 2→3, 3→4
+
+
+class HTTPTransport:
+    def __init__(self, base_url: str, timeout: float = 60.0):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    async def get(self, path: str = "/") -> httpx.Response:
+        """Issue a GET request. Raises httpx exceptions on failure."""
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            return await client.get(f"{self.base_url}{path}")
+
+    async def invoke(self, envelope: TaskEnvelope) -> dict:
+        payload = envelope.model_dump(mode="json")
+        last_exc: Exception | None = None
+        max_attempts = len(_RETRY_DELAYS) + 1  # 4 total
+
+        for attempt in range(1, max_attempts + 1):
+            if attempt > 1:
+                await asyncio.sleep(_RETRY_DELAYS[attempt - 2])
+
+            try:
+                async with httpx.AsyncClient(timeout=self.timeout) as client:
+                    response = await client.post(
+                        f"{self.base_url}/invoke",
+                        json=payload,
+                    )
+
+                if 400 <= response.status_code < 500:
+                    # 4xx — fail immediately, do not retry
+                    raise _make_error(
+                        self.base_url, attempt,
+                        f"HTTP {response.status_code} (not retried)",
+                        retried=False,
+                    )
+
+                if response.status_code >= 500:
+                    last_exc = _make_error(
+                        self.base_url, attempt,
+                        f"HTTP {response.status_code}",
+                    )
+                    continue
+
+                return response.json()
+
+            except (httpx.ConnectError, httpx.ReadTimeout) as exc:
+                last_exc = exc
+                continue
+
+        raise _make_error(
+            self.base_url,
+            max_attempts,
+            str(last_exc),
+            retried=True,
+        )
+
+
+def _make_error(
+    base_url: str,
+    attempts: int,
+    detail: str,
+    retried: bool = True,
+) -> Exception:
+    from oap.router import RoutingError
+
+    suffix = f" after {attempts} attempt(s)" if retried else ""
+    return RoutingError(f"Transport error for {base_url}{suffix}: {detail}")

{open_agent_protocol-0.2.0 → open_agent_protocol-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "open-agent-protocol"
-version = "0.2.0"
+version = "0.2.2"
 description = "Open Agent Protocol — a routing layer for inter-agent task handoff"
 readme = "README.md"
 requires-python = ">=3.11"

{open_agent_protocol-0.2.0 → open_agent_protocol-0.2.2}/tests/test_chain.py

@@ -239,3 +239,163 @@ def test_chain_cli_max_hops_flag(tmp_path, handoff_server):
 
     assert result.exit_code == 0, result.output
     assert "1 hop" in result.output
+
+
+# ---------------------------------------------------------------------------
+# Router-level run_pipeline() tests
+# ---------------------------------------------------------------------------
+
+async def test_pipeline_single_agent():
+    router = make_router(
+        ("agent-a", MockAgentAdapter("agent-a", response="done"), ["research"]),
+    )
+    envelope = TaskEnvelope(goal="research something")
+    result, visited = await router.run_pipeline(envelope, ["agent-a"])
+
+    assert visited == ["agent-a"]
+    assert len(result.steps_taken) == 1
+    assert result.memory["last_result"] == "done"
+
+
+async def test_pipeline_three_hops_in_order():
+    router = make_router(
+        ("agent-a", MockAgentAdapter("agent-a", response="step 1"), ["research"]),
+        ("agent-b", MockAgentAdapter("agent-b", response="step 2"), ["write"]),
+        ("agent-c", MockAgentAdapter("agent-c", response="step 3"), ["translate"]),
+    )
+    envelope = TaskEnvelope(goal="do a thing")
+    result, visited = await router.run_pipeline(envelope, ["agent-a", "agent-b", "agent-c"])
+
+    assert visited == ["agent-a", "agent-b", "agent-c"]
+    assert len(result.steps_taken) == 3
+    assert result.memory["last_result"] == "step 3"
+
+
+async def test_pipeline_ignores_handoff():
+    # agent-a wants to hand off to agent-c, but pipeline forces agent-b next
+    router = make_router(
+        ("agent-a", MockAgentAdapter("agent-a", response="step 1", next_agent="agent-c"), ["research"]),
+        ("agent-b", MockAgentAdapter("agent-b", response="step 2"), ["write"]),
+    )
+    envelope = TaskEnvelope(goal="research something")
+    result, visited = await router.run_pipeline(envelope, ["agent-a", "agent-b"])
+
+    assert visited == ["agent-a", "agent-b"]
+    assert result.handoff is None
+
+
+async def test_pipeline_unknown_agent_raises():
+    router = make_router(
+        ("agent-a", MockAgentAdapter("agent-a"), ["research"]),
+    )
+    envelope = TaskEnvelope(goal="do something")
+    with pytest.raises(RoutingError, match="not found in registry"):
+        await router.run_pipeline(envelope, ["agent-a", "ghost-agent"])
+
+
+async def test_pipeline_preserves_goal_and_id():
+    router = make_router(
+        ("agent-a", MockAgentAdapter("agent-a"), ["research"]),
+        ("agent-b", MockAgentAdapter("agent-b"), ["write"]),
+    )
+    envelope = TaskEnvelope(goal="research something")
+    result, _ = await router.run_pipeline(envelope, ["agent-a", "agent-b"])
+
+    assert result.goal == envelope.goal
+    assert result.id == envelope.id
+
+
+async def test_pipeline_step_labels():
+    router = make_router(
+        ("agent-a", MockAgentAdapter("agent-a"), ["research"]),
+        ("agent-b", MockAgentAdapter("agent-b"), ["write"]),
+    )
+    envelope = TaskEnvelope(goal="research something")
+    result, _ = await router.run_pipeline(envelope, ["agent-a", "agent-b"])
+
+    assert "1/2" in result.steps_taken[0].action
+    assert "2/2" in result.steps_taken[1].action
+
+
+# ---------------------------------------------------------------------------
+# CLI --pipeline tests
+# ---------------------------------------------------------------------------
+
+def test_pipeline_cli_three_hops(tmp_path, handoff_server):
+    HandoffAgentHandler.call_count = 99  # force "done" response for all calls
+
+    task = tmp_path / "task.json"
+    out = tmp_path / "final.json"
+    runner.invoke(app, ["init", "do a thing", "--output", str(task)])
+    runner.invoke(app, ["register", "agent-a", handoff_server, "--capabilities", "research"])
+    runner.invoke(app, ["register", "agent-b", handoff_server, "--capabilities", "write"])
+    runner.invoke(app, ["register", "agent-c", handoff_server, "--capabilities", "translate"])
+
+    result = runner.invoke(app, [
+        "chain", str(task),
+        "--pipeline", "agent-a,agent-b,agent-c",
+        "--output", str(out),
+    ])
+
+    assert result.exit_code == 0, result.output
+    assert "hop 1/3" in result.output
+    assert "hop 2/3" in result.output
+    assert "hop 3/3" in result.output
+    assert "3 hop(s)" in result.output
+    assert out.exists()
+    data = json.loads(out.read_text())
+    assert len(data["steps_taken"]) == 3
+
+
+def test_pipeline_cli_single_agent(tmp_path, handoff_server):
+    HandoffAgentHandler.call_count = 99
+
+    task = tmp_path / "task.json"
+    out = tmp_path / "final.json"
+    runner.invoke(app, ["init", "do a thing", "--output", str(task)])
+    runner.invoke(app, ["register", "agent-a", handoff_server, "--capabilities", "research"])
+
+    result = runner.invoke(app, [
+        "chain", str(task),
+        "--pipeline", "agent-a",
+        "--output", str(out),
+    ])
+
+    assert result.exit_code == 0, result.output
+    assert "1 hop(s)" in result.output
+    assert out.exists()
+
+
+def test_pipeline_cli_unknown_agent(tmp_path, handoff_server):
+    task = tmp_path / "task.json"
+    runner.invoke(app, ["init", "do a thing", "--output", str(task)])
+    runner.invoke(app, ["register", "agent-a", handoff_server, "--capabilities", "research"])
+
+    result = runner.invoke(app, [
+        "chain", str(task),
+        "--pipeline", "agent-a,ghost-agent",
+    ])
+
+    assert result.exit_code == 1
+    assert "Routing failed" in result.output
+    assert "ghost-agent" in result.output
+
+
+def test_pipeline_cli_output_saved(tmp_path, handoff_server):
+    HandoffAgentHandler.call_count = 99
+
+    task = tmp_path / "task.json"
+    out = tmp_path / "final.json"
+    runner.invoke(app, ["init", "do a thing", "--output", str(task)])
+    runner.invoke(app, ["register", "agent-a", handoff_server, "--capabilities", "research"])
+
+    runner.invoke(app, [
+        "chain", str(task),
+        "--pipeline", "agent-a",
+        "--output", str(out),
+    ])
+
+    assert out.exists()
+    data = json.loads(out.read_text())
+    assert data["goal"] == "do a thing"
+    assert len(data["steps_taken"]) == 1

{open_agent_protocol-0.2.0 → open_agent_protocol-0.2.2}/tests/test_registry.py

@@ -20,6 +20,7 @@ def test_add_and_list():
         "id": "agent-a",
         "url": "http://localhost:9000",
         "capabilities": ["research", "find"],
+        "timeout": 60.0,
     }
 
 

open_agent_protocol-0.2.2/tests/test_transport.py

@@ -0,0 +1,263 @@
+"""Tests for HTTPTransport retry/backoff logic and oap ping CLI command."""
+from __future__ import annotations
+
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import httpx
+import pytest
+import respx
+from typer.testing import CliRunner
+
+from oap.cli import app
+from oap.envelope import TaskEnvelope
+from oap.router import RoutingError
+from oap.transport.http import HTTPTransport
+import oap.registry as reg
+
+runner = CliRunner()
+_PING_PORT = 19996
+
+
+# ---------------------------------------------------------------------------
+# Fake server for ping tests
+# ---------------------------------------------------------------------------
+
+class PingHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(b"ok")
+
+    def do_POST(self):
+        length = int(self.headers["Content-Length"])
+        self.rfile.read(length)
+        body = json.dumps({"result": "ok", "memory": {}})
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(body.encode())
+
+    def log_message(self, format, *args):
+        pass
+
+
+@pytest.fixture(scope="module")
+def ping_server():
+    server = HTTPServer(("localhost", _PING_PORT), PingHandler)
+    thread = threading.Thread(target=server.serve_forever)
+    thread.daemon = True
+    thread.start()
+    yield f"http://localhost:{_PING_PORT}"
+    server.shutdown()
+
+
+@pytest.fixture(autouse=True)
+def isolated_registry(tmp_path, monkeypatch):
+    monkeypatch.setattr(reg, "_REGISTRY_PATH", tmp_path / "agents.json")
+
+
+# ---------------------------------------------------------------------------
+# HTTPTransport retry tests (using respx to mock httpx)
+# ---------------------------------------------------------------------------
+
+@respx.mock
+async def test_retry_succeeds_on_second_attempt():
+    """ReadTimeout on attempt 1, success on attempt 2."""
+    envelope = TaskEnvelope(goal="test")
+    transport = HTTPTransport(base_url="http://fake-agent", timeout=1.0)
+
+    route = respx.post("http://fake-agent/invoke")
+    route.side_effect = [
+        httpx.ReadTimeout("timed out"),
+        httpx.Response(200, json={"result": "ok", "memory": {}}),
+    ]
+
+    # Patch sleep so the test doesn't actually wait
+    import oap.transport.http as http_mod
+    original_sleep = http_mod.asyncio.sleep
+    http_mod.asyncio.sleep = lambda _: original_sleep(0)
+
+    result = await transport.invoke(envelope)
+    assert result["result"] == "ok"
+    assert route.call_count == 2
+
+    http_mod.asyncio.sleep = original_sleep
+
+
+@respx.mock
+async def test_retry_exhausted_raises_routing_error():
+    """All 4 attempts fail — raises RoutingError mentioning attempt count."""
+    envelope = TaskEnvelope(goal="test")
+    transport = HTTPTransport(base_url="http://fake-agent", timeout=1.0)
+
+    respx.post("http://fake-agent/invoke").mock(
+        side_effect=httpx.ReadTimeout("timed out")
+    )
+
+    import oap.transport.http as http_mod
+    original_sleep = http_mod.asyncio.sleep
+    http_mod.asyncio.sleep = lambda _: original_sleep(0)
+
+    with pytest.raises(RoutingError) as exc_info:
+        await transport.invoke(envelope)
+
+    http_mod.asyncio.sleep = original_sleep
+
+    assert "4 attempt(s)" in str(exc_info.value)
+    assert "http://fake-agent" in str(exc_info.value)
+
+
+@respx.mock
+async def test_connect_error_triggers_retry():
+    """ConnectError on attempt 1, success on attempt 2."""
+    envelope = TaskEnvelope(goal="test")
+    transport = HTTPTransport(base_url="http://fake-agent", timeout=1.0)
+
+    route = respx.post("http://fake-agent/invoke")
+    route.side_effect = [
+        httpx.ConnectError("connection refused"),
+        httpx.Response(200, json={"result": "ok", "memory": {}}),
+    ]
+
+    import oap.transport.http as http_mod
+    original_sleep = http_mod.asyncio.sleep
+    http_mod.asyncio.sleep = lambda _: original_sleep(0)
+
+    result = await transport.invoke(envelope)
+    assert result["result"] == "ok"
+    assert route.call_count == 2
+
+    http_mod.asyncio.sleep = original_sleep
+
+
+@respx.mock
+async def test_5xx_triggers_retry():
+    """500 on attempt 1, success on attempt 2."""
+    envelope = TaskEnvelope(goal="test")
+    transport = HTTPTransport(base_url="http://fake-agent", timeout=1.0)
+
+    route = respx.post("http://fake-agent/invoke")
+    route.side_effect = [
+        httpx.Response(500, text="internal error"),
+        httpx.Response(200, json={"result": "ok", "memory": {}}),
+    ]
+
+    import oap.transport.http as http_mod
+    original_sleep = http_mod.asyncio.sleep
+    http_mod.asyncio.sleep = lambda _: original_sleep(0)
+
+    result = await transport.invoke(envelope)
+    assert result["result"] == "ok"
+    assert route.call_count == 2
+
+    http_mod.asyncio.sleep = original_sleep
+
+
+@respx.mock
+async def test_4xx_does_not_retry():
+    """404 fails immediately without retrying."""
+    envelope = TaskEnvelope(goal="test")
+    transport = HTTPTransport(base_url="http://fake-agent", timeout=1.0)
+
+    route = respx.post("http://fake-agent/invoke").mock(
+        return_value=httpx.Response(404, text="not found")
+    )
+
+    with pytest.raises(RoutingError) as exc_info:
+        await transport.invoke(envelope)
+
+    assert route.call_count == 1
+    assert "HTTP 404" in str(exc_info.value)
+    assert "not retried" in str(exc_info.value)
+
+
+# ---------------------------------------------------------------------------
+# Timeout wired through registry → HTTPAdapter → HTTPTransport
+# ---------------------------------------------------------------------------
+
+def test_timeout_saved_in_registry():
+    reg.add("agent-a", "http://localhost:9000", ["research"], timeout=120.0)
+    entries = reg.list_all()
+    assert entries[0]["timeout"] == 120.0
+
+
+def test_timeout_default_in_registry():
+    reg.add("agent-a", "http://localhost:9000", ["research"])
+    entries = reg.list_all()
+    assert entries[0]["timeout"] == 60.0
+
+
+def test_timeout_passed_to_http_adapter():
+    reg.add("agent-a", "http://localhost:9000", ["research"], timeout=45.0)
+    router = reg.load_router()
+    # Reach into the adapter to verify timeout was wired through
+    adapter = router._agents["agent-a"]
+    assert adapter.transport.timeout == 45.0
+
+
+def test_register_cli_saves_timeout(ping_server):
+    result = runner.invoke(app, [
+        "register", "agent-a", ping_server,
+        "--capabilities", "research",
+        "--timeout", "90",
+    ])
+    assert result.exit_code == 0
+    assert "90" in result.output
+    entries = reg.list_all()
+    assert entries[0]["timeout"] == 90.0
+
+
+# ---------------------------------------------------------------------------
+# oap ping tests
+# ---------------------------------------------------------------------------
+
+def test_ping_alive_agent(ping_server):
+    runner.invoke(app, ["register", "agent-a", ping_server, "--capabilities", "research"])
+    result = runner.invoke(app, ["ping"])
+    assert result.exit_code == 0
+    assert "alive" in result.output
+    assert "agent-a" in result.output
+
+
+def test_ping_dead_agent():
+    runner.invoke(app, ["register", "dead-agent", "http://localhost:19990", "--capabilities", "research"])
+    result = runner.invoke(app, ["ping"])
+    assert result.exit_code == 1
+    assert "dead" in result.output
+    assert "dead-agent" in result.output
+
+
+def test_ping_mixed_exits_1(ping_server):
+    """One alive, one dead → exit code 1."""
+    runner.invoke(app, ["register", "alive-agent", ping_server, "--capabilities", "research"])
+    runner.invoke(app, ["register", "dead-agent", "http://localhost:19990", "--capabilities", "code"])
+    result = runner.invoke(app, ["ping"])
+    assert result.exit_code == 1
+    assert "alive" in result.output
+    assert "dead" in result.output
+
+
+def test_ping_no_health_endpoint(ping_server):
+    """A 404 on GET / is 'no health endpoint', not dead — exit 0."""
+    # The fake_agent_server returns 404 for GET /
+    from tests.fake_agent_server import FakeAgentHandler
+    _port = 19995
+    server = HTTPServer(("localhost", _port), FakeAgentHandler)
+    t = threading.Thread(target=server.serve_forever)
+    t.daemon = True
+    t.start()
+
+    runner.invoke(app, ["register", "no-health", f"http://localhost:{_port}", "--capabilities", "research"])
+    result = runner.invoke(app, ["ping"])
+    assert result.exit_code == 0
+    assert "no health endpoint" in result.output
+
+    server.shutdown()
+
+
+def test_ping_no_agents_registered():
+    result = runner.invoke(app, ["ping"])
+    assert result.exit_code == 0
+    assert "No agents registered" in result.output

open_agent_protocol-0.2.0/oap/transport/http.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-import httpx
-from oap.envelope import TaskEnvelope
-
-
-class HTTPTransport:
-    def __init__(self, base_url: str, timeout: float = 30.0):
-        self.base_url = base_url.rstrip("/")
-        self.timeout = timeout
-
-    async def invoke(self, envelope: TaskEnvelope) -> dict:
-        payload = envelope.model_dump(mode="json")
-        async with httpx.AsyncClient(timeout=self.timeout) as client:
-            response = await client.post(
-                f"{self.base_url}/invoke",
-                json=payload,
-            )
-            response.raise_for_status()
-            return response.json()