@webex/internal-plugin-call-ai-summary 0.0.0-next.1

package/src/ai-summary.ts

@@ -0,0 +1,318 @@
+/*!
+ * Copyright (c) 2015-2025 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {WebexPlugin} from '@webex/webex-core';
+
+import {AI_SUMMARY_SERVICE, AI_SUMMARY_CONTAINERS_RESOURCE, ERROR_MESSAGES} from './constants';
+import type {
+  GetContainerOptions,
+  GetSummaryContentOptions,
+  PragyaContainerResponse,
+  SummaryContent,
+  SummaryNotes,
+  SummaryActionItems,
+  TranscriptContent,
+} from './types';
+
+const AISummary = WebexPlugin.extend({
+  namespace: 'AISummary',
+
+  /**
+   * Resolve a Pragya container by ID.
+   * Returns container metadata including summary URLs and encryption key.
+   *
+   * @param {GetContainerOptions} options
+   * @returns {Promise<PragyaContainerResponse>}
+   */
+  getContainer(options: GetContainerOptions): Promise<PragyaContainerResponse> {
+    const {containerId} = options;
+
+    this._validateContainerId(containerId);
+
+    return this.webex
+      .request({
+        method: 'GET',
+        service: AI_SUMMARY_SERVICE,
+        resource: `${AI_SUMMARY_CONTAINERS_RESOURCE}/${containerId}`,
+      })
+      .then(({body}) => {
+        // Pragya API nests summary URLs under summaryData.data — flatten
+        // so consumers can access summaryData.summaryUrl directly.
+        if (body.summaryData?.data) {
+          body.summaryData = body.summaryData.data;
+        }
+
+        return body;
+      })
+      .catch((error) => {
+        this.logger.error('AISummary->getContainer failed', {error, containerId});
+        throw this._handleError(error, 'getContainer');
+      });
+  },
+
+  /**
+   * Get AI-generated full summary for a call.
+   * Fetches from containerInfo.summaryData.summaryUrl and decrypts content.
+   *
+   * @param {GetSummaryContentOptions} options
+   * @returns {Promise<SummaryContent>}
+   */
+  async getSummary(options: GetSummaryContentOptions): Promise<SummaryContent> {
+    const {containerInfo} = options;
+
+    this._validateContainerInfo(containerInfo, 'summaryUrl');
+
+    try {
+      const {body} = await this.webex.request({
+        method: 'GET',
+        uri: `${containerInfo.summaryData.summaryUrl}?fields=note,shortnote,actionitems`,
+      });
+
+      const keyUrl = body.keyUrl || containerInfo.encryptionKeyUrl;
+
+      const decryptedNote = await this._decryptContent(body.note.aiGeneratedContent, keyUrl);
+
+      const decryptedShortNote = await this._decryptContent(
+        body.shortnote.aiGeneratedContent,
+        keyUrl
+      );
+
+      const decryptedSnippets = await Promise.all(
+        (body.actionitems?.snippets || []).map(async (snippet: any) => {
+          const decryptedAiContent = await this._decryptContent(snippet.aiGeneratedContent, keyUrl);
+
+          return {
+            id: snippet.id,
+            editedContent: snippet.content || undefined,
+            aiGeneratedContent: decryptedAiContent,
+          };
+        })
+      );
+
+      // feedbackUrl may be in the links array as rel="feedback"
+      const feedbackLink = (body.links || []).find((link: any) => link.rel === 'feedback');
+
+      return {
+        id: body.id,
+        note: decryptedNote,
+        shortNote: decryptedShortNote,
+        actionItems: decryptedSnippets,
+        feedbackUrl: feedbackLink?.href,
+      };
+    } catch (error) {
+      this.logger.error('AISummary->getSummary failed', {error});
+      throw this._handleError(error, 'getSummary');
+    }
+  },
+
+  /**
+   * Get AI-generated notes for a call.
+   * Fetches from containerInfo.summaryData.notesUrl and decrypts content.
+   *
+   * @param {GetSummaryContentOptions} options
+   * @returns {Promise<SummaryNotes>}
+   */
+  async getNotes(options: GetSummaryContentOptions): Promise<SummaryNotes> {
+    const {containerInfo} = options;
+
+    this._validateContainerInfo(containerInfo, 'notesUrl');
+
+    try {
+      const {body} = await this.webex.request({
+        method: 'GET',
+        uri: containerInfo.summaryData.notesUrl,
+      });
+
+      const keyUrl = body.keyUrl || containerInfo.encryptionKeyUrl;
+
+      const decryptedContent = await this._decryptContent(body.aiGeneratedContent, keyUrl);
+
+      return {
+        id: body.id,
+        content: decryptedContent,
+        feedbackUrl: body.feedbackUrl,
+      };
+    } catch (error) {
+      this.logger.error('AISummary->getNotes failed', {error});
+      throw this._handleError(error, 'getNotes');
+    }
+  },
+
+  /**
+   * Get AI-generated action items for a call.
+   * Fetches from containerInfo.summaryData.actionItemsUrl and decrypts content.
+   *
+   * @param {GetSummaryContentOptions} options
+   * @returns {Promise<SummaryActionItems>}
+   */
+  async getActionItems(options: GetSummaryContentOptions): Promise<SummaryActionItems> {
+    const {containerInfo} = options;
+
+    this._validateContainerInfo(containerInfo, 'actionItemsUrl');
+
+    try {
+      const {body} = await this.webex.request({
+        method: 'GET',
+        uri: containerInfo.summaryData.actionItemsUrl,
+      });
+
+      // Action items response is an array; take the first element
+      const actionItemsData = Array.isArray(body) ? body[0] : body;
+
+      if (!actionItemsData) {
+        return {id: undefined, snippets: []};
+      }
+
+      const keyUrl = actionItemsData.keyUrl || containerInfo.encryptionKeyUrl;
+
+      const decryptedSnippets = await Promise.all(
+        (actionItemsData.snippets || []).map(async (snippet: any) => {
+          const decryptedAiContent = await this._decryptContent(snippet.aiGeneratedContent, keyUrl);
+
+          return {
+            id: snippet.id,
+            editedContent: snippet.content || undefined,
+            aiGeneratedContent: decryptedAiContent,
+          };
+        })
+      );
+
+      return {
+        id: actionItemsData.id,
+        snippets: decryptedSnippets,
+        feedbackUrl: actionItemsData.feedbackUrl,
+      };
+    } catch (error) {
+      this.logger.error('AISummary->getActionItems failed', {error});
+      throw this._handleError(error, 'getActionItems');
+    }
+  },
+
+  /**
+   * Get the transcript URL for a call.
+   * Returns the URL string from the container info.
+   *
+   * @param {GetSummaryContentOptions} options
+   * @returns {string}
+   */
+  getTranscriptUrl(options: GetSummaryContentOptions): string {
+    const {containerInfo} = options;
+
+    this._validateContainerInfo(containerInfo, 'transcriptUrl');
+
+    return containerInfo.summaryData.transcriptUrl;
+  },
+
+  /**
+   * Get decrypted transcript for a call.
+   * Fetches from containerInfo.summaryData.transcriptUrl and decrypts each snippet.
+   *
+   * @param {GetSummaryContentOptions} options
+   * @returns {Promise<TranscriptContent>}
+   */
+  async getTranscript(options: GetSummaryContentOptions): Promise<TranscriptContent> {
+    const {containerInfo} = options;
+
+    this._validateContainerInfo(containerInfo, 'transcriptUrl');
+
+    try {
+      const {body} = await this.webex.request({
+        method: 'GET',
+        uri: containerInfo.summaryData.transcriptUrl,
+      });
+
+      const keyUrl = body.keyUrl || containerInfo.encryptionKeyUrl;
+
+      const decryptedSnippets = await Promise.all(
+        (body.transcriptSnippetList || []).map(async (snippet: any) => {
+          const decryptedContent = await this._decryptContent(snippet.content, keyUrl);
+
+          return {
+            startTime: snippet.startTime,
+            endTime: snippet.endTime,
+            content: decryptedContent,
+            audioCSI: snippet.audioCSI,
+            speaker: snippet.speaker,
+          };
+        })
+      );
+
+      return {
+        id: body.id,
+        totalCount: body.totalCount,
+        snippets: decryptedSnippets,
+      };
+    } catch (error) {
+      this.logger.error('AISummary->getTranscript failed', {error});
+      throw this._handleError(error, 'getTranscript');
+    }
+  },
+
+  /**
+   * Validate containerId parameter.
+   * @param {string} containerId - The container ID to validate.
+   * @returns {void}
+   * @private
+   */
+  _validateContainerId(containerId: string): void {
+    if (!containerId || typeof containerId !== 'string' || containerId.trim().length === 0) {
+      throw new Error(ERROR_MESSAGES.INVALID_CONTAINER_ID);
+    }
+  },
+
+  /**
+   * Validate containerInfo has the required URL field and encryption key.
+   * @param {PragyaContainerResponse} containerInfo - The container info to validate.
+   * @param {string} urlField - The summaryData field name to check.
+   * @returns {void}
+   * @private
+   */
+  _validateContainerInfo(containerInfo: PragyaContainerResponse, urlField: string): void {
+    if (!containerInfo?.summaryData?.[urlField] || !containerInfo?.encryptionKeyUrl) {
+      throw new Error(ERROR_MESSAGES.INVALID_CONTAINER_INFO);
+    }
+  },
+
+  /**
+   * Decrypt encrypted content using KMS.
+   * Delegates to the internal encryption plugin.
+   * @param {string} encryptedContent - The encrypted text (JWE format).
+   * @param {string} encryptionKeyUrl - KMS key URL.
+   * @returns {Promise<string>} Decrypted plaintext.
+   * @private
+   */
+  _decryptContent(encryptedContent: string, encryptionKeyUrl: string): Promise<string> {
+    return this.webex.internal.encryption.decryptText(encryptionKeyUrl, encryptedContent);
+  },
+
+  /**
+   * Handle and normalize errors.
+   * @param {object} error - The error object from the request.
+   * @param {string} methodName - The name of the calling method.
+   * @returns {Error} A normalized Error instance.
+   * @private
+   */
+  _handleError(error: any, methodName: string): Error {
+    if (error.statusCode === 404) {
+      const message =
+        methodName === 'getContainer'
+          ? ERROR_MESSAGES.CONTAINER_NOT_FOUND
+          : ERROR_MESSAGES.CONTENT_NOT_FOUND;
+
+      return new Error(message);
+    }
+
+    if (error.statusCode === 403) {
+      return new Error(ERROR_MESSAGES.ACCESS_DENIED);
+    }
+
+    if (error.statusCode === 401) {
+      return new Error(ERROR_MESSAGES.AUTHENTICATION_FAILED);
+    }
+
+    return new Error(`${methodName} failed: ${error.message || 'Unknown error'}`);
+  },
+});
+
+export default AISummary;

