@coveo/quantic 3.42.1 → 3.43.0

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

@@ -0,0 +1,118 @@
+import {resolveSteps} from '../stepsUtils.js';
+
+describe('#resolveSteps', () => {
+  it('should return empty array for empty input', () => {
+    expect(resolveSteps([])).toEqual([]);
+  });
+
+  it('should resolve a full sequence correctly', () => {
+    expect(
+      resolveSteps([
+        {name: 'thinking', status: 'completed', startedAt: 0},
+        {name: 'searching', status: 'completed', startedAt: 10},
+        {name: 'thinking', status: 'completed', startedAt: 20},
+        {name: 'answering', status: 'active', startedAt: 30},
+      ])
+    ).toEqual([
+      {name: 'thinking-before-search', status: 'completed'},
+      {name: 'searching', status: 'completed'},
+      {name: 'thinking-after-search', status: 'completed'},
+      {name: 'answering', status: 'active'},
+    ]);
+  });
+
+  it('should handle repeated searching steps', () => {
+    expect(
+      resolveSteps([
+        {name: 'thinking', status: 'completed', startedAt: 0},
+        {name: 'searching', status: 'completed', startedAt: 10},
+        {name: 'thinking', status: 'completed', startedAt: 20},
+        {name: 'searching', status: 'completed', startedAt: 30},
+        {name: 'thinking', status: 'active', startedAt: 40},
+      ])
+    ).toEqual([
+      {name: 'thinking-before-search', status: 'completed'},
+      {name: 'searching', status: 'completed'},
+      {name: 'thinking-after-search', status: 'completed'},
+      {name: 'searching', status: 'completed'},
+      {name: 'thinking-after-search', status: 'active'},
+    ]);
+  });
+
+  it('should resolve searching step with toolCall query to searching-with-query', () => {
+    expect(
+      resolveSteps([
+        {
+          name: 'searching',
+          status: 'active',
+          startedAt: 0,
+          toolCalls: [
+            {
+              toolCallName: 'search',
+              toolCallId: 'tc-1',
+              startedAt: 0,
+              status: 'active',
+              type: 'search',
+              toolCallArgs: {q: 'how to reset password'},
+            },
+          ],
+        },
+      ])
+    ).toEqual([
+      {
+        name: 'searching-with-query',
+        status: 'active',
+        searchQuery: 'how to reset password',
+      },
+    ]);
+  });
+
+  it('should expand multiple search toolCalls into separate resolved steps', () => {
+    expect(
+      resolveSteps([
+        {
+          name: 'searching',
+          status: 'completed',
+          startedAt: 0,
+          toolCalls: [
+            {
+              toolCallName: 'search',
+              toolCallId: 'tc-1',
+              startedAt: 0,
+              finishedAt: 1,
+              status: 'completed',
+              type: 'search',
+              toolCallArgs: {q: 'What is Quantic'},
+            },
+            {
+              toolCallName: 'search',
+              toolCallId: 'tc-2',
+              startedAt: 1,
+              finishedAt: 2,
+              status: 'completed',
+              type: 'search',
+              toolCallArgs: {q: 'What is Atomic'},
+            },
+          ],
+        },
+      ])
+    ).toEqual([
+      {
+        name: 'searching-with-query',
+        status: 'completed',
+        searchQuery: 'What is Quantic',
+      },
+      {
+        name: 'searching-with-query',
+        status: 'completed',
+        searchQuery: 'What is Atomic',
+      },
+    ]);
+  });
+
+  it('should fall back to searching when toolCalls is absent', () => {
+    expect(
+      resolveSteps([{name: 'searching', status: 'active', startedAt: 0}])
+    ).toEqual([{name: 'searching', status: 'active'}]);
+  });
+});

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

@@ -2,25 +2,25 @@ import analyzingQuestion from '@salesforce/label/c.quantic_AgentGenerationStepAn
 import analyzingQuestionCompleted from '@salesforce/label/c.quantic_AgentGenerationStepAnalyzingQuestionCompleted';
 import search from '@salesforce/label/c.quantic_AgentGenerationStepSearch';
 import searchCompleted from '@salesforce/label/c.quantic_AgentGenerationStepSearchCompleted';
+import searchQuery from '@salesforce/label/c.quantic_AgentGenerationStepSearchQuery';
+import searchQueryCompleted from '@salesforce/label/c.quantic_AgentGenerationStepSearchQueryCompleted';
 import analyzingResults from '@salesforce/label/c.quantic_AgentGenerationStepAnalyzingResults';
 import analyzingResultsCompleted from '@salesforce/label/c.quantic_AgentGenerationStepAnalyzingResultsCompleted';
 import answering from '@salesforce/label/c.quantic_AgentGenerationStepAnswering';
 import answeringCompleted from '@salesforce/label/c.quantic_AgentGenerationStepAnsweringCompleted';
 import collapseButton from '@salesforce/label/c.quantic_CollapseButton';
 import loadingLabel from '@salesforce/label/c.quantic_Loading';
+import {I18nUtils} from 'c/quanticUtils';
 import {LightningElement, api} from 'lwc';
+import {resolveSteps} from './stepsUtils.js';
 // @ts-ignore
 import streamOfThoughtTemplate from './templates/streamOfThought.html';
 // @ts-ignore
 import collapsedSummaryTemplate from './templates/collapsedSummary.html';
 
 /** @typedef {import("coveo").GenerationStep} GenerationStep */
