@lobehub/lobehub 2.0.0-next.233 → 2.0.0-next.235

package/src/store/chat/slices/plugin/actions/internals.ts

@@ -6,7 +6,11 @@ import { type StateCreator } from 'zustand/vanilla';
 
 import { type ChatStore } from '@/store/chat/store';
 import { useToolStore } from '@/store/tool';
-import { klavisStoreSelectors, pluginSelectors } from '@/store/tool/selectors';
+import {
+  klavisStoreSelectors,
+  lobehubSkillStoreSelectors,
+  pluginSelectors,
+} from '@/store/tool/selectors';
 import { builtinTools } from '@/tools';
 
 /**
@@ -34,7 +38,7 @@ export const pluginInternals: StateCreator<
     const manifests: Record<string, LobeChatPluginManifest> = {};
 
     // Track source for each identifier
-    const sourceMap: Record<string, 'builtin' | 'plugin' | 'mcp' | 'klavis'> = {};
+    const sourceMap: Record<string, 'builtin' | 'plugin' | 'mcp' | 'klavis' | 'lobehubSkill'> = {};
 
     // Get all installed plugins
     const installedPlugins = pluginSelectors.installedPlugins(toolStoreState);
@@ -63,6 +67,15 @@ export const pluginInternals: StateCreator<
       }
     }
 
+    // Get all LobeHub Skill tools
+    const lobehubSkillTools = lobehubSkillStoreSelectors.lobehubSkillAsLobeTools(toolStoreState);
+    for (const tool of lobehubSkillTools) {
+      if (tool.manifest) {
+        manifests[tool.identifier] = tool.manifest as LobeChatPluginManifest;
+        sourceMap[tool.identifier] = 'lobehubSkill';
+      }
+    }
+
     // Resolve tool calls and add source field
     const resolved = toolNameResolver.resolve(toolCalls, manifests);
     return resolved.map((payload) => ({

package/src/store/chat/slices/plugin/actions/pluginTypes.ts

@@ -60,6 +60,14 @@ export interface PluginTypesAction {
    */
   invokeKlavisTypePlugin: (id: string, payload: ChatToolPayload) => Promise<string | undefined>;
 
+  /**
+   * Invoke LobeHub Skill type plugin
+   */
+  invokeLobehubSkillTypePlugin: (
+    id: string,
+    payload: ChatToolPayload,
+  ) => Promise<string | undefined>;
+
   /**
    * Invoke markdown type plugin
    */
@@ -93,6 +101,11 @@ export const pluginTypes: StateCreator<
       return await get().invokeKlavisTypePlugin(id, payload);
     }
 
+    // Check if this is a LobeHub Skill tool by source field
+    if (payload.source === 'lobehubSkill') {
+      return await get().invokeLobehubSkillTypePlugin(id, payload);
+    }
+
     // Check if this is Cloud Code Interpreter - route to specific handler
     if (payload.identifier === CloudSandboxIdentifier) {
       return await get().invokeCloudCodeInterpreterTool(id, payload);
@@ -439,6 +452,97 @@ export const pluginTypes: StateCreator<
     return data.content;
   },
 
