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

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,
+};

package/src/styles/antdOverride.ts

@@ -1,3 +1,4 @@
+import { isDesktop } from '@lobechat/const';
 import { type Theme, css } from 'antd-style';
 import { rgba } from 'polished';
 
@@ -16,4 +17,12 @@ export default ({ token }: { prefixCls: string; token: Theme }) => css`
     background: ${rgba(token.colorBgLayout, 0.5)} !important;
     backdrop-filter: blur(2px);
   }
+
+  ${isDesktop &&
+  css`
+    .${token.prefixCls}-modal-mask.${token.prefixCls}-modal-mask-blur {
+      background: ${rgba(token.colorBgLayout, 0.8)} !important;
+      backdrop-filter: none !important;
+    }
+  `}
 `;

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

@@ -1,13 +0,0 @@
-import { router } from './shared';
-import { reembedRouter } from './reembed';
-import { searchRouter } from './search';
-import { toolsRouter } from './tools';
-
-// Re-export searchUserMemories for potential external use
-export { searchUserMemories } from './search';
-
-export const userMemoriesRouter = router({
-  ...reembedRouter._def.procedures,
-  ...searchRouter._def.procedures,
-  tools: toolsRouter,
-});

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

@@ -1,440 +0,0 @@
-import { asc, eq, gte, lte } from 'drizzle-orm';
-import pMap from 'p-map';
-import { z } from 'zod';
-
-import {
-  userMemories,
-  userMemoriesContexts,
-  userMemoriesExperiences,
-  userMemoriesIdentities,
-  userMemoriesPreferences,
-} from '@/database/schemas';
-
-import {
-  EMBEDDING_VECTOR_DIMENSION,
-  combineConditions,
-  getEmbeddingRuntime,
-  memoryProcedure,
-  normalizeEmbeddable,
-  router,
-} from './shared';
-
-const REEMBED_TABLE_KEYS = [
-  'userMemories',
-  'contexts',
-  'preferences',
-  'identities',
-  'experiences',
-] as const;
-type ReEmbedTableKey = (typeof REEMBED_TABLE_KEYS)[number];
-
-const reEmbedInputSchema = z.object({
-  concurrency: z.coerce.number().int().min(1).max(50).optional(),
-  endDate: z.coerce.date().optional(),
-  limit: z.coerce.number().int().min(1).optional(),
-  only: z.array(z.enum(REEMBED_TABLE_KEYS)).optional(),
-  startDate: z.coerce.date().optional(),
-});
-
-interface ReEmbedStats {
-  failed: number;
-  skipped: number;
-  succeeded: number;
-  total: number;
-}
-
-export const reembedRouter = router({
-  reEmbedMemories: memoryProcedure
-    .input(reEmbedInputSchema.optional())
-    .mutation(async ({ ctx, input }) => {
-      try {
-        const options = input ?? {};
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const concurrency = options.concurrency ?? 10;
-        const shouldProcess = (key: ReEmbedTableKey) =>
-          !options.only || options.only.length === 0 || options.only.includes(key);
-
-        const embedTexts = async (texts: string[]): Promise<number[][]> => {
-          if (texts.length === 0) return [];
-
-          const response = await agentRuntime.embeddings({
-            dimensions: EMBEDDING_VECTOR_DIMENSION,
-            input: texts,
-            model: embeddingModel,
-          });
-
-          if (!response || response.length !== texts.length) {
-            throw new Error('Embedding response length mismatch');
-          }
-
-          return response;
-        };
-
-        const results: Partial<Record<ReEmbedTableKey, ReEmbedStats>> = {};
-
-        const run = async (key: ReEmbedTableKey, handler: () => Promise<ReEmbedStats>) => {
-          if (!shouldProcess(key)) return;
-          results[key] = await handler();
-        };
-
-        // Re-embed userMemories
-        await run('userMemories', async () => {
-          const where = combineConditions([
-            eq(userMemories.userId, ctx.userId),
-            options.startDate ? gte(userMemories.createdAt, options.startDate) : undefined,
-            options.endDate ? lte(userMemories.createdAt, options.endDate) : undefined,
-          ]);
-
-          const rows = await ctx.serverDB.query.userMemories.findMany({
-            columns: { details: true, id: true, summary: true },
-            limit: options.limit,
-            orderBy: [asc(userMemories.createdAt)],
-            where,
-          });
-
-          let succeeded = 0;
-          let failed = 0;
-          let skipped = 0;
-
-          await pMap(
-            rows,
-            async (row) => {
-              const summaryText = normalizeEmbeddable(row.summary);
-              const detailsText = normalizeEmbeddable(row.details);
-
-              try {
-                if (!summaryText && !detailsText) {
-                  await ctx.memoryModel.updateUserMemoryVectors(row.id, {
-                    detailsVector1024: null,
-                    summaryVector1024: null,
-                  });
-                  skipped += 1;
-                  return;
-                }
-
-                const inputs: string[] = [];
-                if (summaryText) inputs.push(summaryText);
-                if (detailsText) inputs.push(detailsText);
-
-                const embeddings = await embedTexts(inputs);
-                let embedIndex = 0;
-
-                const summaryVector = summaryText ? (embeddings[embedIndex++] ?? null) : null;
-                const detailsVector = detailsText ? (embeddings[embedIndex++] ?? null) : null;
-
-                await ctx.memoryModel.updateUserMemoryVectors(row.id, {
-                  detailsVector1024: detailsVector,
-                  summaryVector1024: summaryVector,
-                });
-
-                succeeded += 1;
-              } catch (err) {
-                failed += 1;
-                console.error(
-                  `[memoryRouter.reEmbed] Failed to re-embed user memory ${row.id}`,
-                  err,
-                );
-              }
-            },
-            { concurrency },
-          );
-
-          return {
-            failed,
-            skipped,
-            succeeded,
-            total: rows.length,
-          } satisfies ReEmbedStats;
-        });
-
-        // Re-embed contexts
-        await run('contexts', async () => {
-          const where = combineConditions([
-            eq(userMemoriesContexts.userId, ctx.userId),
-            options.startDate ? gte(userMemoriesContexts.createdAt, options.startDate) : undefined,
-            options.endDate ? lte(userMemoriesContexts.createdAt, options.endDate) : undefined,
-          ]);
-
-          const rows = await ctx.serverDB.query.userMemoriesContexts.findMany({
-            columns: { description: true, id: true },
-            limit: options.limit,
-            orderBy: [asc(userMemoriesContexts.createdAt)],
-            where,
-          });
-
-          let succeeded = 0;
-          let failed = 0;
-          let skipped = 0;
-
-          await pMap(
-            rows,
-            async (row) => {
-              const description = normalizeEmbeddable(row.description);
-
-              try {
-                if (!description) {
-                  await ctx.memoryModel.updateContextVectors(row.id, {
-                    descriptionVector: null,
-                  });
-                  skipped += 1;
-                  return;
-                }
-
-                const [embedding] = await embedTexts([description]);
-
-                await ctx.memoryModel.updateContextVectors(row.id, {
-                  descriptionVector: embedding ?? null,
-                });
-                succeeded += 1;
-              } catch (err) {
-                failed += 1;
-                console.error(`[memoryRouter.reEmbed] Failed to re-embed context ${row.id}`, err);
-              }
-            },
-            { concurrency },
-          );
-
-          return {
-            failed,
-            skipped,
-            succeeded,
-            total: rows.length,
-          } satisfies ReEmbedStats;
-        });
-
-        // Re-embed preferences
-        await run('preferences', async () => {
-          const where = combineConditions([
-            eq(userMemoriesPreferences.userId, ctx.userId),
-            options.startDate
-              ? gte(userMemoriesPreferences.createdAt, options.startDate)
-              : undefined,
-            options.endDate ? lte(userMemoriesPreferences.createdAt, options.endDate) : undefined,
-          ]);
-
-          const rows = await ctx.serverDB.query.userMemoriesPreferences.findMany({
-            columns: { conclusionDirectives: true, id: true },
-            limit: options.limit,
-            orderBy: [asc(userMemoriesPreferences.createdAt)],
-            where,
-          });
-
-          let succeeded = 0;
-          let failed = 0;
-          let skipped = 0;
-
-          await pMap(
-            rows,
-            async (row) => {
-              const directives = normalizeEmbeddable(row.conclusionDirectives);
-
-              try {
-                if (!directives) {
-                  await ctx.memoryModel.updatePreferenceVectors(row.id, {
-                    conclusionDirectivesVector: null,
-                  });
-                  skipped += 1;
-                  return;
-                }
-
-                const [embedding] = await embedTexts([directives]);
-                await ctx.memoryModel.updatePreferenceVectors(row.id, {
-                  conclusionDirectivesVector: embedding ?? null,
-                });
-                succeeded += 1;
-              } catch (err) {
-                failed += 1;
-                console.error(
-                  `[memoryRouter.reEmbed] Failed to re-embed preference ${row.id}`,
-                  err,
-                );
-              }
-            },
-            { concurrency },
-          );
-
-          return {
-            failed,
-            skipped,
-            succeeded,
-            total: rows.length,
-          } satisfies ReEmbedStats;
-        });
-
-        // Re-embed identities
-        await run('identities', async () => {
-          const where = combineConditions([
-            eq(userMemoriesIdentities.userId, ctx.userId),
-            options.startDate
-              ? gte(userMemoriesIdentities.createdAt, options.startDate)
-              : undefined,
-            options.endDate ? lte(userMemoriesIdentities.createdAt, options.endDate) : undefined,
-          ]);
-
-          const rows = await ctx.serverDB.query.userMemoriesIdentities.findMany({
-            columns: { description: true, id: true },
-            limit: options.limit,
-            orderBy: [asc(userMemoriesIdentities.createdAt)],
-            where,
-          });
-
-          let succeeded = 0;
-          let failed = 0;
-          let skipped = 0;
-
-          await pMap(
-            rows,
-            async (row) => {
-              const description = normalizeEmbeddable(row.description);
-
-              try {
-                if (!description) {
-                  await ctx.memoryModel.updateIdentityVectors(row.id, {
-                    descriptionVector: null,
-                  });
-                  skipped += 1;
-                  return;
-                }
-
-                const [embedding] = await embedTexts([description]);
-                await ctx.memoryModel.updateIdentityVectors(row.id, {
-                  descriptionVector: embedding ?? null,
-                });
-                succeeded += 1;
-              } catch (err) {
-                failed += 1;
-                console.error(`[memoryRouter.reEmbed] Failed to re-embed identity ${row.id}`, err);
-              }
-            },
-            { concurrency },
-          );
-
-          return {
-            failed,
-            skipped,
-            succeeded,
-            total: rows.length,
-          } satisfies ReEmbedStats;
-        });
-
-        // Re-embed experiences
-        await run('experiences', async () => {
-          const where = combineConditions([
-            eq(userMemoriesExperiences.userId, ctx.userId),
-            options.startDate
-              ? gte(userMemoriesExperiences.createdAt, options.startDate)
-              : undefined,
-            options.endDate ? lte(userMemoriesExperiences.createdAt, options.endDate) : undefined,
-          ]);
-
-          const rows = await ctx.serverDB.query.userMemoriesExperiences.findMany({
-            columns: { action: true, id: true, keyLearning: true, situation: true },
-            limit: options.limit,
-            orderBy: [asc(userMemoriesExperiences.createdAt)],
-            where,
-          });
-
-          let succeeded = 0;
-          let failed = 0;
-          let skipped = 0;
-
-          await pMap(
-            rows,
-            async (row) => {
-              const situation = normalizeEmbeddable(row.situation);
-              const action = normalizeEmbeddable(row.action);
-              const keyLearning = normalizeEmbeddable(row.keyLearning);
-
-              try {
-                if (!situation && !action && !keyLearning) {
-                  await ctx.memoryModel.updateExperienceVectors(row.id, {
-                    actionVector: null,
-                    keyLearningVector: null,
-                    situationVector: null,
-                  });
-                  skipped += 1;
-                  return;
-                }
-
-                const inputs: string[] = [];
-                if (situation) inputs.push(situation);
-                if (action) inputs.push(action);
-                if (keyLearning) inputs.push(keyLearning);
-
-                const embeddings = await embedTexts(inputs);
-                let embedIndex = 0;
-
-                const situationVector = situation ? (embeddings[embedIndex++] ?? null) : null;
-                const actionVector = action ? (embeddings[embedIndex++] ?? null) : null;
-                const keyLearningVector = keyLearning ? (embeddings[embedIndex++] ?? null) : null;
-
-                await ctx.memoryModel.updateExperienceVectors(row.id, {
-                  actionVector,
-                  keyLearningVector,
-                  situationVector,
-                });
-                succeeded += 1;
-              } catch (err) {
-                failed += 1;
-                console.error(
-                  `[memoryRouter.reEmbed] Failed to re-embed experience ${row.id}`,
-                  err,
-                );
-              }
-            },
-            { concurrency },
-          );
-
-          return {
-            failed,
-            skipped,
-            succeeded,
-            total: rows.length,
-          } satisfies ReEmbedStats;
-        });
-
-        const processedEntries = Object.entries(results) as Array<[ReEmbedTableKey, ReEmbedStats]>;
-
-        if (processedEntries.length === 0) {
-          return {
-            message: 'No memory records matched re-embed criteria',
-            results,
-            success: true,
-          };
-        }
-
-        const aggregate = processedEntries.reduce(
-          (acc, [, stats]) => {
-            acc.failed += stats.failed;
-            acc.skipped += stats.skipped;
-            acc.succeeded += stats.succeeded;
-            acc.total += stats.total;
-
-            return acc;
-          },
-          { failed: 0, skipped: 0, succeeded: 0, total: 0 },
-        );
-
-        const message =
-          aggregate.total === 0
-            ? 'No memory records required re-embedding'
-            : `Re-embedded ${aggregate.succeeded} of ${aggregate.total} records`;
-
-        return {
-          aggregate,
-          message,
-          results,
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to re-embed memories:', error);
-        return {
-          message: `Failed to re-embed memories: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-});