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

package/src/services/message/server.ts

@@ -1,151 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { ChatTranslate, UIChatMessage } from '@lobechat/types';
-
-import { INBOX_SESSION_ID } from '@/const/session';
-import { lambdaClient } from '@/libs/trpc/client';
-import { useUserStore } from '@/store/user';
-import { labPreferSelectors } from '@/store/user/selectors';
-
-import { IMessageService } from './type';
-
-export class ServerService implements IMessageService {
-  createMessage: IMessageService['createMessage'] = async ({ sessionId, ...params }) => {
-    return lambdaClient.message.createMessage.mutate({
-      ...params,
-      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
-    });
-  };
-
-  createNewMessage: IMessageService['createNewMessage'] = async ({ sessionId, ...params }) => {
-    return lambdaClient.message.createNewMessage.mutate({
-      ...params,
-      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
-    });
-  };
-
-  getMessages: IMessageService['getMessages'] = async (sessionId, topicId, groupId) => {
-    // Get user lab preference for message grouping
-    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
-
-    const data = await lambdaClient.message.getMessages.query({
-      groupId,
-      sessionId: this.toDbSessionId(sessionId),
-      topicId,
-      useGroup,
-    });
-
-    return data as unknown as UIChatMessage[];
-  };
-
-  getGroupMessages: IMessageService['getGroupMessages'] = async (groupId, topicId) => {
-    // Get user lab preference for message grouping
-    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
-
-    const data = await lambdaClient.message.getMessages.query({
-      groupId,
-      topicId,
-      useGroup,
-    });
-    return data as unknown as UIChatMessage[];
-  };
-
-  countMessages: IMessageService['countMessages'] = async (params) => {
-    return lambdaClient.message.count.query(params);
-  };
-
-  countWords: IMessageService['countWords'] = async (params) => {
-    return lambdaClient.message.countWords.query(params);
-  };
-
-  rankModels: IMessageService['rankModels'] = async () => {
-    return lambdaClient.message.rankModels.query();
-  };
-
-  getHeatmaps: IMessageService['getHeatmaps'] = async () => {
-    return lambdaClient.message.getHeatmaps.query();
-  };
-
-  updateMessageError: IMessageService['updateMessageError'] = async (id, error) => {
-    return lambdaClient.message.update.mutate({ id, value: { error } });
-  };
-
-  updateMessagePluginArguments: IMessageService['updateMessagePluginArguments'] = async (
-    id,
-    value,
-  ) => {
-    const args = typeof value === 'string' ? value : JSON.stringify(value);
-    return lambdaClient.message.updateMessagePlugin.mutate({ id, value: { arguments: args } });
-  };
-
-  updateMessage: IMessageService['updateMessage'] = async (id, value, options) => {
-    return lambdaClient.message.update.mutate({
-      id,
-      sessionId: options?.sessionId,
-      topicId: options?.topicId,
-      value,
-    });
-  };
-
-  updateMessageTranslate: IMessageService['updateMessageTranslate'] = async (id, translate) => {
-    return lambdaClient.message.updateTranslate.mutate({ id, value: translate as ChatTranslate });
-  };
-
-  updateMessageTTS: IMessageService['updateMessageTTS'] = async (id, tts) => {
-    return lambdaClient.message.updateTTS.mutate({ id, value: tts });
-  };
-
-  updateMessagePluginState: IMessageService['updateMessagePluginState'] = async (id, value) => {
-    return lambdaClient.message.updatePluginState.mutate({ id, value });
-  };
-
-  updateMessagePluginError: IMessageService['updateMessagePluginError'] = async (id, error) => {
-    return lambdaClient.message.updatePluginError.mutate({ id, value: error as any });
-  };
-
-  updateMessageRAG: IMessageService['updateMessageRAG'] = async (id, data) => {
-    return lambdaClient.message.updateMessageRAG.mutate({ id, value: data });
-  };
-
-  removeMessage: IMessageService['removeMessage'] = async (id) => {
-    return lambdaClient.message.removeMessage.mutate({ id });
-  };
-
-  removeMessages: IMessageService['removeMessages'] = async (ids) => {
-    return lambdaClient.message.removeMessages.mutate({ ids });
-  };
-
-  removeMessagesByAssistant: IMessageService['removeMessagesByAssistant'] = async (
-    sessionId,
-    topicId,
-  ) => {
-    return lambdaClient.message.removeMessagesByAssistant.mutate({
-      sessionId: this.toDbSessionId(sessionId),
-      topicId,
-    });
-  };
-
-  removeMessagesByGroup: IMessageService['removeMessagesByGroup'] = async (groupId, topicId) => {
-    return lambdaClient.message.removeMessagesByGroup.mutate({
-      groupId,
-      topicId,
-    });
-  };
-
-  removeAllMessages: IMessageService['removeAllMessages'] = async () => {
-    return lambdaClient.message.removeAllMessages.mutate();
-  };
-
-  private toDbSessionId = (sessionId: string | undefined) => {
-    return sessionId === INBOX_SESSION_ID ? null : sessionId;
-  };
-
-  hasMessages: IMessageService['hasMessages'] = async () => {
-    const number = await this.countMessages();
-    return number > 0;
-  };
-
-  messageCountToCheckTrace: IMessageService['messageCountToCheckTrace'] = async () => {
-    const number = await this.countMessages();
-    return number >= 4;
-  };
-}