-/** @typedef {'thinking-before-search'|'searching'|'thinking-after-search'|'answering'} ResolvedStepName */
-/**
- * @typedef {Object} ResolvedStep
- * @property {ResolvedStepName} name
- * @property {'active'|'completed'} status
- */
+/** @typedef {import("./stepsUtils.js").ResolvedStepName} ResolvedStepName */
+/** @typedef {import("./stepsUtils.js").ResolvedStep} ResolvedStep */
 
 /** @type {Record<string, {active: string, completed: string}>} */
 const STEP_LABEL_KEYS = {
@@ -32,6 +32,10 @@ const STEP_LABEL_KEYS = {
     active: search,
     completed: searchCompleted,
   },
+  'searching-with-query': {
+    active: searchQuery,
+    completed: searchQueryCompleted,
+  },
   'thinking-after-search': {
     active: analyzingResults,
     completed: analyzingResultsCompleted,
@@ -42,30 +46,6 @@ const STEP_LABEL_KEYS = {
   },
 };
 
-/**
- * Maps an array of raw generation steps to resolved steps with a normalized type.
- * @param {GenerationStep[]} steps
- * @returns {ResolvedStep[]}
- */
-export function resolveSteps(steps) {
-  let searchWasPerformed = false;
-  return steps.map((step) => {
-    /** @type {ResolvedStepName} */
-    let name;
-    if (step.name === 'searching') {
-      searchWasPerformed = true;
-      name = 'searching';
-    } else if (step.name === 'answering') {
-      name = 'answering';
-    } else {
-      name = searchWasPerformed
-        ? 'thinking-after-search'
-        : 'thinking-before-search';
-    }
-    return {name, status: step.status};
-  });
-}
-
 /**
  * The `QuanticGeneratedAnswerStreamOfThought` component displays a timeline of agent reasoning
  * steps during answer generation, showing real-time progress and completion status.
@@ -111,15 +91,19 @@ export default class QuanticGeneratedAnswerStreamOfThought extends LightningElem
     this._expanded = !this._expanded;
   };
 
-  /** @returns {Array<{key: number, isActive: boolean, label: string}>} */
+  /** @returns {Array<{key: number, name: ResolvedStepName, isActive: boolean, label: string}>} */
   get stepsToDisplay() {
     return this.steps.map((step, index) => {
-      const labelKey = STEP_LABEL_KEYS[step.name][step.status];
+      const rawLabel = STEP_LABEL_KEYS[step.name][step.status];
+      const label =
+        step.name === 'searching-with-query'
+          ? I18nUtils.format(rawLabel, step.searchQuery)
+          : rawLabel;
       return {
         key: index,
         name: step.name,
         isActive: step.status === 'active',
-        label: labelKey,
+        label,
       };
     });
   }
@@ -152,8 +136,10 @@ export default class QuanticGeneratedAnswerStreamOfThought extends LightningElem
   /** @returns {string} */
   get collapsedSummaryLabel() {
     const lastStep = this.steps[this.steps.length - 1];
-    const labelKey = STEP_LABEL_KEYS[lastStep.name].completed;
-    return labelKey;
+    const rawLabel = STEP_LABEL_KEYS[lastStep.name].completed;
+    return lastStep.name === 'searching-with-query'
+      ? I18nUtils.format(rawLabel, lastStep.searchQuery)
+      : rawLabel;
   }
 
   render() {

package/force-app/main/default/lwc/quanticGeneratedAnswerStreamOfThought/stepsUtils.js

@@ -0,0 +1,66 @@
+/** @typedef {import("coveo").GenerationStep} GenerationStep */
+/** @typedef {'thinking-before-search'|'searching'|'searching-with-query'|'thinking-after-search'|'answering'} ResolvedStepName */
+/**
+ * @typedef {Object} ResolvedStep
+ * @property {ResolvedStepName} name
+ * @property {'active'|'completed'} status
+ * @property {string} [searchQuery]
+ */
+
+/**
+ * Maps an array of raw generation steps to resolved steps with a normalized type.
+ * @param {GenerationStep[]} steps
+ * @returns {ResolvedStep[]}
+ */
+export function resolveSteps(steps) {
+  let searchWasPerformed = false;
+  return steps.flatMap(
+    /** @returns {ResolvedStep | ResolvedStep[]} */ (step) => {
+      if (step.name === 'searching') {
+        searchWasPerformed = true;
+        return resolveSearchingStep(step);
+      }
+      if (step.name === 'answering') {
+        return {name: 'answering', status: step.status};
+      }
+      return {
+        name: searchWasPerformed
+          ? 'thinking-after-search'
+          : 'thinking-before-search',
+        status: step.status,
+      };
+    }
+  );
+}
+
+/**
+ * Resolves a searching step, expanding individual tool calls when present.
+ * @param {GenerationStep} step
+ * @returns {ResolvedStep[]}
+ */
+function resolveSearchingStep(step) {
+  const searchToolCalls = step.toolCalls?.filter((tc) => tc.type === 'search');
+  if (searchToolCalls?.length) {
+    return searchToolCalls.map(resolveSearchToolCall);
+  }
+  return [{name: 'searching', status: step.status}];
+}
+
+/**
+ * Resolves a single search tool call into a ResolvedStep.
+ * @param {import("coveo").GenerationToolCall} toolCall
+ * @returns {ResolvedStep}
+ */
+function resolveSearchToolCall(toolCall) {
+  const query =
+    toolCall.toolCallArgs && 'q' in toolCall.toolCallArgs
+      ? toolCall.toolCallArgs.q
+      : undefined;
+  return query
+    ? {
+        name: 'searching-with-query',
+        status: toolCall.status,
+        searchQuery: query,
+      }
+    : {name: 'searching', status: toolCall.status};
+}