@webex/internal-plugin-call-ai-summary 3.12.0-next.6 → 3.12.0-next.61

package/test/unit/spec/ai-summary.ts

@@ -0,0 +1,388 @@
+/*!
+ * Copyright (c) 2015-2025 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import WebexCore from '@webex/webex-core';
+// Importing the package for its side effect is what performs registration.
+import AISummary from '@webex/internal-plugin-call-ai-summary';
+
+import config from '../../../src/config';
+import {ERROR_MESSAGES} from '../../../src/constants';
+import {
+  actionItemsResponse,
+  flattenedContainer,
+  notesResponse,
+  rawPragyaContainer,
+  summaryResponse,
+  transcriptResponse,
+} from '../fixture/responses';
+
+describe('internal-plugin-call-ai-summary', () => {
+  let webex;
+  let aisummary;
+
+  const clone = (value) => JSON.parse(JSON.stringify(value));
+
+  beforeEach(() => {
+    webex = new MockWebex({
+      children: {
+        aisummary: AISummary,
+      },
+    });
+
+    webex.config.aisummary = config.aisummary;
+    webex.internal.encryption = {
+      decryptText: sinon.stub().callsFake((keyUrl, ciphertext) => Promise.resolve(`decrypted:${ciphertext}`)),
+    };
+
+    aisummary = webex.internal.aisummary;
+  });
+
+  // MOD-007: registration happens as an import side effect. Assert it against the internal-core
+  // plugin registry rather than a live WebexCore instance — constructing one boots the service
+  // catalog, which fires asynchronous U2C requests that outlive the test and fail the runner.
+  describe('registration', () => {
+    const registeredPlugins = () =>
+      (WebexCore as any).prototype._children.internal.prototype._children;
+
+    it('registers itself as aisummary on the internal namespace', () => {
+      assert.property(
+        registeredPlugins(),
+        'aisummary',
+        'importing the package should register the aisummary internal plugin'
+      );
+    });
+
+    it('registers the plugin under the AISummary namespace', () => {
+      assert.equal(registeredPlugins().aisummary.prototype.namespace, 'AISummary');
+    });
+
+    it('exposes all six public methods on the registered plugin', () => {
+      const {prototype} = registeredPlugins().aisummary;
+
+      [
+        'getContainer',
+        'getSummary',
+        'getNotes',
+        'getActionItems',
+        'getTranscriptUrl',
+        'getTranscript',
+      ].forEach((method) => {
+        assert.isFunction(prototype[method], `${method} should be registered`);
+      });
+    });
+  });
+
+  describe('#getContainer', () => {
+    it('requests the container through the pragya service catalog entry', async () => {
+      webex.request = sinon.stub().resolves({body: clone(rawPragyaContainer)});
+
+      await aisummary.getContainer({containerId: 'container-123'});
+
+      assert.calledOnceWithExactly(webex.request, {
+        method: 'GET',
+        service: 'pragya',
+        resource: 'containers/container-123',
+      });
+    });
+
+    it('flattens summaryData.data onto summaryData', async () => {
+      webex.request = sinon.stub().resolves({body: clone(rawPragyaContainer)});
+
+      const result = await aisummary.getContainer({containerId: 'container-123'});
+
+      assert.equal(result.summaryData.status, 'Active');
+      assert.equal(result.summaryData.summaryUrl, 'https://aibridge-url/summaries/c635e870');
+      assert.isUndefined(result.summaryData.data);
+    });
+
+    it('leaves summaryData untouched when the upstream body is already flat', async () => {
+      webex.request = sinon.stub().resolves({body: clone(flattenedContainer)});
+
+      const result = await aisummary.getContainer({containerId: 'container-123'});
+
+      assert.equal(result.summaryData.summaryUrl, flattenedContainer.summaryData.summaryUrl);
+    });
+
+    // Validation runs before any request is issued, and getContainer is not async,
+    // so an invalid id throws synchronously rather than rejecting.
+    [
+      {name: 'an empty string', containerId: ''},
+      {name: 'whitespace only', containerId: '   '},
+      {name: 'undefined', containerId: undefined},
+      {name: 'a non-string', containerId: 42},
+    ].forEach(({name, containerId}) => {
+      it(`throws synchronously when containerId is ${name}`, () => {
+        webex.request = sinon.stub();
+
+        assert.throws(
+          () => aisummary.getContainer({containerId}),
+          ERROR_MESSAGES.INVALID_CONTAINER_ID
+        );
+        assert.notCalled(webex.request);
+      });
+    });
+  });
+
+  describe('#getSummary', () => {
+    it('requests the summary url with the fields query', async () => {
+      webex.request = sinon.stub().resolves({body: clone(summaryResponse)});
+
+      await aisummary.getSummary({containerInfo: flattenedContainer});
+
+      assert.calledOnceWithExactly(webex.request, {
+        method: 'GET',
+        uri: `${flattenedContainer.summaryData.summaryUrl}?fields=note,shortnote,actionitems`,
+      });
+    });
+
+    it('decrypts the note, short note and action item snippets', async () => {
+      webex.request = sinon.stub().resolves({body: clone(summaryResponse)});
+
+      const result = await aisummary.getSummary({containerInfo: flattenedContainer});
+
+      assert.equal(result.id, summaryResponse.id);
+      assert.equal(result.note, 'decrypted:<encrypted_note_content>');
+      assert.equal(result.shortNote, 'decrypted:<encrypted_short_note_content>');
+      assert.lengthOf(result.actionItems, 1);
+      assert.equal(
+        result.actionItems[0].aiGeneratedContent,
+        'decrypted:<encrypted_ai_generated_content>'
+      );
+      assert.equal(result.actionItems[0].editedContent, 'edited version');
+    });
+
+    it('extracts feedbackUrl from the links array', async () => {
+      webex.request = sinon.stub().resolves({body: clone(summaryResponse)});
+
+      const result = await aisummary.getSummary({containerInfo: flattenedContainer});
+
+      assert.equal(result.feedbackUrl, summaryResponse.links[0].href);
+    });
+
+    it('returns an undefined feedbackUrl when no feedback link is present', async () => {
+      const body = clone(summaryResponse);
+
+      body.links = [];
+      webex.request = sinon.stub().resolves({body});
+
+      const result = await aisummary.getSummary({containerInfo: flattenedContainer});
+
+      assert.isUndefined(result.feedbackUrl);
+    });
+
+    it('prefers the response keyUrl over containerInfo.encryptionKeyUrl', async () => {
+      webex.request = sinon.stub().resolves({body: clone(summaryResponse)});
+
+      await aisummary.getSummary({containerInfo: flattenedContainer});
+
+      assert.calledWith(
+        webex.internal.encryption.decryptText,
+        summaryResponse.keyUrl,
+        '<encrypted_note_content>'
+      );
+    });
+
+    it('falls back to containerInfo.encryptionKeyUrl when the response omits keyUrl', async () => {
+      const body = clone(summaryResponse);
+
+      delete body.keyUrl;
+      webex.request = sinon.stub().resolves({body});
+
+      await aisummary.getSummary({containerInfo: flattenedContainer});
+
+      assert.calledWith(
+        webex.internal.encryption.decryptText,
+        flattenedContainer.encryptionKeyUrl,
+        '<encrypted_note_content>'
+      );
+    });
+  });
+
+  describe('#getNotes', () => {
+    it('fetches and decrypts notes from notesUrl', async () => {
+      webex.request = sinon.stub().resolves({body: clone(notesResponse)});
+
+      const result = await aisummary.getNotes({containerInfo: flattenedContainer});
+
+      assert.calledOnceWithExactly(webex.request, {
+        method: 'GET',
+        uri: flattenedContainer.summaryData.notesUrl,
+      });
+      assert.equal(result.id, notesResponse.id);
+      assert.equal(result.content, 'decrypted:<encrypted_content>');
+      assert.equal(result.feedbackUrl, notesResponse.feedbackUrl);
+    });
+  });
+
+  describe('#getActionItems', () => {
+    it('unwraps the array response and decrypts every snippet', async () => {
+      webex.request = sinon.stub().resolves({body: clone(actionItemsResponse)});
+
+      const result = await aisummary.getActionItems({containerInfo: flattenedContainer});
+
+      assert.equal(result.id, actionItemsResponse[0].id);
+      assert.lengthOf(result.snippets, 1);
+      assert.equal(
+        result.snippets[0].aiGeneratedContent,
+        'decrypted:<encrypted_ai_generated_content>'
+      );
+      assert.equal(result.snippets[0].editedContent, 'edited version');
+    });
+
+    it('returns an empty snippet list when the response array is empty', async () => {
+      webex.request = sinon.stub().resolves({body: []});
+
+      const result = await aisummary.getActionItems({containerInfo: flattenedContainer});
+
+      assert.isUndefined(result.id);
+      assert.deepEqual(result.snippets, []);
+      assert.notCalled(webex.internal.encryption.decryptText);
+    });
+
+    it('omits editedContent when the snippet has no edited version', async () => {
+      const body = clone(actionItemsResponse);
+
+      delete body[0].snippets[0].content;
+      webex.request = sinon.stub().resolves({body});
+
+      const result = await aisummary.getActionItems({containerInfo: flattenedContainer});
+
+      assert.isUndefined(result.snippets[0].editedContent);
+    });
+  });
+
+  describe('#getTranscriptUrl', () => {
+    it('returns the transcript url synchronously without a request', () => {
+      webex.request = sinon.stub();
+
+      const url = aisummary.getTranscriptUrl({containerInfo: flattenedContainer});
+
+      assert.equal(url, flattenedContainer.summaryData.transcriptUrl);
+      assert.notCalled(webex.request);
+      assert.notCalled(webex.internal.encryption.decryptText);
+    });
+  });
+
+  describe('#getTranscript', () => {
+    it('fetches and decrypts every transcript snippet', async () => {
+      webex.request = sinon.stub().resolves({body: clone(transcriptResponse)});
+
+      const result = await aisummary.getTranscript({containerInfo: flattenedContainer});
+
+      assert.equal(result.id, transcriptResponse.id);
+      assert.equal(result.totalCount, 2);
+      assert.lengthOf(result.snippets, 2);
+      assert.equal(result.snippets[0].content, 'decrypted:<encrypted_snippet_1>');
+      assert.equal(result.snippets[1].content, 'decrypted:<encrypted_snippet_2>');
+      assert.equal(result.snippets[0].startTime, '1000');
+      assert.equal(result.snippets[0].endTime, '2000');
+      assert.equal(result.snippets[0].audioCSI, 'csi-1');
+      assert.deepEqual(result.snippets[0].speaker, {
+        speakerName: 'Ada Lovelace',
+        speakerId: 'speaker-1',
+      });
+    });
+
+    it('returns an empty snippet list when the transcript has no snippets', async () => {
+      webex.request = sinon.stub().resolves({body: {id: 'transcript-id', totalCount: 0}});
+
+      const result = await aisummary.getTranscript({containerInfo: flattenedContainer});
+
+      assert.deepEqual(result.snippets, []);
+    });
+  });
+
+  describe('containerInfo validation', () => {
+    // Every content method validates its own summaryData url field plus the
+    // encryption key before issuing a request.
+    [
+      {method: 'getSummary', urlField: 'summaryUrl'},
+      {method: 'getNotes', urlField: 'notesUrl'},
+      {method: 'getActionItems', urlField: 'actionItemsUrl'},
+      {method: 'getTranscript', urlField: 'transcriptUrl'},
+    ].forEach(({method, urlField}) => {
+      it(`${method} rejects when ${urlField} is missing`, async () => {
+        const containerInfo = clone(flattenedContainer);
+
+        delete containerInfo.summaryData[urlField];
+        webex.request = sinon.stub();
+
+        await assert.isRejected(
+          aisummary[method]({containerInfo}),
+          ERROR_MESSAGES.INVALID_CONTAINER_INFO
+        );
+        assert.notCalled(webex.request);
+      });
+
+      it(`${method} rejects when encryptionKeyUrl is missing`, async () => {
+        const containerInfo = clone(flattenedContainer);
+
+        delete containerInfo.encryptionKeyUrl;
+        webex.request = sinon.stub();
+
+        await assert.isRejected(
+          aisummary[method]({containerInfo}),
+          ERROR_MESSAGES.INVALID_CONTAINER_INFO
+        );
+        assert.notCalled(webex.request);
+      });
+    });
+
+    it('getTranscriptUrl throws synchronously when transcriptUrl is missing', () => {
+      const containerInfo = clone(flattenedContainer);
+
+      delete containerInfo.summaryData.transcriptUrl;
+
+      assert.throws(
+        () => aisummary.getTranscriptUrl({containerInfo}),
+        ERROR_MESSAGES.INVALID_CONTAINER_INFO
+      );
+    });
+  });
+
+  describe('error normalization', () => {
+    [
+      {statusCode: 401, expected: ERROR_MESSAGES.AUTHENTICATION_FAILED},
+      {statusCode: 403, expected: ERROR_MESSAGES.ACCESS_DENIED},
+      {statusCode: 404, expected: ERROR_MESSAGES.CONTAINER_NOT_FOUND},
+    ].forEach(({statusCode, expected}) => {
+      it(`maps a ${statusCode} from getContainer to "${expected}"`, async () => {
+        webex.request = sinon.stub().rejects(Object.assign(new Error('upstream'), {statusCode}));
+
+        await assert.isRejected(aisummary.getContainer({containerId: 'c1'}), expected);
+      });
+    });
+
+    it('maps a 404 from a content endpoint to the content-not-found message', async () => {
+      webex.request = sinon.stub().rejects(Object.assign(new Error('upstream'), {statusCode: 404}));
+
+      await assert.isRejected(
+        aisummary.getNotes({containerInfo: flattenedContainer}),
+        ERROR_MESSAGES.CONTENT_NOT_FOUND
+      );
+    });
+
+    it('prefixes the method name for an unmapped failure', async () => {
+      webex.request = sinon.stub().rejects(new Error('socket hang up'));
+
+      await assert.isRejected(
+        aisummary.getNotes({containerInfo: flattenedContainer}),
+        /getNotes failed: socket hang up/
+      );
+    });
+
+    it('propagates a decryption failure through error normalization', async () => {
+      webex.request = sinon.stub().resolves({body: clone(notesResponse)});
+      webex.internal.encryption.decryptText = sinon.stub().rejects(new Error('kms unavailable'));
+
+      await assert.isRejected(
+        aisummary.getNotes({containerInfo: flattenedContainer}),
+        /getNotes failed: kms unavailable/
+      );
+    });
+  });
+});

package/ai-docs/AGENTS.md

@@ -1,300 +0,0 @@
-# @webex/internal-plugin-call-ai-summary
-
-This is an internal Cisco Webex plugin. As such, it does not strictly adhere to semantic versioning. Use at your own risk. If you're not working on one of our first party clients, please look at our developer api and stick to our public plugins.
-Internal Webex JS SDK plugin for retrieving AI-generated call summaries, notes, action items, and transcript URLs from the Pragya and AI Bridge services.
-
-## Overview
-
-This plugin provides methods to:
-
-1. Resolve a **Pragya container** by ID (returns metadata, summary URLs, and encryption key)
-2. Fetch and decrypt **AI-generated summaries** (note, short note, action items) in a single call
-3. Fetch and decrypt **AI-generated notes** via a dedicated notes endpoint
-4. Fetch and decrypt **AI-generated action items** via a dedicated action items endpoint
-5. Retrieve the **transcript URL** for a call
-
-All AI-generated content is **JWE-encrypted** and decrypted via the KMS (Key Management Service) using `@webex/internal-plugin-encryption`.
-
-## Architecture
-
-```
-Pragya Service                     AI Bridge Service
-(container metadata)               (summary content)
-       |                                  |
-  getContainer()                   getSummary() / getNotes() / getActionItems()
-       |                                  |
-       v                                  v
-  PragyaContainerResponse          Encrypted JWE content
-  (summaryData, encryptionKeyUrl)         |
-                                          v
-                                   KMS Decryption
-                                   (internal-plugin-encryption)
-                                          |
-                                          v
-                                   Decrypted plaintext (HTML)
-```
-
-**Note:** The Pragya API returns summary URLs nested under `summaryData.data`. The `getContainer()` method normalizes this automatically, flattening `summaryData.data` into `summaryData` so consumers can access `summaryData.summaryUrl` directly.
-
-## Registration
-
-The plugin registers itself as `aisummary` on the internal namespace:
-
-```typescript
-import '@webex/internal-plugin-call-ai-summary';
-
-// Accessed via:
-webex.internal.aisummary.getContainer({ containerId: '...' });
-```
-
-## Source Files
-
-| File | Description |
-|------|-------------|
-| `src/index.ts` | Entry point. Registers the plugin via `registerInternalPlugin('aisummary', ...)`. |
-| `src/ai-summary.ts` | Main plugin class extending `WebexPlugin`. Contains all public and private methods. |
-| `src/types.ts` | TypeScript interfaces for request/response DTOs. |
-| `src/constants.ts` | Service name, resource path, and error message constants. |
-| `src/config.ts` | Plugin configuration (currently empty). |
-
-## API Reference
-
-### `getContainer(options: GetContainerOptions): Promise<PragyaContainerResponse>`
-
-Resolves a Pragya container by ID. Returns container metadata including summary URLs and the KMS encryption key URL. Normalizes the response by flattening `summaryData.data` into `summaryData`.
-
-```typescript
-const container = await webex.internal.aisummary.getContainer({
-  containerId: '34125120-13b5-11f1-9b36-adb685725098',
-});
-
-// After normalization, URLs are directly on summaryData:
-console.log(container.summaryData.summaryUrl);    // https://aibridge-.../summaries/...
-console.log(container.summaryData.transcriptUrl); // https://aibridge-.../transcripts/...
-```
-
-**Request**: `GET {pragya-service}/containers/{containerId}`
-
-**Response fields**:
-- `summaryData` — Contains summary URLs (`summaryUrl`, `transcriptUrl`, `status`, `summarizeAfterCall`)
-- `encryptionKeyUrl` — KMS key URL for decrypting content (e.g., `kms://kms-aore.wbx2.com/keys/...`)
-- `kmsResourceObjectUrl`, `aclUrl`, `forkSessionId`, `callSessionId`, `ownerUserId`, `orgId`, `start`, `end`
-
-### `getSummary(options: GetSummaryContentOptions): Promise<SummaryContent>`
-
-Fetches all AI-generated summary content (note, short note, and action items) from a single request to the summary URL, and decrypts each field via KMS. This is the primary method for retrieving summary content.
-
-```typescript
-const summary = await webex.internal.aisummary.getSummary({
-  containerInfo: container,
-});
-
-console.log(summary.note);        // Decrypted full note (HTML)
-console.log(summary.shortNote);   // Decrypted short note (HTML)
-console.log(summary.actionItems); // Array of decrypted action item snippets
-console.log(summary.feedbackUrl); // Feedback URL from links (if available)
-```
-
-**Request**: `GET {summaryUrl}?fields=note,shortnote,actionitems`
-
-**Response structure** (from AI Bridge, before decryption):
-```json
-{
-  "id": "...",
-  "keyUrl": "kms://...",
-  "note": { "aiGeneratedContent": "<JWE>" },
-  "shortnote": { "aiGeneratedContent": "<JWE>" },
-  "actionitems": {
-    "snippets": [
-      { "id": "...", "aiGeneratedContent": "<JWE>" }
-    ]
-  },
-  "links": [
-    { "rel": "feedback", "href": "https://..." }
-  ]
-}
-```
-
-**Return type** (`SummaryContent`):
-- `id` — Summary identifier
-- `note` — Decrypted full note (HTML string)
-- `shortNote` — Decrypted short note (HTML string)
-- `actionItems` — Array of `ActionItemSnippet` objects
-- `feedbackUrl` — Extracted from `links` array (`rel: "feedback"`), if available
-
-### `getNotes(options: GetSummaryContentOptions): Promise<SummaryNotes>`
-
-Fetches AI-generated notes from the dedicated notes endpoint and decrypts via KMS. Requires `notesUrl` to be present in the container's `summaryData`.
-
-```typescript
-const notes = await webex.internal.aisummary.getNotes({
-  containerInfo: container,
-});
-
-console.log(notes.content); // Decrypted notes content
-```
-
-**Request**: `GET {notesUrl}`
-
-> **Note:** The `notesUrl` may not be present in all API versions. Prefer `getSummary()` which returns notes, short notes, and action items in a single call.
-
-### `getActionItems(options: GetSummaryContentOptions): Promise<SummaryActionItems>`
-
-Fetches AI-generated action items from the dedicated action items endpoint and decrypts each snippet via KMS. Requires `actionItemsUrl` to be present in the container's `summaryData`.
-
-```typescript
-const actionItems = await webex.internal.aisummary.getActionItems({
-  containerInfo: container,
-});
-
-actionItems.snippets.forEach((item) => {
-  console.log(item.aiGeneratedContent); // Decrypted action item
-});
-```
-
-**Request**: `GET {actionItemsUrl}`
-
-> **Note:** The `actionItemsUrl` may not be present in all API versions. Prefer `getSummary()` which returns notes, short notes, and action items in a single call.
-
-### `getTranscriptUrl(options: GetSummaryContentOptions): string`
-
-Returns the transcript URL from the container info. Does not fetch or decrypt content.
-
-```typescript
-const transcriptUrl = webex.internal.aisummary.getTranscriptUrl({
-  containerInfo: container,
-});
-```
-
-## Types
-
-### Request Types
-
-```typescript
-interface GetContainerOptions {
-  containerId: string; // Pragya container ID
-}
-
-interface GetSummaryContentOptions {
-  containerInfo: PragyaContainerResponse; // Resolved container from getContainer()
-}
-```
-
-### Response Types
-
-```typescript
-interface PragyaContainerResponse {
-  summaryData: PragyaSummaryData;
-  encryptionKeyUrl: string;
-  kmsResourceObjectUrl: string;
-  aclUrl: string;
-  forkSessionId: string;
-  callSessionId: string;
-  ownerUserId: string;
-  orgId: string;
-  start: string;
-  end: string;
-}
-
-interface PragyaSummaryData {
-  status: string;
-  summaryUrl: string;
-  transcriptUrl: string;
-  summarizeAfterCall: boolean;
-  notesUrl?: string;       // May not be present in all API versions
-  actionItemsUrl?: string; // May not be present in all API versions
-}
-
-interface SummaryContent {
-  id: string;
-  note: string;           // Decrypted full note (HTML)
-  shortNote: string;      // Decrypted short note (HTML)
-  actionItems: ActionItemSnippet[];
-  feedbackUrl?: string;   // From links array (rel="feedback")
-}
-
-interface SummaryNotes {
-  id: string;
-  content: string;        // Decrypted notes content
-  feedbackUrl?: string;
-}
-
-interface SummaryActionItems {
-  id: string;
-  snippets: ActionItemSnippet[];
-  feedbackUrl?: string;
-}
-
-interface ActionItemSnippet {
-  id: string;
-  editedContent?: string;      // User-edited version (if available)
-  aiGeneratedContent: string;  // Decrypted AI-generated content
-}
-```
-
-## Error Handling
-
-The plugin normalizes HTTP errors into descriptive messages:
-
-| Status Code | Error Message |
-|-------------|---------------|
-| 401 | `Authentication failed: Invalid or expired token` |
-| 403 | `Access denied: User not authorized to view this summary` |
-| 404 | `Container not found` |
-| Other | `{methodName} failed: {error.message}` |
-
-Validation errors are thrown synchronously:
-- Missing or empty `containerId` throws `containerId is required and must be a non-empty string`
-- Missing `containerInfo`, `summaryData` URL, or `encryptionKeyUrl` throws `containerInfo with valid summaryData and encryptionKeyUrl is required`
-
-## Encryption / Decryption
-
-All AI-generated content from the AI Bridge service is JWE-encrypted. Decryption uses:
-
-```
-webex.internal.encryption.decryptText(encryptionKeyUrl, encryptedContent)
-```
-
-This requires:
-1. A registered device (`webex.internal.device.register()`)
-2. Mercury WebSocket connection (initiated automatically during KMS key fetch)
-3. ECDHE key exchange with KMS
-4. Key retrieval from KMS using the `encryptionKeyUrl`
-
-The SDK handles steps 1-4 automatically when `decryptText` is called.
-
-## Dependencies
-
-- `@webex/webex-core` — Base plugin class, request handling, auth interceptor
-- `@webex/internal-plugin-encryption` — KMS decryption
-
-## Token Requirements
-
-The Pragya and AI Bridge APIs require a valid Webex access token. The SDK's auth interceptor automatically attaches the token for URLs in the service catalog or on allowed domains (e.g., `wbx2.com`, `webex.com`).
-
-## Manual Testing
-
-Two manual test scripts are provided in `src/`:
-
-### `manual-pragya-api-test.js`
-Validates the Pragya container response structure (34 checks).
-
-```bash
-cd packages/@webex/internal-plugin-call-ai-summary
-WEBEX_TOKEN='<token>' node src/manual-pragya-api-test.js
-```
-
-### `manual-integration-test.js`
-Tests the full end-to-end flow using the SDK service catalog:
-1. Device registration (WDM) to populate the service catalog
-2. `getContainer` via plugin (resolves `service: 'pragya'` from the catalog)
-3. `getSummary` via plugin (fetches + decrypts note, short note, and action items via KMS)
-4. `getTranscriptUrl` via plugin
-5. Transcript content fetch
-
-```bash
-cd packages/@webex/internal-plugin-call-ai-summary
-WEBEX_TOKEN='<token>' CONTAINER_ID='<id>' node src/manual-integration-test.js
-```
-
-Both scripts require a valid Webex access token. Set `WEBEX_TOKEN` and optionally `CONTAINER_ID` as environment variables, or update the placeholder values in the scripts.