@nyris/nyris-webapp 0.3.99 → 0.4.1

package/src/hooks/useResultEvaluator.ts

@@ -14,6 +14,11 @@ import useConversationStore, {
 } from 'stores/chat/conversationStore';
 import useSmartFiltersStore from 'stores/smartFilters/smartFiltersStore';
 import { chatAnalysis } from 'services/vizo';
+import {
+  getChatAttributeFrequency,
+  getChatProductAttributes,
+  getChatProductMetadata,
+} from 'utils/chatProductMetadata';
 import useRequestStore from 'stores/request/requestStore';
 import { canvasToBase64, cropImage } from 'utils/cropImageToBase64';
 import {
@@ -74,29 +79,8 @@ export function useResultEvaluator() {
         const resultsSummary = activeProducts
           .slice(0, 30)
           .map((p: any, i: number) => {
-            // Extract all potentially useful metadata
-            const metadata: Record<string, any> = {};
-            const metadataFields = [
-              'voltage',
-              'size',
-              'brand',
-              'manufacturer',
-              'material',
-              'type',
-              'category',
-              'color',
-              'dimensions',
-              'power',
-              'current',
-              'connector',
-              'model',
-              'series',
-              'product_line',
-            ];
-
-            metadataFields.forEach(field => {
-              if (p[field]) metadata[field] = p[field];
-            });
+            const fullMetadata = getChatProductMetadata(p);
+            const metadata = getChatProductAttributes(fullMetadata);
 
             // Extract from title/description using common patterns
             const title = p.title || p.name || '';
@@ -181,11 +165,8 @@ export function useResultEvaluator() {
 
             return {
               rank: i + 1,
-              title: title || 'Untitled',
-              description: (p.description || '').substring(0, 100),
-              category: p.category || p.type || 'Unknown',
-              score: p.score || p.similarity || 0,
-              metadata: Object.keys(metadata).length > 0 ? metadata : null,
+              metadata: fullMetadata,
+              attributes: metadata,
             };
           });
 
@@ -203,17 +184,9 @@ export function useResultEvaluator() {
         });
 
         // Analyze common attributes across results for filter suggestions
-        const attributeFrequency: Record<string, Record<string, number>> = {};
-        resultsSummary.forEach(r => {
-          if (r.metadata) {
-            Object.entries(r.metadata).forEach(([key, value]) => {
-              if (!attributeFrequency[key]) attributeFrequency[key] = {};
-              const strValue = String(value);
-              attributeFrequency[key][strValue] =
-                (attributeFrequency[key][strValue] || 0) + 1;
-            });
-          }
-        });
+        const attributeFrequency = getChatAttributeFrequency(
+          resultsSummary.map(result => ({ metadata: result.attributes })),
+        );
 
         const requestImage = useRequestStore.getState().requestImages;
         const regions = useRequestStore.getState().regions;
@@ -232,20 +205,16 @@ IMAGE DESCRIPTION: ${hasRequestImage ? imageDescription : 'N/A'}
 SPECIFICATION (from image analysis):
 ${hasRequestImage ? JSON.stringify(p4Specification, null, 2) : 'N/A'}
 
-TOP 20 RESULTS WITH METADATA:
-${resultsSummary
-  .map(
-    r =>
-      `${r.rank}. ${r.title}${r.description ? ` - ${r.description}` : ''} (Score: ${r.score})${r.metadata ? `\n   Metadata: ${JSON.stringify(r.metadata)}` : ''}`,
-  )
-  .join('\n')}
 
 COMMON ATTRIBUTES FOUND IN RESULTS (for filter suggestions):
 ${JSON.stringify(attributeFrequency, null, 2)}
 
 TOTAL RESULTS: ${resultsSummary.length}
 
-Evaluate if these results match ${evaluationTarget}. If they do (same type of product), route to P3 and suggest filter options based on the COMMON ATTRIBUTES found above (like voltage, size, brand). Do NOT suggest the obvious category match.`;
+Evaluate if these results match ${evaluationTarget}. If they do (same type of product), route to P3 and suggest filter options based on the COMMON ATTRIBUTES found above (like voltage, size, brand). Do NOT suggest the obvious category match.
+
+${hasRequestImage ? 'The request image is available, use it for evaluation.' : 'The request image is not available, rely solely on the user query for evaluation. Rest of the image information is only result/response images.'}.
+`;
 
         const productsForImages = activeProducts.slice(0, 30);
         const imageResults = await Promise.all(
@@ -268,14 +237,9 @@ Evaluate if these results match ${evaluationTarget}. If they do (same type of pr
           mimeType?: string;
         }> = [];
 
-        resultsSummary.forEach((result, i) => {
-          const originalProduct = productsForImages[i];
-          const tags = originalProduct?._tags;
-          const tagStr = tags
-            ? ` | TAGS: type=${tags.productType}, color=${tags.color}, shape=${tags.shape}, material=${tags.material}`
-            : '';
-
-          const metaLine = `${result.rank}. ${result.title}${result.description ? ` - ${result.description}` : ''} (Score: ${result.score})${result.metadata ? ` | Metadata: ${JSON.stringify(result.metadata)}` : ''}${tagStr}`;
+        resultsSummary.forEach(({ rank, metadata }, i) => {
+          const result = { rank, metadata };
+          const metaLine = `${JSON.stringify(getChatProductMetadata(result))}. Result_images.`;
 
           if (hasVisualContext && imageResults[i]?.base64) {
             productImageParts.push({
@@ -283,6 +247,8 @@ Evaluate if these results match ${evaluationTarget}. If they do (same type of pr
               image: imageResults[i].base64 || '',
               mimeType: 'image/jpeg',
             });
+          } else {
+            productImageParts.push({ metadata: metaLine });
           }
         });
 

package/src/services/Feedback.ts

@@ -6,6 +6,7 @@ import NyrisAPI, {
 } from '@nyris/nyris-api';
 import { getNyrisSettings } from 'utils/nyrisApiKey';
 import useResultStore from 'stores/result/resultStore';
+import useConversationStore from 'stores/chat/conversationStore';
 import { CONVERSION_SUBTYPE, normalizeSubtype } from './feedbackSubtypes';
 
 export interface FeedbackIds {
@@ -164,8 +165,9 @@ export const trackResultFeedback = (
   success: boolean,
   comment?: string,
   ids?: FeedbackIds,
-) =>
-  trackFeedbackEvent(
+) => {
+  useConversationStore.getState().setSearchResolved(success);
+  return trackFeedbackEvent(
     {
       event: 'feedback',
       data: {
@@ -175,6 +177,7 @@ export const trackResultFeedback = (
     },
     ids,
   );
+};
 
 /** `region` event; converts x1/y1/x2/y2 to the API's x/y/w/h rectangle. */
 export const trackRegion = (

package/src/stores/chat/conversationStore.test.ts

@@ -0,0 +1,133 @@
+import useConversationStore from './conversationStore';
+
+beforeEach(() => {
+  window.settings = {
+    vizo: { requestSupport: true },
+    support: { emailInquiry: true, emailTemplateId: 'support-template' },
+  } as typeof window.settings;
+  useConversationStore.getState().reset();
+});
+
+const sendUserMessages = (count: number) => {
+  for (let index = 0; index < count; index += 1) {
+    useConversationStore.getState().addMessage({
+      role: 'user',
+      content: `Still searching ${index}`,
+    });
+  }
+};
+
+const addApiResponse = () => {
+  useConversationStore.getState().addMessage(
+    {
+      role: 'assistant',
+      content: 'Let us keep looking.',
+      options: [{ label: 'Continue search', action_type: 'filter' }],
+    },
+    { isApiResponse: true },
+  );
+};
+
+test('offers support within the third API reply, once per session', () => {
+  sendUserMessages(2);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+
+  sendUserMessages(1);
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+  addApiResponse();
+  const state = useConversationStore.getState();
+  expect(state.userMessageCount).toBe(3);
+  expect(state.messages).toHaveLength(5);
+  expect(state.messages[state.messages.length - 1]).toMatchObject({
+    role: 'assistant',
+    content: 'Let us keep looking.',
+    options: [
+      { label: 'Continue search', action_type: 'filter' },
+      { label: 'Request support', action_type: 'request_support' },
+    ],
+  });
+
+  sendUserMessages(2);
+  addApiResponse();
+  expect(
+    useConversationStore
+      .getState()
+      .messages.filter(message =>
+        message.options?.some(
+          option => option.action_type === 'request_support',
+        ),
+      ),
+  ).toHaveLength(1);
+});
+
+test('waits for a response and excludes assistant and empty user messages', () => {
+  const store = useConversationStore.getState();
+  store.addMessage({ role: 'assistant', content: 'How can I help?' });
+  store.addMessage({ role: 'user', content: ' ' });
+  expect(useConversationStore.getState().userMessageCount).toBe(0);
+  sendUserMessages(3);
+  store.setIsLoading(true);
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+  store.setIsLoading(false);
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+  store.addMessage({ role: 'assistant', content: 'Something went wrong.' });
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(true);
+});
+
+test('does not offer support after a successful outcome', () => {
+  sendUserMessages(3);
+  useConversationStore.getState().setSearchResolved(true);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(false);
+});
+
+test('offers support on the third reply when recovery exits without another API call', () => {
+  sendUserMessages(3);
+  useConversationStore.getState().addMessage({
+    role: 'assistant',
+    content: 'I was not able to find a match.',
+    action: { type: 'exit' },
+  });
+  const state = useConversationStore.getState();
+  expect(state.supportPromptShown).toBe(true);
+  expect(state.messages[state.messages.length - 1].options).toContainEqual({
+    label: 'Request support',
+    action_type: 'request_support',
+  });
+});
+
+test('a new session resets message counting and allows another support prompt', () => {
+  sendUserMessages(3);
+  addApiResponse();
+  useConversationStore.getState().startNewSession();
+  expect(useConversationStore.getState()).toMatchObject({
+    userMessageCount: 0,
+    supportPromptShown: false,
+    searchResolved: false,
+  });
+  sendUserMessages(3);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(true);
+});
+
+test('does not offer support when vizo.requestSupport is disabled', () => {
+  window.settings.vizo!.requestSupport = false;
+  sendUserMessages(3);
+  addApiResponse();
+  const state = useConversationStore.getState();
+  expect(state.supportPromptShown).toBe(false);
+  expect(state.messages[state.messages.length - 1].options).not.toContainEqual(
+    expect.objectContaining({ action_type: 'request_support' }),
+  );
+});
+
+test('offers support even when the inquiry banner and email template are disabled', () => {
+  window.settings.support.emailInquiry = false;
+  window.settings.support.emailTemplateId = '';
+  sendUserMessages(3);
+  addApiResponse();
+  expect(useConversationStore.getState().supportPromptShown).toBe(true);
+});

package/src/stores/chat/conversationStore.ts

@@ -39,7 +39,8 @@ export interface QuickReplyOption {
     | 'restore_previous'
     | 'related_part'
     | 'find_related_parts'
-    | 'restore_original';
+    | 'restore_original'
+    | 'request_support';
   value?: string;
   key?: string;
 }
@@ -72,7 +73,7 @@ export interface RelatedPartSuggestion {
 interface ConversationState {
   // Session state
   sessionId: string;
-  isEvaluated: boolean;  // P2 has fired
+  isEvaluated: boolean; // P2 has fired
   // Routing
   route: ConversationRoute;
   quality: ResultQuality;
@@ -84,6 +85,9 @@ interface ConversationState {
   // Conversation
   messages: ChatMessage[];
   activeFilters: ActiveFilter[];
+  userMessageCount: number;
+  supportPromptShown: boolean;
+  searchResolved: boolean;
 
   // UI state
   isOpen: boolean;
@@ -126,8 +130,12 @@ interface ConversationActions {
   ) => void;
 
   // Messages
-  addMessage: (message: Omit<ChatMessage, 'id' | 'timestamp'>) => void;
+  addMessage: (
+    message: Omit<ChatMessage, 'id' | 'timestamp'>,
+    options?: { isApiResponse?: boolean },
+  ) => void;
   clearMessages: () => void;
+  setSearchResolved: (resolved: boolean) => void;
 
   // Filters (for P3)
   addFilter: (key: string, value: string) => void;
@@ -172,6 +180,9 @@ const initialState: ConversationState = {
   attemptCounter: 0,
   messages: [],
   activeFilters: [],
+  userMessageCount: 0,
+  supportPromptShown: false,
+  searchResolved: false,
   isOpen: false, // Start closed so left panel is open by default
   hasNotification: false,
   isLoading: false,
@@ -240,20 +251,50 @@ const useConversationStore = create<ConversationState & ConversationActions>()(
       }));
     },
 
-    addMessage: message =>
-      set(state => ({
-        messages: [
-          ...state.messages,
-          {
-            ...message,
-            id: generateId(),
-            timestamp: Date.now(),
-          },
-        ],
-      })),
+    addMessage: (message, { isApiResponse = false } = {}) =>
+      set(state => {
+        const shouldOfferSupport =
+          window.settings?.vizo?.requestSupport &&
+          (isApiResponse || message.action?.type === 'exit') &&
+          message.role === 'assistant' &&
+          state.userMessageCount > 2 &&
+          !state.supportPromptShown &&
+          !state.searchResolved;
+
+        return {
+          userMessageCount:
+            state.userMessageCount +
+            (message.role === 'user' &&
+            (message.content.trim() || message.imageUrl)
+              ? 1
+              : 0),
+          supportPromptShown: state.supportPromptShown || shouldOfferSupport,
+          messages: [
+            ...state.messages,
+            {
+              ...message,
+              id: generateId(),
+              timestamp: Date.now(),
+              ...(shouldOfferSupport
+                ? {
+                    options: [
+                      ...(message.options || []),
+                      {
+                        label: 'Request support',
+                        action_type: 'request_support' as const,
+                      },
+                    ],
+                  }
+                : {}),
+            },
+          ],
+        };
+      }),
 
     clearMessages: () => set({ messages: [] }),
 
+    setSearchResolved: searchResolved => set({ searchResolved }),
+
     addFilter: (key, value) =>
       set(state => ({
         activeFilters: [

package/src/types.ts

@@ -133,6 +133,7 @@ export interface AppSettings extends NyrisAPISettings {
     fallbackToElasticSearch?: boolean;
     chat?: boolean;
     findRelatedParts?: boolean;
+    requestSupport?: boolean;
   };
   headerText?: string;
   instantRedirectPatterns: string[];

package/src/utils/chatProductMetadata.test.ts

@@ -0,0 +1,130 @@
+import {
+  getChatAttributeFrequency,
+  getChatProductAttributes,
+  getChatProductMetadata,
+} from './chatProductMetadata';
+
+test('selects only curated primitive filter traits without mutating metadata', () => {
+  const metadata = {
+    brand: 'ACME',
+    voltage: '24V DC',
+    current: 0,
+    connector: false,
+    product_type: 'PUMP',
+    sku: 'pump-1',
+    title: 'Unique pump title',
+    description: 'Unique pump description',
+    customIds: { mpn: 'MPN-1' },
+    attributes: { pressure: 10 },
+    metadata: { customAttribute: 'value' },
+    _tags: { color: 'blue' },
+    material: { name: 'steel' },
+    category: ['Pumps'],
+    size: null,
+    dimensions: undefined,
+    color: '  ',
+    power: NaN,
+    model: Infinity,
+  };
+  const snapshot = { ...metadata };
+
+  expect(getChatProductAttributes(metadata)).toEqual({
+    brand: 'ACME',
+    voltage: '24V DC',
+    current: 0,
+    connector: false,
+    product_type: 'PUMP',
+  });
+  expect(metadata).toEqual(snapshot);
+});
+
+test('counts trait values, not full metadata or object stringifications', () => {
+  expect(
+    getChatAttributeFrequency([
+      {
+        metadata: {
+          brand: 'ACME',
+          voltage: '24V DC',
+          sku: 'pump-1',
+          attributes: { material: 'steel' },
+        },
+      },
+      {
+        metadata: {
+          brand: 'ACME',
+          voltage: '12V DC',
+          sku: 'pump-2',
+          material: { name: 'steel' },
+        },
+      },
+      { metadata: null },
+    ]),
+  ).toEqual({
+    brand: { ACME: 2 },
+    voltage: { '24V DC': 1, '12V DC': 1 },
+  });
+  expect(getChatAttributeFrequency([])).toEqual({});
+});
+
+test('counts trait values that match object prototype properties', () => {
+  const frequency = getChatAttributeFrequency([
+    { metadata: { model: '__proto__', series: 'constructor' } },
+    { metadata: { model: '__proto__', series: 'constructor' } },
+  ]);
+  expect(frequency.model['__proto__']).toBe(2);
+  expect(frequency.series.constructor).toBe(2);
+});
+
+test('preserves all non-URL metadata, including nested and falsy values', () => {
+  const metadata = {
+    sku: 'pump-1',
+    description: ' Complete description '.repeat(30),
+    customIds: { mpn: 'MPN-1', gtin: '123456' },
+    attributes: [
+      { label: 'pressure', value: 0, unit: 'bar' },
+      { label: 'available', value: false },
+    ],
+    metadata: { security: 'IP67', empty: '', spaces: ' ', unknown: null },
+    _tags: { productType: 'pump', material: 'steel' },
+  };
+
+  expect(getChatProductMetadata(metadata)).toEqual(metadata);
+});
+
+test('removes URL fields and URL values recursively without mutating products', () => {
+  const product = {
+    sku: 'pump-1',
+    url: '/products/pump-1',
+    productURL: '/products/pump-1',
+    image_url_original: '/images/pump.jpg',
+    imageurl: '/images/pump.jpg',
+    attributes: {
+      documentationUri: '/documents/manual.pdf',
+      href: '/products/pump-1',
+      links: ['https://example.com/manual.pdf'],
+      manual: 'https://example.com/manual.pdf',
+      material: 'steel',
+    },
+    images: [
+      'https://example.com/pump.jpg',
+      { url: '/images/pump.jpg', width: 300 },
+    ],
+    references: [
+      'MPN-1',
+      '//example.com/pump',
+      'blob:https://example.com/image',
+      'data:image/png;base64,aGVsbG8=',
+    ],
+    description: 'Pump details at https://example.com/pump with steel housing',
+  };
+  const snapshot = JSON.stringify(product);
+
+  expect(getChatProductMetadata(product)).toEqual({
+    sku: 'pump-1',
+    attributes: { material: 'steel' },
+    images: [{ width: 300 }],
+    references: ['MPN-1'],
+    description: 'Pump details at  with steel housing',
+  });
+  expect(JSON.stringify(product)).toBe(snapshot);
+});

package/src/utils/chatProductMetadata.ts

@@ -0,0 +1,93 @@
+const urlField = /(?:^|_)(?:urls?|uris?|hrefs?|links?)(?:_|$)/i;
+const urlValue = /(?:https?:\/\/|ftp:\/\/|\/\/|blob:|data:)[^\s"'<>]+/gi;
+
+const attributeFields = [
+  'voltage',
+  'size',
+  'brand',
+  'manufacturer',
+  'material',
+  'type',
+  'category',
+  'color',
+  'dimensions',
+  'power',
+  'current',
+  'connector',
+  'model',
+  'series',
+  'product_line',
+  'product_type',
+];
+
+/** Keep filter traits separate from the complete product context sent to chat. */
+export function getChatProductAttributes(
+  metadata: Record<string, unknown>,
+): Record<string, string | number | boolean> {
+  return Object.fromEntries(
+    Object.entries(metadata).filter(
+      (entry): entry is [string, string | number | boolean] => {
+        const [key, value] = entry;
+        return (
+          attributeFields.includes(key) &&
+          ((typeof value === 'string' && value.trim().length > 0) ||
+            (typeof value === 'number' && Number.isFinite(value)) ||
+            typeof value === 'boolean')
+        );
+      },
+    ),
+  );
+}
+
+export function getChatAttributeFrequency(
+  products: ReadonlyArray<{ metadata: Record<string, unknown> | null }>,
+): Record<string, Record<string, number>> {
+  const frequency = new Map<string, Map<string, number>>();
+  products.forEach(({ metadata }) => {
+    Object.entries(getChatProductAttributes(metadata || {})).forEach(
+      ([key, value]) => {
+        const counts = frequency.get(key) || new Map<string, number>();
+        const text = String(value);
+        counts.set(text, (counts.get(text) || 0) + 1);
+        frequency.set(key, counts);
+      },
+    );
+  });
+  return Object.fromEntries(
+    Array.from(frequency, ([key, counts]) => [key, Object.fromEntries(counts)]),
+  );
+}
+
+function withoutUrls(value: unknown): unknown {
+  if (typeof value === 'string') {
+    const text = value.replace(urlValue, '');
+    return text !== value && !text.trim() ? undefined : text;
+  }
+  if (Array.isArray(value)) {
+    return value.map(withoutUrls).filter(item => item !== undefined);
+  }
+  if (value !== null && typeof value === 'object') {
+    return getChatProductMetadata(value);
+  }
+  return value;
+}
+
+/** Preserve product metadata, including nested attributes, without URL fields or values. */
+export function getChatProductMetadata(
+  product: object,
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(product)
+      .filter(([key]) => {
+        const normalizedKey = key
+          .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+          .replace(/[^a-z0-9]/gi, '_');
+        return (
+          !urlField.test(normalizedKey) &&
+          !/(?:urls?|uris?|hrefs?)$/i.test(normalizedKey)
+        );
+      })
+      .map(([key, value]) => [key, withoutUrls(value)])
+      .filter(([, value]) => value !== undefined),
+  );
+}

package/src/utils/compressImage.ts

@@ -28,9 +28,9 @@ export const compressImage = async (input: string | Blob): Promise<string> => {
 
   return new Promise<string>((resolve, reject) => {
     new Compressor(blob, {
-      quality: 0.91,
-      maxHeight: 1024,
-      maxWidth: 1024,
+      quality: window.settings.jpegQuality,
+      maxHeight: window.settings.maxHeight,
+      maxWidth: window.settings.maxWidth,
       strict: true,
       success: compressedResult => {
         const reader = new FileReader();