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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-protocols
-Version: 0.2.2
+Version: 0.3.1
 Summary: Python SDK for Agent Identity, Agent Profile, and Agent Discourse protocols
 Author: LDCLabs
 License: MIT
@@ -8,6 +8,7 @@ Keywords: agent,protocol,ed25519,sdk
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: cryptography>=42
+Requires-Dist: jsonschema<5,>=4.17
 Requires-Dist: rfc8785<0.2,>=0.1.4
 Provides-Extra: http
 Requires-Dist: requests<3,>=2.31; extra == "http"
@@ -20,7 +21,7 @@ Python SDK for the draft Agent Identity, Agent Profile, and Agent Discourse prot
 
 - `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, join request helpers, room-path checks, permission and state helpers.
+- `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]`.
 
 ## Example
@@ -39,3 +40,5 @@ event = profile_update_event(
 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_protocols-0.2.2 → agent_protocols-0.3.1}/README.md

@@ -6,7 +6,7 @@ Python SDK for the draft Agent Identity, Agent Profile, and Agent Discourse prot
 
 - `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, join request helpers, room-path checks, permission and state helpers.
+- `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]`.
 
 ## Example
@@ -25,3 +25,5 @@ event = profile_update_event(
 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_protocols-0.2.2 → agent_protocols-0.3.1}/pyproject.toml

@@ -1,13 +1,17 @@
 [project]
 name = "agent-protocols"
-version = "0.2.2"
+version = "0.3.1"
 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 = ["cryptography>=42", "rfc8785>=0.1.4,<0.2"]
+dependencies = [
+  "cryptography>=42",
+  "jsonschema>=4.17,<5",
+  "rfc8785>=0.1.4,<0.2",
+]
 
 [project.optional-dependencies]
 http = ["requests>=2.31,<3"]

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

