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

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,

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

@@ -1,7 +1,6 @@
 import {
-  LayersEnum,
+  type IdentityListResult,
   type NewUserMemoryIdentity,
-  type TypesEnum,
   type UpdateUserMemoryIdentity,
 } from '@lobechat/types';
 import { uniqBy } from 'es-toolkit/compat';
@@ -21,7 +20,9 @@ export interface IdentityQueryParams {
   page?: number;
   pageSize?: number;
   q?: string;
-  types?: TypesEnum[];
+  relationships?: string[];
+  sort?: 'capturedAt' | 'type';
+  types?: string[];
 }
 
 export interface IdentityAction {
@@ -30,7 +31,7 @@ export interface IdentityAction {
   loadMoreIdentities: () => void;
   resetIdentitiesList: (params?: Omit<IdentityQueryParams, 'page' | 'pageSize'>) => void;
   updateIdentity: (id: string, data: UpdateUserMemoryIdentity) => Promise<boolean>;
-  useFetchIdentities: (params: IdentityQueryParams) => SWRResponse<any>;
+  useFetchIdentities: (params: IdentityQueryParams) => SWRResponse<IdentityListResult>;
 }
 
 export const createIdentitySlice: StateCreator<
@@ -42,14 +43,24 @@ export const createIdentitySlice: StateCreator<
   createIdentity: async (data) => {
     const result = await memoryCRUDService.createIdentity(data);
     // Reset list to refresh
-    get().resetIdentitiesList({ q: get().identitiesQuery, types: get().identitiesTypes });
+    get().resetIdentitiesList({
+      q: get().identitiesQuery,
+      relationships: get().identitiesRelationships,
+      sort: get().identitiesSort,
+      types: get().identitiesTypes,
+    });
     return result;
   },
 
   deleteIdentity: async (id) => {
     await memoryCRUDService.deleteIdentity(id);
     // Reset list to refresh
-    get().resetIdentitiesList({ q: get().identitiesQuery, types: get().identitiesTypes });
+    get().resetIdentitiesList({
+      q: get().identitiesQuery,
+      relationships: get().identitiesRelationships,
+      sort: get().identitiesSort,
+      types: get().identitiesTypes,
+    });
   },
 
   loadMoreIdentities: () => {
@@ -71,7 +82,9 @@ export const createIdentitySlice: StateCreator<
         draft.identities = [];
         draft.identitiesPage = 1;
         draft.identitiesQuery = params?.q;
+        draft.identitiesRelationships = params?.relationships;
         draft.identitiesSearchLoading = true;
+        draft.identitiesSort = params?.sort;
         draft.identitiesTypes = params?.types;
       }),
       false,
@@ -82,7 +95,12 @@ export const createIdentitySlice: StateCreator<
   updateIdentity: async (id, data) => {
     const result = await memoryCRUDService.updateIdentity(id, data);
     // Reset list to refresh
-    get().resetIdentitiesList({ q: get().identitiesQuery, types: get().identitiesTypes });
+    get().resetIdentitiesList({
+      q: get().identitiesQuery,
+      relationships: get().identitiesRelationships,
+      sort: get().identitiesSort,
+      types: get().identitiesTypes,
+    });
     return result;
   },
 
@@ -92,6 +110,8 @@ export const createIdentitySlice: StateCreator<
       params.page,
       params.pageSize,
       params.q,
+      params.relationships?.join(','),
+      params.sort,
       params.types?.join(','),
     ];
     const swrKey = swrKeyParts
