@lobehub/lobehub 2.0.0-next.342 → 2.0.0-next.343

package/src/features/SkillStore/LobeHubList/Item.tsx

@@ -8,7 +8,7 @@ import { Loader2, MoreVerticalIcon, Plus, Unplug } from 'lucide-react';
 import React, { memo } from 'react';
 import { useTranslation } from 'react-i18next';
 
-import { useItemStyles } from '../style';
+import { itemStyles } from '../style';
 import { useSkillConnect } from './useSkillConnect';
 
 interface ItemProps {
@@ -25,7 +25,7 @@ interface ItemProps {
 const Item = memo<ItemProps>(
   ({ description, icon, identifier, label, onOpenDetail, serverName, type }) => {
     const { t } = useTranslation('setting');
-    const { styles } = useItemStyles();
+    const styles = itemStyles;
     const { modal } = App.useApp();
 
     const { handleConnect, handleDisconnect, isConnected, isConnecting } = useSkillConnect({

package/src/features/SkillStore/LobeHubList/index.tsx

@@ -1,7 +1,7 @@
 'use client';
 
 import { KLAVIS_SERVER_TYPES, LOBEHUB_SKILL_PROVIDERS } from '@lobechat/const';
-import { createStyles } from 'antd-style';
+import { createStaticStyles } from 'antd-style';
 import isEqual from 'fast-deep-equal';
 import type { Klavis } from 'klavis';
 import { memo, useMemo, useState } from 'react';
@@ -17,7 +17,7 @@ import Empty from '../Empty';
 import Item from './Item';
 import { useSkillConnect } from './useSkillConnect';
 
-const useStyles = createStyles(({ css }) => ({
+const styles = createStaticStyles(({ css }) => ({
   grid: css`
     display: grid;
     grid-template-columns: repeat(2, 1fr);
@@ -69,7 +69,6 @@ const DetailModalWithConnect = memo<DetailModalWithConnectProps>(({ detailState,
 DetailModalWithConnect.displayName = 'DetailModalWithConnect';
 
 export const LobeHubList = memo<LobeHubListProps>(({ keywords }) => {
-  const { styles } = useStyles();
   const [detailState, setDetailState] = useState<DetailState | null>(null);
 
   const isLobehubSkillEnabled = useServerConfigStore(serverConfigSelectors.enableLobehubSkill);

package/src/features/SkillStore/style.ts

@@ -1,6 +1,6 @@
-import { createStyles } from 'antd-style';
+import { createStaticStyles } from 'antd-style';
 
-export const useItemStyles = createStyles(({ css, token }) => ({
+export const itemStyles = createStaticStyles(({ css, cssVar }) => ({
   container: css`
     position: relative;
     overflow: hidden;
@@ -11,7 +11,7 @@ export const useItemStyles = createStyles(({ css, token }) => ({
     overflow: hidden;
 
     font-size: 12px;
-    color: ${token.colorTextSecondary};
+    color: ${cssVar.colorTextSecondary};
     text-overflow: ellipsis;
     white-space: nowrap;
   `,
@@ -20,7 +20,7 @@ export const useItemStyles = createStyles(({ css, token }) => ({
 
     font-size: 14px;
     font-weight: 500;
-    color: ${token.colorText};
+    color: ${cssVar.colorText};
     text-overflow: ellipsis;
     white-space: nowrap;
   `,

package/src/layout/GlobalProvider/ServerVersionOutdatedAlert.tsx

@@ -1,9 +1,9 @@
 'use client';
 
 import { Button, Flexbox, Icon } from '@lobehub/ui';
-import { createStyles } from 'antd-style';
+import { createStaticStyles, useTheme } from 'antd-style';
 import { TriangleAlert, X } from 'lucide-react';
-import { useState } from 'react';
+import { useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { MANUAL_UPGRADE_URL } from '@/const/url';
@@ -12,7 +12,7 @@ import { useElectronStore } from '@/store/electron';
 import { electronSyncSelectors } from '@/store/electron/selectors';
 import { useGlobalStore } from '@/store/global';
 
-const useStyles = createStyles(({ css, token }) => ({
+const styles = createStaticStyles(({ css, cssVar }) => ({
   closeButton: css`
     cursor: pointer;
 
@@ -26,15 +26,15 @@ const useStyles = createStyles(({ css, token }) => ({
 
     width: 28px;
     height: 28px;
-    border-radius: ${token.borderRadius}px;
+    border-radius: ${cssVar.borderRadius};
 
-    color: ${token.colorTextSecondary};
+    color: ${cssVar.colorTextSecondary};
 
     transition: all 0.2s;
 
     &:hover {
-      color: ${token.colorText};
-      background: ${token.colorFillSecondary};
+      color: ${cssVar.colorText};
+      background: ${cssVar.colorFillSecondary};
     }
   `,
   container: css`
@@ -46,7 +46,7 @@ const useStyles = createStyles(({ css, token }) => ({
     align-items: center;
     justify-content: center;
 
-    background: ${token.colorBgMask};
+    background: ${cssVar.colorBgMask};
   `,
   content: css`
     position: relative;
@@ -55,47 +55,55 @@ const useStyles = createStyles(({ css, token }) => ({
 
     max-width: 480px;
     padding: 24px;
-    border: 1px solid ${token.yellowBorder};
-    border-radius: ${token.borderRadiusLG}px;
+    border: 1px solid var(--content-yellow-border, ${cssVar.colorWarningBorder});
+    border-radius: ${cssVar.borderRadiusLG};
 
-    background: ${token.colorBgContainer};
-    box-shadow: ${token.boxShadowSecondary};
+    background: ${cssVar.colorBgContainer};
+    box-shadow: ${cssVar.boxShadowSecondary};
   `,
   desc: css`
     line-height: 1.6;
-    color: ${token.colorTextSecondary};
+    color: ${cssVar.colorTextSecondary};
   `,
   title: css`
     font-size: 16px;
     font-weight: bold;
-    color: ${token.colorWarningText};
+    color: ${cssVar.colorWarningText};
   `,
   titleIcon: css`
     flex-shrink: 0;
-    color: ${token.colorWarning};
+    color: ${cssVar.colorWarning};
   `,
   warning: css`
     padding: 12px;
-    border-radius: ${token.borderRadius}px;
-    color: ${token.colorWarningText};
-    background: ${token.yellowBg};
+    border-radius: ${cssVar.borderRadius};
+    color: ${cssVar.colorWarningText};
+    background: var(--warning-yellow-bg, ${cssVar.colorWarningBg});
   `,
 }));
 
 const ServerVersionOutdatedAlert = () => {
-  const { styles } = useStyles();
+  const theme = useTheme();
   const { t } = useTranslation('common');
   const [dismissed, setDismissed] = useState(false);
   const isServerVersionOutdated = useGlobalStore((s) => s.isServerVersionOutdated);
   const storageMode = useElectronStore(electronSyncSelectors.storageMode);
 
+  const cssVariables = useMemo<Record<string, string>>(
+    () => ({
+      '--content-yellow-border': theme.yellowBorder,
+      '--warning-yellow-bg': theme.yellowBg,
+    }),
+    [theme.yellowBorder, theme.yellowBg],
+  );
+
   // Only show alert when using self-hosted server, not cloud
   if (storageMode !== 'selfHost') return null;
   if (!isServerVersionOutdated || dismissed) return null;
 
   return (
     <div className={styles.container}>
-      <div className={styles.content}>
+      <div className={styles.content} style={cssVariables}>
         <div className={styles.closeButton} onClick={() => setDismissed(true)}>
           <Icon icon={X} />
         </div>

package/src/server/routers/lambda/userMemories.ts

@@ -21,6 +21,7 @@ import { z } from 'zod';
 import {
   type IdentityEntryBasePayload,
   type IdentityEntryPayload,
+  UserMemoryExperienceModel,
   UserMemoryIdentityModel,
   UserMemoryModel,
 } from '@/database/models/userMemory';
@@ -203,6 +204,8 @@ const memoryProcedure = authedProcedure.use(serverDatabase).use(async (opts) =>
   const { ctx } = opts;
   return opts.next({
     ctx: {
+      experienceModel: new UserMemoryExperienceModel(ctx.serverDB, ctx.userId),
+      identityModel: new UserMemoryIdentityModel(ctx.serverDB, ctx.userId),
       memoryModel: new UserMemoryModel(ctx.serverDB, ctx.userId),
     },
   });
@@ -220,13 +223,66 @@ export const userMemoriesRouter = router({
       }
     }),
 
-  queryIdentitiesForInjection: authedProcedure
-    .use(serverDatabase)
+  queryExperiences: memoryProcedure
+    .input(
+      z
+        .object({
+          order: z.enum(['asc', 'desc']).optional(),
+          page: z.coerce.number().int().min(1).optional(),
+          pageSize: z.coerce.number().int().min(1).max(100).optional(),
+          q: z.string().optional(),
+          sort: z.enum(['capturedAt', 'scoreConfidence']).optional(),
+          tags: z.array(z.string()).optional(),
+          types: z.array(z.string()).optional(),
+        })
+        .optional(),
+    )
+    .query(async ({ ctx, input }) => {
+      const params = input ?? {};
+      const fallbackPage = params.page ?? 1;
+      const fallbackPageSize = params.pageSize ?? 20;
+
+      try {
+        return await ctx.experienceModel.queryList(params);
+      } catch (error) {
+        console.error('Failed to query experiences:', error);
+        return { items: [], page: fallbackPage, pageSize: fallbackPageSize, total: 0 };
+      }
+    }),
+
+  queryIdentities: memoryProcedure
+    .input(
+      z
+        .object({
+          order: z.enum(['asc', 'desc']).optional(),
+          page: z.coerce.number().int().min(1).optional(),
+          pageSize: z.coerce.number().int().min(1).max(100).optional(),
+          q: z.string().optional(),
+          relationships: z.array(z.string()).optional(),
+          sort: z.enum(['capturedAt', 'type']).optional(),
+          tags: z.array(z.string()).optional(),
+          types: z.array(z.string()).optional(),
+        })
+        .optional(),
+    )
+    .query(async ({ ctx, input }) => {
+      const params = input ?? {};
+      const fallbackPage = params.page ?? 1;
+      const fallbackPageSize = params.pageSize ?? 20;
+
+      try {
+        return await ctx.identityModel.queryList(params);
+      } catch (error) {
+        console.error('Failed to query identities:', error);
+        return { items: [], page: fallbackPage, pageSize: fallbackPageSize, total: 0 };
+      }
+    }),
+
+  queryIdentitiesForInjection: memoryProcedure
     .input(z.object({ limit: z.coerce.number().int().min(1).max(100).optional() }).optional())
     .query(async ({ ctx, input }) => {
       try {
-        const identityModel = new UserMemoryIdentityModel(ctx.serverDB, ctx.userId);
-        return await identityModel.queryForInjection(input?.limit ?? 50);
+        return await ctx.identityModel.queryForInjection(input?.limit ?? 50);
       } catch (error) {
         console.error('Failed to query identities for injection:', error);
         return [];
@@ -262,7 +318,7 @@ export const userMemoriesRouter = router({
           pageSize: z.coerce.number().int().min(1).max(100).optional(),
           q: z.string().optional(),
           sort: z
-            .enum(['scoreConfidence', 'scoreImpact', 'scorePriority', 'scoreUrgency'])
+            .enum(['capturedAt', 'scoreConfidence', 'scoreImpact', 'scorePriority', 'scoreUrgency'])
             .optional(),
           tags: z.array(z.string()).optional(),
           types: z.array(z.string()).optional(),

package/src/server/routers/lambda/userMemory.ts

@@ -27,7 +27,6 @@ const userMemoryProcedure = authedProcedure.use(serverDatabase).use(async (opts)
 
 export const userMemoryRouter = router({
   // ============ Identity CRUD ============
-
   createIdentity: userMemoryProcedure
     .input(CreateUserMemoryIdentitySchema)
     .mutation(async ({ ctx, input }) => {
@@ -83,6 +82,11 @@ export const userMemoryRouter = router({
     return ctx.userMemoryModel.getAllIdentities();
   }),
 
+  // ============ Persona ============
+  getPersona: userMemoryProcedure.query(async () => {
+    return { content: '', summary: '' };
+  }),
+
   getPreferences: userMemoryProcedure.query(async ({ ctx }) => {
     return ctx.userMemoryModel.searchPreferences({});
   }),

package/src/services/chat/index.ts

@@ -10,7 +10,6 @@ import {
 import { AgentRuntimeError, type ChatCompletionErrorPayload } from '@lobechat/model-runtime';
 import {
   ChatErrorType,
-  type MessageMapScope,
   type RuntimeInitialContext,
   type RuntimeStepContext,
   type TracePayload,
@@ -75,7 +74,6 @@ interface GetChatCompletionPayload extends Partial<Omit<ChatStreamPayload, 'mess
    * Required to ensure config consistency and proper isSubTask filtering.
    */
   resolvedAgentConfig: ResolvedAgentConfig;
-  scope?: MessageMapScope;
   topicId?: string;
 }
 
@@ -349,6 +347,8 @@ class ChatService {
     // Get the chat config to check streaming preference
     const chatConfig = agentChatConfigSelectors.currentChatConfig(getAgentStoreState());
 
+    delete (res as any).scope;
+
     const payload = merge(
       {
         model: DEFAULT_AGENT_CONFIG.model,

package/src/services/userMemory/index.ts

@@ -11,6 +11,10 @@ import {
   type AddExperienceMemoryResult,
   type AddIdentityMemoryResult,
   type AddPreferenceMemoryResult,
+  type ExperienceListParams,
+  type ExperienceListResult,
+  type IdentityListParams,
+  type IdentityListResult,
   type LayersEnum,
   type RemoveIdentityMemoryResult,
   type SearchMemoryParams,
@@ -57,6 +61,26 @@ class UserMemoryService {
     return lambdaClient.userMemories.getMemoryDetail.query(params);
   };
 
+  getPersona = async () => {
+    return lambdaClient.userMemory.getPersona.query();
+  };
+
+  /**
+   * Query experiences with pagination, search, and sorting
+   * Returns flat structure optimized for frontend display
+   */
+  queryExperiences = async (params?: ExperienceListParams): Promise<ExperienceListResult> => {
+    return lambdaClient.userMemories.queryExperiences.query(params);
+  };
+
+  /**
+   * Query identities with pagination, search, and sorting
+   * Returns flat structure optimized for frontend display
+   */
+  queryIdentities = async (params?: IdentityListParams): Promise<IdentityListResult> => {
+    return lambdaClient.userMemories.queryIdentities.query(params);
+  };
+
   retrieveMemory = async (params: SearchMemoryParams): Promise<SearchMemoryResult> => {
     return lambdaClient.userMemories.toolSearchMemory.query(params);
   };
@@ -96,7 +120,7 @@ class UserMemoryService {
     page?: number;
     pageSize?: number;
     q?: string;
-    sort?: 'scoreConfidence' | 'scoreImpact' | 'scorePriority' | 'scoreUrgency';
+    sort?: 'capturedAt' | 'scoreConfidence' | 'scoreImpact' | 'scorePriority' | 'scoreUrgency';
     tags?: string[];
     types?: TypesEnum[];
   }) => {

package/src/store/chat/slices/aiChat/actions/streamingExecutor.ts

@@ -481,7 +481,6 @@ export const streamingExecutor: StateCreator<
         // Pass pre-resolved config to avoid duplicate resolveAgentConfig calls
         // This ensures isSubTask filtering and other runtime modifications are preserved
         resolvedAgentConfig: agentConfig,
-        scope, // Pass scope to chat service for page-agent injection
         topicId: topicId ?? undefined, // Pass topicId for GTD context injection
         ...agentConfigData.params,
       },

package/src/store/userMemory/initialState.ts

@@ -1,46 +1,32 @@
 import type { RetrieveMemoryParams, RetrieveMemoryResult } from '@lobechat/types';
 
-import {
-  type DisplayContextMemory,
-  type DisplayExperienceMemory,
-  type DisplayPreferenceMemory,
-} from '@/database/repositories/userMemory';
-
 import { type AgentMemorySliceState, agentMemoryInitialState } from './slices/agent';
+import { type ContextSliceState, contextInitialState } from './slices/context';
+import { type ExperienceSliceState, experienceInitialState } from './slices/experience';
 import { type IdentitySliceState, identityInitialState } from './slices/identity';
+import { type PreferenceSliceState, preferenceInitialState } from './slices/preference';
+
+export interface PersonaData {
+  content: string;
+  summary: string;
+}
 
-export interface UserMemoryStoreState extends AgentMemorySliceState, IdentitySliceState {
+export interface UserMemoryStoreState
+  extends
+    AgentMemorySliceState,
+    ContextSliceState,
+    ExperienceSliceState,
+    IdentitySliceState,
+    PreferenceSliceState {
   activeParams?: RetrieveMemoryParams;
   activeParamsKey?: string;
-  contexts: DisplayContextMemory[];
-  contextsHasMore: boolean;
-  contextsInit: boolean;
-  contextsPage: number;
-  contextsQuery?: string;
-  contextsSearchLoading?: boolean;
-  contextsSort?: 'scoreImpact' | 'scoreUrgency';
-  contextsTotal: number;
   editingMemoryContent?: string;
   editingMemoryId?: string;
   editingMemoryLayer?: 'context' | 'experience' | 'identity' | 'preference';
-  experiences: DisplayExperienceMemory[];
-  experiencesHasMore: boolean;
-  experiencesInit: boolean;
-  experiencesPage: number;
-  experiencesQuery?: string;
-  experiencesSearchLoading?: boolean;
-  experiencesSort?: 'scoreConfidence';
-  experiencesTotal: number;
   memoryFetchedAtMap: Record<string, number>;
   memoryMap: Record<string, RetrieveMemoryResult>;
-  preferences: DisplayPreferenceMemory[];
-  preferencesHasMore: boolean;
-  preferencesInit: boolean;
-  preferencesPage: number;
-  preferencesQuery?: string;
-  preferencesSearchLoading?: boolean;
-  preferencesSort?: 'scorePriority';
-  preferencesTotal: number;
+  persona?: PersonaData;
+  personaInit: boolean;
   roles: { count: number; tag: string }[];
   tags: { count: number; tag: string }[];
   tagsInit: boolean;
@@ -48,35 +34,19 @@ export interface UserMemoryStoreState extends AgentMemorySliceState, IdentitySli
 
 export const initialState: UserMemoryStoreState = {
   ...agentMemoryInitialState,
+  ...contextInitialState,
+  ...experienceInitialState,
   ...identityInitialState,
+  ...preferenceInitialState,
   activeParams: undefined,
   activeParamsKey: undefined,
-  contexts: [],
-  contextsHasMore: true,
-  contextsInit: false,
-  contextsPage: 1,
-  contextsQuery: undefined,
-  contextsSort: undefined,
-  contextsTotal: 0,
   editingMemoryContent: undefined,
   editingMemoryId: undefined,
   editingMemoryLayer: undefined,
-  experiences: [],
-  experiencesHasMore: true,
-  experiencesInit: false,
-  experiencesPage: 1,
-  experiencesQuery: undefined,
-  experiencesSort: undefined,
-  experiencesTotal: 0,
   memoryFetchedAtMap: {},
   memoryMap: {},
-  preferences: [],
-  preferencesHasMore: true,
-  preferencesInit: false,
-  preferencesPage: 1,
-  preferencesQuery: undefined,
-  preferencesSort: undefined,
-  preferencesTotal: 0,
+  persona: undefined,
+  personaInit: false,
   roles: [],
   tags: [],
   tagsInit: false,

package/src/store/userMemory/slices/context/action.ts

@@ -16,7 +16,7 @@ export interface ContextQueryParams {
   page?: number;
   pageSize?: number;
   q?: string;
-  sort?: 'scoreImpact' | 'scoreUrgency';
+  sort?: 'capturedAt' | 'scoreImpact' | 'scoreUrgency';
 }
 
 export interface ContextAction {

package/src/store/userMemory/slices/context/index.ts

@@ -1 +1,2 @@
 export { type ContextAction,createContextSlice } from './action';
+export { contextInitialState, type ContextSliceState } from './initialState';

package/src/store/userMemory/slices/context/initialState.ts

@@ -0,0 +1,22 @@
+import { type DisplayContextMemory } from '@/database/repositories/userMemory';
+
+export interface ContextSliceState {
+  contexts: DisplayContextMemory[];
+  contextsHasMore: boolean;
+  contextsInit: boolean;
+  contextsPage: number;
+  contextsQuery?: string;
+  contextsSearchLoading?: boolean;
+  contextsSort?: 'capturedAt' | 'scoreImpact' | 'scoreUrgency';
+  contextsTotal: number;
+}
+
+export const contextInitialState: ContextSliceState = {
+  contexts: [],
+  contextsHasMore: true,
+  contextsInit: false,
+  contextsPage: 1,
+  contextsQuery: undefined,
+  contextsSort: undefined,
+  contextsTotal: 0,
+};

package/src/store/userMemory/slices/experience/action.ts

@@ -1,3 +1,4 @@
+import type { ExperienceListResult } from '@lobechat/types';
 import { uniqBy } from 'es-toolkit/compat';
 import { produce } from 'immer';
 import useSWR, { type SWRResponse } from 'swr';
@@ -5,7 +6,6 @@ import { type StateCreator } from 'zustand/vanilla';
 
 import { userMemoryService } from '@/services/userMemory';
 import { memoryCRUDService } from '@/services/userMemory/index';
-import { LayersEnum } from '@/types/userMemory';
 import { setNamespace } from '@/utils/storeDebug';
 
 import { type UserMemoryStore } from '../../store';
@@ -16,14 +16,14 @@ export interface ExperienceQueryParams {
   page?: number;
   pageSize?: number;
   q?: string;
-  sort?: 'scoreConfidence';
+  sort?: 'capturedAt' | 'scoreConfidence';
 }
 
 export interface ExperienceAction {
   deleteExperience: (id: string) => Promise<void>;
   loadMoreExperiences: () => void;
   resetExperiencesList: (params?: Omit<ExperienceQueryParams, 'page' | 'pageSize'>) => void;
-  useFetchExperiences: (params: ExperienceQueryParams) => SWRResponse<any>;
+  useFetchExperiences: (params: ExperienceQueryParams) => SWRResponse<ExperienceListResult>;
 }
 
 export const createExperienceSlice: StateCreator<
@@ -81,44 +81,32 @@ export const createExperienceSlice: StateCreator<
     return useSWR(
       swrKey,
       async () => {
-        const result = await userMemoryService.queryMemories({
-          layer: LayersEnum.Experience,
+        // Use the new dedicated queryExperiences API
+        return userMemoryService.queryExperiences({
           page: params.page,
           pageSize: params.pageSize,
           q: params.q,
           sort: params.sort,
         });
-
-        return result;
       },
       {
-        onSuccess(data: any) {
+        onSuccess(data: ExperienceListResult) {
           set(
             produce((draft) => {
               draft.experiencesSearchLoading = false;
+              draft.experiencesTotal = data.total;
 
-              // 设置基础信息
               if (!draft.experiencesInit) {
                 draft.experiencesInit = true;
-                draft.experiencesTotal = data.total;
               }
 
-              // 转换数据结构
-              const transformedItems = data.items.map((item: any) => ({
-                ...item.memory,
-                ...item.experience,
-              }));
-
-              // 累积数据逻辑
+              // Backend now returns flat structure directly, no transformation needed
               if (page === 1) {
-                // 第一页，直接设置
-                draft.experiences = uniqBy(transformedItems, 'id');
+                draft.experiences = uniqBy(data.items, 'id');
               } else {
-                // 后续页面，累积数据
-                draft.experiences = uniqBy([...draft.experiences, ...transformedItems], 'id');
+                draft.experiences = uniqBy([...draft.experiences, ...data.items], 'id');
               }
 
-              // 更新 hasMore
               draft.experiencesHasMore = data.items.length >= (params.pageSize || 20);
             }),
             false,

package/src/store/userMemory/slices/experience/index.ts

@@ -1 +1,2 @@
 export { createExperienceSlice, type ExperienceAction } from './action';
+export { experienceInitialState, type ExperienceSliceState } from './initialState';

package/src/store/userMemory/slices/experience/initialState.ts

@@ -0,0 +1,22 @@
+import type { ExperienceListItem } from '@lobechat/types';
+
+export interface ExperienceSliceState {
+  experiences: ExperienceListItem[];
+  experiencesHasMore: boolean;
+  experiencesInit: boolean;
+  experiencesPage: number;
+  experiencesQuery?: string;
+  experiencesSearchLoading?: boolean;
+  experiencesSort?: 'capturedAt' | 'scoreConfidence';
+  experiencesTotal: number;
+}
+
+export const experienceInitialState: ExperienceSliceState = {
+  experiences: [],
+  experiencesHasMore: true,
+  experiencesInit: false,
+  experiencesPage: 1,
+  experiencesQuery: undefined,
+  experiencesSort: undefined,
+  experiencesTotal: 0,
+};

package/src/store/userMemory/slices/home/action.ts

@@ -5,12 +5,15 @@ import { type QueryIdentityRolesResult } from '@/database/models/userMemory';
 import { useClientDataSWR } from '@/libs/swr';
 import { userMemoryService } from '@/services/userMemory';
 
+import { type PersonaData } from '../../initialState';
 import type { UserMemoryStore } from '../../store';
 
 const FETCH_TAGS_KEY = 'useFetchTags';
+const FETCH_PERSONA_KEY = 'useFetchPersona';
 const n = (namespace: string) => namespace;
 
 export interface HomeAction {
+  useFetchPersona: () => SWRResponse<PersonaData>;
   useFetchTags: () => SWRResponse<QueryIdentityRolesResult>;
 }
 
@@ -20,6 +23,20 @@ export const createHomeSlice: StateCreator<
   [],
   HomeAction
 > = (set) => ({
+  useFetchPersona: () =>
+    useClientDataSWR(FETCH_PERSONA_KEY, () => userMemoryService.getPersona(), {
+      onSuccess: (data: PersonaData | undefined) => {
+        set(
+          {
+            persona: data,
+            personaInit: true,
+          },
+          false,
+          n('useFetchPersona/onSuccess'),
+        );
+      },
+    }),
+
   useFetchTags: () =>
     useClientDataSWR(
       FETCH_TAGS_KEY,