@band-ai/sdk 0.2.1 → 0.3.0

package/dist/adapters.js

@@ -23,14 +23,15 @@ import {
   ToolCallingAdapter,
   VercelAISDKAdapter,
   VercelAISDKToolCallingModel,
-  runSingleToolRound
-} from "./chunk-NMZLX7TP.js";
+  runSingleToolRound,
+  systemUpdateParts
+} from "./chunk-MQBBWYRP.js";
 import {
   BandMcpServer,
   BandMcpSseServer,
   generateAuthToken
-} from "./chunk-4IAXZBXX.js";
-import "./chunk-NT7TBFX2.js";
+} from "./chunk-WA7CHXUS.js";
+import "./chunk-XWHWJP4I.js";
 import {
   ACPClientHistoryConverter,
   ACPServerHistoryConverter
@@ -48,21 +49,26 @@ import {
   createGatewayServer,
   parseToolCall,
   parseToolResult
-} from "./chunk-TLBCKDQO.js";
+} from "./chunk-K5KAEYPF.js";
 import {
   SimpleAdapter
 } from "./chunk-AVVDPXP4.js";
 import {
-  ensureHandlePrefix
-} from "./chunk-LBWKISBS.js";
+  ensureHandlePrefix,
+  mentionSubjectsFromMetadata,
+  replaceUuidMentions
+} from "./chunk-OH6VVVKT.js";
 import {
   renderSystemPrompt
-} from "./chunk-WLCM2OXG.js";
+} from "./chunk-YJ42AZO4.js";
 import {
   MCP_SERVER_NAME
-} from "./chunk-RV76SKFT.js";
-import "./chunk-ZZJRRBPQ.js";
-import "./chunk-3BKAC4OZ.js";
+} from "./chunk-MQY74R7D.js";
+import {
+  isBlankEventContent
+} from "./chunk-F63TPOI3.js";
+import "./chunk-KXJ74J73.js";
+import "./chunk-JADCAMZY.js";
 import {
   NoopLogger
 } from "./chunk-OD2G5LFQ.js";
