@lobehub/lobehub 2.0.0-next.25 → 2.0.0-next.27

package/src/services/user/index.test.ts

@@ -0,0 +1,8 @@
+import { describe } from 'vitest';
+import { testService } from '~test-utils';
+
+import { UserService } from './index';
+
+describe('UserService', () => {
+  testService(UserService);
+});

package/src/services/user/index.ts

@@ -1,3 +1,54 @@
-import { ServerService } from './server';
+import type { AdapterAccount } from 'next-auth/adapters';
+import type { PartialDeep } from 'type-fest';
 
-export const userService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
+import { UserSettings } from '@/types/user/settings';
+
+export class UserService {
+  getUserRegistrationDuration = async (): Promise<{
+    createdAt: string;
+    duration: number;
+    updatedAt: string;
+  }> => {
+    return lambdaClient.user.getUserRegistrationDuration.query();
+  };
+
+  getUserState = async (): Promise<UserInitializationState> => {
+    return lambdaClient.user.getUserState.query();
+  };
+
+  getUserSSOProviders = async (): Promise<AdapterAccount[]> => {
+    return lambdaClient.user.getUserSSOProviders.query();
+  };
+
+  unlinkSSOProvider = async (provider: string, providerAccountId: string) => {
+    return lambdaClient.user.unlinkSSOProvider.mutate({ provider, providerAccountId });
+  };
+
+  makeUserOnboarded = async () => {
+    return lambdaClient.user.makeUserOnboarded.mutate();
+  };
+
+  updateAvatar = async (avatar: string) => {
+    return lambdaClient.user.updateAvatar.mutate(avatar);
+  };
+
+  updatePreference = async (preference: Partial<UserPreference>) => {
+    return lambdaClient.user.updatePreference.mutate(preference);
+  };
+
+  updateGuide = async (guide: Partial<UserGuide>) => {
+    return lambdaClient.user.updateGuide.mutate(guide);
+  };
+
+  updateUserSettings = async (value: PartialDeep<UserSettings>, signal?: AbortSignal) => {
+    return lambdaClient.user.updateSettings.mutate(value, { signal });
+  };
+
+  resetUserSettings = async () => {
+    return lambdaClient.user.resetSettings.mutate();
+  };
+}
+
+export const userService = new UserService();

package/src/store/aiInfra/slices/aiModel/action.test.ts