+  invokeLobehubSkillTypePlugin: async (id, payload) => {
+    let data: MCPToolCallResult | undefined;
+
+    // Get message to extract sessionId/topicId
+    const message = dbMessageSelectors.getDbMessageById(id)(get());
+
+    // Get abort controller from operation
+    const operationId = get().messageOperationMap[id];
+    const operation = operationId ? get().operations[operationId] : undefined;
+    const abortController = operation?.abortController;
+
+    log(
+      '[invokeLobehubSkillTypePlugin] messageId=%s, tool=%s, operationId=%s, aborted=%s',
+      id,
+      payload.apiName,
+      operationId,
+      abortController?.signal.aborted,
+    );
+
+    try {
+      // payload.identifier is the provider id (e.g., 'linear', 'microsoft')
+      const provider = payload.identifier;
+
+      // Parse arguments
+      const args = safeParseJSON(payload.arguments) || {};
+
+      // Call LobeHub Skill tool via store action
+      const result = await useToolStore.getState().callLobehubSkillTool({
+        args,
+        provider,
+        toolName: payload.apiName,
+      });
+
+      if (!result.success) {
+        throw new Error(result.error || 'LobeHub Skill tool execution failed');
+      }
+
+      // Convert to MCPToolCallResult format
+      const content = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
+      data = {
+        content,
+        error: undefined,
+        state: { content: [{ text: content, type: 'text' }] },
+        success: true,
+      };
+    } catch (error) {
+      console.error('[invokeLobehubSkillTypePlugin] Error:', error);
+
+      // ignore the aborted request error
+      const err = error as Error;
+      if (err.message.includes('aborted')) {
+        log(
+          '[invokeLobehubSkillTypePlugin] Request aborted: messageId=%s, tool=%s',
+          id,
+          payload.apiName,
+        );
+      } else {
+        const result = await messageService.updateMessageError(id, error as any, {
+          agentId: message?.agentId,
+          topicId: message?.topicId,
+        });
+        if (result?.success && result.messages) {
+          get().replaceMessages(result.messages, {
+            context: {
+              agentId: message?.agentId,
+              topicId: message?.topicId,
+            },
+          });
+        }
+      }
+    }
+
+    // If error occurred, exit
+    if (!data) return;
+
+    const context = operationId ? { operationId } : undefined;
+
+    // Use optimisticUpdateToolMessage to update content and state/error in a single call
+    await get().optimisticUpdateToolMessage(
+      id,
+      {
+        content: data.content,
+        pluginError: data.success ? undefined : data.error,
+        pluginState: data.success ? data.state : undefined,
+      },
+      context,
+    );
+
+    return data.content;
+  },
+
   invokeMarkdownTypePlugin: async (id, payload) => {
     const { internal_callPluginApi } = get();
 

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

@@ -278,11 +278,14 @@ describe('FileManagerActions', () => {
       // Should only dispatch for the valid file
       expect(dispatchSpy).toHaveBeenCalledWith({
         atStart: true,
-        files: [{ file: validFile, id: validFile.name, status: 'pending' }],
+        files: [
+          expect.objectContaining({ file: validFile, id: validFile.name, status: 'pending' }),
+        ],
         type: 'addFiles',
       });
       expect(uploadSpy).toHaveBeenCalledTimes(1);
       expect(uploadSpy).toHaveBeenCalledWith({
+        abortController: expect.any(AbortController),
         file: validFile,
         knowledgeBaseId: undefined,
         onStatusUpdate: expect.any(Function),
@@ -308,6 +311,7 @@ describe('FileManagerActions', () => {
       });
 
       expect(uploadSpy).toHaveBeenCalledWith({
+        abortController: expect.any(AbortController),
         file,
         knowledgeBaseId: 'kb-123',
         onStatusUpdate: expect.any(Function),
@@ -502,7 +506,9 @@ describe('FileManagerActions', () => {
       // Should upload extracted files
       expect(dispatchSpy).toHaveBeenCalledWith({
         atStart: true,
-        files: extractedFiles.map((file) => ({ file, id: file.name, status: 'pending' })),
+        files: extractedFiles.map((file) =>
+          expect.objectContaining({ file, id: file.name, status: 'pending' }),
+        ),
         type: 'addFiles',
       });
     });
@@ -532,7 +538,7 @@ describe('FileManagerActions', () => {
       // Should fallback to uploading the ZIP file itself
       expect(dispatchSpy).toHaveBeenCalledWith({
         atStart: true,
-        files: [{ file: zipFile, id: zipFile.name, status: 'pending' }],
+        files: [expect.objectContaining({ file: zipFile, id: zipFile.name, status: 'pending' })],
         type: 'addFiles',
       });
     });

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

@@ -1,10 +1,18 @@
-import { buildFolderTree, sanitizeFolderName, topologicalSortFolders } from '@lobechat/utils';
+import {
+  buildFolderTree,
+  createNanoId,
+  sanitizeFolderName,
+  topologicalSortFolders,
+} from '@lobechat/utils';
+import { t } from 'i18next';
 import pMap from 'p-map';
 import type { SWRResponse } from 'swr';
 import { type StateCreator } from 'zustand/vanilla';
 
+import { message } from '@/components/AntdStaticMethods';
 import { FILE_UPLOAD_BLACKLIST, MAX_UPLOAD_FILE_COUNT } from '@/const/file';
 import { mutate, useClientDataSWR } from '@/libs/swr';
+import { documentService } from '@/services/document';
 import { FileService, fileService } from '@/services/file';
 import { ragService } from '@/services/rag';
 import {
@@ -27,6 +35,7 @@ export interface FolderCrumb {
 }
 
 export interface FileManageAction {
+  cancelUpload: (id: string) => void;
   dispatchDockFileList: (payload: UploadFileListDispatch) => void;
   embeddingChunks: (fileIds: string[]) => Promise<void>;
   loadMoreKnowledgeItems: () => Promise<void>;
@@ -67,6 +76,21 @@ export const createFileManageSlice: StateCreator<
   [],
   FileManageAction
 > = (set, get) => ({
+  cancelUpload: (id) => {
+    const { dockUploadFileList, dispatchDockFileList } = get();
+    const uploadItem = dockUploadFileList.find((item) => item.id === id);
+
+    if (uploadItem?.abortController) {
+      uploadItem.abortController.abort();
+    }
+
+    // Update status to cancelled
+    dispatchDockFileList({
+      id,
+      status: 'cancelled',
+      type: 'updateFileStatus',
+    });
+  },
   dispatchDockFileList: (payload: UploadFileListDispatch) => {
     const nextValue = uploadFileListReducer(get().dockUploadFileList, payload);
     if (nextValue === get().dockUploadFileList) return;
@@ -186,19 +210,31 @@ export const createFileManageSlice: StateCreator<
     // 1. skip file in blacklist
     const files = filesToUpload.filter((file) => !FILE_UPLOAD_BLACKLIST.includes(file.name));
 
-    // 2. Add all files to dock
+    // 2. Create upload items with abort controllers
+    const uploadFiles = files.map((file) => {
+      const abortController = new AbortController();
+      return {
+        abortController,
+        file,
+        id: file.name,
+        status: 'pending' as const,
+      };
+    });
+
+    // 3. Add all files to dock
     dispatchDockFileList({
       atStart: true,
-      files: files.map((file) => ({ file, id: file.name, status: 'pending' })),
+      files: uploadFiles,
       type: 'addFiles',
     });
 
-    // 3. Upload files with concurrency limit using p-map
+    // 4. Upload files with concurrency limit using p-map
     const uploadResults = await pMap(
-      files,
-      async (file) => {
+      uploadFiles,
+      async (uploadFileItem) => {
         const result = await get().uploadWithProgress({
-          file,
+          abortController: uploadFileItem.abortController,
+          file: uploadFileItem.file,
           knowledgeBaseId,
           onStatusUpdate: dispatchDockFileList,
           parentId,
@@ -207,7 +243,11 @@ export const createFileManageSlice: StateCreator<
         // Note: Don't refresh after each file to avoid flickering
         // We'll refresh once at the end
 
-        return { file, fileId: result?.id, fileType: file.type };
+        return {
+          file: uploadFileItem.file,
+          fileId: result?.id,
+          fileType: uploadFileItem.file.type,
+        };
       },
       { concurrency: MAX_UPLOAD_FILE_COUNT },
     );
@@ -215,7 +255,7 @@ export const createFileManageSlice: StateCreator<
     // Refresh the file list once after all uploads are complete
     await get().refreshFileList();
 
-    // 4. auto-embed files that support chunking
+    // 5. auto-embed files that support chunking
     const fileIdsToEmbed = uploadResults
       .filter(({ fileType, fileId }) => fileId && !isChunkingUnsupported(fileType))
       .map(({ fileId }) => fileId!);
@@ -353,82 +393,137 @@ export const createFileManageSlice: StateCreator<
     // 2. Sort folders by depth to ensure parents are created before children
     const sortedFolderPaths = topologicalSortFolders(folders);
 
-    // Map to store created folder IDs: relative path -> folder ID
-    const folderIdMap = new Map<string, string>();
-
-    // 3. Create all folders sequentially (maintaining hierarchy)
-    for (const folderPath of sortedFolderPaths) {
-      const folder = folders[folderPath];
+    // Show toast notification if there are folders to create
+    const messageKey = 'uploadFolder.creatingFolders';
+    if (sortedFolderPaths.length > 0) {
+      message.loading({
+        content: t('header.actions.uploadFolder.creatingFolders', { ns: 'file' }),
+        duration: 0, // Don't auto-dismiss
+        key: messageKey,
+      });
+    }
 
-      // Determine parent ID: either from previously created folder or current folder
-      const parentId = folder.parent ? folderIdMap.get(folder.parent) : currentFolderId;
+    try {
+      // Map to store created folder IDs: relative path -> folder ID
+      const folderIdMap = new Map<string, string>();
+
+      // 3. Group folders by depth level for batch creation
+      const foldersByLevel = new Map<number, string[]>();
+      for (const folderPath of sortedFolderPaths) {
+        const depth = (folderPath.match(/\//g) || []).length;
+        if (!foldersByLevel.has(depth)) {
+          foldersByLevel.set(depth, []);
+        }
+        foldersByLevel.get(depth)!.push(folderPath);
+      }
 
-      // Sanitize folder name to remove invalid characters
-      const sanitizedName = sanitizeFolderName(folder.name);
+      // 4. Create folders level by level using batch API
+      const generateSlug = createNanoId(8);
+      const levels = Array.from(foldersByLevel.keys()).sort((a, b) => a - b);
+      for (const level of levels) {
+        const foldersAtThisLevel = foldersByLevel.get(level)!;
+
+        // Prepare batch creation data for this level
+        const batchCreateData = foldersAtThisLevel.map((folderPath) => {
+          const folder = folders[folderPath];
+          const parentId = folder.parent ? folderIdMap.get(folder.parent) : currentFolderId;
+          const sanitizedName = sanitizeFolderName(folder.name);
+
+          // Generate unique slug for the folder
+          const slug = generateSlug();
+
+          return {
+            content: '',
+            editorData: '{}',
+            fileType: 'custom/folder',
+            knowledgeBaseId,
+            metadata: { createdAt: Date.now() },
+            parentId,
+            slug,
+            title: sanitizedName,
+          };
+        });
 
-      // Create folder
-      const folderId = await get().createFolder(sanitizedName, parentId, knowledgeBaseId);
+        // Create all folders at this level in a single batch request
+        const createdFolders = await documentService.createDocuments(batchCreateData);
 
-      // Store mapping for child folders
-      folderIdMap.set(folderPath, folderId);
-    }
+        // Store folder ID mappings for the next level
+        for (const [i, element] of foldersAtThisLevel.entries()) {
+          folderIdMap.set(element, createdFolders[i].id);
+        }
+      }
 
-    // 4. Prepare all file uploads with their target folder IDs
-    const allUploads: Array<{ file: File; parentId: string | undefined }> = [];
+      // Dismiss the toast after folders are created
+      if (sortedFolderPaths.length > 0) {
+        message.destroy(messageKey);
+      }
 
-    for (const [folderPath, folderFiles] of Object.entries(filesByFolder)) {
-      // Root-level files (no folder path) go to currentFolderId
-      const targetFolderId = folderPath ? folderIdMap.get(folderPath) : currentFolderId;
+      // Refresh file list to show the new folders
+      await get().refreshFileList();
 
-      allUploads.push(
-        ...folderFiles.map((file) => ({
-          file,
-          parentId: targetFolderId,
-        })),
-      );
-    }
+      // 5. Prepare all file uploads with their target folder IDs
+      const allUploads: Array<{ file: File; parentId: string | undefined }> = [];
 
-    // 5. Filter out blacklisted files
-    const validUploads = allUploads.filter(
-      ({ file }) => !FILE_UPLOAD_BLACKLIST.includes(file.name),
-    );
+      for (const [folderPath, folderFiles] of Object.entries(filesByFolder)) {
+        // Root-level files (no folder path) go to currentFolderId
+        const targetFolderId = folderPath ? folderIdMap.get(folderPath) : currentFolderId;
 
-    // 6. Add all files to dock
-    dispatchDockFileList({
-      atStart: true,
-      files: validUploads.map(({ file }) => ({ file, id: file.name, status: 'pending' })),
-      type: 'addFiles',
-    });
+        allUploads.push(
+          ...folderFiles.map((file) => ({
+            file,
+            parentId: targetFolderId,
+          })),
+        );
+      }
 
-    // 7. Upload files with concurrency limit
-    const uploadResults = await pMap(
-      validUploads,
-      async ({ file, parentId }) => {
-        const result = await get().uploadWithProgress({
-          file,
-          knowledgeBaseId,
-          onStatusUpdate: dispatchDockFileList,
-          parentId,
-        });
+      // 6. Filter out blacklisted files
+      const validUploads = allUploads.filter(
+        ({ file }) => !FILE_UPLOAD_BLACKLIST.includes(file.name),
+      );
 
-        // Note: Don't refresh after each file to avoid flickering
-        // We'll refresh once at the end
+      // 7. Add all files to dock
+      dispatchDockFileList({
+        atStart: true,
+        files: validUploads.map(({ file }) => ({ file, id: file.name, status: 'pending' })),
+        type: 'addFiles',
+      });
 
-        return { file, fileId: result?.id, fileType: file.type };
-      },
-      { concurrency: MAX_UPLOAD_FILE_COUNT },
-    );
+      // 8. Upload files with concurrency limit
+      const uploadResults = await pMap(
+        validUploads,
+        async ({ file, parentId }) => {
+          const result = await get().uploadWithProgress({
+            file,
+            knowledgeBaseId,
+            onStatusUpdate: dispatchDockFileList,
+            parentId,
+          });
+
+          // Note: Don't refresh after each file to avoid flickering
+          // We'll refresh once at the end
+
+          return { file, fileId: result?.id, fileType: file.type };
+        },
+        { concurrency: MAX_UPLOAD_FILE_COUNT },
+      );
 
-    // Refresh the file list once after all uploads are complete
-    await get().refreshFileList();
+      // Refresh the file list once after all uploads are complete
+      await get().refreshFileList();
 
-    // 8. Auto-embed files that support chunking
-    const fileIdsToEmbed = uploadResults
-      .filter(({ fileType, fileId }) => fileId && !isChunkingUnsupported(fileType))
-      .map(({ fileId }) => fileId!);
+      // 9. Auto-embed files that support chunking
+      const fileIdsToEmbed = uploadResults
+        .filter(({ fileType, fileId }) => fileId && !isChunkingUnsupported(fileType))
+        .map(({ fileId }) => fileId!);
 
-    if (fileIdsToEmbed.length > 0) {
-      await get().parseFilesToChunks(fileIdsToEmbed, { skipExist: false });
+      if (fileIdsToEmbed.length > 0) {
+        await get().parseFilesToChunks(fileIdsToEmbed, { skipExist: false });
+      }
+    } catch (error) {
+      // Dismiss toast on error
+      if (sortedFolderPaths.length > 0) {
+        message.destroy(messageKey);
+      }
+      throw error;
     }
   },
 

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

@@ -25,6 +25,7 @@ type OnStatusUpdate = (
 ) => void;
 
 interface UploadWithProgressParams {
+  abortController?: AbortController;
   file: File;
   knowledgeBaseId?: string;
   onStatusUpdate?: OnStatusUpdate;
@@ -93,6 +94,7 @@ export const createFileUploadSlice: StateCreator<
     skipCheckFileType,
     parentId,
     source,
+    abortController,
   }) => {
     const fileArrayBuffer = await file.arrayBuffer();
 
@@ -117,6 +119,7 @@ export const createFileUploadSlice: StateCreator<
     // 3. if file don't exist, need upload files
     else {
       const { data, success } = await uploadService.uploadFileToS3(file, {
+        abortController,
         onNotSupported: () => {
           onStatusUpdate?.({ id: file.name, type: 'removeFile' });
           message.info({

package/src/store/global/actions/general.ts

@@ -20,6 +20,7 @@ export interface GlobalGeneralAction {
   openAgentInNewWindow: (agentId: string) => Promise<void>;
   openTopicInNewWindow: (agentId: string, topicId: string) => Promise<void>;
   switchLocale: (locale: LocaleMode, params?: { skipBroadcast?: boolean }) => void;
+  updateResourceManagerColumnWidth: (column: 'name' | 'date' | 'size', width: number) => void;
   updateSystemStatus: (status: Partial<SystemStatus>, action?: any) => void;
   useCheckLatestVersion: (enabledCheck?: boolean) => SWRResponse<string>;
   useInitSystemStatus: () => SWRResponse;
@@ -110,6 +111,20 @@ export const generalActionSlice: StateCreator<
       })();
     }
   },
+  updateResourceManagerColumnWidth: (column, width) => {
+    const currentWidths = get().status.resourceManagerColumnWidths || {
+      date: 160,
+      name: 574,
+      size: 140,
+    };
+
+    get().updateSystemStatus({
+      resourceManagerColumnWidths: {
+        ...currentWidths,
+        [column]: width,
+      },
+    });
+  },
   updateSystemStatus: (status, action) => {
     if (!get().isStatusInit) return;
 

package/src/store/global/initialState.ts

@@ -127,6 +127,14 @@ export interface SystemStatus {
    */
   pagePageSize?: number;
   portalWidth: number;
+  /**
+   * Resource Manager column widths
+   */
+  resourceManagerColumnWidths?: {
+    date: number;
+    name: number;
+    size: number;
+  };
   showCommandMenu?: boolean;
   showFilePanel?: boolean;
   showHotkeyHelper?: boolean;
@@ -192,6 +200,11 @@ export const INITIAL_STATUS = {
   noWideScreen: true,
   pagePageSize: 20,
   portalWidth: 400,
+  resourceManagerColumnWidths: {
+    date: 160,
+    name: 574,
+    size: 140,
+  },
   showCommandMenu: false,
   showFilePanel: true,
   showHotkeyHelper: false,

package/src/store/serverConfig/selectors.ts

@@ -6,6 +6,7 @@ export const serverConfigSelectors = {
   enableEmailVerification: (s: ServerConfigStore) =>
     s.serverConfig.enableEmailVerification || false,
   enableKlavis: (s: ServerConfigStore) => s.serverConfig.enableKlavis || false,
+  enableLobehubSkill: (s: ServerConfigStore) => s.serverConfig.enableLobehubSkill || false,
   enableMagicLink: (s: ServerConfigStore) => s.serverConfig.enableMagicLink || false,
   enableMarketTrustedClient: (s: ServerConfigStore) =>
     s.serverConfig.enableMarketTrustedClient || false,

package/src/store/tool/initialState.ts

@@ -1,6 +1,13 @@
 import { type BuiltinToolState, initialBuiltinToolState } from './slices/builtin/initialState';
-import { type CustomPluginState, initialCustomPluginState } from './slices/customPlugin/initialState';
+import {
+  type CustomPluginState,
+  initialCustomPluginState,
+} from './slices/customPlugin/initialState';
 import { type KlavisStoreState, initialKlavisStoreState } from './slices/klavisStore/initialState';
+import {
+  type LobehubSkillStoreState,
+  initialLobehubSkillStoreState,
+} from './slices/lobehubSkillStore/initialState';
 import { type MCPStoreState, initialMCPStoreState } from './slices/mcpStore/initialState';
 import { type PluginStoreState, initialPluginStoreState } from './slices/oldStore/initialState';
 import { type PluginState, initialPluginState } from './slices/plugin/initialState';
@@ -10,7 +17,8 @@ export type ToolStoreState = PluginState &
   PluginStoreState &
   BuiltinToolState &
   MCPStoreState &
-  KlavisStoreState;
+  KlavisStoreState &
+  LobehubSkillStoreState;
 
 export const initialState: ToolStoreState = {
   ...initialPluginState,
@@ -19,4 +27,5 @@ export const initialState: ToolStoreState = {
   ...initialBuiltinToolState,
   ...initialMCPStoreState,
   ...initialKlavisStoreState,
+  ...initialLobehubSkillStoreState,
 };

package/src/store/tool/selectors/index.ts

@@ -4,6 +4,7 @@ export {
 } from '../slices/builtin/selectors';
 export { customPluginSelectors } from '../slices/customPlugin/selectors';
 export { klavisStoreSelectors } from '../slices/klavisStore/selectors';
+export { lobehubSkillStoreSelectors } from '../slices/lobehubSkillStore/selectors';
 export { mcpStoreSelectors } from '../slices/mcpStore/selectors';
 export { pluginStoreSelectors } from '../slices/oldStore/selectors';
 export { pluginSelectors } from '../slices/plugin/selectors';

package/src/store/tool/selectors/tool.ts

@@ -6,12 +6,14 @@ import { type LobeToolMeta } from '@/types/tool/tool';
 
 import { type ToolStoreState } from '../initialState';
 import { builtinToolSelectors } from '../slices/builtin/selectors';
+import { lobehubSkillStoreSelectors } from '../slices/lobehubSkillStore/selectors';
 import { pluginSelectors } from '../slices/plugin/selectors';
 
 const metaList = (s: ToolStoreState): LobeToolMeta[] => {
   const pluginList = pluginSelectors.installedPluginMetaList(s) as LobeToolMeta[];
+  const lobehubSkillList = lobehubSkillStoreSelectors.metaList(s) as LobeToolMeta[];
 
-  return builtinToolSelectors.metaList(s).concat(pluginList);
+  return builtinToolSelectors.metaList(s).concat(pluginList).concat(lobehubSkillList);
 };
 
 const getMetaById =