package/src/config.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright (c) 2015-2025 Cisco Systems, Inc. See LICENSE file.
+ */
+
+export default {
+  aisummary: {},
+};

package/src/constants.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) 2015-2025 Cisco Systems, Inc. See LICENSE file.
+ */
+
+export const AI_SUMMARY_SERVICE = 'pragya';
+export const AI_SUMMARY_CONTAINERS_RESOURCE = 'containers';
+
+export const SUMMARY_STATUSES = {
+  ACTIVE: 'Active',
+} as const;
+
+export const ERROR_MESSAGES = {
+  INVALID_CONTAINER_ID: 'containerId is required and must be a non-empty string',
+  INVALID_CONTAINER_INFO: 'containerInfo with valid summaryData and encryptionKeyUrl is required',
+  CONTAINER_NOT_FOUND: 'Container not found',
+  CONTENT_NOT_FOUND: 'Summary content not available or expired',
+  ACCESS_DENIED: 'Access denied: User not authorized to view this summary',
+  AUTHENTICATION_FAILED: 'Authentication failed: Invalid or expired token',
+} as const;

package/src/index.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright (c) 2015-2025 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import '@webex/internal-plugin-encryption';
+import {registerInternalPlugin} from '@webex/webex-core';
+
+import AISummary from './ai-summary';
+import config from './config';
+
+registerInternalPlugin('aisummary', AISummary, {config});
+
+export {default} from './ai-summary';