package/src/services/message/type.ts

@@ -1,55 +0,0 @@
-import {
-  ChatMessageError,
-  ChatMessagePluginError,
-  ChatTTS,
-  ChatTranslate,
-  CreateMessageParams,
-  CreateMessageResult,
-  ModelRankItem,
-  UIChatMessage,
-  UpdateMessageParams,
-  UpdateMessageRAGParams,
-  UpdateMessageResult,
-} from '@lobechat/types';
-import type { HeatmapsProps } from '@lobehub/charts';
-
-/* eslint-disable typescript-sort-keys/interface */
-
-export interface IMessageService {
-  createMessage(data: CreateMessageParams): Promise<string>;
-  createNewMessage(data: CreateMessageParams): Promise<CreateMessageResult>;
-
-  getMessages(sessionId: string, topicId?: string, groupId?: string): Promise<UIChatMessage[]>;
-  getGroupMessages(groupId: string, topicId?: string): Promise<UIChatMessage[]>;
-  countMessages(params?: {
-    endDate?: string;
-    range?: [string, string];
-    startDate?: string;
-  }): Promise<number>;
-  countWords(params?: {
-    endDate?: string;
-    range?: [string, string];
-    startDate?: string;
-  }): Promise<number>;
-  rankModels(): Promise<ModelRankItem[]>;
-  getHeatmaps(): Promise<HeatmapsProps['data']>;
-  updateMessageError(id: string, error: ChatMessageError): Promise<any>;
-  updateMessage(
-    id: string,
-    message: Partial<UpdateMessageParams>,
-    options?: { sessionId?: string | null; topicId?: string | null },
-  ): Promise<UpdateMessageResult>;
-  updateMessageTTS(id: string, tts: Partial<ChatTTS> | false): Promise<any>;
-  updateMessageTranslate(id: string, translate: Partial<ChatTranslate> | false): Promise<any>;
-  updateMessagePluginState(id: string, value: Record<string, any>): Promise<any>;
-  updateMessagePluginError(id: string, value: ChatMessagePluginError | null): Promise<any>;
-  updateMessageRAG(id: string, value: UpdateMessageRAGParams): Promise<void>;
-  updateMessagePluginArguments(id: string, value: string | Record<string, any>): Promise<any>;
-  removeMessage(id: string): Promise<any>;
-  removeMessages(ids: string[]): Promise<any>;
-  removeMessagesByAssistant(assistantId: string, topicId?: string): Promise<any>;
-  removeMessagesByGroup(groupId: string, topicId?: string): Promise<any>;
-  removeAllMessages(): Promise<any>;
-  messageCountToCheckTrace(): Promise<boolean>;
-  hasMessages(): Promise<boolean>;
-}

