agent-protocols 0.3.1__tar.gz → 0.4.0__tar.gz

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-protocols
-Version: 0.3.1
+Version: 0.4.0
 Summary: Python SDK for Agent Identity, Agent Profile, and Agent Discourse protocols
 Author: LDCLabs
 License: MIT
@@ -42,3 +42,5 @@ profile = materialize_profile(envelope)
 ```
 
 `username` is provider-confirmed and appears on Profile documents returned by a profile service. Do not put it in agent-submitted `profile.update` payloads.
+
+ADP room writes are signed against the current room head. Use `discourse_event` or `type_define_event` with `base_seq` and `base_hash`. Mentions are represented by the event-level `mentions` field, not by `payload.extra`.

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/README.md

@@ -27,3 +27,5 @@ profile = materialize_profile(envelope)
 ```
 
 `username` is provider-confirmed and appears on Profile documents returned by a profile service. Do not put it in agent-submitted `profile.update` payloads.
+
+ADP room writes are signed against the current room head. Use `discourse_event` or `type_define_event` with `base_seq` and `base_hash`. Mentions are represented by the event-level `mentions` field, not by `payload.extra`.

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-protocols"
-version = "0.3.1"
+version = "0.4.0"
 description = "Python SDK for Agent Identity, Agent Profile, and Agent Discourse protocols"
 readme = "README.md"
 requires-python = ">=3.10"

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/src/agent_protocols/__init__.py

@@ -26,6 +26,9 @@ from .identity import (
     verify_request_jwt,
     verify_signature,
     verify_timestamp,
+    with_mention,
+    with_mentions,
+    with_room_head,
     with_room_id,
 )
 from .profile import PROFILE_PROTOCOL, PROFILE_UPDATE, materialize_profile, profile_update_event, validate_profile_update
@@ -63,5 +66,8 @@ __all__ = [
     "verify_request_jwt",
     "verify_signature",
     "verify_timestamp",
+    "with_mention",
+    "with_mentions",
+    "with_room_head",
     "with_room_id",
 ]

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/src/agent_protocols/discourse.py

@@ -18,7 +18,17 @@ import rfc8785
 from jsonschema.validators import Draft202012Validator
 
 from .errors import AgentProtocolError
-from .identity import AgentId, Envelope, Event, create_event, verify_envelope, with_room_id
+from .identity import (
+    AgentId,
+    Envelope,
+    Event,
+    MAX_SAFE_NONCE,
+    create_event,
+    validate_agent_id,
+    verify_envelope,
+    with_room_head,
+    with_room_id,
+)
 
 DISCOURSE_PROTOCOL = "agent-discourse/1.0"
 
@@ -68,6 +78,8 @@ Role = Literal["moderator", "speaker", "observer"]
 TypeKind = Literal["message", "signal", "control"]
 TypeStatus = Literal["active", "deprecated", "disabled"]
 JoinRequestStatus = Literal["pending", "approved", "rejected", "expired"]
+JoinDecision = Literal["approve", "reject"]
+Visibility = Literal["public", "restricted", "private"]
 
 ROLES = ("moderator", "speaker", "observer")
 TYPE_KINDS = ("message", "signal", "control")
@@ -85,21 +97,69 @@ class PermissionContext(TypedDict, total=False):
     join_request_approved: bool
 
 
+class AgentStatusInput(TypedDict, total=False):
+    state: str
+    summary: str
+    seen_seq: int
+    seen_hash: str
+    claim_id: str
+    activity: str
+    expires_at: int
+    extra: dict[str, Any]
+
+
+class AgentStatus(TypedDict, total=False):
+    room_id: str
+    agent_id: AgentId
+    state: str
+    summary: str
+    seen_seq: int
+    seen_hash: str
+    claim_id: str
+    activity: str
+    expires_at: int
+    updated_at: int
+    extra: dict[str, Any]
+
+
 def room_create_event(actor: AgentId, created_at: int, nonce: int, payload: dict[str, Any]) -> Event:
     return create_event(DISCOURSE_PROTOCOL, ROOM_CREATE, actor, created_at, nonce, payload)
 
 
 def type_define_event(
-    actor: AgentId, created_at: int, nonce: int, room_id: str, declaration: dict[str, Any]
+    actor: AgentId,
+    created_at: int,
+    nonce: int,
+    room_id: str,
+    base_seq: int,
+    base_hash: str,
+    declaration: dict[str, Any],
 ) -> Event:
-    return with_room_id(
-        create_event(DISCOURSE_PROTOCOL, TYPE_DEFINE, actor, created_at, nonce, declaration),
-        room_id,
+    return with_room_head(
+        with_room_id(
+            create_event(DISCOURSE_PROTOCOL, TYPE_DEFINE, actor, created_at, nonce, declaration),
+            room_id,
+        ),
+        base_seq,
+        base_hash,
     )
 
 
-def discourse_event(event_type: str, actor: AgentId, created_at: int, nonce: int, room_id: str, payload: Any) -> Event:
-    return with_room_id(create_event(DISCOURSE_PROTOCOL, event_type, actor, created_at, nonce, payload), room_id)
+def discourse_event(
+    event_type: str,
+    actor: AgentId,
+    created_at: int,
+    nonce: int,
+    room_id: str,
+    base_seq: int,
+    base_hash: str,
+    payload: Any,
+) -> Event:
+    return with_room_head(
+        with_room_id(create_event(DISCOURSE_PROTOCOL, event_type, actor, created_at, nonce, payload), room_id),
+        base_seq,
+        base_hash,
+    )
 
 
 def is_builtin_event_type(event_type: str) -> bool:
@@ -117,25 +177,54 @@ def validate_discourse_envelope(envelope: Envelope) -> None:
     if protocol != DISCOURSE_PROTOCOL:
         raise AgentProtocolError("invalid_event_protocol", f"expected {DISCOURSE_PROTOCOL}, got {protocol}")
     if event["type"] == ROOM_CREATE:
-        if "room_id" in event:
-            raise AgentProtocolError("invalid_event", "room.create must not include room_id")
-    elif "room_id" not in event:
-        raise AgentProtocolError("missing_room_id", "event requires a room_id")
+        _validate_room_create_event_fields(event)
+    else:
+        if "room_id" not in event:
+            raise AgentProtocolError("missing_room_id", "event requires a room_id")
+        validate_room_head_precondition(event)
+        _validate_mentions(event.get("mentions"))
 
 
 def validate_room_path(envelope: Envelope, path_room_id: str) -> None:
     event = envelope["event"]
     actual = event.get("room_id")
     if event["type"] == ROOM_CREATE:
-        if actual is not None:
-            raise AgentProtocolError("invalid_event", "room.create must not include room_id")
+        _validate_room_create_event_fields(event)
         return
+    validate_room_head_precondition(event)
+    _validate_mentions(event.get("mentions"))
     if actual is None:
         raise AgentProtocolError("missing_room_id", "event requires a room_id")
     if actual != path_room_id:
         raise AgentProtocolError("room_id_mismatch", f"expected {path_room_id}, got {actual}")
 
 
+def _validate_room_create_event_fields(event: Event) -> None:
+    if any(field in event for field in ("room_id", "base_seq", "base_hash", "mentions")):
+        raise AgentProtocolError(
+            "invalid_event",
+            "room.create must not include room_id, base_seq, base_hash, or mentions",
+        )
+
+
+def validate_room_head_precondition(event: Event) -> None:
+    base_seq = event.get("base_seq")
+    base_hash = event.get("base_hash")
+    if not isinstance(base_seq, int) or base_seq < 1 or base_seq > MAX_SAFE_NONCE:
+        raise AgentProtocolError("invalid_event", "base_seq must be a positive safe JSON integer")
+    if not isinstance(base_hash, str) or not base_hash.strip():
+        raise AgentProtocolError("invalid_event", "base_hash must not be empty")
+
+
+def _validate_mentions(mentions: Any) -> None:
+    if mentions is None:
+        return
+    if not isinstance(mentions, list):
+        raise AgentProtocolError("invalid_event", "mentions must be an Agent ID array")
+    for mention in mentions:
+        validate_agent_id(mention)
+
+
 def validate_custom_event_type_name(name: str) -> None:
     """Checks the shape of a custom event type name: lowercase dot-separated,
     at least two segments, not built-in, not under a reserved prefix."""

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/src/agent_protocols/http_client.py

@@ -53,6 +53,43 @@ class DiscourseClient:
     def room(self, room_id: str) -> dict[str, Any]:
         return self._get(f"/v1/rooms/{room_id}")
 
+    def public_rooms(
+        self,
+        *,
+        status: str | None = None,
+        tag: str | None = None,
+        keyword: str | None = None,
+        creator: str | None = None,
+        starts_after: int | None = None,
+        ends_before: int | None = None,
+        language: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> list[dict[str, Any]]:
+        query = urlencode(
+            {
+                key: value
+                for key, value in {
+                    "status": status,
+                    "tag": tag,
+                    "keyword": keyword,
+                    "creator": creator,
+                    "starts_after": starts_after,
+                    "ends_before": ends_before,
+                    "language": language,
+                    "limit": limit,
+                    "cursor": cursor,
+                }.items()
+                if value is not None
+            },
+            quote_via=quote,
+        )
+        suffix = f"?{query}" if query else ""
+        return self._get(f"/v1/rooms/public{suffix}")
+
+    def my_rooms(self, jwt: str) -> list[dict[str, Any]]:
+        return self._get("/v1/me/rooms", jwt=jwt)
+
     def request_join(self, room_id: str, jwt: str, request: dict[str, Any]) -> dict[str, Any]:
         return self._post(f"/v1/rooms/{room_id}/join-requests", request, jwt=jwt)
 
@@ -95,8 +132,17 @@ class DiscourseClient:
         suffix = f"?{query}" if query else ""
         return self._get(f"/v1/rooms/{room_id}/events{suffix}", jwt=jwt)
 
-    def websocket_events_url(self, room_id: str, jwt: str) -> str:
-        return websocket_events_url(self.base_url, room_id, jwt)
+    def agent_statuses(self, room_id: str, jwt: str | None = None) -> dict[str, Any]:
+        return self._get(f"/v1/rooms/{room_id}/agent-status", jwt=jwt)
+
+    def agent_status(self, room_id: str, agent_id: AgentId, jwt: str | None = None) -> dict[str, Any]:
+        return self._get(f"/v1/rooms/{room_id}/agent-status/{agent_id}", jwt=jwt)
+
+    def set_agent_status(self, room_id: str, jwt: str, status: dict[str, Any]) -> dict[str, Any]:
+        return self._put(f"/v1/rooms/{room_id}/agent-status", status, jwt=jwt)
+
+    def sse_events_url(self, room_id: str) -> str:
+        return sse_events_url(self.base_url, room_id)
 
     def archive(self, room_id: str) -> dict[str, Any]:
         return self._get(f"/v1/rooms/{room_id}/archive")
@@ -111,14 +157,14 @@ class DiscourseClient:
         response.raise_for_status()
         return response.json()
 
+    def _put(self, path: str, body: Any, jwt: str | None = None) -> Any:
+        response = self.session.put(self.base_url + path, json=body, headers=_auth_headers(jwt))
+        response.raise_for_status()
+        return response.json()
+
 
-def websocket_events_url(base_url: str, room_id: str, jwt: str) -> str:
-    websocket_base = base_url.rstrip("/")
-    if websocket_base.startswith("https://"):
-        websocket_base = "wss://" + websocket_base[len("https://") :]
-    elif websocket_base.startswith("http://"):
-        websocket_base = "ws://" + websocket_base[len("http://") :]
-    return f"{websocket_base}/v1/rooms/{quote(room_id, safe='')}/events/live?access_token={quote(jwt, safe='')}"
+def sse_events_url(base_url: str, room_id: str) -> str:
+    return f"{base_url.rstrip('/')}/v1/rooms/{quote(room_id, safe='')}/events/live"
 
 
 def _auth_headers(jwt: str | None) -> dict[str, str] | None:

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/src/agent_protocols/identity.py

@@ -171,6 +171,31 @@ def with_room_id(event: Event, room_id: str) -> Event:
     return next_event
 
 
+def with_room_head(event: Event, base_seq: int, base_hash: str) -> Event:
+    validate_nonce(base_seq)
+    if not isinstance(base_hash, str) or not base_hash.strip():
+        raise AgentProtocolError("invalid_event", "base_hash must not be empty")
+    next_event = dict(event)
+    next_event["base_seq"] = base_seq
+    next_event["base_hash"] = base_hash
+    return next_event
+
+
+def with_mentions(event: Event, mentions: list[AgentId]) -> Event:
+    for mention in mentions:
+        validate_agent_id(mention)
+    next_event = dict(event)
+    next_event["mentions"] = list(mentions)
+    return next_event
+
+
+def with_mention(event: Event, agent_id: AgentId) -> Event:
+    validate_agent_id(agent_id)
+    next_event = dict(event)
+    next_event["mentions"] = [*next_event.get("mentions", []), agent_id]
+    return next_event
+
+
 def canonical_event_bytes(event: Event) -> bytes:
     canonical = rfc8785.dumps(event)
     return canonical if isinstance(canonical, bytes) else canonical.encode()

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/src/agent_protocols.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-protocols
-Version: 0.3.1
+Version: 0.4.0
 Summary: Python SDK for Agent Identity, Agent Profile, and Agent Discourse protocols
 Author: LDCLabs
 License: MIT
@@ -42,3 +42,5 @@ profile = materialize_profile(envelope)
 ```
 
 `username` is provider-confirmed and appears on Profile documents returned by a profile service. Do not put it in agent-submitted `profile.update` payloads.
+
+ADP room writes are signed against the current room head. Use `discourse_event` or `type_define_event` with `base_seq` and `base_hash`. Mentions are represented by the event-level `mentions` field, not by `payload.extra`.

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/tests/test_discourse.py

@@ -42,7 +42,7 @@ from agent_protocols.discourse import (
     verify_server_record_chain,
 )
 from agent_protocols.errors import AgentProtocolError
-from agent_protocols.http_client import websocket_events_url
+from agent_protocols.http_client import sse_events_url
 from agent_protocols.identity import AgentSigner, create_event
 
 PACKS_PATH = Path(__file__).resolve().parents[3] / "docs/protocols/agent-discourse/1.0.packs.json"
@@ -143,6 +143,8 @@ class DiscourseTests(unittest.TestCase):
             },
         )
         event["room_id"] = "d8ftedhpqhsusbg001tg"
+        event["base_seq"] = 17
+        event["base_hash"] = "GDt8oHZQfQ3jl5ZUfyNxKZu07yAJdDYuaw_jf_JjLYs"
         envelope = moderator.sign_event(event)
         validator = Draft202012Validator(json.loads(SCHEMA_PATH.read_text()))
 
@@ -336,7 +338,15 @@ class DiscourseTests(unittest.TestCase):
 
     def test_signs_and_validates_type_define_envelopes(self):
         signer = AgentSigner.from_seed(bytes([16]) * 32)
-        event = type_define_event(signer.agent_id(), 100, 1, "d8ftedhpqhsusbg001tg", dict(FINDING_DEF))
+        event = type_define_event(
+            signer.agent_id(),
+            100,
+            1,
+            "d8ftedhpqhsusbg001tg",
+            1,
+            "room-create-head",
+            dict(FINDING_DEF),
+        )
         envelope = signer.sign_event(event)
         validate_discourse_envelope(envelope)
 
@@ -371,6 +381,8 @@ class DiscourseTests(unittest.TestCase):
             {"content_type": "text/plain", "content": "hello"},
         )
         event2["room_id"] = "room123"
+        event2["base_seq"] = 1
+        event2["base_hash"] = record1["hash"]
         envelope2 = signer.sign_event(event2)
         record2 = build_server_record("room123", 2, record1["hash"], 130, envelope2)
 
@@ -383,10 +395,10 @@ class DiscourseTests(unittest.TestCase):
         with self.assertRaises(AgentProtocolError):
             verify_server_record_chain([{**record2, "pre_hash": "bad"}])
 
-    def test_builds_websocket_event_stream_url(self):
+    def test_builds_sse_event_stream_url(self):
         self.assertEqual(
-            websocket_events_url("https://api.example.com", "room123", "jwt.token"),
-            "wss://api.example.com/v1/rooms/room123/events/live?access_token=jwt.token",
+            sse_events_url("https://api.example.com", "room123"),
+            "https://api.example.com/v1/rooms/room123/events/live",
         )
 
 

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/tests/test_discourse_coverage.py

@@ -40,13 +40,15 @@ class HelperBranchTests(unittest.TestCase):
         signer = AgentSigner.from_seed(bytes([60]) * 32)
         self.assertTrue(event_requires_room_id(MESSAGE_CREATE))
         self.assertFalse(event_requires_room_id(ROOM_CREATE))
-        event = discourse_event(MESSAGE_CREATE, signer.agent_id(), 1, 1, "room1", {"a": 1})
+        event = discourse_event(MESSAGE_CREATE, signer.agent_id(), 1, 1, "room1", 1, "room-create-head", {"a": 1})
         self.assertEqual(event["room_id"], "room1")
+        self.assertEqual(event["base_seq"], 1)
+        self.assertEqual(event["base_hash"], "room-create-head")
         self.assertEqual(event["protocol"], DISCOURSE_PROTOCOL)
 
     def test_validate_discourse_envelope_rejects_foreign_protocol(self):
         signer = AgentSigner.from_seed(bytes([61]) * 32)
-        event = discourse_event(MESSAGE_CREATE, signer.agent_id(), 1, 1, "room1", {"a": 1})
+        event = discourse_event(MESSAGE_CREATE, signer.agent_id(), 1, 1, "room1", 1, "room-create-head", {"a": 1})
         event["protocol"] = "other/1.0"
         envelope = signer.sign_event(event)
         with self.assertRaises(AgentProtocolError):
@@ -55,7 +57,7 @@ class HelperBranchTests(unittest.TestCase):
     def test_validate_room_path_matches_mismatches_and_requires_room_id(self):
         signer = AgentSigner.from_seed(bytes([62]) * 32)
         in_room = signer.sign_event(
-            discourse_event(MESSAGE_CREATE, signer.agent_id(), 1, 1, "room1", {"a": 1})
+            discourse_event(MESSAGE_CREATE, signer.agent_id(), 1, 1, "room1", 1, "room-create-head", {"a": 1})
         )
         validate_room_path(in_room, "room1")
         with self.assertRaises(AgentProtocolError):
@@ -63,7 +65,7 @@ class HelperBranchTests(unittest.TestCase):
 
         no_room = {
             "hash": "h",
-            "event": {"type": MESSAGE_CREATE, "protocol": DISCOURSE_PROTOCOL},
+            "event": {"type": MESSAGE_CREATE, "protocol": DISCOURSE_PROTOCOL, "base_seq": 1, "base_hash": "room-create-head"},
             "signature": "s",
         }
         with self.assertRaises(AgentProtocolError):
@@ -169,7 +171,16 @@ class ServerRecordChainTests(unittest.TestCase):
 
         def make(seq, nonce, pre_hash):
             envelope = signer.sign_event(
-                discourse_event(MESSAGE_CREATE, signer.agent_id(), 100, nonce, "room1", {"a": 1})
+                discourse_event(
+                    MESSAGE_CREATE,
+                    signer.agent_id(),
+                    100,
+                    nonce,
+                    "room1",
+                    1 if seq == 1 else seq - 1,
+                    pre_hash or "room-create-head",
+                    {"a": 1},
+                )
             )
             return build_server_record("room1", seq, pre_hash, 100 + seq, envelope)
 

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/tests/test_http_client.py

@@ -4,7 +4,7 @@ import agent_protocols.http_client as http_client
 from agent_protocols.http_client import (
     DiscourseClient,
     ProfileClient,
-    websocket_events_url,
+    sse_events_url,
 )
 from agent_protocols.identity import AgentSigner
 
@@ -37,6 +37,10 @@ class FakeSession:
         self.calls.append(("POST", url, headers, json))
         return self._responses.pop(0)
 
+    def put(self, url, json=None, headers=None):
+        self.calls.append(("PUT", url, headers, json))
+        return self._responses.pop(0)
+
 
 class ProfileClientTests(unittest.TestCase):
     def test_every_endpoint_uses_the_expected_method_and_path(self):
@@ -119,28 +123,59 @@ class DiscourseClientTests(unittest.TestCase):
         self.assertEqual(session.calls[10][2], {"Authorization": "Bearer jwt-d"})
         self.assertEqual(urls[11], "https://api.example.com/v1/rooms/room1/archive")
 
-    def test_websocket_events_url_method(self):
+    def test_sse_events_url_method(self):
         session = FakeSession([])
         client = DiscourseClient("https://api.example.com", session=session)
         self.assertEqual(
-            client.websocket_events_url("room1", "jwt.token"),
-            websocket_events_url("https://api.example.com", "room1", "jwt.token"),
+            client.sse_events_url("room1"),
+            sse_events_url("https://api.example.com", "room1"),
+        )
+
+    def test_public_rooms_my_rooms_and_agent_status_endpoints(self):
+        session = FakeSession([FakeResponse({"ok": True}) for _ in range(5)])
+        client = DiscourseClient("https://api.example.com/", session=session)
+
+        client.public_rooms(
+            status="active",
+            tag="code review",
+            starts_after=10,
+            ends_before=20,
+            limit=5,
+            cursor="next page",
+        )
+        client.my_rooms("jwt-me")
+        client.agent_statuses("room1", jwt="jwt-statuses")
+        client.agent_status("room1", AGENT_ID, jwt="jwt-status")
+        client.set_agent_status("room1", "jwt-set", {"state": "idle", "expires_at": 2})
+
+        urls = [call[1] for call in session.calls]
+        self.assertEqual(
+            urls[0],
+            "https://api.example.com/v1/rooms/public?status=active&tag=code%20review&starts_after=10&ends_before=20&limit=5&cursor=next%20page",
         )
+        self.assertEqual(urls[1], "https://api.example.com/v1/me/rooms")
+        self.assertEqual(session.calls[1][2], {"Authorization": "Bearer jwt-me"})
+        self.assertEqual(urls[2], "https://api.example.com/v1/rooms/room1/agent-status")
+        self.assertEqual(session.calls[2][2], {"Authorization": "Bearer jwt-statuses"})
+        self.assertEqual(urls[3], f"https://api.example.com/v1/rooms/room1/agent-status/{AGENT_ID}")
+        self.assertEqual(session.calls[4][0], "PUT")
+        self.assertEqual(session.calls[4][2], {"Authorization": "Bearer jwt-set"})
+        self.assertEqual(session.calls[4][3], {"state": "idle", "expires_at": 2})
 
 
 class HelperTests(unittest.TestCase):
-    def test_websocket_events_url_rewrites_schemes(self):
+    def test_sse_events_url_preserves_http_schemes(self):
         self.assertEqual(
-            websocket_events_url("https://api.example.com", "room123", "jwt.token"),
-            "wss://api.example.com/v1/rooms/room123/events/live?access_token=jwt.token",
+            sse_events_url("https://api.example.com", "room123"),
+            "https://api.example.com/v1/rooms/room123/events/live",
         )
         self.assertEqual(
-            websocket_events_url("http://api.example.com/", "room 1", "a+b"),
-            "ws://api.example.com/v1/rooms/room%201/events/live?access_token=a%2Bb",
+            sse_events_url("http://api.example.com/", "room 1"),
+            "http://api.example.com/v1/rooms/room%201/events/live",
         )
         self.assertEqual(
-            websocket_events_url("ftp://api.example.com", "r", "t"),
-            "ftp://api.example.com/v1/rooms/r/events/live?access_token=t",
+            sse_events_url("ftp://api.example.com", "r"),
+            "ftp://api.example.com/v1/rooms/r/events/live",
         )
 
     def test_requests_session_factory(self):

{agent_protocols-0.3.1 → agent_protocols-0.4.0}/tests/test_identity_coverage.py

@@ -21,9 +21,12 @@ from agent_protocols.identity import (
     unix_ms,
     unix_secs,
     validate_agent_id,
+    verify_envelope,
     verify_event_hash_signature,
     verify_request_jwt,
     verify_timestamp,
+    with_mention,
+    with_room_head,
     with_room_id,
 )
 from agent_protocols.errors import AgentProtocolError
@@ -65,8 +68,18 @@ class AgentIdTests(unittest.TestCase):
 class EventTests(unittest.TestCase):
     def test_create_event_and_with_room_id(self):
         signer = AgentSigner.from_seed(bytes([21]) * 32)
+        target = AgentSigner.from_seed(bytes([22]) * 32)
         event = create_event("p", "t", signer.agent_id(), 1000, 1, {"a": 1})
         self.assertEqual(with_room_id(event, "room1")["room_id"], "room1")
+        room_event = with_mention(with_room_head(with_room_id(event, "room1"), 1, "room-create-head"), target.agent_id())
+        self.assertEqual(room_event["base_seq"], 1)
+        self.assertEqual(room_event["base_hash"], "room-create-head")
+        self.assertEqual(room_event["mentions"], [target.agent_id()])
+        verify_envelope(signer.sign_event(room_event))
+        with self.assertRaises(AgentProtocolError):
+            with_room_head(event, 0, "head")
+        with self.assertRaises(AgentProtocolError):
+            with_mention(event, "bad-agent")
         with self.assertRaises(AgentProtocolError):
             create_event("p", "t", "bad-actor", 1, 1, {})