package/src/manual-integration-test.js

@@ -0,0 +1,129 @@
+/*!
+ * Copyright (c) 2015-2025 Cisco Systems, Inc. See LICENSE file.
+ *
+ * Manual integration test for internal-plugin-call-ai-summary
+ * Tests the full flow using the SDK service catalog (WDM):
+ *   device.register() -> getContainer -> getSummary (with KMS decryption)
+ *
+ * The SDK resolves `service: 'pragya'` to the correct base URL via the
+ * service catalog populated during device registration.
+ *
+ * Usage:
+ *   WEBEX_TOKEN='<token>' node src/manual-integration-test.js
+ */
+
+/* eslint-disable no-console, require-jsdoc */
+
+require('@webex/internal-plugin-call-ai-summary');
+
+const WebexCore = require('@webex/webex-core').default;
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+const WEBEX_TOKEN = process.env.WEBEX_TOKEN || '<PASTE_YOUR_TOKEN_HERE>';
+const CONTAINER_ID = process.env.CONTAINER_ID || '<PASTE_CONTAINER_ID_HERE>';
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+  console.log('=== Step 1: Create WebexCore ===\n');
+  const webex = new WebexCore({
+    credentials: {
+      access_token: WEBEX_TOKEN,
+    },
+  });
+
+  // Step 2: Register device to populate service catalog
+  console.log('=== Step 2: Register device (WDM) ===\n');
+  await webex.internal.device.register();
+  console.log('Device registered successfully.');
+  console.log('Device URL:', webex.internal.device.url);
+
+  // Log the pragya service URL from the service catalog
+  try {
+    const pragyaUrl = webex.internal.services.get('pragya');
+    console.log('Pragya service URL (from catalog):', pragyaUrl);
+  } catch (e) {
+    console.log('Could not resolve pragya from service catalog:', e.message);
+  }
+
+  // Step 3: Get container via plugin (uses service: 'pragya' + resource)
+  console.log('\n=== Step 3: getContainer via plugin ===\n');
+  const container = await webex.internal.aisummary.getContainer({
+    containerId: CONTAINER_ID,
+  });
+  console.log(
+    'Container Info:',
+    JSON.stringify(
+      {
+        id: container.id,
+        objectType: container.objectType,
+        encryptionKeyUrl: container.encryptionKeyUrl,
+        summaryUrl: container.summaryData?.summaryUrl,
+        transcriptUrl: container.summaryData?.transcriptUrl,
+      },
+      null,
+      2
+    )
+  );
+
+  // Step 4: Call getSummary via plugin (fetches + decrypts all content)
+  console.log('\n=== Step 4: getSummary via plugin ===\n');
+  const summaryResult = await webex.internal.aisummary.getSummary({
+    containerInfo: container,
+  });
+
+  console.log('=== getSummary return structure ===');
+  const noteStr = summaryResult.note || '';
+  const shortNoteStr = summaryResult.shortNote || '';
+  const truncNote = noteStr.length > 200 ? `${noteStr.substring(0, 200)}...` : noteStr;
+  const truncShort =
+    shortNoteStr.length > 200 ? `${shortNoteStr.substring(0, 200)}...` : shortNoteStr;
+  const truncated = {
+    id: summaryResult.id,
+    note: truncNote,
+    shortNote: truncShort,
+    actionItems: (summaryResult.actionItems || []).map((item) => {
+      const content = item.aiGeneratedContent || '';
+      const truncContent = content.length > 100 ? `${content.substring(0, 100)}...` : content;
+
+      return {
+        id: item.id,
+        aiGeneratedContent: truncContent,
+        editedContent: item.editedContent,
+      };
+    }),
+    feedbackUrl: summaryResult.feedbackUrl,
+  };
+  console.log(JSON.stringify(truncated, null, 2));
+
+  // Step 5: Get transcript URL via plugin
+  console.log('\n=== Step 5: getTranscriptUrl via plugin ===\n');
+  const transcriptUrl = webex.internal.aisummary.getTranscriptUrl({
+    containerInfo: container,
+  });
+  console.log('Transcript URL:', transcriptUrl);
+
+  // Step 6: Fetch transcript content
+  console.log('\n=== Step 6: Fetch transcript content ===\n');
+  try {
+    const {body: transcriptBody} = await webex.request({
+      method: 'GET',
+      uri: `${transcriptUrl}?fields=id,content`,
+    });
+    console.log('Transcript response keys:', Object.keys(transcriptBody));
+    console.log(JSON.stringify(transcriptBody, null, 2).substring(0, 500));
+  } catch (err) {
+    console.error('Transcript fetch failed:', err.message);
+  }
+
+  console.log('\nDone.');
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error('FATAL:', err.message || err);
+  process.exit(1);
+});

