@unboundcx/sdk 4.13.37 → 4.13.39

package/index.js

@@ -43,6 +43,7 @@ import { SearchService } from './services/search.js';
 import { DirectoryService } from './services/directory.js';
 import { ChatService } from './services/chat.js';
 import { DeveloperApisService } from './services/developerApis.js';
+import { TextService } from './services/text.js';
 import {
   DataImportService,
   DataExportService,
@@ -120,6 +121,7 @@ class UnboundSDK extends BaseSDK {
     this.generateId = new GenerateIdService(this);
     this.engagementMetrics = new EngagementMetricsService(this);
     this.taskRouter = new TaskRouterService(this);
+    this.text = new TextService(this);
     this.knowledgeBase = new KnowledgeBaseService(this);
     this.fax = new FaxService(this);
     this.documents = new DocumentsService(this);

package/package.json

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

@@ -108,4 +108,26 @@ export class SmsService {
     );
     return result;
   }
+
+  /**
+   * Re-send a failed message as a new row, linked back via retryOfId
+   * (sms-routing-plan.md §5.1, contract C2).
+   * @param {string} id - The failed message's id (required)
+   * @returns {Promise<Object>} The new message's { id, status }
+   */
+  async retry(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(
+      this.sdk,
+      `/messaging/sms/${id}/retry`,
+      'POST',
+    );
+    return result;
+  }
 }

package/services/phoneNumbers.js

