@unboundcx/sdk 4.13.38 → 4.13.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.13.38",
+  "version": "4.13.40",
   "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

@@ -497,6 +497,49 @@ export class ChatService {
     );
   }
 
+  /**
+   * Send a message on a kind:'text' channel (sms-routing-plan.md §3.3.1).
+   * Plain body only — no ProseMirror `message`, no threads/cards. The API
+   * intercepts this route for text channels and sends the plain-text body
+   * as a real SMS/MMS via the same pipeline as sdk.messaging.sms.send
+   * (unless `internal` is set, which stays a regular chat message).
+   * @param {string} channelId
+   * @param {Object} params
+   * @param {string} [params.text] - Plain message text
+   * @param {string[]} [params.storageIds] - Image attachment storage ids
+   * @param {boolean} [params.internal] - Internal note; never sent as SMS
+   * @param {boolean} [params.force] - Force-send past a busy-conversation
+   *   (409 TEXT_CONVERSATION_BUSY) collision
+   * @returns {Promise<Object>} Created message
+   */
+  async sendTextMessage(channelId, { text, storageIds, internal, force } = {}) {
+    this.sdk.validateParams(
+      { channelId, text, storageIds, internal, force },
+      {
+        channelId: { type: "string", required: true },
+        text: { type: "string", required: false },
+        storageIds: { type: "array", required: false },
+        internal: { type: "boolean", required: false },
+        force: { type: "boolean", required: false },
+      },
+    );
+
+    const body = {};
+    if (text !== undefined) body.text = text;
+    if (storageIds !== undefined) body.storageIds = storageIds;
+    if (internal !== undefined) body.internal = internal;
+    if (force !== undefined) body.force = force;
+
+    return internalRequest(
+      this.sdk,
+      `/chat/channels/${channelId}/messages`,
+      "POST",
+      {
+        body,
+      },
+    );
+  }
+
   /**
    * Edit a message body (ProseMirror JSON).
    * @param {string} id
@@ -844,7 +887,11 @@ export class ChatService {
    *   reason"; channel must be a non-archived public/private channel.
    * @returns {Promise<Object>} `{allowReports, reportReasons, reportNotifications}`
    */
-  async adminPutSettings({ allowReports, reportReasons, reportNotifications } = {}) {
+  async adminPutSettings({
+    allowReports,
+    reportReasons,
+    reportNotifications,
+  } = {}) {
     this.sdk.validateParams(
       { allowReports, reportReasons, reportNotifications },
       {
@@ -1145,7 +1192,10 @@ export class ChatService {
    * @param {'open'|'in_review'} [params.status]
    * @returns {Promise<Object>}
    */
-  async adminUpdateCase(id, { title, category, description, ownerId, status } = {}) {
+  async adminUpdateCase(
+    id,
+    { title, category, description, ownerId, status } = {},
+  ) {
     this.sdk.validateParams(
       { id, title, category, description, ownerId, status },
       {

package/services/messaging/SmsService.js

@@ -21,6 +21,8 @@ export class SmsService {
    *   to attach this message to, so it surfaces on that record's feed
    * @param {string} [params.engagementSessionId] - Engagement to attach this message to
    * @param {string} [params.taskId] - Task the message was sent under (multi-channel-per-task attribution)
+   * @param {boolean} [params.force] - Force-send past a busy-conversation
+   *   (409 TEXT_CONVERSATION_BUSY) collision
    * @returns {Promise<Object>} Message details
    */
   async send({
@@ -34,6 +36,7 @@ export class SmsService {
     relatedId,
     engagementSessionId,
     taskId,
+    force,
   }) {
     const messageData = {};
     if (from) messageData.from = from;
@@ -45,6 +48,7 @@ export class SmsService {
     if (relatedId) messageData.relatedId = relatedId;
     if (engagementSessionId) messageData.engagementSessionId = engagementSessionId;
     if (taskId) messageData.taskId = taskId;
+    if (force !== undefined) messageData.force = force;
 
     this.sdk.validateParams(
       { to, ...messageData },
@@ -59,6 +63,7 @@ export class SmsService {
         relatedId: { type: 'string', required: false },
         engagementSessionId: { type: 'string', required: false },
         taskId: { type: 'string', required: false },
+        force: { type: 'boolean', required: false },
       },
     );
 
@@ -108,4 +113,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/text.js

@@ -46,6 +46,57 @@ export class TextConversationsService {
       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 {