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

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 # Changelog
 
+## [Version 2.0.0-next.342](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.341...v2.0.0-next.342)
+
+<sup>Released on **2026-01-22**</sup>
+
+#### ♻ Code Refactoring
+
+- **userMemories**: Removed un-used code.
+
+#### 🐛 Bug Fixes
+
+- **copilot**: Pass correct scope when creating new session in PageEditor.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **userMemories**: Removed un-used code, closes [#11713](https://github.com/lobehub/lobe-chat/issues/11713) ([89750fc](https://github.com/lobehub/lobe-chat/commit/89750fc))
+
+#### What's fixed
+
+- **copilot**: Pass correct scope when creating new session in PageEditor, closes [#11714](https://github.com/lobehub/lobe-chat/issues/11714) ([0259270](https://github.com/lobehub/lobe-chat/commit/0259270))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.341](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.340...v2.0.0-next.341)
 
 <sup>Released on **2026-01-22**</sup>

package/changelog/v1.json

@@ -1,4 +1,9 @@
 [
+  {
+    "children": {},
+    "date": "2026-01-22",
+    "version": "2.0.0-next.342"
+  },
   {
     "children": {
       "features": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.341",
+  "version": "2.0.0-next.342",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/src/features/PageEditor/Copilot/Toolbar.tsx

@@ -189,7 +189,7 @@ const CopilotToolbar = memo<CopilotToolbarProps>(({ agentId, isHovered }) => {
           <div className={cx(styles.fadeContainer, isHovered ? styles.fadeIn : styles.fadeOut)}>
             <ActionIcon
               icon={PlusIcon}
-              onClick={() => switchTopic()}
+              onClick={() => switchTopic(null, { scope: 'page' })}
               size={DESKTOP_HEADER_ICON_SIZE}
               title={t('actions.addNewTopic')}
             />

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

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

@@ -1,117 +0,0 @@
-import { type LobeChatDatabase } from '@lobechat/database';
-import { type z } from 'zod';
-
-import { DEFAULT_FILE_EMBEDDING_MODEL_ITEM } from '@/const/settings/knowledge';
-import { type UserMemoryModel } from '@/database/models/userMemory';
-import { getServerDefaultFilesConfig } from '@/server/globalConfig';
-import { initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
-import { type SearchMemoryResult, searchMemorySchema } from '@/types/userMemory';
-
-import { EMBEDDING_VECTOR_DIMENSION, memoryProcedure, router } from './shared';
-
-type MemorySearchContext = {
-  memoryModel: UserMemoryModel;
-  serverDB: LobeChatDatabase;
-  userId: string;
-};
-
-type MemorySearchResult = Awaited<ReturnType<UserMemoryModel['searchWithEmbedding']>>;
-
-const EMPTY_SEARCH_RESULT: SearchMemoryResult = {
-  contexts: [],
-  experiences: [],
-  preferences: [],
-};
-
-const mapMemorySearchResult = (layeredResults: MemorySearchResult): SearchMemoryResult => {
-  return {
-    contexts: layeredResults.contexts.map((context) => ({
-      accessedAt: context.accessedAt,
-      associatedObjects: context.associatedObjects,
-      associatedSubjects: context.associatedSubjects,
-      createdAt: context.createdAt,
-      currentStatus: context.currentStatus,
-      description: context.description,
-      id: context.id,
-      metadata: context.metadata,
-      scoreImpact: context.scoreImpact,
-      scoreUrgency: context.scoreUrgency,
-      tags: context.tags,
-      title: context.title,
-      type: context.type,
-      updatedAt: context.updatedAt,
-      userMemoryIds: Array.isArray(context.userMemoryIds)
-        ? (context.userMemoryIds as string[])
-        : null,
-    })),
-    experiences: layeredResults.experiences.map((experience) => ({
-      accessedAt: experience.accessedAt,
-      action: experience.action,
-      createdAt: experience.createdAt,
-      id: experience.id,
-      keyLearning: experience.keyLearning,
-      metadata: experience.metadata,
-      possibleOutcome: experience.possibleOutcome,
-      reasoning: experience.reasoning,
-      scoreConfidence: experience.scoreConfidence,
-      situation: experience.situation,
-      tags: experience.tags,
-      type: experience.type,
-      updatedAt: experience.updatedAt,
-      userMemoryId: experience.userMemoryId,
-    })),
-    preferences: layeredResults.preferences.map((preference) => ({
-      accessedAt: preference.accessedAt,
-      conclusionDirectives: preference.conclusionDirectives,
-      createdAt: preference.createdAt,
-      id: preference.id,
-      metadata: preference.metadata,
-      scorePriority: preference.scorePriority,
-      suggestions: preference.suggestions,
-      tags: preference.tags,
-      type: preference.type,
-      updatedAt: preference.updatedAt,
-      userMemoryId: preference.userMemoryId,
-    })),
-  } satisfies SearchMemoryResult;
-};
-
-export const searchUserMemories = async (
-  ctx: MemorySearchContext,
-  input: z.infer<typeof searchMemorySchema>,
-): Promise<SearchMemoryResult> => {
-  const { provider, model: embeddingModel } =
-    getServerDefaultFilesConfig().embeddingModel || DEFAULT_FILE_EMBEDDING_MODEL_ITEM;
-  // Read user's provider config from database
-  const agentRuntime = await initModelRuntimeFromDB(ctx.serverDB, ctx.userId, provider);
-
-  const queryEmbeddings = await agentRuntime.embeddings({
-    dimensions: EMBEDDING_VECTOR_DIMENSION,
-    input: input.query,
-    model: embeddingModel,
-  });
-
-  const limits = {
-    contexts: input.topK?.contexts,
-    experiences: input.topK?.experiences,
-    preferences: input.topK?.preferences,
-  };
-
-  const layeredResults = await ctx.memoryModel.searchWithEmbedding({
-    embedding: queryEmbeddings?.[0],
-    limits,
-  });
-
-  return mapMemorySearchResult(layeredResults);
-};
-
-export const searchRouter = router({
-  searchMemory: memoryProcedure.input(searchMemorySchema).query(async ({ input, ctx }) => {
-    try {
-      return await searchUserMemories(ctx, input);
-    } catch (error) {
-      console.error('Failed to retrieve memories:', error);
-      return EMPTY_SEARCH_RESULT;
-    }
-  }),
-});

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

@@ -1,63 +0,0 @@
-import { type LobeChatDatabase } from '@lobechat/database';
-import { type SQL, and } from 'drizzle-orm';
-
-import { DEFAULT_FILE_EMBEDDING_MODEL_ITEM } from '@/const/settings/knowledge';
-import { UserMemoryModel } from '@/database/models/userMemory';
-import { authedProcedure } from '@/libs/trpc/lambda';
-import { keyVaults, serverDatabase } from '@/libs/trpc/lambda/middleware';
-import { getServerDefaultFilesConfig } from '@/server/globalConfig';
-import { initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
-
-export const EMBEDDING_VECTOR_DIMENSION = 1024;
-
-export const memoryProcedure = authedProcedure
-  .use(serverDatabase)
-  .use(keyVaults)
-  .use(async (opts) => {
-    const { ctx } = opts;
-    return opts.next({
-      ctx: {
-        memoryModel: new UserMemoryModel(ctx.serverDB, ctx.userId),
-      },
-    });
-  });
-
-export const getEmbeddingRuntime = async (serverDB: LobeChatDatabase, userId: string) => {
-  const { provider, model: embeddingModel } =
-    getServerDefaultFilesConfig().embeddingModel || DEFAULT_FILE_EMBEDDING_MODEL_ITEM;
-  // Read user's provider config from database
-  const agentRuntime = await initModelRuntimeFromDB(serverDB, userId, provider);
-
-  return { agentRuntime, embeddingModel };
-};
-
-export const createEmbedder = (agentRuntime: any, embeddingModel: string) => {
-  return async (value?: string | null): Promise<number[] | undefined> => {
-    if (!value || value.trim().length === 0) return undefined;
-
-    const embeddings = await agentRuntime.embeddings({
-      dimensions: EMBEDDING_VECTOR_DIMENSION,
-      input: value,
-      model: embeddingModel,
-    });
-
-    return embeddings?.[0];
-  };
-};
-
-export const combineConditions = (conditions: Array<SQL | undefined>): SQL | undefined => {
-  const filtered = conditions.filter((condition): condition is SQL => condition !== undefined);
-  if (filtered.length === 0) return undefined;
-  if (filtered.length === 1) return filtered[0];
-
-  return and(...filtered);
-};
-
-export const normalizeEmbeddable = (value?: string | null): string | undefined => {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-
-  return trimmed.length > 0 ? trimmed : undefined;
-};
-
-export { router } from '@/libs/trpc/lambda';

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

@@ -1,410 +0,0 @@
-import {
-  AddIdentityActionSchema,
-  ContextMemoryItemSchema,
-  ExperienceMemoryItemSchema,
-  PreferenceMemoryItemSchema,
-  RemoveIdentityActionSchema,
-  UpdateIdentityActionSchema,
-} from '@lobechat/memory-user-memory';
-import { LayersEnum } from '@lobechat/types';
-
-import {
-  type IdentityEntryBasePayload,
-  type IdentityEntryPayload,
-  UserMemoryModel,
-} from '@/database/models/userMemory';
-import { searchMemorySchema } from '@/types/userMemory';
-
-import { searchUserMemories } from './search';
-import { createEmbedder, getEmbeddingRuntime, memoryProcedure, router } from './shared';
-
-export const toolsRouter = router({
-  addContextMemory: memoryProcedure
-    .input(ContextMemoryItemSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        const summaryEmbedding = await embed(input.summary);
-        const detailsEmbedding = await embed(input.details);
-        const contextDescriptionEmbedding = await embed(input.withContext.description);
-
-        const { context, memory } = await ctx.memoryModel.createContextMemory({
-          context: {
-            associatedObjects:
-              UserMemoryModel.parseAssociatedObjects(input.withContext.associatedObjects) ?? null,
-            associatedSubjects:
-              UserMemoryModel.parseAssociatedSubjects(input.withContext.associatedSubjects) ?? null,
-            currentStatus: input.withContext.currentStatus ?? null,
-            description: input.withContext.description ?? null,
-            descriptionVector: contextDescriptionEmbedding ?? null,
-            metadata: {},
-            scoreImpact: input.withContext.scoreImpact ?? null,
-            scoreUrgency: input.withContext.scoreUrgency ?? null,
-            tags: input.tags ?? [],
-            title: input.withContext.title ?? null,
-            type: input.withContext.type ?? null,
-          },
-          details: input.details || '',
-          detailsEmbedding,
-          memoryCategory: input.memoryCategory,
-          memoryLayer: LayersEnum.Context,
-          memoryType: input.memoryType,
-          summary: input.summary,
-          summaryEmbedding,
-          title: input.title,
-        });
-
-        return {
-          contextId: context.id,
-          memoryId: memory.id,
-          message: 'Memory saved successfully',
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to save memory:', error);
-        return {
-          message: `Failed to save memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  addExperienceMemory: memoryProcedure
-    .input(ExperienceMemoryItemSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        const summaryEmbedding = await embed(input.summary);
-        const detailsEmbedding = await embed(input.details);
-        const situationVector = await embed(input.withExperience.situation);
-        const actionVector = await embed(input.withExperience.action);
-        const keyLearningVector = await embed(input.withExperience.keyLearning);
-
-        const { experience, memory } = await ctx.memoryModel.createExperienceMemory({
-          details: input.details || '',
-          detailsEmbedding,
-          experience: {
-            action: input.withExperience.action ?? null,
-            actionVector: actionVector ?? null,
-            keyLearning: input.withExperience.keyLearning ?? null,
-            keyLearningVector: keyLearningVector ?? null,
-            metadata: {},
-            possibleOutcome: input.withExperience.possibleOutcome ?? null,
-            reasoning: input.withExperience.reasoning ?? null,
-            scoreConfidence: input.withExperience.scoreConfidence ?? null,
-            situation: input.withExperience.situation ?? null,
-            situationVector: situationVector ?? null,
-            tags: input.tags ?? [],
-            type: input.memoryType,
-          },
-          memoryCategory: input.memoryCategory,
-          memoryLayer: LayersEnum.Experience,
-          memoryType: input.memoryType,
-          summary: input.summary,
-          summaryEmbedding,
-          title: input.title,
-        });
-
-        return {
-          experienceId: experience.id,
-          memoryId: memory.id,
-          message: 'Memory saved successfully',
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to save memory:', error);
-        return {
-          message: `Failed to save memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  addIdentityMemory: memoryProcedure
-    .input(AddIdentityActionSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        const summaryEmbedding = await embed(input.summary);
-        const detailsEmbedding = await embed(input.details);
-        const descriptionEmbedding = await embed(input.withIdentity.description);
-
-        const identityMetadata: Record<string, unknown> = {};
-        if (
-          input.withIdentity.scoreConfidence !== null &&
-          input.withIdentity.scoreConfidence !== undefined
-        ) {
-          identityMetadata.scoreConfidence = input.withIdentity.scoreConfidence;
-        }
-        if (
-          input.withIdentity.sourceEvidence !== null &&
-          input.withIdentity.sourceEvidence !== undefined
-        ) {
-          identityMetadata.sourceEvidence = input.withIdentity.sourceEvidence;
-        }
-
-        const { identityId, userMemoryId } = await ctx.memoryModel.addIdentityEntry({
-          base: {
-            details: input.details,
-            detailsVector1024: detailsEmbedding ?? null,
-            memoryCategory: input.memoryCategory,
-            memoryLayer: LayersEnum.Identity,
-            memoryType: input.memoryType,
-            metadata: Object.keys(identityMetadata).length > 0 ? identityMetadata : undefined,
-            summary: input.summary,
-            summaryVector1024: summaryEmbedding ?? null,
-            tags: input.tags,
-            title: input.title,
-          },
-          identity: {
-            description: input.withIdentity.description,
-            descriptionVector: descriptionEmbedding ?? null,
-            episodicDate: input.withIdentity.episodicDate,
-            metadata: Object.keys(identityMetadata).length > 0 ? identityMetadata : undefined,
-            relationship: input.withIdentity.relationship,
-            role: input.withIdentity.role,
-            tags: input.tags,
-            type: input.withIdentity.type,
-          },
-        });
-
-        return {
-          identityId,
-          memoryId: userMemoryId,
-          message: 'Identity memory saved successfully',
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to save identity memory:', error);
-        return {
-          message: `Failed to save identity memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  addPreferenceMemory: memoryProcedure
-    .input(PreferenceMemoryItemSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        const summaryEmbedding = await embed(input.summary);
-        const detailsEmbedding = await embed(input.details);
-        const conclusionVector = await embed(input.withPreference.conclusionDirectives);
-
-        const suggestionsText =
-          input.withPreference?.suggestions?.length && input.withPreference?.suggestions?.length > 0
-            ? input.withPreference?.suggestions?.join('\n')
-            : null;
-
-        const metadata = {
-          appContext: input.withPreference.appContext,
-          extractedScopes: input.withPreference.extractedScopes,
-          originContext: input.withPreference.originContext,
-        } satisfies Record<string, unknown>;
-
-        const { memory, preference } = await ctx.memoryModel.createPreferenceMemory({
-          details: input.details || '',
-          detailsEmbedding,
-          memoryCategory: input.memoryCategory,
-          memoryLayer: LayersEnum.Preference,
-          memoryType: input.memoryType,
-          preference: {
-            conclusionDirectives: input.withPreference.conclusionDirectives || '',
-            conclusionDirectivesVector: conclusionVector ?? null,
-            metadata,
-            scorePriority: input.withPreference.scorePriority ?? null,
-            suggestions: suggestionsText,
-            tags: input.tags,
-            type: input.memoryType,
-          },
-          summary: input.summary,
-          summaryEmbedding,
-          title: input.title,
-        });
-
-        return {
-          memoryId: memory.id,
-          message: 'Memory saved successfully',
-          preferenceId: preference.id,
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to save memory:', error);
-        return {
-          message: `Failed to save memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  removeIdentityMemory: memoryProcedure
-    .input(RemoveIdentityActionSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const removed = await ctx.memoryModel.removeIdentityEntry(input.id);
-
-        if (!removed) {
-          return {
-            message: 'Identity memory not found',
-            success: false,
-          };
-        }
-
-        return {
-          identityId: input.id,
-          message: 'Identity memory removed successfully',
-          reason: input.reason,
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to remove identity memory:', error);
-        return {
-          message: `Failed to remove identity memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  searchMemory: memoryProcedure.input(searchMemorySchema).query(async ({ input, ctx }) => {
-    try {
-      return await searchUserMemories(ctx, input);
-    } catch (error) {
-      console.error('Failed to retrieve memories:', error);
-      return { contexts: [], experiences: [], preferences: [] };
-    }
-  }),
-
-  updateIdentityMemory: memoryProcedure
-    .input(UpdateIdentityActionSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        let summaryVector1024: number[] | null | undefined;
-        if (input.set.summary !== undefined) {
-          const vector = await embed(input.set.summary);
-          summaryVector1024 = vector ?? null;
-        }
-
-        let detailsVector1024: number[] | null | undefined;
-        if (input.set.details !== undefined) {
-          const vector = await embed(input.set.details);
-          detailsVector1024 = vector ?? null;
-        }
-
-        let descriptionVector: number[] | null | undefined;
-        if (input.set.withIdentity.description !== undefined) {
-          const vector = await embed(input.set.withIdentity.description);
-          descriptionVector = vector ?? null;
-        }
-
-        const metadataUpdates: Record<string, unknown> = {};
-        if (Object.hasOwn(input.set.withIdentity, 'scoreConfidence')) {
-          metadataUpdates.scoreConfidence = input.set.withIdentity.scoreConfidence ?? null;
-        }
-        if (Object.hasOwn(input.set.withIdentity, 'sourceEvidence')) {
-          metadataUpdates.sourceEvidence = input.set.withIdentity.sourceEvidence ?? null;
-        }
-
-        const identityPayload: Partial<IdentityEntryPayload> = {};
-        if (input.set.withIdentity.description !== undefined) {
-          identityPayload.description = input.set.withIdentity.description;
-          identityPayload.descriptionVector = descriptionVector;
-        }
-        if (input.set.withIdentity.episodicDate !== undefined) {
-          identityPayload.episodicDate = input.set.withIdentity.episodicDate;
-        }
-        if (input.set.withIdentity.relationship !== undefined) {
-          identityPayload.relationship = input.set.withIdentity.relationship;
-        }
-        if (input.set.withIdentity.role !== undefined) {
-          identityPayload.role = input.set.withIdentity.role;
-        }
-        if (input.set.tags !== undefined) {
-          identityPayload.tags = input.set.tags;
-        }
-        if (input.set.withIdentity.type !== undefined) {
-          identityPayload.type = input.set.withIdentity.type;
-        }
-        if (Object.keys(metadataUpdates).length > 0) {
-          identityPayload.metadata = metadataUpdates;
-        }
-
-        const basePayload: Partial<IdentityEntryBasePayload> = {};
-        if (input.set.details !== undefined) {
-          basePayload.details = input.set.details;
-          basePayload.detailsVector1024 = detailsVector1024;
-        }
-        if (input.set.memoryCategory !== undefined) {
-          basePayload.memoryCategory = input.set.memoryCategory;
-        }
-        if (input.set.memoryType !== undefined) {
-          basePayload.memoryType = input.set.memoryType;
-        }
-        if (input.set.summary !== undefined) {
-          basePayload.summary = input.set.summary;
-          basePayload.summaryVector1024 = summaryVector1024;
-        }
-        if (input.set.tags !== undefined) {
-          basePayload.tags = input.set.tags;
-        }
-        if (input.set.title !== undefined) {
-          basePayload.title = input.set.title;
-        }
-        if (Object.keys(metadataUpdates).length > 0) {
-          basePayload.metadata = metadataUpdates;
-        }
-
-        const updated = await ctx.memoryModel.updateIdentityEntry({
-          base: Object.keys(basePayload).length > 0 ? basePayload : undefined,
-          identity: Object.keys(identityPayload).length > 0 ? identityPayload : undefined,
-          identityId: input.id,
-          mergeStrategy: input.mergeStrategy,
-        });
-
-        if (!updated) {
-          return {
-            message: 'Identity memory not found',
-            success: false,
-          };
-        }
-
-        return {
-          identityId: input.id,
-          message: 'Identity memory updated successfully',
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to update identity memory:', error);
-        return {
-          message: `Failed to update identity memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-});