@@ -112,6 +112,9 @@ export class PhoneNumbersService {
       voiceRecordTypeId,
       messagingRecordTypeId,
       recordCalls,
+      textApp,
+      textAppMetaData,
+      textChatVisibility,
     },
   ) {
     this.sdk.validateParams(
@@ -125,6 +128,9 @@ export class PhoneNumbersService {
         voiceRecordTypeId,
         messagingRecordTypeId,
         recordCalls,
+        textApp,
+        textAppMetaData,
+        textChatVisibility,
       },
       {
         id: { type: 'string', required: true },
@@ -137,6 +143,9 @@ export class PhoneNumbersService {
         voiceRecordTypeId: { type: 'string', required: false },
         messagingRecordTypeId: { type: 'string', required: false },
         recordCalls: { type: 'boolean', required: false },
+        textApp: { type: 'string', required: false },
+        textAppMetaData: { type: 'string', required: false },
+        textChatVisibility: { type: 'string', required: false },
       },
     );
 
@@ -155,6 +164,11 @@ export class PhoneNumbersService {
     if (messagingRecordTypeId)
       updateData.messagingRecordTypeId = messagingRecordTypeId;
     if (recordCalls !== undefined) updateData.recordCalls = recordCalls;
+    if (textApp !== undefined) updateData.textApp = textApp;
+    if (textAppMetaData !== undefined)
+      updateData.textAppMetaData = textAppMetaData;
+    if (textChatVisibility !== undefined)
+      updateData.textChatVisibility = textChatVisibility;
 
     const params = {
       body: updateData,

package/services/taskRouter/TaskService.js

@@ -845,6 +845,67 @@ export class TaskService {
     return result;
   }
 
+  /**
+   * Park a task ("waiting for customer"). Clears the worker (freeing
+   * capacity) and stamps preferredWorkerId with the parking worker so
+   * unpark can offer the task back to them first.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.taskId - The task ID to park (required)
+   * @returns {Promise<Object>} { taskId, status: 'parked' }
+   */
+  async park(options = {}) {
+    const { taskId } = options;
+
+    this.sdk.validateParams(
+      { taskId },
+      { taskId: { type: 'string', required: true } },
+    );
+
+    const params = { body: { taskId } };
+
+    return await internalRequest(
+      this.sdk,
+      '/taskRouter/tasks/park',
+      'PUT',
+      params,
+    );
+  }
+
+  /**
+   * Transfer a task to a different queue and/or worker. Passing queueId
+   * moves the task back to 'pending' status for re-distribution.
+   *
+   * @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 }
+   */
+  async transfer(options = {}) {
+    const { taskId, queueId, workerId } = options;
+
+    this.sdk.validateParams(
+      { taskId, queueId, workerId },
+      {
+        taskId: { type: 'string', required: true },
+        queueId: { type: 'string', required: false },
+        workerId: { type: 'string', required: false },
+      },
+    );
+
+    const params = { body: { taskId } };
+    if (queueId !== undefined) params.body.queueId = queueId;
+    if (workerId !== undefined) params.body.workerId = workerId;
+
+    return await internalRequest(
+      this.sdk,
+      '/taskRouter/tasks/transfer',
+      'PUT',
+      params,
+    );
+  }
+
   /**
    * Get the voice transcript for a task, keyed by the media-manager
    * bridgeId (not sipCallId) so it works across requeue/transfer.

package/services/text.js

@@ -0,0 +1,107 @@
+import { internalRequest } from '../base.js';
+
+// Text routing (sms-routing-plan.md §2/§3.2/§3.4): read-only lookups for the
+// durable textConversations row. Mutations (send, park, transfer) go through
+// sdk.messaging.sms / sdk.taskRouter.task — this service is for resolving
+// "what conversation is this" from the client/CC UI.
+export class TextConversationsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Get a single text conversation by id.
+   * @param {string} id - textConversations id (required)
+   * @returns {Promise<Object>}
+   */
+  async get(id) {
+    this.sdk.validateParams(
+      { id },
+      { id: { type: 'string', required: true } },
+    );
+
+    return internalRequest(this.sdk, `/text/conversations/${id}`, 'GET');
+  }
+
+  /**
+   * Resolve the currently-open conversation for an (identity, counterparty)
+   * pair, if any.
+   * @param {Object} options - Parameters
+   * @param {string} options.phoneNumberId - our-side identity id (required)
+   * @param {string} options.counterparty - external address (required)
+   * @returns {Promise<Object|null>} the open conversation row, or null
+   */
+  async resolve(options = {}) {
+    const { phoneNumberId, counterparty } = options;
+
+    this.sdk.validateParams(
+      { phoneNumberId, counterparty },
+      {
+        phoneNumberId: { type: 'string', required: true },
+        counterparty: { type: 'string', required: true },
+      },
+    );
+
+    return internalRequest(this.sdk, '/text/conversations/resolve', 'GET', {
+      query: { phoneNumberId, counterparty },
+    });
+  }
+
+  /**
+   * Join a UC-Chat-owned conversation's text channel (sms-routing-plan.md
+   * §3.3, contract C5) -- private channels aren't joinable via
+   * sdk.chat.channels.join (public-only); public-visibility text channels
+   * still require `messaging:sms:send`, which this route enforces.
+   * @param {string} id - textConversations id (required)
+   * @returns {Promise<Object>} { channel, membership }
+   */
+  async join(id) {
+    this.sdk.validateParams(
+      { id },
+      { id: { type: 'string', required: true } },
+    );
+
+    return internalRequest(this.sdk, `/text/conversations/${id}/join`, 'POST');
+  }
+
+  /**
+   * Escalate a UC-Chat-owned ('user') conversation to a queue or a
+   * workflow (sms-routing-plan.md §3.3/§3.4 "Send to queue" / "Send to
+   * workflow"). Pass exactly one of queueId or workflowId/workflowVersionId.
+   * @param {string} id - textConversations id (required)
+   * @param {Object} options - Parameters
+   * @param {string} [options.queueId] - Escalate to a queue (new task)
+   * @param {string} [options.workflowId] - Escalate to a workflow's current version
+   * @param {string} [options.workflowVersionId] - Escalate to a pinned workflow version
+   * @returns {Promise<Object>} The updated conversation row
+   */
+  async escalate(id, options = {}) {
+    const { queueId, workflowId, workflowVersionId } = options;
+
+    this.sdk.validateParams(
+      { id, queueId, workflowId, workflowVersionId },
+      {
+        id: { type: 'string', required: true },
+        queueId: { type: 'string', required: false },
+        workflowId: { type: 'string', required: false },
+        workflowVersionId: { type: 'string', required: false },
+      },
+    );
+    if (!queueId && !workflowId && !workflowVersionId) {
+      throw new Error(
+        'escalate requires queueId or workflowId/workflowVersionId',
+      );
+    }
+
+    return internalRequest(this.sdk, `/text/conversations/${id}/escalate`, 'POST', {
+      body: { queueId, workflowId, workflowVersionId },
+    });
+  }
+}
+
+export class TextService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.conversations = new TextConversationsService(sdk);
+  }
+}