@coveo/quantic 3.42.1 → 3.43.1

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

@@ -1652,6 +1652,13 @@
     <protected>false</protected>
     <shortDescription>Submit follow-up</shortDescription>
   </labels>
+  <labels>
+    <fullName>quantic_FollowUpInputTooLong</fullName>
+    <value>Your question is too long. Please use {{0}} characters or fewer.</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Follow-up question character limit exceeded</shortDescription>
+  </labels>
   <labels>
     <fullName>quantic_ShowPreviousQuestions_plural</fullName>
     <value>Show {{0}} previous questions</value>
@@ -1687,6 +1694,20 @@
     <protected>false</protected>
     <shortDescription>Knowledge base searched</shortDescription>
   </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepSearchQuery</fullName>
+    <value>Searching for {{0}}…</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Searching for query</shortDescription>
+  </labels>
+  <labels>
+    <fullName>quantic_AgentGenerationStepSearchQueryCompleted</fullName>
+    <value>Searched for {{0}}</value>
+    <language>en_US</language>
+    <protected>false</protected>
+    <shortDescription>Searched for query</shortDescription>
+  </labels>
   <labels>
     <fullName>quantic_AgentGenerationStepAnalyzingResults</fullName>
     <value>Analyzing results…</value>

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/agentData.ts

