@band-ai/sdk 0.1.2

package/dist/runtime.js

@@ -0,0 +1,274 @@
+import {
+  AgentRuntime,
+  AgentTools,
+  ContactEventHandler,
+  ContactToolsImpl,
+  DefaultPreprocessor,
+  Execution,
+  ExecutionContext,
+  GracefulShutdown,
+  HUB_ROOM_SYSTEM_PROMPT,
+  MessageRetryTracker,
+  PlatformRuntime,
+  hydrateTrackedRooms,
+  runWithGracefulShutdown,
+  trackRoomJoin,
+  trackRoomLeave
+} from "./chunk-6AJA2OPC.js";
+import {
+  HistoryProvider,
+  SYNTHETIC_CONTACT_EVENTS_SENDER_ID,
+  SYNTHETIC_CONTACT_EVENTS_SENDER_NAME,
+  SYNTHETIC_SENDER_TYPE,
+  buildParticipantsMessage,
+  ensureHandlePrefix,
+  formatHistoryForLlm,
+  formatMessageForLlm,
+  replaceUuidMentions
+} from "./chunk-INA6YZTZ.js";
+import {
+  ALL_TOOL_NAMES,
+  BASE_TOOL_NAMES,
+  CHAT_EVENT_TYPES,
+  CHAT_MESSAGE_TYPES,
+  CHAT_TOOL_NAMES,
+  CONTACT_TOOL_NAMES,
+  MCP_TOOL_PREFIX,
+  MEMORY_TOOL_NAMES,
+  TOOL_MODELS,
+  assertChatEventType,
+  getToolDescription,
+  isChatEventType,
+  mcpToolNames
+} from "./chunk-GVEQ3RAH.js";
+import {
+  BASE_INSTRUCTIONS,
+  TEMPLATES,
+  renderSystemPrompt
+} from "./chunk-SFVKOEQH.js";
+import {
+  DEFAULT_REQUEST_OPTIONS
+} from "./chunk-SG4WLD2H.js";
+import "./chunk-ZZJRRBPQ.js";
+import "./chunk-3BKAC4OZ.js";
+import {
+  NoopLogger
+} from "./chunk-OD2G5LFQ.js";
+import "./chunk-YR3BOQNW.js";
+
+// src/runtime/rooms/RoomPresence.ts
+var RoomPresence = class {
+  rooms = /* @__PURE__ */ new Set();
+  onRoomJoined = null;
+  onRoomLeft = null;
+  onRoomEvent = null;
+  onContactEvent = null;
+  link;
+  roomFilter;
+  autoSubscribeExistingRooms;
+  logger;
+  eventController = null;
+  eventTask = null;
+  contactsSubscribed = false;
+  constructor(options) {
+    this.link = options.link;
+    this.roomFilter = options.roomFilter;
+    this.autoSubscribeExistingRooms = options.autoSubscribeExistingRooms ?? true;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  async start() {
+    if (this.eventTask) {
+      return;
+    }
+    if (!this.link.isConnected()) {
+      await this.link.connect();
+    }
+    try {
+      await this.link.subscribeAgentRooms();
+    } catch {
+    }
+    if (this.autoSubscribeExistingRooms) {
+      await this.subscribeExistingRooms();
+    }
+    if (this.link.capabilities.contacts) {
+      await this.link.subscribeAgentContacts();
+      this.contactsSubscribed = true;
+    }
+    this.eventController = new AbortController();
+    this.eventTask = this.consumeEvents(this.eventController.signal);
+  }
+  async stop() {
+    this.eventController?.abort();
+    await this.eventTask;
+    this.eventTask = null;
+    this.eventController = null;
+    if (this.contactsSubscribed) {
+      await this.link.unsubscribeAgentContacts();
+      this.contactsSubscribed = false;
+    }
+    for (const roomId of [...this.rooms]) {
+      await trackRoomLeave({
+        link: this.link,
+        roomId,
+        trackedRooms: this.rooms,
+        onLeft: this.onRoomLeft ?? void 0
+      });
+    }
+  }
+  async consumeEvents(signal) {
+    while (!signal.aborted) {
+      const event = await this.link.nextEvent(signal);
+      if (!event) {
+        return;
+      }
+      switch (event.type) {
+        case "room_added":
+          await this.handleRoomAdded(event.roomId, event.payload);
+          break;
+        case "room_removed":
+        case "room_deleted":
+          await this.handleRoomRemoved(event.roomId);
+          break;
+        case "contact_request_received":
+        case "contact_request_updated":
+        case "contact_added":
+        case "contact_removed":
+          await this.onContactEvent?.(event);
+          break;
+        default:
+          if (event.roomId && this.rooms.has(event.roomId)) {
+            await this.onRoomEvent?.(event.roomId, event);
+          }
+          break;
+      }
+    }
+  }
+  async handleRoomAdded(roomId, payload) {
+    await trackRoomJoin({
+      link: this.link,
+      roomId,
+      payload,
+      trackedRooms: this.rooms,
+      roomFilter: this.roomFilter,
+      onJoined: this.onRoomJoined ?? void 0
+    });
+  }
+  async handleRoomRemoved(roomId) {
+    await trackRoomLeave({
+      link: this.link,
+      roomId,
+      trackedRooms: this.rooms,
+      onLeft: this.onRoomLeft ?? void 0
+    });
+  }
+  async subscribeExistingRooms() {
+    await hydrateTrackedRooms({
+      link: this.link,
+      trackedRooms: this.rooms,
+      requestOptions: DEFAULT_REQUEST_OPTIONS,
+      roomFilter: this.roomFilter,
+      onJoined: this.onRoomJoined ?? void 0,
+      onError: async (error) => {
+        this.logger.warn("RoomPresence failed to subscribe existing rooms", {
+          error
+        });
+      }
+    });
+  }
+};
+
+// src/runtime/participantTracker.ts
+var ParticipantTracker = class {
+  participantsList = [];
+  lastSent = null;
+  loaded = false;
+  get participants() {
+    return [...this.participantsList];
+  }
+  get isLoaded() {
+    return this.loaded;
+  }
+  setLoaded(participants) {
+    this.participantsList = participants.map((participant) => ({ ...participant }));
+    this.loaded = true;
+  }
+  add(participant) {
+    if (this.participantsList.some((entry) => entry.id === participant.id)) {
+      return false;
+    }
+    this.participantsList.push({
+      id: participant.id,
+      name: participant.name,
+      type: participant.type,
+      handle: participant.handle
+    });
+    return true;
+  }
+  remove(participantId) {
+    const before = this.participantsList.length;
+    this.participantsList = this.participantsList.filter(
+      (participant) => participant.id !== participantId
+    );
+    return this.participantsList.length < before;
+  }
+  changed() {
+    if (!this.lastSent) {
+      return true;
+    }
+    const oldIds = new Set(this.lastSent.map((participant) => participant.id));
+    const newIds = new Set(this.participantsList.map((participant) => participant.id));
+    if (oldIds.size !== newIds.size) {
+      return true;
+    }
+    for (const id of oldIds) {
+      if (!newIds.has(id)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  markSent() {
+    this.lastSent = this.participantsList.map((participant) => ({ ...participant }));
+  }
+};
+export {
+  ALL_TOOL_NAMES,
+  AgentRuntime,
+  AgentTools,
+  BASE_INSTRUCTIONS,
+  BASE_TOOL_NAMES,
+  CHAT_EVENT_TYPES,
+  CHAT_MESSAGE_TYPES,
+  CHAT_TOOL_NAMES,
+  CONTACT_TOOL_NAMES,
+  ContactEventHandler,
+  ContactToolsImpl,
+  DefaultPreprocessor,
+  Execution,
+  ExecutionContext,
+  GracefulShutdown,
+  HUB_ROOM_SYSTEM_PROMPT,
+  HistoryProvider,
+  MCP_TOOL_PREFIX,
+  MEMORY_TOOL_NAMES,
+  MessageRetryTracker,
+  ParticipantTracker,
+  PlatformRuntime,
+  RoomPresence,
+  SYNTHETIC_CONTACT_EVENTS_SENDER_ID,
+  SYNTHETIC_CONTACT_EVENTS_SENDER_NAME,
+  SYNTHETIC_SENDER_TYPE,
+  TEMPLATES,
+  TOOL_MODELS,
+  assertChatEventType,
+  buildParticipantsMessage,
+  ensureHandlePrefix,
+  formatHistoryForLlm,
+  formatMessageForLlm,
+  getToolDescription,
+  isChatEventType,
+  mcpToolNames,
+  renderSystemPrompt,
+  replaceUuidMentions,
+  runWithGracefulShutdown
+};