@nyris/nyris-webapp 0.3.91 → 0.3.92

package/src/stores/request/filter/filter.slice.ts

@@ -4,17 +4,17 @@ import { initialState } from './filter.initialState';
 
 const filterSlice: StateCreator<FilterState & FilterAction> = set => ({
   ...initialState,
-  setAlgoliaFilter: filter => set(state => ({ algoliaFilter: filter })),
-  setPreFilter: filter => set(state => ({ preFilter: filter })),
+  setAlgoliaFilter: filter => set(() => ({ algoliaFilter: filter })),
+  setPreFilter: filter => set(() => ({ preFilter: filter })),
   setFirstSearchPreFilter: filter =>
-    set(state => ({ firstSearchPreFilter: filter })),
+    set(() => ({ firstSearchPreFilter: filter })),
   setSpecificationFilter: filter =>
-    set(state => ({ specificationFilter: filter })),
-  setPreFilterList: filter => set(state => ({ preFilterList: filter })),
+    set(() => ({ specificationFilter: filter })),
+  setPreFilterList: filter => set(() => ({ preFilterList: filter })),
   setPreFilterLoading: isLoading =>
-    set(state => ({ preFilterLoading: isLoading })),
+    set(() => ({ preFilterLoading: isLoading })),
   setPostFilterSelections: filters =>
-    set(state => ({ postFilterSelections: filters })),
+    set(() => ({ postFilterSelections: filters })),
   togglePostFilterSelection: (attribute, value) =>
     set(state => {
       const current = state.postFilterSelections?.[attribute] || [];
@@ -32,7 +32,7 @@ const filterSlice: StateCreator<FilterState & FilterAction> = set => ({
 
       return { postFilterSelections: nextSelections };
     }),
-  clearPostFilterSelections: () => set(state => ({ postFilterSelections: {} })),
+  clearPostFilterSelections: () => set(() => ({ postFilterSelections: {} })),
 });
 
 export default filterSlice;

package/src/stores/request/query/query.slice.ts

@@ -4,8 +4,8 @@ import { initialState } from './query.initialState';
 
 const querySlice: StateCreator<QueryState & QueryAction> = set => ({
   ...initialState,
-  setQuery: query => set(state => ({ query: query })),
-  setValueInput: value => set(state => ({ valueInput: value })),
+  setQuery: query => set(() => ({ query: query })),
+  setValueInput: value => set(() => ({ valueInput: value })),
 });
 
 export default querySlice;

package/src/stores/request/requestImage/requestImage.slice.ts

@@ -10,9 +10,9 @@ const requestImageSlice: StateCreator<
   addRequestImage: image =>
     set(state => ({ requestImages: [...state.requestImages, image] })),
 
-  setRequestImages: images => set(state => ({ requestImages: images })),
+  setRequestImages: images => set(() => ({ requestImages: images })),
 
-  setFirstSearchImage: image => set(state => ({ firstSearchImage: image })),
+  setFirstSearchImage: image => set(() => ({ firstSearchImage: image })),
 
   removeImage: index => {
     const images = get().requestImages;
@@ -22,7 +22,7 @@ const requestImageSlice: StateCreator<
       return;
     }
     updatedImages.splice(index, 1);
-    set(state => ({ requestImages: updatedImages }));
+    set(() => ({ requestImages: updatedImages }));
   },
 
   updateRegion: (region, index) => {
@@ -30,12 +30,12 @@ const requestImageSlice: StateCreator<
     let updatedRegions = [...regions];
     updatedRegions[index] = region;
 
-    set(state => ({ regions: updatedRegions }));
+    set(() => ({ regions: updatedRegions }));
   },
 
-  setRegions: regions => set(state => ({ regions: regions })),
+  setRegions: regions => set(() => ({ regions: regions })),
   resetRegions: () =>
-    set(state => ({
+    set(() => ({
       regions: [Array(3)].map(() => {
         return { x1: 0, x2: 1, y1: 0, y2: 1 };
       }),

package/src/stores/request/specifications/specifications.slice.ts

@@ -2,14 +2,17 @@ import { SpecificationAction, SpecificationState } from 'stores/types';
 import { StateCreator } from 'zustand';
 import { initialState } from './specifications.initialState';
 
-const filterSlice: StateCreator<SpecificationState & SpecificationAction> = set => ({
+const filterSlice: StateCreator<
+  SpecificationState & SpecificationAction
+> = set => ({
   ...initialState,
-  setSpecifications: specifications => set(state => ({ specifications })),
-  setNameplateNotificationText: nameplateNotificationText => set(state => ({ nameplateNotificationText })),
-  setShowLoading: showLoading => set(state => ({ showLoading })),
-  setNameplateImage: nameplateImage => set(state => ({ nameplateImage })),
-  setShowNotMatchedError: showNotMatchedError => set(state => ({ showNotMatchedError })),
-
+  setSpecifications: specifications => set(() => ({ specifications })),
+  setNameplateNotificationText: nameplateNotificationText =>
+    set(() => ({ nameplateNotificationText })),
+  setShowLoading: showLoading => set(() => ({ showLoading })),
+  setNameplateImage: nameplateImage => set(() => ({ nameplateImage })),
+  setShowNotMatchedError: showNotMatchedError =>
+    set(() => ({ showNotMatchedError })),
 });
 
 export default filterSlice;

package/src/stores/result/detectedRegions/detectedRegions.slice.ts

@@ -10,7 +10,7 @@ const detectedRegionsSlice: StateCreator<
     const detectedObject = get().detectedRegions;
     let updatedDetectedObject = { ...detectedObject };
     updatedDetectedObject[index] = region;
-    set(state => ({ detectedRegions: updatedDetectedObject }));
+    set(() => ({ detectedRegions: updatedDetectedObject }));
   },
 });
 

package/src/stores/result/prodcuts/products.initialState.ts

@@ -19,4 +19,16 @@ export const initialState: ProductsState = {
   googleGroundingResponse: null,
   groundingFilterResult: [],
   showingGroundingFilterResult: false,
+  groundingError: null,
+  firstAlgoliaProducts: [],
+  fullResultPool: [],
+  smartFilters: {
+    status: 'idle',
+    filters: [],
+    selectedFilterKey: null,
+    selectedFilterValue: null,
+    rerankedSkus: [],
+    rerankStatus: 'idle',
+    errorMessage: null,
+  },
 };

package/src/stores/result/prodcuts/products.slice.ts

@@ -5,34 +5,34 @@ import { ProductsAction, ProductsState } from 'stores/types';
 const productsSlice: StateCreator<ProductsState & ProductsAction> = set => ({
   ...initialState,
   setAlgoliaProducts: products =>
-    set(state => ({ productsFromAlgolia: products })),
+    set(() => ({ productsFromAlgolia: products })),
   setFindApiProducts: products =>
-    set(state => ({ productsFromFindApi: products })),
+    set(() => ({ productsFromFindApi: products })),
   setFirstSearchResults: products =>
-    set(state => ({ firstSearchResults: products })),
+    set(() => ({ firstSearchResults: products })),
   setImageAnalysis: analysis =>
-    set(state => ({
+    set(() => ({
       imageAnalysis: {
         ...analysis,
       },
     })),
   setSpecificationFilteredProducts: products =>
-    set(state => ({
+    set(() => ({
       specificationFilteredProducts: products,
     })),
   setFirstRequestImageAnalysis: analysis =>
-    set(state => ({
+    set(() => ({
       firstRequestImageAnalysis: {
         ...analysis,
       },
     })),
   setGoogleGroundingResponse: result =>
-    set(state => ({
+    set(() => ({
       googleGroundingResponse: result,
     })),
 
   setGroundingFilterResult: result =>
-    set(state => ({
+    set(() => ({
       groundingFilterResult: result,
     })),
   setShowingGroundingFilterResult: (val?: boolean) =>
@@ -41,6 +41,26 @@ const productsSlice: StateCreator<ProductsState & ProductsAction> = set => ({
         ? { showingGroundingFilterResult: !state.showingGroundingFilterResult }
         : { showingGroundingFilterResult: val },
     ),
+  setGroundingError: error =>
+    set(() => ({
+      groundingError: error,
+    })),
+
+  setFullResultPool: products =>
+    set(() => ({
+      fullResultPool: products,
+    })),
+  resetGrounding: () =>
+    set(() => ({
+      groundingError: null,
+      groundingFilterResult: [],
+      googleGroundingResponse: null,
+      showingGroundingFilterResult: false,
+    })),
+  setSmartFilters: smartFilters =>
+    set(() => ({
+      smartFilters,
+    })),
 });
 
 export default productsSlice;

package/src/stores/result/session/session.slice.ts

@@ -4,8 +4,8 @@ import { SessionAction, SessionState } from 'stores/types';
 
 const sessionSlice: StateCreator<SessionState & SessionAction> = set => ({
   ...initialState,
-  setSessionId: (sessionId: string) => set(state => ({ sessionId })),
-  setRequestId: (requestId: string) => set(state => ({ requestId })),
+  setSessionId: (sessionId: string) => set(() => ({ sessionId })),
+  setRequestId: (requestId: string) => set(() => ({ requestId })),
 });
 
 export default sessionSlice;

package/src/stores/smartFilters/smartFiltersStore.ts

@@ -0,0 +1,270 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+export interface SmartFilter {
+  id: string;
+  label: string;
+  value: string;
+  type: 'ai-generated';
+}
+
+export interface RerankedResult {
+  sku: string;
+  score: number;
+  reasoning: string;
+  matchedFilters: string[];
+  originalRank: number;
+  currentRank: number;
+}
+
+interface SmartFiltersState {
+  // API Keys (persisted in localStorage for admin convenience)
+  nyrisApiKeyOverride: string; // Override for nyris API key (empty = use settings.js)
+
+  // Settings
+  includeReasoning: boolean; // Toggle for AI reasoning (slower but more informative)
+  backgroundRemovalEnabled: boolean; // Toggle for rembg background removal
+  backgroundRemovalModel: string; // rembg model to use
+  sam3Enabled: boolean; // Toggle for SAM 3 segmentation
+  sam3ServerUrl: string; // SAM 3 server URL (ngrok/remote)
+  sam3SegmentOnClickOnly: boolean; // When true: search on upload, segment only when user clicks
+  chatWithDbEnabled: boolean; // P6: extract filters from product description, query full index / MongoDB
+  chatWithDbApiUrl: string; // Backend API URL for Chat with DB (MongoDB etc.)
+  googleGroundingEnabled: boolean; // P7: validate bad results via Google Search
+  visualRerankEnabled: boolean; // Visual reranking: 1:1 image comparison
+  showFilterChips: boolean; // Toggle visibility of Smart Filter chips (independent of Chat Assistant)
+
+  // Filters
+  filters: SmartFilter[];
+  selectedFilters: SmartFilter[];
+
+  // Reranking (Smart Filters)
+  rerankedResults: RerankedResult[];
+  originalRankings: Record<string, number>;
+  isReranked: boolean;
+
+  // Visual Reranking state
+  isVisualReranked: boolean;
+  isVisualReranking: boolean;
+  visualRerankRankings: Record<
+    string,
+    { originalRank: number; newRank: number; score: number; reasoning: string }
+  >;
+
+  // Loading states
+  isGeneratingFilters: boolean;
+  isReranking: boolean;
+
+  // Error
+  error: string | null;
+}
+
+interface SmartFiltersActions {
+  // API Key actions
+  setNyrisApiKeyOverride: (key: string) => void;
+
+  // Settings
+  setIncludeReasoning: (include: boolean) => void;
+  setBackgroundRemovalEnabled: (enabled: boolean) => void;
+  setBackgroundRemovalModel: (model: string) => void;
+  setSam3Enabled: (enabled: boolean) => void;
+  setSam3ServerUrl: (url: string) => void;
+  setSam3SegmentOnClickOnly: (onClickOnly: boolean) => void;
+  setChatWithDbEnabled: (enabled: boolean) => void;
+  setChatWithDbApiUrl: (url: string) => void;
+  setGoogleGroundingEnabled: (enabled: boolean) => void;
+  setVisualRerankEnabled: (enabled: boolean) => void;
+  setShowFilterChips: (show: boolean) => void;
+
+  // Filter actions
+  setFilters: (filters: SmartFilter[]) => void;
+  toggleFilter: (filter: SmartFilter) => void;
+  clearSelectedFilters: () => void;
+
+  // Reranking actions (Smart Filters)
+  setRerankedResults: (results: RerankedResult[]) => void;
+  setOriginalRankings: (rankings: Record<string, number>) => void;
+  setIsReranked: (isReranked: boolean) => void;
+  clearReranking: () => void;
+
+  // Visual Reranking actions
+  setIsVisualReranked: (isReranked: boolean) => void;
+  setIsVisualReranking: (loading: boolean) => void;
+  setVisualRerankRankings: (
+    rankings: Record<
+      string,
+      {
+        originalRank: number;
+        newRank: number;
+        score: number;
+        reasoning: string;
+      }
+    >,
+  ) => void;
+  clearVisualReranking: () => void;
+
+  // Loading states
+  setIsGeneratingFilters: (loading: boolean) => void;
+  setIsReranking: (loading: boolean) => void;
+
+  // Error
+  setError: (error: string | null) => void;
+
+  // Reset
+  reset: () => void;
+}
+
+const initialState: SmartFiltersState = {
+  nyrisApiKeyOverride: '',
+  includeReasoning: false, // Default: off for faster filtering
+  backgroundRemovalEnabled: false, // Default: off (needs rembg server)
+  backgroundRemovalModel: 'isnet-general-use', // Default model
+  sam3Enabled: false, // Default: off (needs server setup)
+  sam3ServerUrl: '', // No default - user must configure
+  sam3SegmentOnClickOnly: true, // Search first, segment only on click
+  chatWithDbEnabled: true, // P6 enabled by default
+  chatWithDbApiUrl: '', // No default - use Algolia fallback until backend is configured
+  googleGroundingEnabled: false, // P7 off by default
+  visualRerankEnabled: false, // Visual reranking off by default
+  showFilterChips: false, // Smart Filter chips hidden by default
+  filters: [],
+  selectedFilters: [],
+  rerankedResults: [],
+  originalRankings: {},
+  isReranked: false,
+  isVisualReranked: false,
+  isVisualReranking: false,
+  visualRerankRankings: {},
+  isGeneratingFilters: false,
+  isReranking: false,
+  error: null,
+};
+
+const useSmartFiltersStore = create<SmartFiltersState & SmartFiltersActions>()(
+  persist(
+    (set, _get) => ({
+      ...initialState,
+
+      setNyrisApiKeyOverride: key => set({ nyrisApiKeyOverride: key }),
+      setIncludeReasoning: include => set({ includeReasoning: include }),
+      setBackgroundRemovalEnabled: enabled =>
+        set({ backgroundRemovalEnabled: enabled }),
+      setBackgroundRemovalModel: model =>
+        set({ backgroundRemovalModel: model }),
+      setSam3Enabled: enabled => set({ sam3Enabled: enabled }),
+      setSam3ServerUrl: url => set({ sam3ServerUrl: url }),
+      setSam3SegmentOnClickOnly: onClickOnly =>
+        set({ sam3SegmentOnClickOnly: onClickOnly }),
+      setChatWithDbEnabled: enabled => set({ chatWithDbEnabled: enabled }),
+      setChatWithDbApiUrl: url => set({ chatWithDbApiUrl: url }),
+      setGoogleGroundingEnabled: enabled =>
+        set({ googleGroundingEnabled: enabled }),
+      setVisualRerankEnabled: enabled => set({ visualRerankEnabled: enabled }),
+      setShowFilterChips: show => set({ showFilterChips: show }),
+
+      setFilters: filters => set({ filters }),
+
+      toggleFilter: filter =>
+        set(state => {
+          const isSelected = state.selectedFilters.some(
+            f => f.id === filter.id,
+          );
+          if (isSelected) {
+            return {
+              selectedFilters: state.selectedFilters.filter(
+                f => f.id !== filter.id,
+              ),
+            };
+          } else {
+            return { selectedFilters: [...state.selectedFilters, filter] };
+          }
+        }),
+
+      clearSelectedFilters: () =>
+        set({
+          selectedFilters: [],
+          isReranked: false,
+          rerankedResults: [],
+        }),
+
+      setRerankedResults: results => set({ rerankedResults: results }),
+      setOriginalRankings: rankings => set({ originalRankings: rankings }),
+      setIsReranked: isReranked => set({ isReranked }),
+
+      clearReranking: () =>
+        set({
+          rerankedResults: [],
+          isReranked: false,
+        }),
+
+      setIsVisualReranked: isReranked => set({ isVisualReranked: isReranked }),
+      setIsVisualReranking: loading => set({ isVisualReranking: loading }),
+      setVisualRerankRankings: rankings =>
+        set({ visualRerankRankings: rankings }),
+      clearVisualReranking: () =>
+        set({
+          isVisualReranked: false,
+          isVisualReranking: false,
+          visualRerankRankings: {},
+        }),
+
+      setIsGeneratingFilters: loading => set({ isGeneratingFilters: loading }),
+      setIsReranking: loading => set({ isReranking: loading }),
+
+      setError: error => set({ error }),
+
+      reset: () =>
+        set({
+          filters: [],
+          selectedFilters: [],
+          rerankedResults: [],
+          originalRankings: {},
+          isReranked: false,
+          isVisualReranked: false,
+          isVisualReranking: false,
+          visualRerankRankings: {},
+          isGeneratingFilters: false,
+          isReranking: false,
+          error: null,
+        }),
+    }),
+    {
+      name: 'smart-filters-storage',
+      version: 3.2,
+      migrate: (persisted: unknown, version: number) => {
+        const state = persisted as Partial<SmartFiltersState>;
+        if (version < 2) {
+          state.backgroundRemovalEnabled = false;
+          state.googleGroundingEnabled = false;
+          state.visualRerankEnabled = false;
+          state.showFilterChips = false;
+          state.sam3Enabled = false;
+        }
+        // v3.1: removed geminiApiKey and geminiModel
+        delete (state as any).geminiApiKey;
+        delete (state as any).geminiModel;
+        // v3.2: removed prompt customization and admin modal state
+        delete (state as any).filterPrompt;
+        delete (state as any).rerankPrompt;
+        delete (state as any).showAdminSettings;
+        return state;
+      },
+      partialize: state => ({
+        nyrisApiKeyOverride: state.nyrisApiKeyOverride,
+        includeReasoning: state.includeReasoning,
+        backgroundRemovalEnabled: state.backgroundRemovalEnabled,
+        backgroundRemovalModel: state.backgroundRemovalModel,
+        sam3Enabled: state.sam3Enabled,
+        sam3ServerUrl: state.sam3ServerUrl,
+        sam3SegmentOnClickOnly: state.sam3SegmentOnClickOnly,
+        chatWithDbEnabled: state.chatWithDbEnabled,
+        chatWithDbApiUrl: state.chatWithDbApiUrl,
+        googleGroundingEnabled: state.googleGroundingEnabled,
+        visualRerankEnabled: state.visualRerankEnabled,
+        showFilterChips: state.showFilterChips,
+      }),
+    },
+  ),
+);
+
+export default useSmartFiltersStore;

package/src/stores/types.ts

@@ -33,6 +33,15 @@ export interface LoadingState {
   isGoogleGroundingLoading: boolean;
 }
 
+export interface AiUiState {
+  isAiModeOpen: boolean;
+}
+
+export interface AiUiAction {
+  setIsAiModeOpen: (isOpen: boolean) => void;
+  toggleAiMode: () => void;
+}
+
 export interface LoadingAction {
   setIsFindApiLoading: (isLoading: boolean) => void;
   setIsAlgoliaLoading: (isLoading: boolean) => void;
@@ -59,6 +68,23 @@ export interface ProductsState {
   googleGroundingResponse: Record<string, any> | null;
   groundingFilterResult: any[];
   showingGroundingFilterResult: boolean;
+  groundingError: string | null;
+  firstAlgoliaProducts: any[];
+  fullResultPool: any[];
+    smartFilters: {
+        status: 'idle' | 'loading' | 'success' | 'error';
+        filters: Array<{
+            key: string;
+            label: string;
+            value: string;
+            selected?: boolean;
+        }>;
+        selectedFilterKey: string | null;
+        selectedFilterValue: string | null;
+        rerankedSkus: string[];
+        rerankStatus: 'idle' | 'loading' | 'success' | 'error';
+        errorMessage: string | null;
+    };
 }
 
 export interface ProductsAction {
@@ -75,6 +101,10 @@ export interface ProductsAction {
   setGoogleGroundingResponse: (result: any | null) => void;
   setGroundingFilterResult: (result: any[]) => void;
   setShowingGroundingFilterResult: (val?: boolean) => void;
+  setGroundingError: (error: string | null) => void;
+  setFullResultPool: (products: any[]) => void;
+  resetGrounding: () => void;
+  setSmartFilters: (smartFilters: ProductsState['smartFilters']) => void;
 }
 
 export interface DetectedRegionsState {
@@ -125,6 +155,17 @@ export interface FeedbackAction {
   setShowFeedback: (show: boolean) => void;
 }
 
+export interface BannerState {
+  bannerGoBack: boolean;
+  bannerTextSearch: 'loading' | 'resolved' | 'pending';
+}
+
+export interface BannerAction {
+  setBannerGoBack: (goBack: boolean) => void;
+  setBannerTextSearch: (textSearch: 'loading' | 'resolved' | 'pending') => void;
+  resetBanner: () => void;
+}
+
 export interface SidePanelState {
   showSidePanel: boolean;
 }

package/src/stores/ui/ai/ai.initialState.ts

@@ -0,0 +1,5 @@
+import { AiUiState } from 'stores/types';
+
+export const initialState: AiUiState = {
+  isAiModeOpen: false,
+};

package/src/stores/ui/ai/ai.slice.ts

@@ -0,0 +1,15 @@
+import { StateCreator } from 'zustand';
+import { initialState } from './ai.initialState';
+import { AiUiAction, AiUiState } from 'stores/types';
+
+const aiSlice: StateCreator<AiUiState & AiUiAction> = set => ({
+  ...initialState,
+  setIsAiModeOpen: (isOpen: boolean) => {
+    set(() => ({ isAiModeOpen: isOpen }));
+  },
+  toggleAiMode: () => {
+    set(state => ({ isAiModeOpen: !state.isAiModeOpen }));
+  },
+});
+
+export default aiSlice;

package/src/stores/ui/banner/banner.initialState.ts

@@ -0,0 +1,6 @@
+import { BannerState } from 'stores/types';
+
+export const initialState: BannerState = {
+  bannerGoBack: false,
+  bannerTextSearch: 'pending',
+};

package/src/stores/ui/banner/banner.slice.ts

@@ -0,0 +1,14 @@
+import { StateCreator } from 'zustand';
+import { BannerAction, BannerState } from 'stores/types';
+
+import { initialState } from './banner.initialState';
+
+const bannerSlice: StateCreator<BannerState & BannerAction> = set => ({
+  ...initialState,
+  setBannerGoBack: (bannerGoBack: boolean) => set({ bannerGoBack }),
+  setBannerTextSearch: (bannerTextSearch: 'loading' | 'resolved' | 'pending') =>
+    set({ bannerTextSearch }),
+  resetBanner: () => set({ ...initialState }),
+});
+
+export default bannerSlice;

package/src/stores/ui/feedback/feedback.slice.ts

@@ -5,7 +5,7 @@ import { initialState } from './feedback.initialState';
 
 const feedbackSlice: StateCreator<FeedbackState & FeedbackAction> = set => ({
   ...initialState,
-  setShowFeedback: (showFeedback: boolean) => set(state => ({ showFeedback })),
+  setShowFeedback: (showFeedback: boolean) => set(() => ({ showFeedback })),
 });
 
 export default feedbackSlice;

package/src/stores/ui/loading/loading.slice.ts

@@ -5,13 +5,13 @@ import { LoadingAction, LoadingState } from 'stores/types';
 const loadingSlice: StateCreator<LoadingState & LoadingAction> = set => ({
   ...initialState,
   setIsAlgoliaLoading: (isLoading: boolean) =>
-    set(state => ({ isAlgoliaLoading: isLoading })),
+    set(() => ({ isAlgoliaLoading: isLoading })),
   setIsFindApiLoading: (isLoading: boolean) =>
-    set(state => ({ isFindApiLoading: isLoading })),
+    set(() => ({ isFindApiLoading: isLoading })),
   setIsCadenasLoaded: (isLoading: boolean) =>
-    set(state => ({ isCadenasLoaded: isLoading })),
+    set(() => ({ isCadenasLoaded: isLoading })),
   setIsGoogleGroundingLoading: isLoading =>
-    set(state => ({
+    set(() => ({
       isGoogleGroundingLoading: isLoading,
     })),
 });

package/src/stores/ui/uiStore.ts

@@ -2,14 +2,20 @@ import { create } from 'zustand';
 import loadingSlice from './loading/loading.slice';
 import feedbackSlice from './feedback/feedback.slice';
 import sidePanelSlice from './sidePanel/sidePanel.slice';
+import aiSlice from './ai/ai.slice';
+import bannerSlice from './banner/banner.slice';
 
 type UiStore = ReturnType<typeof loadingSlice> &
   ReturnType<typeof feedbackSlice> &
-  ReturnType<typeof sidePanelSlice>;
+  ReturnType<typeof sidePanelSlice> &
+  ReturnType<typeof aiSlice> &
+  ReturnType<typeof bannerSlice>;
 
 const useUiStore = create<UiStore>()((...a) => ({
   ...loadingSlice(...a),
   ...feedbackSlice(...a),
   ...sidePanelSlice(...a),
+  ...aiSlice(...a),
+  ...bannerSlice(...a),
 }));
 export default useUiStore;

package/src/styles/product.scss

@@ -1,9 +1,7 @@
 .wrap-main-item-result {
     display: flex;
     flex-direction: column;
-    border-radius: 12px;
     overflow: hidden;
-    box-shadow: 0px 0px 16px rgba(224, 224, 224, 0.8);
 
     @media screen and (max-width: 776px) {
         .wrap-main-item-result {