vibedate 0.7.2 → 0.8.0

package/dist/index.d.ts

@@ -1,243 +1,9 @@
-import { VibeEvent, UsageSnapshot, UsageSource, Harness, HarnessUsageOptions } from '@pooriaarab/vibe-core';
+import { UsageSnapshot, UsageSource, Harness, HarnessUsageOptions } from '@pooriaarab/vibe-core';
 export { Harness, UsageSnapshot, UsageSource, createConsentLedger } from '@pooriaarab/vibe-core';
+import { P as PeerHello, a as PeerLink } from './room-BStsMaeT.js';
+export { D as DiscoveryOptions, b as DiscoverySession, L as LIVE_NOTICE, R as ROOM_TOPIC_PREFIX, c as RoomMember, d as RoomMessage, e as RoomOptions, f as RoomSession, S as StoredPeer, T as TOPIC_PREFIX, l as leagueTopic, g as loadPeers, p as parseHandshake, r as recordPeer, h as recordPeerMessage, i as roomTopic, s as serializeHandshake, j as startDiscovery, k as startRoom } from './room-BStsMaeT.js';
 import { KeyObject } from 'node:crypto';
 
-type Frame = {
-    t: 'hello';
-    handle: string;
-    league: string;
-    harness: string;
-    verified?: boolean;
-    pubkey?: string;
-    nonce?: string;
-    sig?: string;
-} | {
-    t: 'msg';
-    id: string;
-    text: string;
-    at: number;
-} | {
-    t: 'typing';
-} | {
-    t: 'bye';
-} | {
-    t: 'media-start';
-    id: string;
-    mime: string;
-    size: number;
-    name: string;
-} | {
-    t: 'media-chunk';
-    id: string;
-    seq: number;
-    b64: string;
-} | {
-    t: 'media-end';
-    id: string;
-} | {
-    t: 'rtc-offer';
-    sdp: string;
-} | {
-    t: 'rtc-answer';
-    sdp: string;
-} | {
-    t: 'rtc-ice';
-    candidate: string;
-};
-/** Convenience union of the three WebRTC signaling frame types (offer / answer
- *  / ice). Live A/V runs in the BROWSER via a native RTCPeerConnection; these
- *  frames only RELAY signaling over the P2P socket — no media bytes, no native
- *  WebRTC dependency in the CLI. */
-type RtcFrame = Extract<Frame, {
-    t: `rtc-${string}`;
-}>;
-
-interface ReceivedMedia {
-    readonly mime: string;
-    readonly name: string;
-    /** Temp file path holding the reassembled bytes. */
-    readonly path: string;
-    readonly size: number;
-}
-
-interface PeerLink {
-    /** The validated identity of the remote peer (from the hello handshake). */
-    readonly hello: PeerHello;
-    /** Send a line of text as a `msg` frame. */
-    send(text: string): void;
-    /** Read a file from disk and send it as a chunked media transfer. */
-    sendMedia(filePath: string, opts?: {
-        mime?: string;
-        name?: string;
-    }): Promise<{
-        id: string;
-        size: number;
-    }>;
-    /** Relay one `rtc-*` signaling frame (offer / answer / ice) to the peer.
-     *  Live media never touches this socket — only SDP / ICE strings do. */
-    sendSignal(frame: RtcFrame): void;
-    /** Register a callback for each incoming `msg` frame. */
-    onMessage(cb: (m: {
-        id: string;
-        text: string;
-        at: number;
-    }) => void): void;
-    /** Register a callback fired for each fully-reassembled incoming media file. */
-    onMedia(cb: (m: ReceivedMedia) => void): void;
-    /** Register a callback fired for each incoming `rtc-*` signaling frame. */
-    onSignal(cb: (f: RtcFrame) => void): void;
-    /** Register a callback fired once when the peer closes the link. */
-    onClose(cb: () => void): void;
-    /** Omegle "next": write a `bye` frame, then end the socket. */
-    close(): void;
-}
-
-/** Namespace prefix so vibedating topics never collide with other DHT traffic. */
-declare const TOPIC_PREFIX = "vibedate:";
-/**
- * Derive the 32-byte DHT topic for a league bucket. Deterministic: everyone in
- * the same league anywhere in the world hashes to the same topic, which is the
- * entire discovery mechanism. Pure.
- */
-declare function leagueTopic(leagueName: string): Buffer;
-/**
- * The fields that ever leave the machine over a peer connection: handle, league,
- * harness, and (optionally) the self-asserted usage-verification flag plus the
- * identity proof (pubkey/nonce/sig). NEVER raw usage — no token totals, no logs.
- * `verified`/`pubkey` are undefined for legacy peers that predate them; both
- * `undefined` and `false` display as unverified (~).
- */
-interface PeerHello {
-    readonly handle: string;
-    readonly league: string;
-    readonly harness: string;
-    /**
-     * Self-asserted: the sender's usage came from real local logs (see readUsage).
-     * Bound to the sender's key by the identity signature when `pubkey` is present.
-     */
-    readonly verified?: boolean;
-    /** Raw ed25519 public key (64 hex) — the persistent identity this hello signs. */
-    readonly pubkey?: string;
-    /** Random per-hello nonce (hex) covered by the signature. */
-    readonly nonce?: string;
-    /** ed25519 signature (128 hex) over `handle|league|harness|verified|nonce`. */
-    readonly sig?: string;
-    /**
-     * LOCAL-DERIVED, never on the wire: true when this hello's signature verified
-     * against its pubkey (see classifyHelloIdentity). Marked 🔑 in the UI.
-     */
-    readonly identityVerified?: boolean;
-}
-/** One-line privacy notice printed before joining the swarm. */
-declare const LIVE_NOTICE = "live discovery: sharing only your handle + league + harness + verified flag + identity pubkey (never raw usage) with same-league peers on the public DHT";
-/**
- * Serialize a hello to the single JSON line sent on connect. Built key-by-key
- * from the allowlist — even if a caller sneaks extra properties onto the
- * object, they cannot leak into the wire format.
- */
-declare function serializeHandshake(hello: PeerHello): string;
-/**
- * Parse one incoming handshake line. Returns `null` for anything malformed
- * (bad JSON, non-object, missing/oversized handle or league). The result is
- * constructed from an allowlist of keys, so any extra fields a peer sends —
- * in particular any raw-usage field — are ignored and never retained.
- */
-declare function parseHandshake(raw: string | Buffer): PeerHello | null;
-/** A peer we've shaken hands with, persisted locally. */
-interface StoredPeer extends PeerHello {
-    readonly firstSeenAt: string;
-    readonly lastSeenAt: string;
-    /** LOCAL metadata: when the last `msg` from this peer arrived (never on the wire). */
-    readonly lastMessageAt?: string;
-}
-/** Load persisted live peers, or `[]` if none/corrupt. Local-only data. */
-declare function loadPeers(dir?: string): StoredPeer[];
-/**
- * Record a successfully handshaken peer, keyed by handle (a peer may reconnect
- * from a different key). Returns whether this handle is NEW (first time seen).
- */
-declare function recordPeer(hello: PeerHello, dir?: string, now?: Date): {
-    peer: StoredPeer;
-    isNew: boolean;
-};
-/**
- * Stamp `lastMessageAt` on a stored peer (a `msg` just arrived from them).
- * Local metadata only; never on the wire. Returns false when the handle isn't
- * a known peer. Never throws — best-effort bookkeeping.
- */
-declare function recordPeerMessage(handle: string, dir?: string, now?: Date): boolean;
-/** Injection point for the match notification (defaults to vibe-core notify). */
-type NotifySink = (event: VibeEvent) => void;
-interface DiscoveryOptions {
-    /** What we broadcast. Must already be consent-gated by the caller. */
-    readonly hello: PeerHello;
-    /**
-     * Override the joined topic (tests pass a random one on an isolated DHT).
-     * Defaults to {@link leagueTopic}`(hello.league)`. Ignored when {@link topics}
-     * is set.
-     */
-    readonly topic?: Buffer;
-    /**
-     * ALL topics to join on the one swarm (e.g. your league + adjacent leagues),
-     * so thin pools and cross-league friends still connect. Every topic is
-     * joined, refreshed, and left on close. Defaults to `[topic]` — i.e. a single
-     * own-league topic (the legacy behavior).
-     */
-    readonly topics?: readonly Buffer[];
-    /**
-     * Predicate over an incoming peer's advertised league. Defaults to EXACT
-     * match against `hello.league` — the same privacy invariant as before. Widen
-     * it (e.g. ±1 adjacency via {@link leaguesWithin}) to accept cross-league
-     * peers that arrive on a shared topic.
-     */
-    readonly acceptLeague?: (peerLeague: string) => boolean;
-    /**
-     * Predicate over an incoming peer's advertised handle. A blocked peer's hello
-     * is DROPPED exactly like a wrong-league one — never recorded to peers.json,
-     * never notified, never handed to `onLink`/pairing. Default: nothing blocked.
-     * The CLI passes one backed by the persisted blocklist (~/.vibedating).
-     */
-    readonly isBlocked?: (handle: string) => boolean;
-    /** DHT bootstrap nodes; omit for the public DHT. Tests pass a local testnet. */
-    readonly bootstrap?: ReadonlyArray<{
-        readonly host: string;
-        readonly port: number;
-    }>;
-    /** Where peers.json lives. Defaults to ~/.vibedating. */
-    readonly stateDir?: string;
-    /** Called after each accepted handshake; `isNew` = first time this handle is seen. */
-    readonly onPeer?: (peer: PeerHello, isNew: boolean) => void;
-    /**
-     * Called once per connection with a live {@link PeerLink} over the same socket
-     * (the hello was frame #1; subsequent frames flow to the link). Omit for the
-     * plain `discover` behavior (no live chat). Existing discovery behavior is
-     * unchanged when this is absent.
-     */
-    readonly onLink?: (link: PeerLink) => void;
-    /** Match-notification sink (tests capture with a fake). Best-effort. */
-    readonly notify?: NotifySink;
-}
-interface DiscoverySession {
-    /** The primary (first) joined topic. See {@link topics} for the full set. */
-    readonly topic: Buffer;
-    /** Every topic this session joined (primary first). */
-    readonly topics: readonly Buffer[];
-    /** What we broadcast on every connection. */
-    readonly hello: PeerHello;
-    /** Live peer set, keyed by the remote's public key (hex). */
-    readonly peers: ReadonlyMap<string, PeerHello>;
-    /** Resolves when the first DHT announce/lookup round for every topic completes. */
-    readonly ready: Promise<unknown>;
-    /** Leave every topic and destroy the node. Idempotent. */
-    close(): Promise<void>;
-}
-/**
- * Join the swarm on the league topic and handshake with every peer that
- * connects. CONSENT GATE LIVES WITH THE CALLER — never call this without the
- * `share:live` grant (or an explicit `--live` opt-in in the same breath).
- */
-declare function startDiscovery(opts: DiscoveryOptions): Promise<DiscoverySession>;
-
 /**
  * A Nostr event, reduced to the fields this module touches. Structurally
  * compatible with `nostr-tools`'s `Event`, so a finalized/verified event can be
@@ -351,87 +117,6 @@ declare function createNostrRelayLink(opts: CreateNostrRelayLinkOptions): Promis
  */
 declare function createNostrPoolTransport(urls?: readonly string[]): Promise<RelayTransport>;
 
