@coveo/quantic 3.43.0 → 3.43.2

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

@@ -89,9 +89,8 @@ const selectors = {
   generatedAnswer: '[data-testid="generated-answer__answer"]',
   generatedAnswerBadge: '[data-testid="generated-answer__header-title"]',
   generatedAnswerRetryButton: '[data-testid="generated-answer__retry-button"]',
-  generatedAnswerActions: '[data-testid="generated-answer__actions"]',
   generatedAnswerToggleButton: 'c-quantic-generated-answer-toggle',
-  generatedAnswerContent: 'c-quantic-generated-answer-content',
+  generatedAnswerBodyComponent: 'c-quantic-generated-answer-body',
   generatingMessageWhenAnswerCollapsed:
     '[data-testid="generated-answer__collapse-generating-message"]',
   generatedAnswerCollapseToggle:
@@ -101,10 +100,8 @@ const selectors = {
     '[data-testid="generated-answer__no-answer-card"]',
   generatedAnswerNoAnswerMessage:
     '[data-testid="generated-answer__no-answer-message"]',
-  generatedAnswerCitations: 'c-quantic-source-citations',
   generatedAnswerThread: 'c-quantic-generated-answer-thread',
   generatedAnswerFollowUpInput: 'c-quantic-generated-answer-follow-up-input',
-  generatedAnswerFeedback: 'c-quantic-feedback',
   loadingSpinner: 'lightning-spinner',
 };
 
@@ -128,6 +125,7 @@ const functionsMocks = {
     like: functionsMocks.like,
     dislike: functionsMocks.dislike,
     closeFeedbackModal: functionsMocks.closeFeedbackModal,
+    logCitationHover: functionsMocks.logCitationHover,
   })),
   buildSearchStatus: jest.fn(() => ({
     state: searchStatusState,
@@ -148,6 +146,7 @@ const functionsMocks = {
   like: jest.fn(),
   dislike: jest.fn(),
   closeFeedbackModal: jest.fn(),
+  logCitationHover: jest.fn(),
 };
 
 /**
@@ -504,33 +503,25 @@ describe('c-quantic-generated-answer', () => {
         });
       });
 
-      it('should display the generated answer content', async () => {
+      it('should forward the streaming answer to the generated answer body', async () => {
         const element = createTestComponent();
         await flushPromises();
 
-        const generatedAnswerContent = element.shadowRoot.querySelector(
-          selectors.generatedAnswerContent
-        );
-
-        expect(generatedAnswerContent).not.toBeNull();
-        expect(generatedAnswerContent.isStreaming).toBe(true);
-        expect(generatedAnswerContent.answer).toBe(exampleAnswer);
-        expect(generatedAnswerContent.answerContentFormat).toBe(
-          exampleAnswerContentFormat
+        const generatedAnswerBody = element.shadowRoot.querySelector(
+          selectors.generatedAnswerBodyComponent
         );
-        expect(generatedAnswerContent.engineId).toBe(exampleEngineId);
-        expect(generatedAnswerContent.answerId).toBe(exampleAnswerId);
-      });
-
-      it('should not display the generated answer actions', async () => {
-        const element = createTestComponent();
-        await flushPromises();
 
-        const generatedAnswerActions = element.shadowRoot.querySelector(
-          selectors.generatedAnswerActions
+        expect(generatedAnswerBody).not.toBeNull();
+        expect(generatedAnswerBody.engineId).toBe(exampleEngineId);
+        expect(generatedAnswerBody.disableCitationAnchoring).toBe(false);
+        expect(generatedAnswerBody.generatedAnswer).toEqual(
+          expect.objectContaining({
+            answer: exampleAnswer,
+            answerContentFormat: exampleAnswerContentFormat,
+            answerId: exampleAnswerId,
+            isStreaming: true,
+          })
         );
-
-        expect(generatedAnswerActions).toBeNull();
       });
 
       it('should not display the generated answer disclaimer in the footer', async () => {
@@ -769,38 +760,48 @@ describe('c-quantic-generated-answer', () => {
         });
       });
 
-      it('should display the generated answer content', async () => {
+      it('should forward the ready answer with citations to the generated answer body', async () => {
         const element = createTestComponent();
         await flushPromises();
 
-        const generatedAnswerContent = element.shadowRoot.querySelector(
-          selectors.generatedAnswerContent
+        const generatedAnswerBody = element.shadowRoot.querySelector(
+          selectors.generatedAnswerBodyComponent
         );
 
-        expect(generatedAnswerContent).not.toBeNull();
-        expect(generatedAnswerContent.isStreaming).toBe(false);
-        expect(generatedAnswerContent.answer).toBe(exampleAnswer);
-        expect(generatedAnswerContent.answerContentFormat).toBe(
-          exampleAnswerContentFormat
+        expect(generatedAnswerBody).not.toBeNull();
+        expect(generatedAnswerBody.engineId).toBe(exampleEngineId);
+        expect(generatedAnswerBody.disableCitationAnchoring).toBe(false);
+        expect(generatedAnswerBody.generatedAnswer).toEqual(
+          expect.objectContaining({
+            answer: exampleAnswer,
+            answerContentFormat: exampleAnswerContentFormat,
+            citations: exampleCitations,
+            isStreaming: false,
+          })
         );
       });
 
-      it('should display the generated answer actions', async () => {
-        const element = createTestComponent();
+      it('should collapse the answer when the body reports a content height exceeding the maximum collapsed height', async () => {
+        const element = createTestComponent({
+          ...defaultOptions,
+          collapsible: true,
+        });
         await flushPromises();
 
         const generatedAnswerBody = element.shadowRoot.querySelector(
-          selectors.generatedAnswerBody
+          selectors.generatedAnswerBodyComponent
         );
-        const generatedAnswerActions = element.shadowRoot.querySelector(
-          selectors.generatedAnswerActions
+        generatedAnswerBody.dispatchEvent(
+          new CustomEvent('quantic__answercontentupdated', {
+            detail: {height: defaultAnswerHeight + 100},
+          })
         );
+        await flushPromises();
 
-        expect(generatedAnswerBody).not.toBeNull();
-        expect(generatedAnswerActions).not.toBeNull();
-        expect(generatedAnswerActions.closest('section')).toBe(
-          generatedAnswerBody
+        const generatedAnswerCollapseToggle = element.shadowRoot.querySelector(
+          selectors.generatedAnswerCollapseToggle
         );
+        expect(generatedAnswerCollapseToggle).not.toBeNull();
       });
 
       it('should display the generated answer disclaimer', async () => {
@@ -833,17 +834,6 @@ describe('c-quantic-generated-answer', () => {
         expect(generatedAnswerBadge).not.toBeNull();
       });
 
-      it('should pass the disableCitationAnchoring property to the source citations component', async () => {
-        const element = createTestComponent();
-        await flushPromises();
-
-        const generatedAnswerCitations = element.shadowRoot.querySelector(
-          selectors.generatedAnswerCitations
-        );
-        expect(generatedAnswerCitations).not.toBeNull();
-        expect(generatedAnswerCitations.disableCitationAnchoring).toBe(false);
-      });
-
       describe('when follow-ups are enabled', () => {
         const exampleAgentId = 'example agent id';
         const exampleFollowUpAnswers = [
@@ -1385,6 +1375,103 @@ describe('c-quantic-generated-answer', () => {
     });
   });
 
+  describe('the citation hover event', () => {
+    const exampleAnswer = 'answer generated successfully';
+    const exampleAgentId = 'example agent id';
+    const exampleCitationId = 'citation-id-1';
+    const exampleCitationHoverTimeMs = 1500;
+
+    describe('when follow-ups are not enabled', () => {
+      beforeEach(() => {
+        generatedAnswerState = {
+          ...initialGeneratedAnswerState,
+          isStreaming: false,
+          answer: exampleAnswer,
+          answerContentFormat: 'text/markdown',
+          answerId: exampleAnswerId,
+          citations: exampleCitations,
+        };
+        mockSuccessfulHeadlessInitialization();
+        prepareHeadlessState();
+      });
+
+      afterAll(() => {
+        generatedAnswerState = initialGeneratedAnswerState;
+      });
+
+      it('should call logCitationHover on the controller with the correct parameters', async () => {
+        const element = createTestComponent();
+        await flushPromises();
+
+        const generatedAnswerBody = element.shadowRoot.querySelector(
+          selectors.generatedAnswerBodyComponent
+        );
+        generatedAnswerBody.dispatchEvent(
+          new CustomEvent('quantic__citationhover', {
+            detail: {
+              citationId: exampleCitationId,
+              citationHoverTimeMs: exampleCitationHoverTimeMs,
+              answerId: exampleAnswerId,
+            },
+          })
+        );
+        await flushPromises();
+
+        expect(functionsMocks.logCitationHover).toHaveBeenCalledTimes(1);
+        expect(functionsMocks.logCitationHover).toHaveBeenCalledWith(
+          exampleCitationId,
+          exampleCitationHoverTimeMs,
+          exampleAnswerId
+        );
+      });
+    });
+
+    describe('when follow-ups are enabled', () => {
+      beforeEach(() => {
+        generatedAnswerState = {
+          ...initialGeneratedAnswerState,
+          answer: exampleAnswer,
+          followUpAnswers: {isEnabled: true, followUpAnswers: []},
+        };
+        mockSuccessfulHeadlessInitialization();
+        prepareHeadlessState();
+      });
+
+      afterAll(() => {
+        generatedAnswerState = initialGeneratedAnswerState;
+      });
+
+      it('should call logCitationHover on the controller with the correct parameters', async () => {
+        const element = createTestComponent({
+          ...defaultOptions,
+          agentId: exampleAgentId,
+        });
+        await flushPromises();
+
+        const thread = element.shadowRoot.querySelector(
+          selectors.generatedAnswerThread
+        );
+        thread.dispatchEvent(
+          new CustomEvent('quantic__citationhover', {
+            detail: {
+              citationId: exampleCitationId,
+              citationHoverTimeMs: exampleCitationHoverTimeMs,
+              answerId: exampleAnswerId,
+            },
+          })
+        );
+        await flushPromises();
+
+        expect(functionsMocks.logCitationHover).toHaveBeenCalledTimes(1);
+        expect(functionsMocks.logCitationHover).toHaveBeenCalledWith(
+          exampleCitationId,
+          exampleCitationHoverTimeMs,
+          exampleAnswerId
+        );
+      });
+    });
+  });
+
   describe('the generated answer feedback', () => {
     const exampleAnswer = 'answer generated successfully';
     const exampleAgentId = 'example agent id';
@@ -1392,19 +1479,17 @@ describe('c-quantic-generated-answer', () => {
     describe.each([
       {
         action: 'like',
-        feedbackEvent: 'quantic__like',
         threadEvent: 'quantic__generatedanswerlike',
         controllerMethod: 'like',
       },
       {
         action: 'dislike',
-        feedbackEvent: 'quantic__dislike',
         threadEvent: 'quantic__generatedanswerdislike',
         controllerMethod: 'dislike',
       },
     ])(
       'when the user clicks the $action button',
-      ({feedbackEvent, threadEvent, controllerMethod}) => {
+      ({threadEvent, controllerMethod}) => {
         describe('when follow-ups are not enabled', () => {
           beforeEach(() => {
             generatedAnswerState = {
@@ -1427,11 +1512,11 @@ describe('c-quantic-generated-answer', () => {
             const element = createTestComponent();
             await flushPromises();
 
-            const feedback = element.shadowRoot.querySelector(
-              selectors.generatedAnswerFeedback
+            const generatedAnswerBody = element.shadowRoot.querySelector(
+              selectors.generatedAnswerBodyComponent
             );
-            feedback.dispatchEvent(
-              new CustomEvent(feedbackEvent, {
+            generatedAnswerBody.dispatchEvent(
+              new CustomEvent(threadEvent, {
                 detail: {answerId: exampleAnswerId},
               })
             );

package/force-app/main/default/lwc/quanticGeneratedAnswer/e2e/fixture-agent.ts

@@ -46,7 +46,6 @@ export const testAgent =
         {
           headAnswerRequestRegex: agentAnswerRequestRegex,
           agentFollowUpRequestRegex,
-          isAgent: true,
         }
       );
 
@@ -56,7 +55,8 @@ export const testAgent =
       await generatedAnswerObject.mockAgentFollowUpResponse(
         data.followUpStreams
       );
-
+      
+      await search.mockSearchWithBaseResponse();
       await page.goto(pageUrl);
       await configuration.configure(options);
       await search.waitForSearchResponse();
@@ -67,7 +67,7 @@ export const testAgent =
         generatedAnswerObject.waitForHeadAnswerRequest();
 
       await search.fillSearchInput(exampleQuery);
-      await search.performSearch();
+      search.performSearch();
       await search.waitForSearchResponse();
 
       await use(generatedAnswerObject);

package/force-app/main/default/lwc/quanticGeneratedAnswer/e2e/fixture.ts

@@ -89,6 +89,7 @@ export const testSearch =
         data.streamId
       );
 
+      await search.mockSearchWithBaseResponse();
       await page.goto(pageUrl);
       if (withFacets) {
         await generatedAnswerObject.clickAddFacetsButton();
@@ -104,10 +105,12 @@ export const testSearch =
           generatedAnswerObject.waitForHeadAnswerRequest();
       }
 
-      await search.fillSearchInput(exampleQuery);
       await search.mockSearchWithGenerativeQuestionAnsweringId(data.streamId);
-      await search.performSearch();
-      await search.waitForSearchResponse();
+      await search.fillSearchInput(exampleQuery);
+      await Promise.all([
+        search.waitForSearchResponse(),
+        search.performSearch(),
+      ]);
 
       await use(generatedAnswerObject);
     },
@@ -162,17 +165,14 @@ export const testInsight =
         data.streamId
       );
 
+      await search.mockSearchWithBaseResponse();
       await page.goto(pageUrl);
       if (withFacets) {
         await generatedAnswerObject.clickAddFacetsButton();
       }
       configuration.configure({...options, useCase: useCaseEnum.insight});
-
       await insightSetup.waitForInsightInterfaceInitialization();
-      await search.performSearch();
-      await search.waitForSearchResponse();
 
-      await search.mockSearchWithGenerativeQuestionAnsweringId(data.streamId);
       generatedAnswerObject.streamEndAnalyticRequestPromise =
         generatedAnswerObject.waitForStreamEndAnalytics();
       if (options.answerConfigurationId) {
@@ -180,9 +180,12 @@ export const testInsight =
           generatedAnswerObject.waitForHeadAnswerRequest();
       }
 
+      await search.mockSearchWithGenerativeQuestionAnsweringId(data.streamId);
       await search.fillSearchInput(exampleQuery);
-      await search.performSearch();
-      await search.waitForSearchResponse();
+      await Promise.all([
+        search.waitForSearchResponse(),
+        search.performSearch(),
+      ]);
 
       await use(generatedAnswerObject);
     },

package/force-app/main/default/lwc/quanticGeneratedAnswer/e2e/pageObject.ts

@@ -29,7 +29,6 @@ export interface GeneratedAnswerObjectConfig {
   answerApiEnabled?: boolean;
   headAnswerRequestRegex?: RegExp;
   agentFollowUpRequestRegex?: RegExp;
-  isAgent?: boolean;
   withFacets?: boolean;
 }
 
@@ -39,7 +38,6 @@ export class GeneratedAnswerObject {
   private headAnswerRequestRegex?: RegExp;
   private agentFollowUpRequestRegex?: RegExp;
   private withFacets: boolean;
-  private isAgent: boolean;
 
   constructor(
     private page: Page,
@@ -55,15 +53,14 @@ export class GeneratedAnswerObject {
     this.headAnswerRequestRegex = config.headAnswerRequestRegex;
     this.agentFollowUpRequestRegex = config.agentFollowUpRequestRegex;
     this.withFacets = config.withFacets ?? false;
-    this.isAgent = config.isAgent ?? false;
   }
 
   get likeButton(): Locator {
-    return this.page.getByRole('button', {name: this.isAgent ? 'Like' : 'This answer was helpful', exact: true});
+    return this.page.getByRole('button', {name: 'Like', exact: true});
   }
 
   get dislikeButton(): Locator {
-    return this.page.getByRole('button', {name: this.isAgent ? 'Dislike' : 'This answer was not helpful', exact: true});
+    return this.page.getByRole('button', {name: 'Dislike', exact: true});
   }
 
   get copyToClipboardButton(): Locator {
@@ -132,7 +129,7 @@ export class GeneratedAnswerObject {
 
   get citationLink(): Locator {
     return this.page
-      .getByTestId(this.isAgent ? 'generated-answer-body__citations' : 'generated-answer__citations')
+      .getByTestId('generated-answer-body__citations')
       .locator('.citation__link');
   }
 
@@ -157,8 +154,8 @@ export class GeneratedAnswerObject {
   }
 
   async hoverOverCitation(index: number): Promise<void> {
-    // waiting 500ms to allow the component to render completely, cause any re-rendering abort the hover action.
-    await this.page.waitForTimeout(500);
+    // waiting 1000ms to allow the component to render completely, cause any re-rendering abort the hover action.
+    await this.page.waitForTimeout(1000);
     await this.citationLink.nth(index).hover();
     await this.page.waitForTimeout(minimumCitationTooltipDisplayDurationMs);
     await this.page.mouse.move(0, 0);

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

@@ -1,23 +1,14 @@
 import answerGenerated from '@salesforce/label/c.quantic_AnswerGenerated';
 import couldNotGenerateAnAnswer from '@salesforce/label/c.quantic_CouldNotGenerateAnAnswer';
-import feedback from '@salesforce/label/c.quantic_Feedback';
 import feedbackHelpUsImprove from '@salesforce/label/c.quantic_FeedbackHelpUsImprove';
 import generatedAnswerForYou from '@salesforce/label/c.quantic_GeneratedAnswerForYou';
 import generatedAnswerIsHidden from '@salesforce/label/c.quantic_GeneratedAnswerIsHidden';
 import showLess from '@salesforce/label/c.quantic_GeneratedAnswerShowLess';
 import showMore from '@salesforce/label/c.quantic_GeneratedAnswerShowMore';
 import generatingAnswer from '@salesforce/label/c.quantic_GeneratingAnswer';
-import harmful from '@salesforce/label/c.quantic_Harmful';
-import inaccurate from '@salesforce/label/c.quantic_Inaccurate';
-import irrelevant from '@salesforce/label/c.quantic_Irrelevant';
 import loading from '@salesforce/label/c.quantic_Loading';
-import other from '@salesforce/label/c.quantic_Other';
-import outOfDate from '@salesforce/label/c.quantic_OutOfDate';
 import rgaDisclaimer from '@salesforce/label/c.quantic_RGADisclaimer';
-import thisAnswerWasHelpful from '@salesforce/label/c.quantic_ThisAnswerWasHelpful';
-import thisAnswerWasNotHelpful from '@salesforce/label/c.quantic_ThisAnswerWasNotHelpful';
 import tryAgain from '@salesforce/label/c.quantic_TryAgain';
-import whyGeneratedAnswerWasNotHelpful from '@salesforce/label/c.quantic_WhyGeneratedAnswerWasNotHelpful';
 import noGeneratedAnswer from '@salesforce/label/c.quantic_NoGeneratedAnswer';
 import FeedbackModalQna from 'c/quanticFeedbackModalQna';
 import {
@@ -25,7 +16,7 @@ import {
   initializeWithHeadless,
   getHeadlessBundle,
 } from 'c/quanticHeadlessLoader';
-import {AriaLiveRegion, I18nUtils, getAbsoluteHeight} from 'c/quanticUtils';
+import {AriaLiveRegion, I18nUtils} from 'c/quanticUtils';
 import {LightningElement, api} from 'lwc';
 // @ts-ignore
 import errorTemplate from './templates/errorTemplate.html';
@@ -42,15 +33,9 @@ import conversationTemplate from './templates/conversation.html';
 /** @typedef {import("coveo").GeneratedAnswer} GeneratedAnswer */
 /** @typedef {import("coveo").GeneratedAnswerWithFollowUps} GeneratedAnswerWithFollowUps */
 /** @typedef {import("coveo").GeneratedAnswerState} GeneratedAnswerState */
-/** @typedef {import("coveo").GeneratedAnswerCitation} GeneratedAnswerCitation */
-/** @typedef { 'neutral' | 'liked' | 'disliked'} FeedbackState */
 /** @typedef {import("coveo").SearchStatus} SearchStatus */
 /** @typedef {import("coveo").SearchStatusState} SearchStatusState */
 
-const FEEDBACK_LIKED_STATE = 'liked';
-const FEEDBACK_DISLIKED_STATE = 'disliked';
-const FEEDBACK_NEUTRAL_STATE = 'neutral';
-
 const DEFAULT_COLLAPSED_HEIGHT = 250;
 const MAX_VALID_COLLAPSED_HEIGHT = 500;
 const MIN_VALID_COLLAPSED_HEIGHT = 150;
@@ -143,18 +128,9 @@ export default class QuanticGeneratedAnswer extends LightningElement {
 
   labels = {
     generatedAnswerForYou,
-    thisAnswerWasNotHelpful,
-    thisAnswerWasHelpful,
     tryAgain,
     couldNotGenerateAnAnswer,
-    other,
-    harmful,
-    irrelevant,
-    inaccurate,
-    outOfDate,
     feedbackHelpUsImprove,
-    feedback,
-    whyGeneratedAnswerWasNotHelpful,
     generatingAnswer,
     generatedAnswerIsHidden,
     answerGenerated,
@@ -169,8 +145,6 @@ export default class QuanticGeneratedAnswer extends LightningElement {
   generatedAnswer;
   /** @type {GeneratedAnswerState} */
   state;
-  /** @type {FeedbackState} */
-  feedbackState = 'neutral';
   /** @type {SearchStatus} */
   searchStatus;
   /** @type {SearchStatusState} */
@@ -185,6 +159,8 @@ export default class QuanticGeneratedAnswer extends LightningElement {
   _exceedsMaximumHeight = false;
   /** @type {number} */
   _maxCollapsedHeight = DEFAULT_COLLAPSED_HEIGHT;
+  /** @type {number} */
+  generatedAnswerHeight = 0;
 
   connectedCallback() {
     registerComponentForInit(this, this.engineId);
@@ -266,7 +242,6 @@ export default class QuanticGeneratedAnswer extends LightningElement {
 
   updateState() {
     this.state = this.generatedAnswer.state;
-    this.updateFeedbackState();
     this.ariaLiveMessage.dispatchMessage(this.getGeneratedAnswerStatus());
 
     if (this.isCollapsibleEnabled) {
@@ -278,8 +253,8 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     // If we are still streaming add a little extra height to the answer element to account for the next answer chunk.
     // This helps a lot with the jankyness of the answer fading out when the chunk is close but not yet over the max height.
     const answerElementHeight = this.isStreaming
-      ? this.generatedAnswerElementHeight + 50
-      : this.generatedAnswerElementHeight;
+      ? this.generatedAnswerHeight + 50
+      : this.generatedAnswerHeight;
 
     return answerElementHeight > this.maxCollapsedHeight;
   }
@@ -309,25 +284,6 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     this.searchStatusState = this.searchStatus.state;
   }
 
-  updateFeedbackState() {
-    if (this.state?.liked) {
-      this.feedbackState = FEEDBACK_LIKED_STATE;
-    } else if (this.state?.disliked) {
-      this.feedbackState = FEEDBACK_DISLIKED_STATE;
-    } else {
-      this.feedbackState = FEEDBACK_NEUTRAL_STATE;
-    }
-  }
-
-  /**
-   * handles hovering over a citation.
-   * @param {string} id
-   * @param {number} citationHoverTimeMs
-   */
-  logCitationHover = (id, citationHoverTimeMs) => {
-    this.generatedAnswer.logCitationHover(id, citationHoverTimeMs);
-  };
-
   /**
    * handles liking the generated answer.
    * @param {CustomEvent} event
@@ -420,6 +376,7 @@ export default class QuanticGeneratedAnswer extends LightningElement {
 
   handleAnswerContentUpdated = (event) => {
     event.stopPropagation();
+    this.generatedAnswerHeight = event.detail?.height;
     if (this.isCollapsibleEnabled) {
       this._exceedsMaximumHeight = this.isMaximumHeightExceeded();
     }
@@ -453,15 +410,6 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     return this.template.querySelector('.generated-answer__answer');
   }
 
-  /**
-   * Returns the generated answer height.
-   * @returns {number}
-   */
-  get generatedAnswerElementHeight() {
-    // @ts-ignore
-    return getAbsoluteHeight(this.generatedAnswerElement?.firstChild);
-  }
-
   /**
    * Sets the value of the CSS variable "--maxHeight" to the value of the maxCollapsedHeight property.
    */
@@ -476,31 +424,14 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     return this?.state?.answer;
   }
 
-  get answerId() {
-    return this?.state?.answerId;
-  }
-
   get citations() {
     return this?.state?.citations;
   }
 
-  get answerContentFormat() {
-    return this?.state?.answerContentFormat;
-  }
-
-  get shouldDisplayCitations() {
-    const hasCitations = !!this.citations?.length;
-    return hasCitations && !this.isAnswerCollapsed;
-  }
-
   get isStreaming() {
     return this?.state?.isStreaming;
   }
 
-  get shouldDisplayActions() {
-    return this.isVisible && !this.isStreaming && !this.isAnswerCollapsed;
-  }
-
   get isVisible() {
     return this.state.isVisible;
   }
@@ -527,15 +458,18 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     );
   }
 
-  get allGeneratedAnswers() {
-    const initialAnswer = {
+  get initialAnswer() {
+    return {
       ...this.state,
       question: this.engine?.state.query?.q ?? '',
     };
+  }
+
+  get allGeneratedAnswers() {
     const followUpAnswers =
       this.generateAnswerWithFollowUps?.state.followUpAnswers
         ?.followUpAnswers ?? [];
-    return [initialAnswer, ...followUpAnswers];
+    return [this.initialAnswer, ...followUpAnswers];
   }
 
   get isCollapsibleEnabled() {
@@ -566,36 +500,6 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     return !this?.searchStatusState?.hasError && this.state?.error?.isRetryable;
   }
 
-  /**
-   * Returns the options displayed in the Quantic Feedback Modal.
-   */
-  get options() {
-    return [
-      {
-        label: this.labels.irrelevant,
-        value: 'irrelevant',
-      },
-      {
-        label: this.labels.inaccurate,
-        value: 'notAccurate',
-      },
-      {
-        label: this.labels.outOfDate,
-        value: 'outOfDate',
-      },
-      {
-        label: this.labels.harmful,
-        value: 'harmful',
-      },
-      {
-        label: this.labels.other,
-        value: 'other',
-        withDetails: true,
-        detailsRequired: true,
-      },
-    ];
-  }
-
   get generatedAnswerHeaderClass() {
     const headerBaseClass =
       'generated-answer__card-header slds-grid slds-grid_vertical-align-center slds-grid_align-spread slds-p-horizontal_large slds-p-vertical_small';