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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-agent-protocol
-Version: 0.2.2
+Version: 0.2.3
 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,7 +64,9 @@ print(result.memory["last_result"])
 # Create a new task envelope
 oap init "research the best vector databases" --output task.json
 
-# Register an HTTP agent in the local registry
+# Register an HTTP agent — OAP discovers capabilities automatically from GET /
+oap register research-agent http://localhost:9000
+# Falls back to manual capabilities if the agent has no GET / endpoint
 oap register research-agent http://localhost:9000 --capabilities "research,search,find"
 
 # Route the envelope to the best matching agent
@@ -109,12 +111,35 @@ The chain stops when:
 
 Agents are stored in `~/.oap/agents.json` and persist across commands.
 
+When an agent implements `GET /` returning `{agent_id, capabilities, description}`, registration is automatic:
+
 ```bash
+oap register my-agent http://localhost:9000
+# → OAP hits GET /, reads capabilities and description, saves everything
+
 oap register my-agent http://localhost:9000 --capabilities "research,find"
-oap agents       # list all registered agents
+# → fallback: use provided capabilities if GET / is unavailable
+
+oap agents          # list all registered agents with description column
+oap ping            # health-check all agents, auto-updates capabilities if changed
 oap unregister my-agent
 ```
 
+### Agent health endpoint
+
+Add `GET /` to your agent to enable self-registration and health checks:
+
+```python
+@app.get("/")
+async def info():
+    return {
+        "agent_id": "my-agent",
+        "capabilities": ["research", "find", "search"],
+        "description": "Researches topics and returns structured findings.",
+        "status": "ok",
+    }
+```
+
 ## Concepts
 
 - **TaskEnvelope** — the standard task object passed between agents. Contains the goal, memory, steps taken, and optional constraints.

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

@@ -34,7 +34,9 @@ print(result.memory["last_result"])
 # Create a new task envelope
 oap init "research the best vector databases" --output task.json
 
-# Register an HTTP agent in the local registry
+# Register an HTTP agent — OAP discovers capabilities automatically from GET /
+oap register research-agent http://localhost:9000
+# Falls back to manual capabilities if the agent has no GET / endpoint
 oap register research-agent http://localhost:9000 --capabilities "research,search,find"
 
 # Route the envelope to the best matching agent
@@ -79,12 +81,35 @@ The chain stops when:
 
 Agents are stored in `~/.oap/agents.json` and persist across commands.
 
+When an agent implements `GET /` returning `{agent_id, capabilities, description}`, registration is automatic:
+
 ```bash
+oap register my-agent http://localhost:9000
+# → OAP hits GET /, reads capabilities and description, saves everything
+
 oap register my-agent http://localhost:9000 --capabilities "research,find"
-oap agents       # list all registered agents
+# → fallback: use provided capabilities if GET / is unavailable
+
+oap agents          # list all registered agents with description column
+oap ping            # health-check all agents, auto-updates capabilities if changed
 oap unregister my-agent
 ```
 
+### Agent health endpoint
+
+Add `GET /` to your agent to enable self-registration and health checks:
+
+```python
+@app.get("/")
+async def info():
+    return {
+        "agent_id": "my-agent",
+        "capabilities": ["research", "find", "search"],
+        "description": "Researches topics and returns structured findings.",
+        "status": "ok",
+    }
+```
+
 ## Concepts
 
 - **TaskEnvelope** — the standard task object passed between agents. Contains the goal, memory, steps taken, and optional constraints.

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import time
 from pathlib import Path
