stoops 0.1.0 → 0.2.0

package/dist/chunk-SS5NGUJM.js

@@ -0,0 +1,968 @@
+import {
+  EventCategory
+} from "./chunk-5ADJGMXQ.js";
+import {
+  StoopsEngagement,
+  buildCatchUpLines,
+  formatEvent
+} from "./chunk-BLGV3QN4.js";
+import {
+  createEvent
+} from "./chunk-HQS7HBZR.js";
+
+// src/agent/room-data-source.ts
+var LocalRoomDataSource = class {
+  constructor(_room, _channel) {
+    this._room = _room;
+    this._channel = _channel;
+  }
+  get roomId() {
+    return this._room.roomId;
+  }
+  /** Direct access to the underlying Room (for backward compat / internal use). */
+  get room() {
+    return this._room;
+  }
+  /** Direct access to the underlying Channel (for backward compat / internal use). */
+  get channel() {
+    return this._channel;
+  }
+  listParticipants() {
+    return this._room.listParticipants();
+  }
+  async getMessage(id) {
+    return this._room.getMessage(id);
+  }
+  async searchMessages(query, limit = 10, cursor = null) {
+    return this._room.searchMessages(query, limit, cursor);
+  }
+  async getMessages(limit = 30, cursor = null) {
+    return this._room.listMessages(limit, cursor);
+  }
+  async getEvents(category = null, limit = 50, cursor = null) {
+    return this._room.listEvents(category, limit, cursor);
+  }
+  async sendMessage(content, replyToId, image) {
+    return this._channel.sendMessage(content, replyToId, image ?? void 0);
+  }
+  async emitEvent(event) {
+    await this._channel.emit(event);
+  }
+};
+
+// src/agent/multiplexer.ts
+var EventMultiplexer = class {
+  _queue = [];
+  _waiters = [];
+  _channels = /* @__PURE__ */ new Map();
+  _closed = false;
+  _closeResolve = null;
+  addChannel(roomId, roomName, channel) {
+    if (this._channels.has(roomId) || this._closed) return;
+    const abortController = new AbortController();
+    const loopPromise = this._listenLoop(roomId, roomName, channel, abortController.signal);
+    this._channels.set(roomId, { channel, roomName, abortController, loopPromise });
+  }
+  removeChannel(roomId) {
+    const entry = this._channels.get(roomId);
+    if (!entry) return;
+    entry.abortController.abort();
+    this._channels.delete(roomId);
+  }
+  close() {
+    this._closed = true;
+    for (const [, entry] of this._channels) {
+      entry.abortController.abort();
+    }
+    this._channels.clear();
+    if (this._closeResolve) {
+      this._closeResolve();
+      this._closeResolve = null;
+    }
+    for (const waiter of this._waiters) {
+      waiter.resolve(null);
+    }
+    this._waiters = [];
+  }
+  async _listenLoop(roomId, roomName, channel, signal) {
+    try {
+      for await (const event of channel) {
+        if (signal.aborted) break;
+        this._push({ roomId, roomName, event });
+      }
+    } catch {
+    }
+  }
+  _push(labeled) {
+    if (this._closed) return;
+    if (this._waiters.length > 0) {
+      const waiter = this._waiters.shift();
+      waiter.resolve(labeled);
+    } else {
+      this._queue.push(labeled);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this._queue.length > 0) {
+          return Promise.resolve({ value: this._queue.shift(), done: false });
+        }
+        if (this._closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve) => {
+          this._waiters.push({
+            resolve: (value) => {
+              if (this._closed || value === null) {
+                resolve({ value: void 0, done: true });
+              } else {
+                resolve({ value, done: false });
+              }
+            }
+          });
+        });
+      }
+    };
+  }
+};
+
+// src/agent/ref-map.ts
+var RefMap = class {
+  _counter = Math.floor(Math.random() * 1e4);
+  _refToId = /* @__PURE__ */ new Map();
+  _idToRef = /* @__PURE__ */ new Map();
+  /** Assign a short ref to a message ID. Returns existing ref if already assigned. */
+  assign(messageId) {
+    const existing = this._idToRef.get(messageId);
+    if (existing) return existing;
+    const ref = String(this._counter * 6337 % 1e4).padStart(4, "0");
+    this._counter++;
+    if (this._refToId.has(ref)) {
+      const hex = messageId.replace(/-/g, "");
+      let fallback = null;
+      for (let i = 0; i <= hex.length - 4; i++) {
+        const candidate = hex.slice(i, i + 4);
+        if (!this._refToId.has(candidate)) {
+          fallback = candidate;
+          break;
+        }
+      }
+      if (!fallback) fallback = messageId.slice(0, 8);
+      this._refToId.set(fallback, messageId);
+      this._idToRef.set(messageId, fallback);
+      return fallback;
+    }
+    this._refToId.set(ref, messageId);
+    this._idToRef.set(messageId, ref);
+    return ref;
+  }
+  /** Resolve a ref back to the full message UUID. Returns undefined if unknown. */
+  resolve(ref) {
+    return this._refToId.get(ref);
+  }
+  /** Clear all mappings and reset the counter. Called on context compaction. */
+  clear() {
+    this._refToId.clear();
+    this._idToRef.clear();
+    this._counter = Math.floor(Math.random() * 1e4);
+  }
+};
+
+// src/agent/connection-registry.ts
+var ConnectionRegistry = class {
+  _connections = /* @__PURE__ */ new Map();
+  _nameToId = /* @__PURE__ */ new Map();
+  _identifierToId = /* @__PURE__ */ new Map();
+  _lastMessages = /* @__PURE__ */ new Map();
+  add(roomId, conn) {
+    this._connections.set(roomId, conn);
+    this._nameToId.set(conn.name, roomId);
+    if (conn.identifier) this._identifierToId.set(conn.identifier, roomId);
+  }
+  remove(roomId) {
+    const conn = this._connections.get(roomId);
+    if (!conn) return void 0;
+    this._nameToId.delete(conn.name);
+    if (conn.identifier) this._identifierToId.delete(conn.identifier);
+    this._connections.delete(roomId);
+    this._lastMessages.delete(roomId);
+    return conn;
+  }
+  get(roomId) {
+    return this._connections.get(roomId);
+  }
+  has(roomId) {
+    return this._connections.has(roomId);
+  }
+  resolve(roomName) {
+    const roomId = this._nameToId.get(roomName);
+    if (roomId) return this._connections.get(roomId) ?? null;
+    const idFromIdentifier = this._identifierToId.get(roomName);
+    if (idFromIdentifier) return this._connections.get(idFromIdentifier) ?? null;
+    return this._connections.get(roomName) ?? null;
+  }
+  listAll(getModeForRoom) {
+    return [...this._connections.entries()].map(([roomId, conn]) => ({
+      name: conn.name,
+      roomId,
+      ...conn.identifier ? { identifier: conn.identifier } : {},
+      mode: getModeForRoom(roomId),
+      participantCount: conn.dataSource.listParticipants().length,
+      ...this._lastMessages.has(roomId) ? { lastMessage: this._lastMessages.get(roomId) } : {}
+    }));
+  }
+  setLastMessage(roomId, text) {
+    this._lastMessages.set(roomId, text);
+  }
+  entries() {
+    return this._connections.entries();
+  }
+  get size() {
+    return this._connections.size;
+  }
+  clear() {
+    this._connections.clear();
+    this._nameToId.clear();
+    this._identifierToId.clear();
+    this._lastMessages.clear();
+  }
+  values() {
+    return this._connections.values();
+  }
+};
+
+// src/agent/content-buffer.ts
+var ContentBuffer = class {
+  _buffer = /* @__PURE__ */ new Map();
+  push(roomId, item) {
+    const buf = this._buffer.get(roomId) ?? [];
+    buf.push(item);
+    this._buffer.set(roomId, buf);
+  }
+  flush(roomId) {
+    const items = this._buffer.get(roomId) ?? [];
+    this._buffer.delete(roomId);
+    return items;
+  }
+  delete(roomId) {
+    this._buffer.delete(roomId);
+  }
+  clear() {
+    this._buffer.clear();
+  }
+};
+
+// src/agent/event-tracker.ts
+var EventTracker = class {
+  _processedIds = /* @__PURE__ */ new Set();
+  _deliveredIds = /* @__PURE__ */ new Set();
+  /** Returns true if this event was already processed (and adds it if not). */
+  isDuplicate(id) {
+    if (this._processedIds.has(id)) return true;
+    this._processedIds.add(id);
+    if (this._processedIds.size > 500) {
+      const arr = [...this._processedIds];
+      this._processedIds = new Set(arr.slice(arr.length >> 1));
+    }
+    return false;
+  }
+  isDelivered(id) {
+    return this._deliveredIds.has(id);
+  }
+  markDelivered(id) {
+    this._deliveredIds.add(id);
+  }
+  markManyDelivered(ids) {
+    for (const id of ids) {
+      this._deliveredIds.add(id);
+      this._processedIds.add(id);
+    }
+  }
+  clearDelivered() {
+    this._deliveredIds.clear();
+  }
+  clearAll() {
+    this._processedIds.clear();
+    this._deliveredIds.clear();
+  }
+};
+
+// src/agent/event-processor.ts
+function mergeParts(arrays) {
+  const result = [];
+  for (let i = 0; i < arrays.length; i++) {
+    if (i > 0) result.push({ type: "text", text: "\n" });
+    result.push(...arrays[i]);
+  }
+  return result;
+}
+var EventProcessor = class {
+  _participantId;
+  _participantName;
+  _options;
+  _engagement;
+  _deliver = null;
+  _multiplexer = new EventMultiplexer();
+  _registry = new ConnectionRegistry();
+  _buffer = new ContentBuffer();
+  _tracker = new EventTracker();
+  _processing = false;
+  _eventQueue = [];
+  _stopped = false;
+  _currentContextRoomId = null;
+  _log = [];
+  _refMap = new RefMap();
+  _injectBuffer = [];
+  /** Per-room participant IDs (for multi-server CLI agents where each server assigns a different ID). */
+  _roomSelfIds = /* @__PURE__ */ new Map();
+  constructor(participantId, participantName, options = {}) {
+    this._participantId = participantId;
+    this._participantName = participantName;
+    this._options = options;
+    this._engagement = options.engagement ?? new StoopsEngagement(options.defaultMode ?? "everyone", options.personParticipantId);
+  }
+  // ── Public accessors ────────────────────────────────────────────────────────
+  get participantId() {
+    return this._participantId;
+  }
+  set participantId(id) {
+    this._participantId = id;
+  }
+  get participantName() {
+    return this._participantName;
+  }
+  get currentContextRoomId() {
+    return this._currentContextRoomId;
+  }
+  /** Set a room-specific participant ID (for multi-server CLI agents). */
+  setRoomParticipantId(roomId, participantId) {
+    this._roomSelfIds.set(roomId, participantId);
+  }
+  /** Get the effective selfId for a room — room-specific if set, otherwise the global one. */
+  getSelfIdForRoom(roomId) {
+    return this._roomSelfIds.get(roomId) ?? this._participantId;
+  }
+  // ── Ref map (consumer calls these for MCP tools) ────────────────────────────
+  assignRef(messageId) {
+    return this._refMap.assign(messageId);
+  }
+  resolveRef(ref) {
+    return this._refMap.resolve(ref);
+  }
+  // ── Seen-event cache (consumer calls these for catch_up MCP tool) ───────────
+  isEventSeen(eventId) {
+    return this._tracker.isDelivered(eventId);
+  }
+  markEventsSeen(eventIds) {
+    this._tracker.markManyDelivered(eventIds);
+  }
+  // ── Inject buffer (LangGraph mid-loop event injection) ──────────────────────
+  drainInjectBuffer() {
+    if (this._injectBuffer.length === 0) return null;
+    const drained = this._injectBuffer;
+    this._injectBuffer = [];
+    return drained;
+  }
+  // ── Consumer hooks (called by consumer during/after delivery) ────────────────
+  /**
+   * Called by the consumer when context was compacted.
+   * Clears seen-event cache and ref map so catch_up returns full history.
+   */
+  onContextCompacted() {
+    this._tracker.clearDelivered();
+    this._refMap.clear();
+  }
+  /**
+   * Called by the consumer when a tool call starts or completes.
+   * Routes ToolUseEvent to the room that triggered the current evaluation.
+   */
+  emitToolUse(toolName, status) {
+    if (this._currentContextRoomId) {
+      const conn = this._registry.get(this._currentContextRoomId);
+      if (conn) {
+        const event = createEvent({
+          type: "ToolUse",
+          category: "ACTIVITY",
+          room_id: this._currentContextRoomId,
+          participant_id: this._participantId,
+          tool_name: toolName,
+          status
+        });
+        const emitter = conn.dataSource.emitEvent ? (e) => conn.dataSource.emitEvent(e) : conn.channel ? (e) => conn.channel.emit(e) : null;
+        if (!emitter) return;
+        emitter(event).catch(() => {
+        });
+      }
+    }
+  }
+  // ── RoomResolver implementation ─────────────────────────────────────────────
+  resolve(roomName) {
+    return this._registry.resolve(roomName);
+  }
+  listAll() {
+    return this._registry.listAll((roomId) => this.getModeForRoom(roomId));
+  }
+  // ── Room connection management ──────────────────────────────────────────────
+  async connectRoom(room, roomName, mode, identifier) {
+    if (this._registry.has(room.roomId)) return;
+    const channel = await room.connect(this._participantId, this._participantName, {
+      type: "agent",
+      identifier: this._options.selfIdentifier,
+      subscribe: /* @__PURE__ */ new Set([
+        EventCategory.MESSAGE,
+        EventCategory.PRESENCE,
+        EventCategory.ACTIVITY,
+        EventCategory.MENTION
+      ]),
+      silent: true
+    });
+    const dataSource = new LocalRoomDataSource(room, channel);
+    const conn = { dataSource, room, channel, name: roomName, identifier };
+    this._registry.add(room.roomId, conn);
+    if (mode) this._engagement.setMode?.(room.roomId, mode);
+    const initialMode = this.getModeForRoom(room.roomId);
+    channel.emit(createEvent({
+      type: "Activity",
+      category: "ACTIVITY",
+      room_id: room.roomId,
+      participant_id: this._participantId,
+      action: "mode_changed",
+      detail: { mode: initialMode }
+    })).catch(() => {
+    });
+    this._multiplexer.addChannel(room.roomId, roomName, channel);
+  }
+  /**
+   * 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, roomName, mode, identifier) {
+    if (this._registry.has(dataSource.roomId)) return;
+    const conn = {
+      dataSource,
+      name: roomName,
+      identifier
+    };
+    this._registry.add(dataSource.roomId, conn);
+    if (mode) this._engagement.setMode?.(dataSource.roomId, mode);
+  }
+  /** Disconnect a remote room (by room ID). */
+  disconnectRemoteRoom(roomId) {
+    if (!this._registry.has(roomId)) return;
+    this._registry.remove(roomId);
+    this._engagement.onRoomDisconnected?.(roomId);
+    this._buffer.delete(roomId);
+    this._roomSelfIds.delete(roomId);
+  }
+  async disconnectRoom(roomId) {
+    const conn = this._registry.get(roomId);
+    if (!conn) return;
+    this._multiplexer.removeChannel(roomId);
+    await conn.channel?.disconnect(true);
+    this._registry.remove(roomId);
+    this._engagement.onRoomDisconnected?.(roomId);
+    this._buffer.delete(roomId);
+    this._roomSelfIds.delete(roomId);
+  }
+  // ── Mode management ─────────────────────────────────────────────────────────
+  getModeForRoom(roomId) {
+    return this._engagement.getMode?.(roomId) ?? "everyone";
+  }
+  setModeForRoom(roomId, mode, notifyAgent = true) {
+    this._engagement.setMode?.(roomId, mode);
+    const conn = this._registry.get(roomId);
+    if (conn) {
+      conn.channel?.emit(createEvent({
+        type: "Activity",
+        category: "ACTIVITY",
+        room_id: roomId,
+        participant_id: this._participantId,
+        action: "mode_changed",
+        detail: { mode }
+      }))?.catch(() => {
+      });
+      this._options.onModeChange?.(roomId, conn.name, mode);
+    }
+  }
+  // ── Log ─────────────────────────────────────────────────────────────────────
+  getLog() {
+    return this._log;
+  }
+  // ── Main event loop ─────────────────────────────────────────────────────────
+  /**
+   * 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.
+   */
+  async run(deliver, eventSource, initialParts) {
+    this._deliver = deliver;
+    if (initialParts && initialParts.length > 0) {
+      await this._processRaw(
+        initialParts,
+        this._registry.values().next().value?.dataSource.roomId ?? null
+      );
+    }
+    const source = eventSource ?? this._multiplexer;
+    for await (const labeled of source) {
+      if (this._stopped) break;
+      await this._handleLabeledEvent(labeled);
+    }
+  }
+  async stop() {
+    this._stopped = true;
+    this._multiplexer.close();
+    await Promise.allSettled(
+      [...this._registry.values()].filter((conn) => conn.channel).map((conn) => conn.channel.disconnect(true))
+    );
+    this._registry.clear();
+    this._buffer.clear();
+    this._tracker.clearAll();
+    this._refMap.clear();
+    this._roomSelfIds.clear();
+    this._deliver = null;
+  }
+  // ── Full catch-up (kept for app-path consumers) ────────────────────────────
+  async buildFullCatchUp() {
+    return this._buildFullCatchUp();
+  }
+  async _buildFullCatchUp() {
+    const sections = ["[Session context \u2014 loaded automatically]"];
+    const nameCounts = /* @__PURE__ */ new Map();
+    for (const [, c] of this._registry.entries()) nameCounts.set(c.name, (nameCounts.get(c.name) ?? 0) + 1);
+    for (const [roomId, conn] of this._registry.entries()) {
+      const mode = this.getModeForRoom(roomId);
+      const isDuplicate = (nameCounts.get(conn.name) ?? 0) > 1;
+      const ref = isDuplicate ? roomId : conn.identifier ?? roomId;
+      sections.push(`
+${conn.name} [${ref}] \u2014 ${mode}`);
+      if (mode.startsWith("standby-")) {
+        sections.push("  (standby \u2014 @mentions only)");
+      } else {
+        const participants = conn.dataSource.listParticipants().filter((p) => p.id !== this._participantId);
+        if (participants.length > 0) {
+          const pList = participants.map((p) => `${p.type} ${p.name}`).join(", ");
+          sections.push(`Participants: ${pList}`);
+        }
+        const lines = await buildCatchUpLines(conn, {
+          isEventSeen: (id) => this._tracker.isDelivered(id),
+          markEventsSeen: (ids) => {
+            this._tracker.markManyDelivered(ids);
+          },
+          assignRef: (id) => this.assignRef(id)
+        });
+        if (lines.length > 0) {
+          for (const line of lines) sections.push(`  ${line}`);
+        } else {
+          sections.push("  (nothing new)");
+        }
+      }
+    }
+    sections.push(
+      "\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "Continue immediately if you see fit, or explore further in any active room."
+    );
+    return [{ type: "text", text: sections.join("\n") }];
+  }
+  // ── Event handling ──────────────────────────────────────────────────────────
+  async _handleLabeledEvent(labeled) {
+    if (this._tracker.isDuplicate(labeled.event.id)) return;
+    const { roomId, event } = labeled;
+    const conn = this._registry.get(roomId);
+    const senderLookupId = event.type === "Mentioned" ? event.message.sender_id : event.participant_id;
+    const sender = conn?.dataSource.listParticipants().find((p) => p.id === senderLookupId);
+    const senderType = sender?.type ?? "human";
+    const selfId = this.getSelfIdForRoom(roomId);
+    const disposition = this._engagement.classify(event, roomId, selfId, senderType, senderLookupId);
+    if (disposition === "drop") return;
+    this._tracker.markDelivered(event.id);
+    if (disposition === "content") {
+      this._buffer.push(roomId, { event, roomId, roomName: labeled.roomName });
+      return;
+    }
+    this._log.push(event);
+    if (this._processing) {
+      this._eventQueue.push(labeled);
+      this._formatForLLM(event, roomId, labeled.roomName).then((parts) => {
+        if (parts) this._injectBuffer.push(parts);
+      }).catch((err) => {
+        console.error(`[${this._participantName}] inject buffer format error:`, err);
+      });
+      return;
+    }
+    await this._processTrigger(labeled);
+    while (this._eventQueue.length > 0) {
+      const queued = this._eventQueue;
+      this._eventQueue = [];
+      const formatted = [];
+      let batchContextRoom = null;
+      const roomsProcessed = /* @__PURE__ */ new Set();
+      for (const qe of queued) {
+        const qConn = this._registry.get(qe.roomId);
+        const qSenderLookupId = qe.event.type === "Mentioned" ? qe.event.message.sender_id : qe.event.participant_id;
+        const qSender = qConn?.dataSource.listParticipants().find((p) => p.id === qSenderLookupId);
+        const qSenderType = qSender?.type ?? "human";
+        const qSelfId = this.getSelfIdForRoom(qe.roomId);
+        const qDisposition = this._engagement.classify(qe.event, qe.roomId, qSelfId, qSenderType, qSenderLookupId);
+        if (qDisposition === "drop") continue;
+        if (!roomsProcessed.has(qe.roomId)) {
+          roomsProcessed.add(qe.roomId);
+          const buffered = this._buffer.flush(qe.roomId);
+          for (const item of buffered) {
+            const parts2 = await this._formatForLLM(item.event, item.roomId, item.roomName);
+            if (parts2) {
+              formatted.push(parts2);
+              if (!batchContextRoom) batchContextRoom = qe.roomId;
+            }
+          }
+        }
+        this._log.push(qe.event);
+        const parts = await this._formatForLLM(qe.event, qe.roomId, qe.roomName);
+        if (parts) {
+          formatted.push(parts);
+          if (!batchContextRoom) batchContextRoom = qe.roomId;
+        }
+      }
+      if (formatted.length > 0) {
+        await this._processRaw(mergeParts(formatted), batchContextRoom);
+      }
+    }
+  }
+  async _processTrigger(labeled) {
+    const { roomId, roomName, event } = labeled;
+    const buffered = this._buffer.flush(roomId);
+    const contentPartArrays = [];
+    for (const item of buffered) {
+      const parts = await this._formatForLLM(item.event, item.roomId, item.roomName);
+      if (parts) contentPartArrays.push(parts);
+    }
+    if (event.type === "MessageSent") {
+      const conn = this._registry.get(roomId);
+      const senderLabel = conn?.dataSource.listParticipants().find((p) => p.id === event.message.sender_id)?.name ?? event.message.sender_name;
+      const contentPreview = event.message.content.length > 60 ? event.message.content.slice(0, 57) + "..." : event.message.content;
+      const preview = event.message.image_url && !event.message.content.trim() ? "sent an image" : contentPreview;
+      this._registry.setLastMessage(roomId, `${senderLabel}: ${preview}`);
+    }
+    const triggerParts = await this._formatForLLM(event, roomId, roomName);
+    if (!triggerParts && contentPartArrays.length === 0) return;
+    const mergedParts = mergeParts([...contentPartArrays, ...triggerParts ? [triggerParts] : []]);
+    await this._processRaw(mergedParts, roomId);
+  }
+  // ── Formatting ──────────────────────────────────────────────────────────────
+  _resolveParticipantForRoom(roomId) {
+    return (id) => {
+      const conn = this._registry.get(roomId);
+      if (!conn) return null;
+      return conn.dataSource.listParticipants().find((p) => p.id === id) ?? null;
+    };
+  }
+  async _resolveReplyContext(event, roomId) {
+    if (event.type !== "MessageSent" && event.type !== "Mentioned") return null;
+    const msg = event.message;
+    if (!msg.reply_to_id) return null;
+    const conn = this._registry.get(roomId);
+    if (!conn) return null;
+    const repliedTo = await conn.dataSource.getMessage(msg.reply_to_id);
+    return repliedTo ? { senderName: repliedTo.sender_name, content: repliedTo.content } : null;
+  }
+  async _resolveReactionTarget(event, roomId) {
+    if (event.type !== "ReactionAdded") return null;
+    const conn = this._registry.get(roomId);
+    if (!conn) return null;
+    const target = await conn.dataSource.getMessage(event.message_id);
+    if (!target) return null;
+    return {
+      senderName: target.sender_name,
+      content: target.content,
+      isSelf: target.sender_id === this._participantId
+    };
+  }
+  async _formatForLLM(event, roomId, roomName) {
+    const mode = this.getModeForRoom(roomId);
+    const label = mode !== "everyone" ? `${roomName} \u2014 ${mode}` : roomName;
+    const replyContext = await this._resolveReplyContext(event, roomId);
+    const reactionTarget = await this._resolveReactionTarget(event, roomId);
+    return formatEvent(
+      event,
+      this._resolveParticipantForRoom(roomId),
+      replyContext,
+      label,
+      reactionTarget,
+      (id) => this.assignRef(id)
+    );
+  }
+  // ── Delivery ────────────────────────────────────────────────────────────────
+  async _processRaw(parts, contextRoomId) {
+    if (this._options.preQuery && !await this._options.preQuery()) {
+      return;
+    }
+    this._processing = true;
+    this._currentContextRoomId = contextRoomId;
+    try {
+      if (!this._deliver) return;
+      await this._deliver(parts);
+    } catch (err) {
+      console.error(`[${this._participantName}] error:`, err);
+    } finally {
+      this._currentContextRoomId = null;
+      this._processing = false;
+    }
+  }
+};
+
+// src/agent/remote-room-data-source.ts
+var RemoteRoomDataSource = class {
+  constructor(_serverUrl, _sessionToken, _roomId) {
+    this._serverUrl = _serverUrl;
+    this._sessionToken = _sessionToken;
+    this._roomId = _roomId;
+  }
+  _participants = [];
+  _selfId = "";
+  _selfName = "";
+  /** Set own identity for populating outgoing message stubs. */
+  setSelf(id, name) {
+    this._selfId = id;
+    this._selfName = name;
+  }
+  get roomId() {
+    return this._roomId;
+  }
+  get serverUrl() {
+    return this._serverUrl;
+  }
+  get sessionToken() {
+    return this._sessionToken;
+  }
+  // ── Participant cache ─────────────────────────────────────────────────────
+  /** Set the initial participant list (from join response). */
+  setParticipants(participants) {
+    this._participants = [...participants];
+  }
+  /** Add a participant (on ParticipantJoined event). */
+  addParticipant(participant) {
+    this._participants = this._participants.filter((p) => p.id !== participant.id);
+    this._participants.push(participant);
+  }
+  /** Remove a participant (on ParticipantLeft event). */
+  removeParticipant(participantId) {
+    this._participants = this._participants.filter((p) => p.id !== participantId);
+  }
+  listParticipants() {
+    return [...this._participants];
+  }
+  // ── HTTP-backed data access ───────────────────────────────────────────────
+  async getMessage(id) {
+    try {
+      const res = await fetch(
+        `${this._serverUrl}/message/${encodeURIComponent(id)}?token=${this._sessionToken}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      return data.message;
+    } catch {
+      return null;
+    }
+  }
+  async searchMessages(query, limit = 10, cursor = null) {
+    const params = new URLSearchParams({ token: this._sessionToken, query, count: String(limit) });
+    if (cursor) params.set("cursor", cursor);
+    try {
+      const res = await fetch(`${this._serverUrl}/search?${params}`);
+      if (!res.ok) return { items: [], has_more: false, next_cursor: null };
+      return await res.json();
+    } catch {
+      return { items: [], has_more: false, next_cursor: null };
+    }
+  }
+  async getMessages(limit = 30, cursor = null) {
+    const params = new URLSearchParams({ token: this._sessionToken, count: String(limit) });
+    if (cursor) params.set("cursor", cursor);
+    try {
+      const res = await fetch(`${this._serverUrl}/messages?${params}`);
+      if (!res.ok) return { items: [], has_more: false, next_cursor: null };
+      return await res.json();
+    } catch {
+      return { items: [], has_more: false, next_cursor: null };
+    }
+  }
+  async getEvents(category = null, limit = 50, cursor = null) {
+    const params = new URLSearchParams({ token: this._sessionToken, count: String(limit) });
+    if (category) params.set("category", category);
+    if (cursor) params.set("cursor", cursor);
+    try {
+      const res = await fetch(`${this._serverUrl}/events/history?${params}`);
+      if (!res.ok) return { items: [], has_more: false, next_cursor: null };
+      return await res.json();
+    } catch {
+      return { items: [], has_more: false, next_cursor: null };
+    }
+  }
+  async sendMessage(content, replyToId, image) {
+    const body = { token: this._sessionToken, content };
+    if (replyToId) body.replyTo = replyToId;
+    if (image) body.image = image;
+    const res = await fetch(`${this._serverUrl}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Failed to send message: ${err}`);
+    }
+    const data = await res.json();
+    return {
+      id: data.messageId,
+      room_id: this._roomId,
+      sender_id: this._selfId,
+      sender_name: this._selfName,
+      content,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  async emitEvent(event) {
+    const res = await fetch(`${this._serverUrl}/event`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token: this._sessionToken, event })
+    });
+    if (!res.ok) {
+    }
+  }
+};
+
+// src/agent/sse-multiplexer.ts
+var SseMultiplexer = class {
+  _queue = [];
+  _waiters = [];
+  _connections = /* @__PURE__ */ new Map();
+  _closed = false;
+  /**
+   * Add an SSE connection to a stoop server.
+   * Starts streaming events immediately.
+   */
+  addConnection(serverUrl, sessionToken, roomName, roomId) {
+    if (this._connections.has(roomId) || this._closed) return;
+    const abortController = new AbortController();
+    const loopPromise = this._sseLoop(serverUrl, sessionToken, roomName, roomId, abortController.signal);
+    this._connections.set(roomId, { serverUrl, sessionToken, roomName, roomId, abortController, loopPromise });
+  }
+  /** Remove a connection by room ID. */
+  removeConnection(roomId) {
+    const entry = this._connections.get(roomId);
+    if (!entry) return;
+    entry.abortController.abort();
+    this._connections.delete(roomId);
+  }
+  /** Close all connections and signal the iterator to finish. */
+  close() {
+    this._closed = true;
+    for (const [, entry] of this._connections) {
+      entry.abortController.abort();
+    }
+    this._connections.clear();
+    for (const waiter of this._waiters) {
+      waiter.resolve(null);
+    }
+    this._waiters = [];
+  }
+  async _sseLoop(serverUrl, sessionToken, roomName, roomId, signal) {
+    const INITIAL_BACKOFF = 1e3;
+    const MAX_BACKOFF = 3e4;
+    let backoff = INITIAL_BACKOFF;
+    while (!signal.aborted && !this._closed) {
+      try {
+        const res = await fetch(`${serverUrl}/events`, {
+          method: "POST",
+          headers: {
+            Accept: "text/event-stream",
+            Authorization: `Bearer ${sessionToken}`
+          },
+          signal
+        });
+        if (!res.ok || !res.body) {
+          throw new Error(`SSE connect failed: ${res.status}`);
+        }
+        backoff = INITIAL_BACKOFF;
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (!signal.aborted) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const parts = buffer.split("\n\n");
+          buffer = parts.pop();
+          for (const part of parts) {
+            const dataLine = part.split("\n").find((l) => l.startsWith("data: "));
+            if (!dataLine) continue;
+            try {
+              const event = JSON.parse(dataLine.slice(6));
+              this._push({ roomId, roomName, event });
+            } catch {
+            }
+          }
+        }
+      } catch (err) {
+        if (signal.aborted) break;
+      }
+      if (!signal.aborted && !this._closed) {
+        await new Promise((r) => setTimeout(r, backoff));
+        backoff = Math.min(backoff * 2, MAX_BACKOFF);
+      }
+    }
+  }
+  _push(labeled) {
+    if (this._closed) return;
+    if (this._waiters.length > 0) {
+      const waiter = this._waiters.shift();
+      waiter.resolve(labeled);
+    } else {
+      this._queue.push(labeled);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this._queue.length > 0) {
+          return Promise.resolve({ value: this._queue.shift(), done: false });
+        }
+        if (this._closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve) => {
+          this._waiters.push({
+            resolve: (value) => {
+              if (this._closed || value === null) {
+                resolve({ value: void 0, done: true });
+              } else {
+                resolve({ value, done: false });
+              }
+            }
+          });
+        });
+      }
+    };
+  }
+};
+
+export {
+  LocalRoomDataSource,
+  EventMultiplexer,
+  RefMap,
+  EventProcessor,
+  RemoteRoomDataSource,
+  SseMultiplexer
+};
+//# sourceMappingURL=chunk-SS5NGUJM.js.map