@band-ai/sdk 0.1.2

package/dist/mcp.cjs

@@ -0,0 +1,1247 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/errors.ts
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    "use strict";
+  }
+});
+
+// src/contracts/chatEvents.ts
+var CHAT_EVENT_TYPES, CHAT_MESSAGE_TYPES;
+var init_chatEvents = __esm({
+  "src/contracts/chatEvents.ts"() {
+    "use strict";
+    init_errors();
+    CHAT_EVENT_TYPES = ["tool_call", "tool_result", "thought", "error", "task"];
+    CHAT_MESSAGE_TYPES = ["text", ...CHAT_EVENT_TYPES];
+  }
+});
+
+// src/runtime/tools/schemas.ts
+function mcpToolNames(names) {
+  return [...names].sort((a, b) => a.localeCompare(b)).map((name) => `${MCP_TOOL_PREFIX}${name}`);
+}
+function getToolDescription(name) {
+  const model = TOOL_MODELS[name];
+  return model?.description ?? `Execute ${name}`;
+}
+var TOOL_MODELS, ALL_TOOL_NAMES, MEMORY_TOOL_NAMES, CONTACT_TOOL_NAMES, BASE_TOOL_NAMES, CHAT_TOOL_NAMES, MCP_TOOL_PREFIX;
+var init_schemas = __esm({
+  "src/runtime/tools/schemas.ts"() {
+    "use strict";
+    init_chatEvents();
+    TOOL_MODELS = {
+      thenvoi_send_message: {
+        description: "Send a message to the chat room. Use this to respond to users or other agents. Messages require at least one @mention in the mentions array. You MUST use this tool to communicate \u2014 plain text responses won't reach users. When delegating, send the full task context in this message instead of assuming hidden state.",
+        properties: {
+          content: {
+            type: "string",
+            description: "The message content to send."
+          },
+          mentions: {
+            type: "array",
+            items: { type: "string" },
+            minItems: 1,
+            description: "List of participant handles to @mention. At least one required. For users: @<username> (e.g., '@john'). For agents: @<username>/<agent-name> (e.g., '@john/weather-agent'). Use the handle of someone already in the room."
+          }
+        },
+        required: ["content", "mentions"]
+      },
+      thenvoi_send_event: {
+        description: "Send an event to the chat room. No mentions required. 'thought': Share your reasoning or plan BEFORE taking actions. Explain what you're about to do and why. 'error': Report an error or problem that occurred. 'task': Report task progress or completion status. Always send a thought before complex actions to keep users informed.",
+        properties: {
+          content: {
+            type: "string",
+            description: "Human-readable event content."
+          },
+          message_type: {
+            type: "string",
+            enum: [...CHAT_EVENT_TYPES],
+            description: "Type of event."
+          },
+          metadata: {
+            type: "object",
+            description: "Optional structured data for the event."
+          }
+        },
+        required: ["content", "message_type"]
+      },
+      thenvoi_add_participant: {
+        description: "Add a participant (agent or user) to the chat room by name. IMPORTANT: Use thenvoi_lookup_peers() first to find available agents. Pass the exact peer name from thenvoi_lookup_peers, not the handle. For normal delegation, omit role or use 'member'.",
+        properties: {
+          name: {
+            type: "string",
+            description: "Name of participant to add (must match a name from thenvoi_lookup_peers)."
+          },
+          role: {
+            type: "string",
+            enum: ["owner", "admin", "member"],
+            description: "Role for the participant in this room."
+          }
+        },
+        required: ["name"]
+      },
+      thenvoi_remove_participant: {
+        description: "Remove a participant from the chat room by name.",
+        properties: {
+          name: {
+            type: "string",
+            description: "Name of the participant to remove."
+          }
+        },
+        required: ["name"]
+      },
+      thenvoi_get_participants: {
+        description: "Get a list of all participants in the current chat room.",
+        properties: {},
+        required: []
+      },
+      thenvoi_lookup_peers: {
+        description: "List available peers (agents and users) that can be added to this room. Automatically excludes peers already in the room. Returns dict with 'peers' list and 'metadata' (page, page_size, total_count, total_pages). Use this to find specialized agents (e.g., Weather Agent) when you cannot answer a question directly.",
+        properties: {
+          page: {
+            type: "integer",
+            description: "Page number."
+          },
+          page_size: {
+            type: "integer",
+            description: "Items per page (max 100).",
+            maximum: 100
+          }
+        },
+        required: []
+      },
+      thenvoi_create_chatroom: {
+        description: "Create a new chat room for a specific task or conversation.",
+        properties: {
+          task_id: {
+            type: "string",
+            description: "Associated task ID (optional)."
+          }
+        },
+        required: []
+      },
+      thenvoi_list_contacts: {
+        description: "List agent's contacts with pagination.",
+        properties: {
+          page: {
+            type: "integer",
+            description: "Page number.",
+            minimum: 1
+          },
+          page_size: {
+            type: "integer",
+            description: "Items per page.",
+            minimum: 1,
+            maximum: 100
+          }
+        },
+        required: []
+      },
+      thenvoi_add_contact: {
+        description: "Send a contact request to add someone as a contact. Returns 'pending' when request is created. Returns 'approved' when inverse request existed and was auto-accepted.",
+        properties: {
+          handle: {
+            type: "string",
+            description: "Handle of user/agent to add (e.g., '@john' or '@john/agent-name')."
+          },
+          message: {
+            type: "string",
+            description: "Optional message with the request."
+          }
+        },
+        required: ["handle"]
+      },
+      thenvoi_remove_contact: {
+        description: "Remove an existing contact by handle or ID.",
+        properties: {
+          handle: {
+            type: "string",
+            description: "Contact's handle."
+          },
+          contact_id: {
+            type: "string",
+            description: "Or contact record ID (UUID)."
+          }
+        },
+        required: []
+      },
+      thenvoi_list_contact_requests: {
+        description: "List both received and sent contact requests. Received requests are always filtered to pending status. Sent requests can be filtered by status.",
+        properties: {
+          page: {
+            type: "integer",
+            description: "Page number.",
+            minimum: 1
+          },
+          page_size: {
+            type: "integer",
+            description: "Items per page per direction (max 100).",
+            minimum: 1,
+            maximum: 100
+          },
+          sent_status: {
+            type: "string",
+            enum: ["pending", "approved", "rejected", "cancelled", "all"],
+            description: "Filter sent requests by status."
+          }
+        },
+        required: []
+      },
+      thenvoi_respond_contact_request: {
+        description: "Respond to a contact request. 'approve'/'reject': For requests you RECEIVED (handle = requester's handle). 'cancel': For requests you SENT (handle = recipient's handle).",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["approve", "reject", "cancel"],
+            description: "Action to take."
+          },
+          handle: {
+            type: "string",
+            description: "Other party's handle."
+          },
+          request_id: {
+            type: "string",
+            description: "Or request ID (UUID)."
+          }
+        },
+        required: ["action"]
+      },
+      thenvoi_list_memories: {
+        description: "List memories accessible to the agent. Returns memories about the specified subject (cross-agent sharing) and organization-wide shared memories.",
+        properties: {
+          subject_id: {
+            type: "string",
+            description: "Filter by subject UUID (required for subject-scoped queries)."
+          },
+          scope: {
+            type: "string",
+            enum: ["subject", "organization", "all"],
+            description: "Filter by scope."
+          },
+          system: {
+            type: "string",
+            enum: ["sensory", "working", "long_term"],
+            description: "Filter by memory system."
+          },
+          type: {
+            type: "string",
+            enum: [
+              "iconic",
+              "echoic",
+              "haptic",
+              "episodic",
+              "semantic",
+              "procedural"
+            ],
+            description: "Filter by memory type."
+          },
+          segment: {
+            type: "string",
+            enum: ["user", "agent", "tool", "guideline"],
+            description: "Filter by segment."
+          },
+          content_query: {
+            type: "string",
+            description: "Full-text search query."
+          },
+          page_size: {
+            type: "integer",
+            description: "Number of results per page.",
+            minimum: 1,
+            maximum: 50
+          },
+          status: {
+            type: "string",
+            enum: ["active", "superseded", "archived", "all"],
+            description: "Filter by status."
+          }
+        },
+        required: []
+      },
+      thenvoi_store_memory: {
+        description: "Store a new memory entry. The memory will be associated with the authenticated agent as the source. For subject-scoped memories, provide a subject_id. For organization-scoped memories, omit subject_id.",
+        properties: {
+          content: {
+            type: "string",
+            description: "The memory content."
+          },
+          system: {
+            type: "string",
+            enum: ["sensory", "working", "long_term"],
+            description: "Memory system tier."
+          },
+          type: {
+            type: "string",
+            enum: [
+              "iconic",
+              "echoic",
+              "haptic",
+              "episodic",
+              "semantic",
+              "procedural"
+            ],
+            description: "Memory type (must be valid for selected system)."
+          },
+          segment: {
+            type: "string",
+            enum: ["user", "agent", "tool", "guideline"],
+            description: "Logical segment."
+          },
+          thought: {
+            type: "string",
+            description: "Agent's reasoning for storing this memory."
+          },
+          scope: {
+            type: "string",
+            enum: ["subject", "organization"],
+            description: "Visibility scope."
+          },
+          subject_id: {
+            type: "string",
+            description: "UUID of the subject this memory is about (required for subject scope)."
+          },
+          metadata: {
+            type: "object",
+            description: "Additional metadata (tags, references)."
+          }
+        },
+        required: ["content", "system", "type", "segment", "thought"]
+      },
+      thenvoi_get_memory: {
+        description: "Retrieve a specific memory by ID.",
+        properties: {
+          memory_id: {
+            type: "string",
+            description: "Memory ID (UUID)."
+          }
+        },
+        required: ["memory_id"]
+      },
+      thenvoi_supersede_memory: {
+        description: "Mark a memory as superseded (soft delete). Use when information is outdated or incorrect. The memory remains for audit trail but won't appear in normal queries. Only the source agent can supersede.",
+        properties: {
+          memory_id: {
+            type: "string",
+            description: "Memory ID (UUID)."
+          }
+        },
+        required: ["memory_id"]
+      },
+      thenvoi_archive_memory: {
+        description: "Archive a memory (hide but preserve). Use when memory is valid but not currently needed. Archived memories can be restored later by humans. Only the source agent can archive.",
+        properties: {
+          memory_id: {
+            type: "string",
+            description: "Memory ID (UUID)."
+          }
+        },
+        required: ["memory_id"]
+      }
+    };
+    ALL_TOOL_NAMES = new Set(Object.keys(TOOL_MODELS));
+    MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set([
+      "thenvoi_list_memories",
+      "thenvoi_store_memory",
+      "thenvoi_get_memory",
+      "thenvoi_supersede_memory",
+      "thenvoi_archive_memory"
+    ]);
+    CONTACT_TOOL_NAMES = /* @__PURE__ */ new Set([
+      "thenvoi_list_contacts",
+      "thenvoi_add_contact",
+      "thenvoi_remove_contact",
+      "thenvoi_list_contact_requests",
+      "thenvoi_respond_contact_request"
+    ]);
+    BASE_TOOL_NAMES = new Set(
+      [...ALL_TOOL_NAMES].filter((name) => !MEMORY_TOOL_NAMES.has(name))
+    );
+    CHAT_TOOL_NAMES = new Set(
+      [...BASE_TOOL_NAMES].filter((name) => !CONTACT_TOOL_NAMES.has(name))
+    );
+    MCP_TOOL_PREFIX = "mcp__thenvoi__";
+  }
+});
+
+// src/contracts/protocols.ts
+function isToolExecutorError(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return candidate.ok === false && typeof candidate.errorType === "string" && TOOL_EXECUTOR_ERROR_TYPES.includes(candidate.errorType) && typeof candidate.toolName === "string" && typeof candidate.message === "string" && typeof candidate.legacyMessage === "string";
+}
+function toLegacyToolExecutorErrorMessage(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!isToolExecutorError(value)) {
+    return null;
+  }
+  return value.legacyMessage;
+}
+var TOOL_EXECUTOR_ERROR_TYPES;
+var init_protocols = __esm({
+  "src/contracts/protocols.ts"() {
+    "use strict";
+    TOOL_EXECUTOR_ERROR_TYPES = [
+      "ToolArgumentsValidationError",
+      "ToolNotFoundError",
+      "ToolExecutionError"
+    ];
+  }
+});
+
+// src/mcp/registrations.ts
+function buildRoomScopedRegistrations(resolver, options = {}) {
+  const toolNames = resolveToolNames(options);
+  const registrations = buildRegistrations(toolNames, async (toolName, args) => {
+    const roomId = asNonEmptyString(args.room_id);
+    if (!roomId) {
+      return errorResult("Missing required room_id");
+    }
+    const tools = resolver(roomId);
+    if (!tools) {
+      return errorResult(`No tool context found for room_id ${roomId}`);
+    }
+    const toolArgs = { ...args };
+    delete toolArgs.room_id;
+    return executeToolCall(tools, toolName, toolArgs);
+  }, { injectRoomId: true });
+  if (options.additionalTools) {
+    registrations.push(...options.additionalTools);
+  }
+  return registrations;
+}
+function buildSingleContextRegistrations(tools, options = {}) {
+  const toolNames = resolveToolNames(options);
+  const registrations = buildRegistrations(toolNames, (_toolName, args) => {
+    return executeToolCall(tools, _toolName, args);
+  }, { injectRoomId: false });
+  if (options.additionalTools) {
+    registrations.push(...options.additionalTools);
+  }
+  return registrations;
+}
+function resolveToolNames(options) {
+  const names = /* @__PURE__ */ new Set();
+  for (const name of BASE_TOOL_NAMES) {
+    if (!options.enableContactTools && CONTACT_TOOL_NAMES.has(name)) {
+      continue;
+    }
+    names.add(name);
+  }
+  if (options.enableMemoryTools) {
+    for (const name of MEMORY_TOOL_NAMES) {
+      names.add(name);
+    }
+  }
+  return names;
+}
+function buildRegistrations(toolNames, executor, opts) {
+  const registrations = [];
+  for (const toolName of toolNames) {
+    const model = TOOL_MODELS[toolName];
+    if (!model) {
+      continue;
+    }
+    const properties = { ...model.properties };
+    const required = [...model.required];
+    if (opts.injectRoomId) {
+      properties.room_id = { type: "string", description: "The room ID to execute this tool in" };
+      required.push("room_id");
+    }
+    registrations.push({
+      name: toolName,
+      description: getToolDescription(toolName),
+      inputSchema: {
+        type: "object",
+        properties,
+        required
+      },
+      execute: (args) => executor(toolName, args)
+    });
+  }
+  return registrations;
+}
+async function executeToolCall(tools, toolName, args) {
+  try {
+    const result = await tools.executeToolCall(toolName, args);
+    if (isToolExecutorError(result)) {
+      return errorResult(toLegacyToolExecutorErrorMessage(result) ?? result.message);
+    }
+    return successResult(result);
+  } catch (error) {
+    return errorResult(error instanceof Error ? error.message : String(error));
+  }
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function successResult(value) {
+  return {
+    content: [{
+      type: "text",
+      text: serializeValue(value)
+    }]
+  };
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+function serializeValue(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    const json = JSON.stringify(value);
+    return typeof json === "string" ? json : String(value);
+  } catch {
+    return String(value);
+  }
+}
+var init_registrations = __esm({
+  "src/mcp/registrations.ts"() {
+    "use strict";
+    init_protocols();
+    init_schemas();
+  }
+});
+
+// src/mcp/zod.ts
+function buildZodShape(z2, properties, required) {
+  const shape = {};
+  for (const [name, schema] of Object.entries(properties)) {
+    const validator = jsonSchemaToZod(z2, schema);
+    shape[name] = required.has(name) ? validator : validator.optional();
+  }
+  return shape;
+}
+function jsonSchemaToZod(z2, schema) {
+  const type = schema.type;
+  if (type === "string") {
+    if (Array.isArray(schema.enum) && schema.enum.every((v) => typeof v === "string")) {
+      const values = schema.enum;
+      if (values.length > 0) {
+        return z2.enum(values);
+      }
+    }
+    return z2.string();
+  }
+  if (type === "integer" || type === "number") {
+    return z2.number();
+  }
+  if (type === "boolean") {
+    return z2.boolean();
+  }
+  if (type === "array") {
+    const itemSchema = schema.items;
+    if (itemSchema && typeof itemSchema === "object") {
+      return z2.array(jsonSchemaToZod(z2, itemSchema));
+    }
+    return z2.array(z2.unknown());
+  }
+  if (type === "object") {
+    return z2.record(z2.string(), z2.unknown());
+  }
+  return z2.unknown();
+}
+var init_zod = __esm({
+  "src/mcp/zod.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/sdk.ts
+var sdk_exports = {};
+__export(sdk_exports, {
+  createThenvoiSdkMcpServer: () => createThenvoiSdkMcpServer
+});
+function createThenvoiSdkMcpServer(options) {
+  const registrations = buildRoomScopedRegistrations(
+    options.getToolsForRoom,
+    {
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: true,
+      additionalTools: options.additionalTools
+    }
+  );
+  const toolDefinitions = registrations.map(toSdkToolDefinition);
+  const toolNames = new Set(registrations.map((r) => r.name));
+  const serverConfig = (0, import_claude_agent_sdk.createSdkMcpServer)({
+    name: "thenvoi",
+    tools: toolDefinitions
+  });
+  return {
+    serverConfig,
+    allowedTools: mcpToolNames(toolNames),
+    toolDefinitions
+  };
+}
+function toSdkToolDefinition(registration) {
+  const shape = buildZodShape(
+    import_zod4.z,
+    registration.inputSchema.properties,
+    new Set(registration.inputSchema.required)
+  );
+  return (0, import_claude_agent_sdk.tool)(
+    registration.name,
+    registration.description,
+    shape,
+    async (args) => registration.execute(args)
+  );
+}
+var import_claude_agent_sdk, import_zod4;
+var init_sdk = __esm({
+  "src/mcp/sdk.ts"() {
+    "use strict";
+    import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
+    import_zod4 = require("zod");
+    init_schemas();
+    init_registrations();
+    init_zod();
+  }
+});
+
+// src/mcp/index.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  ThenvoiMcpServer: () => ThenvoiMcpServer,
+  ThenvoiMcpSseServer: () => ThenvoiMcpSseServer,
+  ThenvoiMcpStdioServer: () => ThenvoiMcpStdioServer,
+  buildRoomScopedRegistrations: () => buildRoomScopedRegistrations,
+  buildSingleContextRegistrations: () => buildSingleContextRegistrations,
+  createThenvoiMcpBackend: () => createThenvoiMcpBackend,
+  errorResult: () => errorResult,
+  getThenvoiSdkMcpServerConfig: () => getThenvoiSdkMcpServerConfig,
+  successResult: () => successResult
+});
+module.exports = __toCommonJS(mcp_exports);
+
+// src/mcp/backends.ts
+init_schemas();
+init_registrations();
+
+// src/mcp/stdio.ts
+init_registrations();
+init_zod();
+var ThenvoiMcpStdioServer = class {
+  options;
+  registrations;
+  mcpServer = null;
+  transport = null;
+  constructor(options) {
+    this.options = options;
+    const regOptions = {
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: options.enableContactTools,
+      additionalTools: options.additionalTools
+    };
+    if (typeof options.tools === "function") {
+      this.registrations = buildRoomScopedRegistrations(options.tools, regOptions);
+    } else {
+      this.registrations = buildSingleContextRegistrations(options.tools, regOptions);
+    }
+  }
+  get toolNames() {
+    return this.registrations.map((r) => r.name);
+  }
+  async start() {
+    if (this.transport) {
+      return;
+    }
+    const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+    const { z: z2 } = await import("zod");
+    const mcpServer = new McpServer({
+      name: this.options.name ?? "thenvoi",
+      version: "1.0.0"
+    });
+    registerTools(mcpServer, z2, this.registrations);
+    const transport = new StdioServerTransport(this.options.stdin, this.options.stdout);
+    await mcpServer.connect(transport);
+    this.mcpServer = mcpServer;
+    this.transport = transport;
+  }
+  async stop() {
+    await this.transport?.close();
+    this.transport = null;
+    this.mcpServer = null;
+  }
+};
+function registerTools(mcpServer, z2, registrations) {
+  for (const reg of registrations) {
+    const zodShape = buildZodShape(z2, reg.inputSchema.properties, new Set(reg.inputSchema.required));
+    mcpServer.registerTool(
+      reg.name,
+      {
+        description: reg.description,
+        inputSchema: z2.object(zodShape)
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK handler signature is complex; our McpToolResult is compatible
+      async (args) => reg.execute(args)
+    );
+  }
+}
+
+// src/mcp/server.ts
+init_registrations();
+init_zod();
+var PORT_RANGE_START = 5e4;
+var PORT_RANGE_END = 6e4;
+var MCP_SERVER_VERSION = "1.0.0";
+var SESSION_IDLE_TTL_MS = 15 * 60 * 1e3;
+var SESSION_SWEEP_INTERVAL_MS = 60 * 1e3;
+var ThenvoiMcpServer = class {
+  options;
+  registrations;
+  httpServer = null;
+  actualPort = null;
+  sessions = /* @__PURE__ */ new Map();
+  sessionSweepTimer = null;
+  constructor(options) {
+    this.options = options;
+    const regOptions = {
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: options.enableContactTools,
+      additionalTools: options.additionalTools
+    };
+    if (typeof options.tools === "function") {
+      this.registrations = buildRoomScopedRegistrations(options.tools, regOptions);
+    } else {
+      this.registrations = buildSingleContextRegistrations(options.tools, regOptions);
+    }
+  }
+  /** Port the server is listening on. Null if not started. */
+  get port() {
+    return this.actualPort;
+  }
+  /** MCP endpoint URL. Null if not started. */
+  get url() {
+    if (this.actualPort === null) {
+      return null;
+    }
+    return `http://127.0.0.1:${this.actualPort}/mcp`;
+  }
+  /** Tool names registered on this server. */
+  get toolNames() {
+    return this.registrations.map((r) => r.name);
+  }
+  async start() {
+    const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    const { isInitializeRequest } = await import("@modelcontextprotocol/sdk/types.js");
+    const expressModule = await import("express");
+    const express = expressModule.default ?? expressModule;
+    const http = await import("http");
+    const { randomUUID } = await import("crypto");
+    const { z: z2 } = await import("zod");
+    const serverName = this.options.name ?? "thenvoi";
+    const app = express();
+    app.use(express.json());
+    app.get("/healthz", (_req, res) => {
+      res.json({ status: "ok" });
+    });
+    const handleMcpRequest = async (req, res) => {
+      try {
+        const sessionId = getSessionIdHeader(req.headers["mcp-session-id"]);
+        let session = sessionId ? this.sessions.get(sessionId) : void 0;
+        if (!session) {
+          if (req.method !== "POST" || sessionId || !isInitializeRequest(req.body)) {
+            sendMcpError(res, sessionId ? 404 : 400, sessionId ? "Session not found" : "Bad Request: No valid session ID provided");
+            return;
+          }
+          session = await this.createSession({
+            McpServer,
+            StreamableHTTPServerTransport,
+            serverName,
+            sessionIdGenerator: randomUUID,
+            z: z2
+          });
+        }
+        session.lastSeenAt = Date.now();
+        await session.transport.handleRequest(req, res, req.body);
+      } catch (error) {
+        if (!res.headersSent) {
+          sendMcpError(res, 500, "Internal server error");
+        }
+      }
+    };
+    app.post("/mcp", async (req, res) => {
+      await handleMcpRequest(req, res);
+    });
+    app.get("/mcp", async (req, res) => {
+      await handleMcpRequest(req, res);
+    });
+    app.delete("/mcp", async (req, res) => {
+      await handleMcpRequest(req, res);
+    });
+    const port = this.options.port ?? await findAvailablePort(http);
+    return new Promise((resolve, reject) => {
+      const server = http.createServer(app);
+      server.on("error", reject);
+      server.listen(port, "127.0.0.1", () => {
+        this.httpServer = server;
+        this.actualPort = port;
+        this.startSessionSweep();
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    this.stopSessionSweep();
+    const activeSessions = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.all(activeSessions.map(async (session) => {
+      await session.transport.close();
+    }));
+    if (!this.httpServer) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.httpServer.close((error) => {
+        this.httpServer = null;
+        this.actualPort = null;
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  async createSession(input) {
+    const createdAt = Date.now();
+    const mcpServer = new input.McpServer({ name: input.serverName, version: MCP_SERVER_VERSION });
+    registerTools2(mcpServer, input.z, this.registrations);
+    let record = null;
+    const transport = new input.StreamableHTTPServerTransport({
+      sessionIdGenerator: input.sessionIdGenerator,
+      onsessioninitialized: (sessionId) => {
+        if (!record) {
+          return;
+        }
+        this.sessions.set(sessionId, record);
+      },
+      onsessionclosed: (sessionId) => {
+        this.sessions.delete(sessionId);
+      }
+    });
+    transport.onclose = () => {
+      const sessionId = transport.sessionId;
+      if (sessionId) {
+        this.sessions.delete(sessionId);
+      }
+    };
+    await mcpServer.connect(transport);
+    record = {
+      mcpServer,
+      transport,
+      createdAt,
+      lastSeenAt: createdAt
+    };
+    return record;
+  }
+  startSessionSweep() {
+    if (this.sessionSweepTimer) {
+      return;
+    }
+    this.sessionSweepTimer = setInterval(() => {
+      void this.closeIdleSessions();
+    }, SESSION_SWEEP_INTERVAL_MS);
+    this.sessionSweepTimer.unref?.();
+  }
+  stopSessionSweep() {
+    if (!this.sessionSweepTimer) {
+      return;
+    }
+    clearInterval(this.sessionSweepTimer);
+    this.sessionSweepTimer = null;
+  }
+  async closeIdleSessions() {
+    const cutoff = Date.now() - SESSION_IDLE_TTL_MS;
+    const idleSessions = [...this.sessions.values()].filter((session) => session.lastSeenAt < cutoff);
+    await Promise.all(idleSessions.map(async (session) => {
+      await session.transport.close();
+    }));
+  }
+};
+function getSessionIdHeader(headerValue) {
+  if (typeof headerValue === "string" && headerValue.length > 0) {
+    return headerValue;
+  }
+  return null;
+}
+function sendMcpError(res, status, message) {
+  res.status(status).json({
+    jsonrpc: "2.0",
+    error: {
+      code: -32e3,
+      message
+    },
+    id: null
+  });
+}
+function registerTools2(mcpServer, z2, registrations) {
+  for (const reg of registrations) {
+    const zodShape = buildZodShape(z2, reg.inputSchema.properties, new Set(reg.inputSchema.required));
+    mcpServer.registerTool(
+      reg.name,
+      {
+        description: reg.description,
+        inputSchema: z2.object(zodShape)
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK handler signature is complex; our McpToolResult is compatible
+      async (args) => reg.execute(args)
+    );
+  }
+}
+async function findAvailablePort(http) {
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const port = PORT_RANGE_START + Math.floor(Math.random() * (PORT_RANGE_END - PORT_RANGE_START));
+    const available = await checkPort(http, port);
+    if (available) {
+      return port;
+    }
+  }
+  return 0;
+}
+function checkPort(http, port) {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.once("error", () => resolve(false));
+    server.listen(port, "127.0.0.1", () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+// src/mcp/sse.ts
+init_registrations();
+init_zod();
+var PORT_RANGE_START2 = 5e4;
+var PORT_RANGE_END2 = 6e4;
+var SESSION_IDLE_TTL_MS2 = 15 * 60 * 1e3;
+var SESSION_SWEEP_INTERVAL_MS2 = 60 * 1e3;
+var ThenvoiMcpSseServer = class {
+  options;
+  registrations;
+  httpServer = null;
+  actualPort = null;
+  sessions = /* @__PURE__ */ new Map();
+  sweepTimer = null;
+  constructor(options) {
+    this.options = options;
+    const regOptions = {
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: options.enableContactTools,
+      additionalTools: options.additionalTools
+    };
+    if (typeof options.tools === "function") {
+      this.registrations = buildRoomScopedRegistrations(options.tools, regOptions);
+    } else {
+      this.registrations = buildSingleContextRegistrations(options.tools, regOptions);
+    }
+  }
+  get port() {
+    return this.actualPort;
+  }
+  get sseUrl() {
+    if (this.actualPort === null) {
+      return null;
+    }
+    return `http://127.0.0.1:${this.actualPort}/sse`;
+  }
+  get toolNames() {
+    return this.registrations.map((registration) => registration.name);
+  }
+  async start() {
+    if (this.httpServer) {
+      return;
+    }
+    const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    const { SSEServerTransport } = await import("@modelcontextprotocol/sdk/server/sse.js");
+    const expressModule = await import("express");
+    const express = expressModule.default ?? expressModule;
+    const http = await import("http");
+    const { z: z2 } = await import("zod");
+    const app = express();
+    app.use(express.json());
+    app.get("/healthz", (_req, res) => {
+      res.json({ status: "ok" });
+    });
+    app.get("/sse", async (_req, res) => {
+      const transport = new SSEServerTransport("/messages", res);
+      const mcpServer = new McpServer({
+        name: this.options.name ?? "thenvoi",
+        version: "1.0.0"
+      });
+      registerTools3(mcpServer, z2, this.registrations);
+      await mcpServer.connect(transport);
+      const sessionId = transport.sessionId;
+      this.sessions.set(sessionId, {
+        mcpServer,
+        transport,
+        lastSeenAt: Date.now()
+      });
+      transport.onclose = () => {
+        this.sessions.delete(sessionId);
+      };
+      transport.onerror = () => {
+        this.sessions.delete(sessionId);
+      };
+      res.on("close", () => {
+        this.sessions.delete(sessionId);
+      });
+    });
+    app.post("/messages", async (req, res) => {
+      const sessionId = typeof req.query.sessionId === "string" ? req.query.sessionId : null;
+      if (!sessionId) {
+        res.status(400).send("Missing sessionId");
+        return;
+      }
+      const session = this.sessions.get(sessionId);
+      if (!session) {
+        res.status(404).send("Session not found");
+        return;
+      }
+      session.lastSeenAt = Date.now();
+      await session.transport.handlePostMessage(req, res, req.body);
+    });
+    const port = this.options.port ?? await findAvailablePort2(http);
+    await new Promise((resolve, reject) => {
+      const server = http.createServer(app);
+      server.on("error", reject);
+      server.listen(port, "127.0.0.1", () => {
+        this.httpServer = server;
+        this.actualPort = port;
+        this.startSessionSweep();
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    this.stopSessionSweep();
+    const sessions = [...this.sessions.values()];
+    this.sessions.clear();
+    await Promise.all(sessions.map(async (session) => {
+      await session.transport.close();
+    }));
+    if (!this.httpServer) {
+      return;
+    }
+    const server = this.httpServer;
+    this.httpServer = null;
+    this.actualPort = null;
+    await new Promise((resolve, reject) => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  startSessionSweep() {
+    if (this.sweepTimer) {
+      return;
+    }
+    this.sweepTimer = setInterval(() => {
+      this.closeIdleSessions();
+    }, SESSION_SWEEP_INTERVAL_MS2);
+    this.sweepTimer.unref?.();
+  }
+  stopSessionSweep() {
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+  }
+  closeIdleSessions() {
+    const cutoff = Date.now() - SESSION_IDLE_TTL_MS2;
+    for (const [sessionId, session] of this.sessions) {
+      if (session.lastSeenAt < cutoff) {
+        this.sessions.delete(sessionId);
+        void session.transport.close();
+      }
+    }
+  }
+};
+function registerTools3(mcpServer, z2, registrations) {
+  for (const registration of registrations) {
+    const zodShape = buildZodShape(
+      z2,
+      registration.inputSchema.properties,
+      new Set(registration.inputSchema.required)
+    );
+    mcpServer.registerTool(
+      registration.name,
+      {
+        description: registration.description,
+        inputSchema: z2.object(zodShape)
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK handler signature is complex; our McpToolResult is compatible
+      async (args) => registration.execute(args)
+    );
+  }
+}
+async function findAvailablePort2(http) {
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const port = PORT_RANGE_START2 + Math.floor(Math.random() * (PORT_RANGE_END2 - PORT_RANGE_START2));
+    if (await checkPort2(http, port)) {
+      return port;
+    }
+  }
+  return 0;
+}
+function checkPort2(http, port) {
+  return new Promise((resolve) => {
+    const server = http.createServer();
+    server.once("error", () => {
+      resolve(false);
+    });
+    server.listen(port, "127.0.0.1", () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+// src/mcp/backends.ts
+async function createThenvoiMcpBackend(options) {
+  const registrations = buildRoomScopedRegistrations(
+    options.getToolsForRoom,
+    {
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: true,
+      additionalTools: options.additionalTools
+    }
+  );
+  const allowedTools = mcpToolNames(new Set(registrations.map((registration) => registration.name)));
+  if (options.kind === "sdk") {
+    const { createThenvoiSdkMcpServer: createThenvoiSdkMcpServer2 } = await Promise.resolve().then(() => (init_sdk(), sdk_exports));
+    const server2 = createThenvoiSdkMcpServer2({
+      enableMemoryTools: options.enableMemoryTools,
+      getToolsForRoom: options.getToolsForRoom,
+      additionalTools: options.additionalTools
+    });
+    return {
+      kind: "sdk",
+      server: server2,
+      allowedTools: server2.allowedTools,
+      stop: async () => void 0
+    };
+  }
+  if (options.kind === "stdio") {
+    const server2 = new ThenvoiMcpStdioServer({
+      tools: options.getToolsForRoom,
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: true,
+      additionalTools: options.additionalTools
+    });
+    await server2.start();
+    return {
+      kind: "stdio",
+      server: server2,
+      allowedTools,
+      stop: async () => {
+        await server2.stop();
+      }
+    };
+  }
+  if (options.kind === "sse") {
+    const server2 = new ThenvoiMcpSseServer({
+      tools: options.getToolsForRoom,
+      enableMemoryTools: options.enableMemoryTools,
+      enableContactTools: true,
+      additionalTools: options.additionalTools
+    });
+    await server2.start();
+    return {
+      kind: "sse",
+      server: server2,
+      allowedTools,
+      stop: async () => {
+        await server2.stop();
+      }
+    };
+  }
+  const server = new ThenvoiMcpServer({
+    tools: options.getToolsForRoom,
+    enableMemoryTools: options.enableMemoryTools,
+    enableContactTools: true,
+    additionalTools: options.additionalTools
+  });
+  await server.start();
+  return {
+    kind: "http",
+    server,
+    allowedTools,
+    stop: async () => {
+      await server.stop();
+    }
+  };
+}
+function getThenvoiSdkMcpServerConfig(backend) {
+  if (backend.kind !== "sdk") {
+    throw new Error(`Expected sdk MCP backend, received ${backend.kind}`);
+  }
+  return backend.server.serverConfig;
+}
+
+// src/mcp/index.ts
+init_registrations();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ThenvoiMcpServer,
+  ThenvoiMcpSseServer,
+  ThenvoiMcpStdioServer,
+  buildRoomScopedRegistrations,
+  buildSingleContextRegistrations,
+  createThenvoiMcpBackend,
+  errorResult,
+  getThenvoiSdkMcpServerConfig,
+  successResult
+});