@lobehub/lobehub 2.0.0-next.21 → 2.0.0-next.23

package/packages/database/migrations/meta/_journal.json

@@ -294,6 +294,13 @@
       "when": 1761878697451,
       "tag": "0041_improve_index",
       "breakpoints": true
+    },
+    {
+      "idx": 42,
+      "version": "7",
+      "when": 1762232313711,
+      "tag": "0042_improve_agent_index",
+      "breakpoints": true
     }
   ],
   "version": "6"

package/packages/database/src/core/migrations.json

@@ -746,5 +746,13 @@
     "bps": true,
     "folderMillis": 1761878697451,
     "hash": "2f740719356c4ea28a4f71b6089595871f6e185e056b43288a7d16f7d0aae196"
+  },
+  {
+    "sql": [
+      "CREATE INDEX \"agents_knowledge_bases_agent_id_idx\" ON \"agents_knowledge_bases\" USING btree (\"agent_id\");"
+    ],
+    "bps": true,
+    "folderMillis": 1762232313711,
+    "hash": "8988ec15592e000430d76566323f437b2ebde46122c5f7172067cd0a65f99614"
   }
 ]

package/packages/database/src/models/agent.ts

@@ -28,19 +28,21 @@ export class AgentModel {
   };
 
   getAgentAssignedKnowledge = async (id: string) => {
-    const knowledgeBaseResult = await this.db
-      .select({ enabled: agentsKnowledgeBases.enabled, knowledgeBases })
-      .from(agentsKnowledgeBases)
-      .where(eq(agentsKnowledgeBases.agentId, id))
-      .orderBy(desc(agentsKnowledgeBases.createdAt))
-      .leftJoin(knowledgeBases, eq(knowledgeBases.id, agentsKnowledgeBases.knowledgeBaseId));
-
-    const fileResult = await this.db
-      .select({ enabled: agentsFiles.enabled, files })
-      .from(agentsFiles)
-      .where(eq(agentsFiles.agentId, id))
-      .orderBy(desc(agentsFiles.createdAt))
-      .leftJoin(files, eq(files.id, agentsFiles.fileId));
+    // Run both queries in parallel for better performance
+    const [knowledgeBaseResult, fileResult] = await Promise.all([
+      this.db
+        .select({ enabled: agentsKnowledgeBases.enabled, knowledgeBases })
+        .from(agentsKnowledgeBases)
+        .where(eq(agentsKnowledgeBases.agentId, id))
+        .orderBy(desc(agentsKnowledgeBases.createdAt))
+        .leftJoin(knowledgeBases, eq(knowledgeBases.id, agentsKnowledgeBases.knowledgeBaseId)),
+      this.db
+        .select({ enabled: agentsFiles.enabled, files })
+        .from(agentsFiles)
+        .where(eq(agentsFiles.agentId, id))
+        .orderBy(desc(agentsFiles.createdAt))
+        .leftJoin(files, eq(files.id, agentsFiles.fileId)),
+    ]);
 
     return {
       files: fileResult.map((item) => ({
@@ -61,6 +63,7 @@ export class AgentModel {
     const item = await this.db.query.agentsToSessions.findFirst({
       where: eq(agentsToSessions.sessionId, sessionId),
     });
+
     if (!item) return;
 
     const agentId = item.agentId;

package/packages/database/src/models/session.ts

@@ -123,17 +123,28 @@ export class SessionModel {
   findByIdOrSlug = async (
     idOrSlug: string,
   ): Promise<(SessionItem & { agent: AgentItem }) | undefined> => {
-    const result = await this.db.query.sessions.findFirst({
-      where: and(
-        or(eq(sessions.id, idOrSlug), eq(sessions.slug, idOrSlug)),
-        eq(sessions.userId, this.userId),
-      ),
-      with: { agentsToSessions: { columns: {}, with: { agent: true } }, group: true },
-    });
+    // Use leftJoin instead of nested 'with' for better performance
+    const result = await this.db
+      .select({
+        agent: agents,
+        group: sessionGroups,
+        session: sessions,
+      })
+      .from(sessions)
+      .where(
+        and(
+          or(eq(sessions.id, idOrSlug), eq(sessions.slug, idOrSlug)),
+          eq(sessions.userId, this.userId),
+        ),
+      )
+      .leftJoin(agentsToSessions, eq(sessions.id, agentsToSessions.sessionId))
+      .leftJoin(agents, eq(agentsToSessions.agentId, agents.id))
+      .leftJoin(sessionGroups, eq(sessions.groupId, sessionGroups.id))
+      .limit(1);
 
-    if (!result) return;
+    if (!result || !result[0]) return;
 
-    return { ...result, agent: (result?.agentsToSessions?.[0] as any)?.agent } as any;
+    return { ...result[0].session, agent: result[0].agent, group: result[0].group } as any;
   };
 
   count = async (params?: {

package/packages/database/src/models/user.ts

@@ -82,7 +82,8 @@ export class UserModel {
       })
       .from(users)
       .where(eq(users.id, this.userId))
-      .leftJoin(userSettings, eq(users.id, userSettings.id));
+      .leftJoin(userSettings, eq(users.id, userSettings.id))
+      .limit(1);
 
     if (!result || !result[0]) {
       throw new UserNotFoundError();

package/packages/database/src/schemas/agent.ts

@@ -90,7 +90,10 @@ export const agentsKnowledgeBases = pgTable(
 
     ...timestamps,
   },
-  (t) => [primaryKey({ columns: [t.agentId, t.knowledgeBaseId] })],
+  (t) => [
+    primaryKey({ columns: [t.agentId, t.knowledgeBaseId] }),
+    index('agents_knowledge_bases_agent_id_idx').on(t.agentId),
+  ],
 );
 
 export const agentsFiles = pgTable(

package/packages/memory-extract/package.json

@@ -10,7 +10,7 @@
     "@lobechat/model-runtime": "workspace:*",
     "@lobechat/prompts": "workspace:*",
     "dotenv": "^17.2.3",
-    "ora": "^8.2.0"
+    "ora": "^9.0.0"
   },
   "devDependencies": {
     "tsx": "^4.19.2"

package/packages/types/src/message/ui/params.ts

@@ -130,10 +130,10 @@ export const CreateMessageParamsSchema = z
     files: z.array(z.string()).optional(),
     fromModel: z.string().optional(),
     fromProvider: z.string().optional(),
-    groupId: z.string().optional(),
+    groupId: z.string().nullable().optional(),
     targetId: z.string().nullable().optional(),
     threadId: z.string().nullable().optional(),
-    topicId: z.string().optional(),
+    topicId: z.string().nullable().optional(),
     traceId: z.string().optional(),
     // Allow additional fields from UIChatMessage (many can be null)
     agentId: z.string().optional(),
@@ -180,9 +180,9 @@ export const CreateNewMessageParamsSchema = z
     plugin: ChatPluginPayloadSchema.optional(),
     // Grouping
     parentId: z.string().optional(),
-    groupId: z.string().optional(),
+    groupId: z.string().nullable().optional(),
     // Context
-    topicId: z.string().optional(),
+    topicId: z.string().nullable().optional(),
     threadId: z.string().nullable().optional(),
     targetId: z.string().nullable().optional(),
     // Model info

package/renovate.json

@@ -15,28 +15,64 @@
     "workarounds:all"
   ],
   "ignoreDeps": [],
-  "labels": [
-    "dependencies"
-  ],
+  "labels": ["dependencies"],
   "packageRules": [
+    // 1) Pinned deps: isolate (OK to use separate* here because there's no matchUpdateTypes)
+    {
+      "description": "Isolate PRs for pinned deps (exact x.y.z)",
+      "matchManagers": ["npm", "pnpm", "yarn", "bun"],
+      "matchDepTypes": [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+        "peerDependencies"
+      ],
+      "matchCurrentValue": "^\\d+\\.\\d+\\.\\d+([+-][0-9A-Za-z.-]+)?$",
+      "groupName": null,
+      "separateMinorPatch": true,
+      "separateMajorMinor": true,
+      "separateMultipleMinor": true,
+      "separateMultipleMajor": true
+    },
+    // 2a) Non-pinned deps: override splitting so patch+minor can be combined
     {
-      "groupName": "all non-minor dependencies",
-      "groupSlug": "all-minor-patch",
-      "matchPackageNames": [
-        "*"
+      "description": "Non-pinned deps: allow patch+minor to group; keep majors separate",
+      "matchManagers": ["npm", "pnpm", "yarn", "bun"],
+      "matchDepTypes": [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+        "peerDependencies"
       ],
-      "matchUpdateTypes": [
-        "patch"
-      ]
+      "matchCurrentValue": "/(^[~^]|[<>=| -])/", // anything that looks like a range
+      "separateMinorPatch": false,
+      "separateMajorMinor": true
+    },
+    // 2b) Non-pinned deps: actually group patch+minor together
+    {
+      "description": "Non-pinned deps: group non-major updates",
+      "matchManagers": ["npm", "pnpm", "yarn", "bun"],
+      "matchDepTypes": [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+        "peerDependencies"
+      ],
+      "matchCurrentValue": "/(^[~^]|[<>=| -])/",
+      "matchUpdateTypes": ["minor", "patch"], // only non-majors
+      "groupName": "deps (non-major)"
     }
   ],
-  "postUpdateOptions": [
-    "yarnDedupeHighest"
-  ],
+  "postUpdateOptions": ["yarnDedupeHighest"],
   "prConcurrentLimit": 30,
   "prHourlyLimit": 0,
   "rangeStrategy": "bump",
   "rebaseWhen": "conflicted",
   "schedule": "on sunday before 6:00am",
+  "separateMajorMinor": true,
+  // Global defaults are fine; rule 2a overrides minor/patch splitting for ranged deps
+  "separateMinorPatch": true,
+  "separateMultipleMajor": true,
+  "separateMultipleMinor": true,
   "timezone": "UTC"
 }

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

@@ -283,5 +283,3 @@ export const messageRouter = router({
       return ctx.messageModel.updateTranslate(input.id, input.value);
     }),
 });
-
-export type MessageRouter = typeof messageRouter;

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

@@ -30,7 +30,9 @@ const userProcedure = authedProcedure.use(serverDatabase).use(async ({ ctx, next
     ctx: {
       clerkAuth: new ClerkAuth(),
       fileService: new FileService(ctx.serverDB, ctx.userId),
+      messageModel: new MessageModel(ctx.serverDB, ctx.userId),
       nextAuthUserService: new NextAuthUserService(ctx.serverDB),
+      sessionModel: new SessionModel(ctx.serverDB, ctx.userId),
       userModel: new UserModel(ctx.serverDB, ctx.userId),
     },
   });
@@ -97,12 +99,12 @@ export const userRouter = router({
       }
     }
 
-    const messageModel = new MessageModel(ctx.serverDB, ctx.userId);
-    const hasMoreThan4Messages = await messageModel.hasMoreThanN(4);
-
-    const sessionModel = new SessionModel(ctx.serverDB, ctx.userId);
-    const hasAnyMessages = await messageModel.hasMoreThanN(0);
-    const hasExtraSession = await sessionModel.hasMoreThanN(1);
+    // Run all count queries in parallel
+    const [hasMoreThan4Messages, hasAnyMessages, hasExtraSession] = await Promise.all([
+      ctx.messageModel.hasMoreThanN(4),
+      ctx.messageModel.hasMoreThanN(0),
+      ctx.sessionModel.hasMoreThanN(1),
+    ]);
 
     return {
       avatar: state.avatar,