stoops 0.1.0 → 0.2.0

package/dist/chunk-BLGV3QN4.js

@@ -0,0 +1,692 @@
+import {
+  EVENT_ROLE
+} from "./chunk-HQS7HBZR.js";
+
+// src/agent/prompts.ts
+var MODE_DESCRIPTIONS = {
+  "everyone": "All messages are pushed to you.",
+  "people": "Human messages are pushed to you. Agent messages are delivered as context.",
+  "agents": "Agent messages are pushed to you. Human messages are delivered as context.",
+  "me": "Only your person's messages are pushed to you. Others are delivered as context.",
+  "standby-everyone": "Only @mentions are pushed to you.",
+  "standby-people": "Only human @mentions are pushed to you.",
+  "standby-agents": "Only agent @mentions are pushed to you.",
+  "standby-me": "Only your person's @mentions are pushed to you."
+};
+var SYSTEM_PREAMBLE = `You are a participant in group chats. You may be connected to multiple rooms at once \u2014 events from all of them flow to you, labeled with the room name.
+
+## How this works
+- Messages appear labeled: "[Design Room] [human] Alice: hey everyone"
+- Replies: "[Design Room] [human] Alice (replying to [human] Bob): good point"
+- @mentions: "\u26A1 [Design Room] [human] Alice mentioned you: @Bob what do you think?"
+- All your tools require a room name as the first parameter
+- Rooms have a stable \`identifier\` (e.g., design-room) that doesn't change even if renamed
+- Message references like #3847 are internal tool labels only. Never include them in messages \u2014 participants don't see them.
+
+## Your memory
+You have no persistent memory between sessions. Each time you start, you're waking up fresh. Your conversations are still there \u2014 read them via tools.
+
+If you lack context for something someone references, say so directly \u2014 don't invent explanations.
+
+## Your person
+You were created by someone \u2014 that's your person. You know their participant ID from your identity block below. Their messages carry more weight: they're the one who set you up and knows what they want from you. In group rooms, stay tuned to them even when others are talking.
+
+When someone who isn't your person addresses you in a group room, respond if it's useful and natural. But don't lose track of who you're ultimately here for.
+
+## Engagement modes
+Each room has a mode controlling when you evaluate and respond:
+- everyone \u2014 all messages trigger evaluation. Respond when you have something genuine to add.
+- people \u2014 any human message triggers you. Agent messages are buffered as context.
+- agents \u2014 any agent message triggers you. Human messages are buffered as context.
+- me \u2014 only your person's messages trigger evaluation. Read everything else quietly.
+- standby-everyone \u2014 only @mentions wake you. Stay silent unless directly called, by anyone.
+- standby-people \u2014 only human @mentions wake you.
+- standby-agents \u2014 only agent @mentions wake you.
+- standby-me \u2014 only your person's @mention wakes you.
+
+Non-everyone rooms show the mode in the room label (e.g., "[Design Room \u2014 people]").`;
+function getSystemPreamble(identifier, personParticipantId) {
+  const lines = [];
+  if (identifier) lines.push(`Your identifier: @${identifier}`);
+  if (personParticipantId) lines.push(`Your person's participant ID: ${personParticipantId}`);
+  if (identifier) lines.push(`Recognize other participants by their identifier. Address them by their current display name.`);
+  const identityBlock = lines.length > 0 ? `## Your identity
+${lines.join("\n")}
+
+` : "";
+  return identityBlock + SYSTEM_PREAMBLE;
+}
+function messageRef(messageId) {
+  return messageId.replace(/-/g, "").slice(0, 4);
+}
+function participantLabel(p, fallback) {
+  if (!p) return fallback ?? "someone";
+  return `[${p.type}] ${p.name}`;
+}
+function resolveName(resolveParticipant, id, fallback) {
+  return resolveParticipant(id)?.name ?? fallback ?? "someone";
+}
+function formatTimestamp(date) {
+  return date.toISOString().slice(11, 19);
+}
+function contentPartsToString(parts) {
+  return parts.map((p) => p.type === "text" ? p.text : ` [image: ${p.url}]`).join("");
+}
+function visualLength(s) {
+  if (typeof Intl !== "undefined" && Intl.Segmenter) {
+    const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+    let count = 0;
+    for (const _ of segmenter.segment(s)) count++;
+    return count;
+  }
+  return [...s].length;
+}
+function formatMultilineContent(content, roomLabel, prefix) {
+  const lines = content.split("\n");
+  if (lines.length <= 1) return content;
+  const continuation = roomLabel ? `[${roomLabel}] ` : "";
+  const pad = " ".repeat(visualLength(prefix));
+  return lines[0] + "\n" + lines.slice(1).map((l) => `${pad}${continuation}${l}`).join("\n");
+}
+function formatEvent(event, resolveParticipant, replyContext, roomLabel, reactionTarget, assignRef) {
+  const r = roomLabel ? `[${roomLabel}] ` : "";
+  const ts = `[${formatTimestamp("timestamp" in event ? new Date(event.timestamp) : /* @__PURE__ */ new Date())}] `;
+  const mkRef = (id) => `#${assignRef ? assignRef(id) : messageRef(id)}`;
+  switch (event.type) {
+    case "MessageSent": {
+      const msg = event.message;
+      const name = resolveName(resolveParticipant, msg.sender_id, msg.sender_name);
+      const ref = mkRef(msg.id);
+      const linePrefix = `${ts}${ref} ${r}`;
+      let text;
+      if (msg.reply_to_id && replyContext) {
+        const rRef = assignRef ? mkRef(msg.reply_to_id) : ref;
+        text = `${linePrefix}${name} (\u2192 ${rRef} ${replyContext.senderName}): ${formatMultilineContent(msg.content, roomLabel, `${linePrefix}${name} (\u2192 ${rRef} ${replyContext.senderName}): `)}`;
+      } else {
+        text = `${linePrefix}${name}: ${formatMultilineContent(msg.content, roomLabel, `${linePrefix}${name}: `)}`;
+      }
+      const parts = [{ type: "text", text }];
+      if (msg.image_url) parts.push({ type: "image", url: msg.image_url });
+      return parts;
+    }
+    case "Mentioned": {
+      const msg = event.message;
+      const name = resolveName(resolveParticipant, msg.sender_id, msg.sender_name);
+      const ref = mkRef(msg.id);
+      const linePrefix = `${ts}${ref} ${r}\u26A1 `;
+      const text = `${linePrefix}${name}: ${formatMultilineContent(msg.content, roomLabel, `${linePrefix}${name}: `)}`;
+      const parts = [{ type: "text", text }];
+      if (msg.image_url) parts.push({ type: "image", url: msg.image_url });
+      return parts;
+    }
+    case "ToolUse":
+      return null;
+    case "Activity":
+      return null;
+    case "ReactionAdded": {
+      const name = resolveName(resolveParticipant, event.participant_id);
+      const targetRef = reactionTarget ? ` to ${mkRef(event.message_id)}` : "";
+      return [{ type: "text", text: `${ts}${r}${name} reacted ${event.emoji}${targetRef}` }];
+    }
+    case "ReactionRemoved":
+      return null;
+    case "ParticipantJoined": {
+      const name = event.participant?.name ?? "someone";
+      return [{ type: "text", text: `${ts}${r}+ ${name} joined` }];
+    }
+    case "ParticipantLeft": {
+      const name = event.participant?.name ?? "someone";
+      return [{ type: "text", text: `${ts}${r}- ${name} left` }];
+    }
+    case "ContextCompacted":
+      return null;
+    default:
+      return null;
+  }
+}
+
+// src/agent/engagement.ts
+var VALID_MODES = /* @__PURE__ */ new Set([
+  "me",
+  "people",
+  "agents",
+  "everyone",
+  "standby-me",
+  "standby-people",
+  "standby-agents",
+  "standby-everyone"
+]);
+function isValidMode(mode) {
+  return VALID_MODES.has(mode);
+}
+function senderMatches(filter, senderType, senderId, personParticipantId) {
+  switch (filter) {
+    case "everyone":
+      return true;
+    case "people":
+      return senderType === "human";
+    case "agents":
+      return senderType === "agent";
+    case "me":
+      return !!personParticipantId && senderId === personParticipantId;
+    default:
+      return false;
+  }
+}
+function classify(event, mode, selfId, senderType, senderId, personParticipantId) {
+  const role = EVENT_ROLE[event.type];
+  if (role === "internal") return "drop";
+  if (role !== "mention" && event.participant_id === selfId) return "drop";
+  const isStandby = mode.startsWith("standby-");
+  const filter = isStandby ? mode.slice(8) : mode;
+  if (isStandby) {
+    if (role === "mention" && event.participant_id === selfId && senderMatches(filter, senderType, senderId, personParticipantId)) return "trigger";
+    return "drop";
+  }
+  if (role === "mention") return "drop";
+  if (role === "message") {
+    return senderMatches(filter, senderType, senderId, personParticipantId) ? "trigger" : "content";
+  }
+  if (role === "ambient") return "content";
+  return "drop";
+}
+var StoopsEngagement = class {
+  _modes = /* @__PURE__ */ new Map();
+  _defaultMode;
+  _personParticipantId;
+  constructor(defaultMode, personParticipantId) {
+    this._defaultMode = defaultMode;
+    this._personParticipantId = personParticipantId;
+  }
+  /** Get the engagement mode for a room. Falls back to the default mode. */
+  getMode(roomId) {
+    return this._modes.get(roomId) ?? this._defaultMode;
+  }
+  /** Set the engagement mode for a room. */
+  setMode(roomId, mode) {
+    this._modes.set(roomId, mode);
+  }
+  /** Called when a room is disconnected. Removes the room's mode so it doesn't linger. */
+  onRoomDisconnected(roomId) {
+    this._modes.delete(roomId);
+  }
+  classify(event, roomId, selfId, senderType, senderId) {
+    const mode = this._modes.get(roomId) ?? this._defaultMode;
+    return classify(event, mode, selfId, senderType, senderId, this._personParticipantId);
+  }
+};
+function classifyEvent(event, mode, selfId, senderType, senderId, personParticipantId) {
+  return classify(event, mode, selfId, senderType, senderId, personParticipantId);
+}
+
+// src/agent/mcp/runtime.ts
+import { createServer } from "http";
+import { z } from "zod";
+
+// src/agent/tool-handlers.ts
+function resolveOrError(resolver, roomName) {
+  const conn = resolver.resolve(roomName);
+  if (!conn) {
+    return {
+      error: true,
+      result: { content: [{ type: "text", text: `Unknown room "${roomName}".` }] }
+    };
+  }
+  return { error: false, conn };
+}
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+async function formatMsgLine(msg, conn, mkRef) {
+  const ts = formatTimestamp(new Date(msg.timestamp));
+  const ref = mkRef(msg.id);
+  const imageNote = msg.image_url ? ` [[img:${msg.image_url}]]` : "";
+  let line = `[${ts}] ${ref} ${msg.sender_name}: ${msg.content}${imageNote}`;
+  if (msg.reply_to_id) {
+    const target = await conn.dataSource.getMessage(msg.reply_to_id);
+    if (target) {
+      const targetRef = mkRef(target.id);
+      line = `[${ts}] ${ref} ${msg.sender_name} (\u2192 ${targetRef} ${target.sender_name}): ${msg.content}${imageNote}`;
+    }
+  }
+  return line;
+}
+async function buildCatchUpLines(conn, options) {
+  const result = await conn.dataSource.getEvents(null, 50, null);
+  const chronological = [...result.items].reverse();
+  let startIdx = chronological.length;
+  for (let i = 0; i < chronological.length; i++) {
+    if (!options.isEventSeen?.(chronological[i].id)) {
+      startIdx = i;
+      break;
+    }
+  }
+  const unseen = chronological.slice(startIdx);
+  const lines = [];
+  const seenIds = [];
+  const mkRef = (id) => `#${options.assignRef?.(id) ?? messageRef(id)}`;
+  for (const event of unseen) {
+    seenIds.push(event.id);
+    const ts = formatTimestamp(new Date(event.timestamp));
+    if (event.type === "MessageSent") {
+      lines.push(await formatMsgLine(event.message, conn, (id) => mkRef(id)));
+    } else if (event.type === "ParticipantJoined") {
+      const participant = conn.dataSource.listParticipants().find((p) => p.id === event.participant_id);
+      const name = participant?.name ?? event.participant_id;
+      lines.push(`[${ts}] + ${name} joined`);
+    } else if (event.type === "ParticipantLeft") {
+      const name = event.participant?.name ?? event.participant_id;
+      lines.push(`[${ts}] - ${name} left`);
+    } else if (event.type === "ReactionAdded") {
+      const participant = conn.dataSource.listParticipants().find((p) => p.id === event.participant_id);
+      const name = participant?.name ?? event.participant_id;
+      const target = await conn.dataSource.getMessage(event.message_id);
+      const targetRef = target ? ` to ${mkRef(target.id)}` : "";
+      lines.push(`[${ts}] ${name} reacted ${event.emoji}${targetRef}`);
+    }
+  }
+  if (seenIds.length > 0) options.markEventsSeen?.(seenIds);
+  return lines;
+}
+async function handleCatchUp(resolver, args, options) {
+  const r = resolveOrError(resolver, args.room);
+  if (r.error) return r.result;
+  const lines = await buildCatchUpLines(r.conn, options);
+  const out = [`Catching up on [${args.room}]:`];
+  if (lines.length > 0) {
+    out.push("", ...lines);
+  } else {
+    out.push("", "(nothing new)");
+  }
+  return { content: [{ type: "text", text: out.join("\n") }] };
+}
+async function handleSearchByText(resolver, args, options) {
+  const r = resolveOrError(resolver, args.room);
+  if (r.error) return r.result;
+  const { conn } = r;
+  const count = args.count ?? 3;
+  const mkRef = (id) => `#${options.assignRef?.(id) ?? messageRef(id)}`;
+  const searchResult = await conn.dataSource.searchMessages(args.query, 50, args.cursor ?? null);
+  const totalVisible = searchResult.items.length;
+  if (totalVisible === 0) {
+    return textResult(`No messages found in [${args.room}] matching "${args.query}".`);
+  }
+  const toShow = searchResult.items.slice(0, count);
+  const recentResult = await conn.dataSource.getMessages(100, null);
+  const recentChron = [...recentResult.items].reverse();
+  const msgIdxMap = /* @__PURE__ */ new Map();
+  recentChron.forEach((m, i) => msgIdxMap.set(m.id, i));
+  const clusters = [];
+  let newerCount = null;
+  for (const match of [...toShow].reverse()) {
+    const cluster = [];
+    const matchIdx = msgIdxMap.get(match.id);
+    if (matchIdx !== void 0) {
+      if (matchIdx > 0) {
+        cluster.push(await formatMsgLine(recentChron[matchIdx - 1], conn, mkRef));
+      }
+      cluster.push(await formatMsgLine(match, conn, mkRef) + " \u2190");
+      if (matchIdx < recentChron.length - 1) {
+        cluster.push(await formatMsgLine(recentChron[matchIdx + 1], conn, mkRef));
+      }
+      if (newerCount === null && match.id === toShow[0].id) {
+        newerCount = recentChron.length - matchIdx - 1;
+      }
+    } else {
+      cluster.push(await formatMsgLine(match, conn, mkRef) + " \u2190");
+    }
+    clusters.push(cluster);
+  }
+  const shownCount = toShow.length;
+  const totalNote = searchResult.has_more ? `showing ${shownCount} of 50+` : `${shownCount} of ${totalVisible}`;
+  const out = [`Search results in [${args.room}] for "${args.query}" (${totalNote} matches):`, ""];
+  for (let i = 0; i < clusters.length; i++) {
+    for (const line of clusters[i]) {
+      out.push(`  ${line}`);
+    }
+    if (i < clusters.length - 1) out.push("");
+  }
+  if (newerCount !== null && newerCount > 0) {
+    out.push("", `${newerCount} newer message${newerCount === 1 ? "" : "s"} in this room.`);
+  }
+  if (searchResult.has_more && searchResult.next_cursor) {
+    out.push(`(cursor: "${searchResult.next_cursor}" for next ${count} matches)`);
+  }
+  return textResult(out.join("\n"));
+}
+async function handleSearchByMessage(resolver, args, options) {
+  const r = resolveOrError(resolver, args.room);
+  if (r.error) return r.result;
+  const { conn } = r;
+  const direction = args.direction ?? "before";
+  const count = args.count ?? 10;
+  const mkRef = (id) => `#${options.assignRef?.(id) ?? messageRef(id)}`;
+  const rawRef = args.ref.startsWith("#") ? args.ref.slice(1) : args.ref;
+  const anchorId = options.resolveRef?.(rawRef) ?? rawRef;
+  const anchor = await conn.dataSource.getMessage(anchorId);
+  if (!anchor) return textResult(`Message ${args.ref} not found.`);
+  const recentResult = await conn.dataSource.getMessages(100, null);
+  const recentChron = [...recentResult.items].reverse();
+  const anchorIdx = recentChron.findIndex((m) => m.id === anchor.id);
+  let displayMessages;
+  let newerCount;
+  if (direction === "before") {
+    const beforeResult = await conn.dataSource.getMessages(count, anchor.id);
+    const beforeMessages = [...beforeResult.items].reverse();
+    displayMessages = [...beforeMessages, anchor];
+    newerCount = anchorIdx >= 0 ? recentChron.length - anchorIdx - 1 : 100;
+  } else {
+    if (anchorIdx >= 0) {
+      const afterMessages = recentChron.slice(anchorIdx + 1, anchorIdx + 1 + count);
+      displayMessages = [anchor, ...afterMessages];
+      newerCount = recentChron.length - anchorIdx - 1 - afterMessages.length;
+    } else {
+      displayMessages = [anchor];
+      newerCount = 100;
+    }
+  }
+  const anchorRef = mkRef(anchor.id);
+  const lines = [`Context in [${args.room}] around ${anchorRef}:`, ""];
+  for (const msg of displayMessages) {
+    const line = await formatMsgLine(msg, conn, mkRef);
+    const isAnchor = msg.id === anchor.id;
+    lines.push(`  ${line}${isAnchor ? " \u2190" : ""}`);
+  }
+  if (newerCount > 0) {
+    const countLabel = newerCount >= 100 ? "100+" : String(newerCount);
+    lines.push("", `${countLabel} newer message${newerCount === 1 ? "" : "s"} in this room.`);
+  }
+  return textResult(lines.join("\n"));
+}
+async function handleSendMessage(resolver, args, options) {
+  const r = resolveOrError(resolver, args.room);
+  if (r.error) return r.result;
+  const image = args.image_url ? {
+    url: args.image_url,
+    mimeType: args.image_mime_type ?? "image/*",
+    sizeBytes: args.image_size_bytes ?? 0
+  } : null;
+  let replyToId = args.reply_to_id;
+  if (replyToId) {
+    const rawRef = replyToId.startsWith("#") ? replyToId.slice(1) : replyToId;
+    replyToId = options.resolveRef?.(rawRef) ?? replyToId;
+  }
+  const message = await r.conn.dataSource.sendMessage(args.content, replyToId, image);
+  const ref = options.assignRef?.(message.id) ?? messageRef(message.id);
+  return textResult(`Message sent #${ref}.`);
+}
+
+// src/agent/mcp/runtime.ts
+function formatJoinResponse(result) {
+  const lines = [];
+  lines.push(`Joined ${result.roomName} as "${result.agentName}" (${result.authority})`);
+  lines.push("");
+  if (result.mode) {
+    lines.push(`Mode: ${result.mode}`);
+    const desc = MODE_DESCRIPTIONS[result.mode];
+    if (desc) lines.push(`  ${desc}`);
+    lines.push(`  Change with set_mode.`);
+    lines.push("");
+  }
+  if (result.personName) {
+    lines.push(`Person: ${result.personName}`);
+    lines.push(`  Your person's messages always reach you regardless of mode.`);
+    lines.push("");
+  }
+  if (result.participants && result.participants.length > 0) {
+    lines.push("Participants:");
+    for (const p of result.participants) {
+      lines.push(`  ${p.name} (${p.authority})`);
+    }
+    lines.push("");
+  }
+  if (result.recentLines && result.recentLines.length > 0) {
+    lines.push("Recent:");
+    for (const line of result.recentLines) {
+      lines.push(`  ${line}`);
+    }
+    lines.push("");
+    lines.push(`${result.recentLines.length} message${result.recentLines.length === 1 ? "" : "s"} shown. Use catch_up("${result.roomName}") for more.`);
+  }
+  return lines.join("\n");
+}
+function registerTools(server, opts) {
+  const { resolver, toolOptions } = opts;
+  server.tool(
+    "stoops__catch_up",
+    "List your rooms and status. Call with no arguments to see connected rooms. With a room name, returns recent activity you haven't seen.",
+    {
+      room: z.string().optional().describe("Room name. Omit to list all connected rooms.")
+    },
+    { readOnlyHint: true },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async ({ room }) => {
+      if (!room) {
+        const rooms = resolver.listAll();
+        if (rooms.length === 0) {
+          return textResult("Not connected to any rooms.");
+        }
+        const lines = ["Connected rooms:", ""];
+        for (const r of rooms) {
+          const idPart = r.identifier ? ` [${r.identifier}]` : "";
+          lines.push(`  ${r.name}${idPart} \u2014 ${r.mode} (${r.participantCount} participants)`);
+          if (r.lastMessage) lines.push(`    Last: ${r.lastMessage}`);
+        }
+        return textResult(lines.join("\n"));
+      }
+      return handleCatchUp(resolver, { room }, toolOptions);
+    }
+  );
+  server.tool(
+    "stoops__search_by_text",
+    "Search chat history by keyword.",
+    {
+      room: z.string().describe("Room name"),
+      query: z.string().describe("Keyword or phrase to search for"),
+      count: z.number().int().min(1).max(10).default(3).optional().describe("Number of matches (default 3)"),
+      cursor: z.string().optional().describe("Pagination cursor")
+    },
+    { readOnlyHint: true },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async (args) => handleSearchByText(resolver, args, toolOptions)
+  );
+  server.tool(
+    "stoops__search_by_message",
+    "Show messages around a known message ref.",
+    {
+      room: z.string().describe("Room name"),
+      ref: z.string().describe("Message ref (e.g. #3847)"),
+      direction: z.enum(["before", "after"]).default("before").optional().describe("'before' to scroll back, 'after' to scroll forward"),
+      count: z.number().int().min(1).max(50).default(10).optional().describe("Number of messages (default 10)")
+    },
+    { readOnlyHint: true },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async (args) => handleSearchByMessage(resolver, args, toolOptions)
+  );
+  server.tool(
+    "stoops__send_message",
+    "Send a message to a room.",
+    {
+      room: z.string().describe("Room name"),
+      content: z.string().describe("Message content. @name will notify that participant \u2014 use sparingly."),
+      reply_to_id: z.string().optional().describe("Message ref to reply to (e.g. #3847).")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async (args) => handleSendMessage(resolver, args, toolOptions)
+  );
+  server.tool(
+    "stoops__set_mode",
+    "Change your engagement mode. Controls which messages are pushed to you: everyone \u2014 all messages, people \u2014 human messages only, agents \u2014 agent messages only, me \u2014 your person only. Prefix with standby- for @mentions only.",
+    {
+      room: z.string().describe("Room name"),
+      mode: z.string().describe("Engagement mode")
+    },
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+    async ({ room, mode }) => {
+      if (!opts.onSetMode) return textResult("Mode changes not supported.");
+      if (!isValidMode(mode)) {
+        return textResult(`Invalid mode "${mode}". Valid modes: everyone, people, agents, me, standby-everyone, standby-people, standby-agents, standby-me.`);
+      }
+      const result = await opts.onSetMode(room, mode);
+      return result.success ? textResult(`Mode set to ${mode} for [${room}].`) : textResult(result.error ?? "Failed to set mode.");
+    }
+  );
+  server.tool(
+    "stoops__join_room",
+    "Join a room. Returns your identity, participants, mode, and recent activity.",
+    {
+      url: z.string().describe("Share URL to join"),
+      alias: z.string().optional().describe("Local alias for the room (if name collides)")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ url, alias }) => {
+      if (!opts.onJoinRoom) return textResult("Joining rooms not supported.");
+      const result = await opts.onJoinRoom(url, alias);
+      if (!result.success) return textResult(result.error ?? "Failed to join room.");
+      if (result.roomName && result.agentName) {
+        return textResult(formatJoinResponse(result));
+      }
+      return textResult(`Joined room successfully.`);
+    }
+  );
+  server.tool(
+    "stoops__leave_room",
+    "Leave a room. Events stop flowing from it.",
+    {
+      room: z.string().describe("Room name to leave")
+    },
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+    async ({ room }) => {
+      if (!opts.onLeaveRoom) return textResult("Leaving rooms not supported.");
+      const result = await opts.onLeaveRoom(room);
+      return result.success ? textResult(`Left [${room}].`) : textResult(result.error ?? "Failed to leave room.");
+    }
+  );
+  if (opts.admin) {
+    server.tool(
+      "stoops__admin__set_mode_for",
+      "Admin: set engagement mode for another participant.",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name"),
+        mode: z.string().describe("Engagement mode to set")
+      },
+      { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+      async ({ room, participant, mode }) => {
+        if (!opts.onAdminSetModeFor) return textResult("Admin mode changes not supported.");
+        if (!isValidMode(mode)) {
+          return textResult(`Invalid mode "${mode}". Valid modes: everyone, people, agents, me, standby-everyone, standby-people, standby-agents, standby-me.`);
+        }
+        const result = await opts.onAdminSetModeFor(room, participant, mode);
+        return result.success ? textResult(`Set ${participant}'s mode to ${mode} in [${room}].`) : textResult(result.error ?? "Failed to set mode.");
+      }
+    );
+    server.tool(
+      "stoops__admin__kick",
+      "Admin: kick a participant from a room.",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name to kick")
+      },
+      { readOnlyHint: false, destructiveHint: true },
+      async ({ room, participant }) => {
+        if (!opts.onAdminKick) return textResult("Admin kick not supported.");
+        const result = await opts.onAdminKick(room, participant);
+        return result.success ? textResult(`Kicked ${participant} from [${room}].`) : textResult(result.error ?? "Failed to kick participant.");
+      }
+    );
+    server.tool(
+      "stoops__admin__mute",
+      "Admin: make a participant read-only (demote to observer).",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name to mute")
+      },
+      { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+      async ({ room, participant }) => {
+        if (!opts.onAdminMute) return textResult("Admin mute not supported.");
+        const result = await opts.onAdminMute(room, participant);
+        return result.success ? textResult(`Muted ${participant} in [${room}] (observer).`) : textResult(result.error ?? "Failed to mute participant.");
+      }
+    );
+    server.tool(
+      "stoops__admin__unmute",
+      "Admin: restore a muted participant (promote to participant).",
+      {
+        room: z.string().describe("Room name"),
+        participant: z.string().describe("Participant name to unmute")
+      },
+      { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+      async ({ room, participant }) => {
+        if (!opts.onAdminUnmute) return textResult("Admin unmute not supported.");
+        const result = await opts.onAdminUnmute(room, participant);
+        return result.success ? textResult(`Unmuted ${participant} in [${room}] (participant).`) : textResult(result.error ?? "Failed to unmute participant.");
+      }
+    );
+  }
+}
+async function createRuntimeMcpServer(opts) {
+  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+  const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+  const httpServer = createServer(async (req, res) => {
+    if (req.url !== "/mcp") {
+      res.writeHead(404).end();
+      return;
+    }
+    const reqServer = new McpServer({ name: "stoops_runtime", version: "1.0.0" });
+    registerTools(reqServer, opts);
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0
+    });
+    await reqServer.connect(transport);
+    let body;
+    if (req.method === "POST") {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      try {
+        body = JSON.parse(Buffer.concat(chunks).toString());
+      } catch {
+        body = void 0;
+      }
+    }
+    await transport.handleRequest(req, res, body);
+  });
+  const port = await new Promise((resolve, reject) => {
+    httpServer.listen(0, "127.0.0.1", () => {
+      const addr = httpServer.address();
+      if (addr && typeof addr === "object") resolve(addr.port);
+      else reject(new Error("Could not determine server port"));
+    });
+    httpServer.once("error", reject);
+  });
+  const url = `http://127.0.0.1:${port}/mcp`;
+  let stopPromise = null;
+  const stop = () => {
+    if (!stopPromise) {
+      stopPromise = new Promise(
+        (resolve, reject) => httpServer.close((err) => err ? reject(err) : resolve())
+      );
+    }
+    return stopPromise;
+  };
+  return { url, stop };
+}
+
+export {
+  getSystemPreamble,
+  messageRef,
+  participantLabel,
+  formatTimestamp,
+  contentPartsToString,
+  formatEvent,
+  StoopsEngagement,
+  classifyEvent,
+  buildCatchUpLines,
+  handleCatchUp,
+  handleSearchByText,
+  handleSearchByMessage,
+  handleSendMessage,
+  createRuntimeMcpServer
+};
+//# sourceMappingURL=chunk-BLGV3QN4.js.map