-/** Namespace prefix so room topics never collide with league topics (or anything
- *  else on the DHT). Mirrors {@link p2p.TOPIC_PREFIX} for the 1:1 path. */
-declare const ROOM_TOPIC_PREFIX = "vibedate-room:";
-/**
- * Derive the 32-byte DHT topic for a named room. Deterministic: everyone who
- * joins the same room name anywhere in the world hashes to the same topic,
- * which is the entire discovery mechanism. Pure (mirrors {@link p2p.leagueTopic}).
- */
-declare function roomTopic(name: string): Buffer;
-/** A room member = a connected, handshaken peer. Same shape as a live peer. */
-type RoomMember = PeerHello;
-/** One group chat message: a `msg` frame's payload tagged with the sender. */
-interface RoomMessage {
-    /** Sender's handle (from the validated hello — UNTRUSTED display data). */
-    readonly from: string;
-    readonly id: string;
-    readonly text: string;
-    readonly at: number;
-}
-interface RoomOptions {
-    /** What we broadcast. Must already be consent-gated by the caller. */
-    readonly hello: PeerHello;
-    /** Room name → its own DHT topic (see {@link roomTopic}). */
-    readonly room: string;
-    /** DHT bootstrap nodes; omit for the public DHT. Tests pass a local testnet. */
-    readonly bootstrap?: ReadonlyArray<{
-        readonly host: string;
-        readonly port: number;
-    }>;
-    /** Where peers.json lives. Defaults to ~/.vibedating. */
-    readonly stateDir?: string;
-    /** Predicate over a blocked handle — a blocked peer's hello is dropped exactly
-     *  like in 1:1 discovery. Default: nothing blocked. */
-    readonly isBlocked?: (handle: string) => boolean;
-    /** Match-notification sink (tests capture with a fake). Best-effort. */
-    readonly notify?: NotifySink;
-}
-interface RoomSession {
-    /** The room name. */
-    readonly room: string;
-    /** The joined DHT topic (see {@link roomTopic}). */
-    readonly topic: Buffer;
-    /** What we broadcast. */
-    readonly hello: PeerHello;
-    /** Live member set, keyed by handle (excludes self). Mirrors the live view
-     *  semantics of {@link p2p.DiscoverySession.peers}. */
-    readonly members: ReadonlyMap<string, RoomMember>;
-    /** Resolves when the first DHT announce/lookup round completes. */
-    readonly ready: Promise<unknown>;
-    /**
-     * Broadcast a text message to ALL room members (fan-out: one `msg` frame per
-     * member's {@link PeerLink}). Returns the handles the message was sent to.
-     * Best-effort: a member whose link has just closed is skipped silently.
-     */
-    broadcast(text: string): readonly string[];
-    /** Register a callback fired for each incoming group message (with sender). */
-    onMessage(cb: (m: RoomMessage) => void): void;
-    /** Register a callback fired whenever the member roster changes (join/leave). */
-    onRoster(cb: (members: readonly RoomMember[]) => void): void;
-    /** Register a callback fired for each incoming `rtc-*` signaling frame,
-     *  tagged with the sender's handle (full-mesh video signaling). */
-    onSignal(cb: (from: string, frame: RtcFrame) => void): void;
-    /** Relay one `rtc-*` signaling frame to one member (by handle). */
-    sendSignal(handle: string, frame: RtcFrame): void;
-    /** The underlying {@link PeerLink} to a member (by handle), or undefined. */
-    linkFor(handle: string): PeerLink | undefined;
-    /** Leave the room and destroy the node. Idempotent. */
-    close(): Promise<void>;
-}
-/**
- * Join (or create) a named room on the DHT and discover ALL members. CONSENT
- * GATE LIVES WITH THE CALLER — never call this without the `share:live` grant
- * (or an explicit opt-in in the same breath), exactly like
- * {@link p2p.startDiscovery}.
- *
- * Resolves once the first DHT announce/lookup round completes; the returned
- * session's {@link RoomSession.members} map + {@link RoomSession.onRoster}
- * callback track every member that joins or leaves thereafter.
- */
-declare function startRoom(opts: RoomOptions): Promise<RoomSession>;
-
 /**
  * Persistent ed25519 identity — binds a handle to a keypair so a peer cannot
  * impersonate it.
@@ -639,4 +324,4 @@ declare const CANDIDATES: readonly Candidate[];
  */
 declare function matches(myLeague: string, candidates?: readonly Candidate[]): Candidate[];
 