package/src/services/plugin/server.ts

@@ -1,42 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IPluginService } from './type';
-
-export class ServerService implements IPluginService {
-  installPlugin: IPluginService['installPlugin'] = async (plugin) => {
-    await lambdaClient.plugin.createOrInstallPlugin.mutate(plugin);
-  };
-
-  getInstalledPlugins: IPluginService['getInstalledPlugins'] = () => {
-    return lambdaClient.plugin.getPlugins.query();
-  };
-
-  uninstallPlugin: IPluginService['uninstallPlugin'] = async (identifier) => {
-    await lambdaClient.plugin.removePlugin.mutate({ id: identifier });
-  };
-
-  createCustomPlugin: IPluginService['createCustomPlugin'] = async (customPlugin) => {
-    await lambdaClient.plugin.createPlugin.mutate({ ...customPlugin, type: 'customPlugin' });
-  };
-
-  updatePlugin: IPluginService['updatePlugin'] = async (id, value) => {
-    await lambdaClient.plugin.updatePlugin.mutate({
-      customParams: value.customParams,
-      id,
-      manifest: value.manifest,
-      settings: value.settings,
-    });
-  };
-
-  updatePluginManifest: IPluginService['updatePluginManifest'] = async (id, manifest) => {
-    await lambdaClient.plugin.updatePlugin.mutate({ id, manifest });
-  };
-
-  removeAllPlugins: IPluginService['removeAllPlugins'] = async () => {
-    await lambdaClient.plugin.removeAllPlugins.mutate();
-  };
-
-  updatePluginSettings: IPluginService['updatePluginSettings'] = async (id, settings, signal) => {
-    await lambdaClient.plugin.updatePlugin.mutate({ id, settings }, { signal });
-  };
-}

package/src/services/plugin/type.ts

@@ -1,23 +0,0 @@
-import { LobeTool } from '@lobechat/types';
-import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
-
-import { LobeToolCustomPlugin } from '@/types/tool/plugin';
-
-export interface InstallPluginParams {
-  customParams?: Record<string, any>;
-  identifier: string;
-  manifest: LobeChatPluginManifest;
-  settings?: Record<string, any>;
-  type: 'plugin' | 'customPlugin';
-}
-
-export interface IPluginService {
-  createCustomPlugin: (customPlugin: LobeToolCustomPlugin) => Promise<void>;
-  getInstalledPlugins: () => Promise<LobeTool[]>;
-  installPlugin: (plugin: InstallPluginParams) => Promise<void>;
-  removeAllPlugins: () => Promise<void>;
-  uninstallPlugin: (identifier: string) => Promise<void>;
-  updatePlugin: (id: string, value: Partial<LobeToolCustomPlugin>) => Promise<void>;
-  updatePluginManifest: (id: string, manifest: LobeChatPluginManifest) => Promise<void>;
-  updatePluginSettings: (id: string, settings: any, signal?: AbortSignal) => Promise<void>;
-}

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

