stoops 0.1.0 → 0.2.1

package/dist/agent/index.d.ts

@@ -0,0 +1,553 @@
+import { a as ContentPart, R as RoomResolver, b as RoomConnection, c as RoomDataSource, T as ToolHandlerOptions } from '../types-9iTDVOJG.js';
+export { A as AgentIdentity, C as ClaudeSessionOptions, I as ILLMSession, d as LLMQueryStats, e as LLMSessionOptions, L as LangGraphSessionOptions, f as LocalRoomDataSource, P as ProcessorBridge, Q as QueryTurn, S as SessionCallbacks } from '../types-9iTDVOJG.js';
+import { R as RoomEvent, P as Participant, c as ParticipantType, C as Channel, b as Room, M as Message, a as PaginatedResult, E as EventCategory } from '../index-ByKHLUOe.js';
+import 'zod';
+
+/** Event formatting and mode descriptions for stoops agents. */
+
+declare function getSystemPreamble(identifier?: string, personParticipantId?: string): string;
+/** Short 4-char ref for a message ID, used in transcripts. */
+declare function messageRef(messageId: string): string;
+/** Format a participant as a labeled name: "[human] Alice" or "[agent] Quinn". */
+declare function participantLabel(p: Participant | null, fallback?: string): string;
+/** Convert ContentPart[] back to a plain string (for trace logs and stats). */
+declare function contentPartsToString(parts: ContentPart[]): string;
+/**
+ * Format a typed event as ContentPart[] for the LLM session.
+ * Returns null for events that shouldn't be sent to the LLM (noise).
+ *
+ * Compact one-liner format:
+ *   Messages:  [14:23:01] #3847 [lobby] Alice: hey everyone
+ *   Replies:   [14:23:01] #9102 [lobby] Alice (→ #3847 Bob): good point
+ *   Mentions:  [14:23:01] #5521 [lobby] ⚡ Alice: @bot what do you think?
+ *   Joined:    [14:23:01] [lobby] + Alice joined
+ *   Left:      [14:23:15] [lobby] - Bob left
+ *   Reactions:  [14:23:20] [lobby] Alice reacted ❤️ to #3847
+ */
+declare function formatEvent(event: RoomEvent, resolveParticipant: (id: string) => Participant | null, replyContext?: {
+    senderName: string;
+    content: string;
+} | null, roomLabel?: string, reactionTarget?: {
+    senderName: string;
+    content: string;
+    isSelf: boolean;
+} | null, assignRef?: (messageId: string) => string): ContentPart[] | null;
+
+/**
+ * Engagement — controls which room events trigger LLM evaluation.
+ *
+ * # Overview
+ *
+ * Every event that reaches an agent is classified into one of three dispositions:
+ * - "trigger"  — evaluate now (start an LLM call)
+ * - "content"  — buffer as context; deliver to LLM on the next trigger
+ * - "drop"     — ignore entirely (not delivered to LLM)
+ *
+ * The `EngagementStrategy` interface defines this contract. Implement it to
+ * customize when your agent responds. The built-in `StoopsEngagement` provides
+ * an 8-mode system; `classifyEvent()` is a standalone convenience function
+ * using the same logic.
+ *
+ * # Built-in modes (StoopsEngagement / classifyEvent)
+ *
+ * Active modes (agent evaluates on matching messages):
+ * - "everyone"  — all messages trigger evaluation
+ * - "people"    — only messages from human participants trigger evaluation
+ * - "agents"    — only messages from other agents trigger evaluation
+ * - "me"        — only messages from the agent's designated owner ("person") trigger
+ *
+ * Standby modes (agent only wakes on @mentions):
+ * - "standby-everyone" — any @mention wakes the agent
+ * - "standby-people"   — only @mentions from humans wake the agent
+ * - "standby-agents"   — only @mentions from other agents wake the agent
+ * - "standby-me"       — only an @mention from the agent's owner wakes them
+ *
+ * # Classification rules (in order)
+ *
+ * 1. Internal events (bookkeeping: edits, deletes, status changes, agent
+ *    activity) → always drop
+ * 2. Self-sent events → drop (the agent ignores its own activity).
+ *    Exception: mentions are not self-dropped — a standby agent should wake
+ *    if it is @mentioned, even if the mention event's participant_id is itself.
+ * 3. Standby modes: only @mentions directed at the agent from a matching
+ *    sender → trigger; everything else → drop.
+ * 4. Active modes, @mention → drop (the MessageSent event already carries the
+ *    @mention text; delivering both would be redundant).
+ * 5. Active modes, message from matching sender → trigger
+ * 6. Active modes, message from non-matching sender → content (buffered context)
+ * 7. Active modes, ambient event (join/leave/reaction) → content
+ */
+
+/**
+ * The outcome of classifying an event for a given agent.
+ *
+ * - "trigger" — run an LLM evaluation now
+ * - "content" — buffer as context; include with the next evaluation
+ * - "drop"    — discard; never shown to the LLM
+ */
+type EventDisposition = "trigger" | "content" | "drop";
+/**
+ * Engagement strategy — decides which events trigger LLM evaluation.
+ *
+ * Implement this to customize when your agent responds. The runtime calls
+ * `classify()` for every incoming event and acts on the returned disposition.
+ *
+ * @example
+ * // Respond to everything:
+ * class AlwaysEngage implements EngagementStrategy {
+ *   classify(event, roomId, selfId) {
+ *     if (event.participant_id === selfId) return "drop";
+ *     return "trigger";
+ *   }
+ * }
+ */
+interface EngagementStrategy {
+    /**
+     * Classify a room event for this agent.
+     *
+     * @param event      — the room event to classify
+     * @param roomId     — the room the event came from
+     * @param selfId     — the agent's own participant ID (to drop self-events)
+     * @param senderType — "human" or "agent" for the event's sender
+     * @param senderId   — participant ID of the sender. For `Mentioned` events,
+     *                     pass `event.message.sender_id` (who wrote the mention),
+     *                     not `event.participant_id` (who was mentioned).
+     */
+    classify(event: RoomEvent, roomId: string, selfId: string, senderType: ParticipantType, senderId: string): EventDisposition;
+    /**
+     * Return the current engagement mode for a room.
+     *
+     * Optional — strategies that don't use named modes may omit this.
+     * The runtime falls back to `"everyone"` when absent.
+     */
+    getMode?(roomId: string): EngagementMode;
+    /**
+     * Update the engagement mode for a room.
+     *
+     * Optional — called by the runtime when a room connects with an initial mode
+     * or when the user changes the mode at runtime. Strategies that don't use
+     * named modes may omit this; the call will be silently ignored.
+     */
+    setMode?(roomId: string, mode: EngagementMode): void;
+    /**
+     * Called when a room is disconnected from the runtime.
+     *
+     * Optional — use this for cleanup, e.g. removing per-room state that is
+     * no longer needed. Strategies with no per-room state may omit this.
+     */
+    onRoomDisconnected?(roomId: string): void;
+}
+type EngagementMode = "me" | "people" | "agents" | "everyone" | "standby-me" | "standby-people" | "standby-agents" | "standby-everyone";
+/**
+ * StoopsEngagement — the built-in engagement strategy.
+ *
+ * Implements the 8-mode system: 4 active modes (everyone/people/agents/me)
+ * and 4 standby modes that only wake on @mentions. Maintains per-room mode
+ * state internally.
+ *
+ * @example
+ * const engagement = new StoopsEngagement("people", personId);
+ * engagement.setMode("room-1", "me");
+ * engagement.classify(event, "room-1", selfId, "human", senderId);
+ */
+declare class StoopsEngagement implements EngagementStrategy {
+    private _modes;
+    private _defaultMode;
+    private _personParticipantId?;
+    constructor(defaultMode: EngagementMode, personParticipantId?: string);
+    /** Get the engagement mode for a room. Falls back to the default mode. */
+    getMode(roomId: string): EngagementMode;
+    /** Set the engagement mode for a room. */
+    setMode(roomId: string, mode: EngagementMode): void;
+    /** Called when a room is disconnected. Removes the room's mode so it doesn't linger. */
+    onRoomDisconnected(roomId: string): void;
+    classify(event: RoomEvent, roomId: string, selfId: string, senderType: ParticipantType, senderId: string): EventDisposition;
+}
+/**
+ * Classify a room event for an agent with the given engagement mode.
+ *
+ * Pure function — no state, no side effects, no SDK dependency.
+ * Uses the same classification logic as `StoopsEngagement` but takes all
+ * parameters explicitly. Useful for one-off classification or testing.
+ *
+ * @param event                — the event to classify
+ * @param mode                 — the agent's current engagement mode for this room
+ * @param selfId               — the agent's own participant ID (to drop self-events)
+ * @param senderType           — type of the participant who caused the event
+ * @param senderId             — participant ID of the sender.
+ *                               For `Mentioned` events, pass `event.message.sender_id`
+ *                               (who wrote the mention), not `event.participant_id`
+ *                               (who was mentioned).
+ * @param personParticipantId  — the agent's owner's participant ID, used in
+ *                               "me" and "standby-me" modes
+ */
+declare function classifyEvent(event: RoomEvent, mode: EngagementMode, selfId: string, senderType: ParticipantType, senderId: string, personParticipantId?: string): EventDisposition;
+
+/** EventMultiplexer — merges N channel async streams into one labeled stream. */
+
+interface LabeledEvent {
+    roomId: string;
+    roomName: string;
+    event: RoomEvent;
+}
+/**
+ * Merges events from multiple channels into a single async iterable stream.
+ * Each event is labeled with its source room's ID and name.
+ *
+ * Channels can be added/removed while the multiplexer is running.
+ */
+declare class EventMultiplexer {
+    private _queue;
+    private _waiters;
+    private _channels;
+    private _closed;
+    private _closeResolve;
+    addChannel(roomId: string, roomName: string, channel: Channel): void;
+    removeChannel(roomId: string): void;
+    close(): void;
+    private _listenLoop;
+    private _push;
+    [Symbol.asyncIterator](): AsyncIterator<LabeledEvent>;
+}
+
+/**
+ * EventProcessor — core event loop for stoops agents.
+ *
+ * Owns: engagement classification, content buffering, event formatting,
+ * ref map, room connections, mode management. Does NOT own: LLM sessions,
+ * MCP servers, compaction hooks, stats tracking.
+ *
+ * Delivery is pluggable — pass a `deliver` callback to `run()`.
+ * The callback receives formatted ContentPart[] and does whatever the
+ * consumer needs (Claude SDK query, LangGraph injection, tmux send-keys).
+ */
+
+interface EventProcessorOptions {
+    /** Engagement mode when no per-room override is set. */
+    defaultMode?: EngagementMode;
+    /** Custom engagement strategy. Defaults to StoopsEngagement. */
+    engagement?: EngagementStrategy;
+    /** The agent owner's participant ID (for "me" / "standby-me" modes). */
+    personParticipantId?: string;
+    /** The agent's own stable identifier slug (e.g. "my-agent"). */
+    selfIdentifier?: string;
+    /** Called when engagement mode changes for a room. */
+    onModeChange?: (roomId: string, roomName: string, mode: EngagementMode) => void;
+    /** Called before each delivery. Return false to skip. */
+    preQuery?: () => Promise<boolean>;
+}
+declare class EventProcessor implements RoomResolver {
+    private _participantId;
+    private _participantName;
+    private _options;
+    private _engagement;
+    private _deliver;
+    private _multiplexer;
+    private _registry;
+    private _buffer;
+    private _tracker;
+    private _processing;
+    private _eventQueue;
+    private _stopped;
+    private _currentContextRoomId;
+    private _log;
+    private _refMap;
+    private _injectBuffer;
+    /** Per-room participant IDs (for multi-server CLI agents where each server assigns a different ID). */
+    private _roomSelfIds;
+    constructor(participantId: string, participantName: string, options?: EventProcessorOptions);
+    get participantId(): string;
+    set participantId(id: string);
+    get participantName(): string;
+    get currentContextRoomId(): string | null;
+    /** Set a room-specific participant ID (for multi-server CLI agents). */
+    setRoomParticipantId(roomId: string, participantId: string): void;
+    /** Get the effective selfId for a room — room-specific if set, otherwise the global one. */
+    getSelfIdForRoom(roomId: string): string;
+    assignRef(messageId: string): string;
+    resolveRef(ref: string): string | undefined;
+    isEventSeen(eventId: string): boolean;
+    markEventsSeen(eventIds: string[]): void;
+    drainInjectBuffer(): ContentPart[][] | null;
+    /**
+     * Called by the consumer when context was compacted.
+     * Clears seen-event cache and ref map so catch_up returns full history.
+     */
+    onContextCompacted(): void;
+    /**
+     * Called by the consumer when a tool call starts or completes.
+     * Routes ToolUseEvent to the room that triggered the current evaluation.
+     */
+    emitToolUse(toolName: string, status: "started" | "completed"): void;
+    resolve(roomName: string): RoomConnection | null;
+    listAll(): Array<{
+        name: string;
+        roomId: string;
+        identifier?: string;
+        mode: string;
+        participantCount: number;
+        lastMessage?: string;
+    }>;
+    connectRoom(room: Room, roomName: string, mode?: EngagementMode, identifier?: string): Promise<void>;
+    /**
+     * Connect a remote room via a RoomDataSource (no local Room/Channel).
+     *
+     * Used by the client-side agent runtime to register rooms that are
+     * accessed over HTTP. Events come from an external source (SSE multiplexer)
+     * passed to run(), not from the internal EventMultiplexer.
+     */
+    connectRemoteRoom(dataSource: RoomDataSource, roomName: string, mode?: EngagementMode, identifier?: string): void;
+    /** Disconnect a remote room (by room ID). */
+    disconnectRemoteRoom(roomId: string): void;
+    disconnectRoom(roomId: string): Promise<void>;
+    getModeForRoom(roomId: string): EngagementMode;
+    setModeForRoom(roomId: string, mode: EngagementMode, notifyAgent?: boolean): void;
+    getLog(): RoomEvent[];
+    /**
+     * Start the event loop.
+     *
+     * @param deliver — callback that receives formatted content and delivers
+     *   it to the agent. This is the consumer's responsibility. The function
+     *   should block until delivery is complete (e.g., LLM evaluation finished).
+     * @param eventSource — optional external event source (e.g. SseMultiplexer).
+     *   If provided, events are consumed from this instead of the internal
+     *   EventMultiplexer. Used by the client-side agent runtime.
+     * @param initialParts — optional content to deliver before entering the
+     *   event loop. Used by the runtime to deliver auto-join confirmation.
+     */
+    run(deliver: (parts: ContentPart[]) => Promise<void>, eventSource?: AsyncIterable<LabeledEvent>, initialParts?: ContentPart[]): Promise<void>;
+    stop(): Promise<void>;
+    buildFullCatchUp(): Promise<ContentPart[]>;
+    private _buildFullCatchUp;
+    private _handleLabeledEvent;
+    private _processTrigger;
+    private _resolveParticipantForRoom;
+    private _resolveReplyContext;
+    private _resolveReactionTarget;
+    private _formatForLLM;
+    private _processRaw;
+}
+
+/**
+ * Full MCP server — for embedded/API agents without filesystem access.
+ *
+ * Creates a proper MCP server using @modelcontextprotocol/sdk with
+ * StreamableHTTP transport on a random localhost port.
+ *
+ * 4 tools: catch_up, search_by_text, search_by_message, send_message.
+ *
+ * Returns { url, instance, stop } where:
+ *   url      — http://127.0.0.1:PORT/mcp (for any MCP-capable client)
+ *   instance — McpServer instance (for Claude SDK in-process shortcut)
+ *   stop     — shuts down the HTTP listener
+ */
+
+interface StoopsMcpServer {
+    /** HTTP URL for URL-based MCP clients (e.g. LangGraph, external tools). */
+    url: string;
+    /**
+     * Raw McpServer instance — passed to Claude SDK as
+     * `{ type: 'sdk', name: 'stoops_tools', instance }` to avoid HTTP overhead.
+     */
+    instance: any;
+    /** Shut down the HTTP listener. */
+    stop: () => Promise<void>;
+}
+/**
+ * Start a full stoops MCP server (all 4 tools).
+ * Call once per session start; call stop() on session stop.
+ */
+declare function createFullMcpServer(resolver: RoomResolver, options: ToolHandlerOptions): Promise<StoopsMcpServer>;
+
+/**
+ * Runtime MCP server — local MCP proxy for the client-side agent runtime.
+ *
+ * Claude Code / OpenCode connects to this local server. Tool calls are routed
+ * to the right stoop server via the RoomResolver (which maps room names to
+ * RemoteRoomDataSource instances).
+ *
+ * Tools:
+ *   Always present:
+ *     stoops__catch_up(room?) — with room: room catch-up. Without: list rooms + pending invites.
+ *     stoops__search_by_text(room, query, count?, cursor?)
+ *     stoops__search_by_message(room, ref, direction?, count?)
+ *     stoops__send_message(room, content, reply_to?)
+ *     stoops__set_mode(room, mode)
+ *     stoops__join_room(url, alias?)
+ *     stoops__leave_room(room)
+ *
+ *   With --admin flag:
+ *     stoops__admin__set_mode_for(room, participant, mode)
+ *     stoops__admin__kick(room, participant)
+ */
+
+interface JoinRoomResult {
+    success: boolean;
+    error?: string;
+    roomName?: string;
+    agentName?: string;
+    authority?: string;
+    mode?: string;
+    personName?: string;
+    participants?: Array<{
+        name: string;
+        authority: string;
+    }>;
+    recentLines?: string[];
+}
+interface RuntimeMcpServerOptions {
+    resolver: RoomResolver;
+    toolOptions: ToolHandlerOptions;
+    admin?: boolean;
+    /** Called when the agent requests joining a new room mid-session. */
+    onJoinRoom?: (url: string, alias?: string) => Promise<JoinRoomResult>;
+    /** Called when the agent requests leaving a room. */
+    onLeaveRoom?: (room: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Called when the agent changes its own mode. */
+    onSetMode?: (room: string, mode: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Called for admin set-mode-for. */
+    onAdminSetModeFor?: (room: string, participant: string, mode: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Called for admin kick. */
+    onAdminKick?: (room: string, participant: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Called for admin mute (demote to observer). */
+    onAdminMute?: (room: string, participant: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Called for admin unmute (restore to participant). */
+    onAdminUnmute?: (room: string, participant: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+interface RuntimeMcpServer {
+    url: string;
+    stop: () => Promise<void>;
+}
+/**
+ * Create a runtime MCP server on a random localhost port.
+ * Returns the URL for --mcp-config and a stop function.
+ */
+declare function createRuntimeMcpServer(opts: RuntimeMcpServerOptions): Promise<RuntimeMcpServer>;
+
+/**
+ * RefMap — bidirectional map between short decimal refs and full message UUIDs.
+ *
+ * Why 4 digits: a ref like #3847 tokenizes to 1–2 tokens in most LLMs, while a
+ * raw UUID (a1b2c3d4-e5f6-...) burns 8–12 tokens for no benefit. Since refs
+ * appear on every message in transcripts and tool output, the savings compound.
+ *
+ * 10,000 unique refs per cycle is far more than an LLM context window can hold
+ * (a 200k-token window fits ~2000 messages at most). The map is cleared on every
+ * context compaction, so overflow is essentially impossible in practice. If it
+ * does happen, the fallback to a UUID-derived hash still works — just less tidy.
+ *
+ * Uses a linear congruential generator (n * 6337 mod 10000) to produce
+ * non-sequential refs — gcd(6337, 10000) = 1 guarantees a full cycle through
+ * all 10,000 values before any collision.
+ *
+ * @example
+ * const refs = new RefMap();
+ * const ref = refs.assign("msg-uuid-abc");  // "3847"
+ * refs.assign("msg-uuid-abc");              // "3847" (idempotent)
+ * refs.resolve("3847");                     // "msg-uuid-abc"
+ * refs.clear();                             // reset on compaction
+ */
+declare class RefMap {
+    private _counter;
+    private _refToId;
+    private _idToRef;
+    /** Assign a short ref to a message ID. Returns existing ref if already assigned. */
+    assign(messageId: string): string;
+    /** Resolve a ref back to the full message UUID. Returns undefined if unknown. */
+    resolve(ref: string): string | undefined;
+    /** Clear all mappings and reset the counter. Called on context compaction. */
+    clear(): void;
+}
+
+/**
+ * RemoteRoomDataSource — HTTP-backed RoomDataSource.
+ *
+ * Implements the RoomDataSource interface by making HTTP calls to a stoop
+ * server. Used by the client-side agent runtime when connecting to remote
+ * stoops.
+ *
+ * Participant list is cached locally and updated by the agent runtime
+ * when it processes ParticipantJoined/Left events from the SSE stream.
+ */
+
+declare class RemoteRoomDataSource implements RoomDataSource {
+    private _serverUrl;
+    private _sessionToken;
+    private _roomId;
+    private _participants;
+    private _selfId;
+    private _selfName;
+    constructor(_serverUrl: string, _sessionToken: string, _roomId: string);
+    /** Set own identity for populating outgoing message stubs. */
+    setSelf(id: string, name: string): void;
+    get roomId(): string;
+    get serverUrl(): string;
+    get sessionToken(): string;
+    /** Set the initial participant list (from join response). */
+    setParticipants(participants: Participant[]): void;
+    /** Add a participant (on ParticipantJoined event). */
+    addParticipant(participant: Participant): void;
+    /** Remove a participant (on ParticipantLeft event). */
+    removeParticipant(participantId: string): void;
+    listParticipants(): Participant[];
+    getMessage(id: string): Promise<Message | null>;
+    searchMessages(query: string, limit?: number, cursor?: string | null): Promise<PaginatedResult<Message>>;
+    getMessages(limit?: number, cursor?: string | null): Promise<PaginatedResult<Message>>;
+    getEvents(category?: EventCategory | null, limit?: number, cursor?: string | null): Promise<PaginatedResult<RoomEvent>>;
+    sendMessage(content: string, replyToId?: string, image?: {
+        url: string;
+        mimeType: string;
+        sizeBytes: number;
+    } | null): Promise<Message>;
+    emitEvent(event: RoomEvent): Promise<void>;
+}
+
+/**
+ * SseMultiplexer — merges N SSE connections into one labeled event stream.
+ *
+ * Each connection is an HTTP fetch to a stoop server's /events endpoint.
+ * Events are parsed from the SSE `data:` lines and wrapped as LabeledEvents
+ * (same shape as EventMultiplexer output so EventProcessor can consume either).
+ *
+ * Connections can be added/removed while the multiplexer is running.
+ * Each connection has its own AbortController for independent lifecycle.
+ */
+
+declare class SseMultiplexer {
+    private _queue;
+    private _waiters;
+    private _connections;
+    private _closed;
+    /**
+     * Add an SSE connection to a stoop server.
+     * Starts streaming events immediately.
+     */
+    addConnection(serverUrl: string, sessionToken: string, roomName: string, roomId: string): void;
+    /** Remove a connection by room ID. */
+    removeConnection(roomId: string): void;
+    /** Close all connections and signal the iterator to finish. */
+    close(): void;
+    private _sseLoop;
+    private _push;
+    [Symbol.asyncIterator](): AsyncIterator<LabeledEvent>;
+}
+
+export { ContentPart, type EngagementMode, type EngagementStrategy, type EventDisposition, EventMultiplexer, EventProcessor, type EventProcessorOptions, type LabeledEvent, RefMap, RemoteRoomDataSource, RoomConnection, RoomDataSource, RoomResolver, type RuntimeMcpServer, type RuntimeMcpServerOptions, SseMultiplexer, StoopsEngagement, type StoopsMcpServer, ToolHandlerOptions, classifyEvent, contentPartsToString, createFullMcpServer, createRuntimeMcpServer, formatEvent, getSystemPreamble, messageRef, participantLabel };

package/dist/agent/index.js

@@ -0,0 +1,41 @@
+import {
+  EventMultiplexer,
+  EventProcessor,
+  LocalRoomDataSource,
+  RefMap,
+  RemoteRoomDataSource,
+  SseMultiplexer
+} from "../chunk-OA3CODNP.js";
+import "../chunk-5ADJGMXQ.js";
+import {
+  createFullMcpServer
+} from "../chunk-B4LBE5QS.js";
+import {
+  StoopsEngagement,
+  classifyEvent,
+  contentPartsToString,
+  createRuntimeMcpServer,
+  formatEvent,
+  getSystemPreamble,
+  messageRef,
+  participantLabel
+} from "../chunk-66EFQ2XO.js";
+import "../chunk-EPLQQF6S.js";
+export {
+  EventMultiplexer,
+  EventProcessor,
+  LocalRoomDataSource,
+  RefMap,
+  RemoteRoomDataSource,
+  SseMultiplexer,
+  StoopsEngagement,
+  classifyEvent,
+  contentPartsToString,
+  createFullMcpServer,
+  createRuntimeMcpServer,
+  formatEvent,
+  getSystemPreamble,
+  messageRef,
+  participantLabel
+};
+//# sourceMappingURL=index.js.map

package/dist/agent/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-5ADJGMXQ.js

@@ -0,0 +1,27 @@
+// src/core/types.ts
+import { z } from "zod";
+import { v4 as uuidv4 } from "uuid";
+var EventCategory = {
+  MESSAGE: "MESSAGE",
+  PRESENCE: "PRESENCE",
+  ACTIVITY: "ACTIVITY",
+  MENTION: "MENTION"
+};
+var MessageSchema = z.object({
+  id: z.string().default(() => uuidv4()),
+  room_id: z.string(),
+  sender_id: z.string(),
+  sender_name: z.string(),
+  content: z.string(),
+  reply_to_id: z.string().nullable().default(null),
+  image_url: z.string().nullable().default(null),
+  image_mime_type: z.string().nullable().default(null),
+  image_size_bytes: z.number().int().nullable().default(null),
+  timestamp: z.date().default(() => /* @__PURE__ */ new Date())
+});
+
+export {
+  EventCategory,
+  MessageSchema
+};
+//# sourceMappingURL=chunk-5ADJGMXQ.js.map

package/dist/chunk-5ADJGMXQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/types.ts"],"sourcesContent":["/** Core types for stoops — messages, participants, pagination. */\n\nimport { z } from \"zod\";\nimport { v4 as uuidv4 } from \"uuid\";\n\n// ── Event categories ─────────────────────────────────────────────────────────\n\n/**\n * The four top-level categories events are grouped under.\n *\n * Channels subscribe to one or more categories — they only receive events in\n * their subscription set. Use this to filter what an agent or observer sees:\n *\n * - MESSAGE  — chat messages and reactions (sent, edited, deleted, reacted)\n * - PRESENCE — participants joining and leaving\n * - ACTIVITY — agent activity (thinking, tool use, mode changes, compaction)\n * - MENTION  — direct @mentions delivered only to the mentioned participant\n */\nexport const EventCategory = {\n  MESSAGE:  \"MESSAGE\",\n  PRESENCE: \"PRESENCE\",\n  ACTIVITY: \"ACTIVITY\",\n  MENTION:  \"MENTION\",\n} as const;\n\nexport type EventCategory = (typeof EventCategory)[keyof typeof EventCategory];\n\n// ── Message ──────────────────────────────────────────────────────────────────\n\n/**\n * A chat message. Immutable once stored — edits and deletes are separate events.\n *\n * - `id`                — UUID, assigned by the room on creation\n * - `room_id`           — the room this message belongs to\n * - `sender_id`         — participant ID of the author\n * - `sender_name`       — display name at the time of sending (denormalized)\n * - `content`           — text body (may be empty if the message is image-only)\n * - `reply_to_id`       — if set, this message is a reply to that message ID\n * - `image_url`         — optional attached image URL\n * - `image_mime_type`   — MIME type of the attached image (e.g. \"image/jpeg\")\n * - `image_size_bytes`  — size of the image in bytes\n * - `timestamp`         — creation time (UTC)\n */\nexport const MessageSchema = z.object({\n  id: z.string().default(() => uuidv4()),\n  room_id: z.string(),\n  sender_id: z.string(),\n  sender_name: z.string(),\n  content: z.string(),\n  reply_to_id: z.string().nullable().default(null),\n  image_url: z.string().nullable().default(null),\n  image_mime_type: z.string().nullable().default(null),\n  image_size_bytes: z.number().int().nullable().default(null),\n  timestamp: z.date().default(() => new Date()),\n});\n\nexport type Message = z.infer<typeof MessageSchema>;\n\n// ── Authority ────────────────────────────────────────────────────────────────\n\n/**\n * Authority level — what a participant is allowed to do.\n *\n * - `admin`       — full control: kick, set others' modes, generate share links\n * - `participant` — can send messages, set own mode\n * - `observer`    — read-only: can catch up and search, but can't send or act\n *\n * Set on join, doesn't change during the session. Orthogonal to engagement mode.\n */\nexport type AuthorityLevel = \"admin\" | \"participant\" | \"observer\";\n\n// ── Participant ───────────────────────────────────────────────────────────────\n\n/** Whether a participant is a human or an agent. */\nexport type ParticipantType = \"human\" | \"agent\";\n\n/**\n * A participant in a room.\n *\n * - `id`         — stable unique ID across all rooms and sessions\n * - `name`       — display name (mutable — participants can rename)\n * - `status`     — current presence status (\"online\", \"offline\", etc.)\n * - `type`       — \"human\" or \"agent\"\n * - `identifier` — optional stable @-mention slug, e.g. \"my-agent\".\n *                  Unlike `name`, this never changes on rename.\n *                  Used for @-mention matching in addition to the display name.\n *                  Not all participants have one — guests and anonymous users\n *                  typically don't.\n * - `authority`  — optional authority level. Defaults to \"participant\" if unset.\n */\nexport interface Participant {\n  id: string;\n  name: string;\n  status: string;\n  type: ParticipantType;\n  identifier?: string;\n  authority?: AuthorityLevel;\n}\n\n// ── Pagination ────────────────────────────────────────────────────────────────\n\n/**\n * A page of results with a cursor for fetching the previous page.\n *\n * All paginated queries return results newest-first. Pass `next_cursor` back\n * to the same query to continue paginating backwards through history.\n *\n * - `items`       — results for this page (newest-first)\n * - `next_cursor` — pass this to get the next (older) page; null when exhausted\n * - `has_more`    — true if there are older items beyond this page\n */\nexport interface PaginatedResult<T> {\n  items: T[];\n  next_cursor: string | null;\n  has_more: boolean;\n}\n"],"mappings":";AAEA,SAAS,SAAS;AAClB,SAAS,MAAM,cAAc;AAetB,IAAM,gBAAgB;AAAA,EAC3B,SAAU;AAAA,EACV,UAAU;AAAA,EACV,UAAU;AAAA,EACV,SAAU;AACZ;AAoBO,IAAM,gBAAgB,EAAE,OAAO;AAAA,EACpC,IAAI,EAAE,OAAO,EAAE,QAAQ,MAAM,OAAO,CAAC;AAAA,EACrC,SAAS,EAAE,OAAO;AAAA,EAClB,WAAW,EAAE,OAAO;AAAA,EACpB,aAAa,EAAE,OAAO;AAAA,EACtB,SAAS,EAAE,OAAO;AAAA,EAClB,aAAa,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,IAAI;AAAA,EAC/C,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,IAAI;AAAA,EAC7C,iBAAiB,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,IAAI;AAAA,EACnD,kBAAkB,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,IAAI;AAAA,EAC1D,WAAW,EAAE,KAAK,EAAE,QAAQ,MAAM,oBAAI,KAAK,CAAC;AAC9C,CAAC;","names":[]}