@unboundcx/sdk 2.7.6 → 2.8.0

package/base.js

@@ -30,7 +30,7 @@ export class BaseSDK {
       this.token = token;
       this.fwRequestId = fwRequestId;
     }
-
+    this.baseURL;
     this.transports = new Map();
     this.debugMode = false;
     this._initializeEnvironment();
@@ -101,7 +101,7 @@ export class BaseSDK {
   removeTransport(name) {
     this.transports.delete(name);
   }
-  
+
   _getJsonSafely(str, defaultValue) {
     try {
       return JSON.parse(str);
@@ -167,20 +167,21 @@ export class BaseSDK {
   }
 
   async _fetch(endpoint, method, params = {}, forceFetch = false) {
-    const { body, query, headers = {} } = params;
+    const { body, query, headers = {}, returnRawResponse = false } = params;
 
     this.validateParams(
-      { endpoint, method, body, query, headers },
+      { endpoint, method, body, query, headers, returnRawResponse },
       {
         endpoint: { type: 'string', required: true },
         method: { type: 'string', required: true },
         body: { type: 'object', required: false },
         query: { type: 'object', required: false },
         headers: { type: 'object', required: false },
+        returnRawResponse: { type: 'boolean', required: false },
       },
     );
 
-        // Add auth headers
+    // Add auth headers
     if (this.token) {
       headers.Authorization = `Bearer ${this.token}`;
     }
@@ -205,68 +206,75 @@ export class BaseSDK {
           fwRequestId: this.fwRequestId,
           baseURL: this.baseURL || this.fullUrl,
         });
-        
-        
       } catch (err) {
         // IMPORTANT: This catch block should ONLY handle transport-level failures
         // (e.g., WebSocket disconnected, plugin unavailable, network errors)
-        // 
+        //
         // Transport plugins should:
         // - RETURN API error responses normally (400, 500, etc.) as response objects
         // - ONLY THROW for transport mechanism failures
-        
+
         console.warn(
           `Transport ${transport.name} mechanism failed, falling back to HTTP:`,
           err.message,
         );
 
         // Built-in HTTP transport (fallback)
-        return this._httpRequest(endpoint, method, params);
+        return this._httpRequest(endpoint, method, params, returnRawResponse);
       }
     } else {
       // No transport available, fallback to HTTP
-      return this._httpRequest(endpoint, method, params);
+      return this._httpRequest(endpoint, method, params, returnRawResponse);
     }
 
-    return this._processResponse(response, transport.name, method, endpoint);
+    // For streaming requests, return the raw response from transports
+    if (returnRawResponse) {
+      return response;
+    }
 
+    return this._processResponse(response, transport.name, method, endpoint);
   }
 
   _isMultipartBody(body) {
     // Check if body is FormData or multipart content
     if (!body) return false;
-    
+
     // Browser FormData
     if (typeof FormData !== 'undefined' && body instanceof FormData) {
       return true;
     }
-    
+
     // Node.js Buffer (our manual multipart construction)
     if (typeof Buffer !== 'undefined' && Buffer.isBuffer(body)) {
       return true;
     }
-    
+
     // Uint8Array (fallback multipart construction)
     if (body instanceof Uint8Array) {
       return true;
     }
-    
+
     // String-based multipart (check for multipart boundaries)
-    if (typeof body === 'string' && body.includes('Content-Disposition: form-data')) {
+    if (
+      typeof body === 'string' &&
+      body.includes('Content-Disposition: form-data')
+    ) {
       return true;
     }
-    
+
     return false;
   }
 
-  async _httpRequest(endpoint, method, params = {}) {
+  async _httpRequest(endpoint, method, params = {}, returnRawResponse = false) {
     const { body, query, headers = {} } = params;
 
     const options = {
       method,
       headers: {
         // Smart content-type detection based on actual body content
-        ...(this._isMultipartBody(body) || headers?.['Content-Type'] || headers?.['content-type']
+        ...(this._isMultipartBody(body) ||
+        headers?.['Content-Type'] ||
+        headers?.['content-type']
           ? {}
           : { 'Content-Type': 'application/json' }),
         ...headers,
@@ -300,7 +308,10 @@ export class BaseSDK {
         body &&
         (body.constructor.name === 'FormData' ||
           typeof body.getBoundary === 'function');
-      const isBuffer = (typeof Buffer !== 'undefined') && Buffer.isBuffer && Buffer.isBuffer(body);
+      const isBuffer =
+        typeof Buffer !== 'undefined' &&
+        Buffer.isBuffer &&
+        Buffer.isBuffer(body);
 
       if (isFormData || isBuffer) {
         options.body = body;
@@ -310,9 +321,13 @@ export class BaseSDK {
     }
 
     const response = await fetch(url, options);
-    
+
+    // For streaming requests, return the raw fetch response
+    if (returnRawResponse) {
+      return response;
+    }
+
     return this._processResponse(response, 'https', method, endpoint);
-    
   }
 
   async _processResponse(response, transport, method, endpoint) {
@@ -322,18 +337,24 @@ export class BaseSDK {
     const responseHeaders = response.headers;
     const responseRequestId =
       responseHeaders?.get?.('x-request-id') ||
-      responseHeaders?.['x-request-id'] || '';
+      responseHeaders?.['x-request-id'] ||
+      '';
 
-    const contentType = responseHeaders?.get?.('content-type') || response.headers['content-type'];
+    const contentType =
+      responseHeaders?.get?.('content-type') ||
+      response?.headers?.['content-type'] ||
+      'application/json';
 
     if (!response.ok) {
       let errorBody;
       if (response?.body) {
-          errorBody = response.body;
+        errorBody = response.body;
       } else if (response?.headers?.['content-type']) {
-        
         try {
-          if (typeof  response?.json === 'function' || typeof response?.text === 'function') {
+          if (
+            typeof response?.json === 'function' ||
+            typeof response?.text === 'function'
+          ) {
             if (contentType.includes('application/json')) {
               errorBody = await response.json();
             } else if (contentType.includes('text/')) {
@@ -341,7 +362,10 @@ export class BaseSDK {
             }
           } else {
             if (contentType.includes('application/json')) {
-              errorBody = this._getJsonSafely(response?.body, response?.body || {});
+              errorBody = this._getJsonSafely(
+                response?.body,
+                response?.body || {},
+              );
             } else if (contentType.includes('text/')) {
               errorBody = response?.body || '';
             }
@@ -355,29 +379,37 @@ export class BaseSDK {
       } else {
         errorBody = `HTTP ${response.status} ${response.statusText}`;
       }
-      
+
       // Create a structured error for API/HTTP failures
-      const httpError = new Error(`API :: Error :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${response.status} :: ${response.statusText}`);
+      const httpError = new Error(
+        `API :: Error :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${
+          response.status
+        } :: ${response.statusText}`,
+      );
       httpError.status = response.status;
       httpError.statusText = response.statusText;
       httpError.method = method;
       httpError.endpoint = endpoint;
       httpError.body = errorBody;
       httpError.message = errorBody?.error || errorBody?.message || 'API Error';
-      
-          // Debug logging for successful HTTP requests
-    if (this.debugMode) {
-      console.log(`API :: ERROR :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status} :: ${responseRequestId}`, httpError);
-    }
+
+      // Debug logging for successful HTTP requests
+      if (this.debugMode) {
+        console.log(
+          `API :: ERROR :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${
+            response?.status
+          } :: ${responseRequestId}`,
+          httpError,
+        );
+      }
 
       throw httpError;
     }
 
     let responseBody;
     if (response?.body && !contentType) {
-        responseBody = response.body;
+      responseBody = response.body;
     } else if (contentType) {
-      
       try {
         if (transport === 'https') {
           if (contentType.includes('application/json')) {
@@ -403,15 +435,16 @@ export class BaseSDK {
     } else {
       responseBody = {};
     }
-  
-
-
 
     // Debug logging for successful HTTP requests
     if (this.debugMode) {
-      console.log(`API :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${response?.status} :: ${responseRequestId}`);
+      console.log(
+        `API :: ${transport} :: ${method.toUpperCase()} :: ${endpoint} :: ${
+          response?.status
+        } :: ${responseRequestId}`,
+      );
     }
-    
+
     return responseBody;
   }
 }

package/index.js

@@ -4,7 +4,7 @@
 import { BaseSDK } from './base.js';
 import { LoginService } from './services/login.js';
 import { ObjectsService } from './services/objects.js';
-import { MessagingService } from './services/messaging.js';
+import { MessagingService } from './services/messaging/MessagingService.js';
 import { VideoService } from './services/video.js';
 import { VoiceService } from './services/voice.js';
 import { AIService } from './services/ai.js';
@@ -23,6 +23,7 @@ import { EnrollService } from './services/enroll.js';
 import { PhoneNumbersService } from './services/phoneNumbers.js';
 import { RecordTypesService } from './services/recordTypes.js';
 import { GenerateIdService } from './services/generateId.js';
+import { EngagementMetricsService } from './services/engagementMetrics.js';
 
 class UnboundSDK extends BaseSDK {
   constructor(options = {}) {
@@ -87,6 +88,7 @@ class UnboundSDK extends BaseSDK {
     this.phoneNumbers = new PhoneNumbersService(this);
     this.recordTypes = new RecordTypesService(this);
     this.generateId = new GenerateIdService(this);
+    this.engagementMetrics = new EngagementMetricsService(this);
 
     // Add additional services that might be missing
     this._initializeAdditionalServices();
@@ -190,4 +192,5 @@ export {
   UserRecordTypeDefaultsService,
 } from './services/recordTypes.js';
 export { GenerateIdService } from './services/generateId.js';
+export { EngagementMetricsService } from './services/engagementMetrics.js';
 export { BaseSDK } from './base.js';

package/package.json

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

@@ -22,11 +22,10 @@ export class GenerativeService {
     method,
   }) {
     this.sdk.validateParams(
-      { method },
+      { method, stream, temperature, subscriptionId, model, prompt, messages },
       {
         prompt: { type: 'string', required: false },
         messages: { type: 'array', required: false },
-        relatedId: { type: 'string', required: false },
         model: { type: 'string', required: false },
         temperature: { type: 'number', required: false },
         subscriptionId: { type: 'string', required: false },
@@ -46,9 +45,18 @@ export class GenerativeService {
         stream,
         method,
       },
+      // Return raw response for streaming to allow client-side stream handling
+      returnRawResponse: stream === true,
     };
 
-    const result = await this.sdk._fetch('/ai/generative/chat', 'POST', params);
+    // Force HTTP transport when streaming is enabled since NATS doesn't support streaming responses
+    const forceFetch = stream === true;
+    const result = await this.sdk._fetch(
+      '/ai/generative/chat',
+      'POST',
+      params,
+      forceFetch,
+    );
     return result;
   }
 
@@ -135,12 +143,17 @@ export class GenerativeService {
         stream,
         method,
       },
+      // Return raw response for streaming to allow client-side stream handling
+      returnRawResponse: stream === true,
     };
 
+    // Force HTTP transport when streaming is enabled since NATS doesn't support streaming responses
+    const forceFetch = stream === true;
     const result = await this.sdk._fetch(
       '/ai/generative/ollama',
       'POST',
       params,
+      forceFetch,
     );
     return result;
   }

package/services/engagementMetrics.js

@@ -0,0 +1,153 @@
+export class EngagementMetricsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Get engagement metrics with flexible filtering and configurable response options
+   * @param {Object} options - Query options
+   * @param {string[]} [options.queueIds] - Array of queue IDs to filter by
+   * @param {string[]} [options.statuses] - Array of statuses to filter by (new, working, wrapUp, completed)
+   * @param {string[]} [options.userIds] - Array of user IDs to filter by
+   * @param {boolean} [options.includeSummary=true] - Include overall summary metrics
+   * @param {boolean} [options.includeByQueue=true] - Include metrics grouped by queue and status
+   * @param {boolean} [options.includeQueuePerformance=false] - Include queue performance metrics
+   * @param {boolean} [options.includeAgentPerformance=false] - Include agent performance metrics
+   * @returns {Promise<Object>} Metrics data
+   */
+  async getMetrics({
+    queueIds = [],
+    statuses = [],
+    userIds = [],
+    includeSummary = true,
+    includeByQueue = true,
+    includeQueuePerformance = false,
+    includeAgentPerformance = false,
+  } = {}) {
+    this.sdk.validateParams(
+      {
+        queueIds,
+        statuses,
+        userIds,
+        includeSummary,
+        includeByQueue,
+        includeQueuePerformance,
+        includeAgentPerformance,
+      },
+      {
+        queueIds: { type: 'array', required: false },
+        statuses: { type: 'array', required: false },
+        userIds: { type: 'array', required: false },
+        includeSummary: { type: 'boolean', required: false },
+        includeByQueue: { type: 'boolean', required: false },
+        includeQueuePerformance: { type: 'boolean', required: false },
+        includeAgentPerformance: { type: 'boolean', required: false },
+      },
+    );
+
+    const params = {
+      query: {
+        queueIds: Array.isArray(queueIds) ? queueIds.join(',') : queueIds,
+        statuses: Array.isArray(statuses) ? statuses.join(',') : statuses,
+        userIds: Array.isArray(userIds) ? userIds.join(',') : userIds,
+        includeSummary,
+        includeByQueue,
+        includeQueuePerformance,
+        includeAgentPerformance,
+      },
+    };
+
+    const result = await this.sdk._fetch('/engagementMetrics/', 'GET', params);
+    return result;
+  }
+
+  /**
+   * Get basic engagement metrics summary
+   * @param {Object} options - Filter options
+   * @param {string[]} [options.queueIds] - Array of queue IDs to filter by
+   * @param {string[]} [options.statuses] - Array of statuses to filter by
+   * @returns {Promise<Object>} Summary metrics
+   */
+  async getSummary({ queueIds = [], statuses = [] } = {}) {
+    return this.getMetrics({
+      queueIds,
+      statuses,
+      includeSummary: true,
+      includeByQueue: false,
+      includeQueuePerformance: false,
+      includeAgentPerformance: false,
+    });
+  }
+
+  /**
+   * Get metrics grouped by queue and status
+   * @param {Object} options - Filter options
+   * @param {string[]} [options.queueIds] - Array of queue IDs to filter by
+   * @param {string[]} [options.statuses] - Array of statuses to filter by
+   * @returns {Promise<Object>} Queue-grouped metrics
+   */
+  async getByQueue({ queueIds = [], statuses = [] } = {}) {
+    return this.getMetrics({
+      queueIds,
+      statuses,
+      includeSummary: false,
+      includeByQueue: true,
+      includeQueuePerformance: false,
+      includeAgentPerformance: false,
+    });
+  }
+
+  /**
+   * Get queue performance metrics
+   * @param {Object} options - Filter options
+   * @param {string[]} [options.queueIds] - Array of queue IDs to filter by
+   * @returns {Promise<Object>} Queue performance metrics
+   */
+  async getQueuePerformance({ queueIds = [] } = {}) {
+    return this.getMetrics({
+      queueIds,
+      includeSummary: false,
+      includeByQueue: false,
+      includeQueuePerformance: true,
+      includeAgentPerformance: false,
+    });
+  }
+
+  /**
+   * Get agent performance metrics
+   * @param {Object} options - Filter options
+   * @param {string[]} [options.queueIds] - Array of queue IDs to filter by
+   * @param {string[]} [options.userIds] - Array of user IDs to filter by
+   * @returns {Promise<Object>} Agent performance metrics
+   */
+  async getAgentPerformance({ queueIds = [], userIds = [] } = {}) {
+    return this.getMetrics({
+      queueIds,
+      userIds,
+      includeSummary: false,
+      includeByQueue: false,
+      includeQueuePerformance: false,
+      includeAgentPerformance: true,
+    });
+  }
+
+  /**
+   * Get comprehensive metrics for dashboard
+   * @param {Object} options - Filter options
+   * @param {string[]} [options.queueIds] - Array of queue IDs to filter by
+   * @param {string[]} [options.statuses] - Array of statuses to filter by
+   * @param {string[]} [options.userIds] - Array of user IDs to filter by
+   * @returns {Promise<Object>} All metrics
+   */
+  async getDashboardMetrics({ queueIds = [], statuses = [], userIds = [] } = {}) {
+    return this.getMetrics({
+      queueIds,
+      statuses,
+      userIds,
+      includeSummary: true,
+      includeByQueue: true,
+      includeQueuePerformance: true,
+      includeAgentPerformance: true,
+    });
+  }
+}

package/services/messaging/CampaignsService.js

@@ -0,0 +1,10 @@
+import { TollFreeCampaignsService } from './TollFreeCampaignsService.js';
+import { TenDlcCampaignsService } from './TenDlcCampaignsService.js';
+
+export class CampaignsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.tollFree = new TollFreeCampaignsService(sdk);
+    this.tenDlc = new TenDlcCampaignsService(sdk);
+  }
+}

package/services/messaging/EmailAddressesService.js

@@ -0,0 +1,89 @@
+export class EmailAddressesService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Create email address verification
+   * @param {string} emailAddress - Email address to verify (required)
+   * @returns {Promise<Object>} Email verification details
+   */
+  async create(emailAddress) {
+    this.sdk.validateParams(
+      { emailAddress },
+      {
+        emailAddress: { type: 'string', required: true },
+      },
+    );
+
+    const options = {
+      body: { emailAddress },
+    };
+
+    const result = await this.sdk._fetch(
+      '/messaging/email/validate/emailAddress',
+      'POST',
+      options,
+    );
+    return result;
+  }
+
+  /**
+   * Delete email address verification
+   * @param {string} emailAddress - Email address to remove (required)
+   * @returns {Promise<Object>} Deletion confirmation
+   */
+  async delete(emailAddress) {
+    this.sdk.validateParams(
+      { emailAddress },
+      {
+        emailAddress: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/messaging/email/validate/emailAddress/${encodeURIComponent(
+        emailAddress,
+      )}`,
+      'DELETE',
+    );
+    return result;
+  }
+
+  /**
+   * List all verified email addresses
+   * @returns {Promise<Array>} List of verified email addresses
+   */
+  async list() {
+    const result = await this.sdk._fetch(
+      '/messaging/email/validate/emailAddress',
+      'GET',
+    );
+    return result;
+  }
+
+  /**
+   * Check email address verification status
+   * @param {string} emailAddress - Email address to check (required)
+   * @returns {Promise<Object>} Email verification status
+   */
+  async checkStatus(emailAddress) {
+    this.sdk.validateParams(
+      { emailAddress },
+      {
+        emailAddress: { type: 'string', required: true },
+      },
+    );
+
+    const options = {
+      query: { emailAddress },
+    };
+
+    const result = await this.sdk._fetch(
+      '/messaging/email/validate/emailAddress/status',
+      'GET',
+      options,
+    );
+    return result;
+  }
+}