@@ -11,14 +11,17 @@ from .identity import (
     create_event,
     create_request_jwt_claims,
     event_hash,
+    event_hash_bytes,
     public_key_bytes,
     sign_event,
+    sign_event_hash,
     unix_ms,
     unix_secs,
     validate_agent_id,
     validate_nonce,
     verify_envelope,
     verify_event_hash,
+    verify_event_hash_signature,
     verify_live_envelope,
     verify_request_jwt,
     verify_signature,
@@ -42,10 +45,12 @@ __all__ = [
     "create_event",
     "create_request_jwt_claims",
     "event_hash",
+    "event_hash_bytes",
     "materialize_profile",
     "profile_update_event",
     "public_key_bytes",
     "sign_event",
+    "sign_event_hash",
     "unix_ms",
     "unix_secs",
     "validate_agent_id",
@@ -53,6 +58,7 @@ __all__ = [
     "validate_profile_update",
     "verify_envelope",
     "verify_event_hash",
+    "verify_event_hash_signature",
     "verify_live_envelope",
     "verify_request_jwt",
     "verify_signature",

agent_protocols-0.3.1/src/agent_protocols/discourse.py

@@ -0,0 +1,508 @@
+"""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
+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.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import re
+from typing import Any, Iterable, Literal, TypedDict
+
+import rfc8785
+from jsonschema.validators import Draft202012Validator
+
+from .errors import AgentProtocolError
+from .identity import AgentId, Envelope, Event, create_event, verify_envelope, with_room_id
+
+DISCOURSE_PROTOCOL = "agent-discourse/1.0"
+
+# The nine built-in event types. All other types are room-defined.
+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_CLOSE = "room.close"
+ROOM_CANCEL = "room.cancel"
+TYPE_DEFINE = "type.define"
+MESSAGE_CREATE = "message.create"
+
+BUILTIN_EVENT_TYPES = {
+    ROOM_CREATE,
+    ROOM_JOIN,
+    ROOM_JOIN_REVIEW,
+    ROOM_LEAVE,
+    ROOM_MEMBER_ROLE_UPDATE,
+    ROOM_CLOSE,
+    ROOM_CANCEL,
+    TYPE_DEFINE,
+    MESSAGE_CREATE,
+}
+
+# Custom event types must not use these prefixes.
+RESERVED_TYPE_PREFIXES = ("room.", "type.")
+
+# Registered type packs defined by the specification in `1.0.packs.json`.
+PACK_REACTIONS = "adp:reactions/1.0"
+PACK_DELIBERATION = "adp:deliberation/1.0"
+PACK_CURATION = "adp:curation/1.0"
+PACK_MODERATION = "adp:moderation/1.0"
+PACK_REALTIME = "adp:realtime/1.0"
+
+REGISTERED_PACK_IDS = (
+    PACK_REACTIONS,
+    PACK_DELIBERATION,
+    PACK_CURATION,
+    PACK_MODERATION,
+    PACK_REALTIME,
+)
+
+RoomState = Literal["scheduled", "active", "ended", "cancelled"]
+Role = Literal["moderator", "speaker", "observer"]
+TypeKind = Literal["message", "signal", "control"]
+TypeStatus = Literal["active", "deprecated", "disabled"]
+JoinRequestStatus = Literal["pending", "approved", "rejected", "expired"]
+
+ROLES = ("moderator", "speaker", "observer")
+TYPE_KINDS = ("message", "signal", "control")
+TYPE_STATUSES = ("active", "deprecated", "disabled")
+
+_TYPE_SEGMENT = re.compile(r"^[a-z0-9][a-z0-9_-]*$")
+_REGISTERED_PACK_ID = re.compile(r"^adp:[a-z0-9-]+/[0-9]+\.[0-9]+$")
+
+
+class PermissionContext(TypedDict, total=False):
+    """Permission inputs for one actor in one room."""
+
+    role: Role
+    is_creator: bool
+    join_request_approved: bool
+
+
+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]
+) -> Event:
+    return with_room_id(
+        create_event(DISCOURSE_PROTOCOL, TYPE_DEFINE, actor, created_at, nonce, declaration),
+        room_id,
+    )
+
+
+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 is_builtin_event_type(event_type: str) -> bool:
+    return event_type in BUILTIN_EVENT_TYPES
+
+
+def event_requires_room_id(event_type: str) -> bool:
+    return event_type != ROOM_CREATE
+
+
+def validate_discourse_envelope(envelope: Envelope) -> None:
+    verify_envelope(envelope)
+    event = envelope["event"]
+    protocol = event["protocol"]
+    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")
+
+
+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")
+        return
+    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_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."""
+    segments = name.split(".")
+    if len(segments) < 2 or not all(_TYPE_SEGMENT.match(segment) for segment in segments):
+        raise AgentProtocolError("invalid_event", f"invalid event type name: {name}")
+    if is_builtin_event_type(name):
+        raise AgentProtocolError("invalid_event", f"{name} is a built-in event type")
+    if name.startswith(RESERVED_TYPE_PREFIXES):
+        raise AgentProtocolError("invalid_event", f"{name} uses a reserved type prefix")
+
+
+def is_pack_import(declaration: dict[str, Any]) -> bool:
+    return "use" in declaration or "pack" in declaration or "digest" in declaration
+
+
+def validate_type_def(definition: dict[str, Any]) -> None:
+    validate_custom_event_type_name(str(definition.get("type", "")))
+    if definition.get("kind") not in TYPE_KINDS:
+        raise AgentProtocolError("invalid_event", f"invalid type kind: {definition.get('kind')}")
+    if not str(definition.get("title", "")).strip():
+        raise AgentProtocolError("invalid_event", "type definition title must not be empty")
+    schema = definition.get("schema")
+    if not isinstance(schema, dict):
+        raise AgentProtocolError("invalid_event", "type definition schema must be a JSON Schema object")
+    _compile_schema(schema)
+    roles = definition.get("roles")
+    if roles is not None:
+        if not isinstance(roles, list) or not roles or any(role not in ROLES for role in roles):
+            raise AgentProtocolError("invalid_event", "type definition roles must be a non-empty role list")
+    status = definition.get("status")
+    if status is not None and status not in TYPE_STATUSES:
+        raise AgentProtocolError("invalid_event", f"invalid type status: {status}")
+    for hint in ("rate_hint", "max_payload_hint"):
+        value = definition.get(hint)
+        if value is not None and (not isinstance(value, int) or value < 1):
+            raise AgentProtocolError("invalid_event", "type definition hints must be positive integers")
+
+
+def validate_pack_import(declaration: dict[str, Any]) -> None:
+    has_use = "use" in declaration
+    has_external = "pack" in declaration and "digest" in declaration
+    if has_use:
+        if "pack" in declaration or "digest" in declaration:
+            raise AgentProtocolError("invalid_event", "pack import requires either use, or pack with digest")
+        if not _REGISTERED_PACK_ID.match(str(declaration["use"])):
+            raise AgentProtocolError("invalid_event", f"invalid registered pack id: {declaration['use']}")
+    elif has_external:
+        if not str(declaration["digest"]).strip():
+            raise AgentProtocolError("invalid_event", "external pack digest must not be empty")
+    else:
+        raise AgentProtocolError("invalid_event", "pack import requires either use, or pack with digest")
+    types = declaration.get("types")
+    if types is not None and (not isinstance(types, list) or not types):
+        raise AgentProtocolError("invalid_event", "pack import types subset must not be empty")
+
+
+def validate_type_declaration(declaration: dict[str, Any]) -> None:
+    if not isinstance(declaration, dict):
+        raise AgentProtocolError("invalid_event", "type declaration must be an object")
+    if is_pack_import(declaration):
+        validate_pack_import(declaration)
+    elif "type" in declaration:
+        validate_type_def(declaration)
+    else:
+        raise AgentProtocolError(
+            "invalid_event", "type declaration must be an inline definition or a pack import"
+        )
+
+
+def pack_map(document: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    """Indexes the packs of a document by pack id for registry materialization."""
+    return {pack["id"]: pack for pack in document.get("packs", [])}
+
+
+class TypeRegistry:
+    """The effective set of type definitions active in a room."""
+
+    def __init__(self) -> None:
+        self._types: dict[str, dict[str, Any]] = {}
+
+    @classmethod
+    def from_declarations(
+        cls,
+        declarations: Iterable[dict[str, Any]],
+        packs: dict[str, dict[str, Any]] | None = None,
+    ) -> "TypeRegistry":
+        """Materializes a registry from declarations, resolving pack imports
+        from `packs`, keyed by registered pack id or external pack URI."""
+        registry = cls()
+        for declaration in declarations:
+            registry.apply(declaration, packs)
+        return registry
+
+    def apply(self, declaration: dict[str, Any], packs: dict[str, dict[str, Any]] | None = None) -> None:
+        """Applies one declaration: an inline definition or a pack import.
+        Redefining an existing type replaces it; the latest definition wins."""
+        if is_pack_import(declaration):
+            self._import(declaration, packs or {})
+        elif "type" in declaration:
+            self.define(declaration)
+        else:
+            raise AgentProtocolError(
+                "invalid_event", "type declaration must be an inline definition or a pack import"
+            )
+
+    def define(self, definition: dict[str, Any]) -> None:
+        validate_type_def(definition)
+        self._types[definition["type"]] = definition
+
+    def _import(self, declaration: dict[str, Any], packs: dict[str, dict[str, Any]]) -> None:
+        validate_pack_import(declaration)
+        reference = declaration.get("use") or declaration.get("pack")
+        pack = packs.get(reference)
+        if pack is None:
+            raise AgentProtocolError("pack_unavailable", f"pack not available: {reference}")
+        available = {definition["type"] for definition in pack.get("types", [])}
+        subset = declaration.get("types")
+        if subset is not None:
+            for name in subset:
+                if name not in available:
+                    raise AgentProtocolError("pack_unavailable", f"type {name} is not in pack {reference}")
+        overrides = declaration.get("overrides") or {}
+        for name in overrides:
+            imported = name in subset if subset is not None else name in available
+            if not imported:
+                raise AgentProtocolError(
+                    "invalid_event", f"override target {name} is not imported from pack {reference}"
+                )
+        for definition in pack.get("types", []):
+            if subset is not None and definition["type"] not in subset:
+                continue
+            merged = dict(definition)
+            merged.update(overrides.get(definition["type"], {}))
+            self.define(merged)
+
+    def get(self, event_type: str) -> dict[str, Any] | None:
+        return self._types.get(event_type)
+
+    def __contains__(self, event_type: str) -> bool:
+        return event_type in self._types
+
+    def __len__(self) -> int:
+        return len(self._types)
+
+    def definitions(self) -> list[dict[str, Any]]:
+        return list(self._types.values())
+
+    def validate_payload(self, event_type: str, payload: Any) -> None:
+        """Validates a custom event payload against the type's schema and status."""
+        definition = self._types.get(event_type)
+        if definition is None:
+            raise AgentProtocolError("type_not_defined", f"event type is not defined in the room: {event_type}")
+        if definition.get("status", "active") == "disabled":
+            raise AgentProtocolError("type_disabled", f"event type is disabled in this room: {event_type}")
+        validator = _compile_schema(definition["schema"])
+        errors = sorted(validator.iter_errors(payload), key=lambda error: list(error.absolute_path))
+        if errors:
+            detail = "; ".join(error.message for error in errors[:3])
+            raise AgentProtocolError("payload_schema_violation", f"{event_type}: {detail}")
+
+
+def validate_event_against_registry(event_type: str, payload: Any, registry: TypeRegistry) -> None:
+    """Validates an event payload: built-in payloads are accepted as-is (use
+    the typed validators for them); custom payloads must satisfy the registry."""
+    if is_builtin_event_type(event_type):
+        return
+    registry.validate_payload(event_type, payload)
+
+
+def _compile_schema(schema: dict[str, Any]) -> Draft202012Validator:
+    try:
+        Draft202012Validator.check_schema(schema)
+    except Exception as error:  # jsonschema.SchemaError
+        raise AgentProtocolError("invalid_event", f"invalid type schema: {error}") from error
+    return Draft202012Validator(schema)
+
+
+def verify_pack_digest(data: bytes, digest: str) -> None:
+    """Verifies a `<algorithm>:<base64url-digest>` content digest over raw
+    bytes. Supports `sha256` and `sha3-256`."""
+    algorithm, separator, expected = digest.partition(":")
+    if not separator:
+        raise AgentProtocolError("pack_unavailable", f"invalid digest format: {digest}")
+    if algorithm == "sha256":
+        raw = hashlib.sha256(data).digest()
+    elif algorithm == "sha3-256":
+        raw = hashlib.sha3_256(data).digest()
+    else:
+        raise AgentProtocolError("pack_unavailable", f"unsupported digest algorithm: {algorithm}")
+    actual = base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
+    if actual != expected:
+        raise AgentProtocolError("pack_unavailable", "pack digest mismatch")
+
+
+def validate_room_create_payload(payload: dict[str, Any]) -> None:
+    if not str(payload.get("topic", "")).strip():
+        raise AgentProtocolError("invalid_event", "room topic must not be empty")
+    if payload.get("start_time", 0) >= payload.get("end_time", 0):
+        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")
+    for declaration in payload.get("types", []):
+        validate_type_declaration(declaration)
+
+
+def validate_message_create_payload(payload: dict[str, Any]) -> None:
+    if not str(payload.get("content_type", "")).strip():
+        raise AgentProtocolError("invalid_event", "content_type must not be empty")
+
+
+def server_record_hash_payload(
+    room_id: str,
+    seq: int,
+    pre_hash: str | None,
+    envelope_hash: str,
+    received_at: int,
+) -> dict[str, Any]:
+    return {
+        "room_id": room_id,
+        "seq": seq,
+        "pre_hash": pre_hash,
+        "envelope_hash": envelope_hash,
+        "received_at": received_at,
+    }
+
+
+def server_record_hash(
+    room_id: str,
+    seq: int,
+    pre_hash: str | None,
+    envelope_hash: str,
+    received_at: int,
+) -> str:
+    return _hash_canonical_json(server_record_hash_payload(room_id, seq, pre_hash, envelope_hash, received_at))
+
+
+def build_server_record(
+    room_id: str,
+    seq: int,
+    pre_hash: str | None,
+    received_at: int,
+    envelope: Envelope,
+) -> dict[str, Any]:
+    return {
+        "room_id": room_id,
+        "seq": seq,
+        "pre_hash": pre_hash,
+        "hash": server_record_hash(room_id, seq, pre_hash, envelope["hash"], received_at),
+        "received_at": received_at,
+        "envelope": envelope,
+    }
+
+
+def verify_server_record(record: dict[str, Any]) -> None:
+    expected = server_record_hash(
+        record["room_id"],
+        record["seq"],
+        record.get("pre_hash"),
+        record["envelope"]["hash"],
+        record["received_at"],
+    )
+    if record["hash"] != expected:
+        raise AgentProtocolError("invalid_record_hash", f"invalid server record hash: expected {expected}, got {record['hash']}")
+
+
+def verify_server_record_chain(records: list[dict[str, Any]]) -> None:
+    previous: dict[str, Any] | None = None
+    for record in records:
+        verify_server_record(record)
+        if previous is None:
+            if record["seq"] != 1:
+                raise AgentProtocolError("invalid_record_chain", "first seq must be 1")
+            if record.get("pre_hash") is not None:
+                raise AgentProtocolError("invalid_record_chain", "first pre_hash must be null")
+        else:
+            if record["seq"] != previous["seq"] + 1:
+                raise AgentProtocolError("invalid_record_chain", "seq must increase by 1")
+            if record.get("pre_hash") != previous["hash"]:
+                raise AgentProtocolError("invalid_record_chain", "pre_hash mismatch")
+        previous = record
+
+
+def archive_events_digest(records: list[dict[str, Any]]) -> str:
+    return _hash_canonical_json(records)
+
+
+def default_kind_roles(kind: str) -> tuple[str, ...]:
+    """Default sender roles for each kind. The creator passes every role check."""
+    if kind == "message":
+        return ("moderator", "speaker")
+    if kind == "signal":
+        return ("moderator", "speaker", "observer")
+    if kind == "control":
+        return ("moderator",)
+    raise AgentProtocolError("invalid_event", f"invalid type kind: {kind}")
+
+
+def can_submit_event(
+    event_type: str,
+    context: PermissionContext,
+    registry: TypeRegistry | None = None,
+) -> bool:
+    """Role check for one event type, using kind defaults and per-type role
+    overrides from the room's type registry. State checks are separate."""
+    is_creator = bool(context.get("is_creator"))
+    role = context.get("role")
+    if event_type == ROOM_CREATE:
+        return True
+    if event_type == ROOM_JOIN:
+        return bool(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}:
+        return is_creator or role == "moderator"
+    if event_type == MESSAGE_CREATE:
+        return is_creator or role in ("moderator", "speaker")
+
+    definition = registry.get(event_type) if registry is not None else None
+    if definition is None or definition.get("status", "active") == "disabled":
+        return False
+    if is_creator:
+        return True
+    if role is None:
+        return False
+    roles = definition.get("roles") or default_kind_roles(definition["kind"])
+    return role in roles
+
+
+def can_write_in_state(event_type: str, state: RoomState) -> bool:
+    if state == "scheduled":
+        return event_type in {
+            ROOM_JOIN,
+            ROOM_JOIN_REVIEW,
+            ROOM_MEMBER_ROLE_UPDATE,
+            ROOM_LEAVE,
+            TYPE_DEFINE,
+            ROOM_CANCEL,
+        }
+    if state == "active":
+        return event_type not in {ROOM_CREATE, ROOM_CANCEL}
+    return False
+
+
+def can_accept_room_write(
+    event_type: str,
+    state: RoomState,
+    context: PermissionContext,
+    registry: TypeRegistry | None = None,
+) -> bool:
+    return can_submit_event(event_type, context, registry) and can_write_in_state(event_type, state)
+
+
+def validate_room_write(
+    event_type: str,
+    state: RoomState,
+    context: PermissionContext,
+    registry: TypeRegistry | None = None,
+) -> None:
+    if not can_accept_room_write(event_type, state, context, registry):
+        raise AgentProtocolError("permission_denied", "actor lacks permission or state is not writable")
+
+
+def _hash_canonical_json(value: Any) -> str:
+    canonical = rfc8785.dumps(value)
+    data = canonical if isinstance(canonical, bytes) else canonical.encode()
+    digest = hashlib.sha3_256(data).digest()
+    return base64.urlsafe_b64encode(digest).rstrip(b"=").decode()

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

@@ -89,7 +89,8 @@ class DiscourseClient:
                     "cursor": cursor,
                 }.items()
                 if value is not None
-            }
+            },
+            quote_via=quote,
         )
         suffix = f"?{query}" if query else ""
         return self._get(f"/v1/rooms/{room_id}/events{suffix}", jwt=jwt)