@coveo/quantic 3.39.1 → 3.40.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/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/quanticGeneratedAnswerContent/__tests__/quanticGeneratedAnswerContent.test.js

@@ -1,8 +1,11 @@
+/* eslint-disable no-import-assign */
 // @ts-ignore
 import QuanticGeneratedAnswerContent from 'c/quanticGeneratedAnswerContent';
 import {createElement} from 'lwc';
 import {loadMarkdownDependencies} from 'c/quanticUtils';
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
 
+jest.mock('c/quanticHeadlessLoader');
 jest.mock('c/quanticUtils', () => ({
   loadMarkdownDependencies: jest.fn(
     () =>
@@ -11,6 +14,9 @@ jest.mock('c/quanticUtils', () => ({
       })
   ),
   transformMarkdownToHtml: jest.fn((value) => value),
+  LinkUtils: {
+    bindAnalyticsToLink: jest.fn(() => jest.fn()),
+  },
 }));
 
 const mockMarkedUse = jest.fn();
@@ -23,14 +29,47 @@ global.marked = {
 const SELECTORS = {
   textAnswerContainer: 'span.generated-answer-content__answer',
   markdownAnswerContainer: 'div.generated-answer-content__answer',
+  inlineLink: 'a[data-answer-inline-link]',
+  inlineLinkIconContainer: 'span.slds-icon_container',
+  inlineLinkIconSvg: 'svg.slds-icon',
 };
 
+const exampleEngineId = 'example-engine-id';
+const exampleAnswerId = 'example-answer-id';
+
 const defaultOptions = {
   isStreaming: false,
   answerContentFormat: 'text/plain',
   answer: '',
 };
 
+const exampleEngine = {id: 'dummy-engine'};
+let isInitialized = false;
+
+const mockBuildInteractiveGeneratedAnswerInlineLink = jest.fn(() => ({
+  select: jest.fn(),
+  beginDelayedSelect: jest.fn(),
+  cancelPendingSelect: jest.fn(),
+}));
+
+function prepareHeadlessState() {
+  // @ts-ignore
+  mockHeadlessLoader.getHeadlessBundle = () => ({
+    buildInteractiveGeneratedAnswerInlineLink:
+      mockBuildInteractiveGeneratedAnswerInlineLink,
+  });
+}
+
+function mockSuccessfulHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
+    if (element instanceof QuanticGeneratedAnswerContent && !isInitialized) {
+      isInitialized = true;
+      initialize(exampleEngine);
+    }
+  };
+}
+
 function createTestComponent(options = defaultOptions) {
   const element = createElement('c-quantic-generated-answer-content', {
     is: QuanticGeneratedAnswerContent,
@@ -43,6 +82,20 @@ function createTestComponent(options = defaultOptions) {
   return element;
 }
 
+/**
+ * Builds an HTML string containing anchor tags with the data-answer-inline-link
+ * attribute, which is what the component's processInlineLinks method targets.
+ * @param {Array<{href: string, text: string}>} links
+ * @returns {string}
+ */
+function buildAnswerWithInlineLinks(links) {
+  return links
+    .map(
+      ({href, text}) => `<a href="${href}" data-answer-inline-link>${text}</a>`
+    )
+    .join(' ');
+}
+
 // Helper function to wait until the microtask queue is empty.
 function flushPromises() {
   // eslint-disable-next-line @lwc/lwc/no-async-operation
@@ -56,6 +109,7 @@ describe('c-quantic-generated-answer-content', () => {
       document.body.removeChild(document.body.firstChild);
     }
     jest.clearAllMocks();
+    isInitialized = false;
   }
 
   afterEach(() => {
@@ -148,4 +202,219 @@ describe('c-quantic-generated-answer-content', () => {
       expect(loadMarkdownDependencies).toHaveBeenCalled();
     });
   });
+
+  describe('inline links in a markdown answer', () => {
+    const exampleLinks = [
+      {href: 'https://example.com/1', text: 'Link one'},
+      {href: 'https://example.com/2', text: 'Link two'},
+    ];
+
+    beforeEach(() => {
+      mockSuccessfulHeadlessInitialization();
+      prepareHeadlessState();
+    });
+
+    describe('when the answer contains anchors with data-answer-inline-link', () => {
+      it('should set target="_blank" and append an icon span to each inline link anchor', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(jest.fn());
+
+        const element = createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        const answerContainer = element.shadowRoot.querySelector(
+          SELECTORS.markdownAnswerContainer
+        );
+        const anchors = answerContainer.querySelectorAll(SELECTORS.inlineLink);
+
+        expect(anchors).toHaveLength(exampleLinks.length);
+        anchors.forEach((anchor) => {
+          expect(anchor.target).toBe('_blank');
+        });
+        anchors.forEach((anchor) => {
+          const iconSpan = anchor.querySelector(
+            SELECTORS.inlineLinkIconContainer
+          );
+          expect(iconSpan).not.toBeNull();
+          expect(iconSpan.classList).toContain('slds-icon-utility-new_window');
+          expect(iconSpan.classList).toContain('slds-current-color');
+          expect(
+            iconSpan.querySelector(SELECTORS.inlineLinkIconSvg)
+          ).not.toBeNull();
+        });
+      });
+
+      it('should call buildInteractiveGeneratedAnswerInlineLink with the correct parameters for each inline link', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(jest.fn());
+
+        createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        expect(
+          mockBuildInteractiveGeneratedAnswerInlineLink
+        ).toHaveBeenCalledTimes(exampleLinks.length);
+        expect(LinkUtils.bindAnalyticsToLink).toHaveBeenCalledTimes(
+          exampleLinks.length
+        );
+
+        exampleLinks.forEach((anchor, index) => {
+          expect(
+            mockBuildInteractiveGeneratedAnswerInlineLink
+          ).toHaveBeenNthCalledWith(index + 1, exampleEngine, {
+            options: {
+              link: {
+                linkURL: anchor.href,
+                linkText: anchor.text,
+              },
+              answerId: exampleAnswerId,
+            },
+          });
+        });
+      });
+
+      it('should call LinkUtils.bindAnalyticsToLink for each inline link with the anchor and its controller', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        const mockUnbind = jest.fn();
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(mockUnbind);
+
+        const element = createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        expect(LinkUtils.bindAnalyticsToLink).toHaveBeenCalledTimes(
+          exampleLinks.length
+        );
+
+        const answerContainer = element.shadowRoot.querySelector(
+          SELECTORS.markdownAnswerContainer
+        );
+        const anchors = Array.from(
+          answerContainer.querySelectorAll(SELECTORS.inlineLink)
+        );
+
+        anchors.forEach((anchor, index) => {
+          expect(LinkUtils.bindAnalyticsToLink).toHaveBeenNthCalledWith(
+            index + 1,
+            anchor,
+            expect.objectContaining({
+              select: expect.any(Function),
+              beginDelayedSelect: expect.any(Function),
+              cancelPendingSelect: expect.any(Function),
+            })
+          );
+        });
+      });
+    });
+
+    describe('when the answer does not contain anchors with data-answer-inline-link', () => {
+      it('should not call buildInteractiveGeneratedAnswerInlineLink and LinkUtils.bindAnalyticsToLink', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+
+        createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: '<p>No inline links here</p>',
+        });
+        await flushPromises();
+
+        expect(
+          mockBuildInteractiveGeneratedAnswerInlineLink
+        ).not.toHaveBeenCalled();
+        expect(LinkUtils.bindAnalyticsToLink).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when the headless bundle does not expose buildInteractiveGeneratedAnswerInlineLink', () => {
+      it('should not throw and should not call LinkUtils.bindAnalyticsToLink', async () => {
+        // @ts-ignore
+        mockHeadlessLoader.getHeadlessBundle = () => ({});
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+
+        expect(() => {
+          createTestComponent({
+            ...defaultOptions,
+            engineId: exampleEngineId,
+            answerId: exampleAnswerId,
+            answerContentFormat: 'text/markdown',
+            answer: buildAnswerWithInlineLinks(exampleLinks),
+          });
+        }).not.toThrow();
+
+        await flushPromises();
+
+        expect(LinkUtils.bindAnalyticsToLink).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when the answer is updated', () => {
+      it('should clean up previous inline link bindings before processing the new answer', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        const mockUnbind = jest.fn();
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(mockUnbind);
+
+        const element = createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        expect(mockUnbind).not.toHaveBeenCalled();
+
+        const updatedLinks = [
+          {href: 'https://example.com/3', text: 'Link three'},
+        ];
+        element.answer = buildAnswerWithInlineLinks(updatedLinks);
+        await flushPromises();
+
+        expect(mockUnbind).toHaveBeenCalledTimes(exampleLinks.length);
+      });
+    });
+
+    describe('when the component is disconnected', () => {
+      it('should call the unbind function for each inline link binding', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        const mockUnbind = jest.fn();
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(mockUnbind);
+
+        const element = createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        expect(mockUnbind).not.toHaveBeenCalled();
+
+        document.body.removeChild(element);
+        await flushPromises();
+
+        expect(mockUnbind).toHaveBeenCalledTimes(exampleLinks.length);
+      });
+    });
+  });
 });

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

