@unboundcx/sdk 4.8.8 → 4.8.10

package/base.js

@@ -410,37 +410,36 @@ export class BaseSDK {
       'application/json';
 
     if (!response.ok) {
+      // A fetch Response's `.body` is a ReadableStream, not the parsed
+      // payload — it must go through json()/text() or the API's
+      // `{ message }` envelope is lost and every error surfaces as the
+      // generic "API Error". Only NATS-transport responses carry a
+      // pre-parsed `.body`.
       let errorBody;
-      if (response?.body) {
-        errorBody = response.body;
-      } else if (response?.headers?.['content-type']) {
-        try {
-          if (
-            typeof response?.json === 'function' ||
-            typeof response?.text === 'function'
-          ) {
-            if (contentType.includes('application/json')) {
-              errorBody = await response.json();
-            } else if (contentType.includes('text/')) {
-              errorBody = await response.text();
-            }
-          } else {
-            if (contentType.includes('application/json')) {
-              errorBody = this._getJsonSafely(
-                response?.body,
-                response?.body || {},
-              );
-            } else if (contentType.includes('text/')) {
-              errorBody = response?.body || '';
-            }
+      try {
+        if (
+          typeof response?.json === 'function' ||
+          typeof response?.text === 'function'
+        ) {
+          if (contentType.includes('application/json')) {
+            errorBody = await response.json();
+          } else if (contentType.includes('text/')) {
+            errorBody = await response.text();
           }
-          if (!errorBody) {
-            errorBody = `HTTP ${response.status} ${response.statusText}`;
+        } else if (response?.body) {
+          if (contentType.includes('application/json')) {
+            errorBody = this._getJsonSafely(
+              response?.body,
+              response?.body || {},
+            );
+          } else {
+            errorBody = response.body;
           }
-        } catch (parseError) {
-          errorBody = `HTTP ${response.status} ${response.statusText}`;
         }
-      } else {
+      } catch (parseError) {
+        // fall through to the status-line fallback below
+      }
+      if (!errorBody) {
         errorBody = `HTTP ${response.status} ${response.statusText}`;
       }
 
@@ -455,7 +454,10 @@ export class BaseSDK {
       httpError.method = method;
       httpError.endpoint = endpoint;
       httpError.body = errorBody;
-      httpError.message = errorBody?.error || errorBody?.message || 'API Error';
+      httpError.message =
+        errorBody?.error ||
+        errorBody?.message ||
+        (typeof errorBody === 'string' ? errorBody : 'API Error');
 
       // Debug logging for successful HTTP requests
       if (this.debugMode) {

package/index.js

@@ -33,6 +33,7 @@ import { TriggersService } from './services/triggers.js';
 import { InboxService } from './services/inbox.js';
 import { SearchService } from './services/search.js';
 import { DirectoryService } from './services/directory.js';
+import { ChatService } from './services/chat.js';
 
 class UnboundSDK extends BaseSDK {
   constructor(options = {}) {
@@ -107,6 +108,7 @@ class UnboundSDK extends BaseSDK {
     this.inbox = new InboxService(this);
     this.search = new SearchService(this);
     this.directory = new DirectoryService(this);
+    this.chat = new ChatService(this);
 
     // Add additional services that might be missing
     this._initializeAdditionalServices();
@@ -290,4 +292,5 @@ export { PermissionsService } from './services/permissions.js';
 export { InboxService } from './services/inbox.js';
 export { SearchService } from './services/search.js';
 export { DirectoryService } from './services/directory.js';
+export { ChatService } from './services/chat.js';
 export { BaseSDK } from './base.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.8.8",
+  "version": "4.8.10",
   "description": "Official JavaScript SDK for the Unbound API - A comprehensive toolkit for integrating with Unbound's communication, AI, and data management services",
   "main": "index.js",
   "type": "module",

package/services/chat.js

@@ -0,0 +1,851 @@
+/**
+ * ChatService — channels, DMs, membership, unreads, DND, messages, search,
+ * webhooks, card actions, reports, admin review, admin export, record feeds,
+ * channel meet, push devices, and notifyLevel.
+ * Backed by /chat/* on app1-api (checkApiAuth). Incoming webhook POST
+ * (HMAC) is external and is not an SDK method.
+ */
+export class ChatService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Create a channel.
+   * @param {Object} params
+   * @param {string} params.name - Channel name (required)
+   * @param {string} [params.topic]
+   * @param {'public'|'private'|'dm'|'group_dm'|'record'|'meeting'} [params.kind]
+   * @param {Object} [params.settings]
+   * @param {string[]} [params.groupIds] - Groups whose members are auto-added
+   * @returns {Promise<Object>} Created channel
+   */
+  async createChannel({ name, topic, kind, settings, groupIds }) {
+    this.sdk.validateParams(
+      { name, topic, kind, settings, groupIds },
+      {
+        name: { type: 'string', required: true },
+        topic: { type: 'string', required: false },
+        kind: { type: 'string', required: false },
+        settings: { type: 'object', required: false },
+        groupIds: { type: 'array', required: false },
+      },
+    );
+
+    const body = { name };
+    if (topic !== undefined) body.topic = topic;
+    if (kind !== undefined) body.kind = kind;
+    if (settings !== undefined) body.settings = settings;
+    if (groupIds !== undefined) body.groupIds = groupIds;
+
+    return this.sdk._fetch('/chat/channels', 'POST', { body });
+  }
+
+  /**
+   * List channels the current user is a member of.
+   * @returns {Promise<Object>}
+   */
+  async listChannels() {
+    return this.sdk._fetch('/chat/channels', 'GET');
+  }
+
+  /**
+   * Browse joinable (public) channels.
+   * @returns {Promise<Object>}
+   */
+  async browseChannels() {
+    return this.sdk._fetch('/chat/channels/browse', 'GET');
+  }
+
+  /**
+   * Get a channel by id.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async getChannel(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/channels/${id}`, 'GET');
+  }
+
+  /**
+   * Update channel name/topic/settings.
+   * @param {string} id
+   * @param {Object} [params]
+   * @param {string} [params.name]
+   * @param {string} [params.topic]
+   * @param {Object} [params.settings]
+   * @returns {Promise<Object>}
+   */
+  async updateChannel(id, { name, topic, settings } = {}) {
+    this.sdk.validateParams(
+      { id, name, topic, settings },
+      {
+        id: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+        topic: { type: 'string', required: false },
+        settings: { type: 'object', required: false },
+      },
+    );
+
+    const body = {};
+    if (name !== undefined) body.name = name;
+    if (topic !== undefined) body.topic = topic;
+    if (settings !== undefined) body.settings = settings;
+
+    return this.sdk._fetch(`/chat/channels/${id}`, 'PATCH', { body });
+  }
+
+  /**
+   * Archive a channel (reversible; hard delete is not supported).
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async archiveChannel(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/channels/${id}/archive`, 'POST', {
+      body: {},
+    });
+  }
+
+  /**
+   * Unarchive a channel.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async unarchiveChannel(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/channels/${id}/unarchive`, 'POST', {
+      body: {},
+    });
+  }
+
+  /**
+   * Join a public channel.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async joinChannel(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/channels/${id}/join`, 'POST', { body: {} });
+  }
+
+  /**
+   * Leave a channel.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async leaveChannel(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/channels/${id}/leave`, 'POST', { body: {} });
+  }
+
+  /**
+   * List members of a channel.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async listMembers(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/channels/${id}/members`, 'GET');
+  }
+
+  /**
+   * Add a member to a channel.
+   * @param {string} id
+   * @param {Object} params
+   * @param {string} params.userId
+   * @param {'owner'|'moderator'|'member'} [params.role]
+   * @returns {Promise<Object>}
+   */
+  async addMember(id, { userId, role } = {}) {
+    this.sdk.validateParams(
+      { id, userId, role },
+      {
+        id: { type: 'string', required: true },
+        userId: { type: 'string', required: true },
+        role: { type: 'string', required: false },
+      },
+    );
+
+    const body = { userId };
+    if (role !== undefined) body.role = role;
+
+    return this.sdk._fetch(`/chat/channels/${id}/members`, 'POST', { body });
+  }
+
+  /**
+   * Remove a member from a channel.
+   * @param {string} id
+   * @param {string} userId
+   * @returns {Promise<Object>}
+   */
+  async removeMember(id, userId) {
+    this.sdk.validateParams(
+      { id, userId },
+      {
+        id: { type: 'string', required: true },
+        userId: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/channels/${id}/members/${userId}`, 'DELETE');
+  }
+
+  /**
+   * Get group-default membership links for a channel.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async getGroupDefaults(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/channels/${id}/group-defaults`, 'GET');
+  }
+
+  /**
+   * Replace group-default membership links for a channel.
+   * @param {string} id
+   * @param {Object} params
+   * @param {string[]} params.groupIds
+   * @returns {Promise<Object>}
+   */
+  async setGroupDefaults(id, { groupIds } = {}) {
+    this.sdk.validateParams(
+      { id, groupIds },
+      {
+        id: { type: 'string', required: true },
+        groupIds: { type: 'array', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/channels/${id}/group-defaults`, 'PUT', {
+      body: { groupIds },
+    });
+  }
+
+  /**
+   * Find-or-create a 1:1 or group DM.
+   * @param {Object} params
+   * @param {string[]} params.userIds
+   * @returns {Promise<Object>}
+   */
+  async openDm({ userIds }) {
+    this.sdk.validateParams(
+      { userIds },
+      { userIds: { type: 'array', required: true } },
+    );
+    return this.sdk._fetch('/chat/dms', 'POST', { body: { userIds } });
+  }
+
+  /**
+   * Sidebar unread snapshot (channels + previews + counters).
+   * @returns {Promise<Object>}
+   */
+  async getUnreads() {
+    return this.sdk._fetch('/chat/unreads', 'GET');
+  }
+
+  /**
+   * Get the caller's Do Not Disturb state.
+   * @returns {Promise<Object>}
+   */
+  async getDnd() {
+    return this.sdk._fetch('/chat/dnd', 'GET');
+  }
+
+  /**
+   * Set the caller's Do Not Disturb state.
+   * @param {Object} params
+   * @param {boolean} params.enabled
+   * @returns {Promise<Object>}
+   */
+  async setDnd({ enabled } = {}) {
+    this.sdk.validateParams(
+      { enabled },
+      { enabled: { type: 'boolean', required: true } },
+    );
+    return this.sdk._fetch('/chat/dnd', 'PATCH', { body: { enabled } });
+  }
+
+  /**
+   * Advance the read watermark and recompute unread counters.
+   * @param {string} channelId
+   * @param {string} messageId
+   * @returns {Promise<Object>}
+   */
+  async markRead(channelId, messageId) {
+    this.sdk.validateParams(
+      { channelId, messageId },
+      {
+        channelId: { type: 'string', required: true },
+        messageId: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/channels/${channelId}/read`, 'POST', {
+      body: { messageId },
+    });
+  }
+
+  /**
+   * Set the watermark to the message before `messageId` (mark as unread).
+   * @param {string} channelId
+   * @param {string} messageId
+   * @returns {Promise<Object>}
+   */
+  async markUnread(channelId, messageId) {
+    this.sdk.validateParams(
+      { channelId, messageId },
+      {
+        channelId: { type: 'string', required: true },
+        messageId: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/channels/${channelId}/unread`, 'POST', {
+      body: { messageId },
+    });
+  }
+
+  /**
+   * Channels linked to a group via defaults (remove-from-group prompt).
+   * @param {Object} params
+   * @param {string} params.groupId
+   * @param {string} params.userId
+   * @returns {Promise<Object>}
+   */
+  async getLinkedChannels({ groupId, userId }) {
+    this.sdk.validateParams(
+      { groupId, userId },
+      {
+        groupId: { type: 'string', required: true },
+        userId: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/groups/${groupId}/linked-channels`, 'GET', {
+      query: { userId },
+    });
+  }
+
+  /**
+   * List messages in a channel (cursor pagination).
+   * @param {string} channelId
+   * @param {Object} [params]
+   * @param {string} [params.before]
+   * @param {string} [params.after]
+   * @param {number} [params.limit]
+   * @returns {Promise<Object>}
+   */
+  async listMessages(channelId, { before, after, limit } = {}) {
+    this.sdk.validateParams(
+      { channelId, before, after, limit },
+      {
+        channelId: { type: 'string', required: true },
+        before: { type: 'string', required: false },
+        after: { type: 'string', required: false },
+        limit: { type: 'number', required: false },
+      },
+    );
+
+    const query = {};
+    if (before !== undefined) query.before = before;
+    if (after !== undefined) query.after = after;
+    if (limit !== undefined) query.limit = limit;
+
+    return this.sdk._fetch(`/chat/channels/${channelId}/messages`, 'GET', {
+      query,
+    });
+  }
+
+  /**
+   * Send a message to a channel.
+   * @param {string} channelId
+   * @param {Object} params
+   * @param {Object} params.message - ProseMirror JSON (required)
+   * @param {string} [params.threadRootId]
+   * @param {boolean} [params.alsoSendToChannel]
+   * @param {string[]} [params.storageIds]
+   * @returns {Promise<Object>} Created message
+   */
+  async sendMessage(
+    channelId,
+    { message, threadRootId, alsoSendToChannel, storageIds } = {},
+  ) {
+    this.sdk.validateParams(
+      { channelId, message, threadRootId, alsoSendToChannel, storageIds },
+      {
+        channelId: { type: 'string', required: true },
+        message: { type: 'object', required: true },
+        threadRootId: { type: 'string', required: false },
+        alsoSendToChannel: { type: 'boolean', required: false },
+        storageIds: { type: 'array', required: false },
+      },
+    );
+
+    const body = { message };
+    if (threadRootId !== undefined) body.threadRootId = threadRootId;
+    if (alsoSendToChannel !== undefined) {
+      body.alsoSendToChannel = alsoSendToChannel;
+    }
+    if (storageIds !== undefined) body.storageIds = storageIds;
+
+    return this.sdk._fetch(`/chat/channels/${channelId}/messages`, 'POST', {
+      body,
+    });
+  }
+
+  /**
+   * Edit a message body (ProseMirror JSON).
+   * @param {string} id
+   * @param {Object} params
+   * @param {Object} params.message - ProseMirror JSON (required)
+   * @returns {Promise<Object>}
+   */
+  async editMessage(id, { message } = {}) {
+    this.sdk.validateParams(
+      { id, message },
+      {
+        id: { type: 'string', required: true },
+        message: { type: 'object', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/messages/${id}`, 'PATCH', {
+      body: { message },
+    });
+  }
+
+  /**
+   * Delete a message (tombstone).
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async deleteMessage(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/messages/${id}`, 'DELETE');
+  }
+
+  /**
+   * Add an emoji reaction to a message.
+   * @param {string} id
+   * @param {Object} params
+   * @param {string} params.emoji
+   * @returns {Promise<Object>}
+   */
+  async addReaction(id, { emoji } = {}) {
+    this.sdk.validateParams(
+      { id, emoji },
+      {
+        id: { type: 'string', required: true },
+        emoji: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/messages/${id}/reactions`, 'POST', {
+      body: { emoji },
+    });
+  }
+
+  /**
+   * Remove an emoji reaction from a message.
+   * @param {string} id
+   * @param {Object} params
+   * @param {string} params.emoji
+   * @returns {Promise<Object>}
+   */
+  async removeReaction(id, { emoji } = {}) {
+    this.sdk.validateParams(
+      { id, emoji },
+      {
+        id: { type: 'string', required: true },
+        emoji: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/messages/${id}/reactions`, 'DELETE', {
+      body: { emoji },
+    });
+  }
+
+  /**
+   * Get a thread (root + replies) for a channel message.
+   * @param {string} channelId
+   * @param {string} rootId
+   * @returns {Promise<Object>}
+   */
+  async getThread(channelId, rootId) {
+    this.sdk.validateParams(
+      { channelId, rootId },
+      {
+        channelId: { type: 'string', required: true },
+        rootId: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(
+      `/chat/channels/${channelId}/messages/${rootId}/thread`,
+      'GET',
+    );
+  }
+
+  /**
+   * Search messages the current user can read.
+   * @param {Object} params
+   * @param {string} params.q - Search term (required)
+   * @param {string} [params.channelId]
+   * @param {string} [params.fromUserId]
+   * @param {string} [params.before]
+   * @param {string} [params.after]
+   * @param {'public'|'private'|'dm'|'group_dm'|'record'|'meeting'} [params.kind]
+   * @param {string} [params.nextId]
+   * @param {number} [params.limit]
+   * @returns {Promise<Object>}
+   */
+  async search({
+    q,
+    channelId,
+    fromUserId,
+    before,
+    after,
+    kind,
+    nextId,
+    limit,
+  } = {}) {
+    this.sdk.validateParams(
+      { q, channelId, fromUserId, before, after, kind, nextId, limit },
+      {
+        q: { type: 'string', required: true },
+        channelId: { type: 'string', required: false },
+        fromUserId: { type: 'string', required: false },
+        before: { type: 'string', required: false },
+        after: { type: 'string', required: false },
+        kind: { type: 'string', required: false },
+        nextId: { type: 'string', required: false },
+        limit: { type: 'number', required: false },
+      },
+    );
+
+    const query = { q };
+    if (channelId !== undefined) query.channelId = channelId;
+    if (fromUserId !== undefined) query.fromUserId = fromUserId;
+    if (before !== undefined) query.before = before;
+    if (after !== undefined) query.after = after;
+    if (kind !== undefined) query.kind = kind;
+    if (nextId !== undefined) query.nextId = nextId;
+    if (limit !== undefined) query.limit = limit;
+
+    return this.sdk._fetch('/chat/search', 'GET', { query });
+  }
+
+  /**
+   * Create a channel incoming webhook (signing secret returned once).
+   * Button callback URLs are registered here — never taken from message payloads.
+   * @param {string} channelId
+   * @param {Object} params
+   * @param {string} params.name - Display name (required)
+   * @param {string} [params.avatar]
+   * @param {string} [params.callbackUrl] - Admin-registered button callback URL
+   * @returns {Promise<Object>} Created webhook (includes signingSecret once)
+   */
+  async createWebhook(channelId, { name, avatar, callbackUrl } = {}) {
+    this.sdk.validateParams(
+      { channelId, name, avatar, callbackUrl },
+      {
+        channelId: { type: 'string', required: true },
+        name: { type: 'string', required: true },
+        avatar: { type: 'string', required: false },
+        callbackUrl: { type: 'string', required: false },
+      },
+    );
+
+    const body = { name };
+    if (avatar !== undefined) body.avatar = avatar;
+    if (callbackUrl !== undefined) body.callbackUrl = callbackUrl;
+
+    return this.sdk._fetch(`/chat/channels/${channelId}/webhooks`, 'POST', {
+      body,
+    });
+  }
+
+  /**
+   * List webhooks for a channel.
+   * @param {string} channelId
+   * @returns {Promise<Object>}
+   */
+  async listWebhooks(channelId) {
+    this.sdk.validateParams(
+      { channelId },
+      { channelId: { type: 'string', required: true } },
+    );
+    return this.sdk._fetch(`/chat/channels/${channelId}/webhooks`, 'GET');
+  }
+
+  /**
+   * Revoke a channel webhook.
+   * @param {string} channelId
+   * @param {string} webhookId
+   * @returns {Promise<Object>}
+   */
+  async revokeWebhook(channelId, webhookId) {
+    this.sdk.validateParams(
+      { channelId, webhookId },
+      {
+        channelId: { type: 'string', required: true },
+        webhookId: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(
+      `/chat/channels/${channelId}/webhooks/${webhookId}`,
+      'DELETE',
+    );
+  }
+
+  /**
+   * Click a card action button on a message. Acting principal is the caller.
+   * @param {string} messageId
+   * @param {Object} params
+   * @param {string} params.actionId
+   * @param {string} [params.value]
+   * @returns {Promise<Object>}
+   */
+  async clickAction(messageId, { actionId, value } = {}) {
+    this.sdk.validateParams(
+      { messageId, actionId, value },
+      {
+        messageId: { type: 'string', required: true },
+        actionId: { type: 'string', required: true },
+        value: { type: 'string', required: false },
+      },
+    );
+
+    const body = { actionId };
+    if (value !== undefined) body.value = value;
+
+    return this.sdk._fetch(`/chat/messages/${messageId}/actions`, 'POST', {
+      body,
+    });
+  }
+
+  /**
+   * Report a message.
+   * @param {string} id
+   * @param {Object} params
+   * @param {string} params.reason
+   * @returns {Promise<Object>}
+   */
+  async reportMessage(id, { reason } = {}) {
+    this.sdk.validateParams(
+      { id, reason },
+      {
+        id: { type: 'string', required: true },
+        reason: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/messages/${id}/report`, 'POST', {
+      body: { reason },
+    });
+  }
+
+  /**
+   * Admin: list all channels (optional search/kind filter).
+   * @param {Object} [params]
+   * @param {string} [params.q]
+   * @param {'public'|'private'|'dm'|'group_dm'|'record'|'meeting'} [params.kind]
+   * @returns {Promise<Object>}
+   */
+  async adminListChannels({ q, kind } = {}) {
+    this.sdk.validateParams(
+      { q, kind },
+      {
+        q: { type: 'string', required: false },
+        kind: { type: 'string', required: false },
+      },
+    );
+
+    const query = {};
+    if (q !== undefined) query.q = q;
+    if (kind !== undefined) query.kind = kind;
+
+    return this.sdk._fetch('/chat/admin/channels', 'GET', { query });
+  }
+
+  /**
+   * Admin: get a channel by id (no membership required).
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async adminGetChannel(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/admin/channels/${id}`, 'GET');
+  }
+
+  /**
+   * Admin: export a channel (messages + members).
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async adminExportChannel(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/admin/channels/${id}/export`, 'GET');
+  }
+
+  /**
+   * Admin: list message reports.
+   * @param {Object} [params]
+   * @param {string} [params.status]
+   * @returns {Promise<Object>}
+   */
+  async adminListReports({ status } = {}) {
+    this.sdk.validateParams(
+      { status },
+      { status: { type: 'string', required: false } },
+    );
+
+    const query = {};
+    if (status !== undefined) query.status = status;
+
+    return this.sdk._fetch('/chat/admin/reports', 'GET', { query });
+  }
+
+  /**
+   * Admin: review a message report (set status).
+   * @param {string} id
+   * @param {Object} params
+   * @param {string} params.status
+   * @returns {Promise<Object>}
+   */
+  async adminReviewReport(id, { status } = {}) {
+    this.sdk.validateParams(
+      { id, status },
+      {
+        id: { type: 'string', required: true },
+        status: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/admin/reports/${id}`, 'POST', {
+      body: { status },
+    });
+  }
+
+  /**
+   * Admin: delete a message (moderation).
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async adminDeleteMessage(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/admin/messages/${id}`, 'DELETE');
+  }
+
+  /**
+   * Admin: audit log of review actions.
+   * @returns {Promise<Object>}
+   */
+  async adminAudit() {
+    return this.sdk._fetch('/chat/admin/audit', 'GET');
+  }
+
+  /**
+   * Get (find-or-create) the record-feed channel for a related record.
+   * @param {string} relatedId
+   * @param {Object} params
+   * @param {string} params.recordTypeId
+   * @returns {Promise<Object>} Record-kind channel
+   */
+  async getRecordChannel(relatedId, { recordTypeId } = {}) {
+    this.sdk.validateParams(
+      { relatedId, recordTypeId },
+      {
+        relatedId: { type: 'string', required: true },
+        recordTypeId: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/records/${relatedId}`, 'GET', {
+      query: { recordTypeId },
+    });
+  }
+
+  /**
+   * Post a message to a record-feed channel (find-or-create).
+   * @param {string} relatedId
+   * @param {Object} params
+   * @param {Object} params.message - ProseMirror JSON (required)
+   * @param {string} params.recordTypeId
+   * @returns {Promise<Object>} Created message
+   */
+  async postToRecord(relatedId, { message, recordTypeId } = {}) {
+    this.sdk.validateParams(
+      { relatedId, message, recordTypeId },
+      {
+        relatedId: { type: 'string', required: true },
+        message: { type: 'object', required: true },
+        recordTypeId: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/records/${relatedId}/messages`, 'POST', {
+      body: { message, recordTypeId },
+    });
+  }
+
+  /**
+   * Get the Meet/Call room for a channel.
+   * @param {string} channelId
+   * @returns {Promise<Object>}
+   */
+  async getChannelMeet(channelId) {
+    this.sdk.validateParams(
+      { channelId },
+      { channelId: { type: 'string', required: true } },
+    );
+    return this.sdk._fetch(`/chat/channels/${channelId}/meet`, 'GET');
+  }
+
+  /**
+   * Get the VAPID public key for Web Push subscription.
+   * @returns {Promise<Object>}
+   */
+  async getVapidPublicKey() {
+    return this.sdk._fetch('/chat/push/vapidPublicKey', 'GET');
+  }
+
+  /**
+   * Register a push device (web push subscription or native FCM/APNs token).
+   * @param {Object} params
+   * @param {'webpush'|'fcm'|'apns'} params.kind
+   * @param {Object} params.subscription - Push subscription / token JSON
+   * @returns {Promise<Object>}
+   */
+  async registerPushDevice({ kind, subscription } = {}) {
+    this.sdk.validateParams(
+      { kind, subscription },
+      {
+        kind: { type: 'string', required: true },
+        subscription: { type: 'object', required: true },
+      },
+    );
+    return this.sdk._fetch('/chat/push/devices', 'POST', {
+      body: { kind, subscription },
+    });
+  }
+
+  /**
+   * Unregister a push device.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async unregisterPushDevice(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return this.sdk._fetch(`/chat/push/devices/${id}`, 'DELETE');
+  }
+
+  /**
+   * Set the caller's notifyLevel on a channel (all | mentions | mute).
+   * @param {string} channelId
+   * @param {Object} params
+   * @param {'all'|'mentions'|'mute'} params.notifyLevel
+   * @returns {Promise<Object>}
+   */
+  async setNotifyLevel(channelId, { notifyLevel } = {}) {
+    this.sdk.validateParams(
+      { channelId, notifyLevel },
+      {
+        channelId: { type: 'string', required: true },
+        notifyLevel: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(`/chat/channels/${channelId}/notify`, 'PATCH', {
+      body: { notifyLevel },
+    });
+  }
+}

package/services/inbox.js

@@ -15,15 +15,53 @@ export class InboxService {
    * @param {string} [params.before] - UTC cursor 'YYYY-MM-DD HH:mm:ss';
    *   only items strictly older than this are returned.
    * @param {boolean} [params.unreadOnly] - When true, only unread items.
+   * @param {string} [params.startDate] - Inclusive range start `YYYY-MM-DD`.
+   * @param {string} [params.endDate] - Inclusive range end `YYYY-MM-DD`.
+   * @param {string} [params.q] - Search numbers, names, previews.
+   * @param {string} [params.direction] - `inbound` or `outbound`.
+   * @param {boolean} [params.missed] - Missed inbound calls only.
+   * @param {boolean} [params.hasRecording] - Calls/meetings with a recording.
+   * @param {boolean} [params.hasTranscription] - Calls/meetings/voicemail
+   *   with a transcript.
    * @returns {Promise<{items: Object[], nextCursor: string|null}>}
    */
-  async list({ types, limit, before, unreadOnly } = {}) {
+  async list({
+    types,
+    limit,
+    before,
+    unreadOnly,
+    startDate,
+    endDate,
+    q,
+    direction,
+    missed,
+    hasRecording,
+    hasTranscription,
+  } = {}) {
     this.sdk.validateParams(
-      { limit, before, unreadOnly },
+      {
+        limit,
+        before,
+        unreadOnly,
+        startDate,
+        endDate,
+        q,
+        direction,
+        missed,
+        hasRecording,
+        hasTranscription,
+      },
       {
         limit: { type: 'number', required: false },
         before: { type: 'string', required: false },
         unreadOnly: { type: 'boolean', required: false },
+        startDate: { type: 'string', required: false },
+        endDate: { type: 'string', required: false },
+        q: { type: 'string', required: false },
+        direction: { type: 'string', required: false },
+        missed: { type: 'boolean', required: false },
+        hasRecording: { type: 'boolean', required: false },
+        hasTranscription: { type: 'boolean', required: false },
       },
     );
 
@@ -42,6 +80,15 @@ export class InboxService {
     if (limit !== undefined) query.limit = limit;
     if (before !== undefined) query.before = before;
     if (unreadOnly !== undefined) query.unreadOnly = unreadOnly;
+    if (startDate !== undefined) query.startDate = startDate;
+    if (endDate !== undefined) query.endDate = endDate;
+    if (q !== undefined) query.q = q;
+    if (direction !== undefined) query.direction = direction;
+    if (missed !== undefined) query.missed = missed;
+    if (hasRecording !== undefined) query.hasRecording = hasRecording;
+    if (hasTranscription !== undefined) {
+      query.hasTranscription = hasTranscription;
+    }
 
     const params = { query };
 

package/services/messaging/EmailMailboxesService.js

@@ -455,4 +455,53 @@ export class EmailMailboxesService {
     );
     return result;
   }
+
+  async createFolder(mailboxId, { name, parent } = {}) {
+    this.sdk.validateParams(
+      { mailboxId, name, parent },
+      {
+        mailboxId: { type: 'string', required: true },
+        name: { type: 'string', required: true },
+        parent: { type: 'string', required: false },
+      },
+    );
+    const body = { name };
+    if (parent) body.parent = parent;
+    return this.sdk._fetch(
+      `/messaging/email/mailbox/${mailboxId}/folders`,
+      'POST',
+      { body },
+    );
+  }
+
+  async renameFolder(mailboxId, { from, to } = {}) {
+    this.sdk.validateParams(
+      { mailboxId, from, to },
+      {
+        mailboxId: { type: 'string', required: true },
+        from: { type: 'string', required: true },
+        to: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(
+      `/messaging/email/mailbox/${mailboxId}/folders`,
+      'PUT',
+      { body: { from, to } },
+    );
+  }
+
+  async deleteFolder(mailboxId, { name } = {}) {
+    this.sdk.validateParams(
+      { mailboxId, name },
+      {
+        mailboxId: { type: 'string', required: true },
+        name: { type: 'string', required: true },
+      },
+    );
+    return this.sdk._fetch(
+      `/messaging/email/mailbox/${mailboxId}/folders`,
+      'DELETE',
+      { query: { name }, body: { name } },
+    );
+  }
 }

package/services/taskRouter/CCService.js

@@ -11,7 +11,7 @@ export class CCService {
    * @returns {Promise<Object>} result
    * @returns {boolean} result.isManager - Whether the caller has queue-manager scope
    * @returns {string|null} result.workerId - The caller's own worker id, if any
-   * @returns {Array<Object>} result.queues - Accessible queues [{id, name, slaThreshold}]
+   * @returns {Array<Object>} result.queues - Accessible queues [{id, name, slaThreshold, slaTargetPct, timezone}]
    *
    * @example
    * const scope = await sdk.taskRouter.cc.getScope();
@@ -30,7 +30,7 @@ export class CCService {
    * @param {string[]} [options.queueIds] - Queue ids to scope to (must be a subset of the caller's accessible queues). Omit/empty for full scope.
    * @returns {Promise<Object>} result
    * @returns {Object} result.kpis - Aggregate KPIs (inQueueNow, longestWaitSec, myHandledToday, myAvgHandleSecToday, slaTodayPct, slaTargetPct)
-   * @returns {Array<Object>} result.queues - Per-queue summaries (id, name, waiting, longestWaitSec, agentsAvailable, agentsTotal, slaPct, health)
+   * @returns {Array<Object>} result.queues - Per-queue summaries (id, name, waiting, longestWaitSec, agentsAvailable, agentsTotal, slaPct, slaThreshold, slaTargetPct, timezone, health)
    * @returns {Array<Object>} result.team - Team roster with active tasks
    *
    * @example
@@ -150,7 +150,7 @@ export class CCService {
    *
    * @param {Object} options - Parameters
    * @param {string} options.queueId - Queue id to update
-   * @param {Object} options.weights - `{sentiment, sla, volume, acceptance}` ints summing to 100
+   * @param {Object} options.weights - `{sentiment, aht, volume, acceptance}` ints summing to 100
    * @returns {Promise<Object>} result
    * @returns {string} result.queueId
    * @returns {Object} result.rankingWeights - The stored weights
@@ -158,7 +158,7 @@ export class CCService {
    * @example
    * await sdk.taskRouter.cc.setQueueRankingWeights({
    *   queueId: 'q1',
-   *   weights: { sentiment: 35, sla: 25, volume: 20, acceptance: 20 },
+   *   weights: { sentiment: 40, aht: 30, volume: 5, acceptance: 25 },
    * });
    */
   async setQueueRankingWeights(options = {}) {

package/services/video.js

@@ -1065,7 +1065,10 @@ export class VideoService {
       },
     );
 
-    const result = await this.sdk._fetch(`/video/${roomId}/livePresence`, 'GET');
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/livePresence`,
+      'GET',
+    );
     return result;
   }
 
@@ -1282,7 +1285,11 @@ export class VideoService {
       },
     );
 
-    const result = await this.sdk._fetch(`/video/${roomId}/auto-name`, 'POST', {});
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/auto-name`,
+      'POST',
+      {},
+    );
     return result;
   }
 
@@ -1431,10 +1438,19 @@ export class VideoService {
    * the meet-hub plan — this file has no existing nested-namespace
    * precedent, so flat matches every other method here.
    *
+   * @param {string} [userId] - Optional target userId (admin viewing another user's room, e.g. Setup -> Users -> Meet). Defaults to the calling user.
    * @returns {Promise<{personalRoom: {id: string, slug: string, url: string|null, dialInPin: string, guestsCanStart: boolean}}>}
    */
-  async getPersonalRoom() {
-    const result = await this.sdk._fetch('/video/personal-room', 'GET');
+  async getPersonalRoom(userId = null) {
+    const params = { query: {} };
+    if (userId) {
+      this.sdk.validateParams(
+        { userId },
+        { userId: { type: 'string', required: true } },
+      );
+      params.query.userId = userId;
+    }
+    const result = await this.sdk._fetch('/video/personal-room', 'GET', params);
     return result;
   }
 
@@ -1445,9 +1461,11 @@ export class VideoService {
    * @param {Object} [update]
    * @param {string} [update.slug] - New slug (3-32 chars, lowercase/numbers/hyphens, not reserved). 409-equivalent BadRequestError on collision.
    * @param {boolean} [update.guestsCanStart] - Whether guests can start the room without the host present.
+   * @param {string} [update.password] - New static room passcode.
+   * @param {string} [update.userId] - Optional target userId (admin editing another user's room). Defaults to the calling user.
    * @returns {Promise<{personalRoom: {id: string, slug: string, url: string|null, dialInPin: string, guestsCanStart: boolean}}>}
    */
-  async updatePersonalRoom({ slug, guestsCanStart, password } = {}) {
+  async updatePersonalRoom({ slug, guestsCanStart, password, userId } = {}) {
     const validationSchema = {};
     if (slug !== undefined) validationSchema.slug = { type: 'string' };
     if (guestsCanStart !== undefined)
@@ -1455,10 +1473,11 @@ export class VideoService {
     // Static room passcode — 4-6 digits (api-enforced); applied to every
     // session the room link mints.
     if (password !== undefined) validationSchema.password = { type: 'string' };
+    if (userId !== undefined) validationSchema.userId = { type: 'string' };
 
     if (Object.keys(validationSchema).length > 0) {
       this.sdk.validateParams(
-        { slug, guestsCanStart, password },
+        { slug, guestsCanStart, password, userId },
         validationSchema,
       );
     }
@@ -1467,26 +1486,32 @@ export class VideoService {
     if (slug !== undefined) body.slug = slug;
     if (guestsCanStart !== undefined) body.guestsCanStart = guestsCanStart;
     if (password !== undefined) body.password = password;
+    if (userId !== undefined) body.userId = userId;
 
     const params = { body };
-    const result = await this.sdk._fetch(
-      '/video/personal-room',
-      'PUT',
-      params,
-    );
+    const result = await this.sdk._fetch('/video/personal-room', 'PUT', params);
     return result;
   }
 
   /**
    * Regenerate the dial-in PIN for the calling user's personal meeting room.
    *
+   * @param {string} [userId] - Optional target userId (admin action). Defaults to the calling user.
    * @returns {Promise<{personalRoom: {id: string, dialInPin: string}}>}
    */
-  async regeneratePersonalRoomPin() {
+  async regeneratePersonalRoomPin(userId = null) {
+    const body = {};
+    if (userId) {
+      this.sdk.validateParams(
+        { userId },
+        { userId: { type: 'string', required: true } },
+      );
+      body.userId = userId;
+    }
     const result = await this.sdk._fetch(
       '/video/personal-room/regenerate-pin',
       'POST',
-      {},
+      { body },
     );
     return result;
   }
@@ -1495,17 +1520,23 @@ export class VideoService {
    * Live availability dry-run for a personal-room slug (settings editor).
    *
    * @param {string} slug - Candidate slug.
+   * @param {string} [userId] - Optional target userId (admin action). Defaults to the calling user.
    * @returns {Promise<{slug: string, available: boolean, reason?: 'invalid'|'taken'}>}
    */
-  async checkPersonalRoomSlug(slug) {
+  async checkPersonalRoomSlug(slug, userId = null) {
     this.sdk.validateParams(
-      { slug },
-      { slug: { type: 'string', required: true } },
+      { slug, userId },
+      {
+        slug: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+      },
     );
+    const query = { slug };
+    if (userId) query.userId = userId;
     const result = await this.sdk._fetch(
-      `/video/personal-room/slug-available?slug=${encodeURIComponent(slug)}`,
+      '/video/personal-room/slug-available',
       'GET',
-      {},
+      { query },
     );
     return result;
   }
@@ -1515,13 +1546,22 @@ export class VideoService {
    * meeting room (a separate secret from the dial-in PIN). Sessions minted
    * after this use the new value.
    *
+   * @param {string} [userId] - Optional target userId (admin action). Defaults to the calling user.
    * @returns {Promise<{personalRoom: {id: string, password: string}}>}
    */
-  async regeneratePersonalRoomPassword() {
+  async regeneratePersonalRoomPassword(userId = null) {
+    const body = {};
+    if (userId) {
+      this.sdk.validateParams(
+        { userId },
+        { userId: { type: 'string', required: true } },
+      );
+      body.userId = userId;
+    }
     const result = await this.sdk._fetch(
       '/video/personal-room/regenerate-password',
       'POST',
-      {},
+      { body },
     );
     return result;
   }

package/services/voice.js

@@ -22,6 +22,34 @@ export class VoiceService {
     return result;
   }
 
+  async transcription({
+    cdrId,
+    callId,
+    action = 'start',
+    direction = 'sendrecv',
+  }) {
+    this.sdk.validateParams(
+      { callId, cdrId, action, direction },
+      {
+        cdrId: { type: 'string', required: false },
+        callId: { type: 'string', required: false },
+        action: { type: 'string', required: false },
+        direction: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: { callId, cdrId, action, direction },
+    };
+
+    const result = await this.sdk._fetch(
+      `/voice/transcription/`,
+      'POST',
+      params,
+    );
+    return result;
+  }
+
   async call({ to, from, destination, app, timeout, customHeaders, statusWebhook }) {
     this.sdk.validateParams(
       { to, from, destination, app, timeout, customHeaders, statusWebhook },