@@ -75,6 +81,21 @@ import {
 import { spawn } from "child_process";
 import { Readable, Writable } from "stream";
 
+// src/adapters/shared/withTimeout.ts
+async function withTimeout(promise, timeoutMs, message) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/adapters/acp/types.ts
 var DEFAULT_ACP_SERVER_MODES = [
   {
@@ -348,6 +369,7 @@ var acpModule = new LazyAsyncValue({
 
 // src/adapters/acp/ACPClientAdapter.ts
 var DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 6e4;
+var SET_SESSION_MODE_TIMEOUT_MS = 1e4;
 var ACPClientAdapter = class extends SimpleAdapter {
   command;
   cwd;
@@ -366,6 +388,7 @@ var ACPClientAdapter = class extends SimpleAdapter {
   pendingPermissions = /* @__PURE__ */ new Map();
   resolvePermission;
   permissionTimeoutMs;
+  requestedPermissionMode;
   logger;
   backend = null;
   backendPromise = null;
@@ -396,6 +419,10 @@ var ACPClientAdapter = class extends SimpleAdapter {
     this.resolvePermission = options.resolvePermission;
     this.logger = options.logger ?? new NoopLogger();
     this.permissionTimeoutMs = options.permissionTimeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
+    this.requestedPermissionMode = options.requestedPermissionMode;
+    if (this.requestedPermissionMode !== void 0 && this.requestedPermissionMode.length === 0) {
+      throw new ValidationError("requestedPermissionMode must be a non-empty mode id, got an empty string");
+    }
     if (this.resolvePermission && (!Number.isFinite(this.permissionTimeoutMs) || this.permissionTimeoutMs <= 0)) {
       throw new ValidationError(`permissionTimeoutMs must be a positive finite number, got ${options.permissionTimeoutMs}`);
     }
@@ -410,7 +437,7 @@ var ACPClientAdapter = class extends SimpleAdapter {
     });
     await this.ensureConnection();
   }
-  async onMessage(message, tools, history, _participantsMessage, _contactsMessage, context) {
+  async onMessage(message, tools, history, participantsMessage, contactsMessage, context) {
     if (context.isSessionBootstrap) {
       this.rehydrate(history);
     }
@@ -426,9 +453,11 @@ var ACPClientAdapter = class extends SimpleAdapter {
       sessionId,
       (params) => this.handlePermissionRequest(tools, context.roomId, params)
     );
-    const promptText = this.bootstrappedSessions.has(sessionId) ? message.content : `${this.buildSystemContext(context.roomId, message)}
+    const content = replaceUuidMentions(message.content, mentionSubjectsFromMetadata(message.metadata));
+    const messageWithContext = [...systemUpdateParts(participantsMessage, contactsMessage), content].join("\n\n");
+    const promptText = this.bootstrappedSessions.has(sessionId) ? messageWithContext : `${this.buildSystemContext(context.roomId, message)}
 
-${message.content}`;
+${messageWithContext}`;
     this.bootstrappedSessions.add(sessionId);
     try {
       await connection.prompt({
@@ -555,9 +584,10 @@ ${message.content}`;
     const mcpServers = await this.buildSessionMcpServers();
     if (existingSessionId) {
       const restored = await this.tryRestoreSession(connection, existingSessionId, mcpServers);
-      if (restored) {
+      if (restored.ok) {
         this.activeSessions.add(existingSessionId);
         this.bootstrappedSessions.add(existingSessionId);
+        await this.applyRequestedPermissionMode(connection, existingSessionId, restored.modes);
         return existingSessionId;
       }
     }
@@ -567,30 +597,52 @@ ${message.content}`;
     });
     this.roomToSession.set(roomId, created.sessionId);
     this.activeSessions.add(created.sessionId);
+    await this.applyRequestedPermissionMode(connection, created.sessionId, created.modes);
     return created.sessionId;
   }
   async tryRestoreSession(connection, sessionId, mcpServers) {
+    const capabilities = this.connectionState?.agentCapabilities;
+    const params = { cwd: this.cwd, mcpServers, sessionId };
+    const restore = capabilities?.loadSession ? () => connection.loadSession(params) : capabilities?.sessionCapabilities?.resume ? () => connection.unstable_resumeSession(params) : null;
+    if (!restore) {
+      return { ok: false };
+    }
     try {
-      if (this.connectionState?.agentCapabilities?.loadSession) {
-        await connection.loadSession({
-          cwd: this.cwd,
-          mcpServers,
-          sessionId
-        });
-        return true;
-      }
-      if (this.connectionState?.agentCapabilities?.sessionCapabilities?.resume) {
-        await connection.unstable_resumeSession({
-          cwd: this.cwd,
-          mcpServers,
-          sessionId
-        });
-        return true;
-      }
+      const restored = await restore();
+      return { ok: true, modes: restored?.modes };
     } catch {
-      return false;
+      return { ok: false };
+    }
+  }
+  // Best-effort: never throws, so a mode switch going wrong can't take a
+  // session establishment down with it.
+  async applyRequestedPermissionMode(connection, sessionId, modes) {
+    const requestedModeId = this.requestedPermissionMode;
+    if (!requestedModeId || !modes || modes.currentModeId === requestedModeId) {
+      return;
+    }
+    const availableModes = Array.isArray(modes.availableModes) ? modes.availableModes : [];
+    if (!availableModes.some((mode) => mode?.id === requestedModeId)) {
+      this.safeWarn("requested permission mode is not advertised by this session", {
+        sessionId,
+        requestedModeId,
+        availableModeIds: availableModes.map((mode) => mode?.id)
+      });
+      return;
+    }
+    try {
+      await withTimeout(
+        connection.setSessionMode({ sessionId, modeId: requestedModeId }),
+        SET_SESSION_MODE_TIMEOUT_MS,
+        `setSessionMode did not respond within ${SET_SESSION_MODE_TIMEOUT_MS}ms`
+      );
+    } catch (error) {
+      this.safeWarn("failed to switch session into the requested permission mode", {
+        sessionId,
+        requestedModeId,
+        error: String(error)
+      });
     }
-    return false;
   }
   async buildSessionMcpServers() {
     const mcpServers = [...this.mcpServers];
@@ -729,6 +781,18 @@ ${message.content}`;
     const matched = chosenId !== void 0 && options.some((option) => option.optionId === chosenId);
     return matched ? { outcome: { outcome: "selected", optionId: chosenId } } : { outcome: { outcome: "cancelled" } };
   }
+  // A caller-supplied `Logger` isn't guaranteed to be synchronous or
+  // non-throwing. Every best-effort warning in this file routes through here
+  // so one failing sink — a synchronous throw, or an `async` implementation
+  // rejecting (the `Logger` interface's `void` return type permits either;
+  // a bare try/catch only ever catches the former) — can't turn a warning
+  // into an unhandled rejection in its place.
+  safeWarn(message, context) {
+    try {
+      Promise.resolve(this.logger.warn(message, context)).catch(() => void 0);
+    } catch {
+    }
+  }
   // Races the caller-supplied resolver against a timeout and against
   // `controller`'s own abort signal — aborted externally by
   // `cancelPendingPermissions`/`cancelAllPendingPermissions` (fired from
@@ -752,10 +816,7 @@ ${message.content}`;
         // 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 {
-          }
+          this.safeWarn("resolvePermission threw; treating as no answer", { error: String(error) });
           return void 0;
         }),
         timeout,
@@ -795,13 +856,14 @@ ${message.content}`;
       return;
     }
     for (const chunk of client.getCollectedChunks(input.sessionId)) {
+      if (isBlankEventContent(chunk.content)) {
+        continue;
+      }
       if (chunk.chunkType === "text") {
-        if (chunk.content.length > 0) {
-          await input.tools.sendMessage(chunk.content, [{
-            id: input.senderId,
-            handle: input.senderHandle
-          }]);
-        }
+        await input.tools.sendMessage(chunk.content, [{
+          id: input.senderId,
+          handle: input.senderHandle
+        }]);
         continue;
       }
       const messageType = chunk.chunkType === "plan" ? "task" : chunk.chunkType;

package/dist/chunk-F63TPOI3.js

@@ -0,0 +1,29 @@
+import {
+  ValidationError
+} from "./chunk-JY75VSQK.js";
+
+// src/contracts/chatEvents.ts
+var CHAT_EVENT_TYPES = ["tool_call", "tool_result", "thought", "error", "task"];
+var CHAT_MESSAGE_TYPES = ["text", ...CHAT_EVENT_TYPES];
+function isChatEventType(value) {
+  return CHAT_EVENT_TYPES.includes(value);
+}
+function assertChatEventType(value) {
+  if (!isChatEventType(value)) {
+    throw new ValidationError(
+      `Invalid event message_type '${value}'. Expected one of: ${CHAT_EVENT_TYPES.join(", ")}`
+    );
+  }
+}
+var VISIBLE_CONTENT_PATTERN = /[\p{L}\p{N}\p{P}\p{S}]/u;
+function isBlankEventContent(content) {
+  return !VISIBLE_CONTENT_PATTERN.test(content);
+}
+
+export {
+  CHAT_EVENT_TYPES,
+  CHAT_MESSAGE_TYPES,
+  isChatEventType,
+  assertChatEventType,
+  isBlankEventContent
+};

package/dist/{chunk-3BKAC4OZ.js → chunk-JADCAMZY.js}

@@ -21,6 +21,13 @@ function isToolExecutorError(value) {
   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 isStructuredToolFailure(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const payload = value;
+  return payload.ok === false && typeof payload.message === "string";
+}
 function toLegacyToolExecutorErrorMessage(value) {
   if (typeof value === "string") {
     return value;
@@ -39,6 +46,7 @@ var DEFAULT_AGENT_TOOLS_CAPABILITIES = {
 export {
   createToolExecutorError,
   isToolExecutorError,
+  isStructuredToolFailure,
   toLegacyToolExecutorErrorMessage,
   DEFAULT_AGENT_TOOLS_CAPABILITIES
 };