feishu-mcp 0.1.0 → 0.1.2

package/dist/mcp/tools/feishuBlockTools.js

@@ -8,10 +8,11 @@ import { DocumentIdSchema, ParentBlockIdSchema, BlockIdSchema, IndexSchema, Star
 TextElementsArraySchema, 
 // CodeLanguageSchema,
 // CodeWrapSchema,
-BlockConfigSchema, MediaIdSchema, MediaExtraSchema, ImagesArraySchema,
+BlockConfigSchema, MediaIdSchema, MediaExtraSchema, ImagesArraySchema, 
+// MermaidCodeSchema,
 // ImageWidthSchema,
 // ImageHeightSchema
- } from '../../types/feishuSchema.js';
+TableCreateSchema } from '../../types/feishuSchema.js';
 /**
  * 注册飞书块相关的MCP工具
  * @param server MCP服务器实例
@@ -396,6 +397,38 @@ export function registerFeishuBlockTools(server, feishuService) {
     //     }
     //   },
     // );
+    // 添加创建飞书Mermaid块工具
+    // server.tool(
+    //   "create_feishu_mermaid_block",
+    //   "Creates a new Mermaid block in a Feishu document. This tool allows you to insert a Mermaid diagram by specifying the Mermaid code.  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.",
+    //   {
+    //     documentId: DocumentIdSchema,
+    //     parentBlockId: ParentBlockIdSchema,
+    //     mermaidCode: MermaidCodeSchema,
+    //     index: IndexSchema
+    //   },
+    //   async ({ documentId, parentBlockId, mermaidCode, index }) => {
+    //     try {
+    //       if (!feishuService) {
+    //         return {
+    //           content: [{ type: "text", text: "Feishu service is not initialized. Please check the configuration" }],
+    //         };
+    //       }
+    //       Logger.info(`开始创建飞书Mermaid块，文档ID: ${documentId}，父块ID: ${parentBlockId}，插入位置: ${index}`);
+    //       const result = await (feishuService as any).createMermaidBlock(documentId, parentBlockId, mermaidCode, index);
+    //       Logger.info(`飞书Mermaid块创建成功`);
+    //       return {
+    //         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    //       };
+    //     } catch (error) {
+    //       Logger.error(`创建飞书Mermaid块失败:`, error);
+    //       const errorMessage = formatErrorMessage(error);
+    //       return {
+    //         content: [{ type: "text", text: `创建飞书Mermaid块失败: ${errorMessage}` }],
+    //       };
+    //     }
+    //   },
+    // );
     // 添加飞书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'),
@@ -585,4 +618,45 @@ 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.', {
+        documentId: DocumentIdSchema,
+        parentBlockId: ParentBlockIdSchema,
+        index: IndexSchema,
+        tableConfig: TableCreateSchema,
+    }, async ({ documentId, parentBlockId, index = 0, tableConfig }) => {
+        try {
+            if (!feishuService) {
+                return {
+                    content: [{ type: 'text', text: '飞书服务未初始化，请检查配置' }],
+                };
+            }
+            Logger.info(`开始创建飞书表格，文档ID: ${documentId}，父块ID: ${parentBlockId}，表格大小: ${tableConfig.rowSize}x${tableConfig.columnSize}，插入位置: ${index}`);
+            const result = await feishuService.createTableBlock(documentId, parentBlockId, tableConfig, index);
+            // 构建返回信息
+            let resultText = `表格创建成功！\n\n表格大小: ${tableConfig.rowSize}x${tableConfig.columnSize}\n`;
+            // 如果有图片token，显示图片信息
+            if (result.imageTokens && result.imageTokens.length > 0) {
+                resultText += `\n\n📸 发现 ${result.imageTokens.length} 个图片:\n`;
+                result.imageTokens.forEach((imageToken, index) => {
+                    resultText += `${index + 1}. 坐标(${imageToken.row}, ${imageToken.column}) - blockId: ${imageToken.blockId}\n`;
+                });
+                resultText += "你需要使用upload_and_bind_image_to_block工具绑定图片";
+            }
+            resultText += `\n\n完整结果:\n${JSON.stringify(result, null, 2)}`;
+            return {
+                content: [{
+                        type: 'text',
+                        text: resultText
+                    }],
+            };
+        }
+        catch (error) {
+            Logger.error(`创建飞书表格失败:`, error);
+            const errorMessage = formatErrorMessage(error);
+            return {
+                content: [{ type: 'text', text: `创建飞书表格失败: ${errorMessage}` }],
+            };
+        }
+    });
 }

package/dist/mcp/tools/feishuTools.js

@@ -107,11 +107,14 @@ export function registerFeishuTools(server, feishuService) {
             // 检查是否有 block_type 为 43 的块（画板块）
             const whiteboardBlocks = blocks.filter((block) => block.block_type === 43);
             const hasWhiteboardBlocks = whiteboardBlocks.length > 0;
+            // 检查是否有 block_type 为 27 的块（图片块）
+            const imageBlocks = blocks.filter((block) => block.block_type === 27);
+            const hasImageBlocks = imageBlocks.length > 0;
             let responseText = JSON.stringify(blocks, null, 2);
             if (hasWhiteboardBlocks) {
                 responseText += '\n\n⚠️ 检测到画板块 (block_type: 43)！\n';
-                responseText += `发现 ${whiteboardBlocks.length} 个画板块。画板块包含丰富的图形内容，如形状、文本、思维导图等。\n`;
-                responseText += '建议使用 get_feishu_whiteboard_content 工具来获取画板的具体内容和结构。\n';
+                responseText += `发现 ${whiteboardBlocks.length} 个画板块。\n`;
+                responseText += '💡 提示：如果您需要获取画板的具体内容（如流程图、思维导图等），可以使用 get_feishu_whiteboard_content 工具。\n';
                 responseText += '画板信息:\n';
                 whiteboardBlocks.forEach((block, index) => {
                     responseText += `  ${index + 1}. 块ID: ${block.block_id}`;
@@ -120,7 +123,21 @@ export function registerFeishuTools(server, feishuService) {
                     }
                     responseText += '\n';
                 });
-                responseText += '请使用上述画板ID调用 get_feishu_whiteboard_content 工具。';
+                responseText += '📝 注意：只有在需要分析画板内容时才调用上述工具，仅了解文档结构时无需获取。';
+            }
+            if (hasImageBlocks) {
+                responseText += '\n\n🖼️ 检测到图片块 (block_type: 27)！\n';
+                responseText += `发现 ${imageBlocks.length} 个图片块。\n`;
+                responseText += '💡 提示：如果您需要查看图片的具体内容，可以使用 get_feishu_image_resource 工具下载图片。\n';
+                responseText += '图片信息:\n';
+                imageBlocks.forEach((block, index) => {
+                    responseText += `  ${index + 1}. 块ID: ${block.block_id}`;
+                    if (block.image && block.image.token) {
+                        responseText += `, 媒体ID: ${block.image.token}`;
+                    }
+                    responseText += '\n';
+                });
+                responseText += '📝 注意：只有在需要查看图片内容时才调用上述工具，仅了解文档结构时无需获取。';
             }
             return {
                 content: [{ type: 'text', text: responseText }],
@@ -196,7 +213,7 @@ export function registerFeishuTools(server, feishuService) {
         }
     });
     // 添加获取画板内容工具
-    server.tool('get_feishu_whiteboard_content', 'Retrieves the content and structure of a Feishu whiteboard. This tool fetches all nodes (elements) from a whiteboard, including shapes, text, mind maps, and other graphical elements. Use this to analyze whiteboard content, extract information, or understand the structure of collaborative diagrams. The whiteboard ID can be obtained from the board.token field when getting document blocks with block_type: 43.', {
+    server.tool('get_feishu_whiteboard_content', 'Retrieves the content and structure of a Feishu whiteboard. Use this to analyze whiteboard content, extract information, or understand the structure of collaborative diagrams. The whiteboard ID can be obtained from the board.token field when getting document blocks with block_type: 43.', {
         whiteboardId: WhiteboardIdSchema,
     }, async ({ whiteboardId }) => {
         try {
@@ -207,7 +224,28 @@ export function registerFeishuTools(server, feishuService) {
             }
             Logger.info(`开始获取飞书画板内容，画板ID: ${whiteboardId}`);
             const whiteboardContent = await feishuService.getWhiteboardContent(whiteboardId);
-            Logger.info(`飞书画板内容获取成功，节点数量: ${whiteboardContent.nodes?.length || 0}`);
+            const nodeCount = whiteboardContent.nodes?.length || 0;
+            Logger.info(`飞书画板内容获取成功，节点数量: ${nodeCount}`);
+            // 检查节点数量是否超过100
+            if (nodeCount > 200) {
+                Logger.info(`画板节点数量过多 (${nodeCount} > 200)，返回缩略图`);
+                try {
+                    const thumbnailBuffer = await feishuService.getWhiteboardThumbnail(whiteboardId);
+                    const thumbnailBase64 = thumbnailBuffer.toString('base64');
+                    return {
+                        content: [
+                            {
+                                type: 'image',
+                                data: thumbnailBase64,
+                                mimeType: 'image/png'
+                            }
+                        ],
+                    };
+                }
+                catch (thumbnailError) {
+                    Logger.warn(`获取画板缩略图失败，返回基本信息: ${thumbnailError}`);
+                }
+            }
             return {
                 content: [{ type: 'text', text: JSON.stringify(whiteboardContent, null, 2) }],
             };

package/dist/server.js

@@ -1,5 +1,8 @@
 import express from 'express';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { randomUUID } from 'node:crypto';
 import { Logger } from './utils/logger.js';
 import { SSEConnectionManager } from './manager/sseConnectionManager.js';
 import { FeishuMcp } from './mcp/feishuMcp.js';
@@ -27,6 +30,118 @@ export class FeishuMcpServer {
     }
     async startHttpServer(port) {
         const app = express();
+        const transports = {};
+        // Parse JSON requests for the Streamable HTTP endpoint only, will break SSE endpoint
+        app.use("/mcp", express.json());
+        app.post('/mcp', async (req, res) => {
+            try {
+                Logger.log("Received StreamableHTTP request", {
+                    method: req.method,
+                    url: req.url,
+                    headers: req.headers,
+                    body: req.body,
+                    query: req.query,
+                    params: req.params
+                });
+                // Check for existing session ID
+                const sessionId = req.headers['mcp-session-id'];
+                let transport;
+                if (sessionId && transports[sessionId]) {
+                    // Reuse existing transport
+                    Logger.log("Reusing existing StreamableHTTP transport for sessionId", sessionId);
+                    transport = transports[sessionId];
+                }
+                else if (!sessionId && isInitializeRequest(req.body)) {
+                    // New initialization request
+                    transport = new StreamableHTTPServerTransport({
+                        sessionIdGenerator: () => randomUUID(),
+                        onsessioninitialized: (sessionId) => {
+                            // Store the transport by session ID
+                            Logger.log(`[StreamableHTTP connection] ${sessionId}`);
+                            transports[sessionId] = transport;
+                        }
+                    });
+                    // Clean up transport and server when closed
+                    transport.onclose = () => {
+                        if (transport.sessionId) {
+                            Logger.log(`[StreamableHTTP delete] ${transports[transport.sessionId]}`);
+                            delete transports[transport.sessionId];
+                        }
+                    };
+                    // Create and connect server instance
+                    const server = new FeishuMcp();
+                    await server.connect(transport);
+                }
+                else {
+                    // Invalid request
+                    res.status(400).json({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32000,
+                            message: 'Bad Request: No valid session ID provided',
+                        },
+                        id: null,
+                    });
+                    return;
+                }
+                // Handle the request
+                await transport.handleRequest(req, res, req.body);
+            }
+            catch (error) {
+                console.error('Error handling MCP request:', error);
+                if (!res.headersSent) {
+                    res.status(500).json({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32603,
+                            message: 'Internal server error',
+                        },
+                        id: null,
+                    });
+                }
+            }
+        });
+        // Handle GET requests for server-to-client notifications via Streamable HTTP
+        app.get('/mcp', async (req, res) => {
+            try {
+                Logger.log("Received StreamableHTTP request get");
+                const sessionId = req.headers['mcp-session-id'];
+                if (!sessionId || !transports[sessionId]) {
+                    res.status(400).send('Invalid or missing session ID');
+                    return;
+                }
+                const transport = transports[sessionId];
+                await transport.handleRequest(req, res);
+            }
+            catch (error) {
+                console.error('Error handling GET request:', error);
+                if (!res.headersSent) {
+                    res.status(500).send('Internal server error');
+                }
+            }
+        });
+        // Handle DELETE requests for session termination
+        app.delete('/mcp', async (req, res) => {
+            try {
+                const sessionId = req.headers['mcp-session-id'];
+                if (!sessionId || !transports[sessionId]) {
+                    res.status(400).send('Invalid or missing session ID');
+                    return;
+                }
+                const transport = transports[sessionId];
+                await transport.handleRequest(req, res);
+                // Clean up resources after session termination
+                if (transport.sessionId) {
+                    delete transports[transport.sessionId];
+                }
+            }
+            catch (error) {
+                console.error('Error handling DELETE request:', error);
+                if (!res.headersSent) {
+                    res.status(500).send('Internal server error');
+                }
+            }
+        });
         app.get('/sse', async (req, res) => {
             const sseTransport = new SSEServerTransport('/messages', res);
             const sessionId = sseTransport.sessionId;
@@ -82,10 +197,11 @@ export class FeishuMcpServer {
                 res.status(500).json({ code: 500, msg: e.message || '获取token失败' });
             }
         });
-        app.listen(port, () => {
+        app.listen(port, '0.0.0.0', () => {
             Logger.info(`HTTP server listening on port ${port}`);
             Logger.info(`SSE endpoint available at http://localhost:${port}/sse`);
             Logger.info(`Message endpoint available at http://localhost:${port}/messages`);
+            Logger.info(`StreamableHTTP endpoint available at http://localhost:${port}/mcp`);
         });
     }
 }

package/dist/services/baseService.js

@@ -2,6 +2,8 @@ import axios, { AxiosError } from 'axios';
 import FormData from 'form-data';
 import { Logger } from '../utils/logger.js';
 import { formatErrorMessage } from '../utils/error.js';
+import { CacheManager } from '../utils/cache.js';
+import { Config } from '../utils/config.js';
 /**
  * API服务基类
  * 提供通用的HTTP请求处理和认证功能
@@ -135,7 +137,9 @@ export class BaseApiService {
                 // 清除当前令牌，下次请求会重新获取
                 this.accessToken = '';
                 this.tokenExpireTime = null;
-                Logger.warn('访问令牌可能已过期，已清除缓存的令牌');
+                Logger.warn(`访问令牌可能已过期，已清除缓存的令牌`);
+                const clientKey = await CacheManager.getClientKey(Config.getInstance().feishu.appId, Config.getInstance().feishu.appSecret);
+                CacheManager.getInstance().removeUserToken(clientKey);
                 // 如果这是重试请求，避免无限循环
                 if (error.isRetry) {
                     this.handleApiError(error, `API请求失败 (${endpoint})`);

package/dist/services/blockFactory.js

@@ -9,6 +9,7 @@ export var BlockType;
     BlockType["HEADING"] = "heading";
     BlockType["LIST"] = "list";
     BlockType["IMAGE"] = "image";
+    BlockType["MERMAID"] = "mermaid";
 })(BlockType || (BlockType = {}));
 /**
  * 对齐方式枚举
@@ -75,6 +76,8 @@ export class BlockFactory {
                 return this.createListBlock(options);
             case BlockType.IMAGE:
                 return this.createImageBlock(options);
+            case BlockType.MERMAID:
+                return this.createMermaidBlock(options);
             default:
                 Logger.error(`不支持的块类型: ${type}`);
                 throw new Error(`不支持的块类型: ${type}`);
@@ -225,4 +228,110 @@ export class BlockFactory {
             }
         };
     }
+    /**
+     * 创建Mermaid
+     * @param options Mermaid块选项
+     * @returns Mermaid块内容对象
+     */
+    createMermaidBlock(options = {}) {
+        const { code } = options;
+        return {
+            block_type: 40,
+            add_ons: {
+                component_id: '',
+                component_type_id: 'blk_631fefbbae02400430b8f9f4',
+                record: JSON.stringify({
+                    data: code,
+                }),
+            },
+        };
+    }
+    /**
+     * 创建表格块
+     * @param options 表格块选项
+     * @returns 表格块内容对象
+     */
+    createTableBlock(options) {
+        const { columnSize, rowSize, cells = [] } = options;
+        // 生成表格ID
+        const tableId = `table_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const imageBlocks = Array();
+        // 创建表格单元格
+        const tableCells = [];
+        const descendants = [];
+        for (let row = 0; row < rowSize; row++) {
+            for (let col = 0; col < columnSize; col++) {
+                const cellId = `table_cell${row}_${col}`;
+                // 查找是否有配置的单元格内容
+                const cellConfigs = cells.filter(cell => cell.coordinate.row === row && cell.coordinate.column === col);
+                // 创建单元格内容
+                const cellContentBlocks = [];
+                const cellContentIds = [];
+                if (cellConfigs.length > 0) {
+                    // 处理多个内容块
+                    cellConfigs.forEach((cellConfig, index) => {
+                        const cellContentId = `${cellId}_child_${index}`;
+                        const cellContentBlock = {
+                            block_id: cellContentId,
+                            ...cellConfig.content,
+                            children: []
+                        };
+                        cellContentBlocks.push(cellContentBlock);
+                        cellContentIds.push(cellContentId);
+                        Logger.info(`处理块：${JSON.stringify(cellConfig)}  ${index}`);
+                        if (cellConfig.content.block_type === 27) {
+                            //把图片块保存起来，用于后续获取该图片块的token
+                            imageBlocks.push({
+                                coordinate: cellConfig.coordinate,
+                                localBlockId: cellContentId,
+                            });
+                        }
+                    });
+                }
+                else {
+                    // 创建空的文本块
+                    const cellContentId = `${cellId}_child`;
+                    const cellContentBlock = {
+                        block_id: cellContentId,
+                        ...this.createTextBlock({
+                            textContents: [{ text: "" }]
+                        }),
+                        children: []
+                    };
+                    cellContentBlocks.push(cellContentBlock);
+                    cellContentIds.push(cellContentId);
+                }
+                // 创建表格单元格块
+                const tableCell = {
+                    block_id: cellId,
+                    block_type: 32, // 表格单元格类型
+                    table_cell: {},
+                    children: cellContentIds
+                };
+                tableCells.push(cellId);
+                descendants.push(tableCell);
+                descendants.push(...cellContentBlocks);
+            }
+        }
+        // 创建表格主体
+        const tableBlock = {
+            block_id: tableId,
+            block_type: 31, // 表格块类型
+            table: {
+                property: {
+                    row_size: rowSize,
+                    column_size: columnSize
+                }
+            },
+            children: tableCells
+        };
+        descendants.unshift(tableBlock);
+        // 过滤并记录 block_type 为 27 的元素
+        Logger.info(`发现 ${imageBlocks.length} 个图片块 (block_type: 27):  ${JSON.stringify(imageBlocks)}`);
+        return {
+            children_id: [tableId],
+            descendants: descendants,
+            imageBlocks: imageBlocks
+        };
+    }
 }

package/dist/services/feishuApiService.js

@@ -382,6 +382,120 @@ export class FeishuApiService extends BaseApiService {
         });
         return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
     }
+    /**
+     * 创建Mermaid块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param mermaidCode Mermaid代码
+     * @param index 插入位置索引
+     * @returns 创建结果
+     */
+    async createMermaidBlock(documentId, parentBlockId, mermaidCode, index = 0) {
+        const normalizedDocId = ParamUtils.processDocumentId(documentId);
+        const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/children?document_revision_id=-1`;
+        const blockContent = {
+            block_type: 40,
+            add_ons: {
+                component_id: "",
+                component_type_id: "blk_631fefbbae02400430b8f9f4",
+                record: JSON.stringify({
+                    data: mermaidCode,
+                })
+            }
+        };
+        const payload = {
+            children: [blockContent],
+            index
+        };
+        Logger.info(`请求创建Mermaid块: ${JSON.stringify(payload).slice(0, 500)}...`);
+        const response = await this.post(endpoint, payload);
+        return response;
+    }
+    /**
+     * 创建表格块
+     * @param documentId 文档ID或URL
+     * @param parentBlockId 父块ID
+     * @param tableConfig 表格配置
+     * @param index 插入位置索引
+     * @returns 创建结果
+     */
+    async createTableBlock(documentId, parentBlockId, tableConfig, index = 0) {
+        const normalizedDocId = ParamUtils.processDocumentId(documentId);
+        const endpoint = `/docx/v1/documents/${normalizedDocId}/blocks/${parentBlockId}/descendant?document_revision_id=-1`;
+        // 处理表格配置，为每个单元格创建正确的内容块
+        const processedTableConfig = {
+            ...tableConfig,
+            cells: tableConfig.cells?.map(cell => ({
+                ...cell,
+                content: this.createBlockContent(cell.content.blockType, cell.content.options)
+            }))
+        };
+        // 使用 BlockFactory 创建表格块内容
+        const tableStructure = this.blockFactory.createTableBlock(processedTableConfig);
+        const payload = {
+            children_id: tableStructure.children_id,
+            descendants: tableStructure.descendants,
+            index
+        };
+        Logger.info(`请求创建表格块: ${tableConfig.rowSize}x${tableConfig.columnSize}，单元格数量: ${tableConfig.cells?.length || 0}`);
+        const response = await this.post(endpoint, payload);
+        // 创建表格成功后，获取单元格中的图片token
+        const imageTokens = await this.extractImageTokensFromTable(response, tableStructure.imageBlocks);
+        return {
+            ...response,
+            imageTokens: imageTokens
+        };
+    }
+    /**
+     * 从表格中提取图片块信息（优化版本）
+     * @param tableResponse 创建表格的响应数据
+     * @param cells 表格配置，包含原始cells信息
+     * @returns 图片块信息数组，包含坐标和块ID信息
+     */
+    async extractImageTokensFromTable(tableResponse, cells) {
+        try {
+            const imageTokens = [];
+            Logger.info(`tableResponse: ${JSON.stringify(tableResponse)}`);
+            // 判断 cells 是否为空
+            if (!cells || cells.length === 0) {
+                Logger.info('表格中没有图片单元格，跳过图片块信息提取');
+                return imageTokens;
+            }
+            // 创建 localBlockId 到 block_id 的映射
+            const blockIdMap = new Map();
+            if (tableResponse && tableResponse.block_id_relations) {
+                for (const relation of tableResponse.block_id_relations) {
+                    blockIdMap.set(relation.temporary_block_id, relation.block_id);
+                }
+                Logger.debug(`创建了 ${blockIdMap.size} 个块ID映射关系`);
+            }
+            // 遍历所有图片单元格
+            for (const cell of cells) {
+                const { coordinate, localBlockId } = cell;
+                const { row, column } = coordinate;
+                // 根据 localBlockId 在创建表格的返回数据中找到 block_id
+                const blockId = blockIdMap.get(localBlockId);
+                if (!blockId) {
+                    Logger.warn(`未找到 localBlockId ${localBlockId} 对应的 block_id`);
+                    continue;
+                }
+                Logger.debug(`处理单元格 (${row}, ${column})，localBlockId: ${localBlockId}，blockId: ${blockId}`);
+                // 直接添加块信息
+                imageTokens.push({
+                    row,
+                    column,
+                    blockId
+                });
+                Logger.info(`提取到图片块信息: 位置(${row}, ${column})，blockId: ${blockId}`);
+            }
+            Logger.info(`成功提取 ${imageTokens.length} 个图片块信息`);
+            return imageTokens;
+        }
+        catch (error) {
+            Logger.error(`提取表格图片块信息失败: ${error}`);
+            return [];
+        }
+    }
     /**
      * 删除文档中的块，支持批量删除
      * @param documentId 文档ID或URL
@@ -577,6 +691,14 @@ export class FeishuApiService extends BaseApiService {
                         };
                     }
                     break;
+                case BlockType.MERMAID:
+                    if ('mermaid' in options && options.mermaid) {
+                        const mermaidOptions = options.mermaid;
+                        blockConfig.options = {
+                            code: mermaidOptions.code,
+                        };
+                    }
+                    break;
                 default:
                     Logger.warn(`未知的块类型: ${blockType}，尝试作为标准类型处理`);
                     if ('text' in options) {
@@ -640,6 +762,13 @@ export class FeishuApiService extends BaseApiService {
                             height: imageOptions.height || 100
                         };
                     }
+                    else if ("mermaid" in options) {
+                        blockConfig.type = BlockType.MERMAID;
+                        const mermaidConfig = options.mermaid;
+                        blockConfig.options = {
+                            code: mermaidConfig.code,
+                        };
+                    }
                     break;
             }
             // 记录调试信息
@@ -955,15 +1084,7 @@ export class FeishuApiService extends BaseApiService {
      */
     async getWhiteboardContent(whiteboardId) {
         try {
-            // 从URL中提取画板ID
-            let normalizedWhiteboardId = whiteboardId;
-            if (whiteboardId.includes('feishu.cn/board/')) {
-                // 从URL中提取画板ID
-                const matches = whiteboardId.match(/board\/([^\/\?]+)/);
-                if (matches) {
-                    normalizedWhiteboardId = matches[1];
-                }
-            }
+            const normalizedWhiteboardId = ParamUtils.processWhiteboardId(whiteboardId);
             const endpoint = `/board/v1/whiteboards/${normalizedWhiteboardId}/nodes`;
             Logger.info(`开始获取画板内容，画板ID: ${normalizedWhiteboardId}`);
             const response = await this.get(endpoint);
@@ -974,6 +1095,27 @@ export class FeishuApiService extends BaseApiService {
             this.handleApiError(error, '获取画板内容失败');
         }
     }
+    /**
+     * 获取画板缩略图
+     * @param whiteboardId 画板ID或URL
+     * @returns 画板缩略图的二进制数据
+     */
+    async getWhiteboardThumbnail(whiteboardId) {
+        try {
+            const normalizedWhiteboardId = ParamUtils.processWhiteboardId(whiteboardId);
+            const endpoint = `/board/v1/whiteboards/${normalizedWhiteboardId}/download_as_image`;
+            Logger.info(`开始获取画板缩略图，画板ID: ${normalizedWhiteboardId}`);
+            // 使用通用的request方法获取二进制响应
+            const response = await this.request(endpoint, 'GET', {}, true, {}, 'arraybuffer');
+            const thumbnailBuffer = Buffer.from(response);
+            Logger.info(`画板缩略图获取成功，大小: ${thumbnailBuffer.length} 字节`);
+            return thumbnailBuffer;
+        }
+        catch (error) {
+            this.handleApiError(error, '获取画板缩略图失败');
+            return Buffer.from([]); // 永远不会执行到这里
+        }
+    }
     /**
      * 从路径或URL获取图片的Base64编码
      * @param imagePathOrUrl 图片路径或URL