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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: agent-protocols
-Version: 0.4.0
-Summary: Python SDK for Agent Identity, Agent Profile, and Agent Discourse protocols
+Version: 0.5.0
+Summary: Python SDK for Agent Identity, Agent Profile, Agent Delegation, and Agent Discourse protocols
 Author: LDCLabs
 License: MIT
 Keywords: agent,protocol,ed25519,sdk
@@ -15,14 +15,15 @@ Requires-Dist: requests<3,>=2.31; extra == "http"
 
 # agent-protocols Python SDK
 
-Python SDK for the draft Agent Identity, Agent Profile, and Agent Discourse protocols.
+Python SDK for the draft Agent Identity, Agent Profile, Agent Delegation, and Agent Discourse protocols.
 
 ## Modules
 
 - `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.profile`: `profile.update` payload helpers, delegation discovery hints, validation, materialization.
+- `agent_protocols.delegation`: Agent Delegation principal documents, grant/revoke payloads, credential documents, validation, and materialization.
 - `agent_protocols.discourse`: ADP kernel event constants, the room type system (type definitions, pack imports, type registry, JSON Schema payload validation), join request helpers, room-path checks, kind-based permission and state helpers.
-- `agent_protocols.http_client`: optional requests-based Profile and Discourse clients. Install with `agent-protocols[http]`.
+- `agent_protocols.http_client`: optional requests-based Profile, Delegation, and Discourse clients. Install with `agent-protocols[http]`.
 
 ## Example
 
@@ -41,6 +42,6 @@ envelope = signer.sign_event(event)
 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.
+Agent Profile has no `username` field: the Agent ID is the identity key, and the latest profile is the accepted `profile.update` with the greatest `nonce`.
 
-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`.
+ADP room writes declare a signed `base_seq` / `base_hash`: discussion and contract writes must match the current room head, while `signal`-kind writes — including the built-in membership events — only anchor to an accepted record and never contend for the 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.5.0/README.md

@@ -0,0 +1,32 @@
+# agent-protocols Python SDK
+
+Python SDK for the draft Agent Identity, Agent Profile, Agent Delegation, and Agent Discourse protocols.
+
+## Modules
+
+- `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, delegation discovery hints, validation, materialization.
+- `agent_protocols.delegation`: Agent Delegation principal documents, grant/revoke payloads, credential documents, validation, and materialization.
+- `agent_protocols.discourse`: ADP kernel event constants, the room type system (type definitions, pack imports, type registry, JSON Schema payload validation), join request helpers, room-path checks, kind-based permission and state helpers.
+- `agent_protocols.http_client`: optional requests-based Profile, Delegation, and Discourse clients. Install with `agent-protocols[http]`.
+
+## Example
+
+```python
+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_ms(),
+    nonces.next_nonce(),
+    {"id": signer.agent_id(), "name": "ResearchAgent-v3"},
+)
+envelope = signer.sign_event(event)
+profile = materialize_profile(envelope)
+```
+
+Agent Profile has no `username` field: the Agent ID is the identity key, and the latest profile is the accepted `profile.update` with the greatest `nonce`.
+
+ADP room writes declare a signed `base_seq` / `base_hash`: discussion and contract writes must match the current room head, while `signal`-kind writes — including the built-in membership events — only anchor to an accepted record and never contend for the 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.4.0 → agent_protocols-0.5.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "agent-protocols"
-version = "0.4.0"
-description = "Python SDK for Agent Identity, Agent Profile, and Agent Discourse protocols"
+version = "0.5.0"
+description = "Python SDK for Agent Identity, Agent Profile, Agent Delegation, and Agent Discourse protocols"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }

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

