@unboundcx/sdk 4.13.52 → 4.13.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.13.52",
+  "version": "4.13.54",
   "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/taskRouter/TaskService.js

@@ -89,6 +89,7 @@ export class TaskService {
       aiChatSessionId,
       parentTaskId,
       preferredWorkerId,
+      isRoutable,
       metadata,
       source,
     } = options;
@@ -112,6 +113,7 @@ export class TaskService {
         aiChatSessionId,
         parentTaskId,
         preferredWorkerId,
+        isRoutable,
         metadata,
         source,
       },
@@ -133,6 +135,7 @@ export class TaskService {
         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 },
       },
@@ -205,6 +208,10 @@ export class TaskService {
       params.body.preferredWorkerId = preferredWorkerId;
     }
 
+    if (isRoutable !== undefined) {
+      params.body.isRoutable = isRoutable;
+    }
+
     if (metadata !== undefined) {
       params.body.metadata = metadata;
     }
@@ -468,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,
@@ -904,6 +920,35 @@ 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.
@@ -1021,30 +1066,39 @@ export class TaskService {
   }
 
   /**
-   * Transfer a task to a different queue and/or worker. Passing queueId
-   * moves the task back to 'pending' status for re-distribution.
+   * Transfer a task to a different queue and/or worker. Creates a new task
+   * in the target queue and re-points live channels to it; the old task is
+   * completed (blind) or left connected pending completeTransfer/cancelTransfer
+   * (attended).
    *
    * @param {Object} options - Parameters
    * @param {string} options.taskId - The task ID to transfer (required)
    * @param {string} [options.queueId] - Destination queue ID
    * @param {string} [options.workerId] - Destination worker ID
-   * @returns {Promise<Object>} { taskId }
+   * @param {string} [options.mode='blind'] - 'blind' or 'attended'. Attended is only
+   *   meaningful when a live voice leg exists; otherwise treated as blind.
+   * @param {string} [options.note] - Optional note for the receiving agent
+   * @returns {Promise<Object>} { taskId, newTaskId, mode }
    */
   async transfer(options = {}) {
-    const { taskId, queueId, workerId } = options;
+    const { taskId, queueId, workerId, mode, note } = options;
 
     this.sdk.validateParams(
-      { taskId, queueId, workerId },
+      { taskId, queueId, workerId, mode, note },
       {
         taskId: { type: 'string', required: true },
         queueId: { type: 'string', required: false },
         workerId: { type: 'string', required: false },
+        mode: { type: 'string', required: false },
+        note: { type: 'string', required: false },
       },
     );
 
     const params = { body: { taskId } };
     if (queueId !== undefined) params.body.queueId = queueId;
     if (workerId !== undefined) params.body.workerId = workerId;
+    if (mode !== undefined) params.body.mode = mode;
+    if (note !== undefined) params.body.note = note;
 
     return await internalRequest(
       this.sdk,
@@ -1054,6 +1108,59 @@ export class TaskService {
     );
   }
 
+  /**
+   * Complete an attended transfer: unhold the caller, hang up the old
+   * agent's leg, and complete the old task.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.taskId - The old task ID (required)
+   * @returns {Promise<Object>} { taskId }
+   */
+  async transferComplete(options = {}) {
+    const { taskId } = options;
+
+    this.sdk.validateParams(
+      { taskId },
+      { taskId: { type: 'string', required: true } },
+    );
+
+    const params = { body: { taskId } };
+
+    return await internalRequest(
+      this.sdk,
+      '/taskRouter/tasks/transfer/complete',
+      'PUT',
+      params,
+    );
+  }
+
+  /**
+   * Cancel an attended transfer: complete/hang up the new task, re-point
+   * channels back to the old task, unhold the caller, and clear the old
+   * task's transfer state.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.taskId - The old task ID (required)
+   * @returns {Promise<Object>} { taskId }
+   */
+  async transferCancel(options = {}) {
+    const { taskId } = options;
+
+    this.sdk.validateParams(
+      { taskId },
+      { taskId: { type: 'string', required: true } },
+    );
+
+    const params = { body: { taskId } };
+
+    return await internalRequest(
+      this.sdk,
+      '/taskRouter/tasks/transfer/cancel',
+      'PUT',
+      params,
+    );
+  }
+
   /**
    * Get the voice transcript for a task, keyed by the media-manager
    * bridgeId (not sipCallId) so it works across requeue/transfer.