buzzkit 0.1.1__tar.gz → 0.1.3__tar.gz

buzzkit-0.1.3/.cargo/config.toml

@@ -0,0 +1,12 @@
+# The `opus` crate (audiopus_sys) builds a vendored libopus whose CMakeLists
+# declares a pre-3.5 minimum; CMake 4 removed compatibility with those and
+# aborts configure. This env var is CMake's documented escape hatch and is a
+# no-op on older CMake. Applies to local builds, CI, and source installs alike.
+#
+# Deliberately NOT set here: CMAKE_TOOLCHAIN_FILE. cmake-rs skips its own
+# cross-compilation config whenever a toolchain file is present, which breaks
+# cross builds (aarch64 wheels compiled host-arch objects). The lib64 pin in
+# build-support/vendored-libopus.cmake is applied only where needed, by the
+# release workflow (native RPM-family manylinux containers).
+[env]
+CMAKE_POLICY_VERSION_MINIMUM = "3.5"

{buzzkit-0.1.1 → buzzkit-0.1.3}/.github/workflows/CI.yml

@@ -29,6 +29,9 @@ jobs:
       - name: Clippy
         run: cargo clippy --all-targets -- -D warnings
 
+      - name: Rust tests
+        run: cargo test
+
       - name: Install (editable) with dev deps
         run: pip install -e '.[dev]'
 

{buzzkit-0.1.1 → buzzkit-0.1.3}/.github/workflows/release.yml

@@ -21,7 +21,9 @@ jobs:
         platform:
           - { os: ubuntu-latest, target: x86_64 }
           - { os: ubuntu-latest, target: aarch64 }
-          - { os: macos-13, target: x86_64 }
+          # Intel wheel is cross-compiled from the ARM runner: GitHub retired
+          # the macos-13 (Intel) runners — the label queues forever.
+          - { os: macos-14, target: x86_64 }
           - { os: macos-14, target: aarch64 }
           - { os: windows-latest, target: x64 }
     steps:
@@ -34,7 +36,23 @@ jobs:
         with:
           target: ${{ matrix.platform.target }}
           args: --release --out dist
-          manylinux: auto
+          # 2_28 (not auto): its cross toolchains are recent enough to compile
+          # the vendored libopus NEON intrinsics (manylinux2014's aarch64 gcc
+          # chokes on them).
+          manylinux: 2_28
+          # Static libopus so the wheel is self-contained; cmake for the
+          # vendored build when the container doesn't ship it. On RPM-family
+          # containers (native x86_64 manylinux) GNUInstallDirs installs to
+          # lib64 where audiopus_sys never looks — pin libdir via a toolchain
+          # file there. Never set it for the cross containers (Ubuntu-family,
+          # libdir is already "lib"): cmake-rs skips its own cross config when
+          # a toolchain file is present, producing host-arch objects.
+          before-script-linux: |
+            export LIBOPUS_STATIC=1
+            command -v cmake || yum install -y cmake || dnf install -y cmake || (apt-get update && apt-get install -y cmake)
+            if [ -f /etc/redhat-release ] || [ -f /etc/almalinux-release ]; then
+              export CMAKE_TOOLCHAIN_FILE="$(pwd)/build-support/vendored-libopus.cmake"
+            fi
       - uses: actions/upload-artifact@v4
         with:
           name: wheels-${{ matrix.platform.os }}-${{ matrix.platform.target }}

{buzzkit-0.1.1 → buzzkit-0.1.3}/.gitignore

@@ -6,3 +6,6 @@ __pycache__/
 *.egg-info/
 .python-version
 agent.secret
+/dist
+owner.secret
+/tasks

{buzzkit-0.1.1 → buzzkit-0.1.3}/Cargo.lock

@@ -27,6 +27,17 @@ version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
 
