@coveo/quantic 3.39.1 → 3.41.0

package/force-app/main/default/classes/HeadlessControllerTest.cls

@@ -1,5 +1,6 @@
 @isTest
 private class HeadlessControllerTest {
+  // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
   static final String sampleHeadlessConfiguration = '{"accessToken":"xx564559b1-0045-48e1-953c-3addd1ee4457","organizationId":"searchuisamples"}';
   @IsTest
   static void shouldReturnStringifiedConfiguration() {

package/force-app/main/default/classes/InsightControllerTest.cls

@@ -1,5 +1,6 @@
 @isTest
 private class InsightControllerTest {
+  // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
   static final String sampleHeadlessConfiguration = '{"accessToken":"xx564559b1-0045-48e1-953c-3addd1ee4457","organizationId":"searchuisamples"}';
   @IsTest
   static void shouldReturnStringifiedConfiguration() {

package/force-app/main/default/classes/RecommendationsControllerTest.cls

@@ -1,6 +1,6 @@
 @isTest
 private class RecommendationsControllerTest {
-  // This is a demo token and it's okay to be public.
+  // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
   static final String sampleHeadlessConfiguration = '{"accessToken":"xx564559b1-0045-48e1-953c-3addd1ee4457","organizationId":"searchuisamples"}';
   @IsTest
   static void shouldReturnStringifiedConfiguration() {

package/force-app/main/default/classes/SampleTokenProvider.cls

@@ -10,6 +10,7 @@ global with sharing class SampleTokenProvider implements ITokenProvider {
     headlessConfiguration.put('organizationId', 'searchuisamples');
     headlessConfiguration.put(
       'accessToken',
+      // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
       'xx564559b1-0045-48e1-953c-3addd1ee4457'
     );
     return JSON.serialize(headlessConfiguration);

package/force-app/main/default/classes/SampleTokenProviderTest.cls

@@ -1,5 +1,6 @@
 @isTest
 private class SampleTokenProviderTest {
+  // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
   static final String sampleHeadlessConfiguration = '{"accessToken":"xx564559b1-0045-48e1-953c-3addd1ee4457","organizationId":"searchuisamples"}';
   @IsTest
   static void shouldReturnStringifiedConfiguration() {

package/force-app/main/default/labels/CustomLabels.labels-meta.xml

@@ -455,6 +455,13 @@
     <protected>false</protected>
     <shortDescription>Collapse [component label]</shortDescription>
   </labels>
+  <labels>
+    <fullName>quantic_CollapseButton</fullName>
+    <value>Collapse</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Collapse</shortDescription>
+  </labels>
   <labels>
     <fullName>quantic_Expand</fullName>
     <value>Expand {{0}}</value>
@@ -1288,6 +1295,13 @@
     <protected>false</protected>
     <shortDescription>Something went wrong and we couldn't generate an answer.</shortDescription>
   </labels>
+  <labels>
+    <fullName>quantic_GeneratedAnswerErrorTurnLimitReached</fullName>
+    <value>Conversation turn limit reached. Please start a new conversation.</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Generated answer conversation turn limit reached error.</shortDescription>
+  </labels>
   <labels>
     <fullName>quantic_ShowingResultsFor</fullName>
     <value>Showing results for {{0}}</value>
@@ -1638,4 +1652,67 @@
     <protected>false</protected>
     <shortDescription>Submit follow-up</shortDescription>
   </labels>
+  <labels>
+    <fullName>quantic_ShowPreviousQuestions_plural</fullName>
+    <value>Show {{0}} previous questions</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Show previous questions (plural)</shortDescription>
+  </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepAnalyzingQuestion</fullName>
+    <value>Analyzing your question…</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Analyzing your question</shortDescription>
+  </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepAnalyzingQuestionCompleted</fullName>
+    <value>Question analyzed</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Question analyzed</shortDescription>
+  </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepSearch</fullName>
+    <value>Searching knowledge base…</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Searching knowledge base…</shortDescription>
+  </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepSearchCompleted</fullName>
+    <value>Knowledge base searched</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Knowledge base searched</shortDescription>
+  </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepAnalyzingResults</fullName>
+    <value>Analyzing results…</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Analyzing results…</shortDescription>
+  </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepAnalyzingResultsCompleted</fullName>
+    <value>Results analyzed</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Results analyzed</shortDescription>
+  </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepAnswering</fullName>
+    <value>Generating answer…</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Generating answer…</shortDescription>
+  </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepAnsweringCompleted</fullName>
+    <value>Answer generated</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Answer generated</shortDescription>
+  </labels>
 </CustomLabels>

package/force-app/main/default/lwc/quanticGeneratedAnswer/__tests__/quanticGeneratedAnswer.test.js

@@ -22,6 +22,8 @@ const exampleCitations = [
     uri: 'https://example.com/2',
   },
 ];
+const exampleEngineId = 'example engine id';
+const exampleAnswerId = 'example answer id';
 jest.mock('c/quanticHeadlessLoader');
 jest.mock('c/quanticUtils', () => ({
   AriaLiveRegion: jest.fn(() => ({
@@ -50,6 +52,7 @@ jest.mock(
 
 /** @type {Object} */
 const defaultOptions = {
+  engineId: exampleEngineId,
   fieldsToIncludeInCitations: 'sfid,sfkbid,sfkavid,filetype',
   answerConfigurationId: undefined,
   withToggle: false,
@@ -348,6 +351,7 @@ describe('c-quantic-generated-answer', () => {
           isStreaming: true,
           answer: exampleAnswer,
           answerContentFormat: exampleAnswerContentFormat,
+          answerId: exampleAnswerId,
         };
         mockSuccessfulHeadlessInitialization();
         prepareHeadlessState();
@@ -461,6 +465,8 @@ describe('c-quantic-generated-answer', () => {
         expect(generatedAnswerContent.answerContentFormat).toBe(
           exampleAnswerContentFormat
         );
+        expect(generatedAnswerContent.engineId).toBe(exampleEngineId);
+        expect(generatedAnswerContent.answerId).toBe(exampleAnswerId);
       });
 
       it('should not display the generated answer actions', async () => {
@@ -784,6 +790,54 @@ describe('c-quantic-generated-answer', () => {
         expect(generatedAnswerCitations).not.toBeNull();
         expect(generatedAnswerCitations.disableCitationAnchoring).toBe(false);
       });
+
+      describe('when follow-ups are enabled', () => {
+        // TODO SFINT-6786: Add test cases to cover the behavior of the component when follow-ups are enabled based on the actual implementation of the follow-up feature in the state.
+        it.skip('should render the content section with the scrollable class and ignore the collapsible feature', async () => {
+          mockAnswerHeight = defaultAnswerHeight + 100;
+          const element = createTestComponent({
+            ...defaultOptions,
+            collapsible: true,
+          });
+          await flushPromises();
+
+          const generatedAnswerBody = element.shadowRoot.querySelector(
+            selectors.generatedAnswerBody
+          );
+
+          expect(generatedAnswerBody).not.toBeNull();
+          expect(
+            generatedAnswerBody.classList.contains(
+              'generated-answer__content--scrollable'
+            )
+          ).toBe(true);
+
+          const generatedAnswerCollapseToggle =
+            element.shadowRoot.querySelector(
+              selectors.generatedAnswerCollapseToggle
+            );
+
+          expect(generatedAnswerCollapseToggle).toBeNull();
+        });
+      });
+
+      describe('when follow-ups are not enabled', () => {
+        it('should not render the content section with the scrollable class', async () => {
+          const element = createTestComponent();
+          await flushPromises();
+
+          const generatedAnswerBody = element.shadowRoot.querySelector(
+            selectors.generatedAnswerBody
+          );
+
+          expect(generatedAnswerBody).not.toBeNull();
+          expect(
+            generatedAnswerBody.classList.contains(
+              'generated-answer__content--scrollable'
+            )
+          ).toBe(false);
+        });
+      });
     });
 
     describe('when the answer cannot be generated after a query is executed', () => {

package/force-app/main/default/lwc/quanticGeneratedAnswer/quanticGeneratedAnswer.js

@@ -172,6 +172,8 @@ export default class QuanticGeneratedAnswer extends LightningElement {
   /** @type {boolean} */
   hasInitializationError = false;
   /** @type {boolean} */
+  _areFollowUpsEnabled = false;
+  /** @type {boolean} */
   _exceedsMaximumHeight = false;
   /** @type {boolean} */
   _liked = false;
@@ -196,7 +198,7 @@ export default class QuanticGeneratedAnswer extends LightningElement {
 
   renderedCallback() {
     initializeWithHeadless(this, this.engineId, this.initialize);
-    if (this.collapsible) {
+    if (this.isCollapsibleEnabled) {
       this._exceedsMaximumHeight = this.isMaximumHeightExceeded();
     }
   }
@@ -259,7 +261,7 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     this.updateFeedbackState();
     this.ariaLiveMessage.dispatchMessage(this.getGeneratedAnswerStatus());
 
-    if (this.collapsible) {
+    if (this.isCollapsibleEnabled) {
       this.updateGeneratedAnswerCSSVariables();
     }
   }
@@ -400,7 +402,7 @@ export default class QuanticGeneratedAnswer extends LightningElement {
 
   handleAnswerContentUpdated = (event) => {
     event.stopPropagation();
-    if (this.collapsible) {
+    if (this.isCollapsibleEnabled) {
       this._exceedsMaximumHeight = this.isMaximumHeightExceeded();
     }
     this.updateGeneratedAnswerCSSVariables();
@@ -456,6 +458,10 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     return this?.state?.answer;
   }
 
+  get answerId() {
+    return this?.state?.answerId;
+  }
+
   get citations() {
     return this?.state?.citations;
   }
@@ -481,6 +487,15 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     return this.state.isVisible;
   }
 
+  get areFollowUpsEnabled() {
+    // TODO SFINT-6786: Modify this getter to return the actual value from the state for follow-up enabled/agentId.
+    return this._areFollowUpsEnabled;
+  }
+
+  get isCollapsibleEnabled() {
+    return this.collapsible && !this.areFollowUpsEnabled;
+  }
+
   get isAnswerCollapsed() {
     // Answer is considered collapsed only if it exceeds the maximum height and was not expanded.
     return this._exceedsMaximumHeight && !this.isExpanded;
@@ -501,6 +516,14 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     return `generated-answer__answer ${collapsedStateClass}`;
   }
 
+  get contentSectionClass() {
+    const baseClass =
+      'generated-answer__content slds-p-top_medium slds-p-horizontal_large';
+    return this.areFollowUpsEnabled
+      ? `${baseClass} generated-answer__content--scrollable`
+      : baseClass;
+  }
+
   get hasRetryableError() {
     return !this?.searchStatusState?.hasError && this.state?.error?.isRetryable;
   }

package/force-app/main/default/lwc/quanticGeneratedAnswer/templates/generatedAnswer.css

@@ -9,6 +9,11 @@
   word-wrap: break-word;
 }
 
+.generated-answer__content--scrollable {
+  overflow-y: auto;
+  height: var(--quantic-generated-answer-content-fixed-height, 50vh);
+}
+
 .generated-answer__footer {
   gap: 1rem;
 }

package/force-app/main/default/lwc/quanticGeneratedAnswer/templates/generatedAnswer.html

@@ -27,13 +27,15 @@
       <template lwc:if={isVisible}>
         <section
           data-testid="generated-answer__body"
-          class="generated-answer__content slds-p-top_medium slds-p-horizontal_large"
+          class={contentSectionClass}
         >
           <div
             data-testid="generated-answer__answer"
             class={generatedAnswerClass}
           >
             <c-quantic-generated-answer-content
+              engine-id={engineId}
+              answer-id={answerId}
               answer-content-format={answerContentFormat}
               answer={answer}
               is-streaming={isStreaming}

package/force-app/main/default/lwc/quanticGeneratedAnswerBody/__tests__/quanticGeneratedAnswerBody.test.js

@@ -0,0 +1,341 @@
+// @ts-ignore
+import QuanticGeneratedAnswerBody from 'c/quanticGeneratedAnswerBody';
+import {buildCreateTestComponent, cleanup, flushPromises} from 'c/testUtils';
+
+jest.mock('c/quanticHeadlessLoader');
+jest.mock('c/quanticUtils', () => ({
+  loadMarkdownDependencies: jest.fn(() => Promise.resolve()),
+  transformMarkdownToHtml: jest.fn((answer) => answer),
+  LinkUtils: {
+    bindAnalyticsToLink: jest.fn(() => jest.fn()),
+  },
+  generateTextFragmentUrl: jest.fn((uri) => uri),
+}));
+jest.mock(
+  '@salesforce/label/c.quantic_CouldNotGenerateAnAnswer',
+  () => ({default: 'Could not generate an answer.'}),
+  {virtual: true}
+);
+jest.mock(
+  '@salesforce/label/c.quantic_GenericErrorTitle',
+  () => ({
+    default:
+      'Something went wrong while generating the answer. Please try again later.',
+  }),
+  {virtual: true}
+);
+jest.mock(
+  '@salesforce/label/c.quantic_GeneratedAnswerErrorTurnLimitReached',
+  () => ({
+    default:
+      'Conversation turn limit reached. Please start a new conversation.',
+  }),
+  {virtual: true}
+);
+jest.mock(
+  '@salesforce/label/c.quantic_ThisAnswerWasHelpful',
+  () => ({default: 'This answer was helpful'}),
+  {virtual: true}
+);
+jest.mock(
+  '@salesforce/label/c.quantic_ThisAnswerWasNotHelpful',
+  () => ({default: 'This answer was not helpful'}),
+  {virtual: true}
+);
+
+const defaultOptions = {
+  engineId: 'example-engine',
+  generatedAnswer: {
+    answerId: 'answer-1',
+    question: 'What is the meaning of life?',
+    answer: 'Example generated answer',
+    answerContentFormat: 'text/plain',
+    citations: [],
+    isStreaming: false,
+    liked: false,
+    disliked: false,
+    cannotAnswer: false,
+  },
+};
+
+const selectors = {
+  body: '[data-testid="generated-answer-body"]',
+  actions: '[data-testid="generated-answer-body__actions"]',
+  citations: 'c-quantic-source-citations',
+  feedback: 'c-quantic-feedback',
+  copy: 'c-quantic-generated-answer-copy-to-clipboard',
+  error: '[data-testid="generated-answer-body__error"]',
+  noAnswer: '[data-testid="generated-answer-body__no-answer-message"]',
+  content: 'c-quantic-generated-answer-content',
+};
+
+const createTestComponent = buildCreateTestComponent(
+  QuanticGeneratedAnswerBody,
+  'c-quantic-generated-answer-body',
+  defaultOptions
+);
+
+describe('c-quantic-generated-answer-body', () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  it('should pass answer and answerContentFormat to the QuanticGeneratedAnswerContent component', async () => {
+    const element = createTestComponent();
+    await flushPromises();
+
+    const content = element.shadowRoot.querySelector(selectors.content);
+
+    expect(content.answer).toBe(defaultOptions.generatedAnswer.answer);
+    expect(content.answerContentFormat).toBe(
+      defaultOptions.generatedAnswer.answerContentFormat
+    );
+  });
+
+  it('should send the answerId within event details when dispatching the #quantic__generatedanswerlike event', async () => {
+    const element = createTestComponent();
+    const handler = jest.fn();
+    element.addEventListener('quantic__generatedanswerlike', handler);
+    await flushPromises();
+
+    const feedback = element.shadowRoot.querySelector(selectors.feedback);
+    feedback.dispatchEvent(new CustomEvent('quantic__like'));
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler.mock.calls[0][0].detail).toEqual({answerId: 'answer-1'});
+  });
+
+  it('should send the answerId within event details when dispatching the #quantic__generatedanswerdislike event', async () => {
+    const element = createTestComponent();
+    const handler = jest.fn();
+    element.addEventListener('quantic__generatedanswerdislike', handler);
+    await flushPromises();
+
+    const feedback = element.shadowRoot.querySelector(selectors.feedback);
+    feedback.dispatchEvent(new CustomEvent('quantic__dislike'));
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler.mock.calls[0][0].detail).toEqual({answerId: 'answer-1'});
+  });
+
+  it('should pass the answerId to the copy-to-clipboard component', async () => {
+    const element = createTestComponent();
+    await flushPromises();
+
+    const copy = element.shadowRoot.querySelector(selectors.copy);
+
+    expect(copy.answerId).toBe('answer-1');
+  });
+
+  it('should send the answerId within event details when dispatching the #quantic__citationhover event', async () => {
+    const element = createTestComponent({
+      ...defaultOptions,
+      generatedAnswer: {
+        ...defaultOptions.generatedAnswer,
+        // @ts-ignore
+        citations: [{id: 'citation-1', title: 'Citation'}],
+      },
+    });
+    const handler = jest.fn();
+    element.addEventListener('quantic__citationhover', handler);
+    await flushPromises();
+
+    const citations = element.shadowRoot.querySelector(
+      'c-quantic-source-citations'
+    );
+    citations.citationHoverHandler('citation-1', 1200);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler.mock.calls[0][0].detail).toEqual({
+      answerId: 'answer-1',
+      citationId: 'citation-1',
+      citationHoverTimeMs: 1200,
+    });
+  });
+
+  describe('when an answer has not been generated', () => {
+    it('should render the no-answer message when the answer cannot be generated', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        generatedAnswer: {
+          ...defaultOptions.generatedAnswer,
+          cannotAnswer: true,
+        },
+      });
+      await flushPromises();
+
+      const noAnswer = element.shadowRoot.querySelector(selectors.noAnswer);
+
+      expect(noAnswer).not.toBeNull();
+    });
+  });
+
+  describe('when an error occurs', () => {
+    it('should render the generic error message when a non-retryable error occurs', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        generatedAnswer: {
+          ...defaultOptions.generatedAnswer,
+          answer: '',
+          // @ts-ignore
+          error: {code: 500},
+        },
+      });
+      await flushPromises();
+
+      const error = element.shadowRoot.querySelector(selectors.error);
+
+      expect(error).not.toBeNull();
+      expect(error.textContent).toContain(
+        'Something went wrong while generating the answer. Please try again later.'
+      );
+    });
+
+    it('should render the turn limit reached error message when the SSE turn limit is exceeded', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        generatedAnswer: {
+          ...defaultOptions.generatedAnswer,
+          answer: '',
+          // @ts-ignore
+          error: {
+            code: 429,
+            isSseTurnLimitReachedError: () => true,
+          },
+        },
+      });
+      await flushPromises();
+
+      const error = element.shadowRoot.querySelector(selectors.error);
+
+      expect(error).not.toBeNull();
+      expect(error.textContent).toContain(
+        'Conversation turn limit reached. Please start a new conversation.'
+      );
+    });
+
+    it('should render the error message even when the answer is not empty', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        generatedAnswer: {
+          ...defaultOptions.generatedAnswer,
+          answer: 'Partial answer content',
+          // @ts-ignore
+          error: {code: 500},
+        },
+      });
+      await flushPromises();
+
+      const error = element.shadowRoot.querySelector(selectors.error);
+      const content = element.shadowRoot.querySelector(selectors.content);
+
+      expect(error).not.toBeNull();
+      expect(content).toBeNull();
+    });
+  });
+
+  describe('rendering of actions', () => {
+    it('should display actions when the answer is not empty and done streaming', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const actions = element.shadowRoot.querySelector(selectors.actions);
+
+      expect(actions).not.toBeNull();
+    });
+
+    it('should not display actions while the answer is streaming', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        generatedAnswer: {
+          ...defaultOptions.generatedAnswer,
+          isStreaming: true,
+        },
+      });
+      await flushPromises();
+
+      const actions = element.shadowRoot.querySelector(selectors.actions);
+
+      expect(actions).toBeNull();
+    });
+
+    it('should not display actions when there is no answer', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        generatedAnswer: {
+          ...defaultOptions.generatedAnswer,
+          answer: '',
+        },
+      });
+      await flushPromises();
+
+      const actions = element.shadowRoot.querySelector(selectors.actions);
+
+      expect(actions).toBeNull();
+    });
+  });
+
+  describe('rendering of citations', () => {
+    it('should display citations when citations are not empty', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        generatedAnswer: {
+          ...defaultOptions.generatedAnswer,
+          // @ts-ignore
+          citations: [{id: 'citation-1', title: 'Citation'}],
+        },
+      });
+      await flushPromises();
+
+      const citations = element.shadowRoot.querySelector(selectors.citations);
+
+      expect(citations).not.toBeNull();
+    });
+
+    it('should not display citations when citations are empty', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const citations = element.shadowRoot.querySelector(selectors.citations);
+
+      expect(citations).toBeNull();
+    });
+
+    it('should not display citations while the answer is streaming', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        generatedAnswer: {
+          ...defaultOptions.generatedAnswer,
+          // @ts-ignore
+          citations: [{id: 'citation-1', title: 'Citation'}],
+          isStreaming: true,
+        },
+      });
+      await flushPromises();
+
+      const citations = element.shadowRoot.querySelector(selectors.citations);
+
+      expect(citations).toBeNull();
+    });
+  });
+
+  describe('when generatedAnswer is null', () => {
+    it('should render without errors', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        generatedAnswer: null,
+      });
+      await flushPromises();
+
+      const error = element.shadowRoot.querySelector(selectors.error);
+      const noAnswer = element.shadowRoot.querySelector(selectors.noAnswer);
+      const actions = element.shadowRoot.querySelector(selectors.actions);
+      const citations = element.shadowRoot.querySelector(selectors.citations);
+
+      expect(error).toBeNull();
+      expect(noAnswer).toBeNull();
+      expect(actions).toBeNull();
+      expect(citations).toBeNull();
+    });
+  });
+});