@lobehub/chat 0.162.25 → 0.163.0

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

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+
+import { PluginModel } from '@/database/server/models/plugin';
+import { authedProcedure, publicProcedure, router } from '@/libs/trpc';
+import { LobeTool } from '@/types/tool';
+
+const pluginProcedure = authedProcedure.use(async (opts) => {
+  const { ctx } = opts;
+
+  return opts.next({
+    ctx: { pluginModel: new PluginModel(ctx.userId) },
+  });
+});
+
+export const pluginRouter = router({
+  createOrInstallPlugin: pluginProcedure
+    .input(
+      z.object({
+        customParams: z.any(),
+        identifier: z.string(),
+        manifest: z.any(),
+        type: z.enum(['plugin', 'customPlugin']),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const result = await ctx.pluginModel.findById(input.identifier);
+
+      // if not exist, we should create the plugin
+      if (!result) {
+        const data = await ctx.pluginModel.create({
+          customParams: input.customParams,
+          identifier: input.identifier,
+          manifest: input.manifest,
+          type: input.type,
+        });
+
+        return data.identifier;
+      }
+
+      // or we can just update the plugin manifest
+      await ctx.pluginModel.update(input.identifier, { manifest: input.manifest });
+    }),
+
+  createPlugin: pluginProcedure
+    .input(
+      z.object({
+        customParams: z.any(),
+        identifier: z.string(),
+        manifest: z.any(),
+        type: z.enum(['plugin', 'customPlugin']),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const data = await ctx.pluginModel.create({
+        customParams: input.customParams,
+        identifier: input.identifier,
+        manifest: input.manifest,
+        type: input.type,
+      });
+
+      return data.identifier;
+    }),
+
+  getPlugins: publicProcedure.query(async ({ ctx }): Promise<LobeTool[]> => {
+    if (!ctx.userId) return [];
+
+    const pluginModel = new PluginModel(ctx.userId);
+
+    return pluginModel.query();
+  }),
+
+  removeAllPlugins: pluginProcedure.mutation(async ({ ctx }) => {
+    return ctx.pluginModel.deleteAll();
+  }),
+
+  removePlugin: pluginProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.pluginModel.delete(input.id);
+    }),
+
+  updatePlugin: pluginProcedure
+    .input(
+      z.object({
+        customParams: z.any().optional(),
+        id: z.string(),
+        manifest: z.any().optional(),
+        settings: z.any().optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.pluginModel.update(input.id, {
+        customParams: input.customParams,
+        manifest: input.manifest,
+        settings: input.settings,
+      });
+    }),
+});
+
+export type PluginRouter = typeof pluginRouter;

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

@@ -0,0 +1,194 @@
+import { z } from 'zod';
+
+import { INBOX_SESSION_ID } from '@/const/session';
+import { SessionModel } from '@/database/server/models/session';
+import { SessionGroupModel } from '@/database/server/models/sessionGroup';
+import { insertAgentSchema, insertSessionSchema } from '@/database/server/schemas/lobechat';
+import { pino } from '@/libs/logger';
+import { authedProcedure, publicProcedure, router } from '@/libs/trpc';
+import { AgentChatConfigSchema } from '@/types/agent';
+import { LobeMetaDataSchema } from '@/types/meta';
+import { BatchTaskResult } from '@/types/service';
+import { ChatSessionList } from '@/types/session';
+import { merge } from '@/utils/merge';
+
+const sessionProcedure = authedProcedure.use(async (opts) => {
+  const { ctx } = opts;
+
+  return opts.next({
+    ctx: {
+      sessionGroupModel: new SessionGroupModel(ctx.userId),
+      sessionModel: new SessionModel(ctx.userId),
+    },
+  });
+});
+
+export const sessionRouter = router({
+  batchCreateSessions: sessionProcedure
+    .input(
+      z.array(
+        z
+          .object({
+            config: z.object({}).passthrough(),
+            group: z.string().optional(),
+            id: z.string(),
+            meta: LobeMetaDataSchema,
+            pinned: z.boolean().optional(),
+            type: z.string(),
+          })
+          .partial(),
+      ),
+    )
+    .mutation(async ({ input, ctx }): Promise<BatchTaskResult> => {
+      const data = await ctx.sessionModel.batchCreate(
+        input.map((item) => ({
+          ...item,
+          ...item.meta,
+        })) as any,
+      );
+
+      return { added: data.rowCount as number, ids: [], skips: [], success: true };
+    }),
+
+  cloneSession: sessionProcedure
+    .input(z.object({ id: z.string(), newTitle: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      const data = await ctx.sessionModel.duplicate(input.id, input.newTitle);
+
+      return data?.id;
+    }),
+
+  countSessions: sessionProcedure.query(async ({ ctx }) => {
+    return ctx.sessionModel.count();
+  }),
+
+  createSession: sessionProcedure
+    .input(
+      z.object({
+        config: insertAgentSchema
+          .omit({ chatConfig: true, plugins: true, tags: true, tts: true })
+          .passthrough()
+          .partial(),
+        session: insertSessionSchema.omit({ createdAt: true, updatedAt: true }).partial(),
+        type: z.enum(['agent', 'group']),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const data = await ctx.sessionModel.create(input);
+
+      return data.id;
+    }),
+
+  getGroupedSessions: publicProcedure.query(async ({ ctx }): Promise<ChatSessionList> => {
+    if (!ctx.userId)
+      return {
+        sessionGroups: [],
+        sessions: [],
+      };
+
+    const sessionModel = new SessionModel(ctx.userId);
+
+    return sessionModel.queryWithGroups();
+  }),
+
+  getSessionConfig: sessionProcedure
+    .input(
+      z.object({
+        id: z.string(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      if (input.id === INBOX_SESSION_ID) {
+        const item = await ctx.sessionModel.findByIdOrSlug(INBOX_SESSION_ID);
+        // if there is no session for user, create one
+        if (!item) {
+          const res = await ctx.sessionModel.createInbox();
+          pino.info('create inbox session', res);
+        }
+      }
+
+      const session = await ctx.sessionModel.findByIdOrSlug(input.id);
+
+      if (!session) throw new Error('Session not found');
+
+      return session.agent;
+    }),
+
+  getSessions: sessionProcedure
+    .input(
+      z.object({
+        current: z.number().optional(),
+        pageSize: z.number().optional(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      const { current, pageSize } = input;
+
+      return ctx.sessionModel.query({ current, pageSize });
+    }),
+
+  removeAllSessions: sessionProcedure.mutation(async ({ ctx }) => {
+    return ctx.sessionModel.deleteAll();
+  }),
+
+  removeSession: sessionProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.sessionModel.delete(input.id);
+    }),
+
+  searchSessions: sessionProcedure
+    .input(z.object({ keywords: z.string() }))
+    .query(async ({ input, ctx }) => {
+      return ctx.sessionModel.queryByKeyword(input.keywords);
+    }),
+
+  updateSession: sessionProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: insertSessionSchema.partial(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.sessionModel.update(input.id, input.value);
+    }),
+  updateSessionChatConfig: sessionProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: AgentChatConfigSchema.partial(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const session = await ctx.sessionModel.findByIdOrSlug(input.id);
+
+      if (!session) return;
+
+      return ctx.sessionModel.updateConfig(session.agent.id, {
+        chatConfig: merge(session.agent.chatConfig, input.value),
+      });
+    }),
+  updateSessionConfig: sessionProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: z.object({}).passthrough().partial(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const session = await ctx.sessionModel.findByIdOrSlug(input.id);
+
+      if (!session || !input.value) return;
+
+      if (!session.agent) {
+        throw new Error(
+          'this session is not assign with agent, please contact with admin to fix this issue.',
+        );
+      }
+
+      return ctx.sessionModel.updateConfig(session.agent.id, input.value);
+    }),
+});
+
+export type SessionRouter = typeof sessionRouter;

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

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+
+import { SessionGroupModel } from '@/database/server/models/sessionGroup';
+import { insertSessionGroupSchema } from '@/database/server/schemas/lobechat';
+import { authedProcedure, router } from '@/libs/trpc';
+import { SessionGroupItem } from '@/types/session';
+
+const sessionProcedure = authedProcedure.use(async (opts) => {
+  const { ctx } = opts;
+
+  return opts.next({
+    ctx: {
+      sessionGroupModel: new SessionGroupModel(ctx.userId),
+    },
+  });
+});
+
+export const sessionGroupRouter = router({
+  createSessionGroup: sessionProcedure
+    .input(
+      z.object({
+        name: z.string(),
+        sort: z.number().optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const data = await ctx.sessionGroupModel.create({
+        name: input.name,
+        sort: input.sort,
+      });
+
+      return data?.id;
+    }),
+
+  getSessionGroup: sessionProcedure.query(async ({ ctx }): Promise<SessionGroupItem[]> => {
+    return ctx.sessionGroupModel.query() as any;
+  }),
+
+  removeAllSessionGroups: sessionProcedure.mutation(async ({ ctx }) => {
+    return ctx.sessionGroupModel.deleteAll();
+  }),
+
+  removeSessionGroup: sessionProcedure
+    .input(z.object({ id: z.string(), removeChildren: z.boolean().optional() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.sessionGroupModel.delete(input.id);
+    }),
+
+  updateSessionGroup: sessionProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: insertSessionGroupSchema.partial(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.sessionGroupModel.update(input.id, input.value);
+    }),
+  updateSessionGroupOrder: sessionProcedure
+    .input(
+      z.object({
+        sortMap: z.array(
+          z.object({
+            id: z.string(),
+            sort: z.number(),
+          }),
+        ),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      console.log('sortMap:', input.sortMap);
+
+      return ctx.sessionGroupModel.updateOrder(input.sortMap);
+    }),
+});
+
+export type SessionGroupRouter = typeof sessionGroupRouter;

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

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+
+import { TopicModel } from '@/database/server/models/topic';
+import { authedProcedure, publicProcedure, router } from '@/libs/trpc';
+import { BatchTaskResult } from '@/types/service';
+
+const topicProcedure = authedProcedure.use(async (opts) => {
+  const { ctx } = opts;
+
+  return opts.next({
+    ctx: { topicModel: new TopicModel(ctx.userId) },
+  });
+});
+
+export const topicRouter = router({
+  batchCreateTopics: topicProcedure
+    .input(
+      z.array(
+        z.object({
+          favorite: z.boolean().optional(),
+          id: z.string().optional(),
+          messages: z.array(z.string()).optional(),
+          sessionId: z.string().optional(),
+          title: z.string(),
+        }),
+      ),
+    )
+    .mutation(async ({ input, ctx }): Promise<BatchTaskResult> => {
+      const data = await ctx.topicModel.batchCreate(
+        input.map((item) => ({
+          ...item,
+        })) as any,
+      );
+
+      return { added: data.length, ids: [], skips: [], success: true };
+    }),
+
+  batchDelete: topicProcedure
+    .input(z.object({ ids: z.array(z.string()) }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.topicModel.batchDelete(input.ids);
+    }),
+
+  batchDeleteBySessionId: topicProcedure
+    .input(z.object({ id: z.string().nullable().optional() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.topicModel.batchDeleteBySessionId(input.id);
+    }),
+
+  cloneTopic: topicProcedure
+    .input(z.object({ id: z.string(), newTitle: z.string().optional() }))
+    .mutation(async ({ input, ctx }) => {
+      const data = await ctx.topicModel.duplicate(input.id, input.newTitle);
+
+      return data.topic.id;
+    }),
+
+  countTopics: topicProcedure.query(async ({ ctx }) => {
+    return ctx.topicModel.count();
+  }),
+
+  createTopic: topicProcedure
+    .input(
+      z.object({
+        favorite: z.boolean().optional(),
+        messages: z.array(z.string()).optional(),
+        sessionId: z.string().nullable().optional(),
+        title: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const data = await ctx.topicModel.create(input);
+
+      return data.id;
+    }),
+
+  getAllTopics: topicProcedure.query(async ({ ctx }) => {
+    return ctx.topicModel.queryAll();
+  }),
+
+  getTopics: publicProcedure
+    .input(
+      z.object({
+        current: z.number().optional(),
+        pageSize: z.number().optional(),
+        sessionId: z.string().nullable().optional(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      if (!ctx.userId) return [];
+
+      const topicModel = new TopicModel(ctx.userId);
+
+      return topicModel.query(input);
+    }),
+
+  hasTopics: topicProcedure.query(async ({ ctx }) => {
+    return (await ctx.topicModel.count()) === 0;
+  }),
+
+  removeAllTopics: topicProcedure.mutation(async ({ ctx }) => {
+    return ctx.topicModel.deleteAll();
+  }),
+
+  removeTopic: topicProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.topicModel.delete(input.id);
+    }),
+
+  searchTopics: topicProcedure
+    .input(z.object({ keywords: z.string(), sessionId: z.string().nullable().optional() }))
+    .query(async ({ input, ctx }) => {
+      return ctx.topicModel.queryByKeyword(input.keywords, input.sessionId);
+    }),
+
+  updateTopic: topicProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: z.object({
+          favorite: z.boolean().optional(),
+          messages: z.array(z.string()).optional(),
+          sessionId: z.string().optional(),
+          title: z.string().optional(),
+        }),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.topicModel.update(input.id, input.value);
+    }),
+});
+
+export type TopicRouter = typeof topicRouter;

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+import { MessageModel } from '@/database/server/models/message';
+import { SessionModel } from '@/database/server/models/session';
+import { UserModel } from '@/database/server/models/user';
+import { authedProcedure, router } from '@/libs/trpc';
+import { UserInitializationState, UserPreference } from '@/types/user';
+
+const userProcedure = authedProcedure.use(async (opts) => {
+  return opts.next({
+    ctx: { userModel: new UserModel() },
+  });
+});
+
+export const userRouter = router({
+  getUserState: userProcedure.query(async ({ ctx }): Promise<UserInitializationState> => {
+    const state = await ctx.userModel.getUserState(ctx.userId);
+
+    const messageModel = new MessageModel(ctx.userId);
+    const messageCount = await messageModel.count();
+
+    const sessionModel = new SessionModel(ctx.userId);
+    const sessionCount = await sessionModel.count();
+
+    return {
+      canEnablePWAGuide: messageCount >= 2,
+      canEnableTrace: messageCount >= 4,
+      // 有消息，或者创建过助手，则认为有 conversation
+      hasConversation: messageCount > 0 || sessionCount > 1,
+
+      isOnboard: state.isOnboarded || false,
+      preference: state.preference as UserPreference,
+      settings: state.settings,
+      userId: ctx.userId,
+    };
+  }),
+
+  makeUserOnboarded: userProcedure.mutation(async ({ ctx }) => {
+    return ctx.userModel.updateUser(ctx.userId, { isOnboarded: true });
+  }),
+
+  resetSettings: userProcedure.mutation(async ({ ctx }) => {
+    return ctx.userModel.deleteSetting(ctx.userId);
+  }),
+
+  updatePreference: userProcedure.input(z.any()).mutation(async ({ ctx, input }) => {
+    return ctx.userModel.updatePreference(ctx.userId, input);
+  }),
+
+  updateSettings: userProcedure
+    .input(z.object({}).passthrough())
+    .mutation(async ({ ctx, input }) => {
+      return ctx.userModel.updateSetting(ctx.userId, input);
+    }),
+});
+
+export type UserRouter = typeof userRouter;

package/src/services/file/index.ts

@@ -1,9 +1,6 @@
-// import { getClientConfig } from '@/config/client';
+import { isServerMode } from '@/const/version';
+
 import { ClientService } from './client';
+import { ServerService } from './server';
 
-// import { ServerService } from './server';
-//
-// const { ENABLED_SERVER_SERVICE } = getClientConfig();
-//
-// export const fileService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
-export const fileService = new ClientService();
+export const fileService = isServerMode ? new ServerService() : new ClientService();

package/src/services/file/server.ts

@@ -0,0 +1,45 @@
+import urlJoin from 'url-join';
+
+import { fileEnv } from '@/config/file';
+import { lambdaClient } from '@/libs/trpc/client';
+import { FilePreview, UploadFileParams } from '@/types/files';
+
+import { IFileService } from './type';
+
+interface CreateFileParams extends Omit<UploadFileParams, 'url'> {
+  url: string;
+}
+
+export class ServerService implements IFileService {
+  async createFile(params: UploadFileParams) {
+    return lambdaClient.file.createFile.mutate(params as CreateFileParams);
+  }
+
+  async getFile(id: string): Promise<FilePreview> {
+    if (!fileEnv.NEXT_PUBLIC_S3_DOMAIN) {
+      throw new Error('fileEnv.NEXT_PUBLIC_S3_DOMAIN is not set while enable server upload');
+    }
+
+    const item = await lambdaClient.file.findById.query({ id });
+
+    if (!item) {
+      throw new Error('file not found');
+    }
+
+    return {
+      fileType: item.fileType,
+      id: item.id,
+      name: item.name,
+      saveMode: 'url',
+      url: urlJoin(fileEnv.NEXT_PUBLIC_S3_DOMAIN!, item.url!),
+    };
+  }
+
+  async removeFile(id: string) {
+    await lambdaClient.file.removeFile.mutate({ id });
+  }
+
+  async removeAllFiles() {
+    await lambdaClient.file.removeAllFiles.mutate();
+  }
+}

package/src/services/import/index.ts

@@ -1,3 +1,6 @@
+import { isServerMode } from '@/const/version';
+
 import { ClientService } from './client';
+import { ServerService } from './server';
 
-export const importService = new ClientService();
+export const importService = isServerMode ? new ServerService() : new ClientService();