@@ -1,6 +1,12 @@
+import {
+  registerComponentForInit,
+  initializeWithHeadless,
+  getHeadlessBundle,
+} from 'c/quanticHeadlessLoader';
 import {
   transformMarkdownToHtml,
   loadMarkdownDependencies,
+  LinkUtils,
 } from 'c/quanticUtils';
 import {LightningElement, api} from 'lwc';
 // @ts-ignore
@@ -8,6 +14,21 @@ import generatedMarkdownContentTemplate from './templates/generatedMarkdownConte
 // @ts-ignore
 import generatedTextContentTemplate from './templates/generatedTextContent.html';
 
+/** @typedef {import("coveo").SearchEngine} SearchEngine */
+/** @typedef {import("coveo").InsightEngine} InsightEngine */
+
+const INLINE_LINK_ICON = `
+  <svg
+    class="slds-icon answer-content__link-icon-svg"
+    aria-hidden="true"
+    focusable="false"
+    viewBox="0 0 52 52"
+  >
+    <path d="M48.5 2h-15c-.8 0-1.5.7-1.5 1.5v3c0 .8.7 1.5 1.5 1.5h6.4L22.1 25.8c-.6.6-.6 1.5 0 2.1l2.1 2.1c.6.6 1.5.6 2.1 0L44 12.3v6.2c0 .8.7 1.5 1.5 1.5h3c.8 0 1.5-.7 1.5-1.5v-15c0-.8-.7-1.5-1.5-1.5z"></path>
+    <path d="M38 28.5V46H8V16h17.5c.8 0 1.5-.7 1.5-1.5v-3c0-.8-.7-1.5-1.5-1.5H6c-2.2 0-4 1.8-4 4v34c0 2.2 1.8 4 4 4h34c2.2 0 4-1.8 4-4V28.5c0-.8-.7-1.5-1.5-1.5h-3c-.8 0-1.5.7-1.5 1.5z"></path>
+  </svg>
+`;
+
 /**
  * The `QuanticGeneratedAnswerContent` component displays the generated answer content.
  * @category Internal
@@ -16,6 +37,18 @@ import generatedTextContentTemplate from './templates/generatedTextContent.html'
  * <c-quantic-generated-answer-content answer-content-format={answerContentFormat} answer={answer} is-streaming={isStreaming}></c-quantic-generated-answer-content>
  */
 export default class QuanticGeneratedAnswerContent extends LightningElement {
+  /**
+   * The ID of the engine instance the component registers to.
+   * @api
+   * @type {string}
+   */
+  @api engineId;
+  /**
+   * The unique identifier of the generated answer.
+   * @api
+   * @type {string}
+   */
+  @api answerId;
   /**
    * If the answer is streaming, it will render a blinking cursor at the end of the answer.
    * @api
@@ -65,6 +98,32 @@ export default class QuanticGeneratedAnswerContent extends LightningElement {
   /** @type {'text/plain' | 'text/markdown'} */
   _answerContentFormat = 'text/plain';
   _markdownDependenciesLoaded = false;
+  /** @type {Array<function>} */
+  _inlineLinkBindings = [];
+  /** @type {AnyHeadless} */
+  headless;
+  /** @type {SearchEngine | InsightEngine} */
+  engine;
+
+  connectedCallback() {
+    registerComponentForInit(this, this.engineId);
+  }
+
+  renderedCallback() {
+    initializeWithHeadless(this, this.engineId, this.initialize);
+  }
+
+  /**
+   * @param {SearchEngine | InsightEngine} engine
+   */
+  initialize = (engine) => {
+    this.headless = getHeadlessBundle(this.engineId);
+    this.engine = engine;
+  };
+
+  disconnectedCallback() {
+    this.cleanUpInlineLinkBindings();
+  }
 
   loadMarkdownDependencies() {
     if (
@@ -105,6 +164,7 @@ export default class QuanticGeneratedAnswerContent extends LightningElement {
           // eslint-disable-next-line @lwc/lwc/no-inner-html
           answerContainer.innerHTML = newHTMLContent;
         }
+        this.processInlineLinks(answerContainer);
       }
     }
     // Fallback to display answer as text if the Marked library failed to load
@@ -114,6 +174,82 @@ export default class QuanticGeneratedAnswerContent extends LightningElement {
     this.dispatchEvent(new CustomEvent('quantic__answercontentupdated'));
   }
 
+  /**
+   * Decorates each inline link with an icon and binds analytics, replacing any previous bindings.
+   * @param {Element|null} answerContainer
+   */
+  processInlineLinks(answerContainer) {
+    if (!answerContainer) {
+      return;
+    }
+    this.cleanUpInlineLinkBindings();
+    /** @type {NodeListOf<HTMLAnchorElement>} */
+    const anchors = answerContainer.querySelectorAll(
+      'a[data-answer-inline-link]'
+    );
+    anchors.forEach((anchor) => {
+      anchor.target = '_blank';
+      anchor.rel = 'noopener';
+      this.bindAnalyticsToInlineLink(anchor);
+      this.appendInlineLinkIcon(anchor);
+    });
+  }
+
+  /**
+   * Appends the external link icon to the given anchor.
+   * @param {HTMLAnchorElement} anchor
+   */
+  appendInlineLinkIcon(anchor) {
+    const icon = document.createElement('span');
+    icon.classList.add(
+      'slds-icon_container',
+      'slds-icon-utility-new_window',
+      'slds-current-color',
+      'slds-m-left_xxx-small',
+      'answer-content__link-icon'
+    );
+    // eslint-disable-next-line @lwc/lwc/no-inner-html
+    icon.innerHTML = INLINE_LINK_ICON;
+    anchor.appendChild(icon);
+  }
+
+  /**
+   * Creates an `InteractiveGeneratedAnswerInlineLink` controller for the given anchor
+   * and binds analytics event listeners to it.
+   * @param {HTMLAnchorElement} anchor
+   */
+  bindAnalyticsToInlineLink(anchor) {
+    if (
+      !this.headless?.buildInteractiveGeneratedAnswerInlineLink ||
+      !this.engine
+    ) {
+      return;
+    }
+    const controller = this.headless.buildInteractiveGeneratedAnswerInlineLink(
+      this.engine,
+      {
+        options: {
+          link: {
+            linkURL: anchor.getAttribute('href') || '',
+            linkText: anchor.textContent?.trim() || '',
+          },
+          answerId: this.answerId,
+        },
+      }
+    );
+    this._inlineLinkBindings.push(
+      LinkUtils.bindAnalyticsToLink(anchor, controller)
+    );
+  }
+
+  /**
+   * Cleans up all inline link bindings.
+   */
+  cleanUpInlineLinkBindings() {
+    this._inlineLinkBindings.forEach((remove) => remove());
+    this._inlineLinkBindings = [];
+  }
+
   get generatedAnswerContentClass() {
     return `generated-answer-content__answer ${this.isStreaming ? 'generated-answer-content__answer--streaming' : ''}`;
   }

package/force-app/main/default/lwc/quanticGeneratedAnswerContent/templates/generatedMarkdownContent.css

@@ -152,3 +152,13 @@ tbody tr td:first-of-type {
 tbody tr td:last-of-type td {
   border-bottom: unset;
 }
+
+.answer-content__link-icon-svg {
+  width: 0.625rem;
+  height: 0.625rem;
+  fill: currentColor;
+}
+
+.answer-content__link-icon {
+  display: inline-flex;
+}

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

@@ -67,5 +67,43 @@ describe('c/markdownUtils', () => {
       const resultCode = transformMarkdownToHtml(textCode, marked);
       expect(removeLineBreaks(resultCode)).toEqual('<p><code>code</code></p>');
     });
+
+    it('should transform markdown link to HTML <a> with data-answer-inline-link attribute', () => {
+      const text = '[Google](https://google.com)';
+      const result = transformMarkdownToHtml(text, marked);
+      expect(removeLineBreaks(result)).toEqual(
+        '<p><a href="https://google.com" data-answer-inline-link="true">Google</a></p>'
+      );
+    });
+
+    it('should transform markdown link with title to HTML <a> with title attribute', () => {
+      const text = '[Google](https://google.com "Search Engine")';
+      const result = transformMarkdownToHtml(text, marked);
+      expect(removeLineBreaks(result)).toEqual(
+        '<p><a href="https://google.com" title="Search Engine" data-answer-inline-link="true">Google</a></p>'
+      );
+    });
+
+    it('should escape special characters in link href', () => {
+      const text = '[Link](https://example.com?param="value"&other=test)';
+      const result = transformMarkdownToHtml(text, marked);
+      expect(removeLineBreaks(result)).toEqual(
+        '<p><a href="https://example.com?param=&quot;value&quot;&amp;other=test" data-answer-inline-link="true">Link</a></p>'
+      );
+    });
+
+    it('should escape special characters in link title', () => {
+      const text = '[Link](https://example.com "Title with <script> & quotes")';
+      const result = transformMarkdownToHtml(text, marked);
+      expect(removeLineBreaks(result)).toEqual(
+        '<p><a href="https://example.com" title="Title with &amp;lt;script&amp;gt; &amp;amp; quotes" data-answer-inline-link="true">Link</a></p>'
+      );
+    });
+
+    it('should render link text as span when href is missing', () => {
+      const text = '[Link]()';
+      const result = transformMarkdownToHtml(text, marked);
+      expect(removeLineBreaks(result)).toEqual('<p><span>Link</span></p>');
+    });
   });
 });

