agent-protocols 0.1.0__tar.gz → 0.2.0__tar.gz

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: agent-protocols
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python SDK for Agent Identity, Agent Profile, and Agent Discourse protocols
 Author: LDCLabs
 License: MIT
 Keywords: agent,protocol,ed25519,sdk
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: base58<3,>=2.1
 Requires-Dist: cryptography>=42
 Requires-Dist: rfc8785<0.2,>=0.1.4
 Provides-Extra: http
@@ -19,22 +18,23 @@ Python SDK for the draft Agent Identity, Agent Profile, and Agent Discourse prot
 
 ## Modules
 
-- `agent_protocols.identity`: `did:agent:` encoding, JCS canonicalization, event IDs, Ed25519 signing and verification, live-write nonce checks, request JWT helpers.
+- `agent_protocols.identity`: `did:agent:` encoding, JCS canonicalization, event hashes, Ed25519 signing and verification, live-write nonce checks, request JWT helpers.
 - `agent_protocols.profile`: `profile.update` payload helpers, validation, materialization.
-- `agent_protocols.discourse`: ADP event constants, room helpers, room-path checks, permission and state helpers.
+- `agent_protocols.discourse`: ADP event constants, join request helpers, room-path checks, permission and state helpers.
 - `agent_protocols.http_client`: optional requests-based Profile and Discourse clients. Install with `agent-protocols[http]`.
 
 ## Example
 
 ```python
-from agent_protocols import AgentSigner, materialize_profile, profile_update_event, unix_time_millis
+from agent_protocols import AgentSigner, ClientNonceManager, materialize_profile, profile_update_event, unix_ms
 
 signer = AgentSigner.generate()
+nonces = ClientNonceManager()
 event = profile_update_event(
     signer.agent_id(),
-    unix_time_millis(),
-    "n_01J8Z6",
-    {"agent_id": signer.agent_id(), "name": "ResearchAgent-v3"},
+    unix_ms(),
+    nonces.next_nonce(),
+    {"id": signer.agent_id(), "name": "ResearchAgent-v3"},
 )
 envelope = signer.sign_event(event)
 profile = materialize_profile(envelope)

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/README.md

@@ -4,22 +4,23 @@ Python SDK for the draft Agent Identity, Agent Profile, and Agent Discourse prot
 
 ## Modules
 
-- `agent_protocols.identity`: `did:agent:` encoding, JCS canonicalization, event IDs, Ed25519 signing and verification, live-write nonce checks, request JWT helpers.
+- `agent_protocols.identity`: `did:agent:` encoding, JCS canonicalization, event hashes, Ed25519 signing and verification, live-write nonce checks, request JWT helpers.
 - `agent_protocols.profile`: `profile.update` payload helpers, validation, materialization.
-- `agent_protocols.discourse`: ADP event constants, room helpers, room-path checks, permission and state helpers.
+- `agent_protocols.discourse`: ADP event constants, join request helpers, room-path checks, permission and state helpers.
 - `agent_protocols.http_client`: optional requests-based Profile and Discourse clients. Install with `agent-protocols[http]`.
 
 ## Example
 
 ```python
-from agent_protocols import AgentSigner, materialize_profile, profile_update_event, unix_time_millis
+from agent_protocols import AgentSigner, ClientNonceManager, materialize_profile, profile_update_event, unix_ms
 
 signer = AgentSigner.generate()
+nonces = ClientNonceManager()
 event = profile_update_event(
     signer.agent_id(),
-    unix_time_millis(),
-    "n_01J8Z6",
-    {"agent_id": signer.agent_id(), "name": "ResearchAgent-v3"},
+    unix_ms(),
+    nonces.next_nonce(),
+    {"id": signer.agent_id(), "name": "ResearchAgent-v3"},
 )
 envelope = signer.sign_event(event)
 profile = materialize_profile(envelope)

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "agent-protocols"
-version = "0.1.0"
+version = "0.2.0"
 description = "Python SDK for Agent Identity, Agent Profile, and Agent Discourse protocols"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
 authors = [{ name = "LDCLabs" }]
 keywords = ["agent", "protocol", "ed25519", "sdk"]
-dependencies = ["base58>=2.1,<3", "cryptography>=42", "rfc8785>=0.1.4,<0.2"]
+dependencies = ["cryptography>=42", "rfc8785>=0.1.4,<0.2"]
 
 [project.optional-dependencies]
 http = ["requests>=2.31,<3"]

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/src/agent_protocols/__init__.py

