@unboundcx/sdk 4.13.50 → 4.13.53

package/base.js

@@ -387,8 +387,15 @@ export class BaseSDK {
 
     // Add query parameters
     if (query) {
-      const params = new URLSearchParams(query).toString();
-      url += `?${params}`;
+      // Drop undefined/null so optional args don't serialize as the literal
+      // string "undefined" (URLSearchParams would send limit=undefined).
+      const cleanQuery = Object.fromEntries(
+        Object.entries(query).filter(
+          ([, v]) => v !== undefined && v !== null,
+        ),
+      );
+      const params = new URLSearchParams(cleanQuery).toString();
+      if (params) url += `?${params}`;
     }
 
     // Handle body

package/index.js

@@ -74,10 +74,17 @@ class UnboundSDK extends BaseSDK {
       }
     } else {
       // New object-based parameters
-      const { namespace, callId, token, fwRequestId, url, socketStore } =
-        options;
+      const {
+        namespace,
+        callId,
+        token,
+        fwRequestId,
+        url,
+        socketStore,
+        baseURL,
+      } = options;
 
-      super({ namespace, callId, token, fwRequestId });
+      super({ namespace, callId, token, fwRequestId, baseURL });
 
       // Handle client-side specific parameters
       if (url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.13.50",
+  "version": "4.13.53",
   "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/messaging/EmailService.js

@@ -642,6 +642,7 @@ export class EmailService {
       limit = 25,
       offset = 0,
       assignedUserId,
+      includeTasked = false,
     } = {},
   ) {
     this.sdk.validateParams(
@@ -655,6 +656,7 @@ export class EmailService {
         limit,
         offset,
         assignedUserId,
+        includeTasked,
       },
       {
         mailboxId: { type: 'string', required: true },
@@ -666,12 +668,14 @@ export class EmailService {
         limit: { type: 'number', required: false },
         offset: { type: 'number', required: false },
         assignedUserId: { type: 'string', required: false },
+        includeTasked: { type: 'boolean', required: false },
       },
     );
 
     const query = { folder, includeDrafts, sortBy, sortOrder, limit, offset };
     if (search) query.search = search;
     if (assignedUserId) query.assignedUserId = assignedUserId;
+    if (includeTasked) query.includeTasked = true;
 
     const params = {
       query,

package/services/objects.js

@@ -1291,6 +1291,81 @@ export class ObjectsService {
     });
   }
 
+  /**
+   * Engagement-session participant roster (requester + durable CCs).
+   * `recordId` is an engagement session id.
+   *
+   * GET /object/:id/participants
+   *
+   * @param {string} recordId
+   * @returns {Promise<{participants: Array<{
+   *   id: string,
+   *   engagementSessionId: string,
+   *   role: string,
+   *   email: string|null,
+   *   peopleId: string|null,
+   *   displayName: string|null,
+   *   addedBy: {id: string, name: string|null}|null,
+   *   createdAt: string
+   * }>}>}
+   */
+  async listParticipants(recordId) {
+    this.sdk.validateParams(
+      { recordId },
+      { recordId: { type: 'string', required: true } },
+    );
+    return internalRequest(
+      this.sdk,
+      `/object/${recordId}/participants`,
+      'GET',
+    );
+  }
+
+  /**
+   * Add a durable CC on an engagement session (PR5).
+   * PUT /object/:id/participants
+   *
+   * @param {string} recordId engagement session id
+   * @param {{email: string, displayName?: string, peopleId?: string}} body
+   */
+  async addParticipant(recordId, body = {}) {
+    this.sdk.validateParams(
+      { recordId, email: body.email },
+      {
+        recordId: { type: 'string', required: true },
+        email: { type: 'string', required: true },
+      },
+    );
+    return internalRequest(
+      this.sdk,
+      `/object/${recordId}/participants`,
+      'PUT',
+      { body },
+    );
+  }
+
+  /**
+   * Remove a durable CC from an engagement session (PR5).
+   * DELETE /object/:id/participants/:participantId
+   *
+   * @param {string} recordId engagement session id
+   * @param {string} participantId
+   */
+  async removeParticipant(recordId, participantId) {
+    this.sdk.validateParams(
+      { recordId, participantId },
+      {
+        recordId: { type: 'string', required: true },
+        participantId: { type: 'string', required: true },
+      },
+    );
+    return internalRequest(
+      this.sdk,
+      `/object/${recordId}/participants/${participantId}`,
+      'DELETE',
+    );
+  }
+
   /**
    * Marketing programs dashboard (programs + totals).
    * @returns {Promise<object>}

package/services/taskRouter/TaskService.js

@@ -23,6 +23,9 @@ export class TaskService {
    * @param {boolean} [options.createEngagement=false] - Whether to automatically create an engagement session for this task
    * @param {string} [options.relatedObject] - Related object type for metadata tracking (automatically set if createEngagement is true)
    * @param {string} [options.relatedId] - Related object ID for metadata tracking (automatically set if createEngagement is true)
+   * @param {string} [options.parentTaskId] - Parent task id (wrapUp follow-up / requeue)
+   * @param {string} [options.preferredWorkerId] - Preferred worker id persisted on create INSERT
+   * @param {string} [options.source] - Engagement `source` when `createEngagement` is true (e.g. `'portal'`)
    * @param {Object} [options.metadata] - Arbitrary metadata to attach to the task at creation (e.g. `{ textConversationId }`). Passed through as-is; whether it is persisted depends on the receiving endpoint honoring `metadata` in the request body.
    * @returns {Promise<Object>} Object containing the created task information
    * @returns {string} result.id - The unique identifier for the created task
@@ -84,7 +87,11 @@ export class TaskService {
       cdrId,
       sipCallId,
       aiChatSessionId,
+      parentTaskId,
+      preferredWorkerId,
+      isRoutable,
       metadata,
+      source,
     } = options;
 
     this.sdk.validateParams(
@@ -104,7 +111,11 @@ export class TaskService {
         relatedId,
         sipCallId,
         aiChatSessionId,
+        parentTaskId,
+        preferredWorkerId,
+        isRoutable,
         metadata,
+        source,
       },
       {
         type: { type: 'string', required: true },
@@ -122,7 +133,11 @@ export class TaskService {
         relatedId: { type: 'string', required: false },
         sipCallId: { type: 'string', required: false },
         aiChatSessionId: { type: 'string', required: false },
+        parentTaskId: { type: 'string', required: false },
+        preferredWorkerId: { type: 'string', required: false },
+        isRoutable: { type: 'boolean', required: false },
         metadata: { type: 'object', required: false },
+        source: { type: 'string', required: false },
       },
     );
 
@@ -185,10 +200,26 @@ export class TaskService {
       params.body.aiChatSessionId = aiChatSessionId;
     }
 
+    if (parentTaskId !== undefined) {
+      params.body.parentTaskId = parentTaskId;
+    }
+
+    if (preferredWorkerId !== undefined) {
+      params.body.preferredWorkerId = preferredWorkerId;
+    }
+
+    if (isRoutable !== undefined) {
+      params.body.isRoutable = isRoutable;
+    }
+
     if (metadata !== undefined) {
       params.body.metadata = metadata;
     }
 
+    if (source !== undefined) {
+      params.body.source = source;
+    }
+
     const result = await internalRequest(this.sdk, '/taskRouter/tasks', 'POST', params);
     return result;
   }
@@ -444,44 +475,53 @@ export class TaskService {
   }
 
   /**
-   * Toggle task hold status
+   * Toggle or set task hold status
    * Place a connected task on hold or resume a held task.
-   * If the task is currently 'connected', it will be set to 'hold'.
-   * If the task is currently 'hold', it will be set back to 'connected'.
+   * If `held` is omitted, the current status is toggled: 'connected' -> 'hold'
+   * and 'hold' -> 'connected'. If `held` is a boolean, it explicitly sets the
+   * target status: `true` -> 'hold', `false` -> 'connected'.
    *
    * @param {Object} options - Parameters
    * @param {string} options.taskId - The task ID to hold/resume (required)
+   * @param {boolean} [options.held] - Explicit target hold state; omit for legacy toggle behavior
    * @returns {Promise<Object>} Object containing the task ID and new status
    * @returns {string} result.taskId - The task ID that was modified
    * @returns {string} result.status - The new status ('hold' or 'connected')
+   * @returns {boolean} result.changed - Whether the status actually changed
    *
    * @example
    * // Put a connected task on hold
-   * const result = await sdk.taskRouter.task.hold({ taskId: 'task123' });
+   * const result = await sdk.taskRouter.task.hold({ taskId: 'task123', held: true });
    * console.log(result.status); // "hold"
    *
    * @example
    * // Resume a held task
-   * const result = await sdk.taskRouter.task.hold({ taskId: 'task123' });
+   * const result = await sdk.taskRouter.task.hold({ taskId: 'task123', held: false });
    * console.log(result.status); // "connected"
+   *
+   * @example
+   * // Legacy toggle (no `held`)
+   * const result = await sdk.taskRouter.task.hold({ taskId: 'task123' });
    */
   async hold(options = {}) {
-    const { taskId } = options;
+    const { taskId, held } = options;
 
     this.sdk.validateParams(
-      { taskId },
+      { taskId, held },
       {
         taskId: { type: 'string', required: true },
+        held: { type: 'boolean', required: false },
       },
     );
 
     const params = {
       body: {
         taskId,
+        ...(typeof held === 'boolean' && { held }),
       },
     };
 
-    const result = await internalRequest(this.sdk, 
+    const result = await internalRequest(this.sdk,
       '/taskRouter/tasks/hold',
       'PUT',
       params,
@@ -880,6 +920,92 @@ export class TaskService {
     );
   }
 
+  /**
+   * Resume a parked task ("customer is back"). Flips the task back to
+   * pending so the distributor re-offers it; preferredWorkerId (stamped by
+   * park) is left alone so the parking worker gets first refusal.
+   *
+   * PUT /taskRouter/tasks/unpark
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.taskId - The parked task ID (required)
+   * @returns {Promise<Object>} { taskId, status: 'pending' }
+   */
+  async unpark(options = {}) {
+    const { taskId } = options;
+
+    this.sdk.validateParams(
+      { taskId },
+      { taskId: { type: 'string', required: true } },
+    );
+
+    const params = { body: { taskId } };
+
+    return await internalRequest(
+      this.sdk,
+      '/taskRouter/tasks/unpark',
+      'PUT',
+      params,
+    );
+  }
+
+  /**
+   * Public reply on a ticket task: writes the customer-visible post and
+   * emails requester + CCs (transactional) from the queue mailbox.
+   *
+   * POST /taskRouter/tasks/:id/public-reply
+   *
+   * @param {Object} options
+   * @param {string} options.taskId
+   * @param {string} [options.html]
+   * @param {string} [options.text]
+   * @param {string|string[]} [options.extraTo]
+   * @param {string|string[]} [options.extraCc]
+   * @param {string|string[]} [options.extraBcc]
+   * @param {string|string[]} [options.attachments]
+   * @param {boolean} [options.addExtrasToTicket]
+   * @param {string} [options.retryVisitorMessageId]
+   */
+  async publicReply(options = {}) {
+    const {
+      taskId,
+      html,
+      text,
+      extraTo,
+      extraCc,
+      extraBcc,
+      attachments,
+      addExtrasToTicket,
+      retryVisitorMessageId,
+    } = options;
+
+    this.sdk.validateParams(
+      { taskId },
+      { taskId: { type: 'string', required: true } },
+    );
+
+    const body = {};
+    if (html !== undefined) body.html = html;
+    if (text !== undefined) body.text = text;
+    if (extraTo !== undefined) body.extraTo = extraTo;
+    if (extraCc !== undefined) body.extraCc = extraCc;
+    if (extraBcc !== undefined) body.extraBcc = extraBcc;
+    if (attachments !== undefined) body.attachments = attachments;
+    if (addExtrasToTicket !== undefined) {
+      body.addExtrasToTicket = addExtrasToTicket;
+    }
+    if (retryVisitorMessageId !== undefined) {
+      body.retryVisitorMessageId = retryVisitorMessageId;
+    }
+
+    return await internalRequest(
+      this.sdk,
+      `/taskRouter/tasks/${taskId}/public-reply`,
+      'POST',
+      { body },
+    );
+  }
+
   /**
    * Mark a task's inbound messages as read for one channel (or all).
    * Channel ids: sms | webchat | email | whatsApp | rcs | all.