@lobehub/lobehub 2.0.0-next.3 → 2.0.0-next.31

package/src/services/mcp.ts

@@ -41,10 +41,44 @@ class MCPService {
 
     if (!plugin) return;
 
+    const connection = plugin.customParams?.mcp;
+    const settingsEntries = plugin.settings
+      ? Object.entries(plugin.settings as Record<string, any>).filter(
+        ([, value]) => value !== undefined && value !== null,
+      )
+      : [];
+    const pluginSettings =
+      settingsEntries.length > 0
+        ? settingsEntries.reduce<Record<string, unknown>>((acc, [key, value]) => {
+          acc[key] = value;
+
+          return acc;
+        }, {})
+        : undefined;
+
+    const params = {
+      ...connection,
+      name: identifier,
+    } as any;
+
+    if (connection?.type === 'http') {
+      params.headers = {
+        ...connection.headers,
+        ...pluginSettings,
+      };
+    }
+
+    if (connection?.type === 'stdio') {
+      params.env = {
+        ...connection?.env,
+        ...pluginSettings,
+      };
+    }
+
     const data = {
       args,
-      env: plugin.settings || plugin.customParams?.mcp?.env,
-      params: { ...plugin.customParams?.mcp, name: identifier } as any,
+      env: connection?.type === 'stdio' ? params.env : pluginSettings ?? connection?.env,
+      params,
       toolName: apiName,
     };
 
@@ -93,10 +127,10 @@ class MCPService {
         callDurationMs,
         customPluginInfo: isCustomPlugin
           ? {
-              avatar: plugin.manifest?.meta.avatar,
-              description: plugin.manifest?.meta.description,
-              name: plugin.manifest?.meta.title,
-            }
+            avatar: plugin.manifest?.meta.avatar,
+            description: plugin.manifest?.meta.description,
+            name: plugin.manifest?.meta.title,
+          }
           : undefined,
         errorCode,
         errorMessage,

package/src/services/message/index.ts

@@ -1,13 +1,206 @@
-import { isDesktop } from '@/const/version';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  ChatMessageError,
+  ChatMessagePluginError,
+  ChatTTS,
+  ChatTranslate,
+  CreateMessageParams,
+  CreateMessageResult,
+  ModelRankItem,
+  UIChatMessage,
+  UpdateMessageParams,
+  UpdateMessageRAGParams,
+  UpdateMessageResult,
+} from '@lobechat/types';
+import type { HeatmapsProps } from '@lobehub/charts';
 
-import { ClientService as DeprecatedService } from './_deprecated';
-import { ClientService } from './client';
-import { ServerService } from './server';
+import { INBOX_SESSION_ID } from '@/const/session';
+import { lambdaClient } from '@/libs/trpc/client';
+import { useUserStore } from '@/store/user';
+import { labPreferSelectors } from '@/store/user/selectors';
 