-export { BELOW_LEAGUE, CANDIDATES, type Candidate, type CreateNostrRelayLinkOptions, DEFAULT_RELAYS, DEMO_TOTAL_TOKENS, type DiscoveryOptions, type DiscoverySession, type HelloClaims, type Identity, type IdentityProof, type IdentityVerdict, LEAGUES, LIVE_NOTICE, type League, type LocalUsageSnapshot, type NostrKey, type NostrRelayLink, type PeerHello, ROOM_TOPIC_PREFIX, type RelayEvent, type RelayFilter, type RelayTransport, type RoomMember, type RoomMessage, type RoomOptions, type RoomSession, type StoredPeer, TOKENS_ENV, TOPIC_PREFIX, VIBEDATE_MESSAGE_KIND, VIBEDATE_PRESENCE_KIND, allLeagueNames, canonicalHelloClaims, classifyHelloIdentity, conversationTag, createNostrPoolTransport, createNostrRelayLink, league, leagueIndex, leagueTopic, leaguesWithin, loadOrCreateIdentity, loadOrCreateNostrKey, loadPeers, matches, parseHandshake, parseTokensEnv, readUsage, recordPeer, recordPeerMessage, roomTopic, serializeHandshake, signHelloClaims, startDiscovery, startRoom, verifyHelloClaims };
+export { BELOW_LEAGUE, CANDIDATES, type Candidate, type CreateNostrRelayLinkOptions, DEFAULT_RELAYS, DEMO_TOTAL_TOKENS, type HelloClaims, type Identity, type IdentityProof, type IdentityVerdict, LEAGUES, type League, type LocalUsageSnapshot, type NostrKey, type NostrRelayLink, PeerHello, type RelayEvent, type RelayFilter, type RelayTransport, TOKENS_ENV, VIBEDATE_MESSAGE_KIND, VIBEDATE_PRESENCE_KIND, allLeagueNames, canonicalHelloClaims, classifyHelloIdentity, conversationTag, createNostrPoolTransport, createNostrRelayLink, league, leagueIndex, leaguesWithin, loadOrCreateIdentity, loadOrCreateNostrKey, matches, parseTokensEnv, readUsage, signHelloClaims, verifyHelloClaims };

