@lobehub/chat 1.39.3 → 1.40.0

package/src/services/session/client.ts

@@ -1,22 +1,10 @@
-import { DeepPartial } from 'utility-types';
-
 import { INBOX_SESSION_ID } from '@/const/session';
 import { clientDB } from '@/database/client/db';
 import { AgentItem } from '@/database/schemas';
 import { SessionModel } from '@/database/server/models/session';
 import { SessionGroupModel } from '@/database/server/models/sessionGroup';
 import { BaseClientService } from '@/services/baseClientService';
-import { LobeAgentChatConfig, LobeAgentConfig } from '@/types/agent';
-import { MetaData } from '@/types/meta';
-import {
-  ChatSessionList,
-  LobeAgentSession,
-  LobeSessionType,
-  LobeSessions,
-  SessionGroupItem,
-  SessionGroups,
-  UpdateSessionParams,
-} from '@/types/session';
+import { LobeAgentConfig } from '@/types/agent';
 
 import { ISessionService } from './type';
 
@@ -29,7 +17,12 @@ export class ClientService extends BaseClientService implements ISessionService
     return new SessionGroupModel(clientDB as any, this.userId);
   }
 
-  async createSession(type: LobeSessionType, data: Partial<LobeAgentSession>): Promise<string> {
+  hasSessions: ISessionService['hasSessions'] = async () => {
+    const result = await this.countSessions();
+    return result === 0;
+  };
+
+  createSession: ISessionService['createSession'] = async (type, data) => {
     const { config, group, meta, ...session } = data;
 
     const item = await this.sessionModel.create({
@@ -41,144 +34,125 @@ export class ClientService extends BaseClientService implements ISessionService
       throw new Error('session create Error');
     }
     return item.id;
-  }
+  };
 
-  async batchCreateSessions(importSessions: LobeSessions) {
+  batchCreateSessions: ISessionService['batchCreateSessions'] = async (importSessions) => {
     // @ts-ignore
     return this.sessionModel.batchCreate(importSessions);
-  }
+  };
 
-  async cloneSession(id: string, newTitle: string): Promise<string | undefined> {
+  cloneSession: ISessionService['cloneSession'] = async (id, newTitle) => {
     const res = await this.sessionModel.duplicate(id, newTitle);
 
     if (res) return res?.id;
-  }
+  };
 
-  async getGroupedSessions(): Promise<ChatSessionList> {
+  getGroupedSessions: ISessionService['getGroupedSessions'] = async () => {
     return this.sessionModel.queryWithGroups();
-  }
+  };
 
-  async getSessionConfig(id: string): Promise<LobeAgentConfig> {
+  getSessionConfig: ISessionService['getSessionConfig'] = async (id) => {
     const res = await this.sessionModel.findByIdOrSlug(id);
 
     if (!res) throw new Error('Session not found');
 
     return res.agent as LobeAgentConfig;
-  }
+  };
 
   /**
    * 这个方法要对应移除的
    */
-  async getSessionsByType(type: 'agent' | 'group' | 'all' = 'all'): Promise<LobeSessions> {
+  // @ts-ignore
+  getSessionsByType: ISessionService['getSessionsByType'] = async (type = 'all') => {
     switch (type) {
       // TODO: add a filter to get only agents or agents
-      case 'group': {
-        // @ts-ignore
-        return this.sessionModel.query();
-      }
-      case 'agent': {
-        // @ts-ignore
-        return this.sessionModel.query();
-      }
-
+      case 'group':
+      case 'agent':
       case 'all': {
-        // @ts-ignore
         return this.sessionModel.query();
       }
     }
-  }
+  };
 
-  async countSessions() {
+  countSessions: ISessionService['countSessions'] = async () => {
     return this.sessionModel.count();
-  }
+  };
 
-  async searchSessions(keyword: string) {
+  searchSessions: ISessionService['searchSessions'] = async (keyword) => {
     return this.sessionModel.queryByKeyword(keyword);
-  }
+  };
 
-  async updateSession(id: string, value: Partial<UpdateSessionParams>) {
+  updateSession: ISessionService['updateSession'] = async (id, value) => {
     return this.sessionModel.update(id, {
       ...value,
       groupId: value.group === 'default' ? null : value.group,
     });
-  }
+  };
 
-  async updateSessionConfig(
-    activeId: string,
-    config: DeepPartial<LobeAgentConfig>,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _?: AbortSignal,
-  ) {
+  updateSessionConfig: ISessionService['updateSessionConfig'] = async (activeId, config) => {
     const session = await this.sessionModel.findByIdOrSlug(activeId);
     if (!session || !config) return;
 
     return this.sessionModel.updateConfig(session.agent.id, config as AgentItem);
-  }
+  };
 
-  async updateSessionMeta(
-    activeId: string,
-    meta: Partial<MetaData>,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _?: AbortSignal,
-  ) {
+  updateSessionMeta: ISessionService['updateSessionMeta'] = async (activeId, meta) => {
     // inbox 不允许修改 meta
     if (activeId === INBOX_SESSION_ID) return;
 
     return this.sessionModel.update(activeId, meta);
-  }
+  };
 
-  async updateSessionChatConfig(
-    activeId: string,
-    config: DeepPartial<LobeAgentChatConfig>,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _?: AbortSignal,
-  ) {
+  updateSessionChatConfig: ISessionService['updateSessionChatConfig'] = async (
+    activeId,
+    config,
+  ) => {
     return this.updateSessionConfig(activeId, { chatConfig: config });
-  }
+  };
 
-  async removeSession(id: string) {
+  removeSession: ISessionService['removeSession'] = async (id) => {
     return this.sessionModel.delete(id);
-  }
+  };
 
-  async removeAllSessions() {
+  removeAllSessions: ISessionService['removeAllSessions'] = async () => {
     return this.sessionModel.deleteAll();
-  }
+  };
 
   // ************************************** //
   // ***********  SessionGroup  *********** //
   // ************************************** //
 
-  async createSessionGroup(name: string, sort?: number) {
+  createSessionGroup: ISessionService['createSessionGroup'] = async (name, sort) => {
     const item = await this.sessionGroupModel.create({ name, sort });
     if (!item) {
       throw new Error('session group create Error');
     }
 
     return item.id;
-  }
+  };
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async batchCreateSessionGroups(_groups: SessionGroups) {
+  batchCreateSessionGroups: ISessionService['batchCreateSessionGroups'] = async (_groups) => {
     return { added: 0, ids: [], skips: [], success: true };
-  }
+  };
 
-  async removeSessionGroup(id: string) {
-    return await this.sessionGroupModel.delete(id);
-  }
+  removeSessionGroup: ISessionService['removeSessionGroup'] = async (id) => {
+    return this.sessionGroupModel.delete(id);
+  };
 
-  async updateSessionGroup(id: string, data: Partial<SessionGroupItem>) {
+  updateSessionGroup: ISessionService['updateSessionGroup'] = async (id, data) => {
     return this.sessionGroupModel.update(id, data);
-  }
+  };
 
-  async updateSessionGroupOrder(sortMap: { id: string; sort: number }[]) {
+  updateSessionGroupOrder: ISessionService['updateSessionGroupOrder'] = async (sortMap) => {
     return this.sessionGroupModel.updateOrder(sortMap);
-  }
+  };
 
-  async getSessionGroups(): Promise<SessionGroupItem[]> {
+  getSessionGroups: ISessionService['getSessionGroups'] = async () => {
     return this.sessionGroupModel.query();
-  }
+  };
 
-  async removeSessionGroups() {
+  removeSessionGroups: ISessionService['removeSessionGroups'] = async () => {
     return this.sessionGroupModel.deleteAll();
-  }
+  };
 }