-const clientService =
-  process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
+export class MessageService {
+  private get useGroup() {
+    return labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
+  }
 
-export const messageService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : clientService;
+  createNewMessage = async ({
+    sessionId,
+    ...params
+  }: CreateMessageParams): Promise<CreateMessageResult> => {
+    return lambdaClient.message.createNewMessage.mutate({
+      ...params,
+      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
+      useGroup: this.useGroup,
+    });
+  };
+
+  getMessages = async (
+    sessionId: string,
+    topicId?: string,
+    groupId?: string,
+  ): Promise<UIChatMessage[]> => {
+    const data = await lambdaClient.message.getMessages.query({
+      groupId,
+      sessionId: this.toDbSessionId(sessionId),
+      topicId,
+      useGroup: this.useGroup,
+    });
+
+    return data as unknown as UIChatMessage[];
+  };
+
+  getGroupMessages = async (groupId: string, topicId?: string): Promise<UIChatMessage[]> => {
+    const data = await lambdaClient.message.getMessages.query({
+      groupId,
+      topicId,
+      useGroup: this.useGroup,
+    });
+    return data as unknown as UIChatMessage[];
+  };
+
+  countMessages = async (params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number> => {
+    return lambdaClient.message.count.query(params);
+  };
+
+  countWords = async (params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number> => {
+    return lambdaClient.message.countWords.query(params);
+  };
+
+  rankModels = async (): Promise<ModelRankItem[]> => {
+    return lambdaClient.message.rankModels.query();
+  };
+
+  getHeatmaps = async (): Promise<HeatmapsProps['data']> => {
+    return lambdaClient.message.getHeatmaps.query();
+  };
+
+  updateMessageError = async (id: string, error: ChatMessageError) => {
+    return lambdaClient.message.update.mutate({ id, value: { error } });
+  };
+
+  updateMessagePluginArguments = async (id: string, value: string | Record<string, any>) => {
+    const args = typeof value === 'string' ? value : JSON.stringify(value);
+    return lambdaClient.message.updateMessagePlugin.mutate({ id, value: { arguments: args } });
+  };
+
+  updateMessage = async (
+    id: string,
+    value: Partial<UpdateMessageParams>,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.update.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+      value,
+    });
+  };
+
+  updateMessageTranslate = async (id: string, translate: Partial<ChatTranslate> | false) => {
+    return lambdaClient.message.updateTranslate.mutate({ id, value: translate as ChatTranslate });
+  };
+
+  updateMessageTTS = async (id: string, tts: Partial<ChatTTS> | false) => {
+    return lambdaClient.message.updateTTS.mutate({ id, value: tts });
+  };
+
+  updateMessagePluginState = async (
+    id: string,
+    value: Record<string, any>,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.updatePluginState.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+      value,
+    });
+  };
+
+  updateMessagePluginError = async (
+    id: string,
+    error: ChatMessagePluginError | null,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.updatePluginError.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+      value: error as any,
+    });
+  };
+
+  updateMessageRAG = async (
+    id: string,
+    data: UpdateMessageRAGParams,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.updateMessageRAG.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+      value: data,
+    });
+  };
+
+  removeMessage = async (
+    id: string,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.removeMessage.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+    });
+  };
+
+  removeMessages = async (
+    ids: string[],
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.removeMessages.mutate({
+      ids,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+    });
+  };
+
+  removeMessagesByAssistant = async (sessionId: string, topicId?: string) => {
+    return lambdaClient.message.removeMessagesByAssistant.mutate({
+      sessionId: this.toDbSessionId(sessionId),
+      topicId,
+    });
+  };
+
+  removeMessagesByGroup = async (groupId: string, topicId?: string) => {
+    return lambdaClient.message.removeMessagesByGroup.mutate({
+      groupId,
+      topicId,
+    });
+  };
+
+  removeAllMessages = async () => {
+    return lambdaClient.message.removeAllMessages.mutate();
+  };
+
+  private toDbSessionId = (sessionId: string | undefined) => {
+    return sessionId === INBOX_SESSION_ID ? null : sessionId;
+  };
+}
+
+export const messageService = new MessageService();

package/src/services/message/{__tests__/server.test.ts → server.test.ts}

@@ -2,11 +2,11 @@ import { describe, expect, it } from 'vitest';
 
 import { INBOX_SESSION_ID } from '@/const/session';
 
-import { ServerService } from '../server';
+import { MessageService } from './index';
 