package/force-app/main/default/lwc/quanticUtils/markdownUtils.js

@@ -117,6 +117,24 @@ const customRenderer = {
   text(text) {
     return completeUnclosedElement(text);
   },
+
+  /**
+   * Custom Marked renderer for links.
+   * @param {string} href The link href.
+   * @param {string} title The link title.
+   * @param {string} text The link text.
+   * @returns {string} The link element to render.
+   */
+  link(href, title, text) {
+    const titleAttribute = title ? ` title="${escapeHtml(title)}"` : '';
+    const safeHref = href ? escapeHtml(href) : '';
+
+    if (!safeHref) {
+      return `<span>${text}</span>`;
+    }
+
+    return `<a href="${safeHref}"${titleAttribute} data-answer-inline-link="true">${text}</a>`;
+  },
 };
 
 /**

package/force-app/main/default/staticresources/coveoheadless/case-assist/headless.js

@@ -75,4 +75,4 @@ fast-json-patch/module/duplex.mjs:
    *)
 */if(__exports!=exports)module.exports=exports;return module.exports});
 
-window.coveoQuanticVersion = '3.39.1';
+window.coveoQuanticVersion = '3.40.0';

package/force-app/main/default/staticresources/coveoheadless/headless.js

@@ -79,4 +79,4 @@ fast-json-patch/module/duplex.mjs:
    *)
 */if(__exports!=exports)module.exports=exports;return module.exports});
 
-window.coveoQuanticVersion = '3.39.1';
+window.coveoQuanticVersion = '3.40.0';

package/force-app/main/default/staticresources/coveoheadless/insight/headless.js

@@ -76,4 +76,4 @@ fast-json-patch/module/duplex.mjs:
    *)
 */if(__exports!=exports)module.exports=exports;return module.exports});
 
-window.coveoQuanticVersion = '3.39.1';
+window.coveoQuanticVersion = '3.40.0';

package/force-app/main/default/staticresources/coveoheadless/recommendation/headless.js

@@ -72,4 +72,4 @@ fast-json-patch/module/duplex.mjs:
    *)
 */if(__exports!=exports)module.exports=exports;return module.exports});
 
-window.coveoQuanticVersion = '3.39.1';
+window.coveoQuanticVersion = '3.40.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coveo/quantic",
-  "version": "3.39.1",
+  "version": "3.40.0",
   "description": "A Salesforce Lightning Web Component (LWC) library for building modern UIs interfacing with the Coveo platform",
   "author": "coveo.com",
   "homepage": "https://coveo.com",