@@ -101,7 +101,7 @@ describe('AiModelAction', () => {
         .mockResolvedValue(undefined);
       const serviceSpy = vi
         .spyOn(aiModelService, 'batchUpdateAiModels')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.batchUpdateAiModels(models);
@@ -119,7 +119,7 @@ describe('AiModelAction', () => {
       const { result } = renderHook(() => useStore());
       const serviceSpy = vi
         .spyOn(aiModelService, 'batchUpdateAiModels')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.batchUpdateAiModels([]);
@@ -137,7 +137,7 @@ describe('AiModelAction', () => {
         .mockResolvedValue(undefined);
       const serviceSpy = vi
         .spyOn(aiModelService, 'clearModelsByProvider')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.clearModelsByProvider('test-provider');
@@ -154,7 +154,9 @@ describe('AiModelAction', () => {
       const refreshSpy = vi
         .spyOn(result.current, 'refreshAiModelList')
         .mockResolvedValue(undefined);
-      const serviceSpy = vi.spyOn(aiModelService, 'clearRemoteModels').mockResolvedValue(undefined);
+      const serviceSpy = vi
+        .spyOn(aiModelService, 'clearRemoteModels')
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.clearRemoteModels('test-provider');
@@ -178,7 +180,9 @@ describe('AiModelAction', () => {
       const refreshSpy = vi
         .spyOn(result.current, 'refreshAiModelList')
         .mockResolvedValue(undefined);
-      const serviceSpy = vi.spyOn(aiModelService, 'createAiModel').mockResolvedValue(undefined);
+      const serviceSpy = vi
+        .spyOn(aiModelService, 'createAiModel')
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.createNewAiModel(params);
@@ -349,7 +353,9 @@ describe('AiModelAction', () => {
       const refreshSpy = vi
         .spyOn(result.current, 'refreshAiModelList')
         .mockResolvedValue(undefined);
-      const serviceSpy = vi.spyOn(aiModelService, 'deleteAiModel').mockResolvedValue(undefined);
+      const serviceSpy = vi
+        .spyOn(aiModelService, 'deleteAiModel')
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.removeAiModel('model-1', 'test-provider');
@@ -371,7 +377,7 @@ describe('AiModelAction', () => {
         .mockResolvedValue(undefined);
       const serviceSpy = vi
         .spyOn(aiModelService, 'toggleModelEnabled')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.toggleModelEnabled({ enabled: true, id: 'model-1' });
@@ -395,7 +401,7 @@ describe('AiModelAction', () => {
       const { result } = renderHook(() => useStore());
       const serviceSpy = vi
         .spyOn(aiModelService, 'toggleModelEnabled')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.toggleModelEnabled({ enabled: true, id: 'model-1' });
@@ -435,7 +441,9 @@ describe('AiModelAction', () => {
       const refreshSpy = vi
         .spyOn(result.current, 'refreshAiModelList')
         .mockResolvedValue(undefined);
-      const serviceSpy = vi.spyOn(aiModelService, 'updateAiModel').mockResolvedValue(undefined);
+      const serviceSpy = vi
+        .spyOn(aiModelService, 'updateAiModel')
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.updateAiModelsConfig('model-1', 'test-provider', updateData);

package/src/store/chat/slices/aiChat/actions/__tests__/helpers.ts

@@ -63,10 +63,12 @@ export const spyOnMessageService = () => {
   const updateMessageSpy = vi
     .spyOn(messageService, 'updateMessage')
     .mockResolvedValue({ messages: [], success: true });
-  const removeMessageSpy = vi.spyOn(messageService, 'removeMessage').mockResolvedValue(undefined);
+  const removeMessageSpy = vi
+    .spyOn(messageService, 'removeMessage')
+    .mockResolvedValue(undefined as any);
   const updateMessageErrorSpy = vi
     .spyOn(messageService, 'updateMessageError')
-    .mockResolvedValue(undefined);
+    .mockResolvedValue(undefined as any);
 
   return {
     createMessageSpy,

package/src/store/chat/slices/topic/action.test.ts

@@ -254,7 +254,7 @@ describe('topic action', () => {
 
       const updateFavoriteSpy = vi
         .spyOn(topicService, 'updateTopic')
-        .mockResolvedValue({ success: 1 });
+        .mockResolvedValue(undefined as any);
 
       const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
 

package/src/store/chat/slices/topic/action.ts

@@ -15,7 +15,6 @@ import { useClientDataSWR } from '@/libs/swr';
 import { chatService } from '@/services/chat';
 import { messageService } from '@/services/message';
 import { topicService } from '@/services/topic';
-import { CreateTopicParams } from '@/services/topic/type';
 import type { ChatStore } from '@/store/chat';
 import type { ChatStoreState } from '@/store/chat/initialState';
 import { messageMapKey } from '@/store/chat/utils/messageMapKey';
@@ -24,7 +23,7 @@ import { useSessionStore } from '@/store/session';
 import { sessionSelectors } from '@/store/session/selectors';
 import { useUserStore } from '@/store/user';
 import { systemAgentSelectors } from '@/store/user/selectors';
-import { ChatTopic } from '@/types/topic';
+import { ChatTopic, CreateTopicParams } from '@/types/topic';
 import { merge } from '@/utils/merge';
 import { setNamespace } from '@/utils/storeDebug';
 

package/src/store/chat/slices/topic/reducer.ts

@@ -1,7 +1,6 @@
 import { produce } from 'immer';
 
-import { CreateTopicParams } from '@/services/topic/type';
-import { ChatTopic } from '@/types/topic';
+import { ChatTopic, CreateTopicParams } from '@/types/topic';
 
 interface AddChatTopicAction {
   type: 'addTopic';

package/src/store/file/slices/chat/action.ts

@@ -4,7 +4,6 @@ import { StateCreator } from 'zustand/vanilla';
 import { notification } from '@/components/AntdStaticMethods';
 import { FILE_UPLOAD_BLACKLIST } from '@/const/file';
 import { fileService } from '@/services/file';
-import { ServerService } from '@/services/file/server';
 import { ragService } from '@/services/rag';
 import { UPLOAD_NETWORK_ERROR } from '@/services/upload';
 import {
@@ -21,8 +20,6 @@ import { FileStore } from '../../store';
 
 const n = setNamespace('chat');
 
-const serverFileService = new ServerService();
-
 export interface FileAction {
   clearChatUploadFileList: () => void;
   dispatchChatUploadFileList: (payload: UploadFileListDispatch) => void;
@@ -71,7 +68,7 @@ export const createFileSlice: StateCreator<
       let fileItem: FileListItem | undefined = undefined;
 
       try {
-        fileItem = await serverFileService.getFileItem(id);
+        fileItem = await fileService.getFileItem(id);
       } catch (e) {
         console.error('getFileItem Error:', e);
         continue;

package/src/store/file/slices/fileManager/action.ts

@@ -4,8 +4,7 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { FILE_UPLOAD_BLACKLIST, MAX_UPLOAD_FILE_COUNT } from '@/const/file';
 import { useClientDataSWR } from '@/libs/swr';
-import { fileService } from '@/services/file';
-import { ServerService } from '@/services/file/server';
+import { fileService , FileService } from '@/services/file';
 import { ragService } from '@/services/rag';
 import {
   UploadFileListDispatch,
@@ -18,7 +17,7 @@ import { unzipFile } from '@/utils/unzipFile';
 import { FileStore } from '../../store';
 import { fileManagerSelectors } from './selectors';
 
-const serverFileService = new ServerService();
+const serverFileService = new FileService();
 
 export interface FileManageAction {
   dispatchDockFileList: (payload: UploadFileListDispatch) => void;

package/src/store/session/slices/sessionGroup/action.test.ts

@@ -42,7 +42,7 @@ describe('createSessionGroupSlice', () => {
     it('should clear session groups and refresh sessions', async () => {
       const spyOn = vi
         .spyOn(sessionService, 'removeSessionGroups')
-        .mockResolvedValueOnce(undefined);
+        .mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -59,7 +59,7 @@ describe('createSessionGroupSlice', () => {
   describe('removeSessionGroup', () => {
     it('should remove a session group and refresh sessions', async () => {
       const mockId = 'mock-id';
-      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -77,7 +77,7 @@ describe('createSessionGroupSlice', () => {
     it('should update a session group id and refresh sessions', async () => {
       const mockSessionId = 'session-id';
       const mockGroupId = 'group-id';
-      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -98,7 +98,7 @@ describe('createSessionGroupSlice', () => {
       const mockId = 'mock-id';
       const mockName = 'New Name';
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
-      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined as any);
 
       const { result } = renderHook(() => useSessionStore());
 
@@ -117,7 +117,7 @@ describe('createSessionGroupSlice', () => {
         { id: 'id1', sort: 0 },
         { id: 'id2', sort: 1 },
       ];
-      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());

package/src/store/user/slices/common/action.test.ts

@@ -30,7 +30,7 @@ describe('createCommonSlice', () => {
       const avatar = 'data:image/png;base64,';
 
       const spyOn = vi.spyOn(result.current, 'refreshUserState');
-      const updateAvatarSpy = vi.spyOn(userService, 'updateAvatar').mockResolvedValue(undefined);
+      const updateAvatarSpy = vi.spyOn(userService, 'updateAvatar').mockResolvedValue({} as any);
 
       await act(async () => {
         await result.current.updateAvatar(avatar);

package/src/services/aiModel/server.test.ts

@@ -1,122 +0,0 @@
-import { AiProviderModelListItem } from 'model-bank';
-import { describe, expect, it, vi } from 'vitest';
-
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { ServerService } from './server';
-
-vi.mock('@/libs/trpc/client', () => ({
-  lambdaClient: {
-    aiModel: {
-      createAiModel: { mutate: vi.fn() },
-      getAiProviderModelList: { query: vi.fn() },
-      getAiModelById: { query: vi.fn() },
-      toggleModelEnabled: { mutate: vi.fn() },
-      updateAiModel: { mutate: vi.fn() },
-      batchUpdateAiModels: { mutate: vi.fn() },
-      batchToggleAiModels: { mutate: vi.fn() },
-      clearModelsByProvider: { mutate: vi.fn() },
-      clearRemoteModels: { mutate: vi.fn() },
-      updateAiModelOrder: { mutate: vi.fn() },
-      removeAiModel: { mutate: vi.fn() },
-    },
-  },
-}));
-
-describe('ServerService', () => {
-  const service = new ServerService();
-
-  it('should create AI model', async () => {
-    const params = {
-      id: 'test-id',
-      providerId: 'test-provider',
-      displayName: 'Test Model',
-    };
-    await service.createAiModel(params);
-    expect(vi.mocked(lambdaClient.aiModel.createAiModel.mutate)).toHaveBeenCalledWith(params);
-  });
-
-  it('should get AI provider model list', async () => {
-    await service.getAiProviderModelList('123');
-    expect(vi.mocked(lambdaClient.aiModel.getAiProviderModelList.query)).toHaveBeenCalledWith({
-      id: '123',
-    });
-  });
-
-  it('should get AI model by id', async () => {
-    await service.getAiModelById('123');
-    expect(vi.mocked(lambdaClient.aiModel.getAiModelById.query)).toHaveBeenCalledWith({
-      id: '123',
-    });
-  });
-
-  it('should toggle model enabled', async () => {
-    const params = { id: '123', providerId: 'test', enabled: true };
-    await service.toggleModelEnabled(params);
-    expect(vi.mocked(lambdaClient.aiModel.toggleModelEnabled.mutate)).toHaveBeenCalledWith(params);
-  });
-
-  it('should update AI model', async () => {
-    const value = { contextWindowTokens: 4000, displayName: 'Updated Model' };
-    await service.updateAiModel('123', 'openai', value);
-    expect(vi.mocked(lambdaClient.aiModel.updateAiModel.mutate)).toHaveBeenCalledWith({
-      id: '123',
-      providerId: 'openai',
-      value,
-    });
-  });
-
-  it('should batch update AI models', async () => {
-    const models: AiProviderModelListItem[] = [
-      {
-        id: '123',
-        enabled: true,
-        type: 'chat',
-      },
-    ];
-    await service.batchUpdateAiModels('provider1', models);
-    expect(vi.mocked(lambdaClient.aiModel.batchUpdateAiModels.mutate)).toHaveBeenCalledWith({
-      id: 'provider1',
-      models,
-    });
-  });
-
-  it('should batch toggle AI models', async () => {
-    const models = ['123', '456'];
-    await service.batchToggleAiModels('provider1', models, true);
-    expect(vi.mocked(lambdaClient.aiModel.batchToggleAiModels.mutate)).toHaveBeenCalledWith({
-      id: 'provider1',
-      models,
-      enabled: true,
-    });
-  });
-
-  it('should clear models by provider', async () => {
-    await service.clearModelsByProvider('provider1');
-    expect(vi.mocked(lambdaClient.aiModel.clearModelsByProvider.mutate)).toHaveBeenCalledWith({
-      providerId: 'provider1',
-    });
-  });
-
-  it('should clear remote models', async () => {
-    await service.clearRemoteModels('provider1');
-    expect(vi.mocked(lambdaClient.aiModel.clearRemoteModels.mutate)).toHaveBeenCalledWith({
-      providerId: 'provider1',
-    });
-  });
-
-  it('should update AI model order', async () => {
-    const items = [{ id: '123', sort: 1 }];
-    await service.updateAiModelOrder('provider1', items);
-    expect(vi.mocked(lambdaClient.aiModel.updateAiModelOrder.mutate)).toHaveBeenCalledWith({
-      providerId: 'provider1',
-      sortMap: items,
-    });
-  });
-
-  it('should delete AI model', async () => {
-    const params = { id: '123', providerId: 'openai' };
-    await service.deleteAiModel(params);
-    expect(vi.mocked(lambdaClient.aiModel.removeAiModel.mutate)).toHaveBeenCalledWith(params);
-  });
-});

package/src/services/aiModel/server.ts

@@ -1,51 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-import { IAiModelService } from '@/services/aiModel/type';
-
-export class ServerService implements IAiModelService {
-  createAiModel: IAiModelService['createAiModel'] = async (params) => {
-    return lambdaClient.aiModel.createAiModel.mutate(params);
-  };
-
-  getAiProviderModelList: IAiModelService['getAiProviderModelList'] = async (id) => {
-    return lambdaClient.aiModel.getAiProviderModelList.query({ id });
-  };
-
-  getAiModelById: IAiModelService['getAiModelById'] = async (id) => {
-    return lambdaClient.aiModel.getAiModelById.query({ id });
-  };
-
-  toggleModelEnabled: IAiModelService['toggleModelEnabled'] = async (params) => {
-    return lambdaClient.aiModel.toggleModelEnabled.mutate(params);
-  };
-
-  updateAiModel: IAiModelService['updateAiModel'] = async (id, providerId, value) => {
-    return lambdaClient.aiModel.updateAiModel.mutate({ id, providerId, value });
-  };
-
-  batchUpdateAiModels: IAiModelService['batchUpdateAiModels'] = async (id, models) => {
-    return lambdaClient.aiModel.batchUpdateAiModels.mutate({ id, models });
-  };
-
-  batchToggleAiModels: IAiModelService['batchToggleAiModels'] = async (id, models, enabled) => {
-    return lambdaClient.aiModel.batchToggleAiModels.mutate({ enabled, id, models });
-  };
-
-  clearModelsByProvider: IAiModelService['clearModelsByProvider'] = async (providerId) => {
-    return lambdaClient.aiModel.clearModelsByProvider.mutate({ providerId });
-  };
-
-  clearRemoteModels: IAiModelService['clearRemoteModels'] = async (providerId) => {
-    return lambdaClient.aiModel.clearRemoteModels.mutate({ providerId });
-  };
-
-  updateAiModelOrder: IAiModelService['updateAiModelOrder'] = async (providerId, items) => {
-    return lambdaClient.aiModel.updateAiModelOrder.mutate({ providerId, sortMap: items });
-  };
-
-  deleteAiModel: IAiModelService['deleteAiModel'] = async (params: {
-    id: string;
-    providerId: string;
-  }) => {
-    return lambdaClient.aiModel.removeAiModel.mutate(params);
-  };
-}

package/src/services/aiModel/type.ts

@@ -1,32 +0,0 @@
-/* eslint-disable typescript-sort-keys/interface */
-import {
-  AiModelSortMap,
-  AiProviderModelListItem,
-  CreateAiModelParams,
-  ToggleAiModelEnableParams,
-  UpdateAiModelParams,
-} from 'model-bank';
-
-export interface IAiModelService {
-  createAiModel: (params: CreateAiModelParams) => Promise<any>;
-
-  getAiProviderModelList: (id: string) => Promise<AiProviderModelListItem[]>;
-
-  getAiModelById: (id: string) => Promise<any>;
-
-  toggleModelEnabled: (params: ToggleAiModelEnableParams) => Promise<any>;
-
-  updateAiModel: (id: string, providerId: string, value: UpdateAiModelParams) => Promise<any>;
-
-  batchUpdateAiModels: (id: string, models: AiProviderModelListItem[]) => Promise<any>;
-
-  batchToggleAiModels: (id: string, models: string[], enabled: boolean) => Promise<any>;
-
-  clearRemoteModels: (providerId: string) => Promise<any>;
-
-  clearModelsByProvider: (providerId: string) => Promise<any>;
-
-  updateAiModelOrder: (providerId: string, items: AiModelSortMap[]) => Promise<any>;
-
-  deleteAiModel: (params: { id: string; providerId: string }) => Promise<any>;
-}

package/src/services/aiProvider/server.ts

@@ -1,43 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IAiProviderService } from './type';
-
-export class ServerService implements IAiProviderService {
-  createAiProvider: IAiProviderService['createAiProvider'] = async (params) => {
-    return lambdaClient.aiProvider.createAiProvider.mutate(params);
-  };
-
-  getAiProviderList: IAiProviderService['getAiProviderList'] = async () => {
-    return lambdaClient.aiProvider.getAiProviderList.query();
-  };
-
-  getAiProviderById: IAiProviderService['getAiProviderById'] = async (id) => {
-    return lambdaClient.aiProvider.getAiProviderById.query({ id });
-  };
-
-  toggleProviderEnabled: IAiProviderService['toggleProviderEnabled'] = async (id, enabled) => {
-    return lambdaClient.aiProvider.toggleProviderEnabled.mutate({ enabled, id });
-  };
-
-  updateAiProvider: IAiProviderService['updateAiProvider'] = async (id, value) => {
-    return lambdaClient.aiProvider.updateAiProvider.mutate({ id, value });
-  };
-
-  updateAiProviderConfig: IAiProviderService['updateAiProviderConfig'] = async (id, value) => {
-    return lambdaClient.aiProvider.updateAiProviderConfig.mutate({ id, value });
-  };
-
-  updateAiProviderOrder: IAiProviderService['updateAiProviderOrder'] = async (items) => {
-    return lambdaClient.aiProvider.updateAiProviderOrder.mutate({ sortMap: items });
-  };
-
-  deleteAiProvider: IAiProviderService['deleteAiProvider'] = async (id) => {
-    return lambdaClient.aiProvider.removeAiProvider.mutate({ id });
-  };
-
-  getAiProviderRuntimeState: IAiProviderService['getAiProviderRuntimeState'] = async (
-    isLogin?: boolean,
-  ) => {
-    return lambdaClient.aiProvider.getAiProviderRuntimeState.query({ isLogin });
-  };
-}

package/src/services/aiProvider/type.ts

@@ -1,27 +0,0 @@
-import {
-  AiProviderDetailItem,
-  AiProviderRuntimeState,
-  AiProviderSortMap,
-  CreateAiProviderParams,
-  UpdateAiProviderConfigParams,
-} from '@/types/aiProvider';
-
-export interface IAiProviderService {
-  createAiProvider: (params: CreateAiProviderParams) => Promise<any>;
-
-  deleteAiProvider: (id: string) => Promise<any>;
-
-  getAiProviderById: (id: string) => Promise<AiProviderDetailItem | undefined>;
-
-  getAiProviderList: () => Promise<any>;
-
-  getAiProviderRuntimeState: (isLogin?: boolean) => Promise<AiProviderRuntimeState>;
-
-  toggleProviderEnabled: (id: string, enabled: boolean) => Promise<any>;
-
-  updateAiProvider: (id: string, value: any) => Promise<any>;
-
-  updateAiProviderConfig: (id: string, value: UpdateAiProviderConfigParams) => Promise<any>;
-
-  updateAiProviderOrder: (items: AiProviderSortMap[]) => Promise<any>;
-}

package/src/services/chatGroup/server.ts

@@ -1,67 +0,0 @@
-import {
-  ChatGroupAgentItem,
-  ChatGroupItem,
-  NewChatGroup,
-  NewChatGroupAgent,
-} from '@/database/schemas';
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IChatGroupService } from './type';
-
-export class ServerService implements IChatGroupService {
-  createGroup(params: Omit<NewChatGroup, 'userId'>): Promise<ChatGroupItem> {
-    return lambdaClient.group.createGroup.mutate({
-      ...params,
-      config: params.config as any,
-    });
-  }
-
-  updateGroup(id: string, value: Partial<ChatGroupItem>): Promise<ChatGroupItem> {
-    return lambdaClient.group.updateGroup.mutate({
-      id,
-      value: {
-        ...value,
-        config: value.config as any,
-      },
-    });
-  }
-
-  deleteGroup(id: string): Promise<any> {
-    return lambdaClient.group.deleteGroup.mutate({ id });
-  }
-
-  getGroup(id: string): Promise<ChatGroupItem | undefined> {
-    return lambdaClient.group.getGroup.query({ id });
-  }
-
-  getGroups(): Promise<ChatGroupItem[]> {
-    return lambdaClient.group.getGroups.query();
-  }
-
-  addAgentsToGroup(groupId: string, agentIds: string[]): Promise<ChatGroupAgentItem[]> {
-    return lambdaClient.group.addAgentsToGroup.mutate({ agentIds, groupId });
-  }
-
-  removeAgentsFromGroup(groupId: string, agentIds: string[]): Promise<any> {
-    return lambdaClient.group.removeAgentsFromGroup.mutate({ agentIds, groupId });
-  }
-
-  updateAgentInGroup(
-    groupId: string,
-    agentId: string,
-    updates: Partial<Pick<NewChatGroupAgent, 'order' | 'role'>>,
-  ): Promise<ChatGroupAgentItem> {
-    return lambdaClient.group.updateAgentInGroup.mutate({
-      agentId,
-      groupId,
-      updates: {
-        order: updates.order === null ? undefined : updates.order,
-        role: updates.role === null ? undefined : updates.role,
-      },
-    });
-  }
-
-  getGroupAgents(groupId: string): Promise<ChatGroupAgentItem[]> {
-    return lambdaClient.group.getGroupAgents.query({ groupId });
-  }
-}