feishu-mcp 0.2.2 → 0.2.7

package/dist/modules/document/services/blockFactory.js

@@ -0,0 +1,521 @@
+import { Logger } from '../../../utils/logger.js';
+/**
+ * 块类型枚举
+ */
+export var BlockType;
+(function (BlockType) {
+    BlockType["TEXT"] = "text";
+    BlockType["CODE"] = "code";
+    BlockType["HEADING"] = "heading";
+    BlockType["LIST"] = "list";
+    BlockType["IMAGE"] = "image";
+    BlockType["MERMAID"] = "mermaid";
+    BlockType["WHITEBOARD"] = "whiteboard";
+})(BlockType || (BlockType = {}));
+/**
+ * 对齐方式枚举
+ */
+export var AlignType;
+(function (AlignType) {
+    AlignType[AlignType["LEFT"] = 1] = "LEFT";
+    AlignType[AlignType["CENTER"] = 2] = "CENTER";
+    AlignType[AlignType["RIGHT"] = 3] = "RIGHT";
+})(AlignType || (AlignType = {}));
+/**
+ * 块工厂类
+ * 提供统一接口创建不同类型的块内容
+ */
+export class BlockFactory {
+    constructor() { }
+    /**
+     * 获取块工厂实例
+     * @returns 块工厂实例
+     */
+    static getInstance() {
+        if (!BlockFactory.instance) {
+            BlockFactory.instance = new BlockFactory();
+        }
+        return BlockFactory.instance;
+    }
+    /**
+     * 获取默认的文本元素样式
+     * @returns 默认文本元素样式
+     */
+    static getDefaultTextElementStyle() {
+        return {
+            bold: false,
+            inline_code: false,
+            italic: false,
+            strikethrough: false,
+            underline: false
+        };
+    }
+    /**
+     * 应用默认文本样式
+     * @param style 已有样式（可选）
+     * @returns 合并后的样式
+     */
+    static applyDefaultTextStyle(style) {
+        const defaultStyle = BlockFactory.getDefaultTextElementStyle();
+        return style ? { ...defaultStyle, ...style } : defaultStyle;
+    }
+    /**
+     * 创建块内容
+     * @param type 块类型
+     * @param options 块选项
+     * @returns 块内容对象
+     */
+    createBlock(type, options) {
+        switch (type) {
+            case BlockType.TEXT:
+                return this.createTextBlock(options);
+            case BlockType.CODE:
+                return this.createCodeBlock(options);
+            case BlockType.HEADING:
+                return this.createHeadingBlock(options);
+            case BlockType.LIST:
+                return this.createListBlock(options);
+            case BlockType.IMAGE:
+                return this.createImageBlock(options);
+            case BlockType.MERMAID:
+                return this.createMermaidBlock(options);
+            case BlockType.WHITEBOARD:
+                return this.createWhiteboardBlock(options);
+            default:
+                Logger.error(`不支持的块类型: ${type}`);
+                throw new Error(`不支持的块类型: ${type}`);
+        }
+    }
+    /**
+     * 创建文本块内容
+     * @param options 文本块选项
+     * @returns 文本块内容对象
+     */
+    createTextBlock(options) {
+        const { textContents, align = AlignType.LEFT } = options;
+        return {
+            block_type: 2, // 2表示文本块
+            text: {
+                elements: textContents.map(content => {
+                    // 检查是否是公式元素
+                    if ('equation' in content) {
+                        return {
+                            equation: {
+                                content: content.equation,
+                                text_element_style: BlockFactory.applyDefaultTextStyle(content.style)
+                            }
+                        };
+                    }
+                    else {
+                        // 普通文本元素
+                        return {
+                            text_run: {
+                                content: content.text,
+                                text_element_style: BlockFactory.applyDefaultTextStyle(content.style)
+                            }
+                        };
+                    }
+                }),
+                style: {
+                    align: align, // 1 居左，2 居中，3 居右
+                    folded: false
+                }
+            }
+        };
+    }
+    /**
+     * 创建代码块内容
+     * @param options 代码块选项
+     * @returns 代码块内容对象
+     */
+    createCodeBlock(options) {
+        const { code, language = 0, wrap = false } = options;
+        // 校验 language 合法性，飞书API只允许1~75
+        const safeLanguage = language >= 1 && language <= 75 ? language : 1;
+        return {
+            block_type: 14, // 14表示代码块
+            code: {
+                elements: [
+                    {
+                        text_run: {
+                            content: code,
+                            text_element_style: BlockFactory.getDefaultTextElementStyle()
+                        }
+                    }
+                ],
+                style: {
+                    language: safeLanguage,
+                    wrap: wrap
+                }
+            }
+        };
+    }
+    /**
+     * 创建标题块内容
+     * @param options 标题块选项
+     * @returns 标题块内容对象
+     */
+    createHeadingBlock(options) {
+        const { text, level = 1, align = AlignType.LEFT } = options;
+        // 确保标题级别在有效范围内（1-9）
+        const safeLevel = Math.max(1, Math.min(9, level));
+        // 根据标题级别设置block_type和对应的属性名
+        // 飞书API中，一级标题的block_type为3，二级标题为4，以此类推
+        const blockType = 2 + safeLevel; // 一级标题为3，二级标题为4，以此类推
+        const headingKey = `heading${safeLevel}`; // heading1, heading2, ...
+        // 构建块内容
+        const blockContent = {
+            block_type: blockType
+        };
+        // 设置对应级别的标题属性
+        blockContent[headingKey] = {
+            elements: [
+                {
+                    text_run: {
+                        content: text,
+                        text_element_style: BlockFactory.getDefaultTextElementStyle()
+                    }
+                }
+            ],
+            style: {
+                align: align,
+                folded: false
+            }
+        };
+        return blockContent;
+    }
+    /**
+     * 创建列表块内容（有序或无序）
+     * @param options 列表块选项
+     * @returns 列表块内容对象
+     */
+    createListBlock(options) {
+        const { text, isOrdered = false, align = AlignType.LEFT } = options;
+        // 有序列表是 block_type: 13，无序列表是 block_type: 12
+        const blockType = isOrdered ? 13 : 12;
+        const propertyKey = isOrdered ? "ordered" : "bullet";
+        // 构建块内容
+        const blockContent = {
+            block_type: blockType
+        };
+        // 设置列表属性
+        blockContent[propertyKey] = {
+            elements: [
+                {
+                    text_run: {
+                        content: text,
+                        text_element_style: BlockFactory.getDefaultTextElementStyle()
+                    }
+                }
+            ],
+            style: {
+                align: align,
+                folded: false
+            }
+        };
+        return blockContent;
+    }
+    /**
+     * 创建图片块内容（空图片块，需要后续设置图片资源）
+     * @param options 图片块选项
+     * @returns 图片块内容对象
+     */
+    createImageBlock(options = {}) {
+        const { width = 100, height = 100 } = options;
+        return {
+            block_type: 27, // 27表示图片块
+            image: {
+                width: width,
+                height: height,
+                token: "" // 空token，需要后续通过API设置
+            }
+        };
+    }
+    /**
+     * 创建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 画板块内容对象
+     */
+    createWhiteboardBlock(options = {}) {
+        const { align = AlignType.CENTER } = options;
+        return {
+            block_type: 43, // 43表示画板块
+            board: {
+                align: align // 1 居左，2 居中，3 居右
+            }
+        };
+    }
+    /**
+     * 根据 blockType 字符串和 options 对象创建块内容
+     * 将 MCP 工具传入的高级选项转换为 BlockFactory.createBlock 所需格式
+     */
+    createBlockContentFromOptions(blockType, options) {
+        try {
+            // 处理特殊的 heading 格式，如 heading1, heading2 等
+            if (typeof blockType === 'string' && blockType.startsWith('heading')) {
+                const headingMatch = blockType.match(/^heading([1-9])$/);
+                if (headingMatch) {
+                    const level = parseInt(headingMatch[1], 10);
+                    if (level >= 1 && level <= 9) {
+                        if (!options || Object.keys(options).length === 0) {
+                            options = { heading: { level, content: '', align: 1 } };
+                        }
+                        else if (!('heading' in options)) {
+                            options = { heading: { level, content: '', align: 1 } };
+                        }
+                        else if (options.heading && !('level' in options.heading)) {
+                            options.heading.level = level;
+                        }
+                        blockType = BlockType.HEADING;
+                        Logger.info(`转换特殊标题格式: heading${level} -> standard heading with level=${level}`);
+                    }
+                }
+            }
+            const blockTypeEnum = blockType;
+            const blockConfig = {
+                type: blockTypeEnum,
+                options: {}
+            };
+            switch (blockTypeEnum) {
+                case BlockType.TEXT:
+                    if ('text' in options && options.text) {
+                        const textOptions = options.text;
+                        const textStyles = textOptions.textStyles || [];
+                        const processedTextStyles = textStyles.map((item) => {
+                            if (item.equation !== undefined) {
+                                return { equation: item.equation, style: BlockFactory.applyDefaultTextStyle(item.style) };
+                            }
+                            return { text: item.text || '', style: BlockFactory.applyDefaultTextStyle(item.style) };
+                        });
+                        blockConfig.options = { textContents: processedTextStyles, align: textOptions.align || 1 };
+                    }
+                    break;
+                case BlockType.CODE:
+                    if ('code' in options && options.code) {
+                        const codeOptions = options.code;
+                        blockConfig.options = {
+                            code: codeOptions.code || '',
+                            language: codeOptions.language === 0 ? 0 : (codeOptions.language || 0),
+                            wrap: codeOptions.wrap || false
+                        };
+                    }
+                    break;
+                case BlockType.HEADING:
+                    if ('heading' in options && options.heading) {
+                        const headingOptions = options.heading;
+                        blockConfig.options = {
+                            text: headingOptions.content || '',
+                            level: headingOptions.level || 1,
+                            align: [1, 2, 3].includes(headingOptions.align) ? headingOptions.align : 1
+                        };
+                    }
+                    break;
+                case BlockType.LIST:
+                    if ('list' in options && options.list) {
+                        const listOptions = options.list;
+                        blockConfig.options = {
+                            text: listOptions.content || '',
+                            isOrdered: listOptions.isOrdered || false,
+                            align: [1, 2, 3].includes(listOptions.align) ? listOptions.align : 1
+                        };
+                    }
+                    break;
+                case BlockType.IMAGE:
+                    if ('image' in options && options.image) {
+                        const imageOptions = options.image;
+                        blockConfig.options = { width: imageOptions.width || 100, height: imageOptions.height || 100 };
+                    }
+                    else {
+                        blockConfig.options = { width: 100, height: 100 };
+                    }
+                    break;
+                case BlockType.MERMAID:
+                    if ('mermaid' in options && options.mermaid) {
+                        blockConfig.options = { code: options.mermaid.code };
+                    }
+                    break;
+                case BlockType.WHITEBOARD:
+                    if ('whiteboard' in options && options.whiteboard) {
+                        const whiteboardOptions = options.whiteboard;
+                        blockConfig.options = {
+                            align: [1, 2, 3].includes(whiteboardOptions.align) ? whiteboardOptions.align : 1
+                        };
+                    }
+                    else {
+                        blockConfig.options = { align: 1 };
+                    }
+                    break;
+                default:
+                    Logger.warn(`未知的块类型: ${blockType}，尝试作为标准类型处理`);
+                    if ('text' in options) {
+                        blockConfig.type = BlockType.TEXT;
+                        const textOptions = options.text;
+                        const textStyles = textOptions.textStyles || [];
+                        const processedTextStyles = textStyles.map((item) => {
+                            if (item.equation !== undefined) {
+                                return { equation: item.equation, style: BlockFactory.applyDefaultTextStyle(item.style) };
+                            }
+                            return { text: item.text || '', style: BlockFactory.applyDefaultTextStyle(item.style) };
+                        });
+                        blockConfig.options = { textContents: processedTextStyles, align: textOptions.align || 1 };
+                    }
+                    else if ('code' in options) {
+                        blockConfig.type = BlockType.CODE;
+                        const codeOptions = options.code;
+                        blockConfig.options = {
+                            code: codeOptions.code || '',
+                            language: codeOptions.language === 0 ? 0 : (codeOptions.language || 0),
+                            wrap: codeOptions.wrap || false
+                        };
+                    }
+                    else if ('heading' in options) {
+                        blockConfig.type = BlockType.HEADING;
+                        const headingOptions = options.heading;
+                        blockConfig.options = {
+                            text: headingOptions.content || '',
+                            level: headingOptions.level || 1,
+                            align: [1, 2, 3].includes(headingOptions.align) ? headingOptions.align : 1
+                        };
+                    }
+                    else if ('list' in options) {
+                        blockConfig.type = BlockType.LIST;
+                        const listOptions = options.list;
+                        blockConfig.options = {
+                            text: listOptions.content || '',
+                            isOrdered: listOptions.isOrdered || false,
+                            align: [1, 2, 3].includes(listOptions.align) ? listOptions.align : 1
+                        };
+                    }
+                    else if ('image' in options) {
+                        blockConfig.type = BlockType.IMAGE;
+                        const imageOptions = options.image;
+                        blockConfig.options = { width: imageOptions.width || 100, height: imageOptions.height || 100 };
+                    }
+                    else if ('mermaid' in options) {
+                        blockConfig.type = BlockType.MERMAID;
+                        blockConfig.options = { code: options.mermaid.code };
+                    }
+                    else if ('whiteboard' in options) {
+                        blockConfig.type = BlockType.WHITEBOARD;
+                        const whiteboardConfig = options.whiteboard;
+                        blockConfig.options = {
+                            align: [1, 2, 3].includes(whiteboardConfig.align) ? whiteboardConfig.align : 1
+                        };
+                    }
+                    break;
+            }
+            Logger.debug(`创建块内容: 类型=${blockConfig.type}, 选项=${JSON.stringify(blockConfig.options)}`);
+            return this.createBlock(blockConfig.type, blockConfig.options);
+        }
+        catch (error) {
+            Logger.error(`创建块内容对象失败: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * 创建表格块
+     * @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/modules/document/toolApi/blockToolApi.js

@@ -0,0 +1,160 @@
+import { Logger } from '../../../utils/logger.js';
+import { BlockTextUpdatesArraySchema, WhiteboardFillArraySchema, } from '../../../types/documentSchema.js';
+import { WHITEBOARD_NODE_THUMBNAIL_THRESHOLD, BATCH_SIZE, prepareBlockContents, extractSpecialBlocks, buildSpecialBlockHints, extractFeishuApiError, } from '../tools/toolHelpers.js';
+export async function batchUpdateBlockText(params, api) {
+    const parsed = BlockTextUpdatesArraySchema.safeParse(params.updates);
+    if (!parsed.success)
+        throw new Error(`参数校验失败: ${parsed.error.message}`);
+    Logger.info(`batchUpdateBlockText invoked: documentId=${params.documentId}, count=${parsed.data.length}`);
+    const result = await api.batchUpdateBlocksTextContent(params.documentId, parsed.data);
+    return {
+        updatedCount: parsed.data.length,
+        blockIds: parsed.data.map((u) => u.blockId),
+        document_revision_id: result?.document_revision_id,
+    };
+}
+export async function batchCreateBlocks(params, api) {
+    if (typeof params.blocks === 'string') {
+        throw new Error('错误：blocks 参数传入了字符串而不是数组，请直接传入 JSON 数组。\n' +
+            '正确：blocks:[{blockType:"text",options:{...}}]\n' +
+            '错误：blocks:"[{blockType:\\"text\\"...}]"');
+    }
+    const { documentId, parentBlockId, index = 0, blocks } = params;
+    const totalBatches = Math.ceil(blocks.length / BATCH_SIZE);
+    const results = [];
+    let createdBlocksCount = 0;
+    let currentStartIndex = index;
+    Logger.info(`batchCreateBlocks invoked: documentId=${documentId}, blocks=${blocks.length}, batches=${totalBatches}`);
+    for (let batchNum = 0; batchNum < totalBatches; batchNum++) {
+        const currentBatch = blocks.slice(batchNum * BATCH_SIZE, (batchNum + 1) * BATCH_SIZE);
+        const prepared = prepareBlockContents(currentBatch, api);
+        if (!prepared.ok) {
+            const errText = prepared.error.content?.[0]?.text ?? 'prepareBlockContents failed';
+            throw new Error(errText);
+        }
+        const batchResult = await api.createDocumentBlocks(documentId, parentBlockId, prepared.contents, currentStartIndex);
+        results.push(batchResult);
+        createdBlocksCount += prepared.contents.length;
+        currentStartIndex = index + createdBlocksCount;
+    }
+    const allChildren = results.flatMap((r) => r.children ?? []);
+    const { imageBlocks, whiteboardBlocks } = extractSpecialBlocks(allChildren);
+    const hints = buildSpecialBlockHints(imageBlocks, whiteboardBlocks);
+    return {
+        totalBlocksCreated: createdBlocksCount,
+        nextIndex: currentStartIndex,
+        document_revision_id: results[results.length - 1]?.document_revision_id,
+        ...hints,
+    };
+}
+export async function deleteDocumentBlocks(params, api) {
+    Logger.info(`deleteDocumentBlocks invoked: documentId=${params.documentId}, range=${params.startIndex}-${params.endIndex}`);
+    const result = await api.deleteDocumentBlocks(params.documentId, params.parentBlockId, params.startIndex, params.endIndex);
+    return {
+        deletedRange: { startIndex: params.startIndex, endIndex: params.endIndex },
+        document_revision_id: result.document_revision_id,
+    };
+}
+export async function getImageResource(mediaId, extra, api) {
+    Logger.info(`getImageResource invoked: mediaId=${mediaId}`);
+    return api.getImageResource(mediaId, extra);
+}
+export async function uploadAndBindImageToBlock(params, api) {
+    Logger.info(`uploadAndBindImageToBlock invoked: documentId=${params.documentId}, count=${params.images.length}`);
+    const results = [];
+    for (const { blockId, imagePathOrUrl, fileName } of params.images) {
+        try {
+            const { base64: imageBase64, fileName: detectedFileName } = await api.getImageBase64FromPathOrUrl(imagePathOrUrl);
+            const finalFileName = fileName || detectedFileName;
+            const uploadResult = await api.uploadImageMedia(imageBase64, finalFileName, blockId);
+            if (!uploadResult?.file_token)
+                throw new Error('上传图片素材失败：无法获取file_token');
+            const setContentResult = await api.setImageBlockContent(params.documentId, blockId, uploadResult.file_token);
+            const { client_token: _ct, ...blockResult } = setContentResult?.block ?? {};
+            results.push({
+                blockId,
+                fileToken: uploadResult.file_token,
+                block: blockResult,
+                document_revision_id: setContentResult.document_revision_id,
+            });
+        }
+        catch (err) {
+            Logger.error(`上传图片并绑定到块失败 blockId=${blockId}:`, err);
+            results.push({ blockId, error: err.message });
+        }
+    }
+    return results;
+}
+export async function createTable(params, api) {
+    Logger.info(`createTable invoked: documentId=${params.documentId}, size=${params.tableConfig.rowSize}x${params.tableConfig.columnSize}`);
+    const result = await api.createTableBlock(params.documentId, params.parentBlockId, params.tableConfig, params.index ?? 0);
+    const relations = result.block_id_relations ?? [];
+    const cellMap = [];
+    const tableBlockId = relations.find((r) => /^table_\d/.test(r.temporary_block_id))?.block_id;
+    for (const rel of relations) {
+        const m = rel.temporary_block_id.match(/^table_cell(\d+)_(\d+)$/);
+        if (m)
+            cellMap.push({ row: Number(m[1]), column: Number(m[2]), cellBlockId: rel.block_id });
+    }
+    const response = {
+        document_revision_id: result.document_revision_id,
+        tableBlockId,
+        cells: cellMap,
+    };
+    if (result.imageTokens?.length > 0) {
+        response.imageBlocks = result.imageTokens.map((t) => ({
+            row: t.row,
+            column: t.column,
+            blockId: t.blockId,
+        }));
+        response.imageReminder =
+            'Use upload_and_bind_image_to_block to bind images to the listed blockIds.';
+    }
+    return response;
+}
+export async function getWhiteboardContent(whiteboardId, api) {
+    Logger.info(`getWhiteboardContent invoked: whiteboardId=${whiteboardId}`);
+    const whiteboardContent = await api.getWhiteboardContent(whiteboardId);
+    const nodeCount = whiteboardContent.nodes?.length ?? 0;
+    if (nodeCount > WHITEBOARD_NODE_THUMBNAIL_THRESHOLD) {
+        try {
+            const thumbnailBuffer = await api.getWhiteboardThumbnail(whiteboardId);
+            return { type: 'thumbnail', buffer: thumbnailBuffer };
+        }
+        catch {
+            // fallback to content
+        }
+    }
+    return { type: 'content', content: whiteboardContent };
+}
+export async function fillWhiteboardWithPlantuml(params, api) {
+    const parsed = WhiteboardFillArraySchema.safeParse(params.whiteboards);
+    if (!parsed.success)
+        throw new Error(`参数校验失败: ${parsed.error.message}`);
+    if (parsed.data.length === 0)
+        throw new Error('错误：画板数组不能为空');
+    Logger.info(`fillWhiteboardWithPlantuml invoked: count=${parsed.data.length}`);
+    const results = [];
+    let successCount = 0;
+    let failCount = 0;
+    for (const { whiteboardId, code, syntax_type } of parsed.data) {
+        const syntaxTypeNumber = syntax_type === 'plantuml' ? 1 : 2;
+        const syntaxTypeName = syntax_type === 'plantuml' ? 'PlantUML' : 'Mermaid';
+        try {
+            const result = await api.createDiagramNode(whiteboardId, code, syntaxTypeNumber);
+            successCount++;
+            results.push({ whiteboardId, syntaxType: syntaxTypeName, status: 'success', nodeId: result.node_id });
+        }
+        catch (err) {
+            failCount++;
+            const { message, code: errorCode, logId } = extractFeishuApiError(err);
+            results.push({
+                whiteboardId,
+                syntaxType: syntaxTypeName,
+                status: 'failed',
+                error: { message, code: errorCode, logId },
+            });
+        }
+    }
+    return { total: parsed.data.length, success: successCount, failed: failCount, results };
+}