@@ -1,260 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { lambdaClient } from '@/libs/trpc/client';
-import { LobeSessionType } from '@/types/session';
-
-import { ServerService } from './server';
-
-vi.mock('@/libs/trpc/client', () => ({
-  lambdaClient: {
-    session: {
-      createSession: { mutate: vi.fn() },
-      batchCreateSessions: { mutate: vi.fn() },
-      cloneSession: { mutate: vi.fn() },
-      getGroupedSessions: { query: vi.fn() },
-      countSessions: { query: vi.fn() },
-      rankSessions: { query: vi.fn() },
-      updateSession: { mutate: vi.fn() },
-      updateSessionConfig: { mutate: vi.fn() },
-      updateSessionChatConfig: { mutate: vi.fn() },
-      getSessions: { query: vi.fn() },
-      searchSessions: { query: vi.fn() },
-      removeSession: { mutate: vi.fn() },
-      removeAllSessions: { mutate: vi.fn() },
-    },
-    agent: {
-      getAgentConfig: { query: vi.fn() },
-    },
-    sessionGroup: {
-      createSessionGroup: { mutate: vi.fn() },
-      getSessionGroup: { query: vi.fn() },
-      removeSessionGroup: { mutate: vi.fn() },
-      removeAllSessionGroups: { mutate: vi.fn() },
-      updateSessionGroup: { mutate: vi.fn() },
-      updateSessionGroupOrder: { mutate: vi.fn() },
-    },
-  },
-}));
-
-describe('ServerService', () => {
-  let service: ServerService;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    service = new ServerService();
-  });
-
-  it('hasSessions should return true if count is 0', async () => {
-    vi.mocked(lambdaClient.session.countSessions.query).mockResolvedValue(0);
-    const result = await service.hasSessions();
-    expect(result).toBe(true);
-  });
-
-  it('createSession should call lambdaClient with correct params', async () => {
-    const mockData = {
-      config: {
-        model: 'gpt-3.5',
-        params: {},
-        systemRole: '',
-        chatConfig: {
-          autoCreateTopicThreshold: 2,
-          compressThreshold: 10,
-          enableAutoCreateTopic: true,
-          enableCompressThreshold: true,
-          maxTokens: 2000,
-          model: 'gpt-3.5-turbo',
-          params: {},
-          temperature: 0.7,
-          title: 'test',
-        },
-        tts: {
-          showAllLocaleVoice: false,
-          sttLocale: 'auto',
-          ttsService: 'openai' as const,
-          voice: {
-            model: 'tts-1',
-            name: 'alloy',
-            type: 'tts',
-            openai: 'voice-id',
-          },
-        },
-        openingQuestions: ['Question 1', 'Question 2'],
-        openingMessage: 'Hello, I am [LobeChat](https://github.com/lobehub/lobe-chat).',
-      },
-      group: 'testGroup',
-      meta: { description: 'test' },
-      title: 'Test Session',
-    };
-
-    await service.createSession(LobeSessionType.Agent, mockData);
-
-    expect(lambdaClient.session.createSession.mutate).toBeCalledWith({
-      config: { ...mockData.config, description: 'test' },
-      session: { title: 'Test Session', groupId: 'testGroup' },
-      type: LobeSessionType.Agent,
-    });
-  });
-
-  it('batchCreateSessions should call lambdaClient', async () => {
-    const mockSessions = [
-      {
-        id: '1',
-        title: 'Test',
-        config: {
-          model: 'gpt-3.5',
-          params: {},
-          systemRole: '',
-          chatConfig: {
-            autoCreateTopicThreshold: 2,
-            compressThreshold: 10,
-            enableAutoCreateTopic: true,
-            enableCompressThreshold: true,
-            maxTokens: 2000,
-            model: 'gpt-3.5-turbo',
-            params: {},
-            temperature: 0.7,
-            title: 'test',
-          },
-          tts: {
-            showAllLocaleVoice: false,
-            sttLocale: 'auto',
-            ttsService: 'openai' as const,
-            voice: {
-              model: 'tts-1',
-              name: 'alloy',
-              type: 'tts',
-              openai: 'voice-id',
-            },
-          },
-        },
-        createdAt: new Date(),
-        meta: { description: 'test' },
-        model: 'gpt-3.5',
-        type: LobeSessionType.Agent,
-        updatedAt: new Date(),
-      },
-    ];
-
-    await service.batchCreateSessions(mockSessions as any);
-    expect(lambdaClient.session.batchCreateSessions.mutate).toBeCalledWith(mockSessions);
-  });
-
-  it('cloneSession should call lambdaClient', async () => {
-    await service.cloneSession('123', 'New Title');
-    expect(lambdaClient.session.cloneSession.mutate).toBeCalledWith({
-      id: '123',
-      newTitle: 'New Title',
-    });
-  });
-
-  it('getGroupedSessions should call lambdaClient', async () => {
-    await service.getGroupedSessions();
-    expect(lambdaClient.session.getGroupedSessions.query).toBeCalled();
-  });
-
-  it('countSessions should call lambdaClient with params', async () => {
-    const params = { startDate: '2023-01-01' };
-    await service.countSessions(params);
-    expect(lambdaClient.session.countSessions.query).toBeCalledWith(params);
-  });
-
-  it('rankSessions should call lambdaClient with limit', async () => {
-    await service.rankSessions(10);
-    expect(lambdaClient.session.rankSessions.query).toBeCalledWith(10);
-  });
-
-  it('updateSession should call lambdaClient with correct params', async () => {
-    const mockData = {
-      group: 'default',
-      pinned: true,
-      meta: { description: 'bar' },
-      updatedAt: new Date(),
-    };
-
-    await service.updateSession('123', mockData);
-
-    expect(lambdaClient.session.updateSession.mutate).toBeCalledWith({
-      id: '123',
-      value: {
-        groupId: null,
-        pinned: true,
-        description: 'bar',
-        updatedAt: mockData.updatedAt,
-      },
-    });
-  });
-
-  it('getSessionConfig should call lambdaClient', async () => {
-    await service.getSessionConfig('123');
-    expect(lambdaClient.agent.getAgentConfig.query).toBeCalledWith({ sessionId: '123' });
-  });
-
-  it('updateSessionConfig should call lambdaClient', async () => {
-    const config = { model: 'gpt-4' };
-    const signal = new AbortController().signal;
-    await service.updateSessionConfig('123', config, signal);
-    expect(lambdaClient.session.updateSessionConfig.mutate).toBeCalledWith(
-      { id: '123', value: config },
-      {
-        signal,
-        context: { showNotification: false },
-      },
-    );
-  });
-
-  it('getSessionsByType should call lambdaClient', async () => {
-    await service.getSessionsByType('all');
-    expect(lambdaClient.session.getSessions.query).toBeCalledWith({});
-  });
-
-  it('searchSessions should call lambdaClient with keywords', async () => {
-    await service.searchSessions('test');
-    expect(lambdaClient.session.searchSessions.query).toBeCalledWith({ keywords: 'test' });
-  });
-
-  it('removeSession should call lambdaClient', async () => {
-    await service.removeSession('123');
-    expect(lambdaClient.session.removeSession.mutate).toBeCalledWith({ id: '123' });
-  });
-
-  it('removeAllSessions should call lambdaClient', async () => {
-    await service.removeAllSessions();
-    expect(lambdaClient.session.removeAllSessions.mutate).toBeCalled();
-  });
-
-  it('createSessionGroup should call lambdaClient', async () => {
-    await service.createSessionGroup('Test Group', 1);
-    expect(lambdaClient.sessionGroup.createSessionGroup.mutate).toBeCalledWith({
-      name: 'Test Group',
-      sort: 1,
-    });
-  });
-
-  it('getSessionGroups should call lambdaClient', async () => {
-    await service.getSessionGroups();
-    expect(lambdaClient.sessionGroup.getSessionGroup.query).toBeCalled();
-  });
-
-  it('removeSessionGroup should call lambdaClient', async () => {
-    await service.removeSessionGroup('123', true);
-    expect(lambdaClient.sessionGroup.removeSessionGroup.mutate).toBeCalledWith({
-      id: '123',
-      removeChildren: true,
-    });
-  });
-
-  it('updateSessionGroup should call lambdaClient', async () => {
-    const value = { name: 'Updated Group' };
-    await service.updateSessionGroup('123', value);
-    expect(lambdaClient.sessionGroup.updateSessionGroup.mutate).toBeCalledWith({
-      id: '123',
-      value,
-    });
-  });
-
-  it('updateSessionGroupOrder should call lambdaClient', async () => {
-    const sortMap = [{ id: '123', sort: 1 }];
-    await service.updateSessionGroupOrder(sortMap);
-    expect(lambdaClient.sessionGroup.updateSessionGroupOrder.mutate).toBeCalledWith({ sortMap });
-  });
-});