package/src/services/session/server.ts

@@ -1,145 +1,121 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { DeepPartial } from 'utility-types';
-
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { lambdaClient } from '@/libs/trpc/client';
 import { useUserStore } from '@/store/user';
 import { authSelectors } from '@/store/user/selectors';
-import { LobeAgentChatConfig, LobeAgentConfig } from '@/types/agent';
-import { MetaData } from '@/types/meta';
-import { BatchTaskResult } from '@/types/service';
-import {
-  ChatSessionList,
-  LobeAgentSession,
-  LobeSessionType,
-  LobeSessions,
-  SessionGroupItem,
-  SessionGroups,
-  UpdateSessionParams,
-} from '@/types/session';
 
 import { ISessionService } from './type';
 
 export class ServerService implements ISessionService {
-  async hasSessions() {
-    return (await this.countSessions()) === 0;
-  }
+  hasSessions: ISessionService['hasSessions'] = async () => {
+    const result = await this.countSessions();
+    return result === 0;
+  };
 
-  createSession(type: LobeSessionType, data: Partial<LobeAgentSession>): Promise<string> {
+  createSession: ISessionService['createSession'] = async (type, data) => {
     const { config, group, meta, ...session } = data;
-
     return lambdaClient.session.createSession.mutate({
       config: { ...config, ...meta } as any,
       session: { ...session, groupId: group },
       type,
     });
-  }
+  };
 
-  async batchCreateSessions(importSessions: LobeSessions): Promise<BatchTaskResult> {
+  batchCreateSessions: ISessionService['batchCreateSessions'] = async (importSessions) => {
     // TODO: remove any
     const data = await lambdaClient.session.batchCreateSessions.mutate(importSessions as any);
     console.log(data);
     return data;
-  }
+  };
 
-  cloneSession(id: string, newTitle: string): Promise<string | undefined> {
+  cloneSession: ISessionService['cloneSession'] = (id, newTitle) => {
     return lambdaClient.session.cloneSession.mutate({ id, newTitle });
-  }
+  };
 
-  getGroupedSessions(): Promise<ChatSessionList> {
+  getGroupedSessions: ISessionService['getGroupedSessions'] = () => {
     return lambdaClient.session.getGroupedSessions.query();
-  }
+  };
 
-  countSessions(): Promise<number> {
+  countSessions: ISessionService['countSessions'] = () => {
     return lambdaClient.session.countSessions.query();
-  }
+  };
 
-  updateSession(id: string, data: Partial<UpdateSessionParams>): Promise<any> {
+  updateSession: ISessionService['updateSession'] = (id, data) => {
     const { group, pinned, meta, updatedAt } = data;
     return lambdaClient.session.updateSession.mutate({
       id,
       value: { groupId: group === 'default' ? null : group, pinned, ...meta, updatedAt },
     });
-  }
+  };
 
-  async getSessionConfig(id: string): Promise<LobeAgentConfig> {
+  // TODO: Need to be fixed
+  // @ts-ignore
+  getSessionConfig: ISessionService['getSessionConfig'] = async (id) => {
     const isLogin = authSelectors.isLogin(useUserStore.getState());
     if (!isLogin) return DEFAULT_AGENT_CONFIG;
 
-    // TODO: Need to be fixed
-    // @ts-ignore
     return lambdaClient.agent.getAgentConfig.query({ sessionId: id });
-  }
+  };
 
-  updateSessionConfig(
-    id: string,
-    config: DeepPartial<LobeAgentConfig>,
-    signal?: AbortSignal,
-  ): Promise<any> {
+  updateSessionConfig: ISessionService['updateSessionConfig'] = (id, config, signal) => {
     return lambdaClient.session.updateSessionConfig.mutate({ id, value: config }, { signal });
-  }
+  };
 
-  updateSessionMeta(id: string, meta: Partial<MetaData>, signal?: AbortSignal): Promise<any> {
+  updateSessionMeta: ISessionService['updateSessionMeta'] = (id, meta, signal) => {
     return lambdaClient.session.updateSessionConfig.mutate({ id, value: meta }, { signal });
-  }
+  };
 
-  updateSessionChatConfig(
-    id: string,
-    value: DeepPartial<LobeAgentChatConfig>,
-    signal?: AbortSignal,
-  ): Promise<any> {
+  updateSessionChatConfig: ISessionService['updateSessionChatConfig'] = (id, value, signal) => {
     return lambdaClient.session.updateSessionChatConfig.mutate({ id, value }, { signal });
-  }
+  };
 
-  getSessionsByType(_type: 'agent' | 'group' | 'all' = 'all'): Promise<LobeSessions> {
-    // TODO: need be fixed
-    // @ts-ignore
+  // TODO: need be fixed
+  // @ts-ignore
+  getSessionsByType: ISessionService['getSessionsByType'] = (_type = 'all') => {
     return lambdaClient.session.getSessions.query({});
-  }
+  };
 
-  searchSessions(keywords: string): Promise<LobeSessions> {
+  searchSessions: ISessionService['searchSessions'] = (keywords) => {
     return lambdaClient.session.searchSessions.query({ keywords });
-  }
+  };
 
-  removeSession(id: string): Promise<any> {
+  removeSession: ISessionService['removeSession'] = (id) => {
     return lambdaClient.session.removeSession.mutate({ id });
-  }
+  };
 
-  removeAllSessions(): Promise<any> {
+  removeAllSessions: ISessionService['removeAllSessions'] = () => {
     return lambdaClient.session.removeAllSessions.mutate();
-  }
+  };
 
   // ************************************** //
   // ***********  SessionGroup  *********** //
   // ************************************** //
 
-  createSessionGroup(name: string, sort?: number): Promise<string> {
+  createSessionGroup: ISessionService['createSessionGroup'] = (name, sort) => {
     return lambdaClient.sessionGroup.createSessionGroup.mutate({ name, sort });
-  }
+  };
 
-  getSessionGroups(): Promise<SessionGroupItem[]> {
+  getSessionGroups: ISessionService['getSessionGroups'] = () => {
     return lambdaClient.sessionGroup.getSessionGroup.query();
-  }
+  };
 
-  batchCreateSessionGroups(_groups: SessionGroups): Promise<BatchTaskResult> {
+  batchCreateSessionGroups: ISessionService['batchCreateSessionGroups'] = (_groups) => {
     return Promise.resolve({ added: 0, ids: [], skips: [], success: true });
-  }
+  };
 
-  removeSessionGroup(id: string, removeChildren?: boolean): Promise<any> {
+  removeSessionGroup: ISessionService['removeSessionGroup'] = (id, removeChildren) => {
     return lambdaClient.sessionGroup.removeSessionGroup.mutate({ id, removeChildren });
-  }
+  };
 
-  removeSessionGroups(): Promise<any> {
+  removeSessionGroups: ISessionService['removeSessionGroups'] = () => {
     return lambdaClient.sessionGroup.removeAllSessionGroups.mutate();
-  }
+  };
 
-  updateSessionGroup(id: string, value: Partial<SessionGroupItem>): Promise<any> {
-    // TODO: need be fixed
-    // @ts-ignore
+  updateSessionGroup: ISessionService['updateSessionGroup'] = (id, value) => {
     return lambdaClient.sessionGroup.updateSessionGroup.mutate({ id, value });
-  }
+  };
 
-  updateSessionGroupOrder(sortMap: { id: string; sort: number }[]): Promise<any> {
+  updateSessionGroupOrder: ISessionService['updateSessionGroupOrder'] = (sortMap) => {
     return lambdaClient.sessionGroup.updateSessionGroupOrder.mutate({ sortMap });
-  }
+  };
 }