package/dist/index.js

@@ -36,7 +36,7 @@ import {
   startDiscovery,
   startRoom,
   verifyHelloClaims
-} from "./chunk-HDHJLZZG.js";
+} from "./chunk-S7MO5OSO.js";
 export {
   BELOW_LEAGUE,
   CANDIDATES,

package/dist/mcp.d.ts

@@ -1,7 +1,187 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { a as PeerLink, P as PeerHello, f as RoomSession, b as DiscoverySession, d as RoomMessage } from './room-BStsMaeT.js';
+import '@pooriaarab/vibe-core';
+
+/**
+ * Pairing policy for the live layer — pure, over an injected set of links.
+ *
+ * Two modes share one policy object:
+ *
+ *   - Omegle: links arrive (`add`) and are auto-paired one at a time; `next()`
+ *     closes the current match and rolls to the next waiting link (or idles).
+ *   - Dating: `open(handle)` picks the specific waiting link whose peer
+ *     advertised that handle, closing any current match first.
+ *
+ * This module knows nothing about hyperswarm, the DHT, or the wire — it only
+ * shuffles {@link PeerLink}s handed to it. That keeps it trivially unit-testable
+ * with fakes and keeps the policy out of the transport.
+ *
+ * Remote hang-ups are handled too: when the matched peer "next"s us, the link's
+ * onClose fires and we auto-pair the next waiting link (omegle stays live).
+ *
+ * MESSAGE ROUTING (the correctness bit): `onMessage` is bound ONCE per link in
+ * {@link LivePairing.add} — never re-bound on match. A message from the current
+ * peer is delivered live; a message from a NON-current (queued) peer is BUFFERED
+ * (never dropped) and a queued-count notice fires, then flushed when that peer
+ * becomes current. Binding once per link means there is exactly one handler per
+ * link: no accumulation (no duplicate delivery) and no silent drops.
+ */
+
+/** A chat message received from a peer. Mirrors PeerLink.onMessage's payload. */
+interface IncomingMessage {
+    readonly id: string;
+    readonly text: string;
+    readonly at: number;
+}
+/**
+ * A drained message tagged with its sender's handle — for PULL-based consumers
+ * (the MCP `live_poll` tool) that read every inbound message since the last
+ * poll, current or queued, without registering a push callback.
+ */
+interface PairingMessage {
+    readonly from: string;
+    readonly id: string;
+    readonly text: string;
+    readonly at: number;
+    /** True if this arrived from a NON-current (queued) peer at receive time. */
+    readonly queued: boolean;
+}
+interface LivePairing {
+    /** Number of unmatched links waiting in the queue. */
+    readonly available: number;
+    /** The currently-matched link, or `undefined` when idle. */
+    current(): PeerLink | undefined;
+    /**
+     * Omegle "next": close the current match and advance to the next waiting link
+     * (auto-pair), or go idle if the queue is empty. Returns the new current link.
+     */
+    next(): PeerLink | undefined;
+    /**
+     * Dating pick: match the available link whose `hello.handle === handle`.
+     * Closes the current match first. Returns the matched link, or `undefined`.
+     */
+    open(handle: string): PeerLink | undefined;
+    /** Add a newly-arrived link (fed from discovery's `onLink`). Auto-pairs if idle. */
+    add(link: PeerLink): void;
+    /** Register a callback fired whenever the current match changes (incl. → idle). */
+    onMatch(cb: (link: PeerLink | undefined) => void): void;
+    /**
+     * Register a callback fired for each message from the CURRENT peer — including
+     * buffered messages flushed when a peer becomes current. `from` is the sender's
+     * handle. Registered on the pairing (not per-link), so callers NEVER bind
+     * `link.onMessage` themselves.
+     */
+    onMessage(cb: (from: string, m: IncomingMessage) => void): void;
+    /**
+     * Register a callback fired when a NON-current (queued) peer sends a message —
+     * it is buffered, not dropped. `queued` is that peer's current buffered count.
+     */
+    onQueued(cb: (from: string, queued: number) => void): void;
+    /**
+     * Pull every inbound message received since the last drain (current + queued),
+     * tagged with sender; empties the buffer. For PULL consumers (MCP live_poll).
+     */
+    drain(): PairingMessage[];
+    /** Snapshot of the currently-queued (non-current) links. */
+    queued(): PeerLink[];
+}
+
+/**
+ * vibedating MCP server (stdio) — full agent-native tool surface.
+ *
+ * An agent drives vibedate ENTIRELY via tool calls — no interactive terminal.
+ * This is the fix for agents whose interactive `live` sessions time out.
+ *
+ * Tools (every response is structured JSON with `{ ok, ... }` / `{ ok:false, error }`):
+ *
+ *   READ/STATE
+ *     get_profile · connect · matches · handle_get · handle_set · blocklist
+ *     block · unblock · daemon_status
+ *
+ *   DISCOVERY
+ *     discover · who · find
+ *
+ *   LIVE CHAT (stateful in-process session — poll, don't block a TTY)
+ *     live_start · live_peers · live_send · live_poll · live_open · live_next · live_stop
+ *
+ *   ROOMS
+ *     room_join · room_send · room_poll · room_who · room_leave
+ *
+ *   MEDIA
+ *     media_send
+ *
+ * Legacy aliases `profile` / `matches` remain registered for back-compat.
+ *
+ * AEGIS: peer text is UNTRUSTED display data — sanitized before return, never
+ * executed, never fed to a shell.
+ */
+
+/** Injectable hooks so tests can drive live/room without the real DHT. */
+interface McpLiveHooks {
+    /** Build (or inject) the pairing object used by live_* tools. */
+    createPairing?: () => LivePairing;
+    /**
+     * Optional override for live_start's discovery join. When provided, the
+     * real DHT is never touched — the hook receives the pairing and is free to
+     * inject fake links. Return a close handle (or nothing).
+     */
+    startLive?: (args: {
+        pairing: LivePairing;
+        hello: PeerHello;
+        any: boolean;
+        to: string | null;
+    }) => Promise<{
+        close: () => Promise<void>;
+    } | void> | {
+        close: () => Promise<void>;
+    } | void;
+    /** Optional override for room_join. */
+    startRoom?: (args: {
+        hello: PeerHello;
+        room: string;
+    }) => Promise<RoomSession> | RoomSession;
+}
+interface McpSessionState {
+    discovery: DiscoverySession | null;
+    /** Target handle sought by `find` (canonical), or null when idle. */
+    findTarget: string | null;
+    findSeen: boolean;
+    live: {
+        pairing: LivePairing;
+        session: DiscoverySession | {
+            close: () => Promise<void>;
+        } | null;
+        any: boolean;
+        to: string | null;
+    } | null;
+    room: {
+        session: RoomSession;
+        /** Draining buffer of inbound room messages since last room_poll. */
+        buffer: RoomMessage[];
+        name: string;
+    } | null;
+}
+/** Construct a fresh in-process session bag (also used by tests to reset). */
+declare function createSessionState(): McpSessionState;
+/**
+ * Create the vibedating MCP server with every agent-native tool registered.
+ * Pure registration — no transport attached. Callers (or {@link runMcp}) attach
+ * a transport. Tests drive this with InMemoryTransport.
+ *
+ * Pass a session bag to share/reset state across calls; omit to use a private
+ * fresh bag for this server instance.
+ */
+declare function createMcpServer(opts?: {
+    readonly session?: McpSessionState;
+    readonly hooks?: McpLiveHooks;
+    readonly version?: string;
+}): McpServer;
 /**
  * Start the stdio MCP server. Resolves once connected to the transport; the
  * transport then keeps the process alive for the host agent to call tools.
  */
 declare function runMcp(): Promise<void>;
+/** Full set of tool names the server exposes — kept in sync for tests. */
+declare const MCP_TOOL_NAMES: readonly ["get_profile", "profile", "connect", "matches", "handle_get", "handle_set", "blocklist", "block", "unblock", "daemon_status", "discover", "who", "find", "live_start", "live_peers", "live_send", "live_poll", "live_open", "live_next", "live_stop", "room_join", "room_send", "room_poll", "room_who", "room_leave", "media_send"];
 
-export { runMcp };
+export { MCP_TOOL_NAMES, type McpLiveHooks, type McpSessionState, createMcpServer, createSessionState, runMcp };

package/dist/mcp.js

@@ -1,7 +1,13 @@
 import {
+  MCP_TOOL_NAMES,
+  createMcpServer,
+  createSessionState,
   runMcp
-} from "./chunk-ZD6JBWEW.js";
-import "./chunk-HDHJLZZG.js";
+} from "./chunk-JBADPOR5.js";
+import "./chunk-S7MO5OSO.js";
 export {
+  MCP_TOOL_NAMES,
+  createMcpServer,
+  createSessionState,
   runMcp
 };