@unboundcx/sdk 4.13.95 → 4.13.96

package/package.json

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

@@ -80,9 +80,9 @@ export class AssistService {
    * @example
    * const { suggestions } = await sdk.ai.assist.listSuggestions({ queueId: 'queue_123', limit: 50 });
    */
-  async listSuggestions({ queueId, limit } = {}) {
+  async listSuggestions({ queueId, limit, actorKind } = {}) {
     const result = await internalRequest(this.sdk, '/ai/assist/suggestions', 'GET', {
-      query: { queueId, limit },
+      query: { queueId, limit, actorKind },
     });
     return result;
   }
@@ -97,9 +97,9 @@ export class AssistService {
    * @example
    * const stats = await sdk.ai.assist.suggestionStats({ queueId: 'queue_123' });
    */
-  async suggestionStats({ queueId } = {}) {
+  async suggestionStats({ queueId, actorKind } = {}) {
     const result = await internalRequest(this.sdk, '/ai/assist/suggestions/stats', 'GET', {
-      query: { queueId },
+      query: { queueId, actorKind },
     });
     return result;
   }

package/services/ai.js

@@ -964,14 +964,16 @@ export class SpeechToTextService {
    * @param {Object} message - Message data
    * @param {string} message.text - Transcribed text
    * @param {Object} [message.transcriptionJson] - Full transcription metadata
+   * @param {string} [message.transcriptionJson.source] - 'tts' for synthetic bot ingest
    * @param {number} [message.duration] - Duration of this segment in seconds
-   * @param {number} [message.confidence] - Confidence score (0-1)
+   * @param {number} [message.confidence] - Confidence score (0-1). Omit for TTS.
    * @param {string} [message.languageCode] - Language code for this segment
    * @param {string} [message.userId] - User associated with this message
    * @param {string} [message.role] - Speaker role
    * @param {string} [message.sipCallId] - SIP call identifier
    * @param {string} [message.side] - Stream side ('send' or 'recv')
    * @param {string} [message.bridgeId] - bridge id
+   * @param {string} [message.taskId] - Task id (stamped on the transcription session)
    * @param {Object} [message.sentiment] - Sentiment analysis data
    * @param {number} [message.sentiment.score] - Overall sentiment score (-100 to +100)
    * @param {number} [message.sentiment.previousScore] - Previous sentiment score (-100 to +100)
@@ -999,13 +1001,14 @@ export class SpeechToTextService {
       sipCallId,
       side,
       bridgeId,
+      taskId,
       sentiment,
       videoRoomId,
       videoParticipantId,
     },
   ) {
     this.sdk.validateParams(
-      { messageId, sessionId, text, bridgeId },
+      { messageId, sessionId, text, bridgeId, taskId },
       {
         sessionId: { type: 'string', required: true },
         messageId: { type: 'string', required: false },
@@ -1020,6 +1023,7 @@ export class SpeechToTextService {
         sipCallId: { type: 'string', required: false },
         side: { type: 'string', required: false },
         bridgeId: { type: 'string', required: false },
+        taskId: { type: 'string', required: false },
         sentiment: { type: 'object', required: false },
         videoRoomId: { type: 'string', required: false },
         videoParticipantId: { type: 'string', required: false },
@@ -1040,6 +1044,7 @@ export class SpeechToTextService {
         sipCallId,
         side,
         bridgeId,
+        taskId,
         sentiment,
         videoRoomId,
         videoParticipantId,

package/services/reportingAgents.js

@@ -19,19 +19,19 @@ export class ReportingAgentsService {
 
   /**
    * Agent summary rows (§6 metrics), grouped by agent, queue, or team.
-   * @param {Object} params - { from, to, userIds, queueIds, teamIds, groupBy }
+   * @param {Object} params - { from, to, userIds, queueIds, teamIds, groupBy, agentKind }
    * @returns {Promise<Object>} { columns, rows, definitions, meta }
    * @example
    * await sdk.reporting.agents.summary({ from, to, groupBy: 'team' });
    */
-  async summary({ from, to, userIds, queueIds, teamIds, groupBy } = {}) {
+  async summary({ from, to, userIds, queueIds, teamIds, groupBy, agentKind } = {}) {
     this.sdk.validateParams(
       { from, to },
       { from: { type: 'string', required: true }, to: { type: 'string', required: true } },
     );
     return internalRequest(
       this.sdk,
-      `/reporting/agents/summary${queryString({ from, to, userIds, queueIds, teamIds, groupBy })}`,
+      `/reporting/agents/summary${queryString({ from, to, userIds, queueIds, teamIds, groupBy, agentKind })}`,
       'GET',
     );
   }
@@ -90,19 +90,19 @@ export class ReportingAgentsService {
   /**
    * Per-agent per-local-day timesheet rows (net paid hours), plus one
    * additive-sum row per agent (`agents`) for grouped totals.
-   * @param {Object} params - { from, to, userIds, teamIds }
+   * @param {Object} params - { from, to, userIds, teamIds, agentKind }
    * @returns {Promise<Object>} { columns, rows, agents }
    * @example
    * await sdk.reporting.agents.timesheet({ from, to, userIds: ['u1'] });
    */
-  async timesheet({ from, to, userIds, teamIds } = {}) {
+  async timesheet({ from, to, userIds, teamIds, agentKind } = {}) {
     this.sdk.validateParams(
       { from, to },
       { from: { type: 'string', required: true }, to: { type: 'string', required: true } },
     );
     return internalRequest(
       this.sdk,
-      `/reporting/agents/timesheet${queryString({ from, to, userIds, teamIds })}`,
+      `/reporting/agents/timesheet${queryString({ from, to, userIds, teamIds, agentKind })}`,
       'GET',
     );
   }
@@ -111,7 +111,7 @@ export class ReportingAgentsService {
    * CSV export of any of the four views above. For view: 'timesheet', pass
    * `totals: true` to get one additive-sum row per agent instead of the
    * flat per-agent-per-day rows.
-   * @param {Object} params - { view: 'summary'|'states'|'interactions'|'timesheet', from, to, userId, userIds, queueIds, teamIds, groupBy, totals }
+   * @param {Object} params - { view: 'summary'|'states'|'interactions'|'timesheet', from, to, userId, userIds, queueIds, teamIds, groupBy, agentKind, totals }
    * @returns {Promise<Object>} raw CSV response (transport-dependent)
    * @example
    * await sdk.reporting.agents.export({ view: 'timesheet', from, to });
@@ -126,6 +126,7 @@ export class ReportingAgentsService {
     queueIds,
     teamIds,
     groupBy,
+    agentKind,
     totals,
   } = {}) {
     this.sdk.validateParams(
@@ -141,6 +142,7 @@ export class ReportingAgentsService {
       queueIds,
       teamIds,
       groupBy,
+      agentKind,
       totals: totals ? '1' : undefined,
       format: 'csv',
     });

package/services/taskRouter/CcBotsService.js

@@ -0,0 +1,242 @@
+import { internalRequest } from '../../base.js';
+
+/**
+ * CC worker bots — Setup → Bots (K21). Not Graham /chat/bots.
+ */
+export class CcBotsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Platform defaults for When to get help + model pickers.
+   * @returns {Promise<Object>}
+   */
+  async defaults() {
+    return internalRequest(this.sdk, '/taskRouter/ccBots/defaults', 'GET');
+  }
+
+  /**
+   * List CC worker bots for the account.
+   * @returns {Promise<Object>} { results }
+   */
+  async list() {
+    return internalRequest(this.sdk, '/taskRouter/ccBots', 'GET');
+  }
+
+  /**
+   * Create a named CC worker bot (user + worker, capacity 1).
+   * @param {Object} params
+   * @param {string} params.name
+   * @param {string} params.slug
+   * @param {string} [params.soulMd]
+   * @param {string} [params.provider]
+   * @param {string} [params.model]
+   * @param {string} [params.queueId]
+   * @param {string} [params.mailboxId]
+   * @returns {Promise<Object>}
+   */
+  async create({
+    name,
+    slug,
+    soulMd,
+    provider,
+    model,
+    queueId,
+    mailboxId,
+  } = {}) {
+    this.sdk.validateParams(
+      { name, slug },
+      {
+        name: { type: 'string', required: true },
+        slug: { type: 'string', required: true },
+      },
+    );
+    const body = { name, slug };
+    if (soulMd !== undefined) body.soulMd = soulMd;
+    if (provider !== undefined) body.provider = provider;
+    if (model !== undefined) body.model = model;
+    if (queueId !== undefined) body.queueId = queueId;
+    if (mailboxId !== undefined) body.mailboxId = mailboxId;
+    return internalRequest(this.sdk, '/taskRouter/ccBots', 'POST', { body });
+  }
+
+  /**
+   * Get one CC worker bot.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async get(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return internalRequest(this.sdk, `/taskRouter/ccBots/${id}`, 'GET');
+  }
+
+  /**
+   * Patch name / soul / model / pause kill-switch.
+   * @param {string} id
+   * @param {Object} [params]
+   * @returns {Promise<Object>}
+   */
+  async update(id, params = {}) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    const body = {};
+    for (const key of [
+      'name',
+      'soulMd',
+      'additionalDetails',
+      'provider',
+      'model',
+      'mediaProvider',
+      'mediaModel',
+      'voiceId',
+      'profilePhoto',
+      'paused',
+      'acceptChannels',
+      'useChannels',
+      'groupId',
+      'groupOverrides',
+      'inherit',
+    ]) {
+      if (key in params) body[key] = params[key];
+    }
+    return internalRequest(this.sdk, `/taskRouter/ccBots/${id}`, 'PATCH', {
+      body,
+    });
+  }
+
+  /**
+   * Clone a CC worker bot (new user + worker, copied config).
+   * @param {string} id
+   * @param {Object} [params]
+   * @param {string} [params.name]
+   * @returns {Promise<Object>}
+   */
+  async clone(id, { name } = {}) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    const body = {};
+    if (name !== undefined) body.name = name;
+    return internalRequest(this.sdk, `/taskRouter/ccBots/${id}/clone`, 'POST', {
+      body,
+    });
+  }
+
+  /**
+   * Enable or disable many CC bots.
+   * @param {Object} params
+   * @param {string[]} params.ids
+   * @param {boolean} params.paused
+   * @returns {Promise<Object>}
+   */
+  async bulkPaused({ ids, paused } = {}) {
+    this.sdk.validateParams(
+      { ids, paused },
+      {
+        ids: { type: 'object', required: true },
+        paused: { type: 'boolean', required: true },
+      },
+    );
+    return internalRequest(this.sdk, '/taskRouter/ccBots/bulkPaused', 'POST', {
+      body: { ids, paused },
+    });
+  }
+
+  /**
+   * List bot groups.
+   * @returns {Promise<Object>}
+   */
+  async listGroups() {
+    return internalRequest(this.sdk, '/taskRouter/ccBotGroups', 'GET');
+  }
+
+  /**
+   * Create a bot group.
+   * @param {Object} params
+   * @returns {Promise<Object>}
+   */
+  async createGroup(params = {}) {
+    this.sdk.validateParams(
+      { name: params.name },
+      { name: { type: 'string', required: true } },
+    );
+    return internalRequest(this.sdk, '/taskRouter/ccBotGroups', 'POST', {
+      body: params,
+    });
+  }
+
+  /**
+   * Get one bot group.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async getGroup(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return internalRequest(this.sdk, `/taskRouter/ccBotGroups/${id}`, 'GET');
+  }
+
+  /**
+   * Patch a bot group (propagates inherited fields to member bots).
+   * @param {string} id
+   * @param {Object} [params]
+   * @returns {Promise<Object>}
+   */
+  async updateGroup(id, params = {}) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    const body = {};
+    for (const key of [
+      'name',
+      'soulMd',
+      'provider',
+      'model',
+      'mediaProvider',
+      'mediaModel',
+      'voiceId',
+      'paused',
+      'acceptChannels',
+      'useChannels',
+      'queueIds',
+      'skillIds',
+    ]) {
+      if (key in params) body[key] = params[key];
+    }
+    return internalRequest(this.sdk, `/taskRouter/ccBotGroups/${id}`, 'PATCH', {
+      body,
+    });
+  }
+
+  /**
+   * Soft-delete a bot group and detach members.
+   * @param {string} id
+   * @returns {Promise<Object>}
+   */
+  async deleteGroup(id) {
+    this.sdk.validateParams({ id }, { id: { type: 'string', required: true } });
+    return internalRequest(
+      this.sdk,
+      `/taskRouter/ccBotGroups/${id}`,
+      'DELETE',
+    );
+  }
+
+  /**
+   * Login a CC bot into a queue (queueUsers + worker addQueues).
+   * @param {string} id
+   * @param {Object} params
+   * @param {string} params.queueId
+   * @returns {Promise<Object>}
+   */
+  async addToQueue(id, { queueId } = {}) {
+    this.sdk.validateParams(
+      { id, queueId },
+      {
+        id: { type: 'string', required: true },
+        queueId: { type: 'string', required: true },
+      },
+    );
+    return internalRequest(
+      this.sdk,
+      `/taskRouter/ccBots/${id}/queues`,
+      'POST',
+      { body: { queueId } },
+    );
+  }
+}

package/services/taskRouter/TaskRouterService.js

@@ -4,6 +4,7 @@ import { MetricsService } from './MetricsService.js';
 import { CCService } from './CCService.js';
 import { OfferService } from './OfferService.js';
 import { ParticipantService } from './ParticipantService.js';
+import { CcBotsService } from './CcBotsService.js';
 
 export class TaskRouterService {
   constructor(sdk) {
@@ -14,5 +15,6 @@ export class TaskRouterService {
     this.cc = new CCService(sdk);
     this.offer = new OfferService(sdk);
     this.participants = new ParticipantService(sdk);
+    this.ccBots = new CcBotsService(sdk);
   }
 }

package/services/taskRouter/TaskService.js

@@ -409,6 +409,64 @@ export class TaskService {
     return result;
   }
 
+  /**
+   * Unassign a task back to pending (worker unlinked). Used by CC bot
+   * drain for short-lived connected tasks — not park.
+   *
+   * @param {Object} options
+   * @param {string} options.taskId
+   * @returns {Promise<Object>}
+   */
+  async unassign(options = {}) {
+    const { taskId, userId } = options;
+
+    this.sdk.validateParams(
+      { taskId, userId },
+      {
+        taskId: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = { body: { taskId } };
+    if (userId) params.body.userId = userId;
+
+    return internalRequest(
+      this.sdk,
+      '/taskRouter/tasks/unassign',
+      'PUT',
+      params,
+    );
+  }
+
+  /**
+   * Staff-only internal note on a task (webchat/SMS/voice feed, or
+   * timeline). Never sent to the customer.
+   *
+   * @param {Object} options
+   * @param {string} options.taskId
+   * @param {string} options.message
+   * @returns {Promise<Object>}
+   */
+  async note(options = {}) {
+    const { taskId, message } = options;
+
+    this.sdk.validateParams(
+      { taskId, message },
+      {
+        taskId: { type: 'string', required: true },
+        message: { type: 'string', required: true },
+      },
+    );
+
+    return internalRequest(
+      this.sdk,
+      `/taskRouter/tasks/${taskId}/notes`,
+      'POST',
+      { body: { message } },
+    );
+  }
+
   /**
    * Change task priority
    * Modify the priority of a task to increase or decrease its routing priority.
@@ -730,12 +788,13 @@ export class TaskService {
    * console.log(result.taskId); // "task456"
    */
   async complete(options = {}) {
-    const { taskId } = options;
+    const { taskId, completedReason } = options;
 
     this.sdk.validateParams(
-      { taskId },
+      { taskId, completedReason },
       {
         taskId: { type: 'string', required: true },
+        completedReason: { type: 'string', required: false },
       },
     );
 
@@ -745,6 +804,10 @@ export class TaskService {
       },
     };
 
+    if (completedReason) {
+      params.body.completedReason = completedReason;
+    }
+
     const result = await internalRequest(this.sdk, 
       '/taskRouter/tasks/complete',
       'PUT',

package/services/webchat.js

@@ -281,4 +281,98 @@ export class WebchatService {
     // instance with just `{namespace}` and uses only this namespace.
     this.visitor = new WebchatVisitorService(sdk);
   }
+
+  /**
+   * Send an agent webchat message on a task. The server resolves the
+   * widget + engagement from the task — callers must not UOQL
+   * webchatConversations for widgetId.
+   *
+   * @param {Object} options
+   * @param {string} options.taskId
+   * @param {string} [options.message]
+   * @param {Object} [options.media]
+   * @param {Object|Array} [options.card]
+   * @returns {Promise<Object>}
+   */
+  async sendOnTask(options = {}) {
+    const { taskId, message, media, card } = options;
+
+    this.sdk.validateParams(
+      { taskId, message, media, card },
+      {
+        taskId: { type: 'string', required: true },
+        message: { type: 'string', required: false },
+        media: { type: 'object', required: false },
+        card: { type: 'object', required: false },
+      },
+    );
+
+    const body = {};
+    if (message !== undefined) body.message = message;
+    if (media !== undefined) body.media = media;
+    if (card !== undefined) body.card = card;
+
+    return internalRequest(
+      this.sdk,
+      `/webchat/tasks/${taskId}/messages`,
+      'POST',
+      { body },
+    );
+  }
+
+  /**
+   * Agent/bot typing indicator on a task's webchat. Server resolves the
+   * engagement from the task — callers must not UOQL widgetId.
+   *
+   * @param {Object} options
+   * @param {string} options.taskId
+   * @param {boolean} options.isTyping
+   * @returns {Promise<Object>}
+   */
+  async typingOnTask(options = {}) {
+    const { taskId, isTyping } = options;
+
+    this.sdk.validateParams(
+      { taskId, isTyping },
+      {
+        taskId: { type: 'string', required: true },
+        isTyping: { type: 'boolean', required: true },
+      },
+    );
+
+    return internalRequest(
+      this.sdk,
+      `/webchat/tasks/${taskId}/typing`,
+      'POST',
+      { body: { isTyping } },
+    );
+  }
+
+  /**
+   * Staff-only system note on a task's webchat feed (visibility=internal).
+   * Not sent to the visitor. Server resolves engagement from the task.
+   *
+   * @param {Object} options
+   * @param {string} options.taskId
+   * @param {string} options.message
+   * @returns {Promise<Object>}
+   */
+  async noteOnTask(options = {}) {
+    const { taskId, message } = options;
+
+    this.sdk.validateParams(
+      { taskId, message },
+      {
+        taskId: { type: 'string', required: true },
+        message: { type: 'string', required: true },
+      },
+    );
+
+    return internalRequest(
+      this.sdk,
+      `/webchat/tasks/${taskId}/notes`,
+      'POST',
+      { body: { message } },
+    );
+  }
 }