@band-ai/sdk 0.1.10 → 0.2.1

package/dist/adapters.js

@@ -24,12 +24,13 @@ import {
   VercelAISDKAdapter,
   VercelAISDKToolCallingModel,
   runSingleToolRound
-} from "./chunk-J3M3PFFY.js";
+} from "./chunk-NMZLX7TP.js";
 import {
-  ThenvoiMcpServer,
-  ThenvoiMcpSseServer
-} from "./chunk-2BHHR6YW.js";
-import "./chunk-6RXWL6TC.js";
+  BandMcpServer,
+  BandMcpSseServer,
+  generateAuthToken
+} from "./chunk-4IAXZBXX.js";
+import "./chunk-NT7TBFX2.js";
 import {
   ACPClientHistoryConverter,
   ACPServerHistoryConverter
@@ -47,23 +48,28 @@ import {
   createGatewayServer,
   parseToolCall,
   parseToolResult
-} from "./chunk-XA4N2JPH.js";
+} from "./chunk-TLBCKDQO.js";
 import {
   SimpleAdapter
 } from "./chunk-AVVDPXP4.js";
 import {
   ensureHandlePrefix
-} from "./chunk-RDM4TE4B.js";
+} from "./chunk-LBWKISBS.js";
 import {
   renderSystemPrompt
-} from "./chunk-DNPVCR3S.js";
-import "./chunk-MLROFDKR.js";
+} from "./chunk-WLCM2OXG.js";
+import {
+  MCP_SERVER_NAME
+} from "./chunk-RV76SKFT.js";
 import "./chunk-ZZJRRBPQ.js";
 import "./chunk-3BKAC4OZ.js";
-import "./chunk-OD2G5LFQ.js";
 import {
-  UnsupportedFeatureError
-} from "./chunk-YR3BOQNW.js";
+  NoopLogger
+} from "./chunk-OD2G5LFQ.js";
+import {
+  UnsupportedFeatureError,
+  ValidationError
+} from "./chunk-JY75VSQK.js";
 
 // src/adapters/acp/ACPClientAdapter.ts
 import { spawn } from "child_process";
@@ -129,7 +135,7 @@ function normalizeMcpServers(mcpServers) {
 }
 
 // src/adapters/acp/client.ts