+[[package]]
+name = "audiopus_sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62314a1546a2064e033665d658e88c620a62904be945f8147e6b16c3db9f8651"
+dependencies = [
+ "cmake",
+ "log",
+ "pkg-config",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.5.1"
@@ -168,13 +179,14 @@ dependencies = [
 
 [[package]]
 name = "buzzkit"
-version = "0.1.1"
+version = "0.1.3"
 dependencies = [
  "base64",
  "buzz-core",
  "buzz-sdk",
  "hex",
  "nostr",
+ "opus",
  "pyo3",
  "sha2 0.10.9",
  "uuid",
@@ -265,6 +277,15 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "cmake"
+version = "0.1.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "cmov"
 version = "0.5.4"
@@ -748,6 +769,15 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
+[[package]]
+name = "opus"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d3809943dff6fbad5f0484449ea26bdb9cb7d8efdf26ed50d3c7f227f69eb5c"
+dependencies = [
+ "audiopus_sys",
+]
+
 [[package]]
 name = "password-hash"
 version = "0.5.0"
@@ -781,6 +811,12 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+
 [[package]]
 name = "poly1305"
 version = "0.8.0"

{buzzkit-0.1.1 → buzzkit-0.1.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "buzzkit"
-version = "0.1.1"
+version = "0.1.3"
 edition = "2021"
 publish = false
 description = "PyO3 bindings over Block's Buzz zero-I/O crates (buzz-core / buzz-sdk)"
@@ -13,7 +13,9 @@ name = "_native"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.24", features = ["extension-module", "abi3-py312"] }
+# extension-module is enabled by maturin via pyproject.toml, not here, so
+# plain `cargo build` / `cargo test` can link against libpython.
+pyo3 = { version = "0.24", features = ["abi3-py312"] }
 # Must match the `nostr` version buzz-core/buzz-sdk resolve to so the
 # Event/Keys/EventBuilder types unify across crate boundaries.
 nostr = { version = "0.44", features = ["nip44", "nip98"] }
@@ -24,3 +26,4 @@ uuid = { version = "1", features = ["v4"] }
 sha2 = "0.10"
 hex = "0.4"
 base64 = "0.22"
+opus = "0.3"

{buzzkit-0.1.1 → buzzkit-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: buzzkit
-Version: 0.1.1
+Version: 0.1.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -86,6 +86,32 @@ async def main():
 asyncio.run(main())
 ```
 
+### Huddle audio (voice)
+
+Buzz huddles are ephemeral voice channels; audio is Opus (48 kHz mono, 20 ms
+frames) over a dedicated WebSocket. `HuddleClient` handles the handshake,
+Opus encode/decode (in Rust), and real-time outbound pacing — you deal in raw
+PCM (s16le mono 48 kHz):
+
+```python
+from buzzkit import BuzzClient, HuddleAudio, HuddleClient
+
+# Huddles announce themselves as kind 48100 on their parent channel:
+async with BuzzClient(relay_url, nsec) as bz:
+    async for ev in bz.subscribe_channel(parent_id, kinds=[buzzkit.KIND_HUDDLE_STARTED]):
+        huddle_id = json.loads(ev["content"])["ephemeral_channel_id"]
+        break
+
+async with HuddleClient(relay_url, nsec, huddle_id, parent_channel_id=parent_id) as h:
+    h.send_pcm(pcm_s16le_48k)              # queued, paced at 50 frames/s
+    async for ev in h.events():
+        if isinstance(ev, HuddleAudio):    # decoded remote audio
+            print(ev.pubkey, len(ev.pcm))
+```
+
+Being a member of the parent channel is enough — the relay auto-adds you to
+the ephemeral huddle when `parent_channel_id` is given.
+
 ## Joining a community (relay onboarding)
 
 Hosted Buzz communities are **closed relays**: an identity must be a relay member
@@ -114,6 +140,8 @@ claiming. After joining, `set_profile(...)` gives the agent a display name.
 | `verify_event(json)` | check id + Schnorr signature |
 | `BuzzClient.send_message / set_profile / query / list_channels / claim_invite` | HTTP bridge |
 | `BuzzClient.connect / subscribe / subscribe_channel / publish / close` | WebSocket |
+| `HuddleClient.connect / send_pcm / events / clear_queue / leave` | huddle voice (Opus) |
+| `HuddleEncoder` / `HuddleDecoder` | raw huddle wire frames ↔ PCM |
 
 ## Build from source
 

{buzzkit-0.1.1 → buzzkit-0.1.3}/README.md

@@ -53,6 +53,32 @@ async def main():
 asyncio.run(main())
 ```
 
+### Huddle audio (voice)
+
+Buzz huddles are ephemeral voice channels; audio is Opus (48 kHz mono, 20 ms
+frames) over a dedicated WebSocket. `HuddleClient` handles the handshake,
+Opus encode/decode (in Rust), and real-time outbound pacing — you deal in raw
+PCM (s16le mono 48 kHz):
+
+```python
+from buzzkit import BuzzClient, HuddleAudio, HuddleClient
+
+# Huddles announce themselves as kind 48100 on their parent channel:
+async with BuzzClient(relay_url, nsec) as bz:
+    async for ev in bz.subscribe_channel(parent_id, kinds=[buzzkit.KIND_HUDDLE_STARTED]):
+        huddle_id = json.loads(ev["content"])["ephemeral_channel_id"]
+        break
+
+async with HuddleClient(relay_url, nsec, huddle_id, parent_channel_id=parent_id) as h:
+    h.send_pcm(pcm_s16le_48k)              # queued, paced at 50 frames/s
+    async for ev in h.events():
+        if isinstance(ev, HuddleAudio):    # decoded remote audio
+            print(ev.pubkey, len(ev.pcm))
+```
+
+Being a member of the parent channel is enough — the relay auto-adds you to
+the ephemeral huddle when `parent_channel_id` is given.
+
 ## Joining a community (relay onboarding)
 
 Hosted Buzz communities are **closed relays**: an identity must be a relay member
@@ -81,6 +107,8 @@ claiming. After joining, `set_profile(...)` gives the agent a display name.
 | `verify_event(json)` | check id + Schnorr signature |
 | `BuzzClient.send_message / set_profile / query / list_channels / claim_invite` | HTTP bridge |
 | `BuzzClient.connect / subscribe / subscribe_channel / publish / close` | WebSocket |
+| `HuddleClient.connect / send_pcm / events / clear_queue / leave` | huddle voice (Opus) |
+| `HuddleEncoder` / `HuddleDecoder` | raw huddle wire frames ↔ PCM |
 
 ## Build from source
 

buzzkit-0.1.3/build-support/vendored-libopus.cmake

@@ -0,0 +1,11 @@
+# Toolchain file for building the vendored libopus (audiopus_sys) via cmake-rs.
+#
+# audiopus_sys's build script adds only `<out>/lib` to the linker search path,
+# but GNUInstallDirs installs to `lib64` on RPM-family hosts (manylinux,
+# Fedora, RHEL) — the link then fails with `unable to find library -lopus`.
+# Pinning the classic layout keeps the library where the build script looks.
+#
+# Applied by the release workflow ONLY on native RPM-family containers.
+# Do not export CMAKE_TOOLCHAIN_FILE globally: cmake-rs skips its own
+# cross-compilation config when a toolchain file is present.
+set(CMAKE_INSTALL_LIBDIR "lib" CACHE PATH "installation libdir pinned for audiopus_sys" FORCE)

buzzkit-0.1.3/examples/huddle_echo.py

@@ -0,0 +1,58 @@
+"""Echo agent for Buzz huddles — repeats back everything it hears.
+
+Joins a huddle and echoes remote audio with a short delay. Useful for
+verifying the audio path end-to-end (desktop → relay → agent → relay →
+desktop) without any AI provider.
+
+    BUZZ_RELAY_URL=wss://... python examples/huddle_echo.py <parent_channel_id>
+
+Watches the parent channel for huddle announcements (kind 48100) and joins
+each one; pass a second argument to join a known huddle directly:
+
+    python examples/huddle_echo.py <parent_channel_id> <huddle_channel_id>
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+import time
+
+from _shared import agent_secret, relay_url
+from buzzkit import KIND_HUDDLE_STARTED, BuzzClient, HuddleAudio, HuddleClient
+
+
+async def echo_in_huddle(relay: str, secret: str, huddle_id: str, parent_id: str) -> None:
+    async with HuddleClient(relay, secret, huddle_id, parent_channel_id=parent_id) as huddle:
+        print(f"joined huddle {huddle_id} — echoing (peers: {len(huddle.peers) - 1})")
+        async for ev in huddle.events():
+            if isinstance(ev, HuddleAudio):
+                huddle.send_pcm(ev.pcm)
+            else:
+                print(f"  {type(ev).__name__}: {ev.pubkey[:12]}…")
+        print(f"huddle {huddle_id} ended")
+
+
+async def main() -> None:
+    if len(sys.argv) < 2:
+        raise SystemExit("usage: huddle_echo.py <parent_channel_id> [huddle_channel_id]")
+    parent_id = sys.argv[1]
+    relay, secret = relay_url(), agent_secret()
+
+    if len(sys.argv) > 2:
+        await echo_in_huddle(relay, secret, sys.argv[2], parent_id)
+        return
+
+    print(f"watching {parent_id} for huddles…")
+    async with BuzzClient(relay, secret) as bz:
+        live = {"kinds": [KIND_HUDDLE_STARTED], "#h": [parent_id], "since": int(time.time())}
+        async for event in bz.subscribe([live]):
+            huddle_id = json.loads(event["content"]).get("ephemeral_channel_id")
+            if huddle_id:
+                await echo_in_huddle(relay, secret, huddle_id, parent_id)
+                print(f"watching {parent_id} for the next huddle…")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{buzzkit-0.1.1 → buzzkit-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "buzzkit"
-version = "0.1.1"
+version = "0.1.3"
 description = "Python bindings + async client for Block's Buzz (Nostr) protocol, backed by Rust buzz-core/buzz-sdk"
 readme = "README.md"
 requires-python = ">=3.12"

{buzzkit-0.1.1 → buzzkit-0.1.3}/python/buzzkit/__init__.py

@@ -10,39 +10,81 @@ This is an independent, unofficial project — not affiliated with Block, Inc.
 from __future__ import annotations
 
 from ._native import (
+    HUDDLE_FRAME_SAMPLES,
+    HUDDLE_PROTOCOL_VERSION,
+    HUDDLE_SAMPLE_RATE,
     KIND_ADD_MEMBER,
     KIND_AUTH,
+    KIND_CREATE_CHANNEL,
     KIND_HTTP_AUTH,
+    KIND_HUDDLE_ENDED,
+    KIND_HUDDLE_PARTICIPANT_JOINED,
+    KIND_HUDDLE_PARTICIPANT_LEFT,
+    KIND_HUDDLE_STARTED,
     KIND_PRESENCE_UPDATE,
     KIND_REACTION,
     KIND_STREAM_MESSAGE,
     KIND_STREAM_MESSAGE_V2,
+    HuddleDecoder,
+    HuddleEncoder,
     build_auth_event,
+    build_create_channel_event,
+    build_huddle_started_event,
     build_join_channel_event,
     build_message_event,
+    build_presence_event,
     build_profile_event,
+    compute_auth_tag,
     generate_keypair,
     pubkey_from_secret,
     sign_nip98,
     verify_event,
 )
 from .client import BuzzClient
+from .huddle import (
+    HuddleAudio,
+    HuddleClient,
+    HuddleError,
+    HuddleEvent,
+    HuddlePeerJoined,
+    HuddlePeerLeft,
+)
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"
 
 __all__ = [
+    "HUDDLE_FRAME_SAMPLES",
+    "HUDDLE_PROTOCOL_VERSION",
+    "HUDDLE_SAMPLE_RATE",
     "KIND_ADD_MEMBER",
     "KIND_AUTH",
+    "KIND_CREATE_CHANNEL",
     "KIND_HTTP_AUTH",
+    "KIND_HUDDLE_ENDED",
+    "KIND_HUDDLE_PARTICIPANT_JOINED",
+    "KIND_HUDDLE_PARTICIPANT_LEFT",
+    "KIND_HUDDLE_STARTED",
     "KIND_PRESENCE_UPDATE",
     "KIND_REACTION",
     "KIND_STREAM_MESSAGE",
     "KIND_STREAM_MESSAGE_V2",
     "BuzzClient",
+    "HuddleAudio",
+    "HuddleClient",
+    "HuddleDecoder",
+    "HuddleEncoder",
+    "HuddleError",
+    "HuddleEvent",
+    "HuddlePeerJoined",
+    "HuddlePeerLeft",
     "build_auth_event",
+    "build_create_channel_event",
+    "build_huddle_started_event",
     "build_join_channel_event",
     "build_message_event",
+    "build_presence_event",
     "build_profile_event",
+    "compute_auth_tag",
     "generate_keypair",
     "pubkey_from_secret",
     "sign_nip98",

buzzkit-0.1.3/python/buzzkit/_native.pyi

@@ -0,0 +1,102 @@
+"""Type stubs for the Rust extension module (buzzkit._native)."""
+
+def generate_keypair() -> tuple[str, str, str]:
+    """Return ``(nsec, npub, pubkey_hex)`` for a fresh keypair."""
+
+def pubkey_from_secret(secret: str) -> tuple[str, str]:
+    """Return ``(npub, pubkey_hex)`` for a secret (hex or ``nsec…``)."""
+
+def build_message_event(
+    secret: str, channel_id: str, content: str, mentions: list[str] | None = ...
+) -> str:
+    """Build + sign a channel message (kind 9); returns NIP-01 event JSON."""
+
+def build_profile_event(
+    secret: str,
+    display_name: str | None = ...,
+    name: str | None = ...,
+    about: str | None = ...,
+    picture: str | None = ...,
+    nip05: str | None = ...,
+    auth_tag: str | None = ...,
+) -> str:
+    """Build + sign a profile event (kind 0); returns NIP-01 event JSON.
+
+    ``auth_tag`` embeds a NIP-OA owner attestation so the Buzz desktop shows
+    the identity as "managed by <owner>".
+    """
+
+def build_join_channel_event(secret: str, channel_id: str) -> str:
+    """Build + sign a NIP-29 channel self-join event (kind 9000, role=bot)."""
+
+def build_create_channel_event(
+    secret: str,
+    channel_id: str,
+    name: str,
+    visibility: str | None = ...,
+    channel_type: str | None = ...,
+    about: str | None = ...,
+    ttl: int | None = ...,
+) -> str:
+    """Build + sign a NIP-29 create-channel event (kind 9007)."""
+
+def build_huddle_started_event(
+    secret: str, parent_channel_id: str, ephemeral_channel_id: str
+) -> str:
+    """Build + sign a huddle-started advisory (kind 48100) for the parent channel."""
+
+def build_presence_event(secret: str, status: str = ...) -> str:
+    """Build + sign a presence event (kind 20001); status online/away/offline."""
+
+def build_auth_event(
+    secret: str, challenge: str, relay_url: str, auth_tag: str | None = ...
+) -> str:
+    """Build + sign a NIP-42 AUTH event (kind 22242); returns event JSON."""
+
+def compute_auth_tag(owner_secret: str, agent_pubkey_hex: str, conditions: str = ...) -> str:
+    """Compute a NIP-OA owner-attestation tag JSON attesting an agent pubkey."""
+
+def sign_nip98(secret: str, method: str, url: str, body: bytes | None = ...) -> str:
+    """Return an ``Authorization: Nostr <base64>`` header value (NIP-98)."""
+
+def verify_event(event_json: str) -> bool:
+    """Verify an event's id + Schnorr signature."""
+
+class HuddleEncoder:
+    """Stateful huddle audio encoder: s16le mono 48 kHz PCM in, v2 wire frames out."""
+
+    def __init__(self, bitrate: int = 32000, dtx: bool = True) -> None: ...
+    def encode(self, pcm: bytes) -> list[bytes]:
+        """Feed PCM; returns complete 20 ms wire frames (partials are buffered)."""
+
+    def flush(self) -> bytes | None:
+        """Zero-pad and emit the buffered partial frame, if any."""
+
+    def discard(self) -> None:
+        """Drop buffered PCM without emitting it (barge-in)."""
+
+class HuddleDecoder:
+    """Stateful huddle audio decoder for relay frames ([peer_index][header][opus])."""
+
+    def __init__(self) -> None: ...
+    def decode(self, frame: bytes) -> tuple[int, int, int, int, bool, bytes]:
+        """Return ``(peer_index, seq, ts_48k, level_dbov, is_dtx, pcm_s16le_48k)``."""
+
+    def remove_peer(self, peer_index: int) -> None:
+        """Forget a peer's decoder state (indexes are recycled by the relay)."""
+
+KIND_REACTION: int
+KIND_STREAM_MESSAGE: int
+KIND_PRESENCE_UPDATE: int
+KIND_AUTH: int
+KIND_HTTP_AUTH: int
+KIND_STREAM_MESSAGE_V2: int
+KIND_ADD_MEMBER: int
+KIND_CREATE_CHANNEL: int
+KIND_HUDDLE_STARTED: int
+KIND_HUDDLE_PARTICIPANT_JOINED: int
+KIND_HUDDLE_PARTICIPANT_LEFT: int
+KIND_HUDDLE_ENDED: int
+HUDDLE_PROTOCOL_VERSION: int
+HUDDLE_SAMPLE_RATE: int
+HUDDLE_FRAME_SAMPLES: int

{buzzkit-0.1.1 → buzzkit-0.1.3}/python/buzzkit/client.py

@@ -20,6 +20,7 @@ import asyncio
 import contextlib
 import json
 import logging
+import uuid
 from collections.abc import AsyncIterator
 from typing import Any
 
@@ -61,7 +62,7 @@ class BuzzClient:
         self._http = _to_http(relay_url)
         self._ws_url = _to_ws(relay_url)
         self._secret = secret
-        self._auth_tag = auth_tag  # reserved for NIP-OA owner attestation
+        self._auth_tag = auth_tag  # NIP-OA owner attestation (AUTH + profile)
         self.npub, self.pubkey_hex = _native.pubkey_from_secret(secret)
         self._ws: Any = None
         self._reader: asyncio.Task | None = None
@@ -96,15 +97,26 @@ class BuzzClient:
         return await self.post_event(ev)
 
     async def set_profile(
-        self, display_name: str, *, about: str | None = None, picture: str | None = None
+        self,
+        display_name: str,
+        *,
+        about: str | None = None,
+        picture: str | None = None,
+        auth_tag: str | None = None,
     ) -> dict:
-        """Publish this identity's profile (kind 0) so it shows a name in Buzz."""
+        """Publish this identity's profile (kind 0) so it shows a name in Buzz.
+
+        ``auth_tag`` defaults to the client's NIP-OA owner attestation, so a
+        client constructed with one automatically shows as "managed by
+        <owner>" in the Buzz desktop (which reads the tag from kind 0).
+        """
         ev = _native.build_profile_event(
             self._secret,
             display_name=display_name,
             name=display_name,
             about=about,
             picture=picture,
+            auth_tag=auth_tag if auth_tag is not None else self._auth_tag,
         )
         return await self.post_event(ev)
 
@@ -119,6 +131,41 @@ class BuzzClient:
         ev = _native.build_join_channel_event(self._secret, channel_id)
         return await self.publish(ev)
 
+    async def start_huddle(
+        self, parent_channel_id: str, *, name: str | None = None, ttl: int = 3600
+    ) -> str:
+        """Start a huddle in a channel; returns the ephemeral huddle channel id.
+
+        Creates a private ephemeral channel (kind 9007, over the WebSocket —
+        :meth:`connect` first) and posts the kind-48100 announcement to the
+        parent channel. Join the audio with
+        ``HuddleClient(..., huddle_id, parent_channel_id=parent_channel_id)``.
+        """
+        huddle_id = str(uuid.uuid4())
+        create_ev = _native.build_create_channel_event(
+            self._secret,
+            huddle_id,
+            name or f"huddle-{huddle_id[:8]}",
+            visibility="private",
+            channel_type="stream",
+            ttl=ttl,
+        )
+        result = await self.publish(create_ev)
+        if not result["accepted"]:
+            raise RuntimeError(f"huddle channel rejected: {result['message']}")
+        started_ev = _native.build_huddle_started_event(
+            self._secret, parent_channel_id, huddle_id
+        )
+        result = await self.publish(started_ev)
+        if not result["accepted"]:
+            raise RuntimeError(f"huddle announcement rejected: {result['message']}")
+        return huddle_id
+
+    async def publish_presence(self, status: str = "online") -> dict:
+        """Announce presence (kind 20001, ephemeral) over the WebSocket."""
+        ev = _native.build_presence_event(self._secret, status)
+        return await self.publish(ev)
+
     async def query(self, filters: list[dict]) -> list[dict]:
         """Run a NIP-01 REQ over the HTTP bridge; returns a list of events."""
         url = f"{self._http}/query"
@@ -225,7 +272,9 @@ class BuzzClient:
                 q.put_nowait(("closed", "connection lost"))
 
     async def _on_auth_challenge(self, challenge: str) -> None:
-        auth_ev = json.loads(_native.build_auth_event(self._secret, challenge, self._ws_url))
+        auth_ev = json.loads(
+            _native.build_auth_event(self._secret, challenge, self._ws_url, self._auth_tag)
+        )
         self._auth_event_id = auth_ev["id"]
         await self._ws.send(json.dumps(["AUTH", auth_ev]))