@band-ai/sdk 0.1.6 → 0.2.0

package/dist/{chunk-I5EZG52P.js → chunk-N2QTUMGO.js}

@@ -3,21 +3,45 @@ import {
   SYNTHETIC_CONTACT_EVENTS_SENDER_ID,
   SYNTHETIC_CONTACT_EVENTS_SENDER_NAME,
   SYNTHETIC_SENDER_TYPE,
-  buildParticipantsMessage
-} from "./chunk-INA6YZTZ.js";
+  buildParticipantsMessage,
+  toParticipantRecord,
+  toParticipantRecordFromRest
+} from "./chunk-LBWKISBS.js";
 import {
   CHAT_EVENT_TYPES,
   CHAT_TOOL_NAMES,
+  MEMORY_LIST_SCOPES,
+  MEMORY_SEGMENTS,
+  MEMORY_STATUSES,
+  MEMORY_STORE_SCOPES,
+  MEMORY_SYSTEMS,
   MEMORY_TOOL_NAMES,
+  MEMORY_TYPES,
   TOOL_MODELS,
   assertChatEventType,
-  getToolDescription
-} from "./chunk-GVEQ3RAH.js";
+  expectedList,
+  expectedMemoryTypesForSystem,
+  getToolDescription,
+  isMemoryListScope,
+  isMemorySegment,
+  isMemoryStatus,
+  isMemoryStoreScope,
+  isMemorySystem,
+  isMemoryType,
+  isMemoryTypeForSystem,
+  memoryTypeForSystemError
+} from "./chunk-RV76SKFT.js";
+import {
+  WebSocketDisconnectError,
+  genericCloseReason,
+  parseSupersedeDisconnectReason,
+  parseUpgradeDisconnectReason
+} from "./chunk-US226AS4.js";
 import {
   DEFAULT_REQUEST_OPTIONS,
   FernRestAdapter,
   fetchPaginated
-} from "./chunk-SG4WLD2H.js";
+} from "./chunk-EAI2M3WM.js";
 import {
   DEFAULT_AGENT_TOOLS_CAPABILITIES,
   createToolExecutorError,
@@ -31,7 +55,7 @@ import {
   TransportError,
   UnsupportedFeatureError,
   ValidationError
-} from "./chunk-YR3BOQNW.js";
+} from "./chunk-JY75VSQK.js";
 
 // src/contracts/capabilities.ts
 var CAPABILITY_LABELS = {
@@ -143,55 +167,117 @@ var payloadSchemas = {
 
 // src/platform/streaming/PhoenixChannelsTransport.ts
 import { Socket } from "phoenix";
+
+// src/platform/streaming/nodeWebSocketFactory.ts
 import { WebSocket as NodeWebSocket } from "ws";
+function createNodeWebSocketFactory(headers) {
+  const Constructor = NodeWebSocket;
+  class BandNodeWebSocket {
+    constructor(address, protocols) {
+      const socket = new Constructor(address, protocols, headers ? { headers } : void 0);
+      socket.once("unexpected-response", (request, response) => {
+        void emitUpgradeError(socket, request, response);
+      });
+      return socket;
+    }
+  }
+  return BandNodeWebSocket;
+}
+async function emitUpgradeError(websocket, request, response) {
+  const body = await readResponseBody(response);
+  const error = new Error(
+    `Unexpected server response: ${response.statusCode ?? "unknown"}`
+  );
+  error.status = response.statusCode;
+  error.body = body;
+  error.headers = response.headers;
+  request.destroy();
+  websocket.emit("error", error);
+  websocket.emit("close", 1006, Buffer.alloc(0));
+}
+async function readResponseBody(response) {
+  const chunks = [];
+  for await (const chunk of response) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/platform/streaming/PhoenixChannelsTransport.ts
 var PhoenixChannelsTransport = class {
   socket;
+  agentId;
   channels = /* @__PURE__ */ new Map();
   channelRefs = /* @__PURE__ */ new Map();
   pendingJoins = /* @__PURE__ */ new Map();
   logger;
+  onTerminalDisconnect;
   onHandlerError;
   connected = false;
   connectPromise = null;
   connectResolve = null;
+  connectReject = null;
+  lastDisconnectReason = null;
+  terminalDisconnectError = null;
+  runForeverWaiters = /* @__PURE__ */ new Set();
+  stoppingReconnect = false;
+  suppressNextCloseReason = false;
   constructor(options) {
     this.logger = options.logger ?? new NoopLogger();
+    this.agentId = options.agentId;
+    this.onTerminalDisconnect = options.onTerminalDisconnect;
     let wsUrl = options.wsUrl;
     if (wsUrl.endsWith("/websocket")) {
       wsUrl = wsUrl.slice(0, -"/websocket".length);
     }
+    const reconnectAfterMs = options.reconnectAfterMs ?? ((tries) => [1e3, 2e3, 5e3, 1e4, 3e4][tries - 1] ?? 3e4);
     this.socket = new Socket(wsUrl, {
       params: {
-        api_key: options.apiKey,
-        agent_id: options.agentId
+        agent_id: options.agentId,
+        ...options.conflictPolicy ? { on_conflict: options.conflictPolicy } : {}
       },
       heartbeatIntervalMs: options.heartbeatIntervalMs,
-      reconnectAfterMs: options.reconnectAfterMs ?? ((tries) => [1e3, 2e3, 5e3, 1e4, 3e4][tries - 1] ?? 3e4),
-      transport: options.websocketFactory ?? resolveWebSocketFactory()
+      reconnectAfterMs: (tries) => {
+        if (this.terminalDisconnectError) {
+          return Number.POSITIVE_INFINITY;
+        }
+        return reconnectAfterMs(tries);
+      },
+      transport: options.websocketFactory ?? resolveWebSocketFactory(options.apiKey)
     });
     this.socket.onOpen(() => {
-      this.connected = true;
-      this.connectResolve?.();
-      this.connectResolve = null;
-      this.logger.info("Phoenix socket opened", {
-        channels: getSocketChannelCount(this.socket)
-      });
+      void this.handleOpen();
     });
     this.socket.onClose((event) => {
-      this.connected = false;
-      if (getSocketChannelCount(this.socket) === 0) {
-        this.socket.disconnect();
-      }
-      this.logger.info("Phoenix socket closed", {
-        code: event?.code ?? null,
-        reason: event?.reason ?? null
-      });
+      this.recordSocketClose(event);
     });
     this.socket.onError((event) => {
+      const errorEvent = unwrapErrorEvent(event);
+      const upgradeReason = parseUpgradeDisconnectReason(errorEvent);
+      if (upgradeReason) {
+        if (upgradeReason.retryable) {
+          this.lastDisconnectReason = upgradeReason;
+          this.connectReject?.(new WebSocketDisconnectError(upgradeReason));
+          this.stopReconnectIfNoChannels({ suppressCloseReason: true });
+        } else {
+          this.recordTerminalDisconnect(upgradeReason);
+        }
+        this.logger.warn("Phoenix socket upgrade failed", {
+          reason: upgradeReason
+        });
+        return;
+      }
+      this.connectReject?.(
+        new TransportError("Phoenix socket connection failed", errorEvent)
+      );
+      this.stopReconnectIfNoChannels({ suppressCloseReason: true });
       this.logger.warn("Phoenix socket error", { event });
     });
   }
   async connect() {
+    if (this.terminalDisconnectError) {
+      throw this.terminalDisconnectError;
+    }
     if (this.connected) {
       return;
     }
@@ -215,15 +301,30 @@ var PhoenixChannelsTransport = class {
     await this.connectPromise;
   }
   async disconnect() {
-    for (const topic of this.channels.keys()) {
-      await this.leave(topic);
-    }
+    const results = await Promise.allSettled(
+      [...this.channels.keys()].map((topic) => this.leave(topic))
+    );
     this.socket.disconnect();
     this.connected = false;
+    const failures = [];
+    for (const result of results) {
+      if (result.status === "rejected") {
+        failures.push(result.reason);
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(
+        failures,
+        "Failed to leave one or more Phoenix topics during disconnect"
+      );
+    }
   }
   isConnected() {
     return this.connected;
   }
+  getDisconnectReason() {
+    return this.lastDisconnectReason;
+  }
   async join(topic, handlers) {
     if (this.channels.has(topic)) {
       return;
@@ -259,7 +360,10 @@ var PhoenixChannelsTransport = class {
         channel.join().receive("ok", () => resolve()).receive(
           "error",
           (error) => reject(new TransportError(`Failed to join topic ${topic}`, error))
-        ).receive("timeout", () => reject(new TransportError(`Timeout joining topic ${topic}`)));
+        ).receive(
+          "timeout",
+          () => reject(new TransportError(`Timeout joining topic ${topic}`))
+        );
       });
     } catch (error) {
       for (const [event, ref] of refs) {
@@ -287,19 +391,127 @@ var PhoenixChannelsTransport = class {
       channel.leave().receive("ok", () => resolve()).receive(
         "error",
         (error) => reject(new TransportError(`Failed to leave topic ${topic}`, error))
-      ).receive("timeout", () => reject(new TransportError(`Timeout leaving topic ${topic}`)));
+      ).receive(
+        "timeout",
+        () => reject(new TransportError(`Timeout leaving topic ${topic}`))
+      );
     });
     this.channels.delete(topic);
     this.logger.debug("Left topic", { topic });
   }
   async runForever(signal) {
+    if (this.terminalDisconnectError) {
+      throw this.terminalDisconnectError;
+    }
     if (signal.aborted) {
       return;
     }
-    await new Promise((resolve) => {
-      signal.addEventListener("abort", () => resolve(), { once: true });
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const abortController = new AbortController();
+      const waiter = {
+        reject: (error) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          this.runForeverWaiters.delete(waiter);
+          abortController.abort();
+          reject(error);
+        }
+      };
+      this.runForeverWaiters.add(waiter);
+      signal.addEventListener(
+        "abort",
+        () => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          this.runForeverWaiters.delete(waiter);
+          resolve();
+        },
+        { once: true, signal: abortController.signal }
+      );
+    });
+  }
+  async handleOpen() {
+    try {
+      await this.subscribeAgentControl();
+    } catch (error) {
+      this.connected = false;
+      this.socket.disconnect();
+      this.connectReject?.(
+        error instanceof Error ? error : new TransportError(String(error))
+      );
+      this.logger.warn("Failed to join mandatory agent_control channel", {
+        error
+      });
+      return;
+    }
+    this.connected = true;
+    this.connectResolve?.();
+    this.connectResolve = null;
+    this.connectReject = null;
+    this.logger.info("Phoenix socket opened", {
+      channels: getSocketChannelCount(this.socket)
+    });
+  }
+  stopReconnectIfNoChannels(options = {}) {
+    if (this.stoppingReconnect || getSocketChannelCount(this.socket) !== 0) {
+      return;
+    }
+    this.suppressNextCloseReason = options.suppressCloseReason ?? false;
+    this.stoppingReconnect = true;
+    this.socket.disconnect();
+    this.stoppingReconnect = false;
+  }
+  async subscribeAgentControl() {
+    if (!this.agentId) {
+      return;
+    }
+    await this.join(`agent_control:${this.agentId}`, {
+      supersede: (payload) => {
+        const reason = parseSupersedeDisconnectReason(payload);
+        if (!reason) {
+          this.logger.warn("Invalid agent_control supersede payload", {
+            payload
+          });
+          return;
+        }
+        this.recordTerminalDisconnect(reason);
+      }
     });
   }
+  recordSocketClose(event) {
+    this.connected = false;
+    const suppressCloseReason = this.suppressNextCloseReason;
+    this.suppressNextCloseReason = false;
+    this.stopReconnectIfNoChannels();
+    if (!suppressCloseReason && !this.terminalDisconnectError && !this.lastDisconnectReason) {
+      this.lastDisconnectReason = genericCloseReason(event);
+    }
+    this.logger.info("Phoenix socket closed", {
+      code: event?.code ?? null,
+      reason: event?.reason ?? null,
+      platformReason: this.lastDisconnectReason
+    });
+  }
+  recordTerminalDisconnect(reason) {
+    if (this.terminalDisconnectError) {
+      return;
+    }
+    const error = new WebSocketDisconnectError(reason);
+    this.lastDisconnectReason = reason;
+    this.terminalDisconnectError = error;
+    this.onTerminalDisconnect?.(reason);
+    this.connectReject?.(error);
+    for (const waiter of this.runForeverWaiters) {
+      waiter.reject(error);
+    }
+    this.runForeverWaiters.clear();
+    this.socket.disconnect();
+  }
   async waitForConnection(timeoutMs = 1e4) {
     if (this.connected) {
       return;
@@ -307,20 +519,43 @@ var PhoenixChannelsTransport = class {
     await new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.connectResolve = null;
-        reject(new TransportError("Timed out waiting for Phoenix socket connection"));
+        this.connectReject = null;
+        reject(
+          new TransportError("Timed out waiting for Phoenix socket connection")
+        );
       }, timeoutMs);
       this.connectResolve = () => {
         clearTimeout(timeout);
+        this.connectReject = null;
         resolve();
       };
+      this.connectReject = (error) => {
+        clearTimeout(timeout);
+        this.connectResolve = null;
+        this.connectReject = null;
+        reject(
+          error instanceof Error ? error : new TransportError(String(error))
+        );
+      };
     });
   }
 };