@@ -0,0 +1,248 @@
+type AgentRunType = {
+  type: 'RUN_STARTED' | 'RUN_FINISHED';
+  timestamp: number;
+  threadId: string;
+  runId: string;
+  result?: {
+    completionReason: string;
+  };
+};
+
+type AgentCustomType = {
+  type: 'CUSTOM';
+  timestamp: number;
+  name: string;
+  value: any;
+};
+
+type AgentStepType = {
+  type: 'STEP_STARTED' | 'STEP_FINISHED';
+  timestamp: number;
+  stepName: string;
+};
+
+type AgentToolCallType = {
+  type: 'TOOL_CALL_START' | 'TOOL_CALL_END';
+  timestamp: number;
+  toolCallId: string;
+  toolCallName: string;
+  parentMessageId: string;
+};
+
+type AgentToolCallArgsType = {
+  type: 'TOOL_CALL_ARGS';
+  timestamp: number;
+  toolCallId: string;
+  delta: any;
+};
+
+type AgentTextMessageType = {
+  type: 'TEXT_MESSAGE_CHUNK';
+  timestamp: number;
+  messageId: string;
+  parentMessageId: string;
+  delta: string;
+};
+
+export type AgentCitation = {
+  id: string;
+  title: string;
+  uri: string;
+  permanentid: string;
+  primaryId: string;
+  clickUri: string;
+  text: string;
+  source: string;
+  filetype: string;
+  fields: Record<string, any>;
+};
+
+type AgentCitationType = {
+  type: 'CUSTOM';
+  timestamp: number;
+  name: 'citations';
+  value: {
+    citations: Array<AgentCitation>;
+  };
+};
+
+const STREAM_ID = 'conv_1';
+const ANSWER_ID_1 = 'conv_1_0001';
+const ANSWER_ID_2 = 'conv_1_0002';
+const ANSWER_ID_3 = 'conv_1_0003';
+const CONVERSATION_TOKEN = 'conv_1_token';
+
+const runStartStream = (answerId: string): AgentRunType => ({
+  type: 'RUN_STARTED',
+  timestamp: new Date().valueOf(),
+  threadId: STREAM_ID,
+  runId: answerId,
+});
+
+const customInitialHeadersStream = (followUpEnabled: boolean): AgentCustomType => ({
+  type: 'CUSTOM',
+  timestamp: new Date().valueOf(),
+  name: 'header',
+  value: {
+    contentFormat: 'text/markdown',
+    conversationId: STREAM_ID,
+    followUpEnabled,
+    conversationToken: CONVERSATION_TOKEN,
+  },
+});
+
+const stepStartedStream = (stepName: string): AgentStepType => ({
+  type: 'STEP_STARTED',
+  timestamp: new Date().valueOf(),
+  stepName,
+});
+
+const stepFinishedStream = (stepName: string): AgentStepType => ({
+  type: 'STEP_FINISHED',
+  timestamp: new Date().valueOf(),
+  stepName,
+});
+
+const toolCallStartStream = (toolCallName: string): AgentToolCallType => ({
+  type: 'TOOL_CALL_START',
+  timestamp: new Date().valueOf(),
+  toolCallId: 'tool_call_1',
+  toolCallName,
+  parentMessageId: 'message_1',
+});
+
+const searchQueryToolCallArgsStream = (q: string): AgentToolCallArgsType => ({
+  type: 'TOOL_CALL_ARGS',
+  timestamp: new Date().valueOf(),
+  toolCallId: 'tool_call_1',
+  delta: JSON.stringify({
+    q,
+  }),
+});
+
+const toolCallEndStream = (toolCallName: string): AgentToolCallType => ({
+  type: 'TOOL_CALL_END',
+  timestamp: new Date().valueOf(),
+  toolCallId: 'tool_call_1',
+  toolCallName,
+  parentMessageId: 'message_1',
+});
+
+const textMessageStream = (delta: string): AgentTextMessageType => ({
+  type: 'TEXT_MESSAGE_CHUNK',
+  timestamp: new Date().valueOf(),
+  messageId: 'message_2',
+  parentMessageId: 'message_1',
+  delta,
+});
+
+const exampleCitation: AgentCitation = {
+  id: 'some-id-1',
+  title: 'Some Title 1',
+  uri: 'https://www.coveo.com',
+  permanentid: 'some-permanent-id-1',
+  clickUri: 'https://www.coveo.com',
+  text: 'example text 1',
+  source: 'Some source 1',
+  filetype: 'pdf',
+  fields: {},
+  primaryId: 'primary-id-1',
+};
+
+const citationStream: AgentCitationType = {
+  type: 'CUSTOM',
+  timestamp: new Date().valueOf(),
+  name: 'citations',
+  value: {
+    citations: [exampleCitation],
+  },
+};
+
+const runFinishedStream = (answerId: string): AgentRunType => ({
+  type: 'RUN_FINISHED',
+  timestamp: new Date().valueOf(),
+  threadId: STREAM_ID,
+  runId: answerId,
+  result: {
+    completionReason: 'ANSWERED',
+  },
+});
+
+export type AgentMessage =
+  | AgentRunType
+  | AgentCustomType
+  | AgentStepType
+  | AgentToolCallType
+  | AgentToolCallArgsType
+  | AgentTextMessageType
+  | AgentCitationType;
+
+export type AgentData = {
+  answerStreams: Array<AgentMessage>;
+  followUpStreams: Array<Array<AgentMessage>>;
+  conversationId: string;
+  answerId1: string;
+  answerId2: string;
+  answerId3: string;
+  conversationToken: string;
+  citations: Array<AgentCitation>;
+};
+
+const agentData: AgentData = {
+  answerStreams: [
+    runStartStream(ANSWER_ID_1),
+    customInitialHeadersStream(true),
+    stepStartedStream('Searching'),
+    toolCallStartStream('search'),
+    searchQueryToolCallArgsStream('test'),
+    toolCallEndStream('search'),
+    stepFinishedStream('Searching'),
+    stepStartedStream('Answering'),
+    textMessageStream('### Testing in Coveo\n\nclick **Edit components**.\n   - On the **A/B test** tab, click **Configure A/B test**.\n   - Set the traffic ratio and configure the **Test scenario**.\n   - Click **Start** to activate the A/B test.\n\n2. **Edit an A/B Test**\n   - Follow the same steps as creating an A/B test.\n   - Click **Edit A/B test** and adjust the traffic ratio.'),
+    citationStream,
+    stepFinishedStream('Answering'),
+    runFinishedStream(ANSWER_ID_1),
+  ],
+  followUpStreams: [
+    [
+      runStartStream(ANSWER_ID_2),
+      customInitialHeadersStream(true),
+      stepStartedStream('Thinking'),
+      stepFinishedStream('Thinking'),
+      stepStartedStream('Searching'),
+      toolCallStartStream('search'),
+      searchQueryToolCallArgsStream('follow-up question'),
+      toolCallEndStream('search'),
+      stepFinishedStream('Searching'),
+      stepStartedStream('Answering'),
+      textMessageStream('This is a follow-up answer.'),
+      citationStream,
+      stepFinishedStream('Answering'),
+      runFinishedStream(ANSWER_ID_2),
+    ],
+    [
+      runStartStream(ANSWER_ID_3),
+      customInitialHeadersStream(true),
+      stepStartedStream('Thinking'),
+      stepFinishedStream('Thinking'),
+      stepStartedStream('Searching'),
+      toolCallStartStream('search'),
+      searchQueryToolCallArgsStream('third question'),
+      toolCallEndStream('search'),
+      stepFinishedStream('Searching'),
+      stepStartedStream('Answering'),
+      textMessageStream('This is the third answer.'),
+      citationStream,
+      stepFinishedStream('Answering'),
+      runFinishedStream(ANSWER_ID_3),
+    ],
+  ],
+  conversationId: STREAM_ID,
+  answerId1: ANSWER_ID_1,
+  answerId2: ANSWER_ID_2,
+  answerId3: ANSWER_ID_3,
+  conversationToken: CONVERSATION_TOKEN,
+  citations: [exampleCitation],
+};
+
+export default agentData;

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

