feishu-mcp 0.1.7 → 0.1.8

package/dist/mcp/tools/feishuBlockTools.js

@@ -20,7 +20,7 @@ TableCreateSchema, WhiteboardFillArraySchema } from '../../types/feishuSchema.js
  */
 export function registerFeishuBlockTools(server, feishuService) {
     // 添加更新块文本内容工具
-    server.tool('update_feishu_block_text', 'Updates the text content and styling of a specific block in a Feishu document. Can be used to modify content in existing text, code, or heading blocks while preserving the block type and other properties. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx) you must first use convert_feishu_wiki_to_document_id tool to obtain a compatible document ID.', {
+    server.tool('update_feishu_block_text', 'Updates the text content and styling of a specific block in a Feishu document. Can be used to modify content in existing text, code, or heading blocks while preserving the block type and other properties. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx), use get_feishu_document_info to get document information, then use the returned documentId for editing operations.', {
         documentId: DocumentIdSchema,
         blockId: BlockIdSchema,
         textElements: TextElementsArraySchema,
@@ -47,7 +47,7 @@ export function registerFeishuBlockTools(server, feishuService) {
         }
     });
     // 添加通用飞书块创建工具（支持文本、代码、标题）
-    server.tool('batch_create_feishu_blocks', 'PREFERRED: Efficiently creates multiple blocks (text, code, heading, list, image, mermaid, whiteboard) in a single API call. USE THIS TOOL when creating multiple consecutive blocks at the same position - reduces API calls by up to 90%. KEY FEATURES: (1) Handles any number of blocks by auto-batching large requests (>50 blocks), (2) Creates blocks at consecutive positions in a document, (3) Supports direct heading level format (e.g. "heading1", "heading2") or standard "heading" type with level in options. CORRECT FORMAT: mcp_feishu_batch_create_feishu_blocks({documentId:"doc123",parentBlockId:"para123",startIndex:0,blocks:[{blockType:"text",options:{...}},{blockType:"heading1",options:{heading:{content:"Title"}}}]}). For whiteboard blocks, use blockType:"whiteboard" with options:{whiteboard:{align:1}}. After creating a whiteboard block, you will receive a token in the response (board.token field) which can be used with fill_whiteboard_with_plantuml tool. The fill_whiteboard_with_plantuml tool supports both PlantUML (syntax_type: 1) and Mermaid (syntax_type: 2) formats. For separate positions, use individual block creation tools instead. For wiki links (https://xxx.feishu.cn/wiki/xxx), first convert with convert_feishu_wiki_to_document_id tool.', {
+    server.tool('batch_create_feishu_blocks', 'PREFERRED: Efficiently creates multiple blocks (text, code, heading, list, image, mermaid, whiteboard) in a single API call. USE THIS TOOL when creating multiple consecutive blocks at the same position - reduces API calls by up to 90%. KEY FEATURES: (1) Handles any number of blocks by auto-batching large requests (>50 blocks), (2) Creates blocks at consecutive positions in a document, (3) Supports direct heading level format (e.g. "heading1", "heading2") or standard "heading" type with level in options. CORRECT FORMAT: mcp_feishu_batch_create_feishu_blocks({documentId:"doc123",parentBlockId:"para123",startIndex:0,blocks:[{blockType:"text",options:{...}},{blockType:"heading1",options:{heading:{content:"Title"}}}]}). For whiteboard blocks, use blockType:"whiteboard" with options:{whiteboard:{align:1}}. After creating a whiteboard block, you will receive a token in the response (board.token field) which can be used with fill_whiteboard_with_plantuml tool. The fill_whiteboard_with_plantuml tool supports both PlantUML (syntax_type: 1) and Mermaid (syntax_type: 2) formats. For separate positions, use individual block creation tools instead. For wiki links (https://xxx.feishu.cn/wiki/xxx), use get_feishu_document_info to get document information, then use the returned documentId for editing operations.', {
         documentId: DocumentIdSchema,
         parentBlockId: ParentBlockIdSchema,
         index: IndexSchema,
@@ -458,34 +458,41 @@ export function registerFeishuBlockTools(server, feishuService) {
     //   },
     // );
     // 添加飞书Wiki文档ID转换工具
-    server.tool('convert_feishu_wiki_to_document_id', 'Converts a Feishu Wiki document link to a compatible document ID. This conversion is required before using wiki links with any other Feishu document tools.', {
-        wikiUrl: z.string().describe('Wiki URL or Token (required). Supports complete URL formats like https://xxx.feishu.cn/wiki/xxxxx or direct use of the Token portion'),
-    }, async ({ wikiUrl }) => {
-        try {
-            if (!feishuService) {
-                return {
-                    content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
-                };
-            }
-            Logger.info(`开始转换Wiki文档链接，输入: ${wikiUrl}`);
-            const documentId = await feishuService.convertWikiToDocumentId(wikiUrl);
-            Logger.info(`Wiki文档转换成功，可用的文档ID为: ${documentId}`);
-            return {
-                content: [
-                    { type: 'text', text: `Converted Wiki link to Document ID: ${documentId}\n\nUse this Document ID with other Feishu document tools.` }
-                ],
-            };
-        }
-        catch (error) {
-            Logger.error(`转换Wiki文档链接失败:`, error);
-            const errorMessage = formatErrorMessage(error);
-            return {
-                content: [{ type: 'text', text: `转换Wiki文档链接失败: ${errorMessage}` }],
-            };
-        }
-    });
+    // server.tool(
+    //   'convert_feishu_wiki_to_document_id',
+    //   'Converts a Feishu Wiki document link to a compatible document ID. This conversion is required before using wiki links with any other Feishu document tools.',
+    //   {
+    //     wikiUrl: z.string().describe('Wiki URL or Token (required). Supports complete URL formats like https://xxx.feishu.cn/wiki/xxxxx or direct use of the Token portion'),
+    //   },
+    //   async ({ wikiUrl }) => {
+    //     try {
+    //       if (!feishuService) {
+    //         return {
+    //           content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
+    //         };
+    //       }
+    //
+    //       Logger.info(`开始转换Wiki文档链接，输入: ${wikiUrl}`);
+    //       const documentId = await feishuService.convertWikiToDocumentId(wikiUrl);
+    //
+    //       Logger.info(`Wiki文档转换成功，可用的文档ID为: ${documentId}`);
+    //
+    //       return {
+    //         content: [
+    //           { type: 'text', text: `Converted Wiki link to Document ID: ${documentId}\n\nUse this Document ID with other Feishu document tools.` }
+    //         ],
+    //       };
+    //     } catch (error) {
+    //       Logger.error(`转换Wiki文档链接失败:`, error);
+    //       const errorMessage = formatErrorMessage(error);
+    //       return {
+    //         content: [{ type: 'text', text: `转换Wiki文档链接失败: ${errorMessage}` }],
+    //       };
+    //     }
+    //   },
+    // );
     // 添加删除文档块工具
-    server.tool('delete_feishu_document_blocks', 'Deletes one or more consecutive blocks from a Feishu document. Use this tool to remove unwanted content, clean up document structure, or clear space before inserting new content. Supports batch deletion for efficiency. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx) you must first use convert_feishu_wiki_to_document_id tool to obtain a compatible document ID.', {
+    server.tool('delete_feishu_document_blocks', 'Deletes one or more consecutive blocks from a Feishu document. Use this tool to remove unwanted content, clean up document structure, or clear space before inserting new content. Supports batch deletion for efficiency. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx), use get_feishu_document_info to get document information, then use the returned documentId for editing operations.', {
         documentId: DocumentIdSchema,
         parentBlockId: ParentBlockIdSchema,
         startIndex: StartIndexSchema,
@@ -647,7 +654,7 @@ export function registerFeishuBlockTools(server, feishuService) {
         }
     });
     // 添加创建飞书表格工具
-    server.tool('create_feishu_table', 'Creates a table block in a Feishu document with specified rows and columns. Each cell can contain different types of content blocks (text, lists, code, etc.). This tool creates the complete table structure including table cells and their content. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx) you must first use convert_feishu_wiki_to_document_id tool to obtain a compatible document ID.', {
+    server.tool('create_feishu_table', 'Creates a table block in a Feishu document with specified rows and columns. Each cell can contain different types of content blocks (text, lists, code, etc.). This tool creates the complete table structure including table cells and their content. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx), use get_feishu_document_info to get document information, then use the returned documentId for editing operations.', {
         documentId: DocumentIdSchema,
         parentBlockId: ParentBlockIdSchema,
         index: IndexSchema,

package/dist/mcp/tools/feishuFolderTools.js

@@ -1,61 +1,126 @@
 import { formatErrorMessage } from '../../utils/error.js';
 import { Logger } from '../../utils/logger.js';
-import { FolderTokenSchema, FolderNameSchema, } from '../../types/feishuSchema.js';
-import { Config } from '../../utils/config.js';
+import { FolderTokenSchema, FolderTokenOptionalSchema, FolderNameSchema, WikiSpaceNodeContextSchema, } from '../../types/feishuSchema.js';
 /**
  * 注册飞书文件夹相关的MCP工具
  * @param server MCP服务器实例
  * @param feishuService 飞书API服务实例
  */
 export function registerFeishuFolderTools(server, feishuService) {
-    const config = Config.getInstance();
     // 添加获取根文件夹信息工具
-    if (config.feishu.authType === 'user') {
-        server.tool('get_feishu_root_folder_info', 'Retrieves basic information about the root folder in Feishu Drive. Returns the token, ID and user ID of the root folder, which can be used for subsequent folder operations.', {}, async () => {
-            try {
-                if (!feishuService) {
-                    return {
-                        content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
-                    };
-                }
-                Logger.info(`开始获取飞书根文件夹信息`);
-                const folderInfo = await feishuService.getRootFolderInfo();
-                Logger.info(`飞书根文件夹信息获取成功，token: ${folderInfo.token}`);
+    server.tool('get_feishu_root_folder_info', 'Retrieves the root folder in Feishu Drive, wiki spaces list, and "My Library". Use this when you need to browse folders or wiki spaces from the root. If you know the wiki node name, you can also use search_feishu_documents to directly locate specific wiki nodes instead of traversing from root. Returns root folder token, all wiki spaces, and personal library information.', {}, async () => {
+        try {
+            if (!feishuService) {
                 return {
-                    content: [{ type: 'text', text: JSON.stringify(folderInfo, null, 2) }],
+                    content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
                 };
             }
+            Logger.info(`开始获取飞书根文件夹信息、知识空间列表和我的知识库`);
+            const result = {
+                root_folder: null,
+                wiki_spaces: null,
+                my_library: null,
+            };
+            // 获取根文件夹信息
+            try {
+                const folderInfo = await feishuService.getRootFolderInfo();
+                result.root_folder = folderInfo?.data || folderInfo;
+                Logger.info(`飞书根文件夹信息获取成功，token: ${result.root_folder?.token}`);
+            }
             catch (error) {
                 Logger.error(`获取飞书根文件夹信息失败:`, error);
-                const errorMessage = formatErrorMessage(error, '获取飞书根文件夹信息失败');
-                return {
-                    content: [{ type: 'text', text: errorMessage }],
-                };
+                result.root_folder = { error: formatErrorMessage(error, '获取根文件夹信息失败') };
+            }
+            // 获取知识空间列表（遍历所有分页）
+            try {
+                const wikiSpaces = await feishuService.getAllWikiSpacesList(20);
+                result.wiki_spaces = wikiSpaces || [];
+                Logger.info(`知识空间列表获取成功，共 ${Array.isArray(result.wiki_spaces) ? result.wiki_spaces.length : 0} 个空间`);
+            }
+            catch (error) {
+                Logger.error(`获取知识空间列表失败:`, error);
+                result.wiki_spaces = [];
             }
-        });
-    }
+            // 获取"我的知识库"（通过传入 my_library 作为 space_id）
+            try {
+                const myLibrary = await feishuService.getWikiSpaceInfo('my_library', 'en');
+                // 提取 space 对象的内容，去掉 space 这一层
+                const libraryData = myLibrary?.data || myLibrary;
+                result.my_library = libraryData?.space || libraryData;
+                Logger.info(`我的知识库获取成功，space_id: ${result.my_library?.space_id}`);
+            }
+            catch (error) {
+                Logger.error(`获取我的知识库失败:`, error);
+                result.my_library = { error: formatErrorMessage(error, '获取我的知识库失败') };
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            Logger.error(`获取飞书信息失败:`, error);
+            const errorMessage = formatErrorMessage(error, '获取飞书信息失败');
+            return {
+                content: [{ type: 'text', text: errorMessage }],
+            };
+        }
+    });
     // 添加获取文件夹中的文件清单工具
-    server.tool('get_feishu_folder_files', 'Retrieves a list of files and subfolders in a specified folder. Use this to explore folder contents, view file metadata, and get URLs and tokens for further operations.', {
-        folderToken: FolderTokenSchema,
-    }, async ({ folderToken, }) => {
+    server.tool('get_feishu_folder_files', 'Retrieves a list of files and subfolders in a specified folder or wiki space node. Supports two modes: (1) Feishu Drive folder mode: use folderToken to get files in a Feishu Drive folder. (2) Wiki space node mode: use wikiContext with spaceId (and optional parentNodeToken) to get documents under a wiki space node. If parentNodeToken is not provided, retrieves nodes from the root of the wiki space. Only one mode can be used at a time - provide either folderToken OR wikiContext.', {
+        folderToken: FolderTokenOptionalSchema,
+        wikiContext: WikiSpaceNodeContextSchema,
+    }, async ({ folderToken, wikiContext }) => {
         try {
             if (!feishuService) {
                 return {
                     content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
                 };
             }
-            Logger.info(`开始获取飞书文件夹中的文件清单，文件夹Token: ${folderToken}`);
-            const fileList = await feishuService.getFolderFileList(folderToken);
-            Logger.info(`飞书文件夹中的文件清单获取成功，共 ${fileList.files?.length || 0} 个文件`);
+            // 验证参数：必须提供 folderToken 或 wikiContext 之一，但不能同时提供
+            if (folderToken && wikiContext) {
+                return {
+                    content: [{ type: 'text', text: '错误：不能同时提供 folderToken 和 wikiContext 参数，请选择其中一种模式。' }],
+                };
+            }
+            if (!folderToken && !wikiContext) {
+                return {
+                    content: [{ type: 'text', text: '错误：必须提供 folderToken（飞书文档目录模式）或 wikiContext（知识库节点模式）参数之一。' }],
+                };
+            }
+            // 模式一：飞书文档目录模式
+            if (folderToken) {
+                Logger.info(`开始获取飞书文件夹中的文件清单，文件夹Token: ${folderToken}`);
+                const fileList = await feishuService.getFolderFileList(folderToken);
+                Logger.info(`飞书文件夹中的文件清单获取成功，共 ${fileList.files?.length || 0} 个文件`);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(fileList, null, 2) }],
+                };
+            }
+            // 模式二：知识库节点模式
+            if (wikiContext) {
+                const { spaceId, parentNodeToken } = wikiContext;
+                if (!spaceId) {
+                    return {
+                        content: [{ type: 'text', text: '错误：使用 wikiContext 模式时，必须提供 spaceId。' }],
+                    };
+                }
+                Logger.info(`开始获取知识空间子节点列表，知识空间ID: ${spaceId}, 父节点Token: ${parentNodeToken || 'null（根节点）'}`);
+                const nodeList = await feishuService.getAllWikiSpaceNodes(spaceId, parentNodeToken);
+                Logger.info(`知识空间子节点列表获取成功，共 ${Array.isArray(nodeList) ? nodeList.length : 0} 个节点`);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ nodes: nodeList || [] }, null, 2) }],
+                };
+            }
+            // 理论上不会到达这里
             return {
-                content: [{ type: 'text', text: JSON.stringify(fileList, null, 2) }],
+                content: [{ type: 'text', text: '错误：未知错误' }],
             };
         }
         catch (error) {
-            Logger.error(`获取飞书文件夹中的文件清单失败:`, error);
+            Logger.error(`获取文件列表失败:`, error);
             const errorMessage = formatErrorMessage(error);
             return {
-                content: [{ type: 'text', text: `获取飞书文件夹中的文件清单失败: ${errorMessage}` }],
+                content: [{ type: 'text', text: `获取文件列表失败: ${errorMessage}` }],
             };
         }
     });

package/dist/mcp/tools/feishuTools.js

@@ -1,9 +1,8 @@
-// import { z } from 'zod';
 import { formatErrorMessage } from '../../utils/error.js';
 import { Logger } from '../../utils/logger.js';
-import { DocumentIdSchema, 
+import { DocumentIdSchema, DocumentIdOrWikiIdSchema, DocumentTypeSchema, 
 // BlockIdSchema,
-SearchKeySchema, WhiteboardIdSchema, DocumentTitleSchema, FolderTokenSchema, } from '../../types/feishuSchema.js';
+SearchKeySchema, SearchTypeSchema, PageTokenSchema, OffsetSchema, WhiteboardIdSchema, DocumentTitleSchema, FolderTokenOptionalSchema, WikiSpaceNodeContextSchema, } from '../../types/feishuSchema.js';
 /**
  * 注册飞书相关的MCP工具
  * @param server MCP服务器实例
@@ -11,42 +10,94 @@ SearchKeySchema, WhiteboardIdSchema, DocumentTitleSchema, FolderTokenSchema, } f
  */
 export function registerFeishuTools(server, feishuService) {
     // 添加创建飞书文档工具
-    server.tool('create_feishu_document', 'Creates a new Feishu document and returns its information. Use this tool when you need to create a document from scratch with a specific title and folder location.', {
+    server.tool('create_feishu_document', 'Creates a new Feishu document and returns its information. Supports two modes: (1) Feishu Drive folder mode: use folderToken to create a document in a folder. (2) Wiki space node mode: use wikiContext with spaceId (and optional parentNodeToken) to create a node (document) in a wiki space. IMPORTANT: In wiki spaces, documents are nodes themselves - they can act as parent nodes containing child documents, and can also be edited as regular documents. The created node returns both node_token (node ID, can be used as parentNodeToken for creating child nodes) and obj_token (document ID, can be used for document editing operations like get_feishu_document_blocks, batch_create_feishu_blocks, etc.). Only one mode can be used at a time - provide either folderToken OR wikiContext, not both.', {
         title: DocumentTitleSchema,
-        folderToken: FolderTokenSchema,
-    }, async ({ title, folderToken }) => {
+        folderToken: FolderTokenOptionalSchema,
+        wikiContext: WikiSpaceNodeContextSchema,
+    }, async ({ title, folderToken, wikiContext }) => {
         try {
-            Logger.info(`开始创建飞书文档，标题: ${title}${folderToken ? `，文件夹Token: ${folderToken}` : '，使用默认文件夹'}`);
-            const newDoc = await feishuService?.createDocument(title, folderToken);
-            if (!newDoc) {
-                throw new Error('创建文档失败，未返回文档信息');
+            if (!feishuService) {
+                return {
+                    content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
+                };
+            }
+            // 参数验证：必须提供 folderToken 或 wikiContext 之一，但不能同时提供
+            if (folderToken && wikiContext) {
+                return {
+                    content: [{ type: 'text', text: '错误：不能同时提供 folderToken 和 wikiContext 参数，请选择其中一种模式。\n- 使用 folderToken 在飞书文档目录中创建文档\n- 使用 wikiContext 在知识库中创建节点（文档）' }],
+                };
             }
-            Logger.info(`飞书文档创建成功，文档ID: ${newDoc.objToken || newDoc.document_id}`);
+            if (!folderToken && !wikiContext) {
+                return {
+                    content: [{ type: 'text', text: '错误：必须提供 folderToken（飞书文档目录模式）或 wikiContext（知识库节点模式）参数之一。' }],
+                };
+            }
+            // 模式一：飞书文档目录模式
+            if (folderToken) {
+                Logger.info(`开始创建飞书文档（文件夹模式），标题: ${title}，文件夹Token: ${folderToken}`);
+                const newDoc = await feishuService.createDocument(title, folderToken);
+                if (!newDoc) {
+                    throw new Error('创建文档失败，未返回文档信息');
+                }
+                Logger.info(`飞书文档创建成功，文档ID: ${newDoc.objToken || newDoc.document_id}`);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(newDoc, null, 2) }],
+                };
+            }
+            // 模式二：知识库节点模式
+            if (wikiContext) {
+                const { spaceId, parentNodeToken } = wikiContext;
+                if (!spaceId) {
+                    return {
+                        content: [{ type: 'text', text: '错误：使用 wikiContext 模式时，必须提供 spaceId。' }],
+                    };
+                }
+                Logger.info(`开始创建知识库节点，标题: ${title}，知识空间ID: ${spaceId}，父节点Token: ${parentNodeToken || 'null（根节点）'}`);
+                const node = await feishuService.createWikiSpaceNode(spaceId, title, parentNodeToken);
+                if (!node) {
+                    throw new Error('创建知识库节点失败，未返回节点信息');
+                }
+                // 构建返回信息，说明知识库节点的特殊性质
+                const result = {
+                    ...node,
+                    _note: '知识库节点既是节点又是文档：node_token 可作为父节点使用，obj_token 可用于文档编辑操作'
+                };
+                Logger.info(`知识库节点创建成功，node_token: ${node.node_token}, obj_token: ${node.obj_token}`);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            // 理论上不会到达这里
             return {
-                content: [{ type: 'text', text: JSON.stringify(newDoc, null, 2) }],
+                content: [{ type: 'text', text: '错误：未知错误' }],
             };
         }
         catch (error) {
-            Logger.error(`创建飞书文档失败:`, error);
+            Logger.error(`创建文档失败:`, error);
             const errorMessage = formatErrorMessage(error);
             return {
-                content: [{ type: 'text', text: `创建飞书文档失败: ${errorMessage}` }],
+                content: [{ type: 'text', text: `创建文档失败: ${errorMessage}` }],
             };
         }
     });
-    // 添加获取飞书文档信息工具
-    server.tool('get_feishu_document_info', 'Retrieves basic information about a Feishu document. Use this to verify a document exists, check access permissions, or get metadata like title, type, and creation information.', {
-        documentId: DocumentIdSchema,
-    }, async ({ documentId }) => {
+    // 添加获取飞书文档信息工具（支持普通文档和Wiki文档）
+    server.tool('get_feishu_document_info', 'Retrieves basic information about a Feishu document or Wiki node. Supports both regular documents (via document ID/URL) and Wiki documents (via Wiki URL/token). Use this to verify a document exists, check access permissions, or get metadata like title, type, and creation information. For Wiki documents, returns complete node information including documentId (obj_token) for document editing operations, and space_id and node_token for creating child nodes. ', {
+        documentId: DocumentIdOrWikiIdSchema,
+        documentType: DocumentTypeSchema,
+    }, async ({ documentId, documentType }) => {
         try {
             if (!feishuService) {
                 return {
                     content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
                 };
             }
-            Logger.info(`开始获取飞书文档信息，文档ID: ${documentId}`);
-            const docInfo = await feishuService.getDocumentInfo(documentId);
-            Logger.info(`飞书文档信息获取成功，标题: ${docInfo.title}`);
+            Logger.info(`开始获取飞书文档信息，文档ID: ${documentId}, 类型: ${documentType || 'auto'}`);
+            const docInfo = await feishuService.getDocumentInfo(documentId, documentType);
+            if (!docInfo) {
+                throw new Error('获取文档信息失败，未返回数据');
+            }
+            const title = docInfo.title || docInfo.document?.title || '未知标题';
+            Logger.info(`飞书文档信息获取成功，标题: ${title}, 类型: ${docInfo._type || 'document'}`);
             return {
                 content: [{ type: 'text', text: JSON.stringify(docInfo, null, 2) }],
             };
@@ -92,7 +143,7 @@ export function registerFeishuTools(server, feishuService) {
     //   },
     // );
     // 添加获取飞书文档块工具
-    server.tool('get_feishu_document_blocks', 'Retrieves the block structure information of a Feishu document. Essential to use before inserting content to understand document structure and determine correct insertion positions. Returns a detailed hierarchy of blocks with their IDs, types, and content. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx) you must first use convert_feishu_wiki_to_document_id tool to obtain a compatible document ID.', {
+    server.tool('get_feishu_document_blocks', 'Retrieves the block structure information of a Feishu document. Essential to use before inserting content to understand document structure and determine correct insertion positions. Returns a detailed hierarchy of blocks with their IDs, types, and content. Note: For Feishu wiki links (https://xxx.feishu.cn/wiki/xxx), use get_feishu_document_info to get document information, then use the returned documentId for editing operations.', {
         documentId: DocumentIdSchema,
     }, async ({ documentId }) => {
         try {
@@ -183,19 +234,22 @@ export function registerFeishuTools(server, feishuService) {
     //     }
     //   },
     // );
-    // 添加搜索文档工具
-    server.tool('search_feishu_documents', 'Searches for documents in Feishu. Supports keyword-based search and returns document information including title, type, and owner. Use this tool to find specific content or related documents in your document library.', {
+    // 添加搜索文档工具（支持文档和知识库搜索）
+    server.tool('search_feishu_documents', 'Searches for documents and/or Wiki knowledge base nodes in Feishu. Supports keyword-based search with type filtering (document, wiki, or both). Returns document and wiki information including title, type, and owner. Supports pagination: use offset for document search pagination and pageToken for wiki search pagination. Each type (document or wiki) can return up to 100 results maximum per search. Default page size is 20 items.', {
         searchKey: SearchKeySchema,
-    }, async ({ searchKey }) => {
+        searchType: SearchTypeSchema,
+        offset: OffsetSchema,
+        pageToken: PageTokenSchema,
+    }, async ({ searchKey, searchType, offset, pageToken }) => {
         try {
             if (!feishuService) {
                 return {
                     content: [{ type: 'text', text: 'Feishu service is not initialized. Please check the configuration.' }],
                 };
             }
-            Logger.info(`开始搜索飞书文档，关键字: ${searchKey},`);
-            const searchResult = await feishuService.searchDocuments(searchKey);
-            Logger.info(`文档搜索完成，找到 ${searchResult.size} 个结果`);
+            Logger.info(`开始搜索，关键字: ${searchKey}, 类型: ${searchType || 'both'}, offset: ${offset || 0}, pageToken: ${pageToken || '无'}`);
+            const searchResult = await feishuService.search(searchKey, searchType || 'both', offset, pageToken);
+            Logger.info(`搜索完成，文档: ${searchResult.documents?.length || 0} 条，知识库: ${searchResult.wikis?.length || 0} 条`);
             return {
                 content: [
                     { type: 'text', text: JSON.stringify(searchResult, null, 2) },
@@ -203,11 +257,11 @@ export function registerFeishuTools(server, feishuService) {
             };
         }
         catch (error) {
-            Logger.error(`搜索飞书文档失败:`, error);
+            Logger.error(`搜索失败:`, error);
             const errorMessage = formatErrorMessage(error);
             return {
                 content: [
-                    { type: 'text', text: `搜索飞书文档失败: ${errorMessage}` },
+                    { type: 'text', text: `搜索失败: ${errorMessage}` },
                 ],
             };
         }