-function resolveWebSocketFactory() {
+function resolveWebSocketFactory(apiKey) {
   if (typeof process !== "undefined" && process.versions?.node) {
-    return NodeWebSocket;
+    return createNodeWebSocketFactory({ "x-api-key": apiKey });
   }
-  return WebSocket;
+  throw new TransportError(
+    "Phoenix WebSocket API-key auth requires a WebSocket transport that can set handshake headers."
+  );
+}
+function unwrapErrorEvent(event) {
+  if (!isErrorEvent(event)) {
+    return event;
+  }
+  return event.error;
+}
+function isErrorEvent(event) {
+  return typeof event === "object" && event !== null && "error" in event;
 }
 function removeSocketChannel(socket, channel) {
   const candidate = socket;
@@ -334,14 +569,20 @@ function getSocketChannelCount(socket) {
   return candidate.channels.length;
 }
 
-// src/platform/ThenvoiLink.ts
-import { ThenvoiClient } from "@thenvoi/rest-client";
-var DEFAULT_WS_URL = "wss://app.thenvoi.com/api/v1/socket";
+// src/platform/BandLink.ts
+import { BandClient } from "@band-ai/rest-client";
+var DEFAULT_WS_URL = "wss://app.band.ai/api/v1/socket";
 function deriveDefaultRestUrl(wsUrl) {
   const parsed = new URL(wsUrl);
   const protocol = parsed.protocol === "ws:" ? "http:" : "https:";
   return `${protocol}//${parsed.host}`;
 }
+function roomTopics(roomId) {
+  return {
+    chat: `chat_room:${roomId}`,
+    participants: `room_participants:${roomId}`
+  };
+}
 function toPlatformMessage(roomId, message) {
   return {
     id: message.id,
@@ -355,7 +596,7 @@ function toPlatformMessage(roomId, message) {
     createdAt: new Date(message.inserted_at)
   };
 }
-var ThenvoiLink = class {
+var BandLink = class {
   agentId;
   apiKey;
   wsUrl;
@@ -368,6 +609,8 @@ var ThenvoiLink = class {
   eventQueue = [];
   waiters = [];
   connected = false;
+  lastDisconnectReason = null;
+  terminalDisconnectError = null;
   constructor(options) {
     this.agentId = options.agentId;
     this.apiKey = options.apiKey;
@@ -379,7 +622,7 @@ var ThenvoiLink = class {
       ...options.capabilities
     };
     const restApi = options.restApi ?? new FernRestAdapter(
-      new ThenvoiClient({
+      new BandClient({
         apiKey: this.apiKey,
         baseUrl: this.restUrl
       })
@@ -389,17 +632,35 @@ var ThenvoiLink = class {
       wsUrl: this.wsUrl,
       apiKey: this.apiKey,
       agentId: this.agentId,
-      logger: this.logger
+      logger: this.logger,
+      conflictPolicy: options.conflictPolicy,
+      onTerminalDisconnect: (reason) => {
+        this.recordDisconnectReason(reason);
+      }
     });
   }
   isConnected() {
     return this.connected;
   }
+  getDisconnectReason() {
+    return this.lastDisconnectReason;
+  }
   async connect() {
     if (this.connected) {
       return;
     }
-    await this.transport.connect();
+    try {
+      await this.transport.connect();
+    } catch (error) {
+      if (error instanceof WebSocketDisconnectError) {
+        if (error.reason.retryable) {
+          this.lastDisconnectReason = error.reason;
+        } else {
+          this.recordDisconnectError(error);
+        }
+      }
+      throw error;
+    }
     this.connected = true;
   }
   async disconnect() {
@@ -413,8 +674,23 @@ var ThenvoiLink = class {
     this.connected = false;
   }
   async runForever(signal) {
+    if (this.terminalDisconnectError) {
+      throw this.terminalDisconnectError;
+    }
     await this.transport.runForever(signal);
   }
+  recordDisconnectReason(reason) {
+    this.recordDisconnectError(new WebSocketDisconnectError(reason));
+  }
+  recordDisconnectError(error) {
+    this.connected = false;
+    this.lastDisconnectReason = error.reason;
+    this.terminalDisconnectError = error;
+    while (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      waiter?.reject(error);
+    }
+  }
   queueEvent(event) {
     const waiter = this.waiters.shift();
     if (waiter) {
@@ -439,32 +715,42 @@ var ThenvoiLink = class {
     if (this.subscribedRooms.has(roomId)) {
       return;
     }
-    await this.transport.join(`chat_room:${roomId}`, {
-      message_created: (payload) => {
-        this.emit("message_created", payload, roomId);
-      }
-    });
-    await this.transport.join(`room_participants:${roomId}`, {
-      participant_added: (payload) => {
-        this.emit("participant_added", payload, roomId);
-      },
-      participant_removed: (payload) => {
-        this.emit("participant_removed", payload, roomId);
-      },
-      room_deleted: (payload) => {
-        this.emit("room_deleted", payload, roomId);
-      }
-    });
+    await this.joinRoomTopics(roomId);
     this.subscribedRooms.add(roomId);
   }
   async unsubscribeRoom(roomId) {
     if (!this.subscribedRooms.has(roomId)) {
       return;
     }
-    await this.transport.leave(`chat_room:${roomId}`);
-    await this.transport.leave(`room_participants:${roomId}`);
+    const topics = roomTopics(roomId);
+    await this.transport.leave(topics.chat);
+    await this.transport.leave(topics.participants);
     this.subscribedRooms.delete(roomId);
   }
+  async joinRoomTopics(roomId) {
+    const topics = roomTopics(roomId);
+    await this.transport.join(topics.chat, {
+      message_created: (payload) => {
+        this.emit("message_created", payload, roomId);
+      }
+    });
+    try {
+      await this.transport.join(topics.participants, {
+        participant_added: (payload) => {
+          this.emit("participant_added", payload, roomId);
+        },
+        participant_removed: (payload) => {
+          this.emit("participant_removed", payload, roomId);
+        },
+        room_deleted: (payload) => {
+          this.emit("room_deleted", payload, roomId);
+        }
+      });
+    } catch (error) {
+      await this.transport.leave(topics.chat);
+      throw error;
+    }
+  }
   async subscribeAgentContacts() {
     assertCapability(this.capabilities, "contacts", "Contacts streaming");
     await this.transport.join(`agent_contacts:${this.agentId}`, {
@@ -486,6 +772,9 @@ var ThenvoiLink = class {
     await this.transport.leave(`agent_contacts:${this.agentId}`);
   }
   async nextEvent(signal) {
+    if (this.terminalDisconnectError) {
+      throw this.terminalDisconnectError;
+    }
     if (signal?.aborted) {
       return null;
     }
@@ -493,19 +782,19 @@ var ThenvoiLink = class {
     if (queued) {
       return queued;
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
       let settled = false;
       const onAbort = () => {
         const index = this.waiters.indexOf(waiter);
         if (index >= 0) {
           this.waiters.splice(index, 1);
         }
-        finalize(null);
+        finalizeResolve(null);
       };
       const cleanup = () => {
         signal?.removeEventListener("abort", onAbort);
       };
-      const finalize = (event) => {
+      const finalizeResolve = (event) => {
         if (settled) {
           return;
         }
@@ -513,8 +802,17 @@ var ThenvoiLink = class {
         cleanup();
         resolve(event);
       };
+      const finalizeReject = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(error);
+      };
       const waiter = {
-        resolve: finalize,
+        resolve: finalizeResolve,
+        reject: finalizeReject,
         cleanup
       };
       this.waiters.push(waiter);
@@ -526,7 +824,10 @@ var ThenvoiLink = class {
       next: async () => {
         const value = await this.nextEvent();
         if (value === null) {
-          return { done: true, value: void 0 };
+          return {
+            done: true,
+            value: void 0
+          };
         }
         return { done: false, value };
       }
@@ -608,7 +909,9 @@ var ThenvoiLink = class {
   }
   async listChats(request, requestOptions) {
     if (!this.rest.listChats) {
-      throw new UnsupportedFeatureError("Chat listing is not available in current REST adapter");
+      throw new UnsupportedFeatureError(
+        "Chat listing is not available in current REST adapter"
+      );
     }
     return this.rest.listChats(request, requestOptions);
   }
@@ -934,6 +1237,7 @@ var Execution = class {
 };
 
 // src/runtime/tools/AgentTools.ts
+import { ParticipantRoster } from "@band-ai/band-sdk-core";
 var REQUIRED_ADAPTER_TOOL_METHODS = [
   "sendMessage",
   "sendEvent",
@@ -968,51 +1272,17 @@ var CONTACT_REQUEST_ACTIONS = /* @__PURE__ */ new Set([
   "reject",
   "cancel"
 ]);
-var MEMORY_SYSTEMS = /* @__PURE__ */ new Set([
-  "sensory",
-  "working",
-  "long_term"
-]);
-var MEMORY_TYPES = /* @__PURE__ */ new Set([
-  "iconic",
-  "echoic",
-  "haptic",
-  "episodic",
-  "semantic",
-  "procedural"
-]);
-var MEMORY_SEGMENTS = /* @__PURE__ */ new Set([
-  "user",
-  "agent",
-  "tool",
-  "guideline"
-]);
-var LIST_MEMORY_SCOPES = /* @__PURE__ */ new Set([
-  "subject",
-  "organization",
-  "all"
-]);
-var LIST_MEMORY_STATUSES = /* @__PURE__ */ new Set([
-  "active",
-  "superseded",
-  "archived",
-  "all"
-]);
-var MEMORY_SCOPES = /* @__PURE__ */ new Set([
-  "subject",
-  "organization"
-]);
 var AgentTools = class {
   roomId;
   capabilities;
   rest;
-  participants;
+  roster;
   adapterTools;
   toolHandlers;
   constructor(options) {
     this.roomId = options.roomId;
     this.rest = options.rest;
-    this.participants = options.participants ?? [];
+    this.roster = options.roster ?? new ParticipantRoster();
     this.capabilities = {
       ...DEFAULT_AGENT_TOOLS_CAPABILITIES,
       ...options.capabilities
@@ -1024,17 +1294,20 @@ var AgentTools = class {
     return this.adapterTools;
   }
   async sendMessage(content, mentions = []) {
-    if (mentions.length > 0 && typeof mentions[0] === "string" && this.participants.length === 0) {
-      await this.syncParticipants();
+    let participants;
+    if (mentions.length > 0 && typeof mentions[0] === "string") {
+      participants = this.roster.list();
+      if (participants.length === 0) {
+        participants = await this.syncParticipants();
+      }
     }
-    const resolvedMentions = this.resolveMentions(mentions);
+    const resolvedMentions = this.resolveMentions(mentions, participants);
     return this.rest.createChatMessage(
       this.roomId,
       {
         content,
         mentions: resolvedMentions
-      },
-      DEFAULT_REQUEST_OPTIONS
+      }
     );
   }
   async sendEvent(content, messageType, metadata) {
@@ -1045,8 +1318,7 @@ var AgentTools = class {
         content,
         messageType,
         metadata
-      },
-      DEFAULT_REQUEST_OPTIONS
+      }
     );
   }
   async createChatroom(taskId) {
@@ -1085,7 +1357,7 @@ var AgentTools = class {
       type: String(peer.type ?? "Agent"),
       handle: typeof peer.handle === "string" ? peer.handle : null
     };
-    this.participants.push(participantRecord);
+    this.roster.add(participantRecord);
     return {
       ...participantRecord,
       status: "added"
@@ -1100,7 +1372,7 @@ var AgentTools = class {
       throw new ValidationError(`Participant '${name}' not found in room`);
     }
     await this.rest.removeChatParticipant(this.roomId, String(participant.id), DEFAULT_REQUEST_OPTIONS);
-    this.replaceParticipants(this.participants.filter((entry) => entry.id !== participant.id));
+    this.roster.remove(participant.id);
     return {
       id: participant.id,
       name,
@@ -1128,17 +1400,12 @@ var AgentTools = class {
   }
   async fetchParticipants() {
     const participants = await this.rest.listChatParticipants(this.roomId, DEFAULT_REQUEST_OPTIONS);
-    return participants.map((participant) => ({
-      id: participant.id,
-      name: participant.name,
-      type: participant.type,
-      handle: participant.handle ?? null
-    }));
+    return participants.map(toParticipantRecordFromRest);
   }
   async syncParticipants() {
     const participants = await this.fetchParticipants();
-    this.replaceParticipants(participants);
-    return [...this.participants];
+    this.roster.setAll(participants);
+    return this.roster.list().map(toParticipantRecord);
   }
   async executeToolCall(toolName, arguments_) {
     const validationError = validateToolArgs(toolName, arguments_);
@@ -1186,7 +1453,7 @@ var AgentTools = class {
       if (!CHAT_TOOL_NAMES.has(name) && !this.capabilities.contacts) {
         return false;
       }
-      if (name === "thenvoi_lookup_peers" && !this.capabilities.peers) {
+      if (name === "band_lookup_peers" && !this.capabilities.peers) {
         return false;
       }
       return true;
@@ -1381,7 +1648,7 @@ var AgentTools = class {
     }
     return this.rest.archiveMemory(normalizedMemoryId, DEFAULT_REQUEST_OPTIONS);
   }
-  resolveMentions(mentions) {
+  resolveMentions(mentions, participants) {
     if (mentions.length === 0) {
       return [];
     }
@@ -1394,7 +1661,7 @@ var AgentTools = class {
     const participantsByHandle = /* @__PURE__ */ new Map();
     const participantsById = /* @__PURE__ */ new Map();
     const participantsByName = /* @__PURE__ */ new Map();
-    for (const participant of this.participants) {
+    for (const participant of participants ?? []) {
       const ref = {
         id: String(participant.id),
         handle: typeof participant.handle === "string" ? participant.handle : void 0
@@ -1450,9 +1717,6 @@ var AgentTools = class {
   normalizeMentionHandle(handle) {
     return handle.trim().replace(/^@+/, "").toLowerCase();
   }
-  replaceParticipants(participants) {
-    this.participants.splice(0, this.participants.length, ...participants);
-  }
   buildAdapterTools() {
     const tools = {
       capabilities: this.capabilities
@@ -1483,51 +1747,51 @@ var AgentTools = class {
   }
   buildMessagingToolHandlers() {
     return {
-      thenvoi_send_message: async (arguments_) => this.sendMessage(
+      band_send_message: async (arguments_) => this.sendMessage(
         String(arguments_.content ?? ""),
         this.normalizeMentionInput(arguments_.mentions)
       ),
-      thenvoi_send_event: async (arguments_) => this.sendEvent(
+      band_send_event: async (arguments_) => this.sendEvent(
         String(arguments_.content ?? ""),
         String(arguments_.message_type ?? "task"),
         this.normalizeOptionalMetadata(arguments_.metadata)
       ),
-      thenvoi_add_participant: async (arguments_) => this.addParticipant(String(arguments_.name ?? ""), String(arguments_.role ?? "member")),
-      thenvoi_remove_participant: async (arguments_) => this.removeParticipant(String(arguments_.name ?? "")),
-      thenvoi_lookup_peers: async (arguments_) => this.lookupPeers(
+      band_add_participant: async (arguments_) => this.addParticipant(String(arguments_.name ?? ""), String(arguments_.role ?? "member")),
+      band_remove_participant: async (arguments_) => this.removeParticipant(String(arguments_.name ?? "")),
+      band_lookup_peers: async (arguments_) => this.lookupPeers(
         coercePositiveInt(arguments_.page, 1),
         coercePositiveInt(arguments_.page_size, 50)
       ),
-      thenvoi_get_participants: async () => this.getParticipants(),
-      thenvoi_create_chatroom: async (arguments_) => this.createChatroom(this.normalizeOptionalString(arguments_.task_id))
+      band_get_participants: async () => this.getParticipants(),
+      band_create_chatroom: async (arguments_) => this.createChatroom(this.normalizeOptionalString(arguments_.task_id))
     };
   }
   buildContactToolHandlers() {
     return {
-      thenvoi_list_contacts: async (arguments_) => this.listContacts({
+      band_list_contacts: async (arguments_) => this.listContacts({
         page: coercePositiveInt(arguments_.page, 1),
         pageSize: coercePositiveInt(arguments_.page_size, 50)
       }),
-      thenvoi_add_contact: async (arguments_) => this.addContact({
+      band_add_contact: async (arguments_) => this.addContact({
         handle: String(arguments_.handle ?? ""),
         ...typeof arguments_.message === "string" ? { message: arguments_.message } : {}
       }),
-      thenvoi_remove_contact: async (arguments_) => this.removeContact(this.toRemoveContactArgs(arguments_)),
-      thenvoi_list_contact_requests: async (arguments_) => this.listContactRequests({
+      band_remove_contact: async (arguments_) => this.removeContact(this.toRemoveContactArgs(arguments_)),
+      band_list_contact_requests: async (arguments_) => this.listContactRequests({
         page: coercePositiveInt(arguments_.page, 1),
         pageSize: coercePositiveInt(arguments_.page_size, 50),
         sentStatus: String(arguments_.sent_status ?? "pending")
       }),
-      thenvoi_respond_contact_request: async (arguments_) => this.respondContactRequest(this.toRespondContactRequestArgs(arguments_))
+      band_respond_contact_request: async (arguments_) => this.respondContactRequest(this.toRespondContactRequestArgs(arguments_))
     };
   }
   buildMemoryToolHandlers() {
     return {
-      thenvoi_list_memories: async (arguments_) => this.listMemories(this.toListMemoriesArgs(arguments_)),
-      thenvoi_store_memory: async (arguments_) => this.storeMemory(this.toStoreMemoryArgs(arguments_)),
-      thenvoi_get_memory: async (arguments_) => this.getMemory(String(arguments_.memory_id ?? "")),
-      thenvoi_supersede_memory: async (arguments_) => this.supersedeMemory(String(arguments_.memory_id ?? "")),
-      thenvoi_archive_memory: async (arguments_) => this.archiveMemory(String(arguments_.memory_id ?? ""))
+      band_list_memories: async (arguments_) => this.listMemories(this.toListMemoriesArgs(arguments_)),
+      band_store_memory: async (arguments_) => this.storeMemory(this.toStoreMemoryArgs(arguments_)),
+      band_get_memory: async (arguments_) => this.getMemory(String(arguments_.memory_id ?? "")),
+      band_supersede_memory: async (arguments_) => this.supersedeMemory(String(arguments_.memory_id ?? "")),
+      band_archive_memory: async (arguments_) => this.archiveMemory(String(arguments_.memory_id ?? ""))
     };
   }
   toRemoveContactArgs(arguments_) {
@@ -1579,6 +1843,9 @@ var AgentTools = class {
     const status = this.normalizeOptionalMemoryStatus(arguments_.status);
     const subjectId = this.normalizeOptionalString(arguments_.subject_id);
     const contentQuery = this.normalizeOptionalString(arguments_.content_query);
+    if (system && type && !isMemoryTypeForSystem(system, type)) {
+      throw new ValidationError(memoryTypeForSystemError(system));
+    }
     return {
       ...subjectId ? { subject_id: subjectId } : {},
       ...scope ? { scope } : {},
@@ -1600,13 +1867,21 @@ var AgentTools = class {
     const subjectId = this.normalizeOptionalString(arguments_.subject_id);
     const metadata = this.normalizeOptionalMetadata(arguments_.metadata);
     if (!system) {
-      throw new ValidationError("system must be one of: sensory, working, long_term");
+      throw new ValidationError(`system must be one of: ${expectedList(MEMORY_SYSTEMS)}`);
     }
     if (!type) {
-      throw new ValidationError("type must be one of: iconic, echoic, haptic, episodic, semantic, procedural");
+      throw new ValidationError(`type must be one of: ${expectedList(MEMORY_TYPES)}`);
+    }
+    if (!isMemoryTypeForSystem(system, type)) {
+      throw new ValidationError(memoryTypeForSystemError(system));
     }
     if (!segment) {
-      throw new ValidationError("segment must be one of: user, agent, tool, guideline");
+      throw new ValidationError(`segment must be one of: ${expectedList(MEMORY_SEGMENTS)}`);
+    }
+    if (scope === "subject" && !subjectId) {
+      throw new ValidationError(
+        'scope="subject" requires a subject_id (the UUID of the person or agent the memory is about). If you do not have a concrete subject UUID, retry with scope="organization" and omit subject_id. Do not invent a UUID.'
+      );
     }
     return {
       content,
@@ -1686,8 +1961,8 @@ var AgentTools = class {
     if (!normalized) {
       return void 0;
     }
-    if (!isListMemoryScope(normalized)) {
-      throw new ValidationError("scope must be one of: subject, organization, all");
+    if (!isMemoryListScope(normalized)) {
+      throw new ValidationError(`scope must be one of: ${expectedList(MEMORY_LIST_SCOPES)}`);
     }
     return normalized;
   }
@@ -1697,7 +1972,7 @@ var AgentTools = class {
       return void 0;
     }
     if (!isMemorySystem(normalized)) {
-      throw new ValidationError("system must be one of: sensory, working, long_term");
+      throw new ValidationError(`system must be one of: ${expectedList(MEMORY_SYSTEMS)}`);
     }
     return normalized;
   }
@@ -1707,7 +1982,7 @@ var AgentTools = class {
       return void 0;
     }
     if (!isMemoryType(normalized)) {
-      throw new ValidationError("type must be one of: iconic, echoic, haptic, episodic, semantic, procedural");
+      throw new ValidationError(`type must be one of: ${expectedList(MEMORY_TYPES)}`);
     }
     return normalized;
   }
@@ -1717,7 +1992,7 @@ var AgentTools = class {
       return void 0;
     }
     if (!isMemorySegment(normalized)) {
-      throw new ValidationError("segment must be one of: user, agent, tool, guideline");
+      throw new ValidationError(`segment must be one of: ${expectedList(MEMORY_SEGMENTS)}`);
     }
     return normalized;
   }
@@ -1727,7 +2002,7 @@ var AgentTools = class {
       return void 0;
     }
     if (!isMemoryStatus(normalized)) {
-      throw new ValidationError("status must be one of: active, superseded, archived, all");
+      throw new ValidationError(`status must be one of: ${expectedList(MEMORY_STATUSES)}`);
     }
     return normalized;
   }
@@ -1736,8 +2011,8 @@ var AgentTools = class {
     if (!normalized) {
       return void 0;
     }
-    if (!isStoreMemoryScope(normalized)) {
-      throw new ValidationError("scope must be one of: subject, organization");
+    if (!isMemoryStoreScope(normalized)) {
+      throw new ValidationError(`scope must be one of: ${expectedList(MEMORY_STORE_SCOPES)}`);
     }
     return normalized;
   }
@@ -1745,24 +2020,6 @@ var AgentTools = class {
 function isContactRequestAction(value) {
   return CONTACT_REQUEST_ACTIONS.has(value);
 }
-function isMemorySystem(value) {
-  return MEMORY_SYSTEMS.has(value);
-}
-function isMemoryType(value) {
-  return MEMORY_TYPES.has(value);
-}
-function isMemorySegment(value) {
-  return MEMORY_SEGMENTS.has(value);
-}
-function isStoreMemoryScope(value) {
-  return MEMORY_SCOPES.has(value);
-}
-function isListMemoryScope(value) {
-  return LIST_MEMORY_SCOPES.has(value);
-}
-function isMemoryStatus(value) {
-  return LIST_MEMORY_STATUSES.has(value);
-}
 function coercePositiveInt(value, fallback) {
   const num = Number(value ?? fallback);
   return Number.isFinite(num) && num >= 1 ? Math.floor(num) : fallback;
@@ -1778,13 +2035,13 @@ function validateToolArgs(toolName, args) {
       errors.push(`${field}: Field required`);
     }
   }
-  if (toolName === "thenvoi_send_message") {
+  if (toolName === "band_send_message") {
     const mentions = args.mentions;
     if (Array.isArray(mentions) && mentions.length === 0) {
       errors.push("mentions: At least one mention is required");
     }
   }
-  if (toolName === "thenvoi_send_event") {
+  if (toolName === "band_send_event") {
     const messageType = args.message_type;
     if (typeof messageType === "string" && !CHAT_EVENT_TYPES.includes(messageType)) {
       errors.push(
@@ -1792,7 +2049,7 @@ function validateToolArgs(toolName, args) {
       );
     }
   }
-  if (toolName === "thenvoi_respond_contact_request") {
+  if (toolName === "band_respond_contact_request") {
     const action = args.action;
     const validActions = ["approve", "reject", "cancel"];
     if (typeof action === "string" && !validActions.includes(action)) {
@@ -1801,18 +2058,20 @@ function validateToolArgs(toolName, args) {
       );
     }
   }
-  if (toolName === "thenvoi_store_memory") {
-    const validSystems = ["sensory", "working", "long_term"];
-    const validTypes = ["iconic", "echoic", "haptic", "episodic", "semantic", "procedural"];
-    const validSegments = ["user", "agent", "tool", "guideline"];
-    if (typeof args.system === "string" && !validSystems.includes(args.system)) {
-      errors.push(`system: Invalid value '${args.system}'. Expected one of: ${validSystems.join(", ")}`);
+  if (toolName === "band_store_memory") {
+    if (typeof args.system === "string" && !isMemorySystem(args.system)) {
+      errors.push(`system: Invalid value '${args.system}'. Expected one of: ${expectedList(MEMORY_SYSTEMS)}`);
     }
-    if (typeof args.type === "string" && !validTypes.includes(args.type)) {
-      errors.push(`type: Invalid value '${args.type}'. Expected one of: ${validTypes.join(", ")}`);
+    if (typeof args.type === "string" && !isMemoryType(args.type)) {
+      errors.push(`type: Invalid value '${args.type}'. Expected one of: ${expectedList(MEMORY_TYPES)}`);
+    }
+    if (typeof args.system === "string" && isMemorySystem(args.system) && typeof args.type === "string" && isMemoryType(args.type) && !isMemoryTypeForSystem(args.system, args.type)) {
+      errors.push(
+        `type: Invalid value '${args.type}' for system '${args.system}'. Expected one of: ${expectedMemoryTypesForSystem(args.system)}`
+      );
     }
-    if (typeof args.segment === "string" && !validSegments.includes(args.segment)) {
-      errors.push(`segment: Invalid value '${args.segment}'. Expected one of: ${validSegments.join(", ")}`);
+    if (typeof args.segment === "string" && !isMemorySegment(args.segment)) {
+      errors.push(`segment: Invalid value '${args.segment}'. Expected one of: ${expectedList(MEMORY_SEGMENTS)}`);
     }
   }
   if (errors.length > 0) {
@@ -1828,58 +2087,8 @@ function validateToolArgs(toolName, args) {
   return null;
 }
 
-// src/runtime/retryTracker.ts
-var DEFAULT_MAX_TRACKED = 1e4;
-var MessageRetryTracker = class {
-  maxRetriesValue;
-  maxTracked;
-  attempts = /* @__PURE__ */ new Map();
-  failed = /* @__PURE__ */ new Set();
-  constructor(maxRetries = 1, maxTracked = DEFAULT_MAX_TRACKED) {
-    this.maxRetriesValue = maxRetries;
-    this.maxTracked = maxTracked;
-  }
-  get maxRetries() {
-    return this.maxRetriesValue;
-  }
-  isPermanentlyFailed(messageId) {
-    return this.failed.has(messageId);
-  }
-  recordAttempt(messageId) {
-    const attempts = (this.attempts.get(messageId) ?? 0) + 1;
-    this.attempts.set(messageId, attempts);
-    const exceeded = attempts > this.maxRetriesValue;
-    if (exceeded) {
-      this.evictSetIfNeeded(this.failed);
-      this.failed.add(messageId);
-    }
-    this.evictMapIfNeeded(this.attempts);
-    return [attempts, exceeded];
-  }
-  markSuccess(messageId) {
-    this.attempts.delete(messageId);
-  }
-  markPermanentlyFailed(messageId) {
-    this.evictSetIfNeeded(this.failed);
-    this.failed.add(messageId);
-  }
-  evictMapIfNeeded(map) {
-    while (map.size >= this.maxTracked) {
-      const first = map.keys().next();
-      if (first.done) break;
-      map.delete(first.value);
-    }
-  }
-  evictSetIfNeeded(set) {
-    while (set.size >= this.maxTracked) {
-      const first = set.values().next();
-      if (first.done) break;
-      set.delete(first.value);
-    }
-  }
-};
-
 // src/runtime/ExecutionContext.ts
+import { ParticipantRoster as ParticipantRoster2, RetryTracker } from "@band-ai/band-sdk-core";
 var DEDUP_CACHE_MAX = 500;
 var ExecutionContext = class {
   roomId;
@@ -1891,11 +2100,10 @@ var ExecutionContext = class {
   history = [];
   messageIds = /* @__PURE__ */ new Set();
   dedupCache = /* @__PURE__ */ new Map();
-  participants = [];
+  roster = new ParticipantRoster2();
   tools;
   adapterTools;
   participantsMessage = null;
-  lastSentParticipantIds = null;
   contactsMessage = null;
   contextCache = null;
   contextCacheExpiresAt = 0;
@@ -1910,11 +2118,11 @@ var ExecutionContext = class {
     this.enableContextCache = options.enableContextCache ?? true;
     this.contextCacheTtlMs = Math.max(0, (options.contextCacheTtlSeconds ?? 300) * 1e3);
     this.enableContextHydration = options.enableContextHydration ?? true;
-    this.retryTrackerInstance = new MessageRetryTracker(options.maxMessageRetries ?? 1);
+    this.retryTrackerInstance = new RetryTracker(options.maxMessageRetries ?? 1);
     this.tools = new AgentTools({
       roomId: this.roomId,
       rest: this.link.rest,
-      participants: this.participants,
+      roster: this.roster,
       capabilities: this.link.capabilities
     });
     this.adapterTools = this.tools.getAdapterTools();
@@ -1982,23 +2190,20 @@ var ExecutionContext = class {
     }));
   }
   setParticipants(participants) {
-    this.replaceParticipants(participants);
+    this.roster.setAll(participants);
     this.updateCachedParticipants();
   }
   addParticipant(participant) {
-    const existingIndex = this.participants.findIndex((entry) => entry.id === participant.id);
-    if (existingIndex >= 0) {
-      this.participants.splice(existingIndex, 1);
+    const isNew = this.roster.add(participant);
+    if (isNew) {
+      const name = String(participant.name ?? "unknown");
+      this.participantsMessage = `${name} joined the room.`;
     }
-    this.participants.push(participant);
-    const name = String(participant.name ?? "unknown");
-    this.participantsMessage = `${name} joined the room.`;
     this.updateCachedParticipants();
   }
   removeParticipant(participantId) {
-    const removed = this.participants.find((entry) => String(entry.id) === participantId);
-    const next = this.participants.filter((entry) => String(entry.id) !== participantId);
-    this.replaceParticipants(next);
+    const removed = this.roster.list().find((entry) => entry.id === participantId);
+    this.roster.remove(participantId);
     if (removed) {
       this.participantsMessage = `${String(removed.name ?? participantId)} left the room.`;
     }
@@ -2008,16 +2213,7 @@ var ExecutionContext = class {
     this.contactsMessage = message;
   }
   consumeParticipantsMessage() {
-    const currentIds = new Set(this.participants.map((p) => String(p.id)));
-    let changed = !this.lastSentParticipantIds || currentIds.size !== this.lastSentParticipantIds.size;
-    if (!changed) {
-      for (const id of currentIds) {
-        if (!this.lastSentParticipantIds.has(id)) {
-          changed = true;
-          break;
-        }
-      }
-    }
+    const changed = this.roster.changed();
     if (!changed && !this.participantsMessage) {
       return null;
     }
@@ -2027,15 +2223,9 @@ var ExecutionContext = class {
       this.participantsMessage = null;
     }
     if (changed) {
-      const asRecords = this.participants.map((p) => ({
-        id: p.id,
-        name: p.name,
-        type: p.type,
-        handle: p.handle ?? null
-      }));
-      parts.push(buildParticipantsMessage(asRecords));
-    }
-    this.lastSentParticipantIds = currentIds;
+      parts.push(buildParticipantsMessage(this.roster.list().map((p) => ({ ...toParticipantRecord(p) }))));
+    }
+    this.roster.markSent();
     return parts.length > 0 ? parts.join("\n") : null;
   }
   consumeContactsMessage() {
@@ -2086,27 +2276,19 @@ var ExecutionContext = class {
       return fallback;
     }
   }
-  replaceParticipants(participants) {
-    this.participants.splice(0, this.participants.length, ...participants);
-  }
   buildLocalContext() {
     return {
       roomId: this.roomId,
       messages: this.getRawHistory(),
-      participants: [...this.participants],
+      participants: this.roster.list().map(toParticipantRecord),
       hydratedAt: /* @__PURE__ */ new Date()
     };
   }
   async loadParticipants() {
     const participants = await this.link.rest.listChatParticipants(this.roomId, DEFAULT_REQUEST_OPTIONS);
-    const normalized = participants.map((participant) => ({
-      id: participant.id,
-      name: participant.name,
-      type: participant.type,
-      handle: participant.handle ?? null
-    }));
-    this.replaceParticipants(normalized);
-    return [...this.participants];
+    const normalized = participants.map(toParticipantRecordFromRest);
+    this.roster.setAll(normalized);
+    return this.roster.list().map(toParticipantRecord);
   }
   async loadHydratedMessages() {
     const messages = [];
@@ -2148,7 +2330,7 @@ var ExecutionContext = class {
     if (!this.contextCache) {
       return;
     }
-    this.contextCache.participants = [...this.participants];
+    this.contextCache.participants = this.roster.list().map(toParticipantRecord);
     this.contextCache.hydratedAt = /* @__PURE__ */ new Date();
     this.contextCacheExpiresAt = this.nextCacheExpiry();
   }
@@ -2349,7 +2531,7 @@ var AgentRuntime = class {
     await this.link.disconnect();
   }
   async stop(timeoutMs) {
-    if (!this.running || this.stopping) {
+    if (this.stopping || !this.running && !this.fatalError) {
       return true;
     }
     this.stopping = true;
@@ -2369,7 +2551,8 @@ var AgentRuntime = class {
       }
     }
     for (const roomId of [...this.subscribedRooms]) {
-      await this.leaveTrackedRoom(roomId);
+      const remaining = deadline === void 0 ? void 0 : Math.max(0, deadline - Date.now());
+      await this.leaveTrackedRoom(roomId, remaining);
     }
     for (const roomId of [...this.contexts.keys()]) {
       await this.onSessionCleanup(roomId);
@@ -2405,7 +2588,13 @@ var AgentRuntime = class {
   }
   async consumeLoop(signal) {
     while (!signal.aborted) {
-      const event = await this.link.nextEvent(signal);
+      let event;
+      try {
+        event = await this.link.nextEvent(signal);
+      } catch (error) {
+        await this.failRuntime(error, syntheticRuntimeFailureEvent(this.agentId));
+        return;
+      }
       if (!event) {
         return;
       }
@@ -2568,13 +2757,13 @@ var AgentRuntime = class {
       }
     });
   }
-  async leaveTrackedRoom(roomId) {
+  async leaveTrackedRoom(roomId, timeoutMs) {
     await trackRoomLeave({
       link: this.link,
       roomId,
       trackedRooms: this.subscribedRooms,
       onLeft: async (leftRoomId) => {
-        await this.executions.get(leftRoomId)?.stop();
+        await this.executions.get(leftRoomId)?.stop(timeoutMs);
         this.contexts.delete(leftRoomId);
         this.executions.delete(leftRoomId);
         await this.onSessionCleanup(leftRoomId);
@@ -2611,6 +2800,23 @@ var AgentRuntime = class {
     }
   }
 };
+function syntheticRuntimeFailureEvent(agentId) {
+  return {
+    type: "message_created",
+    roomId: null,
+    payload: {
+      id: "runtime-failed",
+      content: "",
+      sender_id: agentId,
+      sender_type: "Agent",
+      sender_name: null,
+      message_type: "text",
+      metadata: {},
+      inserted_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date(0)).toISOString()
+    }
+  };
+}
 function assertNever(value) {
   throw new Error(`Unhandled platform event: ${JSON.stringify(value)}`);
 }
@@ -2762,14 +2968,6 @@ var ContactToolsImpl = class {
 };
 
 // src/runtime/tools/ContactCallbackTools.ts
-function toParticipantRecord(participant) {
-  return {
-    id: participant.id,
-    name: participant.name,
-    type: participant.type,
-    handle: participant.handle ?? null
-  };
-}
 function normalizePage(value, fallback) {
   return Number.isInteger(value) && value && value > 0 ? value : fallback;
 }
@@ -2813,8 +3011,7 @@ var ContactCallbackTools = class {
       {
         content,
         ...normalizedMentions ? { mentions: normalizedMentions } : {}
-      },
-      DEFAULT_REQUEST_OPTIONS
+      }
     );
   }
   async sendEvent(content, messageType, metadata) {
@@ -2828,8 +3025,7 @@ var ContactCallbackTools = class {
         content,
         messageType,
         ...metadata ? { metadata } : {}
-      },
-      DEFAULT_REQUEST_OPTIONS
+      }
     );
   }
   async addParticipant() {
@@ -2843,7 +3039,7 @@ var ContactCallbackTools = class {
     if (!this.rest.listChatParticipants) {
       throw new UnsupportedFeatureError("Participant listing is not available in current REST adapter");
     }
-    return (await this.rest.listChatParticipants(roomId, DEFAULT_REQUEST_OPTIONS)).map(toParticipantRecord);
+    return (await this.rest.listChatParticipants(roomId, DEFAULT_REQUEST_OPTIONS)).map(toParticipantRecordFromRest);
   }
   async createChatroom(taskId) {
     const chat = await this.rest.createChat(taskId, DEFAULT_REQUEST_OPTIONS);
@@ -2933,48 +3129,48 @@ var ContactCallbackTools = class {
   }
   async executeToolCall(toolName, toolArgs) {
     switch (toolName) {
-      case "thenvoi_send_message":
+      case "band_send_message":
         return this.sendMessage(
           String(toolArgs.content ?? ""),
           toolArgs.mentions
         );
-      case "thenvoi_send_event":
+      case "band_send_event":
         return this.sendEvent(
           String(toolArgs.content ?? ""),
           String(toolArgs.message_type ?? "task"),
           toolArgs.metadata
         );
-      case "thenvoi_get_participants":
+      case "band_get_participants":
         return this.getParticipants();
-      case "thenvoi_create_chatroom":
+      case "band_create_chatroom":
         return this.createChatroom(typeof toolArgs.task_id === "string" ? toolArgs.task_id : void 0);
-      case "thenvoi_lookup_peers":
+      case "band_lookup_peers":
         return this.lookupPeers(
           typeof toolArgs.page === "number" ? toolArgs.page : void 0,
           typeof toolArgs.page_size === "number" ? toolArgs.page_size : void 0
         );
-      case "thenvoi_list_contacts":
+      case "band_list_contacts":
         return this.listContacts({
           page: typeof toolArgs.page === "number" ? toolArgs.page : void 0,
           pageSize: typeof toolArgs.page_size === "number" ? toolArgs.page_size : void 0
         });
-      case "thenvoi_add_contact":
+      case "band_add_contact":
         return this.addContact({
           handle: String(toolArgs.handle ?? ""),
           ...typeof toolArgs.message === "string" ? { message: toolArgs.message } : {}
         });
-      case "thenvoi_remove_contact":
+      case "band_remove_contact":
         if (typeof toolArgs.contact_id === "string") {
           return this.removeContact({ target: "contactId", contactId: toolArgs.contact_id });
         }
         return this.removeContact({ target: "handle", handle: String(toolArgs.handle ?? "") });
-      case "thenvoi_list_contact_requests":
+      case "band_list_contact_requests":
         return this.listContactRequests({
           page: typeof toolArgs.page === "number" ? toolArgs.page : void 0,
           pageSize: typeof toolArgs.page_size === "number" ? toolArgs.page_size : void 0,
           sentStatus: typeof toolArgs.sent_status === "string" ? toolArgs.sent_status : void 0
         });
-      case "thenvoi_respond_contact_request":
+      case "band_respond_contact_request":
         if (typeof toolArgs.request_id === "string") {
           return this.respondContactRequest({
             action: String(toolArgs.action ?? "approve"),
@@ -2987,15 +3183,15 @@ var ContactCallbackTools = class {
           target: "handle",
           handle: String(toolArgs.handle ?? "")
         });
-      case "thenvoi_list_memories":
+      case "band_list_memories":
         return this.listMemories(toolArgs);
-      case "thenvoi_store_memory":
+      case "band_store_memory":
         return this.storeMemory(toolArgs);
-      case "thenvoi_get_memory":
+      case "band_get_memory":
         return this.getMemory(String(toolArgs.memory_id ?? ""));
-      case "thenvoi_supersede_memory":
+      case "band_supersede_memory":
         return this.supersedeMemory(String(toolArgs.memory_id ?? ""));
-      case "thenvoi_archive_memory":
+      case "band_archive_memory":
         return this.archiveMemory(String(toolArgs.memory_id ?? ""));
       default:
         throw new UnsupportedFeatureError(`Unsupported tool call for contact callback: ${toolName}`);
@@ -3009,14 +3205,14 @@ var HUB_ROOM_SYSTEM_PROMPT = `## OVERRIDE: Contact Management Mode
 
 This is your CONTACTS HUB - a dedicated room for managing contact requests.
 
-**IMPORTANT: Do NOT delegate or add participants here.** You handle contact events DIRECTLY using the contact tools below. Do NOT call thenvoi_lookup_peers() or thenvoi_add_participant() in this room.
+**IMPORTANT: Do NOT delegate or add participants here.** You handle contact events DIRECTLY using the contact tools below. Do NOT call band_lookup_peers() or band_add_participant() in this room.
 
 ## Your Role
 
 1. **Review incoming contact requests** - When you see a [Contact Request] message, evaluate it
 2. **Take action** - Use the contact tools to respond:
-   - \`thenvoi_respond_contact_request(action="approve", request_id="...")\` to accept
-   - \`thenvoi_respond_contact_request(action="reject", request_id="...")\` to decline
+   - \`band_respond_contact_request(action="approve", request_id="...")\` to accept
+   - \`band_respond_contact_request(action="reject", request_id="...")\` to decline
 3. **Report your decision** - Send a thought event explaining what you did
 
 ## Example
@@ -3025,14 +3221,14 @@ This is your CONTACTS HUB - a dedicated room for managing contact requests.
 Request ID: abc-123
 
 Your response:
-1. thenvoi_send_event("Received contact request from Alice. Approving.", message_type="thought")
-2. thenvoi_respond_contact_request(action="approve", request_id="abc-123")
-3. thenvoi_send_event("Approved contact request from Alice (@alice)", message_type="thought")
+1. band_send_event("Received contact request from Alice. Approving.", message_type="thought")
+2. band_respond_contact_request(action="approve", request_id="abc-123")
+3. band_send_event("Approved contact request from Alice (@alice)", message_type="thought")
 
 ## Contact Tools (use these, NOT participant tools)
-- \`thenvoi_respond_contact_request(action, request_id)\` - Approve/reject requests
-- \`thenvoi_list_contact_requests()\` - List pending requests
-- \`thenvoi_list_contacts()\` - List current contacts`;
+- \`band_respond_contact_request(action, request_id)\` - Approve/reject requests
+- \`band_list_contact_requests()\` - List pending requests
+- \`band_list_contacts()\` - List current contacts`;
 var ContactEventHandlerError = class extends Error {
   retryable;
   stage;
@@ -3360,6 +3556,8 @@ function normalizeHandle(handle) {
 }
 
 // src/runtime/PlatformRuntime.ts
+var MAX_MESSAGE_RETRIES = 4294967295;
+var isValidRetryCount = (value) => Number.isInteger(value) && value >= 0 && value <= MAX_MESSAGE_RETRIES;
 var PlatformRuntime = class {
   _agentId;
   _apiKey;
@@ -3396,6 +3594,12 @@ var PlatformRuntime = class {
         "apiKey is required and must be a non-empty string. Use loadAgentConfig() to load credentials from agent_config.yaml."
       );
     }
+    const maxMessageRetries = options.sessionConfig?.maxMessageRetries;
+    if (maxMessageRetries !== void 0 && !isValidRetryCount(maxMessageRetries)) {
+      throw new ValidationError(
+        `sessionConfig.maxMessageRetries must be an integer between 0 and ${MAX_MESSAGE_RETRIES}, got ${maxMessageRetries}.`
+      );
+    }
     this._agentId = options.agentId;
     this._apiKey = options.apiKey;
     this._wsUrl = options.wsUrl;
@@ -3448,12 +3652,13 @@ var PlatformRuntime = class {
   }
   async doInitialize() {
     if (!this.linkInstance) {
-      this.linkInstance = new ThenvoiLink({
+      this.linkInstance = new BandLink({
         ...this.linkOptions,
         agentId: this._agentId,
         apiKey: this._apiKey,
         wsUrl: this._wsUrl,
-        restUrl: this._restUrl
+        restUrl: this._restUrl,
+        logger: this.logger
       });
     }
     if (this.configuredIdentity) {
@@ -3670,10 +3875,10 @@ async function runWithGracefulShutdown(agent, options) {
 }
 
 export {
-  ThenvoiLink,
+  deriveDefaultRestUrl,
+  BandLink,
   Execution,
   AgentTools,
-  MessageRetryTracker,
   ExecutionContext,
   trackRoomJoin,
   trackRoomLeave,