@@ -1,26 +1,26 @@
 from .errors import AgentProtocolError
 from .identity import (
     AGENT_ID_PREFIX,
-    EVENT_ID_PREFIX,
     AgentSigner,
+    ClientNonceManager,
+    MAX_NONCE_HEADER,
     MemoryNonceStore,
     RequestBinding,
     agent_id_from_public_key,
     canonical_event_bytes,
     create_event,
     create_request_jwt_claims,
-    event_id,
+    event_hash,
     public_key_bytes,
-    random_nonce,
     sign_event,
-    unix_time_millis,
-    unix_time_secs,
+    unix_ms,
+    unix_secs,
     validate_agent_id,
+    validate_nonce,
     verify_envelope,
-    verify_event_id,
+    verify_event_hash,
     verify_live_envelope,
     verify_request_jwt,
-    verify_request_jwt_live,
     verify_signature,
     verify_timestamp,
     with_room_id,
@@ -29,32 +29,32 @@ from .profile import PROFILE_PROTOCOL, PROFILE_UPDATE, materialize_profile, prof
 
 __all__ = [
     "AGENT_ID_PREFIX",
-    "EVENT_ID_PREFIX",
+    "MAX_NONCE_HEADER",
     "PROFILE_PROTOCOL",
     "PROFILE_UPDATE",
     "AgentProtocolError",
     "AgentSigner",
+    "ClientNonceManager",
     "MemoryNonceStore",
     "RequestBinding",
     "agent_id_from_public_key",
     "canonical_event_bytes",
     "create_event",
     "create_request_jwt_claims",
-    "event_id",
+    "event_hash",
     "materialize_profile",
     "profile_update_event",
     "public_key_bytes",
-    "random_nonce",
     "sign_event",
-    "unix_time_millis",
-    "unix_time_secs",
+    "unix_ms",
+    "unix_secs",
     "validate_agent_id",
+    "validate_nonce",
     "validate_profile_update",
     "verify_envelope",
-    "verify_event_id",
+    "verify_event_hash",
     "verify_live_envelope",
     "verify_request_jwt",
-    "verify_request_jwt_live",
     "verify_signature",
     "verify_timestamp",
     "with_room_id",

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/src/agent_protocols/discourse.py

@@ -10,61 +10,55 @@ LEGACY_DISCOURSE_PROTOCOL = "adp/1.0"
 
 ROOM_CREATE = "room.create"
 ROOM_JOIN = "room.join"
+ROOM_JOIN_REVIEW = "room.join.review"
 ROOM_LEAVE = "room.leave"
 ROOM_MEMBER_ROLE_UPDATE = "room.member.role.update"
-ROOM_INVITE = "room.invite"
-ROOM_INVITE_REVOKE = "room.invite.revoke"
 ROOM_CLOSE = "room.close"
 ROOM_CANCEL = "room.cancel"
-MESSAGE_TEXT = "message.text"
-MESSAGE_MARKDOWN = "message.markdown"
-MESSAGE_DATA = "message.data"
+MESSAGE_CREATE = "message.create"
 REACTION_CREATE = "reaction.create"
-PROPOSAL_CREATE = "proposal.create"
-POLL_CREATE = "poll.create"
-POLL_VOTE = "poll.vote"
-RESOLUTION_CREATE = "resolution.create"
+MESSAGE_PROPOSAL_CREATE = "message.proposal.create"
+MESSAGE_POLL_CREATE = "message.poll.create"
+MESSAGE_POLL_VOTE = "message.poll.vote"
+MESSAGE_RESOLUTION_CREATE = "message.resolution.create"
 SOURCE_ADD = "source.add"
 TURN_UPDATE = "turn.update"
-QUESTION_GENERATE = "question.generate"
-DISCOURSE_STEER = "discourse.steer"
-MINDMAP_UPDATE = "mindmap.update"
-REPORT_GENERATE = "report.generate"
-SESSION_AUTH = "session.auth"
+QUESTION_CREATE = "question.create"
+ROOM_STEER = "room.steer"
+MAP_UPDATE = "map.update"
+ARTIFACT_CREATE = "artifact.create"
 
 KNOWN_EVENT_TYPES = {
     ROOM_CREATE,
     ROOM_JOIN,
+    ROOM_JOIN_REVIEW,
     ROOM_LEAVE,
     ROOM_MEMBER_ROLE_UPDATE,
-    ROOM_INVITE,
-    ROOM_INVITE_REVOKE,
     ROOM_CLOSE,
     ROOM_CANCEL,
-    MESSAGE_TEXT,
-    MESSAGE_MARKDOWN,
-    MESSAGE_DATA,
+    MESSAGE_CREATE,
     REACTION_CREATE,
-    PROPOSAL_CREATE,
-    POLL_CREATE,
-    POLL_VOTE,
-    RESOLUTION_CREATE,
+    MESSAGE_PROPOSAL_CREATE,
+    MESSAGE_POLL_CREATE,
+    MESSAGE_POLL_VOTE,
+    MESSAGE_RESOLUTION_CREATE,
     SOURCE_ADD,
     TURN_UPDATE,
-    QUESTION_GENERATE,
-    DISCOURSE_STEER,
-    MINDMAP_UPDATE,
-    REPORT_GENERATE,
-    SESSION_AUTH,
+    QUESTION_CREATE,
+    ROOM_STEER,
+    MAP_UPDATE,
+    ARTIFACT_CREATE,
 }
 
 RoomState = Literal["scheduled", "active", "ended", "cancelled"]
 Role = Literal["moderator", "expert", "participant", "observer"]
+JoinRequestStatus = Literal["pending", "approved", "rejected", "expired"]
 
 
 class PermissionContext(TypedDict, total=False):
     role: Role
     is_creator: bool
+    join_request_approved: bool
     moderator_authorized: bool
     expert_policy_allowed: bool
     participant_policy_allowed: bool
@@ -72,11 +66,11 @@ class PermissionContext(TypedDict, total=False):
     observer_poll_vote_allowed: bool
 
 
-def room_create_event(actor: AgentId, created_at: int, nonce: str, payload: dict[str, Any]) -> Event:
+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 discourse_event(event_type: str, actor: AgentId, created_at: int, nonce: str, room_id: str, payload: Any) -> Event:
+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)
 
 
@@ -92,6 +86,8 @@ def validate_discourse_envelope(envelope: Envelope, accept_legacy_protocol: bool
 
 def validate_room_path(envelope: Envelope, path_room_id: str) -> None:
     actual = envelope["event"].get("room_id")
+    if actual is None and envelope["event"]["type"] == ROOM_CREATE:
+        return
     if actual is None:
         raise AgentProtocolError("missing_room_id", "event requires a room_id")
     if actual != path_room_id:
@@ -103,8 +99,10 @@ def event_requires_room_id(event_type: str) -> bool:
 
 
 def can_submit_event(event_type: str, context: PermissionContext) -> bool:
-    if event_type in {ROOM_CREATE, ROOM_JOIN}:
+    if event_type == ROOM_CREATE:
         return True
+    if event_type == ROOM_JOIN:
+        return context.get("join_request_approved", False)
     if context.get("is_creator"):
         return event_type in KNOWN_EVENT_TYPES
 
@@ -122,7 +120,7 @@ def can_submit_event(event_type: str, context: PermissionContext) -> bool:
 
 def can_write_in_state(event_type: str, state: RoomState, *, post_end_reaction_allowed: bool = False) -> bool:
     if state == "scheduled":
-        return event_type in {ROOM_JOIN, ROOM_INVITE, ROOM_INVITE_REVOKE, ROOM_CANCEL}
+        return event_type in {ROOM_JOIN, ROOM_JOIN_REVIEW, ROOM_CANCEL}
     if state == "active":
         return event_type not in {ROOM_CREATE, ROOM_CANCEL}
     if state == "ended":
@@ -143,22 +141,19 @@ def validate_room_write(event_type: str, state: RoomState, context: PermissionCo
 
 def _moderator_can_submit(event_type: str, moderator_authorized: bool) -> bool:
     allowed = {
-        ROOM_INVITE,
-        ROOM_INVITE_REVOKE,
+        ROOM_JOIN_REVIEW,
         ROOM_CLOSE,
-        MESSAGE_TEXT,
-        MESSAGE_MARKDOWN,
-        MESSAGE_DATA,
+        MESSAGE_CREATE,
         SOURCE_ADD,
         TURN_UPDATE,
-        QUESTION_GENERATE,
-        DISCOURSE_STEER,
-        MINDMAP_UPDATE,
-        REPORT_GENERATE,
-        PROPOSAL_CREATE,
-        POLL_CREATE,
-        POLL_VOTE,
-        RESOLUTION_CREATE,
+        QUESTION_CREATE,
+        ROOM_STEER,
+        MAP_UPDATE,
+        ARTIFACT_CREATE,
+        MESSAGE_PROPOSAL_CREATE,
+        MESSAGE_POLL_CREATE,
+        MESSAGE_POLL_VOTE,
+        MESSAGE_RESOLUTION_CREATE,
         REACTION_CREATE,
         ROOM_LEAVE,
     }
@@ -167,24 +162,22 @@ def _moderator_can_submit(event_type: str, moderator_authorized: bool) -> bool:
 
 def _speaker_can_submit(event_type: str, policy_allowed: bool) -> bool:
     allowed = {
-        MESSAGE_TEXT,
-        MESSAGE_MARKDOWN,
-        MESSAGE_DATA,
+        MESSAGE_CREATE,
         SOURCE_ADD,
-        DISCOURSE_STEER,
-        PROPOSAL_CREATE,
-        POLL_CREATE,
-        POLL_VOTE,
+        ROOM_STEER,
+        MESSAGE_PROPOSAL_CREATE,
+        MESSAGE_POLL_CREATE,
+        MESSAGE_POLL_VOTE,
         REACTION_CREATE,
         ROOM_LEAVE,
     }
-    policy_events = {QUESTION_GENERATE, MINDMAP_UPDATE, REPORT_GENERATE, RESOLUTION_CREATE}
+    policy_events = {QUESTION_CREATE, MAP_UPDATE, ARTIFACT_CREATE, MESSAGE_RESOLUTION_CREATE}
     return event_type in allowed or (policy_allowed and event_type in policy_events)
 
 
 def _observer_can_submit(event_type: str, context: PermissionContext) -> bool:
     return (
         event_type in {REACTION_CREATE, ROOM_LEAVE}
-        or (context.get("observer_steering_allowed", False) and event_type == DISCOURSE_STEER)
-        or (context.get("observer_poll_vote_allowed", False) and event_type == POLL_VOTE)
+        or (context.get("observer_steering_allowed", False) and event_type == ROOM_STEER)
+        or (context.get("observer_poll_vote_allowed", False) and event_type == MESSAGE_POLL_VOTE)
     )

agent_protocols-0.2.0/src/agent_protocols/http_client.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote, urlencode
+
+try:
+    import requests
+except ImportError:  # pragma: no cover
+    requests = None  # type: ignore[assignment]
+
+from .identity import AgentId, Envelope
+
+
+class ProfileClient:
+    def __init__(self, base_url: str, session: Any | None = None):
+        self.base_url = base_url.rstrip("/")
+        self.session = session or _requests_session()
+
+    def get_profile(self, agent_id: AgentId) -> dict[str, Any]:
+        return self._get(f"/v1/profiles/{agent_id}")
+
+    def get_profiles(self, agent_ids: list[AgentId]) -> dict[str, Any]:
+        return self._post("/v1/profiles/batch", {"ids": agent_ids})
+
+    def profile_events(self, agent_id: AgentId, limit: int = 1) -> dict[str, Any]:
+        return self._get(f"/v1/profiles/{agent_id}/events?limit={limit}")
+
+    def submit_profile_update(self, envelope: Envelope) -> dict[str, Any]:
+        return self._post("/v1/profiles", envelope)
+
+    def _get(self, path: str) -> Any:
+        response = self.session.get(self.base_url + path)
+        response.raise_for_status()
+        return response.json()
+
+    def _post(self, path: str, body: Any) -> dict[str, Any]:
+        response = self.session.post(self.base_url + path, json=body)
+        response.raise_for_status()
+        return response.json()
+
+
+class DiscourseClient:
+    def __init__(self, base_url: str, session: Any | None = None):
+        self.base_url = base_url.rstrip("/")
+        self.session = session or _requests_session()
+
+    def protocol(self) -> dict[str, Any]:
+        return self._get("/.well-known/agent-discourse")
+
+    def create_room(self, envelope: Envelope) -> dict[str, Any]:
+        return self._post("/v1/rooms", envelope)
+
+    def room(self, room_id: str) -> dict[str, Any]:
+        return self._get(f"/v1/rooms/{room_id}")
+
+    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)
+
+    def join_request(self, room_id: str, request_id: str, jwt: str) -> dict[str, Any]:
+        return self._get(f"/v1/rooms/{room_id}/join-requests/{request_id}", jwt=jwt)
+
+    def join_requests(self, room_id: str, jwt: str) -> list[dict[str, Any]]:
+        return self._get(f"/v1/rooms/{room_id}/join-requests", jwt=jwt)
+
+    def join_room(self, room_id: str, envelope: Envelope) -> dict[str, Any]:
+        return self._post(f"/v1/rooms/{room_id}", envelope)
+
+    def leave_room(self, room_id: str, envelope: Envelope) -> dict[str, Any]:
+        return self._post(f"/v1/rooms/{room_id}", envelope)
+
+    def submit_event(self, room_id: str, envelope: Envelope) -> dict[str, Any]:
+        return self._post(f"/v1/rooms/{room_id}", envelope)
+
+    def events(
+        self,
+        room_id: str,
+        *,
+        after_seq: int | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+        jwt: str | None = None,
+    ) -> list[dict[str, Any]]:
+        query = urlencode(
+            {
+                key: value
+                for key, value in {
+                    "after_seq": after_seq,
+                    "limit": limit,
+                    "cursor": cursor,
+                }.items()
+                if value is not None
+            }
+        )
+        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 archive(self, room_id: str) -> dict[str, Any]:
+        return self._get(f"/v1/rooms/{room_id}/archive")
+
+    def _get(self, path: str, jwt: str | None = None) -> Any:
+        response = self.session.get(self.base_url + path, headers=_auth_headers(jwt))
+        response.raise_for_status()
+        return response.json()
+
+    def _post(self, path: str, body: Any, jwt: str | None = None) -> Any:
+        response = self.session.post(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 _auth_headers(jwt: str | None) -> dict[str, str] | None:
+    return {"Authorization": f"Bearer {jwt}"} if jwt else None
+
+
+def _requests_session() -> Any:
+    if requests is None:
+        raise RuntimeError("Install agent-protocols[http] to use HTTP clients")
+    return requests.Session()

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/src/agent_protocols/identity.py

@@ -3,12 +3,11 @@ from __future__ import annotations
 import base64
 import hashlib
 import json
-import os
+import re
 import time
 from dataclasses import dataclass
 from typing import Any, MutableMapping, Protocol
 
-import base58
 import rfc8785
 from cryptography.exceptions import InvalidSignature
 from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
@@ -17,10 +16,10 @@ from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
 from .errors import AgentProtocolError
 
 AGENT_ID_PREFIX = "did:agent:"
-EVENT_ID_PREFIX = "evt_"
 DEFAULT_LIVE_WRITE_WINDOW_MS = 300_000
+DEFAULT_NONCE_TTL_MS = 300_000
 DEFAULT_REQUEST_JWT_TTL_SECS = 300
-_REQUEST_AUTH_REPLAY_SCOPE = "agent-identity/request-auth"
+MAX_NONCE_HEADER = "Max-Seen-Nonce"
 
 Event = dict[str, Any]
 Envelope = dict[str, Any]
@@ -30,13 +29,13 @@ AgentId = str
 def agent_id_from_public_key(public_key: bytes) -> AgentId:
     if len(public_key) != 32:
         raise AgentProtocolError("invalid_public_key", f"public key must be 32 bytes, got {len(public_key)}")
-    return f"{AGENT_ID_PREFIX}{_base58btc_encode(public_key)}"
+    return f"{AGENT_ID_PREFIX}{_base64url_encode(public_key)}"
 
 
 def public_key_bytes(agent_id: AgentId) -> bytes:
     if not agent_id.startswith(AGENT_ID_PREFIX):
         raise AgentProtocolError("invalid_agent_id", "agent id must start with did:agent:")
-    data = _base58btc_decode(agent_id[len(AGENT_ID_PREFIX):])
+    data = _base64url_decode_no_pad(agent_id[len(AGENT_ID_PREFIX):])
     if len(data) != 32:
         raise AgentProtocolError("invalid_public_key", f"agent id public key must be 32 bytes, got {len(data)}")
     return data
@@ -50,13 +49,10 @@ def validate_agent_id(agent_id: AgentId) -> AgentId:
 @dataclass(frozen=True)
 class RequestBinding:
     audience: str
-    method: str
-    host: str
-    path: str
 
     @classmethod
-    def create(cls, audience: str, method: str, host: str, path: str) -> "RequestBinding":
-        return cls(audience=audience, method=method.upper(), host=host, path=path)
+    def create(cls, audience: str) -> "RequestBinding":
+        return cls(audience=audience)
 
 
 class AgentSigner:
@@ -81,7 +77,7 @@ class AgentSigner:
 
     def sign_event(self, event: Event) -> Envelope:
         return {
-            "event_id": event_id(event),
+            "hash": event_hash(event),
             "event": event,
             "signature": sign_event(self._private_key, event),
         }
@@ -99,21 +95,63 @@ class AgentSigner:
 
 
 class NonceStore(Protocol):
-    def check_and_insert(self, scope: tuple[AgentId, str, str | None, str]) -> None: ...
+    def check_and_update(self, actor: AgentId, nonce: int, now_ms: int, ttl_ms: int) -> int: ...
+
+    def max_nonce(self, actor: AgentId, now_ms: int) -> int | None: ...
 
 
 class MemoryNonceStore:
     def __init__(self) -> None:
-        self._seen: set[tuple[AgentId, str, str | None, str]] = set()
-
-    def check_and_insert(self, scope: tuple[AgentId, str, str | None, str]) -> None:
-        if scope in self._seen:
-            raise AgentProtocolError("nonce_reused", "nonce was already used in this replay scope")
-        self._seen.add(scope)
-
-
-def create_event(protocol: str, event_type: str, actor: AgentId, created_at: int, nonce: str, payload: Any) -> Event:
+        self._records: dict[AgentId, tuple[int, int]] = {}
+
+    def check_and_update(self, actor: AgentId, nonce: int, now_ms: int, ttl_ms: int) -> int:
+        validate_nonce(nonce)
+        if ttl_ms < 0:
+            raise AgentProtocolError("invalid_nonce", "nonce cache ttl must be non-negative")
+        record = self._records.get(actor)
+        if record is not None:
+            max_nonce, expires_at = record
+            if expires_at > now_ms and nonce <= max_nonce:
+                raise AgentProtocolError("nonce_not_greater", f"nonce must be greater than accepted max nonce {max_nonce}")
+        self._records[actor] = (nonce, now_ms + ttl_ms)
+        return nonce
+
+    def max_nonce(self, actor: AgentId, now_ms: int) -> int | None:
+        record = self._records.get(actor)
+        if record is None:
+            return None
+        max_nonce, expires_at = record
+        return max_nonce if expires_at > now_ms else None
+
+
+class ClientNonceManager:
+    def __init__(self, next_nonce: int = 1) -> None:
+        validate_nonce(next_nonce)
+        self._next_nonce = next_nonce
+
+    def peek(self) -> int:
+        return self._next_nonce
+
+    def next_nonce(self) -> int:
+        nonce = self._next_nonce
+        self._next_nonce += 1
+        return nonce
+
+    def observe_max_nonce(self, max_nonce: int | str | None) -> None:
+        if max_nonce is None or max_nonce == "":
+            return
+        try:
+            parsed = int(max_nonce)
+        except (TypeError, ValueError) as exc:
+            raise AgentProtocolError("invalid_nonce", "invalid max nonce header") from exc
+        validate_nonce(parsed)
+        if parsed >= self._next_nonce:
+            self._next_nonce = parsed + 1
+
+
+def create_event(protocol: str, event_type: str, actor: AgentId, created_at: int, nonce: int, payload: Any) -> Event:
     validate_agent_id(actor)
+    validate_nonce(nonce)
     return {
         "protocol": protocol,
         "type": event_type,
@@ -135,20 +173,20 @@ def canonical_event_bytes(event: Event) -> bytes:
     return canonical if isinstance(canonical, bytes) else canonical.encode()
 
 
-def event_id(event: Event) -> str:
-    digest = hashlib.sha256(canonical_event_bytes(event)).digest()
-    return f"{EVENT_ID_PREFIX}{_base58btc_encode(digest)}"
+def event_hash(event: Event) -> str:
+    digest = hashlib.sha3_256(canonical_event_bytes(event)).digest()
+    return _base64url_encode(digest)
 
 
 def sign_event(private_key: Ed25519PrivateKey, event: Event) -> str:
     return _base64url_encode(private_key.sign(canonical_event_bytes(event)))
 
 
-def verify_event_id(envelope: Envelope) -> None:
-    expected = event_id(envelope["event"])
-    actual = envelope["event_id"]
+def verify_event_hash(envelope: Envelope) -> None:
+    expected = event_hash(envelope["event"])
+    actual = envelope["hash"]
     if expected != actual:
-        raise AgentProtocolError("invalid_event_id", f"invalid event id: expected {expected}, got {actual}")
+        raise AgentProtocolError("invalid_event_hash", f"invalid event hash: expected {expected}, got {actual}")
 
 
 def verify_signature(envelope: Envelope) -> None:
@@ -163,7 +201,7 @@ def verify_signature(envelope: Envelope) -> None:
 
 
 def verify_envelope(envelope: Envelope) -> None:
-    verify_event_id(envelope)
+    verify_event_hash(envelope)
     verify_signature(envelope)
 
 
@@ -172,32 +210,24 @@ def verify_timestamp(created_at: int, now_ms: int, window_ms: int) -> None:
         raise AgentProtocolError("timestamp_out_of_window", "timestamp is outside the allowed live-write window")
 
 
-def nonce_scope_for_event(event: Event, kind: str = "actor_protocol") -> tuple[AgentId, str, str | None, str]:
-    room_id = event.get("room_id") if kind == "actor_room" else None
-    return (event["actor"], event["protocol"], room_id, event["nonce"])
-
-
-def verify_live_envelope(envelope: Envelope, nonce_store: NonceStore, *, now_ms: int | None = None, window_ms: int = DEFAULT_LIVE_WRITE_WINDOW_MS, nonce_scope: str = "actor_protocol") -> None:
+def verify_live_envelope(envelope: Envelope, nonce_store: NonceStore, *, now_ms: int | None = None, window_ms: int = DEFAULT_LIVE_WRITE_WINDOW_MS, nonce_ttl_ms: int = DEFAULT_NONCE_TTL_MS) -> int:
+    current_now_ms = now_ms if now_ms is not None else unix_ms()
     verify_envelope(envelope)
-    verify_timestamp(envelope["event"]["created_at"], now_ms if now_ms is not None else unix_time_millis(), window_ms)
-    nonce_store.check_and_insert(nonce_scope_for_event(envelope["event"], nonce_scope))
+    verify_timestamp(envelope["event"]["created_at"], current_now_ms, window_ms)
+    return nonce_store.check_and_update(envelope["event"]["actor"], envelope["event"]["nonce"], current_now_ms, nonce_ttl_ms)
 
 
-def create_request_jwt_claims(agent_id: AgentId, binding: RequestBinding, issued_at: int, ttl_secs: int, jti: str) -> dict[str, Any]:
+def create_request_jwt_claims(agent_id: AgentId, binding: RequestBinding, issued_at: int, ttl_secs: int) -> dict[str, Any]:
     return {
         "iss": agent_id,
         "sub": agent_id,
         "aud": binding.audience,
         "iat": issued_at,
         "exp": issued_at + ttl_secs,
-        "jti": jti,
-        "method": binding.method.upper(),
-        "host": binding.host,
-        "path": binding.path,
     }
 
 
-def verify_request_jwt(token: str, *, audience: str, method: str, host: str, path: str, now_secs: int | None = None, max_ttl_secs: int = DEFAULT_REQUEST_JWT_TTL_SECS) -> dict[str, Any]:
+def verify_request_jwt(token: str, *, audience: str, now_secs: int | None = None, max_ttl_secs: int = DEFAULT_REQUEST_JWT_TTL_SECS) -> dict[str, Any]:
     parts = token.split(".")
     if len(parts) != 3:
         raise AgentProtocolError("invalid_jwt", "expected three compact JWS parts")
@@ -219,17 +249,10 @@ def verify_request_jwt(token: str, *, audience: str, method: str, host: str, pat
     except InvalidSignature as exc:
         raise AgentProtocolError("invalid_signature", "JWT signature verification failed") from exc
 
-    expected_method = method.upper()
     if claims.get("aud") != audience:
         raise AgentProtocolError("invalid_jwt_claim", "aud mismatch")
-    if claims.get("method") != expected_method:
-        raise AgentProtocolError("invalid_jwt_claim", "method mismatch")
-    if claims.get("host") != host:
-        raise AgentProtocolError("invalid_jwt_claim", "host mismatch")
-    if claims.get("path") != path:
-        raise AgentProtocolError("invalid_jwt_claim", "path mismatch")
-
-    now = now_secs if now_secs is not None else unix_time_secs()
+
+    now = now_secs if now_secs is not None else unix_secs()
     if claims["iat"] > now or claims["exp"] < now:
         raise AgentProtocolError("invalid_jwt_claim", "iat/exp outside valid time window")
     if claims["exp"] - claims["iat"] > max_ttl_secs:
@@ -237,32 +260,17 @@ def verify_request_jwt(token: str, *, audience: str, method: str, host: str, pat
     return claims
 
 
-def verify_request_jwt_live(token: str, nonce_store: NonceStore, **context: Any) -> dict[str, Any]:
-    claims = verify_request_jwt(token, **context)
-    nonce_store.check_and_insert((claims["iss"], _REQUEST_AUTH_REPLAY_SCOPE, None, claims["jti"]))
-    return claims
-
-
-def unix_time_millis() -> int:
+def unix_ms() -> int:
     return int(time.time() * 1000)
 
 
-def unix_time_secs() -> int:
+def unix_secs() -> int:
     return int(time.time())
 
 
-def random_nonce(prefix: str = "n_") -> str:
-    return f"{prefix}{_base64url_encode(os.urandom(16))}"
-
-
-def _base58btc_encode(data: bytes) -> str:
-    return "z" + base58.b58encode(data).decode()
-
-
-def _base58btc_decode(value: str) -> bytes:
-    if not value.startswith("z"):
-        raise AgentProtocolError("invalid_encoding", "expected base58btc multibase value")
-    return base58.b58decode(value[1:])
+def validate_nonce(nonce: int) -> None:
+    if not isinstance(nonce, int) or nonce < 1 or nonce > 0x1FFFFFFFFFFFFF:
+        raise AgentProtocolError("invalid_nonce", "nonce must be a positive integer less than or equal to 9007199254740991")
 
 
 def _base64url_encode(data: bytes) -> str:
@@ -272,3 +280,9 @@ def _base64url_encode(data: bytes) -> str:
 def _base64url_decode(value: str) -> bytes:
     padding = "=" * ((4 - len(value) % 4) % 4)
     return base64.urlsafe_b64decode(value + padding)
+
+
+def _base64url_decode_no_pad(value: str) -> bytes:
+    if not re.fullmatch(r"[A-Za-z0-9_-]+", value):
+        raise AgentProtocolError("invalid_encoding", "expected base64url without padding")
+    return _base64url_decode(value)

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/src/agent_protocols/profile.py

@@ -12,34 +12,36 @@ ProfileUpdatePayload = dict[str, Any]
 AgentProfile = dict[str, Any]
 
 
-def profile_update_event(actor: AgentId, created_at: int, nonce: str, payload: ProfileUpdatePayload) -> Event:
+def profile_update_event(actor: AgentId, created_at: int, nonce: int, payload: ProfileUpdatePayload) -> Event:
     return create_event(PROFILE_PROTOCOL, PROFILE_UPDATE, actor, created_at, nonce, payload)
 
 
 def validate_profile_update(envelope: Envelope) -> None:
     verify_envelope(envelope)
     event = envelope["event"]
+    payload_id = event["payload"].get("id") or event["payload"].get("agent_id")
     if event["protocol"] != PROFILE_PROTOCOL:
         raise AgentProtocolError("invalid_event_protocol", f"expected {PROFILE_PROTOCOL}, got {event['protocol']}")
     if event["type"] != PROFILE_UPDATE:
         raise AgentProtocolError("invalid_event_type", f"expected {PROFILE_UPDATE}, got {event['type']}")
-    if event["actor"] != event["payload"].get("agent_id"):
-        raise AgentProtocolError("invalid_actor", "profile update actor must match payload.agent_id")
+    if event["actor"] != payload_id:
+        raise AgentProtocolError("invalid_actor", "profile update actor must match payload.id")
 
 
 def materialize_profile(envelope: Envelope) -> AgentProfile:
     validate_profile_update(envelope)
     payload = envelope["event"]["payload"]
+    payload_id = payload.get("id") or payload.get("agent_id")
     return {
-        "agent_id": payload["agent_id"],
+        "id": payload_id,
         "name": payload["name"],
         "description": payload.get("description"),
         "avatar_url": payload.get("avatar_url"),
         "provider": payload.get("provider"),
         "capabilities": payload.get("capabilities", []),
         "service_endpoints": payload.get("service_endpoints", []),
-        "links": payload.get("links", {}),
-        "metadata": payload.get("metadata", {}),
+        "links": payload.get("links", []),
+        "extra": payload.get("extra", {}),
         "updated_at": envelope["event"]["created_at"],
-        "profile_event_id": envelope["event_id"],
+        "event_id": envelope["hash"],
     }

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/src/agent_protocols.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: agent-protocols
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python SDK for Agent Identity, Agent Profile, and Agent Discourse protocols
 Author: LDCLabs
 License: MIT
 Keywords: agent,protocol,ed25519,sdk
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: base58<3,>=2.1
 Requires-Dist: cryptography>=42
 Requires-Dist: rfc8785<0.2,>=0.1.4
 Provides-Extra: http
@@ -19,22 +18,23 @@ Python SDK for the draft Agent Identity, Agent Profile, and Agent Discourse prot
 
 ## Modules
 
-- `agent_protocols.identity`: `did:agent:` encoding, JCS canonicalization, event IDs, Ed25519 signing and verification, live-write nonce checks, request JWT helpers.
+- `agent_protocols.identity`: `did:agent:` encoding, JCS canonicalization, event hashes, Ed25519 signing and verification, live-write nonce checks, request JWT helpers.
 - `agent_protocols.profile`: `profile.update` payload helpers, validation, materialization.
-- `agent_protocols.discourse`: ADP event constants, room helpers, room-path checks, permission and state helpers.
+- `agent_protocols.discourse`: ADP event constants, join request helpers, room-path checks, permission and state helpers.
 - `agent_protocols.http_client`: optional requests-based Profile and Discourse clients. Install with `agent-protocols[http]`.
 
 ## Example
 
 ```python
-from agent_protocols import AgentSigner, materialize_profile, profile_update_event, unix_time_millis
+from agent_protocols import AgentSigner, ClientNonceManager, materialize_profile, profile_update_event, unix_ms
 
 signer = AgentSigner.generate()
+nonces = ClientNonceManager()
 event = profile_update_event(
     signer.agent_id(),
-    unix_time_millis(),
-    "n_01J8Z6",
-    {"agent_id": signer.agent_id(), "name": "ResearchAgent-v3"},
+    unix_ms(),
+    nonces.next_nonce(),
+    {"id": signer.agent_id(), "name": "ResearchAgent-v3"},
 )
 envelope = signer.sign_event(event)
 profile = materialize_profile(envelope)

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/src/agent_protocols.egg-info/requires.txt

@@ -1,4 +1,3 @@
-base58<3,>=2.1
 cryptography>=42
 rfc8785<0.2,>=0.1.4
 

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/tests/test_discourse.py

@@ -1,15 +1,19 @@
 import unittest
 
 from agent_protocols.discourse import (
-    MESSAGE_TEXT,
+    MESSAGE_CREATE,
     REACTION_CREATE,
     ROOM_CANCEL,
     ROOM_CREATE,
+    ROOM_JOIN,
+    ROOM_JOIN_REVIEW,
     can_accept_room_write,
     can_submit_event,
     room_create_event,
     validate_discourse_envelope,
+    validate_room_path,
 )
+from agent_protocols.http_client import websocket_events_url
 from agent_protocols.identity import AgentSigner, create_event
 
 
@@ -19,16 +23,24 @@ class DiscourseTests(unittest.TestCase):
         event = room_create_event(
             signer.agent_id(),
             100,
-            "n_room",
+            1,
             {"topic": "Research room", "visibility": "public", "start_time": 1000, "end_time": 2000},
         )
         envelope = signer.sign_event(event)
 
         validate_discourse_envelope(envelope)
+        validate_room_path(envelope, "d8ftedhpqhsusbg001tg")
 
     def test_rejects_room_event_without_room_id(self):
         signer = AgentSigner.from_seed(bytes([15]) * 32)
-        event = create_event("agent-discourse/1.0", MESSAGE_TEXT, signer.agent_id(), 100, "n_message", {"text": "hello"})
+        event = create_event(
+            "agent-discourse/1.0",
+            MESSAGE_CREATE,
+            signer.agent_id(),
+            100,
+            1,
+            {"content_type": "text/plain", "content": "hello"},
+        )
         envelope = signer.sign_event(event)
 
         with self.assertRaises(Exception):
@@ -36,17 +48,29 @@ class DiscourseTests(unittest.TestCase):
 
     def test_applies_permission_matrix(self):
         self.assertTrue(can_submit_event(REACTION_CREATE, {"role": "observer"}))
-        self.assertFalse(can_submit_event(MESSAGE_TEXT, {"role": "observer"}))
+        self.assertFalse(can_submit_event(MESSAGE_CREATE, {"role": "observer"}))
+        self.assertFalse(can_submit_event(ROOM_JOIN, {"role": "observer"}))
+        self.assertTrue(can_submit_event(ROOM_JOIN, {"join_request_approved": True}))
+        self.assertTrue(can_submit_event(ROOM_JOIN_REVIEW, {"role": "moderator"}))
+        self.assertFalse(can_submit_event(ROOM_JOIN_REVIEW, {"role": "participant"}))
         self.assertFalse(can_submit_event(ROOM_CANCEL, {"role": "moderator"}))
         self.assertTrue(can_submit_event(ROOM_CANCEL, {"role": "moderator", "moderator_authorized": True}))
         self.assertTrue(can_submit_event(ROOM_CREATE, {}))
 
     def test_applies_state_restrictions(self):
-        self.assertTrue(can_accept_room_write(MESSAGE_TEXT, "active", {"role": "participant"}))
-        self.assertFalse(can_accept_room_write(MESSAGE_TEXT, "scheduled", {"role": "participant"}))
+        self.assertTrue(can_accept_room_write(MESSAGE_CREATE, "active", {"role": "participant"}))
+        self.assertFalse(can_accept_room_write(MESSAGE_CREATE, "scheduled", {"role": "participant"}))
+        self.assertTrue(can_accept_room_write(ROOM_JOIN_REVIEW, "scheduled", {"role": "moderator"}))
+        self.assertTrue(can_accept_room_write(ROOM_JOIN, "scheduled", {"join_request_approved": True}))
         self.assertFalse(can_accept_room_write(REACTION_CREATE, "ended", {"role": "participant"}))
         self.assertTrue(can_accept_room_write(REACTION_CREATE, "ended", {"role": "participant"}, post_end_reaction_allowed=True))
 
+    def test_builds_websocket_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",
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

{agent_protocols-0.1.0 → agent_protocols-0.2.0}/tests/test_identity.py

@@ -2,13 +2,14 @@ import unittest
 
 from agent_protocols.identity import (
     AgentSigner,
+    ClientNonceManager,
     MemoryNonceStore,
     RequestBinding,
     create_event,
     create_request_jwt_claims,
     verify_envelope,
     verify_live_envelope,
-    verify_request_jwt_live,
+    verify_request_jwt,
 )
 
 
@@ -20,19 +21,20 @@ class IdentityTests(unittest.TestCase):
             "profile.update",
             signer.agent_id(),
             1_779_753_600_000,
-            "n_test",
+            1,
             {"agent_id": signer.agent_id(), "name": "ResearchAgent"},
         )
 
         envelope = signer.sign_event(event)
 
-        self.assertTrue(envelope["event_id"].startswith("evt_z"))
+        self.assertEqual(len(envelope["hash"]), 43)
+        self.assertFalse(envelope["hash"].startswith("evt_"))
         verify_envelope(envelope)
 
     def test_rejects_tampered_payloads(self):
         signer = AgentSigner.from_seed(bytes([8]) * 32)
         envelope = signer.sign_event(
-            create_event("agent-profile/1.0", "profile.update", signer.agent_id(), 1000, "n_test", {"name": "before"})
+            create_event("agent-profile/1.0", "profile.update", signer.agent_id(), 1000, 1, {"name": "before"})
         )
         envelope["event"]["payload"] = {"name": "after"}
 
@@ -42,44 +44,37 @@ class IdentityTests(unittest.TestCase):
     def test_rejects_nonce_reuse(self):
         signer = AgentSigner.from_seed(bytes([9]) * 32)
         envelope = signer.sign_event(
-            create_event("agent-profile/1.0", "profile.update", signer.agent_id(), 1000, "n_reused", {"name": "ResearchAgent"})
+            create_event("agent-profile/1.0", "profile.update", signer.agent_id(), 1000, 1, {"name": "ResearchAgent"})
         )
         store = MemoryNonceStore()
 
-        verify_live_envelope(envelope, store, now_ms=1000, window_ms=1000)
+        self.assertEqual(verify_live_envelope(envelope, store, now_ms=1000, window_ms=1000), 1)
         with self.assertRaises(Exception):
             verify_live_envelope(envelope, store, now_ms=1000, window_ms=1000)
 
+    def test_client_nonce_manager_observes_server_max(self):
+        manager = ClientNonceManager()
+
+        self.assertEqual(manager.next_nonce(), 1)
+        manager.observe_max_nonce("5")
+
+        self.assertEqual(manager.peek(), 6)
+        self.assertEqual(manager.next_nonce(), 6)
+
     def test_signs_and_verifies_request_jwts(self):
         signer = AgentSigner.from_seed(bytes([10]) * 32)
-        binding = RequestBinding.create("https://api.example.com", "get", "api.example.com", "/v1/profiles/did:agent:test")
-        claims = create_request_jwt_claims(signer.agent_id(), binding, 100, 300, "jwt_nonce")
+        binding = RequestBinding.create("https://api.example.com")
+        claims = create_request_jwt_claims(signer.agent_id(), binding, 100, 300)
         token = signer.sign_request_jwt(claims)
-        store = MemoryNonceStore()
 
-        verified = verify_request_jwt_live(
+        verified = verify_request_jwt(
             token,
-            store,
             audience=binding.audience,
-            method=binding.method,
-            host=binding.host,
-            path=binding.path,
             now_secs=120,
             max_ttl_secs=300,
         )
 
-        self.assertEqual(verified["jti"], "jwt_nonce")
-        with self.assertRaises(Exception):
-            verify_request_jwt_live(
-                token,
-                store,
-                audience=binding.audience,
-                method=binding.method,
-                host=binding.host,
-                path=binding.path,
-                now_secs=120,
-                max_ttl_secs=300,
-            )
+        self.assertEqual(verified["iss"], signer.agent_id())
 
 
 if __name__ == "__main__":

agent_protocols-0.2.0/tests/test_profile.py

@@ -0,0 +1,49 @@
+import unittest
+
+from agent_protocols.identity import AgentSigner
+from agent_protocols.profile import materialize_profile, profile_update_event, validate_profile_update
+
+
+class ProfileTests(unittest.TestCase):
+    def test_materializes_valid_profile_update(self):
+        signer = AgentSigner.from_seed(bytes([11]) * 32)
+        payload = {
+            "id": signer.agent_id(),
+            "name": "ResearchAgent-v3",
+            "capabilities": ["research"],
+            "extra": {"domain": "research"},
+            "links": [{"name": "Homepage", "url": "https://example.com", "rel": "homepage"}],
+        }
+        envelope = signer.sign_event(profile_update_event(signer.agent_id(), 1_779_753_600_000, 1, payload))
+
+        profile = materialize_profile(envelope)
+
+        self.assertEqual(profile["id"], signer.agent_id())
+        self.assertEqual(profile["name"], "ResearchAgent-v3")
+        self.assertEqual(profile["links"], payload["links"])
+        self.assertEqual(profile["extra"], payload["extra"])
+        self.assertEqual(profile["updated_at"], 1_779_753_600_000)
+        self.assertEqual(profile["event_id"], envelope["hash"])
+
+    def test_rejects_actor_payload_mismatch(self):
+        signer = AgentSigner.from_seed(bytes([12]) * 32)
+        other = AgentSigner.from_seed(bytes([13]) * 32)
+        payload = {"id": other.agent_id(), "name": "Imposter"}
+        envelope = signer.sign_event(profile_update_event(signer.agent_id(), 1_779_753_600_000, 1, payload))
+
+        with self.assertRaises(Exception):
+            validate_profile_update(envelope)
+
+    def test_materializes_legacy_agent_id_payload(self):
+        signer = AgentSigner.from_seed(bytes([14]) * 32)
+        payload = {"agent_id": signer.agent_id(), "name": "LegacyAgent"}
+        envelope = signer.sign_event(profile_update_event(signer.agent_id(), 1_779_753_600_001, 1, payload))
+
+        profile = materialize_profile(envelope)
+
+        self.assertEqual(profile["id"], signer.agent_id())
+        self.assertEqual(profile["name"], "LegacyAgent")
+
+
+if __name__ == "__main__":
+    unittest.main()

agent_protocols-0.1.0/src/agent_protocols/http_client.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-try:
-    import requests
-except ImportError:  # pragma: no cover
-    requests = None  # type: ignore[assignment]
-
-from .identity import AgentId, Envelope
-
-
-class ProfileClient:
-    def __init__(self, base_url: str, session: Any | None = None):
-        self.base_url = base_url.rstrip("/")
-        self.session = session or _requests_session()
-
-    def get_profile(self, agent_id: AgentId) -> dict[str, Any]:
-        return self._get(f"/v1/profiles/{agent_id}")
-
-    def submit_profile_update(self, envelope: Envelope) -> dict[str, Any]:
-        return self._post("/v1/profiles", envelope)
-
-    def _get(self, path: str) -> dict[str, Any]:
-        response = self.session.get(self.base_url + path)
-        response.raise_for_status()
-        return response.json()
-
-    def _post(self, path: str, body: Any) -> dict[str, Any]:
-        response = self.session.post(self.base_url + path, json=body)
-        response.raise_for_status()
-        return response.json()
-
-
-class DiscourseClient:
-    def __init__(self, base_url: str, session: Any | None = None):
-        self.base_url = base_url.rstrip("/")
-        self.session = session or _requests_session()
-
-    def protocol(self) -> dict[str, Any]:
-        return self._get("/v1/protocol")
-
-    def create_room(self, envelope: Envelope) -> dict[str, Any]:
-        return self._post("/v1/rooms", envelope)
-
-    def join_room(self, room_id: str, envelope: Envelope) -> dict[str, Any]:
-        return self._post(f"/v1/rooms/{room_id}/join", envelope)
-
-    def leave_room(self, room_id: str, envelope: Envelope) -> dict[str, Any]:
-        return self._post(f"/v1/rooms/{room_id}/leave", envelope)
-
-    def submit_event(self, room_id: str, envelope: Envelope) -> dict[str, Any]:
-        return self._post(f"/v1/rooms/{room_id}/events", envelope)
-
-    def events(self, room_id: str) -> list[dict[str, Any]]:
-        return self._get(f"/v1/rooms/{room_id}/events")
-
-    def archive(self, room_id: str) -> dict[str, Any]:
-        return self._get(f"/v1/rooms/{room_id}/archive")
-
-    def _get(self, path: str) -> Any:
-        response = self.session.get(self.base_url + path)
-        response.raise_for_status()
-        return response.json()
-
-    def _post(self, path: str, body: Any) -> Any:
-        response = self.session.post(self.base_url + path, json=body)
-        response.raise_for_status()
-        return response.json()
-
-
-def _requests_session() -> Any:
-    if requests is None:
-        raise RuntimeError("Install agent-protocols[http] to use HTTP clients")
-    return requests.Session()

agent_protocols-0.1.0/tests/test_profile.py

@@ -1,30 +0,0 @@
-import unittest
-
-from agent_protocols.identity import AgentSigner
-from agent_protocols.profile import materialize_profile, profile_update_event, validate_profile_update
-
-
-class ProfileTests(unittest.TestCase):
-    def test_materializes_valid_profile_update(self):
-        signer = AgentSigner.from_seed(bytes([11]) * 32)
-        payload = {"agent_id": signer.agent_id(), "name": "ResearchAgent-v3", "capabilities": ["research"]}
-        envelope = signer.sign_event(profile_update_event(signer.agent_id(), 1_779_753_600_000, "n_profile", payload))
-
-        profile = materialize_profile(envelope)
-
-        self.assertEqual(profile["name"], "ResearchAgent-v3")
-        self.assertEqual(profile["updated_at"], 1_779_753_600_000)
-        self.assertEqual(profile["profile_event_id"], envelope["event_id"])
-
-    def test_rejects_actor_payload_mismatch(self):
-        signer = AgentSigner.from_seed(bytes([12]) * 32)
-        other = AgentSigner.from_seed(bytes([13]) * 32)
-        payload = {"agent_id": other.agent_id(), "name": "Imposter"}
-        envelope = signer.sign_event(profile_update_event(signer.agent_id(), 1_779_753_600_000, "n_profile", payload))
-
-        with self.assertRaises(Exception):
-            validate_profile_update(envelope)
-
-
-if __name__ == "__main__":
-    unittest.main()