package/src/manual-pragya-api-test.js

@@ -0,0 +1,166 @@
+/*!
+ * Copyright (c) 2015-2025 Cisco Systems, Inc. See LICENSE file.
+ *
+ * Manual test for internal-plugin-call-ai-summary
+ *
+ * Usage:
+ *   WEBEX_TOKEN='<your-token>' node manual-test.js
+ *
+ * Or paste your token directly into WEBEX_TOKEN below.
+ */
+
+/* eslint-disable no-console, require-jsdoc */
+
+require('@webex/internal-plugin-call-ai-summary');
+
+const WebexCore = require('@webex/webex-core').default;
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+const WEBEX_TOKEN = process.env.WEBEX_TOKEN || '<PASTE_YOUR_TOKEN_HERE>';
+const CONTAINER_ID = '<PASTE_CONTAINER_ID_HERE>';
+const PRAGYA_BASE_URL = '<PASTE_PRAGYA_BASE_URL_HERE>';
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+  if (WEBEX_TOKEN === '<PASTE_YOUR_TOKEN_HERE>') {
+    console.error('ERROR: Set WEBEX_TOKEN env var or paste your token in the script.');
+    process.exit(1);
+  }
+
+  const webex = new WebexCore({
+    credentials: {
+      access_token: WEBEX_TOKEN,
+    },
+  });
+
+  console.log('--- Fetching container', CONTAINER_ID, '(SDK auth) ---\n');
+
+  const response = await webex.request({
+    method: 'GET',
+    uri: `${PRAGYA_BASE_URL}/containers/${CONTAINER_ID}`,
+    headers: {
+      'content-type': 'application/json',
+    },
+  });
+
+  const container = response.body;
+  let passed = 0;
+  let failed = 0;
+
+  function check(label, actual, expected) {
+    if (actual === expected) {
+      console.log(`  PASS: ${label}`);
+      passed += 1;
+    } else {
+      console.log(
+        `  FAIL: ${label} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`
+      );
+      failed += 1;
+    }
+  }
+
+  function checkExists(label, value) {
+    if (value !== undefined && value !== null) {
+      console.log(`  PASS: ${label} exists`);
+      passed += 1;
+    } else {
+      console.log(`  FAIL: ${label} is missing`);
+      failed += 1;
+    }
+  }
+
+  function checkType(label, value, type) {
+    const actual = Array.isArray(value) ? 'array' : typeof value;
+    const expected = type;
+    if (type === 'array' ? Array.isArray(value) : actual === expected) {
+      console.log(`  PASS: ${label} is ${type}`);
+      passed += 1;
+    } else {
+      console.log(`  FAIL: ${label} — expected ${type}, got ${actual}`);
+      failed += 1;
+    }
+  }
+
+  function checkMatch(label, value, regex) {
+    if (regex.test(value)) {
+      console.log(`  PASS: ${label} matches ${regex}`);
+      passed += 1;
+    } else {
+      console.log(`  FAIL: ${label} — ${JSON.stringify(value)} does not match ${regex}`);
+      failed += 1;
+    }
+  }
+
+  // --- Top-level container ---
+  console.log('\n--- Top-level container ---');
+  checkType('container', container, 'object');
+  check('container.id', container.id, CONTAINER_ID);
+  check('container.objectType', container.objectType, 'callingAIContainer');
+  checkExists('container.summaryData', container.summaryData);
+  checkExists('container.memberships', container.memberships);
+  checkMatch('container.encryptionKeyUrl', container.encryptionKeyUrl, /^kms:\/\//);
+  checkMatch('container.kmsResourceObjectUrl', container.kmsResourceObjectUrl, /^kms:\/\//);
+  checkMatch('container.aclUrl', container.aclUrl, /^https?:\/\//);
+  checkExists('container.start', container.start);
+  checkExists('container.end', container.end);
+  checkExists('container.forkSessionId', container.forkSessionId);
+  checkExists('container.callSessionId', container.callSessionId);
+  checkExists('container.ownerUserId', container.ownerUserId);
+  checkExists('container.orgId', container.orgId);
+
+  // --- summaryData ---
+  console.log('\n--- summaryData ---');
+  const {summaryData} = container;
+  checkType('summaryData', summaryData, 'object');
+  checkExists('summaryData.extensionId', summaryData.extensionId);
+  check('summaryData.objectType', summaryData.objectType, 'extension');
+  check('summaryData.extensionType', summaryData.extensionType, 'callingAISummary');
+
+  // --- summaryData.data ---
+  console.log('\n--- summaryData.data ---');
+  const summaryDataData = summaryData.data;
+  checkType('summaryData.data', summaryDataData, 'object');
+  checkExists('summaryData.data.id', summaryDataData.id);
+  check('summaryData.data.objectType', summaryDataData.objectType, 'callingAISummary');
+  checkExists('summaryData.data.status', summaryDataData.status);
+  checkMatch('summaryData.data.summaryUrl', summaryDataData.summaryUrl, /^https?:\/\//);
+  checkMatch('summaryData.data.transcriptUrl', summaryDataData.transcriptUrl, /^https?:\/\//);
+  checkMatch('summaryData.data.aclUrl', summaryDataData.aclUrl, /^https?:\/\//);
+  checkMatch(
+    'summaryData.data.kmsResourceObjectUrl',
+    summaryDataData.kmsResourceObjectUrl,
+    /^kms:\/\//
+  );
+  checkType('summaryData.data.summarizeAfterCall', summaryDataData.summarizeAfterCall, 'boolean');
+  checkType('summaryData.data.contentRetention', summaryDataData.contentRetention, 'object');
+
+  // --- memberships ---
+  console.log('\n--- memberships ---');
+  const {memberships} = container;
+  checkType('memberships', memberships, 'object');
+  checkType('memberships.items', memberships.items, 'array');
+  if (memberships.items.length > 0) {
+    console.log(`  PASS: memberships.items has ${memberships.items.length} member(s)`);
+    passed += 1;
+    const first = memberships.items[0];
+    checkExists('memberships.items[0].id', first.id);
+    checkType('memberships.items[0].roles', first.roles, 'array');
+    check('memberships.items[0].objectType', first.objectType, 'containerMembership');
+  } else {
+    console.log('  FAIL: memberships.items is empty');
+    failed += 1;
+  }
+
+  // --- Summary ---
+  console.log(`\n=== ${passed} passed, ${failed} failed ===`);
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch((err) => {
+  console.error('FAILED:', err.message || err);
+  process.exit(1);
+});