@@ -0,0 +1,77 @@
+import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
+import {SearchObject} from '../../../../../../playwright/page-object/searchObject';
+import {
+  searchRequestRegex,
+  agentAnswerRequestRegex,
+  agentFollowUpRequestRegex,
+} from '../../../../../../playwright/utils/requests';
+import {GeneratedAnswerObject} from './pageObject';
+import agentData from './agentData';
+import type {AgentData} from './agentData';
+import {AnalyticsModeEnum} from '../../../../../../playwright/utils/analyticsMode';
+
+const pageUrl = 's/quantic-generated-answer';
+
+interface AgentOptions {
+  agentId: string;
+  withToggle: boolean;
+}
+
+type QuanticGeneratedAnswerAgentE2EFixtures = {
+  agentData: AgentData;
+  generatedAnswer: GeneratedAnswerObject;
+  search: SearchObject;
+  options: Partial<AgentOptions>;
+};
+
+export const exampleQuery = 'test';
+
+export const testAgent =
+  quanticBase.extend<QuanticGeneratedAnswerAgentE2EFixtures>({
+    pageUrl,
+    agentData,
+    options: {},
+    analyticsMode: AnalyticsModeEnum.legacy,
+    search: async ({page}, use) => {
+      await use(new SearchObject(page, searchRequestRegex));
+    },
+    generatedAnswer: async (
+      {page, options, configuration, search, agentData: data, analytics},
+      use
+    ) => {
+      const generatedAnswerObject = new GeneratedAnswerObject(
+        page,
+        data.answerId1,
+        analytics,
+        {
+          headAnswerRequestRegex: agentAnswerRequestRegex,
+          agentFollowUpRequestRegex,
+        }
+      );
+
+      await generatedAnswerObject.mockAgentAnswerResponse(
+        data.answerStreams
+      );
+      await generatedAnswerObject.mockAgentFollowUpResponse(
+        data.followUpStreams
+      );
+      
+      await search.mockSearchWithBaseResponse();
+      await page.goto(pageUrl);
+      await configuration.configure(options);
+      await search.waitForSearchResponse();
+
+      generatedAnswerObject.streamEndAnalyticRequestPromise =
+        generatedAnswerObject.waitForStreamEndAnalytics();
+      generatedAnswerObject.generateRequestPromise =
+        generatedAnswerObject.waitForHeadAnswerRequest();
+
+      await search.fillSearchInput(exampleQuery);
+      search.performSearch();
+      await search.waitForSearchResponse();
+
+      await use(generatedAnswerObject);
+    },
+  });
+
+export {expect} from '@playwright/test';