@unboundcx/sdk 4.8.9 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.8.9",
+  "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/directory.js

@@ -15,27 +15,33 @@ export class DirectoryService {
   }
 
   /**
-   * Add a person or company to directory favorites. Reactivates a
-   * soft-deleted favorite on unique conflict.
+   * Add a person, company, user, or queue to directory favorites.
+   * Reactivates a soft-deleted favorite on unique conflict.
    *
    * @param {Object} params
-   * @param {string} params.objectType - 'person' or 'company' (required).
+   * @param {string} params.objectType - 'person', 'company', 'user', or 'queue' (required).
    * @param {string} params.objectId - Id of the favorited record (required).
    * @param {string[]} [params.channelIds] - Channel ids to pin for this favorite.
+   * @param {string} [params.channelId] - Channel id to pin for this favorite.
+   * @param {string} [params.numberField] - Number field to associate with this favorite.
    * @returns {Promise<Object>} The created (or reactivated) favorite.
    */
-  async addFavorite({ objectType, objectId, channelIds }) {
+  async addFavorite({ objectType, objectId, channelIds, channelId, numberField }) {
     this.sdk.validateParams(
-      { objectType, objectId, channelIds },
+      { objectType, objectId, channelIds, channelId, numberField },
       {
         objectType: { type: 'string', required: true },
         objectId: { type: 'string', required: true },
         channelIds: { type: 'array', required: false },
+        channelId: { type: 'string', required: false },
+        numberField: { type: 'string', required: false },
       },
     );
 
     const body = { objectType, objectId };
     if (channelIds !== undefined) body.channelIds = channelIds;
+    if (channelId !== undefined) body.channelId = channelId;
+    if (numberField !== undefined) body.numberField = numberField;
 
     const params = { body };
 
@@ -49,21 +55,27 @@ export class DirectoryService {
    * @param {string} favoriteId - Id of the favorite to update (required).
    * @param {Object} params
    * @param {string[]} [params.channelIds]
+   * @param {string} [params.channelId]
+   * @param {string} [params.numberField]
    * @param {number} [params.sortOrder]
    * @returns {Promise<Object>} The updated favorite.
    */
-  async updateFavorite(favoriteId, { channelIds, sortOrder } = {}) {
+  async updateFavorite(favoriteId, { channelIds, channelId, numberField, sortOrder } = {}) {
     this.sdk.validateParams(
-      { favoriteId, channelIds, sortOrder },
+      { favoriteId, channelIds, channelId, numberField, sortOrder },
       {
         favoriteId: { type: 'string', required: true },
         channelIds: { type: 'array', required: false },
+        channelId: { type: 'string', required: false },
+        numberField: { type: 'string', required: false },
         sortOrder: { type: 'number', required: false },
       },
     );
 
     const body = {};
     if (channelIds !== undefined) body.channelIds = channelIds;
+    if (channelId !== undefined) body.channelId = channelId;
+    if (numberField !== undefined) body.numberField = numberField;
     if (sortOrder !== undefined) body.sortOrder = sortOrder;
 
     const params = { body };
@@ -121,4 +133,58 @@ export class DirectoryService {
     );
     return result;
   }
+
+  /**
+   * List the current user's directory contacts.
+   *
+   * @returns {Promise<{contacts: Object[]}>}
+   */
+  async listContacts() {
+    const result = await this.sdk._fetch('/directory/contacts', 'GET');
+    return result;
+  }
+
+  /**
+   * Add a person or company to directory contacts.
+   *
+   * @param {Object} params
+   * @param {string} params.objectType - 'person' or 'company' (required).
+   * @param {string} params.objectId - Id of the contacted record (required).
+   * @returns {Promise<Object>} The created contact.
+   */
+  async addContact({ objectType, objectId }) {
+    this.sdk.validateParams(
+      { objectType, objectId },
+      {
+        objectType: { type: 'string', required: true },
+        objectId: { type: 'string', required: true },
+      },
+    );
+
+    const params = { body: { objectType, objectId } };
+
+    const result = await this.sdk._fetch('/directory/contacts', 'POST', params);
+    return result;
+  }
+
+  /**
+   * Remove a directory contact.
+   *
+   * @param {string} contactId - Id of the contact to remove (required).
+   * @returns {Promise<Object>}
+   */
+  async removeContact(contactId) {
+    this.sdk.validateParams(
+      { contactId },
+      {
+        contactId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/directory/contacts/${contactId}`,
+      'DELETE',
+    );
+    return result;
+  }
 }

package/services/inbox.js

@@ -9,21 +9,59 @@ export class InboxService {
    *
    * @param {Object} params
    * @param {string|string[]} [params.types] - Source kinds to include
-   *   ('call','voicemail','fax','sms'). Pass an array or a comma-joined
-   *   string; omit to include all kinds.
+   *   ('call','voicemail','fax','sms','meeting'). Pass an array or a
+   *   comma-joined string; omit to include all kinds.
    * @param {number} [params.limit] - Max items to return.
    * @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 };
 
@@ -82,10 +129,10 @@ export class InboxService {
   }
 
   /**
-   * Fetch inbox stats (calls/talk time/missed/unread voicemail) for the
-   * current user.
+   * Fetch inbox stats (calls/talk time/missed/unread voicemail/meetings) for
+   * the current user.
    *
-   * @returns {Promise<{callsToday: number, talkTimeSeconds: number, missedToday: number, unreadVoicemail: number, oldestUnreadVoicemailAt: string|null}>}
+   * @returns {Promise<{callsToday: number, talkTimeSeconds: number, missedToday: number, unreadVoicemail: number, oldestUnreadVoicemailAt: string|null, meetingsToday: number, meetingMinutesToday: number}>}
    */
   async stats() {
     const result = await this.sdk._fetch('/inbox/stats', 'GET');

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

@@ -0,0 +1,302 @@
+export class CCService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Resolve the caller's Contact Center queue scope + role.
+   * Managers see every non-deleted queue; agents see only the queues they
+   * belong to (queueUsers).
+   *
+   * @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, slaTargetPct, timezone}]
+   *
+   * @example
+   * const scope = await sdk.taskRouter.cc.getScope();
+   * console.log(scope.isManager, scope.queues.length);
+   */
+  async getScope() {
+    const result = await this.sdk._fetch('/taskRouter/cc/scope', 'GET', {});
+    return result;
+  }
+
+  /**
+   * Get a live Contact Center snapshot (KPIs, per-queue summaries, team roster
+   * with active tasks) scoped to a set of queues.
+   *
+   * @param {Object} [options] - Parameters
+   * @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, slaThreshold, slaTargetPct, timezone, health)
+   * @returns {Array<Object>} result.team - Team roster with active tasks
+   *
+   * @example
+   * const snapshot = await sdk.taskRouter.cc.getSnapshot({ queueIds: ['q1', 'q2'] });
+   * console.log(snapshot.kpis.inQueueNow);
+   */
+  async getSnapshot(options = {}) {
+    const { queueIds } = options;
+
+    this.sdk.validateParams(
+      { queueIds },
+      {
+        queueIds: { type: 'array', required: false },
+      },
+    );
+
+    const params = {};
+    if (queueIds && queueIds.length) {
+      params.query = { queueIds: queueIds.join(',') };
+    }
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/cc/snapshot',
+      'GET',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Get on-queue session history for a worker (self allowed; another
+   * worker's sessions require the queue-manager scope).
+   *
+   * @param {Object} [options] - Parameters
+   * @param {string} [options.workerId] - Worker id to fetch sessions for (defaults to the caller's own worker)
+   * @param {string} [options.from] - ISO-8601 range start
+   * @param {string} [options.to] - ISO-8601 range end
+   * @returns {Promise<Object>} result
+   * @returns {Array<Object>} result.sessions - [{id, startedAt, endedAt, onQueueSec, breakSec, doneCount}]
+   *
+   * @example
+   * const { sessions } = await sdk.taskRouter.cc.getSessions({ workerId: 'w1', from: '2026-08-12T00:00:00Z', to: '2026-08-19T00:00:00Z' });
+   */
+  async getSessions(options = {}) {
+    const { workerId, from, to } = options;
+
+    this.sdk.validateParams(
+      { workerId, from, to },
+      {
+        workerId: { type: 'string', required: false },
+        from: { type: 'string', required: false },
+        to: { type: 'string', required: false },
+      },
+    );
+
+    const query = {};
+    if (workerId) query.workerId = workerId;
+    if (from) query.from = from;
+    if (to) query.to = to;
+
+    const result = await this.sdk._fetch('/taskRouter/cc/sessions', 'GET', {
+      query,
+    });
+    return result;
+  }
+
+  /**
+   * Get windowed composite agent rankings (top/struggling) per queue + an
+   * 'all' rollup, scored from sentiment/SLA/volume/acceptance. `struggling`
+   * arrays are only present when the caller has the queue-manager scope
+   * (see `strugglingIncluded` on the result).
+   *
+   * @param {Object} [options] - Parameters
+   * @param {string[]} [options.queueIds] - Queue ids to scope to (must be a subset of the caller's accessible queues). Omit/empty for full scope.
+   * @param {string} options.from - ISO-8601 window start
+   * @param {string} options.to - ISO-8601 window end
+   * @returns {Promise<Object>} result
+   * @returns {Object} result.queues - Per-queue rankings, keyed by queueId: `{ top: [{workerId,name,score}], struggling?: [...] }`
+   * @returns {Object} result.all - Same shape, aggregated across every scoped queue
+   * @returns {boolean} result.strugglingIncluded - Whether `struggling` arrays were included
+   *
+   * @example
+   * const { queues, all } = await sdk.taskRouter.cc.getRankings({
+   *   queueIds: ['q1'],
+   *   from: '2026-08-12T00:00:00Z',
+   *   to: '2026-08-19T00:00:00Z',
+   * });
+   * console.log(all.top[0].name, all.top[0].score);
+   */
+  async getRankings(options = {}) {
+    const { queueIds, from, to } = options;
+
+    this.sdk.validateParams(
+      { queueIds, from, to },
+      {
+        queueIds: { type: 'array', required: false },
+        from: { type: 'string', required: true },
+        to: { type: 'string', required: true },
+      },
+    );
+
+    const query = { from, to };
+    if (queueIds && queueIds.length) {
+      query.queueIds = queueIds.join(',');
+    }
+
+    const result = await this.sdk._fetch('/taskRouter/cc/rankings', 'GET', {
+      query,
+    });
+    return result;
+  }
+
+  /**
+   * Set a queue's composite ranking-weights override. Manager-only
+   * (`taskrouter:queue:manage`). Weights must be integers 0-100 that sum to
+   * exactly 100.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.queueId - Queue id to update
+   * @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
+   *
+   * @example
+   * await sdk.taskRouter.cc.setQueueRankingWeights({
+   *   queueId: 'q1',
+   *   weights: { sentiment: 40, aht: 30, volume: 5, acceptance: 25 },
+   * });
+   */
+  async setQueueRankingWeights(options = {}) {
+    const { queueId, weights } = options;
+
+    this.sdk.validateParams(
+      { queueId, weights },
+      {
+        queueId: { type: 'string', required: true },
+        weights: { type: 'object', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/taskRouter/cc/queues/${queueId}/rankingWeights`,
+      'PUT',
+      { body: weights },
+    );
+    return result;
+  }
+
+  /**
+   * Get one agent's Contact Center performance summary (KPIs, per-day
+   * charts, live tasks, on-queue sessions) over a date/date-range, with a
+   * comparison window for deltas. Self allowed; another worker's summary
+   * requires the queue-manager scope.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.workerId - Worker id to summarize
+   * @param {string} options.from - ISO-8601 window start
+   * @param {string} options.to - ISO-8601 window end
+   * @param {string} [options.compareFrom] - ISO-8601 comparison window start (defaults to the preceding equal-length period)
+   * @param {string} [options.compareTo] - ISO-8601 comparison window end
+   * @returns {Promise<Object>} result
+   * @returns {Object} result.kpis - tasksHandled, offersAccepted, avgHandleSec, slaMet, avgSentiment, composite, onQueue
+   * @returns {Array<Object>} result.tasksPerDay - [{date, count}]
+   * @returns {Array<Object>} result.trend - [{date, sentiment, slaPct}]
+   * @returns {Array<Object>} result.liveNow - Current tasks (only when the window includes today)
+   * @returns {Array<Object>} result.sessions - On-queue session log
+   *
+   * @example
+   * const summary = await sdk.taskRouter.cc.getAgentSummary({
+   *   workerId: 'w1',
+   *   from: '2026-08-12T00:00:00Z',
+   *   to: '2026-08-19T00:00:00Z',
+   * });
+   * console.log(summary.kpis.tasksHandled.value);
+   */
+  async getAgentSummary(options = {}) {
+    const { workerId, from, to, compareFrom, compareTo } = options;
+
+    this.sdk.validateParams(
+      { workerId, from, to, compareFrom, compareTo },
+      {
+        workerId: { type: 'string', required: true },
+        from: { type: 'string', required: true },
+        to: { type: 'string', required: true },
+        compareFrom: { type: 'string', required: false },
+        compareTo: { type: 'string', required: false },
+      },
+    );
+
+    const query = { from, to };
+    if (compareFrom) query.compareFrom = compareFrom;
+    if (compareTo) query.compareTo = compareTo;
+
+    const result = await this.sdk._fetch(
+      `/taskRouter/cc/agents/${workerId}/summary`,
+      'GET',
+      { query },
+    );
+    return result;
+  }
+
+  /**
+   * Log a worker into or out of a queue. Manager-only
+   * (`taskrouter:queue:manage`). Mutates the worker's queue membership
+   * through task-router (audited).
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.workerId - Worker id to update
+   * @param {string} options.queueId - Queue id to log in/out of
+   * @param {'login'|'logout'} options.action - Whether to add or remove the queue
+   * @returns {Promise<Object>} result
+   * @returns {string} result.workerId
+   * @returns {string} result.status
+   * @returns {Array<string>} result.queues - The worker's updated queue list
+   *
+   * @example
+   * await sdk.taskRouter.cc.setWorkerQueue({ workerId: 'w1', queueId: 'q1', action: 'login' });
+   */
+  async setWorkerQueue(options = {}) {
+    const { workerId, queueId, action } = options;
+
+    this.sdk.validateParams(
+      { workerId, queueId, action },
+      {
+        workerId: { type: 'string', required: true },
+        queueId: { type: 'string', required: true },
+        action: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/taskRouter/cc/workers/${workerId}/queues`,
+      'PUT',
+      { body: { queueId, action } },
+    );
+    return result;
+  }
+
+  /**
+   * Force a worker offline (out of every queue), closing their on-queue
+   * session. Manager-only (`taskrouter:queue:manage`, audited).
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.workerId - Worker id to log out
+   * @returns {Promise<Object>} result
+   * @returns {string} result.workerId
+   * @returns {string} result.status
+   * @returns {Array<string>} result.queues
+   *
+   * @example
+   * await sdk.taskRouter.cc.forceLogoutWorker({ workerId: 'w1' });
+   */
+  async forceLogoutWorker(options = {}) {
+    const { workerId } = options;
+
+    this.sdk.validateParams(
+      { workerId },
+      { workerId: { type: 'string', required: true } },
+    );
+
+    const result = await this.sdk._fetch(
+      `/taskRouter/cc/workers/${workerId}/forceLogout`,
+      'POST',
+      {},
+    );
+    return result;
+  }
+}

package/services/taskRouter/MetricsService.js

@@ -108,4 +108,58 @@ export class MetricsService {
     );
     return result;
   }
+
+  /**
+   * Get windowed queue/company metrics with a compare-window delta, per
+   * queue + an 'all' rollup (avg wait, avg handle, service level, longest
+   * wait, live depth/workers, and a waiting-count sparkline).
+   *
+   * @param {Object} params - Parameters
+   * @param {string[]} [params.queueIds] - Queue ids to scope to. Omit/empty for all queues.
+   * @param {string} params.from - ISO-8601 window start
+   * @param {string} params.to - ISO-8601 window end
+   * @param {string} params.compareFrom - ISO-8601 compare-window start
+   * @param {string} params.compareTo - ISO-8601 compare-window end
+   * @returns {Promise<Object>} result
+   * @returns {Object} result.window - `{from, to}`
+   * @returns {Object} result.compare - `{from, to}`
+   * @returns {Object} result.all - Rollup across every scoped queue (avgWaitSec, avgHandleSec, serviceLevelPct, longestWaitSec, depth, workersAvailable, workersTotal, waitingSparkline, deltas)
+   * @returns {Object} result.queues - Same shape as `result.all`, keyed by queueId
+   *
+   * @example
+   * const { all, queues } = await sdk.taskRouter.metrics.getWindow({
+   *   queueIds: ['q1', 'q2'],
+   *   from: '2026-08-19T22:00:00Z',
+   *   to: '2026-08-19T23:00:00Z',
+   *   compareFrom: '2026-08-19T21:00:00Z',
+   *   compareTo: '2026-08-19T22:00:00Z',
+   * });
+   * console.log(all.serviceLevelPct, all.deltas.serviceLevelPct);
+   */
+  async getWindow(params = {}) {
+    const { queueIds, from, to, compareFrom, compareTo } = params;
+
+    this.sdk.validateParams(
+      { queueIds, from, to, compareFrom, compareTo },
+      {
+        queueIds: { type: 'array', required: false },
+        from: { type: 'string', required: true },
+        to: { type: 'string', required: true },
+        compareFrom: { type: 'string', required: false },
+        compareTo: { type: 'string', required: false },
+      },
+    );
+
+    const query = { from, to };
+    if (queueIds && queueIds.length) query.queueIds = queueIds.join(',');
+    if (compareFrom) query.compareFrom = compareFrom;
+    if (compareTo) query.compareTo = compareTo;
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/metrics/window',
+      'GET',
+      { query },
+    );
+    return result;
+  }
 }

package/services/taskRouter/TaskRouterService.js

@@ -1,6 +1,7 @@
 import { WorkerService } from './WorkerService.js';
 import { TaskService } from './TaskService.js';
 import { MetricsService } from './MetricsService.js';
+import { CCService } from './CCService.js';
 
 export class TaskRouterService {
   constructor(sdk) {
@@ -8,5 +9,6 @@ export class TaskRouterService {
     this.worker = new WorkerService(sdk);
     this.task = new TaskService(sdk);
     this.metrics = new MetricsService(sdk);
+    this.cc = new CCService(sdk);
   }
 }

package/services/video.js

@@ -230,6 +230,7 @@ export class VideoService {
     calendarProvider,
     vocabularyTerms,
     shareOcrEnabled,
+    earlyJoinMinutes,
   }) {
     this.sdk.validateParams(
       {
@@ -259,6 +260,7 @@ export class VideoService {
         calendarProvider,
         vocabularyTerms,
         shareOcrEnabled,
+        earlyJoinMinutes,
       },
       {
         name: { type: 'string', required: false },
@@ -287,6 +289,9 @@ export class VideoService {
         calendarProvider: { type: 'string', required: false },
         vocabularyTerms: { type: 'array', required: false },
         shareOcrEnabled: { type: 'boolean', required: false },
+        // 0 = strict at startTime, 5 = 5-min early window (api rejects
+        // other values); omit for no schedule-window enforcement.
+        earlyJoinMinutes: { type: 'number', required: false },
       },
     );
     const params = {
@@ -317,6 +322,7 @@ export class VideoService {
         calendarProvider,
         vocabularyTerms,
         shareOcrEnabled,
+        earlyJoinMinutes,
       },
     };
     const result = await this.sdk._fetch(`/video`, 'POST', params);
@@ -362,6 +368,8 @@ export class VideoService {
       validationSchema.vocabularyTerms = { type: 'array' };
     if ('shareOcrEnabled' in update)
       validationSchema.shareOcrEnabled = { type: 'boolean' };
+    if ('earlyJoinMinutes' in update)
+      validationSchema.earlyJoinMinutes = { type: 'number' };
 
     if (Object.keys(validationSchema).length > 0) {
       this.sdk.validateParams(update, validationSchema);
@@ -1057,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;
   }
 
@@ -1274,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;
   }
 
@@ -1411,4 +1426,173 @@ export class VideoService {
     );
     return result;
   }
+
+  /**
+   * Get (or lazily create) the calling user's personal meeting room for this
+   * account. Every account user has exactly one; the first call provisions
+   * it server-side.
+   *
+   * NOTE: implemented flat (`getPersonalRoom`/`updatePersonalRoom`/
+   * `regeneratePersonalRoomPin`/`resolvePersonalRoom`) rather than the
+   * `sdk.video.personalRoom.{get,update,regeneratePin}` namespace named in
+   * 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(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;
+  }
+
+  /**
+   * Update the calling user's personal meeting room (slug and/or
+   * guests-can-start). Omit a field to leave it unchanged.
+   *
+   * @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, userId } = {}) {
+    const validationSchema = {};
+    if (slug !== undefined) validationSchema.slug = { type: 'string' };
+    if (guestsCanStart !== undefined)
+      validationSchema.guestsCanStart = { type: 'boolean' };
+    // 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, userId },
+        validationSchema,
+      );
+    }
+
+    const body = {};
+    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);
+    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(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;
+  }
+
+  /**
+   * 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, userId = null) {
+    this.sdk.validateParams(
+      { 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',
+      'GET',
+      { query },
+    );
+    return result;
+  }
+
+  /**
+   * Regenerate the static web passcode for the calling user's personal
+   * 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(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;
+  }
+
+  /**
+   * Resolve a personal-room slug to a live session (join page). Guest-capable
+   * — mints/claims a fresh meeting if none is live, or returns the already
+   * -claimed session; if the caller is an unauthenticated guest and the room
+   * doesn't allow guests to start, returns `waitingForHost: true` instead.
+   * Guests only receive `password` when they supply the room's static
+   * passcode; otherwise `passwordRequired: true` is returned and the join
+   * page should prompt.
+   *
+   * @param {string} slug - The personal room's slug.
+   * @param {{password?: string}} [options] - The room's static passcode, when known.
+   * @returns {Promise<{claimed: boolean, meetingId?: string, friendlyName?: string, password?: string, passwordRequired?: boolean, waitingForHost?: boolean}>}
+   */
+  async resolvePersonalRoom(slug, { password } = {}) {
+    this.sdk.validateParams(
+      { slug, password },
+      {
+        slug: { type: 'string', required: true },
+        password: { type: 'string', required: false },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/video/personal-room/resolve/${slug}`,
+      'POST',
+      { body: { password } },
+    );
+    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 },