@@ -22,6 +24,29 @@ app = typer.Typer(
 console = Console()
 
 
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+async def _fetch_agent_info(url: str, timeout: float = 5.0) -> dict | None:
+    """Hit GET / on an agent URL. Returns parsed JSON or None on failure."""
+    transport = HTTPTransport(base_url=url, timeout=timeout)
+    try:
+        response = await transport.get("/")
+        if response.status_code == 200:
+            try:
+                return response.json()
+            except Exception:
+                return None
+    except (httpx.ConnectError, httpx.ReadTimeout, httpx.ConnectTimeout):
+        pass
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
 @app.command()
 def init(
     goal: str = typer.Argument(..., help="The task goal for this envelope"),
@@ -30,9 +55,7 @@ def init(
     """Create a new TaskEnvelope and print it."""
     envelope = TaskEnvelope(goal=goal)
     json_str = envelope.model_dump_json(indent=2)
-
     console.print(Syntax(json_str, "json", theme="monokai"))
-
     if output:
         output.write_text(json_str)
         console.print(f"\n[green]Saved to {output}[/green]")
@@ -94,14 +117,48 @@ def validate(
 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"),
+    capabilities: Optional[str] = typer.Option(None, "--capabilities", "-c", help="Comma-separated capability keywords (fallback if GET / returns none)"),
     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, timeout=timeout)
-    console.print(f"[green]Registered[/green] [cyan]{agent_id}[/cyan] → {url}")
-    console.print(f"[dim]Capabilities:[/dim] {', '.join(caps)}")
+    """Register an HTTP agent. Discovers capabilities automatically from GET /."""
+    info = asyncio.run(_fetch_agent_info(url, timeout=timeout))
+
+    discovered_caps: list[str] = []
+    description = ""
+    source = "manual"
+
+    if info and info.get("capabilities"):
+        discovered_caps = [c.strip() for c in info["capabilities"]]
+        description = info.get("description", "")
+        source = "discovered"
+        console.print(f"[dim]Discovered from agent:[/dim] capabilities={discovered_caps}")
+        if description:
+            console.print(f"[dim]Description:[/dim] {description}")
+    elif capabilities:
+        discovered_caps = [c.strip() for c in capabilities.split(",")]
+    else:
+        # GET / either failed or returned no capabilities — and no --capabilities given
+        if info is None:
+            console.print(
+                f"[red]Agent at {url} has no GET / endpoint.[/red]\n"
+                f"Add one that returns {{agent_id, capabilities, description}} "
+                f"or pass [bold]--capabilities[/bold] manually."
+            )
+        else:
+            console.print(
+                f"[red]Agent at {url} returned no capabilities.[/red]\n"
+                f"Add a GET / endpoint that returns {{agent_id, capabilities, description}} "
+                f"or pass [bold]--capabilities[/bold] manually."
+            )
+        raise typer.Exit(1)
+
+    # Use agent_id from GET / response if present, otherwise use CLI argument
+    final_agent_id = (info or {}).get("agent_id") or agent_id
+
+    registry.add(final_agent_id, url, discovered_caps, timeout=timeout, description=description)
+
+    console.print(f"[green]Registered[/green] [cyan]{final_agent_id}[/cyan] → {url} [dim]({source})[/dim]")
+    console.print(f"[dim]Capabilities:[/dim] {', '.join(discovered_caps)}")
     console.print(f"[dim]Timeout:[/dim] {timeout}s")
 
 
@@ -216,7 +273,7 @@ def chain(
 
 @app.command()
 def ping():
-    """Check reachability of all registered agents."""
+    """Check reachability of all registered agents. Updates capabilities if changed."""
     entries = registry.list_all()
 
     if not entries:
@@ -229,17 +286,48 @@ def ping():
         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}
+
+            if response.status_code >= 400:
+                return {
+                    "id": entry["id"], "status": "no health endpoint",
+                    "ms": elapsed, "ok": True,
+                    "caps_updated": False, "new_caps": None,
+                }
+
+            # Alive — check if capabilities changed
+            caps_updated = False
+            new_caps = None
+            try:
+                info = response.json()
+                remote_caps = info.get("capabilities")
+                remote_desc = info.get("description", "")
+                if remote_caps and sorted(remote_caps) != sorted(entry["capabilities"]):
+                    registry.add(
+                        entry["id"], entry["url"], remote_caps,
+                        timeout=entry["timeout"], description=remote_desc,
+                    )
+                    caps_updated = True
+                    new_caps = remote_caps
+            except Exception:
+                pass
+
+            return {
+                "id": entry["id"], "status": "alive",
+                "ms": elapsed, "ok": True,
+                "caps_updated": caps_updated, "new_caps": new_caps,
+            }
         except (httpx.ConnectError, httpx.ReadTimeout, httpx.ConnectTimeout):
             elapsed = int((time.monotonic() - start) * 1000)
-            return {"id": entry["id"], "status": "dead", "ms": elapsed, "ok": False}
+            return {
+                "id": entry["id"], "status": "dead",
+                "ms": elapsed, "ok": False,
+                "caps_updated": False, "new_caps": None,
+            }
 
-    async def run_all() -> list[dict]:
+    async def _run_all() -> list[dict]:
         return await asyncio.gather(*[check(e) for e in entries])
 
-    results = asyncio.run(run_all())
+    results = asyncio.run(_run_all())
 
     table = Table(show_header=True, header_style="bold dim")
     table.add_column("Agent ID")
@@ -250,7 +338,8 @@ def ping():
     any_dead = False
     for res, entry in zip(results, entries):
         if res["status"] == "alive":
-            status_str = "[green]alive[/green]"
+            note = " [yellow](capabilities updated)[/yellow]" if res["caps_updated"] else ""
+            status_str = f"[green]alive[/green]{note}"
         elif res["status"] == "dead":
             status_str = "[red]dead[/red]"
             any_dead = True
@@ -284,6 +373,7 @@ def agents():
     table.add_column("URL")
     table.add_column("Capabilities")
     table.add_column("Timeout")
+    table.add_column("Description")
 
     for entry in entries:
         table.add_row(
@@ -291,6 +381,7 @@ def agents():
             entry["url"],
             ", ".join(entry["capabilities"]),
             f"{entry['timeout']}s",
+            entry.get("description", "") or "—",
         )
 
     console.print(table)

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

@@ -26,9 +26,15 @@ def add(
     url: str,
     capabilities: list[str],
     timeout: float = _DEFAULT_TIMEOUT,
+    description: str = "",
 ) -> None:
     data = _load_raw()
-    data[agent_id] = {"url": url, "capabilities": capabilities, "timeout": timeout}
+    data[agent_id] = {
+        "url": url,
+        "capabilities": capabilities,
+        "timeout": timeout,
+        "description": description,
+    }
     _save_raw(data)
 
 
@@ -48,6 +54,7 @@ def list_all() -> list[dict]:
             "url": entry["url"],
             "capabilities": entry["capabilities"],
             "timeout": entry.get("timeout", _DEFAULT_TIMEOUT),
+            "description": entry.get("description", ""),
         }
         for agent_id, entry in _load_raw().items()
     ]

open_agent_protocol-0.2.3/oap-demo/research_agent.py

@@ -0,0 +1,47 @@
+"""
+Research agent demo — implements the OAP agent interface.
+
+Endpoints:
+  GET  /        → health + capability info (used by oap ping and oap register)
+  POST /invoke  → receives a TaskEnvelope, returns result + optional handoff
+"""
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+AGENT_ID = "research-agent"
+CAPABILITIES = ["research", "find", "search", "analyse", "compare"]
+DESCRIPTION = (
+    "I research topics thoroughly, find information from multiple angles, "
+    "analyse options and summarise findings across any domain."
+)
+
+
+@app.get("/")
+async def info():
+    return {
+        "agent_id": AGENT_ID,
+        "capabilities": CAPABILITIES,
+        "description": DESCRIPTION,
+        "status": "ok",
+    }
+
+
+class InvokeRequest(BaseModel):
+    goal: str
+    memory: dict = {}
+
+
+@app.post("/invoke")
+async def invoke(request: InvokeRequest):
+    # TODO: replace stub with real Claude Bedrock call
+    return {
+        "result": f"[{AGENT_ID}] Researched: {request.goal}",
+        "memory": {"researched_by": AGENT_ID},
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001)

open_agent_protocol-0.2.3/oap-demo/translator_agent.py

@@ -0,0 +1,47 @@
+"""
+Translator agent demo — implements the OAP agent interface.
+
+Endpoints:
+  GET  /        → health + capability info (used by oap ping and oap register)
+  POST /invoke  → receives a TaskEnvelope, returns result + optional handoff
+"""
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+AGENT_ID = "translator-agent"
+CAPABILITIES = ["translate", "simplify", "explain"]
+DESCRIPTION = (
+    "I rewrite technical content for non-technical audiences. "
+    "I use plain English, analogies and friendly language to make complex topics accessible to anyone."
+)
+
+
+@app.get("/")
+async def info():
+    return {
+        "agent_id": AGENT_ID,
+        "capabilities": CAPABILITIES,
+        "description": DESCRIPTION,
+        "status": "ok",
+    }
+
+
+class InvokeRequest(BaseModel):
+    goal: str
+    memory: dict = {}
+
+
+@app.post("/invoke")
+async def invoke(request: InvokeRequest):
+    # TODO: replace stub with real Claude Bedrock call
+    return {
+        "result": f"[{AGENT_ID}] Simplified for general audience: {request.goal}",
+        "memory": {"translated_by": AGENT_ID},
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8003)

open_agent_protocol-0.2.3/oap-demo/writer_agent.py

@@ -0,0 +1,47 @@
+"""
+Writer agent demo — implements the OAP agent interface.
+
+Endpoints:
+  GET  /        → health + capability info (used by oap ping and oap register)
+  POST /invoke  → receives a TaskEnvelope, returns result + optional handoff
+"""
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+AGENT_ID = "writer-agent"
+CAPABILITIES = ["write", "report", "summarise", "draft"]
+DESCRIPTION = (
+    "I write clear, well-structured reports and documents based on research findings. "
+    "I turn raw information into polished readable content."
+)
+
+
+@app.get("/")
+async def info():
+    return {
+        "agent_id": AGENT_ID,
+        "capabilities": CAPABILITIES,
+        "description": DESCRIPTION,
+        "status": "ok",
+    }
+
+
+class InvokeRequest(BaseModel):
+    goal: str
+    memory: dict = {}
+
+
+@app.post("/invoke")
+async def invoke(request: InvokeRequest):
+    # TODO: replace stub with real Claude Bedrock call
+    return {
+        "result": f"[{AGENT_ID}] Drafted report for: {request.goal}",
+        "memory": {"written_by": AGENT_ID},
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8002)

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

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

open_agent_protocol-0.2.3/tests/test_register.py

@@ -0,0 +1,229 @@
+"""Tests for the self-describing oap register command."""
+from __future__ import annotations
+
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import pytest
+from typer.testing import CliRunner
+
+from oap.cli import app
+import oap.registry as reg
+
+runner = CliRunner()
+
+_REG_PORT = 19993
+_REG_PORT_NO_HEALTH = 19992
+_REG_PORT_NO_CAPS = 19991
+
+
+# ---------------------------------------------------------------------------
+# Fake servers
+# ---------------------------------------------------------------------------
+
+class SelfDescribingHandler(BaseHTTPRequestHandler):
+    """Returns full agent info on GET /, accepts POST /invoke."""
+
+    agent_info = {
+        "agent_id": "research-agent",
+        "capabilities": ["research", "find", "search", "analyse"],
+        "description": "Researches topics thoroughly.",
+        "status": "ok",
+    }
+
+    def do_GET(self):
+        body = json.dumps(self.agent_info).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_POST(self):
+        length = int(self.headers["Content-Length"])
+        self.rfile.read(length)
+        body = json.dumps({"result": "done", "memory": {}}).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, format, *args):
+        pass
+
+
+class NoCapsHandler(BaseHTTPRequestHandler):
+    """GET / returns 200 but no capabilities field."""
+
+    def do_GET(self):
+        body = json.dumps({"agent_id": "empty-agent", "status": "ok"}).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, format, *args):
+        pass
+
+
+@pytest.fixture(scope="module")
+def self_describing_server():
+    server = HTTPServer(("localhost", _REG_PORT), SelfDescribingHandler)
+    t = threading.Thread(target=server.serve_forever)
+    t.daemon = True
+    t.start()
+    yield f"http://localhost:{_REG_PORT}"
+    server.shutdown()
+
+
+@pytest.fixture(scope="module")
+def no_caps_server():
+    server = HTTPServer(("localhost", _REG_PORT_NO_CAPS), NoCapsHandler)
+    t = threading.Thread(target=server.serve_forever)
+    t.daemon = True
+    t.start()
+    yield f"http://localhost:{_REG_PORT_NO_CAPS}"
+    server.shutdown()
+
+
+@pytest.fixture(autouse=True)
+def isolated_registry(tmp_path, monkeypatch):
+    monkeypatch.setattr(reg, "_REGISTRY_PATH", tmp_path / "agents.json")
+
+
+# ---------------------------------------------------------------------------
+# Discovery tests
+# ---------------------------------------------------------------------------
+
+def test_register_discovers_capabilities(self_describing_server):
+    result = runner.invoke(app, ["register", "my-agent", self_describing_server])
+    assert result.exit_code == 0, result.output
+    assert "Discovered" in result.output
+
+    entries = reg.list_all()
+    assert len(entries) == 1
+    assert sorted(entries[0]["capabilities"]) == sorted(["research", "find", "search", "analyse"])
+
+
+def test_register_discovers_description(self_describing_server):
+    runner.invoke(app, ["register", "my-agent", self_describing_server])
+    entries = reg.list_all()
+    assert entries[0]["description"] == "Researches topics thoroughly."
+
+
+def test_register_uses_agent_id_from_response(self_describing_server):
+    """The agent_id from GET / should override the CLI positional argument."""
+    runner.invoke(app, ["register", "cli-given-id", self_describing_server])
+    entries = reg.list_all()
+    assert entries[0]["id"] == "research-agent"
+
+
+def test_register_fallback_to_capabilities_flag_on_no_endpoint():
+    """GET / fails (nothing listening) → fall back to --capabilities."""
+    result = runner.invoke(app, [
+        "register", "my-agent", "http://localhost:19980",
+        "--capabilities", "research,find",
+    ])
+    assert result.exit_code == 0, result.output
+    entries = reg.list_all()
+    assert sorted(entries[0]["capabilities"]) == sorted(["research", "find"])
+
+
+def test_register_error_when_no_endpoint_and_no_caps():
+    """GET / fails and no --capabilities → clear error, exit 1."""
+    result = runner.invoke(app, ["register", "my-agent", "http://localhost:19980"])
+    assert result.exit_code == 1
+    assert "no GET / endpoint" in result.output
+    assert "--capabilities" in result.output
+
+
+def test_register_fallback_when_no_caps_in_response(no_caps_server):
+    """GET / returns 200 but no capabilities → fall back to --capabilities."""
+    result = runner.invoke(app, [
+        "register", "my-agent", no_caps_server,
+        "--capabilities", "research,find",
+    ])
+    assert result.exit_code == 0, result.output
+    entries = reg.list_all()
+    assert "research" in entries[0]["capabilities"]
+
+
+def test_register_error_when_no_caps_in_response_and_no_flag(no_caps_server):
+    """GET / returns 200 but no capabilities and no --capabilities → exit 1."""
+    result = runner.invoke(app, ["register", "my-agent", no_caps_server])
+    assert result.exit_code == 1
+    assert "returned no capabilities" in result.output
+
+
+def test_register_saves_description_as_empty_for_manual_registration():
+    """Manual --capabilities registration stores empty description."""
+    runner.invoke(app, [
+        "register", "my-agent", "http://localhost:19980",
+        "--capabilities", "research",
+    ])
+    entries = reg.list_all()
+    assert entries[0]["description"] == ""
+
+
+# ---------------------------------------------------------------------------
+# ping capability update tests
+# ---------------------------------------------------------------------------
+
+def test_ping_updates_capabilities_when_changed(self_describing_server):
+    """ping re-reads GET / and updates capabilities when they differ."""
+    # Register with stale capabilities
+    reg.add("research-agent", self_describing_server, ["old-cap"], description="old")
+
+    result = runner.invoke(app, ["ping"])
+    assert result.exit_code == 0, result.output
+    assert "capabilities updated" in result.output
+
+    entries = reg.list_all()
+    assert sorted(entries[0]["capabilities"]) == sorted(["research", "find", "search", "analyse"])
+
+
+def test_ping_no_update_when_capabilities_match(self_describing_server):
+    """ping does not show 'capabilities updated' when nothing changed."""
+    reg.add(
+        "research-agent", self_describing_server,
+        ["research", "find", "search", "analyse"],
+        description="Researches topics thoroughly.",
+    )
+    result = runner.invoke(app, ["ping"])
+    assert result.exit_code == 0, result.output
+    assert "capabilities updated" not in result.output
+
+
+# ---------------------------------------------------------------------------
+# oap agents description column
+# ---------------------------------------------------------------------------
+
+def test_agents_shows_description_column(self_describing_server):
+    runner.invoke(app, ["register", "my-agent", self_describing_server])
+    result = runner.invoke(app, ["agents"])
+    assert result.exit_code == 0
+    assert "Description" in result.output
+    assert "Researches" in result.output
+
+
+def test_agents_shows_dash_for_empty_description():
+    reg.add("my-agent", "http://localhost:9000", ["research"], description="")
+    result = runner.invoke(app, ["agents"])
+    assert result.exit_code == 0
+    assert "—" in result.output
+
+
+# ---------------------------------------------------------------------------
+# Backward compat: old registry entries without description
+# ---------------------------------------------------------------------------
+
+def test_list_all_defaults_description_for_old_entries(tmp_path, monkeypatch):
+    """Registry entries written before description field was added default to ''."""
+    registry_file = tmp_path / "agents.json"
+    registry_file.write_text(json.dumps({
+        "legacy-agent": {"url": "http://localhost:9000", "capabilities": ["research"], "timeout": 60.0}
+    }))
+    monkeypatch.setattr(reg, "_REGISTRY_PATH", registry_file)
+
+    entries = reg.list_all()
+    assert entries[0]["description"] == ""

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

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