@unboundcx/sdk 4.13.36 → 4.13.38

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.36",
+  "version": "4.13.38",
   "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/ai/assist.js

@@ -0,0 +1,65 @@
+import { internalRequest } from '../../base.js';
+
+/**
+ * Assist Service - Live AI Assist evaluation for a task
+ */
+export class AssistService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Evaluate utterances against assigned battle cards for a task
+   *
+   * @param {Object} options - Evaluate options
+   * @param {string} options.taskId - Task ID
+   * @param {Array} options.utterances - Utterances to evaluate
+   * @returns {Promise<Object>} Evaluation result
+   *
+   * @example
+   * const result = await sdk.ai.assist.evaluate({
+   *   taskId: 'task_123',
+   *   utterances: [{ speaker: 'customer', text: 'That is too expensive' }]
+   * });
+   */
+  async evaluate({ taskId, utterances }) {
+    this.sdk.validateParams(
+      { taskId, utterances },
+      {
+        taskId: { type: 'string', required: true },
+        utterances: { type: 'array', required: true },
+      },
+    );
+
+    const params = {
+      body: { taskId, utterances },
+    };
+
+    const result = await internalRequest(this.sdk, '/ai/assist/evaluate', 'POST', params);
+    return result;
+  }
+
+  /**
+   * Get the last AI Assist evaluation for a task
+   *
+   * @param {Object} options - Options
+   * @param {string} options.taskId - Task ID
+   * @returns {Promise<Object>} Last evaluation
+   *
+   * @example
+   * const last = await sdk.ai.assist.getLast({
+   *   taskId: 'task_123'
+   * });
+   */
+  async getLast({ taskId }) {
+    this.sdk.validateParams(
+      { taskId },
+      {
+        taskId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(this.sdk, `/ai/assist/last/${taskId}`, 'GET');
+    return result;
+  }
+}

package/services/ai/battleCards.js

@@ -0,0 +1,415 @@
+import { internalRequest } from '../../base.js';
+
+/**
+ * Battle Cards Service - Manage AI Assist battle card packs, cards, and queue assignments
+ */
+export class BattleCardsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  // ========================================
+  // Pack CRUD Methods
+  // ========================================
+
+  /**
+   * Create a battle card pack
+   *
+   * @param {Object} options - Pack creation options
+   * @param {string} options.name - Name of the pack
+   * @param {string} [options.recordTypeId] - Record type ID
+   * @returns {Promise<Object>} Created pack with id
+   *
+   * @example
+   * const pack = await sdk.ai.battleCards.createPack({
+   *   name: 'Pricing Objection Handling'
+   * });
+   */
+  async createPack({ name, recordTypeId }) {
+    this.sdk.validateParams(
+      { name },
+      {
+        name: { type: 'string', required: true },
+        recordTypeId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: { name, recordTypeId },
+    };
+
+    const result = await internalRequest(this.sdk, '/ai/battleCards/packs', 'POST', params);
+    return result;
+  }
+
+  /**
+   * Get a battle card pack by ID
+   *
+   * @param {Object} options - Options
+   * @param {string} options.packId - The ID of the pack
+   * @returns {Promise<Object>} Pack object
+   *
+   * @example
+   * const pack = await sdk.ai.battleCards.getPack({
+   *   packId: '251abc'
+   * });
+   */
+  async getPack({ packId }) {
+    this.sdk.validateParams(
+      { packId },
+      {
+        packId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(this.sdk, `/ai/battleCards/packs/${packId}`, 'GET');
+    return result;
+  }
+
+  /**
+   * List battle card packs
+   *
+   * @param {Object} [options={}] - Query options
+   * @param {number} [options.limit] - Maximum number of results
+   * @param {string} [options.orderBy] - Field to order by
+   * @param {string} [options.orderDirection] - Order direction
+   * @returns {Promise<Object>} Object with results array
+   *
+   * @example
+   * const packs = await sdk.ai.battleCards.listPacks({
+   *   limit: 50,
+   *   orderBy: 'createdAt',
+   *   orderDirection: 'DESC'
+   * });
+   */
+  async listPacks({
+    limit,
+    orderBy,
+    orderDirection,
+  } = {}) {
+    const params = {
+      query: { limit, orderBy, orderDirection },
+    };
+
+    const result = await internalRequest(this.sdk, '/ai/battleCards/packs', 'GET', params);
+    return result;
+  }
+
+  /**
+   * Update a battle card pack
+   *
+   * @param {Object} options - Update options
+   * @param {string} options.packId - The ID of the pack
+   * @param {string} [options.name] - New name
+   * @param {string} [options.recordTypeId] - Record type ID
+   * @returns {Promise<Object>} Updated pack object
+   *
+   * @example
+   * const updated = await sdk.ai.battleCards.updatePack({
+   *   packId: '251abc',
+   *   name: 'Updated Pricing Pack'
+   * });
+   */
+  async updatePack({ packId, name, recordTypeId }) {
+    this.sdk.validateParams(
+      { packId },
+      {
+        packId: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+        recordTypeId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: { name, recordTypeId },
+    };
+
+    const result = await internalRequest(this.sdk, 
+      `/ai/battleCards/packs/${packId}`,
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Delete a battle card pack
+   *
+   * @param {Object} options - Delete options
+   * @param {string} options.packId - The ID of the pack
+   * @returns {Promise<Object>} Success response
+   *
+   * @example
+   * await sdk.ai.battleCards.deletePack({
+   *   packId: '251abc'
+   * });
+   */
+  async deletePack({ packId }) {
+    this.sdk.validateParams(
+      { packId },
+      {
+        packId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(this.sdk, 
+      `/ai/battleCards/packs/${packId}`,
+      'DELETE',
+    );
+    return result;
+  }
+
+  // ========================================
+  // Card CRUD Methods
+  // ========================================
+
+  /**
+   * Create a battle card in a pack
+   *
+   * @param {Object} options - Card creation options
+   * @param {string} options.packId - The ID of the pack
+   * @param {string} options.title - Card title
+   * @param {string} [options.body] - Card body
+   * @param {string} [options.reply] - Suggested reply
+   * @param {string} [options.dontSay] - Phrases to avoid
+   * @param {Array} [options.triggers] - Trigger phrases
+   * @param {number} [options.order] - Display order
+   * @param {string} [options.recordTypeId] - Record type ID
+   * @returns {Promise<Object>} Created card with id
+   *
+   * @example
+   * const card = await sdk.ai.battleCards.createCard({
+   *   packId: '251abc',
+   *   title: 'Too expensive',
+   *   body: 'Acknowledge the concern, then reframe value.',
+   *   reply: 'I hear you — let me walk through what that includes.',
+   *   triggers: ['too expensive', 'price']
+   * });
+   */
+  async createCard({
+    packId,
+    title,
+    body,
+    reply,
+    dontSay,
+    triggers,
+    order,
+    recordTypeId,
+  }) {
+    this.sdk.validateParams(
+      { packId, title },
+      {
+        packId: { type: 'string', required: true },
+        title: { type: 'string', required: true },
+        body: { type: 'string', required: false },
+        reply: { type: 'string', required: false },
+        dontSay: { type: 'string', required: false },
+        triggers: { type: 'array', required: false },
+        order: { type: 'number', required: false },
+        recordTypeId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: { title, body, reply, dontSay, triggers, order, recordTypeId },
+    };
+
+    const result = await internalRequest(this.sdk, 
+      `/ai/battleCards/packs/${packId}/cards`,
+      'POST',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Get a battle card by ID
+   *
+   * @param {Object} options - Options
+   * @param {string} options.cardId - The ID of the card
+   * @returns {Promise<Object>} Card object
+   *
+   * @example
+   * const card = await sdk.ai.battleCards.getCard({
+   *   cardId: '252abc'
+   * });
+   */
+  async getCard({ cardId }) {
+    this.sdk.validateParams(
+      { cardId },
+      {
+        cardId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(this.sdk, `/ai/battleCards/cards/${cardId}`, 'GET');
+    return result;
+  }
+
+  /**
+   * List battle cards in a pack
+   *
+   * @param {Object} options - Options
+   * @param {string} options.packId - The ID of the pack
+   * @returns {Promise<Object>} Object with results array
+   *
+   * @example
+   * const cards = await sdk.ai.battleCards.listCards({
+   *   packId: '251abc'
+   * });
+   */
+  async listCards({ packId }) {
+    this.sdk.validateParams(
+      { packId },
+      {
+        packId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(this.sdk, `/ai/battleCards/packs/${packId}/cards`, 'GET');
+    return result;
+  }
+
+  /**
+   * Update a battle card
+   *
+   * @param {Object} options - Update options
+   * @param {string} options.cardId - The ID of the card
+   * @param {string} [options.title] - Card title
+   * @param {string} [options.body] - Card body
+   * @param {string} [options.reply] - Suggested reply
+   * @param {string} [options.dontSay] - Phrases to avoid
+   * @param {Array} [options.triggers] - Trigger phrases
+   * @param {number} [options.order] - Display order
+   * @returns {Promise<Object>} Updated card object
+   *
+   * @example
+   * const updated = await sdk.ai.battleCards.updateCard({
+   *   cardId: '252abc',
+   *   title: 'Budget concern'
+   * });
+   */
+  async updateCard({
+    cardId,
+    title,
+    body,
+    reply,
+    dontSay,
+    triggers,
+    order,
+  }) {
+    this.sdk.validateParams(
+      { cardId },
+      {
+        cardId: { type: 'string', required: true },
+        title: { type: 'string', required: false },
+        body: { type: 'string', required: false },
+        reply: { type: 'string', required: false },
+        dontSay: { type: 'string', required: false },
+        triggers: { type: 'array', required: false },
+        order: { type: 'number', required: false },
+      },
+    );
+
+    const params = {
+      body: { title, body, reply, dontSay, triggers, order },
+    };
+
+    const result = await internalRequest(this.sdk, 
+      `/ai/battleCards/cards/${cardId}`,
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Delete a battle card
+   *
+   * @param {Object} options - Delete options
+   * @param {string} options.cardId - The ID of the card
+   * @returns {Promise<Object>} Success response
+   *
+   * @example
+   * await sdk.ai.battleCards.deleteCard({
+   *   cardId: '252abc'
+   * });
+   */
+  async deleteCard({ cardId }) {
+    this.sdk.validateParams(
+      { cardId },
+      {
+        cardId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(this.sdk, 
+      `/ai/battleCards/cards/${cardId}`,
+      'DELETE',
+    );
+    return result;
+  }
+
+  // ========================================
+  // Queue Pack Assignment
+  // ========================================
+
+  /**
+   * List battle card packs assigned to a queue
+   *
+   * @param {Object} options - Options
+   * @param {string} options.queueId - The ID of the queue
+   * @returns {Promise<Object>} Assigned packs
+   *
+   * @example
+   * const assigned = await sdk.ai.battleCards.listQueuePacks({
+   *   queueId: 'queue_123'
+   * });
+   */
+  async listQueuePacks({ queueId }) {
+    this.sdk.validateParams(
+      { queueId },
+      {
+        queueId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(this.sdk, `/ai/battleCards/queues/${queueId}`, 'GET');
+    return result;
+  }
+
+  /**
+   * Set battle card packs assigned to a queue
+   *
+   * @param {Object} options - Options
+   * @param {string} options.queueId - The ID of the queue
+   * @param {Array<string>} options.packIds - Pack IDs to assign
+   * @returns {Promise<Object>} Updated assignment
+   *
+   * @example
+   * await sdk.ai.battleCards.setQueuePacks({
+   *   queueId: 'queue_123',
+   *   packIds: ['251abc']
+   * });
+   */
+  async setQueuePacks({ queueId, packIds }) {
+    this.sdk.validateParams(
+      { queueId, packIds },
+      {
+        queueId: { type: 'string', required: true },
+        packIds: { type: 'array', required: true },
+      },
+    );
+
+    const params = {
+      body: { packIds },
+    };
+
+    const result = await internalRequest(this.sdk, 
+      `/ai/battleCards/queues/${queueId}`,
+      'PUT',
+      params,
+    );
+    return result;
+  }
+}

package/services/ai.js

@@ -1,5 +1,7 @@
 import { internalRequest } from '../base.js';
 import { PlaybooksService } from './ai/playbooks.js';
+import { BattleCardsService } from './ai/battleCards.js';
+import { AssistService } from './ai/assist.js';
 import { VocabularyService } from './ai/vocabulary.js';
 import { EmailService } from './ai/email.js';
 import { translate as translateItems } from './ai/translate.js';
@@ -16,6 +18,8 @@ export class AIService {
     this.stt = new SpeechToTextService(sdk);
     this.extract = new ExtractService(sdk);
     this.playbooks = new PlaybooksService(sdk);
+    this.battleCards = new BattleCardsService(sdk);
+    this.assist = new AssistService(sdk);
     this.vocabulary = new VocabularyService(sdk);
     this.email = new EmailService(sdk);
   }

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,56 @@
+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 },
+    });
+  }
+}
+
+export class TextService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.conversations = new TextConversationsService(sdk);
+  }
+}