package/src/services/session/type.ts

@@ -9,12 +9,13 @@ import {
   LobeAgentSession,
   LobeSessionType,
   LobeSessions,
-  SessionGroupId,
   SessionGroupItem,
   SessionGroups,
+  UpdateSessionParams,
 } from '@/types/session';
 
 export interface ISessionService {
+  hasSessions(): Promise<boolean>;
   createSession(type: LobeSessionType, defaultValue: Partial<LobeAgentSession>): Promise<string>;
 
   /**
@@ -29,14 +30,11 @@ export interface ISessionService {
   /**
    * @deprecated
    */
-  getSessionsByType(type: 'agent' | 'group' | 'all'): Promise<LobeSessions>;
+  getSessionsByType(type?: 'agent' | 'group' | 'all'): Promise<LobeSessions>;
   countSessions(): Promise<number>;
   searchSessions(keyword: string): Promise<LobeSessions>;
 
-  updateSession(
-    id: string,
-    data: Partial<{ group?: SessionGroupId; pinned?: boolean }>,
-  ): Promise<any>;
+  updateSession(id: string, data: Partial<UpdateSessionParams>): Promise<any>;
 
   getSessionConfig(id: string): Promise<LobeAgentConfig>;
   updateSessionConfig(

package/src/services/share.ts

@@ -10,22 +10,22 @@ class ShareService {
    * @param settings - The settings object to be encoded in the URL.
    * @returns The share settings URL.
    */
-  public createShareSettingsUrl(settings: DeepPartial<UserSettings>) {
+  public createShareSettingsUrl = (settings: DeepPartial<UserSettings>) => {
     return withBasePath(`/?${LOBE_URL_IMPORT_NAME}=${encodeURI(JSON.stringify(settings))}`);
-  }
+  };
 
   /**
    * Decode share settings from search params
    * @param settings
    * @returns
    */
-  public decodeShareSettings(settings: string) {
+  decodeShareSettings = (settings: string) => {
     try {
       return { data: JSON.parse(settings) as DeepPartial<UserSettings> };
     } catch (e) {
       return { message: JSON.stringify(e) };
     }
-  }
+  };
 }
 
 export const shareService = new ShareService();

package/src/services/textToImage.ts

@@ -9,7 +9,10 @@ interface FetchOptions {
 }
 
 class ImageGenerationService {
-  async generateImage(params: Omit<OpenAIImagePayload, 'model' | 'n'>, options?: FetchOptions) {
+  generateImage = async (
+    params: Omit<OpenAIImagePayload, 'model' | 'n'>,
+    options?: FetchOptions,
+  ) => {
     const payload: OpenAIImagePayload = { ...params, model: 'dall-e-3', n: 1 };
 
     const provider = ModelProvider.OpenAI;
@@ -32,7 +35,7 @@ class ImageGenerationService {
     const urls = await res.json();
 
     return urls[0] as string;
-  }
+  };
 }
 
 export const imageGenerationService = new ImageGenerationService();

package/src/services/thread/client.ts

@@ -3,29 +3,23 @@ import { clientDB } from '@/database/client/db';
 import { MessageModel } from '@/database/server/models/message';
 import { ThreadModel } from '@/database/server/models/thread';
 import { BaseClientService } from '@/services/baseClientService';
-import { CreateMessageParams } from '@/types/message';
-import { CreateThreadParams, ThreadItem } from '@/types/topic';
 
 import { IThreadService } from './type';
 
-interface CreateThreadWithMessageParams extends CreateThreadParams {
-  message: CreateMessageParams;
-}
 export class ClientService extends BaseClientService implements IThreadService {
   private get threadModel(): ThreadModel {
     return new ThreadModel(clientDB as any, this.userId);
   }
+
   private get messageModel(): MessageModel {
     return new MessageModel(clientDB as any, this.userId);
   }
 
-  getThreads = async (topicId: string): Promise<ThreadItem[]> => {
+  getThreads: IThreadService['getThreads'] = async (topicId) => {
     return this.threadModel.queryByTopicId(topicId);
   };
 
-  createThreadWithMessage = async (
-    input: CreateThreadWithMessageParams,
-  ): Promise<{ messageId: string; threadId: string }> => {
+  createThreadWithMessage: IThreadService['createThreadWithMessage'] = async (input) => {
     const thread = await this.threadModel.create({
       parentThreadId: input.parentThreadId,
       sourceMessageId: input.sourceMessageId,
@@ -43,15 +37,15 @@ export class ClientService extends BaseClientService implements IThreadService {
     return { messageId: message?.id, threadId: thread?.id };
   };
 
-  updateThread(id: string, data: Partial<ThreadItem>): Promise<any> {
+  updateThread: IThreadService['updateThread'] = async (id, data) => {
     return this.threadModel.update(id, data);
-  }
+  };
 
-  removeThread(id: string): Promise<any> {
+  removeThread: IThreadService['removeThread'] = async (id) => {
     return this.threadModel.delete(id);
-  }
+  };
 
-  private toDbSessionId(sessionId: string | undefined) {
+  private toDbSessionId = (sessionId: string | undefined) => {
     return sessionId === INBOX_SESSION_ID ? null : sessionId;
-  }
+  };
 }

package/src/services/thread/server.ts

@@ -1,37 +1,32 @@
 import { INBOX_SESSION_ID } from '@/const/session';
 import { lambdaClient } from '@/libs/trpc/client';
-import { CreateMessageParams } from '@/types/message';
-import { CreateThreadParams, ThreadItem } from '@/types/topic';
 
 import { IThreadService } from './type';
 
-interface CreateThreadWithMessageParams extends CreateThreadParams {
-  message: CreateMessageParams;
-}
 export class ServerService implements IThreadService {
-  getThreads = (topicId: string): Promise<ThreadItem[]> => {
+  getThreads: IThreadService['getThreads'] = (topicId) => {
     return lambdaClient.thread.getThreads.query({ topicId });
   };
 
-  createThreadWithMessage({
+  createThreadWithMessage: IThreadService['createThreadWithMessage'] = async ({
     message,
     ...params
-  }: CreateThreadWithMessageParams): Promise<{ messageId: string; threadId: string }> {
+  }) => {
     return lambdaClient.thread.createThreadWithMessage.mutate({
       ...params,
       message: { ...message, sessionId: this.toDbSessionId(message.sessionId) },
     });
-  }
+  };
 
-  updateThread(id: string, data: Partial<ThreadItem>): Promise<any> {
+  updateThread: IThreadService['updateThread'] = async (id, data) => {
     return lambdaClient.thread.updateThread.mutate({ id, value: data });
-  }
+  };
 
-  removeThread(id: string): Promise<any> {
+  removeThread: IThreadService['removeThread'] = async (id) => {
     return lambdaClient.thread.removeThread.mutate({ id });
-  }
+  };
 
-  private toDbSessionId(sessionId: string | undefined) {
+  private toDbSessionId = (sessionId: string | undefined) => {
     return sessionId === INBOX_SESSION_ID ? null : sessionId;
-  }
+  };
 }