@lobehub/lobehub 2.0.0-next.117 → 2.0.0-next.119

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.117",
+  "version": "2.0.0-next.119",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/fetch-sse/src/__tests__/headers.test.ts

@@ -0,0 +1,367 @@
+import { describe, expect, it } from 'vitest';
+
+import { headersToRecord } from '../headers';
+
+describe('headersToRecord', () => {
+  describe('undefined or null input', () => {
+    it('should return empty object when headersInit is undefined', () => {
+      // Arrange & Act
+      const result = headersToRecord(undefined);
+
+      // Assert
+      expect(result).toEqual({});
+    });
+
+    it('should return empty object when headersInit is not provided', () => {
+      // Arrange & Act
+      const result = headersToRecord();
+
+      // Assert
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('Headers instance', () => {
+    it('should convert Headers instance to record', () => {
+      // Arrange
+      const headers = new Headers();
+      headers.append('content-type', 'application/json');
+      headers.append('authorization', 'Bearer token123');
+      headers.append('x-custom-header', 'custom-value');
+
+      // Act
+      const result = headersToRecord(headers);
+
+      // Assert
+      expect(result).toEqual({
+        'content-type': 'application/json',
+        'authorization': 'Bearer token123',
+        'x-custom-header': 'custom-value',
+      });
+    });
+
+    it('should handle Headers instance with multiple values for same key', () => {
+      // Arrange
+      const headers = new Headers();
+      headers.append('accept', 'application/json');
+      headers.append('accept', 'text/html');
+
+      // Act
+      const result = headersToRecord(headers);
+
+      // Assert
+      expect(result).toHaveProperty('accept');
+      expect(typeof result.accept).toBe('string');
+    });
+
+    it('should handle empty Headers instance', () => {
+      // Arrange
+      const headers = new Headers();
+
+      // Act
+      const result = headersToRecord(headers);
+
+      // Assert
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('Array format', () => {
+    it('should convert array of tuples to record', () => {
+      // Arrange
+      const headersArray: [string, string][] = [
+        ['content-type', 'application/json'],
+        ['authorization', 'Bearer token123'],
+        ['x-api-key', 'api-key-value'],
+      ];
+
+      // Act
+      const result = headersToRecord(headersArray);
+
+      // Assert
+      expect(result).toEqual({
+        'content-type': 'application/json',
+        'authorization': 'Bearer token123',
+        'x-api-key': 'api-key-value',
+      });
+    });
+
+    it('should handle empty array', () => {
+      // Arrange
+      const headersArray: [string, string][] = [];
+
+      // Act
+      const result = headersToRecord(headersArray);
+
+      // Assert
+      expect(result).toEqual({});
+    });
+
+    it('should handle array with single header', () => {
+      // Arrange
+      const headersArray: [string, string][] = [['x-single-header', 'single-value']];
+
+      // Act
+      const result = headersToRecord(headersArray);
+
+      // Assert
+      expect(result).toEqual({
+        'x-single-header': 'single-value',
+      });
+    });
+  });
+
+  describe('Plain object', () => {
+    it('should convert plain object to record', () => {
+      // Arrange
+      const headersObj = {
+        'content-type': 'application/json',
+        'authorization': 'Bearer token123',
+        'x-custom': 'value',
+      };
+
+      // Act
+      const result = headersToRecord(headersObj);
+
+      // Assert
+      expect(result).toEqual({
+        'content-type': 'application/json',
+        'authorization': 'Bearer token123',
+        'x-custom': 'value',
+      });
+    });
+
+    it('should handle empty object', () => {
+      // Arrange
+      const headersObj = {};
+
+      // Act
+      const result = headersToRecord(headersObj);
+
+      // Assert
+      expect(result).toEqual({});
+    });
+
+    it('should handle object with special characters in values', () => {
+      // Arrange
+      const headersObj = {
+        'authorization': 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
+        'x-special': 'value with spaces and symbols: !@#$%',
+      };
+
+      // Act
+      const result = headersToRecord(headersObj);
+
+      // Assert
+      expect(result).toEqual({
+        'authorization': 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
+        'x-special': 'value with spaces and symbols: !@#$%',
+      });
+    });
+  });
+
+  describe('Restricted headers filtering', () => {
+    it('should remove "host" header from Headers instance', () => {
+      // Arrange
+      const headers = new Headers();
+      headers.append('host', 'example.com');
+      headers.append('content-type', 'application/json');
+
+      // Act
+      const result = headersToRecord(headers);
+
+      // Assert
+      expect(result).not.toHaveProperty('host');
+      expect(result).toEqual({
+        'content-type': 'application/json',
+      });
+    });
+
+    it('should remove "connection" header from array', () => {
+      // Arrange
+      const headersArray: [string, string][] = [
+        ['connection', 'keep-alive'],
+        ['authorization', 'Bearer token'],
+      ];
+
+      // Act
+      const result = headersToRecord(headersArray);
+
+      // Assert
+      expect(result).not.toHaveProperty('connection');
+      expect(result).toEqual({
+        authorization: 'Bearer token',
+      });
+    });
+
+    it('should remove "content-length" header from plain object', () => {
+      // Arrange
+      const headersObj = {
+        'content-length': '1234',
+        'content-type': 'application/json',
+      };
+
+      // Act
+      const result = headersToRecord(headersObj);
+
+      // Assert
+      expect(result).not.toHaveProperty('content-length');
+      expect(result).toEqual({
+        'content-type': 'application/json',
+      });
+    });
+
+    it('should remove all restricted headers (host, connection, content-length)', () => {
+      // Arrange
+      const headersObj = {
+        'host': 'example.com',
+        'connection': 'keep-alive',
+        'content-length': '1234',
+        'authorization': 'Bearer token',
+        'content-type': 'application/json',
+      };
+
+      // Act
+      const result = headersToRecord(headersObj);
+
+      // Assert
+      expect(result).not.toHaveProperty('host');
+      expect(result).not.toHaveProperty('connection');
+      expect(result).not.toHaveProperty('content-length');
+      expect(result).toEqual({
+        'authorization': 'Bearer token',
+        'content-type': 'application/json',
+      });
+    });
+
+    it('should handle case when only restricted headers are present', () => {
+      // Arrange
+      const headersObj = {
+        'host': 'example.com',
+        'connection': 'keep-alive',
+        'content-length': '1234',
+      };
+
+      // Act
+      const result = headersToRecord(headersObj);
+
+      // Assert
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle headers with empty string values', () => {
+      // Arrange
+      const headersObj = {
+        'x-empty': '',
+        'x-normal': 'value',
+      };
+
+      // Act
+      const result = headersToRecord(headersObj);
+
+      // Assert
+      expect(result).toEqual({
+        'x-empty': '',
+        'x-normal': 'value',
+      });
+    });
+
+    it('should handle headers with numeric-like values as strings', () => {
+      // Arrange
+      const headersArray: [string, string][] = [
+        ['x-request-id', '12345'],
+        ['x-retry-count', '3'],
+      ];
+
+      // Act
+      const result = headersToRecord(headersArray);
+
+      // Assert
+      expect(result).toEqual({
+        'x-request-id': '12345',
+        'x-retry-count': '3',
+      });
+    });
+
+    it('should handle case-sensitive header names', () => {
+      // Arrange
+      const headersObj = {
+        'Content-Type': 'application/json',
+        'Authorization': 'Bearer token',
+      };
+
+      // Act
+      const result = headersToRecord(headersObj);
+
+      // Assert
+      expect(result).toEqual({
+        'Content-Type': 'application/json',
+        'Authorization': 'Bearer token',
+      });
+    });
+
+    it('should preserve header order from array input', () => {
+      // Arrange
+      const headersArray: [string, string][] = [
+        ['z-last', 'last'],
+        ['a-first', 'first'],
+        ['m-middle', 'middle'],
+      ];
+
+      // Act
+      const result = headersToRecord(headersArray);
+
+      // Assert
+      expect(Object.keys(result)).toEqual(['z-last', 'a-first', 'm-middle']);
+    });
+  });
+
+  describe('Real-world scenarios', () => {
+    it('should handle typical SSE request headers', () => {
+      // Arrange
+      const headers = new Headers();
+      headers.append('accept', 'text/event-stream');
+      headers.append('content-type', 'application/json');
+      headers.append('authorization', 'Bearer abc123');
+      headers.append('cache-control', 'no-cache');
+      headers.append('connection', 'keep-alive'); // Should be filtered
+
+      // Act
+      const result = headersToRecord(headers);
+
+      // Assert
+      expect(result).toEqual({
+        'accept': 'text/event-stream',
+        'content-type': 'application/json',
+        'authorization': 'Bearer abc123',
+        'cache-control': 'no-cache',
+      });
+      expect(result).not.toHaveProperty('connection');
+    });
+
+    it('should handle API request headers with custom fields', () => {
+      // Arrange
+      const headersObj = {
+        'content-type': 'application/json',
+        'x-api-key': 'secret-key',
+        'x-request-id': 'req-123',
+        'user-agent': 'MyApp/1.0',
+        'host': 'api.example.com', // Should be filtered
+        'content-length': '256', // Should be filtered
+      };
+
+      // Act
+      const result = headersToRecord(headersObj);
+
+      // Assert
+      expect(result).toEqual({
+        'content-type': 'application/json',
+        'x-api-key': 'secret-key',
+        'x-request-id': 'req-123',
+        'user-agent': 'MyApp/1.0',
+      });
+    });
+  });
+});

package/src/app/[variants]/(main)/discover/(detail)/assistant/features/Details/Capabilities/Plugins.tsx

@@ -1,6 +1,6 @@
 import { Block } from '@lobehub/ui';
 import { Empty } from 'antd';
-import Link from 'next/link';
+import { Link } from 'react-router-dom';
 import { memo } from 'react';
 import { Flexbox } from 'react-layout-kit';
 import urlJoin from 'url-join';
@@ -20,11 +20,16 @@ const Plugin = memo(() => {
 
   return (
     <Flexbox gap={8}>
-      {config?.plugins.map((item) => (
-        <Link href={urlJoin('/discover/plugin', item)} key={item}>
-          <PluginItem identifier={item} />
-        </Link>
-      ))}
+      {config?.plugins.map((item) => {
+        const identifier =
+          typeof item === 'string' ? item : (item as { identifier: string }).identifier;
+
+        return (
+          <Link key={identifier} to={urlJoin('/discover/plugin', identifier)}>
+            <PluginItem identifier={identifier} />
+          </Link>
+        );
+      })}
     </Flexbox>
   );
 });

package/src/libs/mcp/__tests__/__snapshots__/index.test.ts.snap

@@ -5,6 +5,8 @@ exports[`MCPClient > Stdio Transport > should list tools via stdio 1`] = `
   {
     "description": "Echoes back a message with 'Hello' prefix",
     "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "additionalProperties": false,
       "properties": {
         "message": {
           "description": "The message to echo",
@@ -21,6 +23,7 @@ exports[`MCPClient > Stdio Transport > should list tools via stdio 1`] = `
   {
     "description": "Lists all available tools and methods",
     "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
       "properties": {},
       "type": "object",
     },
@@ -29,6 +32,8 @@ exports[`MCPClient > Stdio Transport > should list tools via stdio 1`] = `
   {
     "description": "Adds two numbers",
     "inputSchema": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "additionalProperties": false,
       "properties": {
         "a": {
           "description": "The first number",

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

@@ -886,8 +886,48 @@ export class DiscoverService {
     const all = await this._getPluginList(locale);
     let raw = all.find((item) => item.identifier === identifier);
     if (!raw) {
-      log('getPluginDetail: plugin not found for identifier=%s', identifier);
-      return;
+      log('getPluginDetail: plugin not found in default store for identifier=%s, trying MCP plugin', identifier);
+      try {
+        const mcpDetail = await this.getMcpDetail({ identifier, locale });
+        const convertedMcp: Partial<DiscoverPluginDetail> = {
+          author:
+            typeof (mcpDetail as any).author === 'object'
+              ? (mcpDetail as any).author?.name || ''
+              : (mcpDetail as any).author || '',
+          avatar: (mcpDetail as any).icon || (mcpDetail as any).avatar || '',
+          category: (mcpDetail as any).category as any,
+          createdAt: (mcpDetail as any).createdAt || '',
+          description: mcpDetail.description || '',
+          homepage: mcpDetail.homepage || '',
+          identifier: mcpDetail.identifier,
+          manifest: undefined,
+          related: mcpDetail.related.map((item) => ({
+            author:
+              typeof (item as any).author === 'object'
+                ? (item as any).author?.name || ''
+                : (item as any).author || '',
+            avatar: (item as any).icon || (item as any).avatar || '',
+            category: (item as any).category as any,
+            createdAt: (item as any).createdAt || '',
+            description: (item as any).description || '',
+            homepage: (item as any).homepage || '',
+            identifier: item.identifier,
+            manifest: undefined,
+            schemaVersion: 1,
+            tags: (item as any).tags || [],
+            title: (item as any).name || item.identifier,
+          })) as unknown as DiscoverPluginItem[],
+          schemaVersion: 1,
+          tags: (mcpDetail as any).tags || [],
+          title: (mcpDetail as any).name || mcpDetail.identifier,
+        };
+        const plugin = merge(cloneDeep(DEFAULT_DISCOVER_PLUGIN_ITEM), convertedMcp);
+        log('getPluginDetail: returning converted MCP plugin');
+        return plugin as DiscoverPluginDetail;
+      } catch (error) {
+        log('getPluginDetail: MCP plugin not found for identifier=%s, error=%O', identifier, error);
+        return;
+      }
     }
 
     raw = merge(cloneDeep(DEFAULT_DISCOVER_PLUGIN_ITEM), raw);

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

@@ -13,9 +13,9 @@ const log = debug('lobe-mcp:content-processor');
 export type ProcessContentBlocksFn = (blocks: ToolCallContent[]) => Promise<ToolCallContent[]>;
 
 /**
- * 处理 MCP 返回的 content blocks
- * - 上传图片/音频到存储并替换 data 为代理 URL
- * - 保持其他类型的 block 不变
+ * Process content blocks returned by MCP
+ * - Upload images/audio to storage and replace data with proxy URL
+ * - Keep other types of blocks unchanged
  */
 export const processContentBlocks = async (
   blocks: ToolCallContent[],
@@ -64,10 +64,10 @@ export const processContentBlocks = async (
 };
 
 /**
- * 将 content blocks 转换为字符串
- * - text: 提取 text 字段
- * - image/audio: 提取 data 字段（通常是上传后的代理 URL）
- * - 其他: 返回空字符串
+ * Convert content blocks to string
+ * - text: Extract text field
+ * - image/audio: Extract data field (usually the proxy URL after upload)
+ * - others: Return empty string
  */
 export const contentBlocksToString = (blocks: ToolCallContent[] | null | undefined): string => {
   if (!blocks) return '';

package/src/server/services/mcp/deps/MCPSystemDepsCheckService.ts

@@ -195,13 +195,13 @@ class MCPSystemDepsCheckService {
     // Check if all system dependencies meet requirements
     const allDependenciesMet = systemDependenciesResults.every((dep) => dep.meetRequirement);
 
-    // Check if configuration is required (有必填项)
+    // Check if configuration is required (has mandatory fields)
     const configSchema = option.connection?.configSchema;
     const needsConfig = Boolean(
       configSchema &&
-        // 检查是否有 required 数组且不为空
+        // Check if there's a non-empty required array
         ((Array.isArray(configSchema.required) && configSchema.required.length > 0) ||
-          // 检查 properties 中是否有字段标记为 required
+          // Check if any field in properties is marked as required
           (configSchema.properties &&
             Object.values(configSchema.properties).some((prop: any) => prop.required === true))),
     );

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

@@ -250,7 +250,7 @@ export class MCPService {
     } catch (error) {
       console.error(`Failed to initialize MCP client:`, error);
 
-      // 保留完整的错误信息，特别是详细的 stderr 输出
+      // Preserve complete error information, especially detailed stderr output
       const errorMessage = error instanceof Error ? error.message : String(error);
 
       if (typeof error === 'object' && !!error && 'data' in error) {
@@ -261,7 +261,7 @@ export class MCPService {
         });
       }
 
-      // 记录详细的错误信息用于调试
+      // Log detailed error information for debugging
       log('Detailed initialization error: %O', {
         error: errorMessage,
         params: this.sanitizeForLogging(params),
@@ -271,7 +271,7 @@ export class MCPService {
       throw new TRPCError({
         cause: error,
         code: 'INTERNAL_SERVER_ERROR',
-        message: errorMessage, // 直接使用完整的错误信息
+        message: errorMessage, // Use complete error message directly
       });
     }
   }
@@ -307,12 +307,12 @@ export class MCPService {
   ): Promise<LobeChatPluginManifest> {
     const mcpParams = { name: identifier, type: 'http' as const, url };
 
-    // 如果有认证信息，添加到参数中
+    // Add authentication info to parameters if available
     if (auth) {
       (mcpParams as any).auth = auth;
     }
 
-    // 如果有 headers 信息，添加到参数中
+    // Add headers info to parameters if available
     if (headers) {
       (mcpParams as any).headers = headers;
     }
@@ -383,23 +383,23 @@ export class MCPService {
       log('Checking MCP plugin installation status: %O', loggableInput);
       const results = [];
 
-      // 检查每个部署选项
+      // Check each deployment option
       for (const option of input.deploymentOptions) {
-        // 使用系统依赖检查服务检查部署选项
+        // Use system dependency check service to check deployment option
         const result = await mcpSystemDepsCheckService.checkDeployOption(option);
         results.push(result);
       }
 
-      // 找出推荐的或第一个可安装的选项
+      // Find the recommended or first installable option
       const recommendedResult = results.find((r) => r.isRecommended && r.allDependenciesMet);
       const firstInstallableResult = results.find((r) => r.allDependenciesMet);
 
-      // 返回推荐的结果，或第一个可安装的结果，或第一个结果
+      // Return the recommended result, or the first installable result, or the first result
       const bestResult = recommendedResult || firstInstallableResult || results[0];
 
       log('Check completed, best result: %O', bestResult);
 
-      // 构造返回结果，确保包含配置检查信息
+      // Construct return result, ensure configuration check information is included
       const checkResult: CheckMcpInstallResult = {
         ...bestResult,
         allOptions: results,
@@ -407,7 +407,7 @@ export class MCPService {
         success: true,
       };
 
-      // 如果最佳结果需要配置，确保在顶层设置相关字段
+      // If the best result requires configuration, ensure related fields are set at the top level
       if (bestResult?.needsConfig) {
         checkResult.needsConfig = true;
         checkResult.configSchema = bestResult.configSchema;