@lobehub/lobehub 2.0.0-next.160 → 2.0.0-next.162

package/src/locales/default/setting.ts

@@ -779,12 +779,37 @@ export default {
       groupName: '内置插件',
     },
     disabled: '当前模型不支持函数调用，无法使用插件',
+    klavis: {
+      addServer: '添加服务器',
+      authCompleted: '认证完成',
+      authFailed: '认证失败',
+      authRequired: '需要认证',
+      connected: '已连接',
+      error: '错误',
+      groupName: 'Klavis 工具',
+      manage: '管理 Klavis',
+      manageTitle: '管理 Klavis 集成',
+      noServers: '暂无连接的服务器',
+      notEnabled: 'Klavis 服务未启用',
+      oauthRequired: '请在新窗口中完成 OAuth 认证',
+      pendingAuth: '待认证',
+      serverCreated: '服务器创建成功',
+      serverCreatedFailed: '服务器创建失败',
+      serverRemoved: '服务器已删除',
+      servers: '个服务器',
+      tools: '个工具',
+      verifyAuth: '我已完成认证',
+    },
     plugins: {
       enabled: '已启用 {{num}}',
       groupName: '三方插件',
       noEnabled: '暂无启用插件',
       store: '插件商店',
     },
+    tabs: {
+      all: '全部',
+      installed: '已启用',
+    },
     title: '扩展插件',
   },
 };

package/src/proxy.ts