-describe('ServerService', () => {
+describe('MessageService', () => {
   describe('toDbSessionId', () => {
-    const service = new ServerService();
+    const service = new MessageService();
     // @ts-ignore access private method for testing
     const toDbSessionId = service.toDbSessionId;
 

package/src/services/models.ts

@@ -1,8 +1,5 @@
-import { isDeprecatedEdition } from '@/const/version';
 import { createHeaderWithAuth } from '@/services/_auth';
 import { aiProviderSelectors, getAiInfraStoreState } from '@/store/aiInfra';
-import { useUserStore } from '@/store/user';
-import { modelConfigSelectors } from '@/store/user/selectors';
 import { ChatModelCard } from '@/types/llm';
 import { getMessageError } from '@/utils/fetch';
 
@@ -10,14 +7,8 @@ import { API_ENDPOINTS } from './_url';
 import { initializeWithClientStore } from './chat/clientModelRuntime';
 import { resolveRuntimeProvider } from './chat/helper';
 
-const isEnableFetchOnClient = (provider: string) => {
-  // TODO: remove this condition in V2.0
-  if (isDeprecatedEdition) {
-    return modelConfigSelectors.isProviderFetchOnClient(provider)(useUserStore.getState());
-  } else {
-    return aiProviderSelectors.isProviderFetchOnClient(provider)(getAiInfraStoreState());
-  }
-};
+const isEnableFetchOnClient = (provider: string) =>
+  aiProviderSelectors.isProviderFetchOnClient(provider)(getAiInfraStoreState());
 
 // 进度信息接口
 export interface ModelProgressInfo {

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

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

package/src/services/plugin/index.ts

@@ -1,13 +1,54 @@
-import { isDesktop } from '@/const/version';
+import { LobeTool } from '@lobechat/types';
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 
-import { ClientService as DeprecatedService } from './_deprecated';
-import { ClientService } from './client';
-import { ServerService } from './server';
+import { lambdaClient } from '@/libs/trpc/client';
+import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
-const clientService =
-  process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
+export interface InstallPluginParams {
+  customParams?: Record<string, any>;
+  identifier: string;
+  manifest: LobeChatPluginManifest;
+  settings?: Record<string, any>;
+  type: 'plugin' | 'customPlugin';
+}
 
-export const pluginService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : clientService;
+export class PluginService {
+  installPlugin = async (plugin: InstallPluginParams): Promise<void> => {
+    await lambdaClient.plugin.createOrInstallPlugin.mutate(plugin);
+  };
+
+  getInstalledPlugins = (): Promise<LobeTool[]> => {
+    return lambdaClient.plugin.getPlugins.query();
+  };
+
+  uninstallPlugin = async (identifier: string): Promise<void> => {
+    await lambdaClient.plugin.removePlugin.mutate({ id: identifier });
+  };
+
+  createCustomPlugin = async (customPlugin: LobeToolCustomPlugin): Promise<void> => {
+    await lambdaClient.plugin.createPlugin.mutate({ ...customPlugin, type: 'customPlugin' });
+  };
+
+  updatePlugin = async (id: string, value: Partial<LobeToolCustomPlugin>): Promise<void> => {
+    await lambdaClient.plugin.updatePlugin.mutate({
+      customParams: value.customParams,
+      id,
+      manifest: value.manifest,
+      settings: value.settings,
+    });
+  };
+
+  updatePluginManifest = async (id: string, manifest: LobeChatPluginManifest): Promise<void> => {
+    await lambdaClient.plugin.updatePlugin.mutate({ id, manifest });
+  };
+
+  removeAllPlugins = async (): Promise<void> => {
+    await lambdaClient.plugin.removeAllPlugins.mutate();
+  };
+
+  updatePluginSettings = async (id: string, settings: any, signal?: AbortSignal): Promise<void> => {
+    await lambdaClient.plugin.updatePlugin.mutate({ id, settings }, { signal });
+  };
+}
+
+export const pluginService = new PluginService();

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

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

package/src/services/session/index.ts

@@ -1,13 +1,146 @@
-import { isDesktop } from '@/const/version';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { PartialDeep } from 'type-fest';
 
-import { ClientService as DeprecatedService } from './_deprecated';
-import { ClientService } from './client';
-import { ServerService } from './server';
+import { lambdaClient } from '@/libs/trpc/client';
+import { LobeAgentChatConfig, LobeAgentConfig } from '@/types/agent';
+import { MetaData } from '@/types/meta';
+import { BatchTaskResult } from '@/types/service';
+import {
+  ChatSessionList,
+  LobeAgentSession,
+  LobeSessionType,
+  LobeSessions,
+  SessionGroupItem,
+  SessionGroups,
+  SessionRankItem,
+  UpdateSessionParams,
+} from '@/types/session';
 
-const clientService =
-  process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
+export class SessionService {
+  hasSessions = async (): Promise<boolean> => {
+    const result = await this.countSessions();
+    return result === 0;
+  };
 
-export const sessionService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : clientService;
+  createSession = async (
+    type: LobeSessionType,
+    data: Partial<LobeAgentSession>,
+  ): Promise<string> => {
+    const { config, group, meta, ...session } = data;
+    return lambdaClient.session.createSession.mutate({
+      config: { ...config, ...meta } as any,
+      session: { ...session, groupId: group },
+      type,
+    });
+  };
+
+  cloneSession = (id: string, newTitle: string): Promise<string | undefined> => {
+    return lambdaClient.session.cloneSession.mutate({ id, newTitle });
+  };
+
+  getGroupedSessions = (): Promise<ChatSessionList> => {
+    return lambdaClient.session.getGroupedSessions.query();
+  };
+
+  countSessions = async (params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number> => {
+    return lambdaClient.session.countSessions.query(params);
+  };
+
+  rankSessions = async (limit?: number): Promise<SessionRankItem[]> => {
+    return lambdaClient.session.rankSessions.query(limit);
+  };
+
+  updateSession = (id: string, data: Partial<UpdateSessionParams>) => {
+    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
+  getSessionConfig = async (id: string): Promise<LobeAgentConfig> => {
+    // @ts-ignore
+    return lambdaClient.agent.getAgentConfig.query({ sessionId: id });
+  };
+
+  updateSessionConfig = (
+    id: string,
+    config: PartialDeep<LobeAgentConfig>,
+    signal?: AbortSignal,
+  ) => {
+    return lambdaClient.session.updateSessionConfig.mutate(
+      { id, value: config },
+      {
+        context: { showNotification: false },
+        signal,
+      },
+    );
+  };
+
+  updateSessionMeta = (id: string, meta: Partial<MetaData>, signal?: AbortSignal) => {
+    return lambdaClient.session.updateSessionConfig.mutate({ id, value: meta }, { signal });
+  };
+
+  updateSessionChatConfig = (
+    id: string,
+    value: Partial<LobeAgentChatConfig>,
+    signal?: AbortSignal,
+  ) => {
+    return lambdaClient.session.updateSessionChatConfig.mutate({ id, value }, { signal });
+  };
+
+  searchSessions = (keywords: string): Promise<LobeSessions> => {
+    return lambdaClient.session.searchSessions.query({ keywords });
+  };
+
+  removeSession = (id: string) => {
+    return lambdaClient.session.removeSession.mutate({ id });
+  };
+
+  removeAllSessions = () => {
+    return lambdaClient.session.removeAllSessions.mutate();
+  };
+
+  // ************************************** //
+  // ***********  SessionGroup  *********** //
+  // ************************************** //
+
+  createSessionGroup = (name: string, sort?: number): Promise<string> => {
+    return lambdaClient.sessionGroup.createSessionGroup.mutate({ name, sort });
+  };
+
+  getSessionGroups = (): Promise<SessionGroupItem[]> => {
+    return lambdaClient.sessionGroup.getSessionGroup.query();
+  };
+
+  /**
+   * 需要废弃
+   * @deprecated
+   */
+  batchCreateSessionGroups = (groups: SessionGroups): Promise<BatchTaskResult> => {
+    return Promise.resolve({ added: 0, ids: [], skips: [], success: true });
+  };
+
+  removeSessionGroup = (id: string, removeChildren?: boolean) => {
+    return lambdaClient.sessionGroup.removeSessionGroup.mutate({ id, removeChildren });
+  };
+
+  removeSessionGroups = () => {
+    return lambdaClient.sessionGroup.removeAllSessionGroups.mutate();
+  };
+
+  updateSessionGroup = (id: string, value: Partial<SessionGroupItem>) => {
+    return lambdaClient.sessionGroup.updateSessionGroup.mutate({ id, value });
+  };
+
+  updateSessionGroupOrder = (sortMap: { id: string; sort: number }[]) => {
+    return lambdaClient.sessionGroup.updateSessionGroupOrder.mutate({ sortMap });
+  };
+}
+
+export const sessionService = new SessionService();

package/src/services/tableViewer/client.ts

@@ -1,16 +1,13 @@
-import { clientDB } from '@/database/client/db';
-import { TableViewerRepo } from '@/database/repositories/tableViewer';
-import { BaseClientService } from '@/services/baseClientService';
-
-export class ClientService extends BaseClientService {
-  private get tableViewerRepo(): TableViewerRepo {
-    return new TableViewerRepo(clientDB as any, this.userId);
-  }
-
-  getAllTables = async () => this.tableViewerRepo.getAllTables();
-
-  getTableDetails = async (tableName: string) => this.tableViewerRepo.getTableDetails(tableName);
-
-  getTableData = async (tableName: string) =>
-    this.tableViewerRepo.getTableData(tableName, { page: 1, pageSize: 300 });
+export class ClientService {
+  getAllTables = async () => [];
+
+  getTableDetails = async (tableName: string) => {
+    console.log('getTableDetails:', tableName);
+    return [];
+  };
+
+  getTableData = async (tableName: string) => {
+    console.log('getTableData:', tableName);
+    return [];
+  };
 }

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

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

package/src/services/thread/index.ts

@@ -1,9 +1,39 @@
-import { isDesktop } from '@/const/version';
+import { CreateMessageParams } from '@lobechat/types';
 
-import { ClientService } from './client';
-import { ServerService } from './server';
+import { INBOX_SESSION_ID } from '@/const/session';
+import { lambdaClient } from '@/libs/trpc/client';
+import { CreateThreadParams, ThreadItem } from '@/types/topic';
 
-export const threadService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : new ClientService();
+interface CreateThreadWithMessageParams extends CreateThreadParams {
+  message: CreateMessageParams;
+}
+
+export class ThreadService {
+  getThreads = (topicId: string): Promise<ThreadItem[]> => {
+    return lambdaClient.thread.getThreads.query({ topicId });
+  };
+
+  createThreadWithMessage = async ({
+    message,
+    ...params
+  }: CreateThreadWithMessageParams): Promise<{ messageId: string; threadId: string }> => {
+    return lambdaClient.thread.createThreadWithMessage.mutate({
+      ...params,
+      message: { ...message, sessionId: this.toDbSessionId(message.sessionId) },
+    });
+  };
+
+  updateThread = async (id: string, data: Partial<ThreadItem>) => {
+    return lambdaClient.thread.updateThread.mutate({ id, value: data });
+  };
+
+  removeThread = async (id: string) => {
+    return lambdaClient.thread.removeThread.mutate({ id });
+  };
+
+  private toDbSessionId = (sessionId: string | undefined) => {
+    return sessionId === INBOX_SESSION_ID ? null : sessionId;
+  };
+}
+
+export const threadService = new ThreadService();

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

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