-var ThenvoiACPClient = class {
+var BandACPClient = class {
   sessionChunks = /* @__PURE__ */ new Map();
   permissionHandlers = /* @__PURE__ */ new Map();
   async sessionUpdate(params) {
@@ -341,6 +347,7 @@ var acpModule = new LazyAsyncValue({
 });
 
 // src/adapters/acp/ACPClientAdapter.ts
+var DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 6e4;
 var ACPClientAdapter = class extends SimpleAdapter {
   command;
   cwd;
@@ -356,7 +363,12 @@ var ACPClientAdapter = class extends SimpleAdapter {
   roomTools = /* @__PURE__ */ new Map();
   activeSessions = /* @__PURE__ */ new Set();
   bootstrappedSessions = /* @__PURE__ */ new Set();
+  pendingPermissions = /* @__PURE__ */ new Map();
+  resolvePermission;
+  permissionTimeoutMs;
+  logger;
   backend = null;
+  backendPromise = null;
   client = null;
   connectionHandle = null;
   connection = null;
@@ -381,6 +393,12 @@ var ACPClientAdapter = class extends SimpleAdapter {
     this.additionalMcpTools = [...options.additionalMcpTools ?? []];
     this.clientCapabilities = options.clientCapabilities;
     this.connectionFactory = options.connectionFactory ?? createSubprocessConnection;
+    this.resolvePermission = options.resolvePermission;
+    this.logger = options.logger ?? new NoopLogger();
+    this.permissionTimeoutMs = options.permissionTimeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
+    if (this.resolvePermission && (!Number.isFinite(this.permissionTimeoutMs) || this.permissionTimeoutMs <= 0)) {
+      throw new ValidationError(`permissionTimeoutMs must be a positive finite number, got ${options.permissionTimeoutMs}`);
+    }
   }
   async onStarted(agentName, agentDescription) {
     await super.onStarted(agentName, agentDescription);
@@ -446,6 +464,7 @@ ${message.content}`;
       this.activeSessions.delete(sessionId);
       this.bootstrappedSessions.delete(sessionId);
       this.client?.setPermissionHandler(sessionId, void 0);
+      this.cancelPendingPermissions(sessionId);
     }
   }
   async onRuntimeStop() {
@@ -458,6 +477,7 @@ ${message.content}`;
     this.bootstrappedSessions.clear();
     this.roomToSession.clear();
     this.roomTools.clear();
+    this.cancelAllPendingPermissions();
     this.client = null;
     this.connection = null;
     if (this.backend) {
@@ -497,7 +517,7 @@ ${message.content}`;
   }
   async spawnConnection() {
     const acp = await acpModule.get();
-    const client = new ThenvoiACPClient();
+    const client = new BandACPClient();
     const handle = await this.connectionFactory(client, {
       command: this.command,
       cwd: this.cwd,
@@ -529,11 +549,11 @@ ${message.content}`;
   }
   async getOrCreateSession(roomId, connection) {
     const existingSessionId = this.roomToSession.get(roomId);
+    if (existingSessionId && this.activeSessions.has(existingSessionId)) {
+      return existingSessionId;
+    }
     const mcpServers = await this.buildSessionMcpServers();
     if (existingSessionId) {
-      if (this.activeSessions.has(existingSessionId)) {
-        return existingSessionId;
-      }
       const restored = await this.tryRestoreSession(connection, existingSessionId, mcpServers);
       if (restored) {
         this.activeSessions.add(existingSessionId);
@@ -581,26 +601,26 @@ ${message.content}`;
     if (backend.kind === "http") {
       const url = backend.server.url;
       if (!url) {
-        throw new Error("Thenvoi MCP HTTP backend did not expose a URL");
+        throw new Error("Band MCP HTTP backend did not expose a URL");
       }
       mcpServers.push({
         type: "http",
-        name: "thenvoi",
+        name: MCP_SERVER_NAME,
         url,
-        headers: []
+        headers: [{ name: "Authorization", value: `Bearer ${backend.authToken}` }]
       });
       return mcpServers;
     }
     if (backend.kind === "sse") {
       const url = backend.server.sseUrl;
       if (!url) {
-        throw new Error("Thenvoi MCP SSE backend did not expose a URL");
+        throw new Error("Band MCP SSE backend did not expose a URL");
       }
       mcpServers.push({
         type: "sse",
-        name: "thenvoi",
+        name: MCP_SERVER_NAME,
         url,
-        headers: []
+        headers: [{ name: "Authorization", value: `Bearer ${backend.authToken}` }]
       });
       return mcpServers;
     }
@@ -610,34 +630,51 @@ ${message.content}`;
     if (this.backend) {
       return this.backend;
     }
-    const transport = this.connectionState?.agentCapabilities?.mcpCapabilities?.http ? "http" : this.connectionState?.agentCapabilities?.mcpCapabilities?.sse ? "sse" : "http";
+    this.backendPromise ??= this.createBackend().finally(() => {
+      this.backendPromise = null;
+    });
+    return this.backendPromise;
+  }
+  async createBackend() {
+    const mcpCapabilities = this.connectionState?.agentCapabilities?.mcpCapabilities;
+    const transport = mcpCapabilities?.http ? "http" : mcpCapabilities?.sse ? "sse" : null;
+    if (transport === null) {
+      throw new Error(
+        "ACP agent does not advertise MCP transport support: its initialize response has mcpCapabilities.http and .sse both false or missing, so Band tools cannot be exposed to it over MCP."
+      );
+    }
+    const authToken = generateAuthToken();
     if (transport === "sse") {
-      const server2 = new ThenvoiMcpSseServer({
+      const server2 = new BandMcpSseServer({
         tools: (roomId) => this.roomTools.get(roomId),
         enableMemoryTools: this.enableMemoryTools,
         enableContactTools: true,
-        additionalTools: this.additionalMcpTools
+        additionalTools: this.additionalMcpTools,
+        authToken
       });
       await server2.start();
       this.backend = {
         kind: "sse",
         server: server2,
+        authToken,
         stop: async () => {
           await server2.stop();
         }
       };
       return this.backend;
     }
-    const server = new ThenvoiMcpServer({
+    const server = new BandMcpServer({
       tools: (roomId) => this.roomTools.get(roomId),
       enableMemoryTools: this.enableMemoryTools,
       enableContactTools: true,
-      additionalTools: this.additionalMcpTools
+      additionalTools: this.additionalMcpTools,
+      authToken
     });
     await server.start();
     this.backend = {
       kind: "http",
       server,
+      authToken,
       stop: async () => {
         await server.stop();
       }
@@ -652,39 +689,105 @@ ${message.content}`;
       this.systemPrompt,
       "",
       "## Room Context",
-      "You are connected to Thenvoi using Thenvoi MCP tools.",
-      "Use the Thenvoi tools for any visible room action. Plain text output is not posted back to the room.",
+      "You are connected to Band using Band MCP tools.",
+      "Use the Band tools for any visible room action. Plain text output is not posted back to the room.",
       "",
       `Current room_id: ${roomId}`,
       `Current requester name: ${requesterName}`,
       `Current requester id: ${requesterId}`,
       "",
-      "All Thenvoi MCP tool calls must include room_id."
+      "All Band MCP tool calls must include room_id."
     ].join("\n");
   }
   async handlePermissionRequest(tools, roomId, params) {
-    const selected = choosePermissionOption(params.options);
     const toolName = params.toolCall.title ?? "unknown";
-    await tools.sendEvent(`Permission requested: ${toolName}`, "tool_call", {
-      permission_request: true,
-      tool_name: toolName,
-      tool_call_id: params.toolCall.toolCallId,
-      acp_session_id: params.sessionId,
-      auto_allowed: selected !== null
+    const autoSelection = this.resolvePermission ? void 0 : choosePermissionOption(params.options);
+    const controller = this.resolvePermission ? new AbortController() : void 0;
+    if (controller) {
+      this.trackPending(params.sessionId, controller);
+    }
+    const [, chosenId] = await Promise.all([
+      // This is the room's only "a permission request is pending" signal,
+      // and the only one other room participants ever see — started
+      // immediately rather than serialized in front of a manual wait that
+      // can take up to `permissionTimeoutMs`.
+      tools.sendEvent(`Permission requested: ${toolName}`, "tool_call", {
+        permission_request: true,
+        tool_name: toolName,
+        tool_call_id: params.toolCall.toolCallId,
+        acp_session_id: params.sessionId,
+        auto_allowed: autoSelection !== void 0 && autoSelection !== null
+      }),
+      controller ? this.resolveManually(params.sessionId, params, controller) : Promise.resolve(autoSelection?.optionId)
+    ]);
+    return this.toResponse(chosenId, params.options);
+  }
+  // `undefined`, or an id absent from this request's own `options` (a buggy
+  // or stale caller), both map to `cancelled` — never silently treated as a
+  // deny. A real match, reject-kind options included, maps to `selected`.
+  toResponse(chosenId, options) {
+    const matched = chosenId !== void 0 && options.some((option) => option.optionId === chosenId);
+    return matched ? { outcome: { outcome: "selected", optionId: chosenId } } : { outcome: { outcome: "cancelled" } };
+  }
+  // Races the caller-supplied resolver against a timeout and against
+  // `controller`'s own abort signal — aborted externally by
+  // `cancelPendingPermissions`/`cancelAllPendingPermissions` (fired from
+  // `onCleanup`/`stop()` below) when a room or the whole adapter tears down
+  // while this is still pending. `controller` is the same object tracked in
+  // `pendingPermissions` by the caller, so there is exactly one cancellation
+  // channel here, not a second hand-rolled one alongside it.
+  async resolveManually(sessionId, params, controller) {
+    let timer;
+    const cancelled = new Promise((resolve) => {
+      controller.signal.addEventListener("abort", () => resolve(void 0));
     });
-    if (!selected) {
-      return {
-        outcome: {
-          outcome: "cancelled"
-        }
-      };
+    try {
+      const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(void 0), this.permissionTimeoutMs);
+      });
+      return await Promise.race([
+        // `resolvePermission` is caller-supplied; nothing guarantees it's
+        // `async` or otherwise well-behaved. `Promise.resolve().then(...)`
+        // normalizes a synchronous throw the same way it normalizes a
+        // rejected promise, so both land in the `.catch` below rather than
+        // escaping this race uncaught.
+        Promise.resolve().then(() => this.resolvePermission(params, controller.signal)).catch((error) => {
+          try {
+            this.logger.warn("resolvePermission threw; treating as no answer", { error: String(error) });
+          } catch {
+          }
+          return void 0;
+        }),
+        timeout,
+        cancelled
+      ]);
+    } finally {
+      clearTimeout(timer);
+      this.untrackPending(sessionId, controller);
+      controller.abort();
+    }
+  }
+  trackPending(sessionId, controller) {
+    const pending = this.pendingPermissions.get(sessionId) ?? /* @__PURE__ */ new Set();
+    pending.add(controller);
+    this.pendingPermissions.set(sessionId, pending);
+  }
+  untrackPending(sessionId, controller) {
+    const pending = this.pendingPermissions.get(sessionId);
+    pending?.delete(controller);
+    if (pending?.size === 0) {
+      this.pendingPermissions.delete(sessionId);
+    }
+  }
+  cancelPendingPermissions(sessionId) {
+    for (const controller of this.pendingPermissions.get(sessionId) ?? []) {
+      controller.abort();
+    }
+  }
+  cancelAllPendingPermissions() {
+    for (const sessionId of this.pendingPermissions.keys()) {
+      this.cancelPendingPermissions(sessionId);
     }
-    return {
-      outcome: {
-        outcome: "selected",
-        optionId: selected.optionId
-      }
-    };
   }
   async flushChunks(input) {
     const client = this.client;
@@ -768,7 +871,7 @@ function toErrorMessage(error) {
 // src/adapters/acp/ACPServer.ts
 import { Readable as Readable2, Writable as Writable2 } from "stream";
 
-// src/adapters/acp/ThenvoiACPServerAdapter.ts
+// src/adapters/acp/BandACPServerAdapter.ts
 import { randomUUID } from "crypto";
 
 // src/adapters/acp/eventConverter.ts
@@ -922,12 +1025,12 @@ var AgentRouter = class {
   }
 };
 
-// src/adapters/acp/ThenvoiACPServerAdapter.ts
+// src/adapters/acp/BandACPServerAdapter.ts
 var DEFAULT_MAX_SESSIONS = 100;
 var DEFAULT_PROMPT_TIMEOUT_MS = 3e5;
 var DEFAULT_PROMPT_COMPLETION_GRACE_MS = 250;
-var ThenvoiACPServerAdapter = class extends SimpleAdapter {
-  thenvoiRest;
+var BandACPServerAdapter = class extends SimpleAdapter {
+  bandRest;
   maxSessions;
   responseTimeoutMs;
   promptCompletionGraceMs;
@@ -948,7 +1051,7 @@ var ThenvoiACPServerAdapter = class extends SimpleAdapter {
     super({
       historyConverter: new ACPServerHistoryConverter()
     });
-    this.thenvoiRest = options.thenvoiRest;
+    this.bandRest = options.bandRest;
     this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.responseTimeoutMs = options.responseTimeoutMs ?? DEFAULT_PROMPT_TIMEOUT_MS;
     this.promptCompletionGraceMs = options.promptCompletionGraceMs ?? DEFAULT_PROMPT_COMPLETION_GRACE_MS;
@@ -1010,7 +1113,7 @@ var ThenvoiACPServerAdapter = class extends SimpleAdapter {
   }
   async verifyCredentials() {
     try {
-      await this.thenvoiRest.getAgentMe();
+      await this.bandRest.getAgentMe();
       return true;
     } catch {
       return false;
@@ -1019,7 +1122,7 @@ var ThenvoiACPServerAdapter = class extends SimpleAdapter {
   async onStarted(agentName, agentDescription) {
     await super.onStarted(agentName, agentDescription);
     try {
-      const identity = await this.thenvoiRest.getAgentMe();
+      const identity = await this.bandRest.getAgentMe();
       this.agentId = identity.id;
     } catch {
       this.agentId = null;
@@ -1033,7 +1136,7 @@ var ThenvoiACPServerAdapter = class extends SimpleAdapter {
       throw new Error(`Maximum ACP sessions (${this.maxSessions}) reached`);
     }
     try {
-      const room = await this.thenvoiRest.createChat();
+      const room = await this.bandRest.createChat();
       const sessionId = randomUUID();
       const normalizedMcpServers = normalizeMcpServers(input.mcpServers);
       this.sessionToRoom.set(sessionId, room.id);
@@ -1043,7 +1146,7 @@ var ThenvoiACPServerAdapter = class extends SimpleAdapter {
         this.sessionMcpServers.set(sessionId, normalizedMcpServers);
       }
       try {
-        await this.thenvoiRest.createChatEvent(room.id, {
+        await this.bandRest.createChatEvent(room.id, {
           content: "ACP session context",
           messageType: "task",
           metadata: {
@@ -1076,10 +1179,10 @@ var ThenvoiACPServerAdapter = class extends SimpleAdapter {
     this.pendingPrompts.set(roomId, pending);
     const resolved = this.router.resolve(text, this.sessionModeIds.get(sessionId));
     const promptText = this.prependSessionContext(sessionId, resolved.text);
-    const participants = await this.thenvoiRest.listChatParticipants(roomId);
+    const participants = await this.bandRest.listChatParticipants(roomId);
     const mentions = this.resolveMentions(participants, resolved.targetPeer);
     try {
-      await this.thenvoiRest.createChatMessage(roomId, {
+      await this.bandRest.createChatMessage(roomId, {
         content: promptText,
         mentions
       });
@@ -1332,7 +1435,7 @@ var ACPServer = class {
     this.authMethods = options?.authMethods ?? [{
       id: "api_key",
       name: "API Key",
-      description: "Authenticate with THENVOI_API_KEY."
+      description: "Authenticate with BAND_API_KEY (legacy THENVOI_API_KEY)."
     }];
     this.agentInfo = options?.agentInfo ?? {};
     this.extensionHandler = options?.extensionHandler ?? new CursorExtensionHandler();
@@ -1385,8 +1488,8 @@ var ACPServer = class {
         }
       },
       agentInfo: {
-        name: this.agentInfo.name ?? "thenvoi-agent",
-        title: this.agentInfo.title ?? this.adapter.displayName ?? "Thenvoi Agent",
+        name: this.agentInfo.name ?? "band-agent",
+        title: this.agentInfo.title ?? this.adapter.displayName ?? "Band Agent",
         version: this.agentInfo.version ?? "0.1.0"
       },
       authMethods: this.authMethods
@@ -1558,6 +1661,7 @@ export {
   ACPServer,
   AnthropicAdapter,
   AnthropicToolCallingModel,
+  BandACPServerAdapter,
   CODEX_REASONING_EFFORTS,
   CODEX_REASONING_SUMMARIES,
   CODEX_WEB_SEARCH_MODES,
@@ -1581,7 +1685,6 @@ export {
   OpencodeAdapter,
   ParlantAdapter,
   ParlantHistoryConverter,
-  ThenvoiACPServerAdapter,
   ToolCallingAdapter,
   VercelAISDKAdapter,
   VercelAISDKToolCallingModel,

package/dist/backends-D-dBdDm-.d.ts

@@ -0,0 +1,27 @@
+import { A as AdapterToolsProtocol } from './protocols-Bwwcql0h.js';
+import { M as McpToolRegistration, B as BandSdkMcpServer } from './sdk-qKJtMma_.js';
+
+type BandMcpBackendKind = "sdk" | "http" | "sse" | "stdio";
+interface BandMcpBackend {
+    kind: BandMcpBackendKind;
+    server: unknown;
+    allowedTools: string[];
+    /** Bearer token callers must present to reach `server`. Set for "http"/"sse", which listen on a loopback network port. */
+    authToken?: string;
+    stop(): Promise<void>;
+}
+interface CreateBandMcpBackendOptions {
+    kind: BandMcpBackendKind;
+    enableMemoryTools: boolean;
+    /**
+     * Returns the tools for a given room. In single-room mode (`multiRoom: false`),
+     * called once during init with `""` — must return the tools instance regardless of the argument.
+     */
+    getToolsForRoom: (roomId: string) => AdapterToolsProtocol | undefined;
+    additionalTools?: McpToolRegistration[];
+    multiRoom?: boolean;
+}
+declare function createBandMcpBackend(options: CreateBandMcpBackendOptions): Promise<BandMcpBackend>;
+declare function getBandSdkMcpServerConfig(backend: BandMcpBackend): BandSdkMcpServer["serverConfig"];
+
+export { type BandMcpBackend as B, type CreateBandMcpBackendOptions as C, type BandMcpBackendKind as a, createBandMcpBackend as c, getBandSdkMcpServerConfig as g };

package/dist/backends-ZLxmQrTZ.d.cts

@@ -0,0 +1,27 @@
+import { A as AdapterToolsProtocol } from './protocols-Bz1rxcUg.cjs';
+import { M as McpToolRegistration, B as BandSdkMcpServer } from './sdk-BTciSLRQ.cjs';
+
+type BandMcpBackendKind = "sdk" | "http" | "sse" | "stdio";
+interface BandMcpBackend {
+    kind: BandMcpBackendKind;
+    server: unknown;
+    allowedTools: string[];
+    /** Bearer token callers must present to reach `server`. Set for "http"/"sse", which listen on a loopback network port. */
+    authToken?: string;
+    stop(): Promise<void>;
+}
+interface CreateBandMcpBackendOptions {
+    kind: BandMcpBackendKind;
+    enableMemoryTools: boolean;
+    /**
+     * Returns the tools for a given room. In single-room mode (`multiRoom: false`),
+     * called once during init with `""` — must return the tools instance regardless of the argument.
+     */
+    getToolsForRoom: (roomId: string) => AdapterToolsProtocol | undefined;
+    additionalTools?: McpToolRegistration[];
+    multiRoom?: boolean;
+}
+declare function createBandMcpBackend(options: CreateBandMcpBackendOptions): Promise<BandMcpBackend>;
+declare function getBandSdkMcpServerConfig(backend: BandMcpBackend): BandSdkMcpServer["serverConfig"];
+
+export { type BandMcpBackend as B, type CreateBandMcpBackendOptions as C, type BandMcpBackendKind as a, createBandMcpBackend as c, getBandSdkMcpServerConfig as g };