@@ -102,42 +122,34 @@ export const createIdentitySlice: StateCreator<
     return useSWR(
       swrKey,
       async () => {
-        return await userMemoryService.queryMemories({
-          layer: LayersEnum.Identity,
+        // Use the new dedicated queryIdentities API
+        return userMemoryService.queryIdentities({
           page: params.page,
           pageSize: params.pageSize,
           q: params.q,
+          relationships: params.relationships,
+          sort: params.sort,
           types: params.types,
         });
       },
       {
-        onSuccess(data: any) {
+        onSuccess(data: IdentityListResult) {
           set(
             produce((draft) => {
               draft.identitiesSearchLoading = false;
+              draft.identitiesTotal = data.total;
 
-              // 设置基础信息
               if (!draft.identitiesInit) {
                 draft.identitiesInit = true;
-                draft.identitiesTotal = data.total;
               }
 
-              // 转换数据结构
-              const transformedItems = data.items.map((item: any) => ({
-                ...item.memory,
-                ...item.identity,
-              }));
-
-              // 累积数据逻辑
+              // Backend now returns flat structure directly, no transformation needed
               if (page === 1) {
-                // 第一页，直接设置
-                draft.identities = uniqBy(transformedItems, 'id');
+                draft.identities = uniqBy(data.items, 'id');
               } else {
-                // 后续页面，累积数据
-                draft.identities = uniqBy([...draft.identities, ...transformedItems], 'id');
+                draft.identities = uniqBy([...draft.identities, ...data.items], 'id');
               }
 
-              // 更新 hasMore
               draft.identitiesHasMore = data.items.length >= (params.pageSize || 20);
             }),
             false,

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

@@ -1,5 +1,4 @@
-import { type DisplayIdentityMemory } from '@/database/repositories/userMemory';
-import type { TypesEnum } from '@/types/userMemory';
+import type { IdentityListItem, IdentityListSort } from '@lobechat/types';
 
 import type { IdentityForInjection } from '../../types';
 
@@ -10,14 +9,16 @@ export interface IdentitySliceState {
   globalIdentitiesFetchedAt?: number;
   /** Whether global identities have been initialized */
   globalIdentitiesInit: boolean;
-  identities: DisplayIdentityMemory[];
+  identities: IdentityListItem[];
   identitiesHasMore: boolean;
   identitiesInit: boolean;
   identitiesPage: number;
   identitiesQuery?: string;
+  identitiesRelationships?: string[];
   identitiesSearchLoading?: boolean;
+  identitiesSort?: IdentityListSort;
   identitiesTotal: number;
-  identitiesTypes?: TypesEnum[];
+  identitiesTypes?: string[];
 }
 
 export const identityInitialState: IdentitySliceState = {
@@ -29,6 +30,8 @@ export const identityInitialState: IdentitySliceState = {
   identitiesInit: false,
   identitiesPage: 1,
   identitiesQuery: undefined,
+  identitiesRelationships: undefined,
+  identitiesSort: undefined,
   identitiesTotal: 0,
   identitiesTypes: undefined,
 };

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

@@ -16,7 +16,7 @@ export interface PreferenceQueryParams {
   page?: number;
   pageSize?: number;
   q?: string;
-  sort?: 'scorePriority';
+  sort?: 'capturedAt' | 'scorePriority';
 }
 
 export interface PreferenceAction {

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

@@ -1 +1,2 @@
 export { createPreferenceSlice, type PreferenceAction } from './action';
+export { preferenceInitialState, type PreferenceSliceState } from './initialState';

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

@@ -0,0 +1,22 @@
+import { type DisplayPreferenceMemory } from '@/database/repositories/userMemory';
+
+export interface PreferenceSliceState {
+  preferences: DisplayPreferenceMemory[];
+  preferencesHasMore: boolean;
+  preferencesInit: boolean;
+  preferencesPage: number;
+  preferencesQuery?: string;
+  preferencesSearchLoading?: boolean;
+  preferencesSort?: 'capturedAt' | 'scorePriority';
+  preferencesTotal: number;
+}
+
+export const preferenceInitialState: PreferenceSliceState = {
+  preferences: [],
+  preferencesHasMore: true,
+  preferencesInit: false,
+  preferencesPage: 1,
+  preferencesQuery: undefined,
+  preferencesSort: undefined,
+  preferencesTotal: 0,
+};