@@ -52,6 +52,7 @@ export const config = {
     '/signin(.*)',
     '/verify-email(.*)',
     '/reset-password(.*)',
+    '/auth-error(.*)',
     '/next-auth/(.*)',
     '/oauth(.*)',
     '/oidc(.*)',

package/src/server/globalConfig/index.ts

@@ -1,3 +1,4 @@
+import { klavisEnv } from '@/config/klavis';
 import { isDesktop } from '@/const/version';
 import { appEnv, getAppConfig } from '@/envs/app';
 import { authEnv } from '@/envs/auth';
@@ -66,6 +67,7 @@ export const getServerGlobalConfig = async () => {
     defaultAgent: {
       config: parseAgentConfig(DEFAULT_AGENT_CONFIG),
     },
+    enableKlavis: !!klavisEnv.KLAVIS_API_KEY,
     enableUploadFileToServer: !!fileEnv.S3_SECRET_ACCESS_KEY,
     enabledAccessCode: ACCESS_CODES?.length > 0,
 

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

@@ -20,6 +20,7 @@ import { generationTopicRouter } from './generationTopic';
 import { groupRouter } from './group';
 import { imageRouter } from './image';
 import { importerRouter } from './importer';
+import { klavisRouter } from './klavis';
 import { knowledgeBaseRouter } from './knowledgeBase';
 import { marketRouter } from './market';
 import { messageRouter } from './message';
@@ -52,6 +53,7 @@ export const lambdaRouter = router({
   healthcheck: publicProcedure.query(() => "i'm live!"),
   image: imageRouter,
   importer: importerRouter,
+  klavis: klavisRouter,
   knowledgeBase: knowledgeBaseRouter,
   market: marketRouter,
   message: messageRouter,

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

@@ -0,0 +1,249 @@
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
+import { z } from 'zod';
+
+import { PluginModel } from '@/database/models/plugin';
+import { getKlavisClient } from '@/libs/klavis';
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { serverDatabase } from '@/libs/trpc/lambda/middleware';
+
+/**
+ * Klavis procedure with API key validation and database access
+ */
+const klavisProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
+  const client = getKlavisClient();
+  const pluginModel = new PluginModel(opts.ctx.serverDB, opts.ctx.userId);
+
+  return opts.next({
+    ctx: { ...opts.ctx, klavisClient: client, pluginModel },
+  });
+});
+
+export const klavisRouter = router({
+  /**
+   * Create a single MCP server instance and save to database
+   * Returns: { serverUrl, instanceId, oauthUrl?, identifier, serverName }
+   */
+  createServerInstance: klavisProcedure
+    .input(
+      z.object({
+        /** Identifier for storage (e.g., 'google-calendar') */
+        identifier: z.string(),
+        /** Server name for Klavis API (e.g., 'Google Calendar') */
+        serverName: z.string(),
+        userId: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const { serverName, userId, identifier } = input;
+
+      // 创建单个服务器实例
+      const response = await ctx.klavisClient.mcpServer.createServerInstance({
+        serverName: serverName as any,
+        userId,
+      });
+
+      const { serverUrl, instanceId, oauthUrl } = response;
+
+      // 获取该服务器的工具列表
+      const toolsResponse = await ctx.klavisClient.mcpServer.getTools(serverName as any);
+      const tools = toolsResponse.tools || [];
+
+      // 保存到数据库，使用传入的 identifier（格式：小写，空格替换为连字符）
+      const manifest: LobeChatPluginManifest = {
+        api: tools.map((tool: any) => ({
+          description: tool.description || '',
+          name: tool.name,
+          parameters: tool.inputSchema || { properties: {}, type: 'object' },
+        })),
+        identifier,
+        meta: {
+          avatar: '🔌',
+          description: `Klavis MCP Server: ${serverName}`,
+          title: serverName,
+        },
+        type: 'default',
+      };
+
+      // 保存到数据库，包含 oauthUrl 和 isAuthenticated 状态
+      const isAuthenticated = !oauthUrl; // 如果没有 oauthUrl，说明不需要认证或已认证
+      await ctx.pluginModel.create({
+        customParams: {
+          klavis: {
+            instanceId,
+            isAuthenticated,
+            oauthUrl,
+            serverName,
+            serverUrl,
+          },
+        },
+        identifier,
+        manifest,
+        source: 'klavis',
+        type: 'plugin',
+      });
+
+      return {
+        identifier,
+        instanceId,
+        isAuthenticated,
+        oauthUrl,
+        serverName,
+        serverUrl,
+      };
+    }),
+
+  /**
+   * Delete a server instance
+   */
+  deleteServerInstance: klavisProcedure
+    .input(
+      z.object({
+        /** Identifier for storage (e.g., 'google-calendar') */
+        identifier: z.string(),
+        instanceId: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      // 调用 Klavis API 删除服务器实例
+      await ctx.klavisClient.mcpServer.deleteServerInstance(input.instanceId);
+
+      // 从数据库删除（使用 identifier）
+      await ctx.pluginModel.delete(input.identifier);
+
+      return { success: true };
+    }),
+
+  /**
+   * Get Klavis plugins from database
+   */
+  getKlavisPlugins: klavisProcedure.query(async ({ ctx }) => {
+    const allPlugins = await ctx.pluginModel.query();
+    // Filter plugins that have klavis customParams
+    return allPlugins.filter((plugin) => plugin.customParams?.klavis);
+  }),
+
+  /**
+   * Get server instance status from Klavis API
+   */
+  getServerInstance: klavisProcedure
+    .input(
+      z.object({
+        instanceId: z.string(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      const response = await ctx.klavisClient.mcpServer.getServerInstance(input.instanceId);
+      return {
+        authNeeded: response.authNeeded,
+        externalUserId: response.externalUserId,
+        instanceId: response.instanceId,
+        isAuthenticated: response.isAuthenticated,
+        oauthUrl: response.oauthUrl,
+        platform: response.platform,
+        serverName: response.serverName,
+      };
+    }),
+
+  getUserIntergrations: klavisProcedure
+    .input(
+      z.object({
+        userId: z.string(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      const response = await ctx.klavisClient.user.getUserIntegrations(input.userId);
+
+      return {
+        integrations: response.integrations,
+      };
+    }),
+
+  /**
+   * Remove Klavis plugin from database by identifier
+   */
+  removeKlavisPlugin: klavisProcedure
+    .input(
+      z.object({
+        /** Identifier for storage (e.g., 'google-calendar') */
+        identifier: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      await ctx.pluginModel.delete(input.identifier);
+      return { success: true };
+    }),
+
+  /**
+   * Update Klavis plugin with tools and auth status in database
+   */
+  updateKlavisPlugin: klavisProcedure
+    .input(
+      z.object({
+        /** Identifier for storage (e.g., 'google-calendar') */
+        identifier: z.string(),
+        instanceId: z.string(),
+        isAuthenticated: z.boolean(),
+        oauthUrl: z.string().optional(),
+        /** Server name for Klavis API (e.g., 'Google Calendar') */
+        serverName: z.string(),
+        serverUrl: z.string(),
+        tools: z.array(
+          z.object({
+            description: z.string().optional(),
+            inputSchema: z.any().optional(),
+            name: z.string(),
+          }),
+        ),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const { identifier, serverName, serverUrl, instanceId, tools, isAuthenticated, oauthUrl } =
+        input;
+
+      // 获取现有插件（使用 identifier）
+      const existingPlugin = await ctx.pluginModel.findById(identifier);
+
+      // 构建包含所有工具的 manifest
+      const manifest: LobeChatPluginManifest = {
+        api: tools.map((tool) => ({
+          description: tool.description || '',
+          name: tool.name,
+          parameters: tool.inputSchema || { properties: {}, type: 'object' },
+        })),
+        identifier,
+        meta: existingPlugin?.manifest?.meta || {
+          avatar: '🔌',
+          description: `Klavis MCP Server: ${serverName}`,
+          title: serverName,
+        },
+        type: 'default',
+      };
+
+      const customParams = {
+        klavis: {
+          instanceId,
+          isAuthenticated,
+          oauthUrl,
+          serverName,
+          serverUrl,
+        },
+      };
+
+      // 更新或创建插件
+      if (existingPlugin) {
+        await ctx.pluginModel.update(identifier, { customParams, manifest });
+      } else {
+        await ctx.pluginModel.create({
+          customParams,
+          identifier,
+          manifest,
+          source: 'klavis',
+          type: 'plugin',
+        });
+      }
+
+      return { savedCount: tools.length };
+    }),
+});
+
+export type KlavisRouter = typeof klavisRouter;

package/src/server/routers/tools/index.ts

@@ -1,10 +1,12 @@
 import { publicProcedure, router } from '@/libs/trpc/lambda';
 
+import { klavisRouter } from './klavis';
 import { mcpRouter } from './mcp';
 import { searchRouter } from './search';
 
 export const toolsRouter = router({
   healthcheck: publicProcedure.query(() => "i'm live!"),
+  klavis: klavisRouter,
   mcp: mcpRouter,
   search: searchRouter,
 });

package/src/server/routers/tools/klavis.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+
+import { getKlavisClient } from '@/libs/klavis';
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { MCPService } from '@/server/services/mcp';
+
+/**
+ * Klavis procedure with client initialized in context
+ */
+const klavisProcedure = authedProcedure.use(async (opts) => {
+  const klavisClient = getKlavisClient();
+
+  return opts.next({
+    ctx: { ...opts.ctx, klavisClient },
+  });
+});
+
+/**
+ * Klavis router for tools
+ * Contains callTool and listTools which call external Klavis API
+ */
+export const klavisRouter = router({
+  /**
+   * Call a tool on a Klavis Strata server
+   */
+  callTool: klavisProcedure
+    .input(
+      z.object({
+        serverUrl: z.string(),
+        toolArgs: z.record(z.unknown()).optional(),
+        toolName: z.string(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const response = await ctx.klavisClient.mcpServer.callTools({
+        serverUrl: input.serverUrl,
+        toolArgs: input.toolArgs,
+        toolName: input.toolName,
+      });
+
+      // Handle error case
+      if (!response.success || !response.result) {
+        return {
+          content: response.error || 'Unknown error',
+          state: {
+            content: [{ text: response.error || 'Unknown error', type: 'text' }],
+            isError: true,
+          },
+          success: false,
+        };
+      }
+
+      // Process the response using the common MCP tool call result processor
+      const processedResult = await MCPService.processToolCallResult({
+        content: (response.result.content || []) as any[],
+        isError: response.result.isError,
+      });
+
+      return processedResult;
+    }),
+
+  /**
+   * List tools available on a Klavis Strata server
+   */
+  listTools: klavisProcedure
+    .input(
+      z.object({
+        serverUrl: z.string(),
+      }),
+    )
+    .query(async ({ ctx, input }) => {
+      const response = await ctx.klavisClient.mcpServer.listTools({
+        serverUrl: input.serverUrl,
+      });
+
+      return {
+        tools: response.tools,
+      };
+    }),
+});

package/src/server/services/mcp/index.ts

@@ -21,12 +21,60 @@ import { mcpSystemDepsCheckService } from './deps';
 
 const log = debug('lobe-mcp:service');
 
+/**
+ * MCP Tool call raw result type
+ */
+export interface MCPToolCallRawResult {
+  content: any[];
+  isError?: boolean;
+}
+
+/**
+ * MCP Tool call processed result type
+ */
+export interface MCPToolCallProcessedResult {
+  content: string;
+  error?: Error;
+  state: {
+    content: any[];
+    isError?: boolean;
+  };
+  success: boolean;
+}
+
 // Removed MCPConnection interface as it's no longer needed
 
 export class MCPService {
   // Store instances of the custom MCPClient, keyed by serialized MCPClientParams
   private clients: Map<string, MCPClient> = new Map();
 
+  /**
+   * Process MCP tool call result with content blocks processing
+   * This is a common utility method that can be used by both internal MCP calls and external services (e.g., Klavis)
+   */
+  static async processToolCallResult(
+    result: MCPToolCallRawResult,
+    processContentBlocksFn?: ProcessContentBlocksFn,
+  ): Promise<MCPToolCallProcessedResult> {
+    // Process content blocks (upload images, etc.)
+
+    const newContent =
+      result.isError || !processContentBlocksFn
+        ? result.content
+        : await processContentBlocksFn(result.content);
+
+    // Convert content blocks to string
+    const content = contentBlocksToString(newContent);
+
+    const state = { ...result, content: newContent };
+
+    if (result.isError) {
+      return { content, state, success: true };
+    }
+
+    return { content, state, success: true };
+  }
+
   private sanitizeForLogging = <T extends Record<string, any>>(obj: T): Omit<T, 'env'> => {
     if (!obj) return obj;
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -162,7 +210,12 @@ export class MCPService {
     processContentBlocks?: ProcessContentBlocksFn;
     toolName: string;
   }): Promise<any> {
-    const { clientParams, toolName, argsStr, processContentBlocks } = options;
+    const {
+      clientParams,
+      toolName,
+      argsStr,
+      processContentBlocks: processContentBlocksFn,
+    } = options;
 
     const client = await this.getClient(clientParams); // Get client using params
 
@@ -179,26 +232,19 @@ export class MCPService {
       // Delegate the call to the MCPClient instance
       const result = await client.callTool(toolName, args); // Pass args directly
 
-      // Process content blocks (upload images, etc.)
-      const newContent =
-        result.isError || !processContentBlocks
-          ? result.content
-          : await processContentBlocks(result.content);
-
-      // Convert content blocks to string
-      const content = contentBlocksToString(newContent);
-
-      const state = { ...result, content: newContent };
+      // Use the common processing method
+      const processedResult = await MCPService.processToolCallResult(
+        result,
+        processContentBlocksFn,
+      );
 
       log(
         `Tool "${toolName}" called successfully for params: %O, result: %O`,
         loggableParams,
-        state,
+        processedResult.state,
       );
 
-      if (result.isError) return { content, state, success: true };
-
-      return { content, state, success: true };
+      return processedResult;
     } catch (error) {
       if (error instanceof McpError) {
         const mcpError = error as McpError;