@band-ai/sdk 0.1.2 → 0.1.6

package/dist/adapters.cjs

@@ -30,6 +30,35 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// 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/core/errors.ts
 var ThenvoiSdkError, UnsupportedFeatureError, ValidationError, RuntimeStateError;
 var init_errors = __esm({
@@ -420,35 +449,6 @@ var init_schemas = __esm({
   }
 });
 
-// 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);
@@ -576,42 +576,42 @@ var init_registrations = __esm({
 });
 
 // src/mcp/zod.ts
-function buildZodShape(z3, properties, required) {
+function buildZodShape(z4, properties, required) {
   const shape = {};
   for (const [name, schema] of Object.entries(properties)) {
-    const validator = jsonSchemaToZod(z3, schema);
+    const validator = jsonSchemaToZod(z4, schema);
     shape[name] = required.has(name) ? validator : validator.optional();
   }
   return shape;
 }
-function jsonSchemaToZod(z3, schema) {
+function jsonSchemaToZod(z4, 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 z3.enum(values);
+        return z4.enum(values);
       }
     }
-    return z3.string();
+    return z4.string();
   }
   if (type === "integer" || type === "number") {
-    return z3.number();
+    return z4.number();
   }
   if (type === "boolean") {
-    return z3.boolean();
+    return z4.boolean();
   }
   if (type === "array") {
     const itemSchema = schema.items;
     if (itemSchema && typeof itemSchema === "object") {
-      return z3.array(jsonSchemaToZod(z3, itemSchema));
+      return z4.array(jsonSchemaToZod(z4, itemSchema));
     }
-    return z3.array(z3.unknown());
+    return z4.array(z4.unknown());
   }
   if (type === "object") {
-    return z3.record(z3.string(), z3.unknown());
+    return z4.record(z4.string(), z4.unknown());
   }
-  return z3.unknown();
+  return z4.unknown();
 }
 var init_zod = __esm({
   "src/mcp/zod.ts"() {
@@ -647,7 +647,7 @@ function createThenvoiSdkMcpServer(options) {
 }
 function toSdkToolDefinition(registration) {
   const shape = buildZodShape(
-    import_zod4.z,
+    import_zod5.z,
     registration.inputSchema.properties,
     new Set(registration.inputSchema.required)
   );
@@ -658,12 +658,12 @@ function toSdkToolDefinition(registration) {
     async (args) => registration.execute(args)
   );
 }
-var import_claude_agent_sdk, import_zod4;
+var import_claude_agent_sdk, import_zod5;
 var init_sdk = __esm({
   "src/mcp/sdk.ts"() {
     "use strict";
     import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
-    import_zod4 = require("zod");
+    import_zod5 = require("zod");
     init_schemas();
     init_registrations();
     init_zod();
@@ -774,7 +774,6 @@ var GenericAdapter = class extends SimpleAdapter {
 // src/adapters/acp/ACPClientAdapter.ts
 var import_node_child_process = require("child_process");
 var import_node_stream = require("stream");
-var import_sdk = require("@agentclientprotocol/sdk");
 
 // src/converters/acp-client.ts
 var ACPClientHistoryConverter = class {
@@ -894,72 +893,6 @@ ${customSection}`.trim();
   return templateString.replaceAll("{agent_name}", agentName).replaceAll("{agent_description}", agentDescription).replaceAll("{custom_section}", customSection);
 }
 
-// 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: z3 } = await import("zod");
-    const mcpServer = new McpServer({
-      name: this.options.name ?? "thenvoi",
-      version: "1.0.0"
-    });
-    registerTools(mcpServer, z3, 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, z3, registrations) {
-  for (const reg of registrations) {
-    const zodShape = buildZodShape(z3, reg.inputSchema.properties, new Set(reg.inputSchema.required));
-    mcpServer.registerTool(
-      reg.name,
-      {
-        description: reg.description,
-        inputSchema: z3.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();
@@ -1011,7 +944,7 @@ var ThenvoiMcpServer = class {
     const express = expressModule.default ?? expressModule;
     const http = await import("http");
     const { randomUUID: randomUUID7 } = await import("crypto");
-    const { z: z3 } = await import("zod");
+    const { z: z4 } = await import("zod");
     const serverName = this.options.name ?? "thenvoi";
     const app = express();
     app.use(express.json());
@@ -1032,7 +965,7 @@ var ThenvoiMcpServer = class {
             StreamableHTTPServerTransport,
             serverName,
             sessionIdGenerator: randomUUID7,
-            z: z3
+            z: z4
           });
         }
         session.lastSeenAt = Date.now();
@@ -1089,7 +1022,7 @@ var ThenvoiMcpServer = class {
   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);
+    registerTools(mcpServer, input.z, this.registrations);
     let record = null;
     const transport = new input.StreamableHTTPServerTransport({
       sessionIdGenerator: input.sessionIdGenerator,
@@ -1158,14 +1091,14 @@ function sendMcpError(res, status, message) {
     id: null
   });
 }
-function registerTools2(mcpServer, z3, registrations) {
+function registerTools(mcpServer, z4, registrations) {
   for (const reg of registrations) {
-    const zodShape = buildZodShape(z3, reg.inputSchema.properties, new Set(reg.inputSchema.required));
+    const zodShape = buildZodShape(z4, reg.inputSchema.properties, new Set(reg.inputSchema.required));
     mcpServer.registerTool(
       reg.name,
       {
         description: reg.description,
-        inputSchema: z3.object(zodShape)
+        inputSchema: z4.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)
@@ -1240,7 +1173,7 @@ var ThenvoiMcpSseServer = class {
     const expressModule = await import("express");
     const express = expressModule.default ?? expressModule;
     const http = await import("http");
-    const { z: z3 } = await import("zod");
+    const { z: z4 } = await import("zod");
     const app = express();
     app.use(express.json());
     app.get("/healthz", (_req, res) => {
@@ -1252,7 +1185,7 @@ var ThenvoiMcpSseServer = class {
         name: this.options.name ?? "thenvoi",
         version: "1.0.0"
       });
-      registerTools3(mcpServer, z3, this.registrations);
+      registerTools2(mcpServer, z4, this.registrations);
       await mcpServer.connect(transport);
       const sessionId = transport.sessionId;
       this.sessions.set(sessionId, {
@@ -1344,10 +1277,10 @@ var ThenvoiMcpSseServer = class {
     }
   }
 };
-function registerTools3(mcpServer, z3, registrations) {
+function registerTools2(mcpServer, z4, registrations) {
   for (const registration of registrations) {
     const zodShape = buildZodShape(
-      z3,
+      z4,
       registration.inputSchema.properties,
       new Set(registration.inputSchema.required)
     );
@@ -1355,7 +1288,7 @@ function registerTools3(mcpServer, z3, registrations) {
       registration.name,
       {
         description: registration.description,
-        inputSchema: z3.object(zodShape)
+        inputSchema: z4.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)
@@ -1383,85 +1316,6 @@ function checkPort2(http, port) {
   });
 }
 
-// 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();
-    }
-  };
-}
-
-// src/mcp/index.ts
-init_registrations();
-
 // src/adapters/acp/types.ts
 var DEFAULT_ACP_SERVER_MODES = [
   {
@@ -1722,6 +1576,67 @@ function toOptionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 
+// src/adapters/acp/loader.ts
+init_errors();
+
+// src/adapters/shared/lazyAsyncValue.ts
+var DEFAULT_RETRY_BACKOFF_MS = 1e3;
+var LazyAsyncValue = class {
+  load;
+  onRejected;
+  retryBackoffMs;
+  value = null;
+  pending = null;
+  lastFailureAt = 0;
+  constructor(options) {
+    this.load = options.load;
+    this.onRejected = options.onRejected;
+    this.retryBackoffMs = options.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
+  }
+  get current() {
+    return this.value;
+  }
+  async get() {
+    if (this.value) {
+      return this.value;
+    }
+    if (!this.pending) {
+      if (this.lastFailureAt > 0 && Date.now() - this.lastFailureAt < this.retryBackoffMs) {
+        throw new Error(
+          `LazyAsyncValue load failed recently; retrying after ${this.retryBackoffMs}ms backoff.`
+        );
+      }
+      this.pending = this.load().then((value) => {
+        this.value = value;
+        this.lastFailureAt = 0;
+        return value;
+      }).catch((error) => {
+        this.pending = null;
+        this.lastFailureAt = Date.now();
+        this.onRejected?.(error);
+        throw error;
+      });
+    }
+    return this.pending;
+  }
+  clear() {
+    this.value = null;
+    this.pending = null;
+    this.lastFailureAt = 0;
+  }
+};
+
+// src/adapters/acp/loader.ts
+var acpModule = new LazyAsyncValue({
+  load: async () => {
+    return await import("@agentclientprotocol/sdk").catch((error) => {
+      throw new UnsupportedFeatureError(
+        `ACP adapters require optional dependency "@agentclientprotocol/sdk". Install it with "pnpm add @agentclientprotocol/sdk". (${error instanceof Error ? error.message : String(error)})`
+      );
+    });
+  }
+});
+
 // src/adapters/acp/ACPClientAdapter.ts
 var ACPClientAdapter = class extends SimpleAdapter {
   command;
@@ -1878,6 +1793,7 @@ ${message.content}`;
     }
   }
   async spawnConnection() {
+    const acp = await acpModule.get();
     const client = new ThenvoiACPClient();
     const handle = await this.connectionFactory(client, {
       command: this.command,
@@ -1886,7 +1802,7 @@ ${message.content}`;
     });
     const connection = handle.connection;
     const initializeResult = await connection.initialize({
-      protocolVersion: import_sdk.PROTOCOL_VERSION,
+      protocolVersion: acp.PROTOCOL_VERSION,
       clientCapabilities: this.clientCapabilities ?? {}
     });
     if (this.authMethod) {
@@ -1985,19 +1901,44 @@ ${message.content}`;
       });
       return mcpServers;
     }
-    throw new Error(`Unsupported MCP backend for ACP client injection: ${backend.kind}`);
+    return mcpServers;
   }
   async getOrCreateBackend() {
     if (this.backend) {
       return this.backend;
     }
     const transport = this.connectionState?.agentCapabilities?.mcpCapabilities?.http ? "http" : this.connectionState?.agentCapabilities?.mcpCapabilities?.sse ? "sse" : "http";
-    this.backend = await createThenvoiMcpBackend({
-      kind: transport,
+    if (transport === "sse") {
+      const server2 = new ThenvoiMcpSseServer({
+        tools: (roomId) => this.roomTools.get(roomId),
+        enableMemoryTools: this.enableMemoryTools,
+        enableContactTools: true,
+        additionalTools: this.additionalMcpTools
+      });
+      await server2.start();
+      this.backend = {
+        kind: "sse",
+        server: server2,
+        stop: async () => {
+          await server2.stop();
+        }
+      };
+      return this.backend;
+    }
+    const server = new ThenvoiMcpServer({
+      tools: (roomId) => this.roomTools.get(roomId),
       enableMemoryTools: this.enableMemoryTools,
-      getToolsForRoom: (roomId) => this.roomTools.get(roomId),
+      enableContactTools: true,
       additionalTools: this.additionalMcpTools
     });
+    await server.start();
+    this.backend = {
+      kind: "http",
+      server,
+      stop: async () => {
+        await server.stop();
+      }
+    };
     return this.backend;
   }
   buildSystemContext(roomId, message) {
@@ -2067,6 +2008,7 @@ ${message.content}`;
   }
 };
 async function createSubprocessConnection(client, options) {
+  const acp = await acpModule.get();
   const child = (0, import_node_child_process.spawn)(options.command[0], options.command.slice(1), {
     cwd: options.cwd,
     env: {
@@ -2078,11 +2020,11 @@ async function createSubprocessConnection(client, options) {
   if (!child.stdin || !child.stdout) {
     throw new Error("ACP subprocess did not expose stdio pipes");
   }
-  const stream = (0, import_sdk.ndJsonStream)(
+  const stream = acp.ndJsonStream(
     import_node_stream.Writable.toWeb(child.stdin),
     import_node_stream.Readable.toWeb(child.stdout)
   );
-  const connection = new import_sdk.ClientSideConnection(() => client, stream);
+  const connection = new acp.ClientSideConnection(() => client, stream);
   return {
     connection,
     stop: async () => {
@@ -2122,7 +2064,6 @@ function toErrorMessage(error) {
 
 // src/adapters/acp/ACPServer.ts
 var import_node_stream2 = require("stream");
-var import_sdk2 = require("@agentclientprotocol/sdk");
 
 // src/adapters/acp/ThenvoiACPServerAdapter.ts
 var import_node_crypto = require("crypto");
@@ -2791,11 +2732,12 @@ var ACPServer = class {
     this.agentInfo = options?.agentInfo ?? {};
     this.extensionHandler = options?.extensionHandler ?? new CursorExtensionHandler();
   }
-  connectStream(stream) {
+  async connectStream(stream) {
     if (this.connection && !this.connection.signal.aborted) {
       return this.connection;
     }
-    this.connection = new import_sdk2.AgentSideConnection((connection) => {
+    const acp = await acpModule.get();
+    this.connection = new acp.AgentSideConnection((connection) => {
       this.adapter.bindConnection(connection);
       return this;
     }, stream);
@@ -2809,19 +2751,20 @@ var ACPServer = class {
   connectStdio(options) {
     const stdin = options?.stdin ?? process.stdin;
     const stdout = options?.stdout ?? process.stdout;
-    return this.connectStream(
-      (0, import_sdk2.ndJsonStream)(
+    return acpModule.get().then((acp) => this.connectStream(
+      acp.ndJsonStream(
         import_node_stream2.Writable.toWeb(stdout),
         import_node_stream2.Readable.toWeb(stdin)
       )
-    );
+    ));
   }
   get closed() {
     return this.connection?.closed ?? Promise.resolve();
   }
   async initialize(params) {
+    const acp = await acpModule.get();
     return {
-      protocolVersion: params.protocolVersion === import_sdk2.PROTOCOL_VERSION ? params.protocolVersion : import_sdk2.PROTOCOL_VERSION,
+      protocolVersion: params.protocolVersion === acp.PROTOCOL_VERSION ? params.protocolVersion : acp.PROTOCOL_VERSION,
       agentCapabilities: {
         loadSession: true,
         promptCapabilities: {
@@ -2856,7 +2799,8 @@ var ACPServer = class {
   }
   async loadSession(params) {
     if (!this.adapter.hasSession(params.sessionId)) {
-      throw import_sdk2.RequestError.resourceNotFound(params.sessionId);
+      const acp = await acpModule.get();
+      throw acp.RequestError.resourceNotFound(params.sessionId);
     }
     this.adapter.updateSessionContext(params.sessionId, {
       cwd: params.cwd,
@@ -2875,7 +2819,8 @@ var ACPServer = class {
   }
   async unstable_forkSession(params) {
     if (!this.adapter.hasSession(params.sessionId)) {
-      throw import_sdk2.RequestError.resourceNotFound(params.sessionId);
+      const acp = await acpModule.get();
+      throw acp.RequestError.resourceNotFound(params.sessionId);
     }
     const sessionId = await this.adapter.createSession({
       cwd: params.cwd,
@@ -2887,7 +2832,8 @@ var ACPServer = class {
   }
   async unstable_resumeSession(params) {
     if (!this.adapter.hasSession(params.sessionId)) {
-      throw import_sdk2.RequestError.resourceNotFound(params.sessionId);
+      const acp = await acpModule.get();
+      throw acp.RequestError.resourceNotFound(params.sessionId);
     }
     this.adapter.updateSessionContext(params.sessionId, {
       cwd: params.cwd,
@@ -2903,14 +2849,16 @@ var ACPServer = class {
   }
   async setSessionMode(params) {
     if (!this.adapter.hasSession(params.sessionId)) {
-      throw import_sdk2.RequestError.resourceNotFound(params.sessionId);
+      const acp = await acpModule.get();
+      throw acp.RequestError.resourceNotFound(params.sessionId);
     }
     this.adapter.setSessionMode(params.sessionId, params.modeId);
     return {};
   }
   async unstable_setSessionModel(params) {
     if (!this.adapter.hasSession(params.sessionId)) {
-      throw import_sdk2.RequestError.resourceNotFound(params.sessionId);
+      const acp = await acpModule.get();
+      throw acp.RequestError.resourceNotFound(params.sessionId);
     }
     this.adapter.setSessionModel(params.sessionId, params.modelId);
     return {};
@@ -2922,11 +2870,13 @@ var ACPServer = class {
   }
   async authenticate(params) {
     if (params.methodId !== "api_key" && params.methodId !== "cursor_login") {
-      throw import_sdk2.RequestError.authRequired(void 0, `Unsupported auth method: ${params.methodId}`);
+      const acp = await acpModule.get();
+      throw acp.RequestError.authRequired(void 0, `Unsupported auth method: ${params.methodId}`);
     }
     const ok = await this.adapter.verifyCredentials();
     if (!ok) {
-      throw import_sdk2.RequestError.authRequired(void 0, "Authentication failed");
+      const acp = await acpModule.get();
+      throw acp.RequestError.authRequired(void 0, "Authentication failed");
     }
     return {};
   }
@@ -3046,7 +2996,7 @@ function formatHistoryForLlm(messages, options) {
 }
 
 // src/runtime/tools/customTools.ts
-var import_zod6 = require("zod");
+var import_zod3 = require("zod");
 var import_zod_to_json_schema = require("zod-to-json-schema");
 var CustomToolDefinitionError = class extends Error {
   constructor(message) {
@@ -3344,53 +3294,6 @@ function runSingleToolRound(model, request) {
 // src/adapters/vercel-ai-sdk/model.ts
 init_errors();
 
-// src/adapters/shared/lazyAsyncValue.ts
-var DEFAULT_RETRY_BACKOFF_MS = 1e3;
-var LazyAsyncValue = class {
-  load;
-  onRejected;
-  retryBackoffMs;
-  value = null;
-  pending = null;
-  lastFailureAt = 0;
-  constructor(options) {
-    this.load = options.load;
-    this.onRejected = options.onRejected;
-    this.retryBackoffMs = options.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
-  }
-  get current() {
-    return this.value;
-  }
-  async get() {
-    if (this.value) {
-      return this.value;
-    }
-    if (!this.pending) {
-      if (this.lastFailureAt > 0 && Date.now() - this.lastFailureAt < this.retryBackoffMs) {
-        throw new Error(
-          `LazyAsyncValue load failed recently; retrying after ${this.retryBackoffMs}ms backoff.`
-        );
-      }
-      this.pending = this.load().then((value) => {
-        this.value = value;
-        this.lastFailureAt = 0;
-        return value;
-      }).catch((error) => {
-        this.pending = null;
-        this.lastFailureAt = Date.now();
-        this.onRejected?.(error);
-        throw error;
-      });
-    }
-    return this.pending;
-  }
-  clear() {
-    this.value = null;
-    this.pending = null;
-    this.lastFailureAt = 0;
-  }
-};
-
 // src/adapters/shared/coercion.ts
 init_protocols();
 function asOptionalRecord(value) {
@@ -7833,6 +7736,148 @@ async function loadLettaClientFactory(config) {
   });
 }
 
+// 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: z4 } = await import("zod");
+    const mcpServer = new McpServer({
+      name: this.options.name ?? "thenvoi",
+      version: "1.0.0"
+    });
+    registerTools3(mcpServer, z4, 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 registerTools3(mcpServer, z4, registrations) {
+  for (const reg of registrations) {
+    const zodShape = buildZodShape(z4, reg.inputSchema.properties, new Set(reg.inputSchema.required));
+    mcpServer.registerTool(
+      reg.name,
+      {
+        description: reg.description,
+        inputSchema: z4.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/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();
+    }
+  };
+}
+
 // src/adapters/opencode/OpencodeAdapter.ts
 init_registrations();
 
@@ -8997,6 +9042,10 @@ function delay(ms) {
   });
 }
 
+// src/adapters/claude-sdk/ClaudeSDKAdapter.ts
+init_errors();
+init_schemas();
+
 // src/adapters/shared/conversationPrompt.ts
 function buildConversationPrompt(options) {
   const parts = [];
@@ -9030,11 +9079,57 @@ function extractClaudeSessionId(raw) {
   return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
 }
 
-// src/mcp/claude.ts
-init_sdk();
-
 // src/adapters/claude-sdk/ClaudeSDKAdapter.ts
+init_registrations();
+init_zod();
+var import_zod8 = require("zod");
 var DEFAULT_MODEL2 = "claude-sonnet-4-6";
+var thenvoiMcpBridgeFactory = new LazyAsyncValue({
+  load: async () => {
+    const module2 = await import("@anthropic-ai/claude-agent-sdk").catch((error) => {
+      throw new UnsupportedFeatureError(
+        `ClaudeSDKAdapter requires optional dependency "@anthropic-ai/claude-agent-sdk" when MCP tools are enabled. Install it with "pnpm add @anthropic-ai/claude-agent-sdk". (${error instanceof Error ? error.message : String(error)})`
+      );
+    });
+    if (typeof module2.createSdkMcpServer !== "function" || typeof module2.tool !== "function") {
+      throw new UnsupportedFeatureError(
+        'ClaudeSDKAdapter requires optional dependency "@anthropic-ai/claude-agent-sdk" when MCP tools are enabled. Install it with "pnpm add @anthropic-ai/claude-agent-sdk".'
+      );
+    }
+    const createSdkMcpServer2 = module2.createSdkMcpServer;
+    const defineTool = module2.tool;
+    return (input) => {
+      const registrations = buildRoomScopedRegistrations(
+        input.getToolsForRoom,
+        {
+          enableMemoryTools: input.enableMemoryTools,
+          enableContactTools: true,
+          additionalTools: input.additionalTools
+        }
+      );
+      const toolDefinitions = registrations.map((registration) => {
+        const shape = buildZodShape(
+          import_zod8.z,
+          registration.inputSchema.properties,
+          new Set(registration.inputSchema.required)
+        );
+        return defineTool(
+          registration.name,
+          registration.description,
+          shape,
+          async (args) => registration.execute(args)
+        );
+      });
+      return {
+        serverConfig: createSdkMcpServer2({
+          name: "thenvoi",
+          tools: toolDefinitions
+        }),
+        allowedTools: mcpToolNames(new Set(registrations.map((registration) => registration.name)))
+      };
+    };
+  }
+});
 var ClaudeSDKAdapter = class extends SimpleAdapter {
   model;
   customSection;
@@ -9077,7 +9172,8 @@ var ClaudeSDKAdapter = class extends SimpleAdapter {
       includeBaseInstructions: this.includeBaseInstructions
     });
     if (this.enableMcpTools) {
-      this.mcpBridge = createThenvoiSdkMcpServer({
+      const createThenvoiMcpBridge = await thenvoiMcpBridgeFactory.get();
+      this.mcpBridge = createThenvoiMcpBridge({
         enableMemoryTools: this.enableMemoryTools,
         getToolsForRoom: (roomId) => this.roomTools.get(roomId),
         additionalTools: this.additionalMcpTools.length > 0 ? this.additionalMcpTools : void 0
@@ -9201,9 +9297,13 @@ var ClaudeSDKAdapter = class extends SimpleAdapter {
   }
 };
 async function loadClaudeQuery() {
-  const module2 = await import("@anthropic-ai/claude-agent-sdk");
+  const module2 = await import("@anthropic-ai/claude-agent-sdk").catch((error) => {
+    throw new UnsupportedFeatureError(
+      `ClaudeSDKAdapter requires optional dependency "@anthropic-ai/claude-agent-sdk". Install it with "pnpm add @anthropic-ai/claude-agent-sdk". (${error instanceof Error ? error.message : String(error)})`
+    );
+  });
   if (!module2.query) {
-    throw new Error("@anthropic-ai/claude-agent-sdk did not export query()");
+    throw new UnsupportedFeatureError("@anthropic-ai/claude-agent-sdk did not export query()");
   }
   return module2.query;
 }