package/src/services/session/server.ts

@@ -1,125 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { ISessionService } from './type';
-
-export class ServerService implements ISessionService {
-  hasSessions: ISessionService['hasSessions'] = async () => {
-    const result = await this.countSessions();
-    return result === 0;
-  };
-
-  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,
-    });
-  };
-
-  batchCreateSessions: ISessionService['batchCreateSessions'] = async (importSessions) => {
-    // TODO: remove any
-    const data = await lambdaClient.session.batchCreateSessions.mutate(importSessions as any);
-    console.log(data);
-    return data;
-  };
-
-  cloneSession: ISessionService['cloneSession'] = (id, newTitle) => {
-    return lambdaClient.session.cloneSession.mutate({ id, newTitle });
-  };
-
-  getGroupedSessions: ISessionService['getGroupedSessions'] = () => {
-    return lambdaClient.session.getGroupedSessions.query();
-  };
-
-  countSessions: ISessionService['countSessions'] = async (params) => {
-    return lambdaClient.session.countSessions.query(params);
-  };
-
-  rankSessions: ISessionService['rankSessions'] = async (limit) => {
-    return lambdaClient.session.rankSessions.query(limit);
-  };
-
-  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 },
-    });
-  };
-
-  // TODO: Need to be fixed
-  // @ts-ignore
-  getSessionConfig: ISessionService['getSessionConfig'] = async (id) => {
-    return lambdaClient.agent.getAgentConfig.query({ sessionId: id });
-  };
-
-  updateSessionConfig: ISessionService['updateSessionConfig'] = (id, config, signal) => {
-    return lambdaClient.session.updateSessionConfig.mutate(
-      { id, value: config },
-      {
-        context: { showNotification: false },
-        signal,
-      },
-    );
-  };
-
-  updateSessionMeta: ISessionService['updateSessionMeta'] = (id, meta, signal) => {
-    return lambdaClient.session.updateSessionConfig.mutate({ id, value: meta }, { signal });
-  };
-
-  updateSessionChatConfig: ISessionService['updateSessionChatConfig'] = (id, value, signal) => {
-    return lambdaClient.session.updateSessionChatConfig.mutate({ id, value }, { signal });
-  };
-
-  // TODO: need be fixed
-  // @ts-ignore
-  getSessionsByType: ISessionService['getSessionsByType'] = (_type = 'all') => {
-    return lambdaClient.session.getSessions.query({});
-  };
-
-  searchSessions: ISessionService['searchSessions'] = (keywords) => {
-    return lambdaClient.session.searchSessions.query({ keywords });
-  };
-
-  removeSession: ISessionService['removeSession'] = (id) => {
-    return lambdaClient.session.removeSession.mutate({ id });
-  };
-
-  removeAllSessions: ISessionService['removeAllSessions'] = () => {
-    return lambdaClient.session.removeAllSessions.mutate();
-  };
-
-  // ************************************** //
-  // ***********  SessionGroup  *********** //
-  // ************************************** //
-
-  createSessionGroup: ISessionService['createSessionGroup'] = (name, sort) => {
-    return lambdaClient.sessionGroup.createSessionGroup.mutate({ name, sort });
-  };
-
-  getSessionGroups: ISessionService['getSessionGroups'] = () => {
-    return lambdaClient.sessionGroup.getSessionGroup.query();
-  };
-
-  batchCreateSessionGroups: ISessionService['batchCreateSessionGroups'] = (_groups) => {
-    return Promise.resolve({ added: 0, ids: [], skips: [], success: true });
-  };
-
-  removeSessionGroup: ISessionService['removeSessionGroup'] = (id, removeChildren) => {
-    return lambdaClient.sessionGroup.removeSessionGroup.mutate({ id, removeChildren });
-  };
-
-  removeSessionGroups: ISessionService['removeSessionGroups'] = () => {
-    return lambdaClient.sessionGroup.removeAllSessionGroups.mutate();
-  };
-
-  updateSessionGroup: ISessionService['updateSessionGroup'] = (id, value) => {
-    return lambdaClient.sessionGroup.updateSessionGroup.mutate({ id, value });
-  };
-
-  updateSessionGroupOrder: ISessionService['updateSessionGroupOrder'] = (sortMap) => {
-    return lambdaClient.sessionGroup.updateSessionGroupOrder.mutate({ sortMap });
-  };
-}