@@ -13,6 +13,7 @@ from .identity import (
     event_hash,
     event_hash_bytes,
     public_key_bytes,
+    service_origin,
     sign_event,
     sign_event_hash,
     unix_ms,
@@ -31,10 +32,33 @@ from .identity import (
     with_room_head,
     with_room_id,
 )
-from .profile import PROFILE_PROTOCOL, PROFILE_UPDATE, materialize_profile, profile_update_event, validate_profile_update
+from .profile import (
+    PROFILE_PROTOCOL,
+    PROFILE_UPDATE,
+    latest_profile_update,
+    materialize_profile,
+    profile_update_event,
+    validate_profile_update,
+)
+from .delegation import (
+    DELEGATION_GRANT,
+    DELEGATION_PROTOCOL,
+    DELEGATION_REVOKE,
+    delegation_grant_event,
+    delegation_revoke_event,
+    materialize_delegation_credential,
+    validate_delegation_envelope,
+    validate_delegation_grant_payload,
+    validate_delegation_query_request,
+    validate_delegation_revoke_payload,
+    validate_principal_document,
+)
 
 __all__ = [
     "AGENT_ID_PREFIX",
+    "DELEGATION_GRANT",
+    "DELEGATION_PROTOCOL",
+    "DELEGATION_REVOKE",
     "MAX_NONCE_HEADER",
     "PROFILE_PROTOCOL",
     "PROFILE_UPDATE",
@@ -46,18 +70,28 @@ __all__ = [
     "agent_id_from_public_key",
     "canonical_event_bytes",
     "create_event",
+    "delegation_grant_event",
+    "delegation_revoke_event",
     "create_request_jwt_claims",
     "event_hash",
     "event_hash_bytes",
+    "latest_profile_update",
     "materialize_profile",
+    "materialize_delegation_credential",
     "profile_update_event",
     "public_key_bytes",
+    "service_origin",
     "sign_event",
     "sign_event_hash",
     "unix_ms",
     "unix_secs",
     "validate_agent_id",
+    "validate_delegation_envelope",
+    "validate_delegation_grant_payload",
+    "validate_delegation_query_request",
+    "validate_delegation_revoke_payload",
     "validate_nonce",
+    "validate_principal_document",
     "validate_profile_update",
     "verify_envelope",
     "verify_event_hash",

agent_protocols-0.5.0/src/agent_protocols/delegation.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urlparse
+
+from .errors import AgentProtocolError
+from .identity import AgentId, Envelope, Event, create_event, validate_agent_id, verify_envelope
+
+DELEGATION_PROTOCOL = "agent-delegation/1.0"
+DELEGATION_GRANT = "delegation.grant"
+DELEGATION_REVOKE = "delegation.revoke"
+
+DelegationGrantPayload = dict[str, Any]
+DelegationRevokePayload = dict[str, Any]
+DelegationCredential = dict[str, Any]
+PrincipalDocument = dict[str, Any]
+
+
+def delegation_grant_event(
+    actor: AgentId,
+    created_at: int,
+    nonce: int,
+    payload: DelegationGrantPayload,
+) -> Event:
+    return create_event(DELEGATION_PROTOCOL, DELEGATION_GRANT, actor, created_at, nonce, payload)
+
+
+def delegation_revoke_event(
+    actor: AgentId,
+    created_at: int,
+    nonce: int,
+    payload: DelegationRevokePayload,
+) -> Event:
+    return create_event(DELEGATION_PROTOCOL, DELEGATION_REVOKE, actor, created_at, nonce, payload)
+
+
+def validate_principal_document(document: PrincipalDocument) -> None:
+    _validate_https_url(document.get("id"), "principal.id")
+    controllers = document.get("controllers")
+    if not isinstance(controllers, list) or not controllers:
+        raise AgentProtocolError(
+            "invalid_principal",
+            "principal document controllers must be non-empty",
+        )
+    for controller in controllers:
+        validate_agent_id(controller)
+    if document.get("delegations_url") is not None:
+        _validate_https_url(document["delegations_url"], "delegations_url")
+
+
+def validate_delegation_grant_payload(
+    payload: DelegationGrantPayload,
+    created_at: int | None = None,
+) -> None:
+    _validate_non_empty(payload.get("id"), "payload.id")
+    _validate_principal_descriptor(payload.get("principal"))
+    validate_agent_id(payload.get("subject"))
+    scopes = payload.get("scopes")
+    if not isinstance(scopes, list) or not scopes:
+        raise AgentProtocolError("invalid_delegation", "delegation scopes must be non-empty")
+    for scope in scopes:
+        _validate_non_empty(scope, "scope")
+    constraints = payload.get("constraints")
+    if constraints is not None and not isinstance(constraints, dict):
+        raise AgentProtocolError("invalid_delegation", "constraints must be an object")
+    expires_at = payload.get("expires_at")
+    if expires_at is not None:
+        not_before = payload.get("not_before")
+        if not_before is not None and expires_at <= not_before:
+            raise AgentProtocolError(
+                "invalid_delegation",
+                "expires_at must be greater than not_before",
+            )
+        if created_at is not None and expires_at <= created_at:
+            raise AgentProtocolError(
+                "invalid_delegation",
+                "expires_at must be greater than created_at",
+            )
+
+
+def validate_delegation_query_request(request: dict[str, Any]) -> None:
+    """A delegation query MUST include at least one of `subject` or
+    `principal_id`. `limit` defaults to 20; services SHOULD cap it at 100."""
+    subject = request.get("subject")
+    principal_id = request.get("principal_id")
+    if subject is None and principal_id is None:
+        raise AgentProtocolError(
+            "invalid_delegation",
+            "query must include at least one of subject or principal_id",
+        )
+    if subject is not None:
+        validate_agent_id(subject)
+    if principal_id is not None:
+        _validate_https_url(principal_id, "principal_id")
+    limit = request.get("limit")
+    if limit is not None and (not isinstance(limit, int) or limit < 1):
+        raise AgentProtocolError("invalid_delegation", "limit must be a positive integer")
+
+
+def validate_delegation_revoke_payload(payload: DelegationRevokePayload) -> None:
+    _validate_non_empty(payload.get("id"), "payload.id")
+    _validate_https_url(payload.get("principal_id"), "principal_id")
+
+
+def validate_delegation_envelope(envelope: Envelope) -> None:
+    verify_envelope(envelope)
+    event = envelope["event"]
+    if event["protocol"] != DELEGATION_PROTOCOL:
+        raise AgentProtocolError(
+            "invalid_event_protocol",
+            f"expected {DELEGATION_PROTOCOL}, got {event['protocol']}",
+        )
+    if event["type"] == DELEGATION_GRANT:
+        validate_delegation_grant_payload(event["payload"], event["created_at"])
+    elif event["type"] == DELEGATION_REVOKE:
+        validate_delegation_revoke_payload(event["payload"])
+    else:
+        raise AgentProtocolError(
+            "invalid_event_type",
+            f"expected {DELEGATION_GRANT} or {DELEGATION_REVOKE}, got {event['type']}",
+        )
+
+
+def materialize_delegation_credential(
+    envelope: Envelope,
+    *,
+    status: str = "active",
+    status_url: str | None = None,
+    updated_at: int | None = None,
+) -> DelegationCredential:
+    validate_delegation_envelope(envelope)
+    event = envelope["event"]
+    if event["type"] != DELEGATION_GRANT:
+        raise AgentProtocolError(
+            "invalid_event_type",
+            "delegation credential materialization requires a grant event",
+        )
+    payload = event["payload"]
+    credential = {
+        "id": payload["id"],
+        "protocol": DELEGATION_PROTOCOL,
+        "principal": payload["principal"],
+        "controller": event["actor"],
+        "subject": payload["subject"],
+        "relationship": payload.get("relationship"),
+        "scopes": payload["scopes"],
+        "constraints": payload.get("constraints"),
+        "not_before": payload.get("not_before"),
+        "expires_at": payload.get("expires_at"),
+        "status": status,
+        "status_url": status_url,
+        "updated_at": updated_at if updated_at is not None else event["created_at"],
+        "event_id": envelope["hash"],
+    }
+    return credential
+
+
+def _validate_principal_descriptor(value: Any) -> None:
+    if not isinstance(value, dict):
+        raise AgentProtocolError("invalid_principal", "principal must be an object")
+    _validate_https_url(value.get("id"), "principal.id")
+
+
+def _validate_https_url(value: Any, field: str) -> None:
+    if not isinstance(value, str):
+        raise AgentProtocolError("invalid_url", f"{field} must be an HTTPS URL")
+    parsed = urlparse(value)
+    if parsed.scheme != "https" or not parsed.netloc:
+        raise AgentProtocolError("invalid_url", f"{field} must be an HTTPS URL")
+
+
+def _validate_non_empty(value: Any, field: str) -> None:
+    if not isinstance(value, str) or not value.strip():
+        raise AgentProtocolError("invalid_delegation", f"{field} must not be empty")

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

@@ -1,7 +1,7 @@
 """Agent Discourse Protocol 1.0: kernel types, the room type system, and
 verification helpers.
 
-The protocol defines nine built-in event types. Every other event type is
+The protocol defines eleven built-in event types. Every other event type is
 declared per room as a schema-validated type definition, either inline or
 imported from a type pack. Hosts validate structure and permissions; they
 never need to understand application semantics.
@@ -32,12 +32,14 @@ from .identity import (
 
 DISCOURSE_PROTOCOL = "agent-discourse/1.0"
 
-# The nine built-in event types. All other types are room-defined.
+# The eleven built-in event types. All other types are room-defined.
 ROOM_CREATE = "room.create"
+ROOM_UPDATE = "room.update"
 ROOM_JOIN = "room.join"
 ROOM_JOIN_REVIEW = "room.join.review"
 ROOM_LEAVE = "room.leave"
 ROOM_MEMBER_ROLE_UPDATE = "room.member.role.update"
+ROOM_MEMBER_REMOVE = "room.member.remove"
 ROOM_CLOSE = "room.close"
 ROOM_CANCEL = "room.cancel"
 TYPE_DEFINE = "type.define"
@@ -45,16 +47,67 @@ MESSAGE_CREATE = "message.create"
 
 BUILTIN_EVENT_TYPES = {
     ROOM_CREATE,
+    ROOM_UPDATE,
     ROOM_JOIN,
     ROOM_JOIN_REVIEW,
     ROOM_LEAVE,
     ROOM_MEMBER_ROLE_UPDATE,
+    ROOM_MEMBER_REMOVE,
     ROOM_CLOSE,
     ROOM_CANCEL,
     TYPE_DEFINE,
     MESSAGE_CREATE,
 }
 
+# Built-in membership events. They carry the `signal` class: they anchor to
+# an accepted record but never contend for or advance the room head, so busy
+# rooms cannot starve joins, reviews, or other membership writes.
+MEMBERSHIP_EVENT_TYPES = (
+    ROOM_JOIN,
+    ROOM_JOIN_REVIEW,
+    ROOM_LEAVE,
+    ROOM_MEMBER_ROLE_UPDATE,
+    ROOM_MEMBER_REMOVE,
+)
+
+# Standard ADP error codes from the Section 20 table.
+DISCOURSE_ERROR_CODES = frozenset(
+    {
+        "invalid_event",
+        "invalid_event_hash",
+        "invalid_signature",
+        "invalid_actor",
+        "timestamp_out_of_window",
+        "nonce_not_greater",
+        "room_not_found",
+        "room_not_active",
+        "room_ended",
+        "permission_denied",
+        "approval_required",
+        "join_request_not_found",
+        "join_request_not_approved",
+        "join_request_role_mismatch",
+        "join_request_expired",
+        "member_banned",
+        "role_not_allowed",
+        "max_speakers_exceeded",
+        "membership_required",
+        "invalid_token",
+        "room_head_mismatch",
+        "base_record_mismatch",
+        "agent_status_not_found",
+        "rate_limited",
+        "payload_too_large",
+        "type_not_defined",
+        "type_disabled",
+        "payload_schema_violation",
+        "pack_unavailable",
+    }
+)
+
+# Hosts MUST reject events with more than this many `mentions` entries.
+MAX_MENTIONS = 32
+
 # Custom event types must not use these prefixes.
 RESERVED_TYPE_PREFIXES = ("room.", "type.")
 
@@ -94,6 +147,7 @@ class PermissionContext(TypedDict, total=False):
 
     role: Role
     is_creator: bool
+    public_join_allowed: bool
     join_request_approved: bool
 
 
@@ -170,6 +224,42 @@ def event_requires_room_id(event_type: str) -> bool:
     return event_type != ROOM_CREATE
 
 
+BuiltinEventClass = Literal["lifecycle", "signal", "control", "message"]
+
+_BUILTIN_EVENT_CLASSES: dict[str, BuiltinEventClass] = {
+    ROOM_CREATE: "lifecycle",
+    ROOM_UPDATE: "lifecycle",
+    ROOM_CLOSE: "lifecycle",
+    ROOM_CANCEL: "lifecycle",
+    ROOM_JOIN: "signal",
+    ROOM_JOIN_REVIEW: "signal",
+    ROOM_LEAVE: "signal",
+    ROOM_MEMBER_ROLE_UPDATE: "signal",
+    ROOM_MEMBER_REMOVE: "signal",
+    TYPE_DEFINE: "control",
+    MESSAGE_CREATE: "message",
+}
+
+
+def builtin_event_class(event_type: str) -> BuiltinEventClass | None:
+    """Section 13.2 class of a built-in type; ``None`` for room-defined types."""
+    return _BUILTIN_EVENT_CLASSES.get(event_type)
+
+
+def event_advances_room_head(event_type: str, registry: "TypeRegistry | None" = None) -> bool:
+    """Whether an accepted record of this type advances the room head and must
+    therefore match the current head when written (Section 6.1). Room
+    lifecycle, `message`-kind, and `control`-kind records advance the head;
+    `signal`-kind records — including the built-in membership events — only
+    anchor to an accepted record. Unknown custom types default to
+    head-advancing."""
+    builtin_class = builtin_event_class(event_type)
+    if builtin_class is not None:
+        return builtin_class != "signal"
+    definition = registry.get(event_type) if registry is not None else None
+    return definition is None or definition.get("kind") != "signal"
+
+
 def validate_discourse_envelope(envelope: Envelope) -> None:
     verify_envelope(envelope)
     event = envelope["event"]
@@ -221,8 +311,17 @@ def _validate_mentions(mentions: Any) -> None:
         return
     if not isinstance(mentions, list):
         raise AgentProtocolError("invalid_event", "mentions must be an Agent ID array")
+    if len(mentions) > MAX_MENTIONS:
+        raise AgentProtocolError("invalid_event", f"mentions must not exceed {MAX_MENTIONS} entries")
+    # Validate each entry before testing uniqueness: a non-string mention would
+    # otherwise raise a raw TypeError from set() instead of a clean protocol
+    # error.
+    seen: set[str] = set()
     for mention in mentions:
         validate_agent_id(mention)
+        if mention in seen:
+            raise AgentProtocolError("invalid_event", "mentions must be unique")
+        seen.add(mention)
 
 
 def validate_custom_event_type_name(name: str) -> None:
@@ -333,6 +432,12 @@ class TypeRegistry:
 
     def define(self, definition: dict[str, Any]) -> None:
         validate_type_def(definition)
+        existing = self._types.get(definition["type"])
+        if existing is not None and existing.get("kind") != definition.get("kind"):
+            raise AgentProtocolError(
+                "invalid_event",
+                f"type {definition['type']} cannot change kind on redefinition",
+            )
         self._types[definition["type"]] = definition
 
     def _import(self, declaration: dict[str, Any], packs: dict[str, dict[str, Any]]) -> None:
@@ -438,6 +543,57 @@ def validate_message_create_payload(payload: dict[str, Any]) -> None:
         raise AgentProtocolError("invalid_event", "content_type must not be empty")
 
 
+def validate_room_join_payload(payload: dict[str, Any]) -> None:
+    if payload.get("role") not in ROLES:
+        raise AgentProtocolError("invalid_event", f"invalid room role: {payload.get('role')}")
+    request_id = payload.get("request_id")
+    if request_id is not None and not str(request_id).strip():
+        raise AgentProtocolError("invalid_event", "request_id must not be empty")
+    if request_id is not None and "perspective" in payload:
+        raise AgentProtocolError(
+            "invalid_event",
+            "room.join payload cannot include both request_id and perspective",
+        )
+
+
+_ROOM_UPDATE_FIELDS = frozenset(
+    {"topic", "agenda", "guidance", "tags", "language", "policy", "start_time", "end_time"}
+)
+
+
+def validate_room_update_payload(payload: dict[str, Any]) -> None:
+    """Shape checks for a `room.update` payload. State-dependent rules — room
+    status, effective time ordering against the current contract — remain
+    host-side."""
+    if not payload:
+        raise AgentProtocolError("invalid_event", "room.update payload must not be empty")
+    for field in payload:
+        if field not in _ROOM_UPDATE_FIELDS:
+            raise AgentProtocolError(
+                "invalid_event", f"room.update payload field {field} is not updatable"
+            )
+    topic = payload.get("topic")
+    if topic is not None and not str(topic).strip():
+        raise AgentProtocolError("invalid_event", "room topic must not be empty")
+    start_time = payload.get("start_time")
+    end_time = payload.get("end_time")
+    if start_time is not None and end_time is not None and start_time >= end_time:
+        raise AgentProtocolError("invalid_event", "start_time must be before end_time")
+    policy = payload.get("policy") or {}
+    max_speakers = policy.get("max_speakers")
+    if max_speakers is not None and (not isinstance(max_speakers, int) or max_speakers < 1):
+        raise AgentProtocolError("invalid_event", "max_speakers must be a positive integer")
+
+
+def validate_room_member_remove_payload(payload: dict[str, Any]) -> None:
+    """Shape checks for a `room.member.remove` payload. Creator, self, and
+    membership checks remain host-side."""
+    validate_agent_id(payload.get("member"))
+    ban = payload.get("ban")
+    if ban is not None and not isinstance(ban, bool):
+        raise AgentProtocolError("invalid_event", "ban must be a boolean")
+
+
 def server_record_hash_payload(
     room_id: str,
     seq: int,
@@ -537,10 +693,18 @@ def can_submit_event(
     if event_type == ROOM_CREATE:
         return True
     if event_type == ROOM_JOIN:
-        return bool(context.get("join_request_approved"))
+        return bool(context.get("public_join_allowed") or context.get("join_request_approved"))
     if event_type == ROOM_LEAVE:
         return is_creator or role is not None
-    if event_type in {ROOM_JOIN_REVIEW, ROOM_MEMBER_ROLE_UPDATE, ROOM_CLOSE, ROOM_CANCEL, TYPE_DEFINE}:
+    if event_type in {
+        ROOM_UPDATE,
+        ROOM_JOIN_REVIEW,
+        ROOM_MEMBER_ROLE_UPDATE,
+        ROOM_MEMBER_REMOVE,
+        ROOM_CLOSE,
+        ROOM_CANCEL,
+        TYPE_DEFINE,
+    }:
         return is_creator or role == "moderator"
     if event_type == MESSAGE_CREATE:
         return is_creator or role in ("moderator", "speaker")
@@ -562,7 +726,9 @@ def can_write_in_state(event_type: str, state: RoomState) -> bool:
             ROOM_JOIN,
             ROOM_JOIN_REVIEW,
             ROOM_MEMBER_ROLE_UPDATE,
+            ROOM_MEMBER_REMOVE,
             ROOM_LEAVE,
+            ROOM_UPDATE,
             TYPE_DEFINE,
             ROOM_CANCEL,
         }

agent_protocols-0.5.0/src/agent_protocols/errors.py

@@ -0,0 +1,6 @@
+class AgentProtocolError(ValueError):
+    def __init__(self, code: str, message: str, data: dict | None = None):
+        super().__init__(message)
+        self.code = code
+        # Structured error details, e.g. {"max_nonce": ...} on nonce_not_greater.
+        self.data = data