@liselvins/lark-mcp 0.1.0

package/dist/mcp-tool/tools/en/builtin-tools/docx/block-tools.js

@@ -0,0 +1,686 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.docxBlockTools = exports.larkDocxFillWhiteboardTool = exports.larkDocxUploadImageTool = exports.larkDocxCreateTableTool = exports.larkDocxDeleteBlocksTool = exports.larkDocxUpdateBlockTextTool = exports.larkDocxBatchCreateBlocksTool = exports.larkDocxGetDocumentBlocksTool = void 0;
+const lark = __importStar(require("@larksuiteoapi/node-sdk"));
+const stream_1 = require("stream");
+const zod_1 = require("zod");
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const block_factory_1 = require("./block-factory");
+// ─── Zod Schemas ──────────────────────────────────────────────────────────────
+const DocumentIdSchema = zod_1.z.string().describe('Document ID or URL. Supports: https://xxx.feishu.cn/docx/xxx, https://xxx.feishu.cn/docs/xxx, or direct ID.');
+const ParentBlockIdSchema = zod_1.z.string().describe('Parent block ID. For page-level (root) insertion, use the document ID itself. Get block IDs via docx.builtin.getDocumentBlocks.');
+const BlockIdSchema = zod_1.z.string().describe('Block ID of the specific block to operate on. Get block IDs via docx.builtin.getDocumentBlocks.');
+const IndexSchema = zod_1.z.number().describe('Insertion position index relative to the parent block\'s children array. 0 = insert at the beginning. For consecutive insertions, increment by 1.');
+const TextStyleSchema = zod_1.z
+    .object({
+    bold: zod_1.z.boolean().optional().describe('Bold text'),
+    italic: zod_1.z.boolean().optional().describe('Italic text'),
+    underline: zod_1.z.boolean().optional().describe('Underline text'),
+    strikethrough: zod_1.z.boolean().optional().describe('Strikethrough text'),
+    inline_code: zod_1.z.boolean().optional().describe('Inline code'),
+    text_color: zod_1.z
+        .number()
+        .optional()
+        .describe('Text color: 0=black, 1=gray, 2=brown, 3=orange, 4=yellow, 5=green, 6=blue, 7=purple'),
+    background_color: zod_1.z
+        .number()
+        .optional()
+        .describe('Background color: 1=gray, 2=brown, 3=orange, 4=yellow, 5=green, 6=blue, 7=purple'),
+})
+    .optional();
+const TextElementSchema = zod_1.z.union([
+    zod_1.z.object({ text: zod_1.z.string().describe('Text content'), style: TextStyleSchema }),
+    zod_1.z.object({ equation: zod_1.z.string().describe('LaTeX equation content'), style: TextStyleSchema }),
+]);
+const BlockConfigSchema = zod_1.z.object({
+    blockType: zod_1.z.string().describe("Block type: 'text', 'code', 'heading', 'list', 'image', 'mermaid', 'whiteboard', or 'heading1'-'heading9'."),
+    options: zod_1.z
+        .union([
+        zod_1.z.object({
+            text: zod_1.z.object({
+                textStyles: zod_1.z.array(TextElementSchema).describe('Array of text segments with styles'),
+                align: zod_1.z.number().optional().default(1).describe('Alignment: 1=left, 2=center, 3=right'),
+            }),
+        }),
+        zod_1.z.object({
+            code: zod_1.z.object({
+                code: zod_1.z.string().describe('Code content'),
+                language: zod_1.z
+                    .number()
+                    .optional()
+                    .default(1)
+                    .describe('Language code: 1=PlainText, 7=Bash, 10=C, 22=Go, 29=Java, 30=JavaScript, 49=Python, 53=Rust, 56=SQL, 63=TypeScript'),
+                wrap: zod_1.z.boolean().optional().default(false).describe('Auto line wrap'),
+            }),
+        }),
+        zod_1.z.object({
+            heading: zod_1.z.object({
+                level: zod_1.z.number().min(1).max(9).describe('Heading level 1-9'),
+                content: zod_1.z.string().describe('Heading text'),
+                align: zod_1.z.number().optional().default(1),
+            }),
+        }),
+        zod_1.z.object({
+            list: zod_1.z.object({
+                content: zod_1.z.string().describe('List item text'),
+                isOrdered: zod_1.z.boolean().optional().default(false).describe('true=ordered, false=bullet'),
+                align: zod_1.z.number().optional().default(1),
+            }),
+        }),
+        zod_1.z.object({
+            image: zod_1.z.object({
+                width: zod_1.z.number().optional().describe('Image width in pixels'),
+                height: zod_1.z.number().optional().describe('Image height in pixels'),
+            }),
+        }),
+        zod_1.z.object({
+            mermaid: zod_1.z.object({
+                code: zod_1.z.string().describe('Mermaid diagram code'),
+            }),
+        }),
+        zod_1.z.object({
+            whiteboard: zod_1.z.object({
+                align: zod_1.z.number().optional().default(2).describe('Whiteboard alignment: 1=left, 2=center, 3=right'),
+            }),
+        }),
+        zod_1.z.record(zod_1.z.any()),
+    ])
+        .describe('Options for the specific block type'),
+});
+const TableCellContentSchema = zod_1.z.object({
+    coordinate: zod_1.z.object({
+        row: zod_1.z.number().min(0).describe('Row (0-based)'),
+        column: zod_1.z.number().min(0).describe('Column (0-based)'),
+    }),
+    content: BlockConfigSchema,
+});
+const TableCreateSchema = zod_1.z.object({
+    columnSize: zod_1.z.number().min(1).describe('Number of columns'),
+    rowSize: zod_1.z.number().min(1).describe('Number of rows'),
+    cells: zod_1.z
+        .array(TableCellContentSchema)
+        .optional()
+        .describe('Cell configurations. Multiple entries with same coordinates create multi-block cells.'),
+});
+const ImagesArraySchema = zod_1.z.array(zod_1.z.object({
+    blockId: BlockIdSchema,
+    imagePathOrUrl: zod_1.z.string().describe('Local file path or HTTP/HTTPS URL of the image'),
+    fileName: zod_1.z.string().optional().describe('Image file name (e.g. "image.png")'),
+})).describe('Array of image binding objects');
+const WhiteboardFillArraySchema = zod_1.z.array(zod_1.z.object({
+    whiteboardId: zod_1.z.string().describe('Whiteboard ID (the token from board.token field)'),
+    code: zod_1.z.string().describe('PlantUML or Mermaid diagram code'),
+    syntax_type: zod_1.z.number().describe('1=PlantUML, 2=Mermaid'),
+})).describe('Array of whiteboard fill items');
+// ─── Helper ───────────────────────────────────────────────────────────────────
+function extractDocumentId(input) {
+    // Try URL patterns
+    const urlPattern = /\/(?:docx|docs)\/([a-zA-Z0-9_-]{10,})/;
+    const match = input.match(urlPattern);
+    if (match)
+        return match[1];
+    // Direct ID
+    if (/^[a-zA-Z0-9_-]{10,}$/.test(input))
+        return input;
+    return input;
+}
+// ─── Tool: getDocumentBlocks ──────────────────────────────────────────────────
+exports.larkDocxGetDocumentBlocksTool = {
+    project: 'docx',
+    name: 'docx.builtin.getDocumentBlocks',
+    accessTokens: ['user', 'tenant'],
+    description: '[Feishu/Lark]-Docs-Document-Get Document Blocks-Retrieves the complete block structure of a document. Use this before editing to understand the document layout, get block IDs, and determine insertion positions.',
+    schema: {
+        data: zod_1.z.object({
+            document_id: DocumentIdSchema,
+            page_size: zod_1.z.number().optional().default(500).describe('Number of blocks per page (max 500)'),
+            page_token: zod_1.z.string().optional().describe('Pagination token from previous response'),
+        }),
+        useUAT: zod_1.z.boolean().optional().describe('Whether to use user access token'),
+    },
+    customHandler: async (client, params, options) => {
+        var _a, _b;
+        try {
+            const { userAccessToken } = options || {};
+            const docId = extractDocumentId(params.data.document_id);
+            const allBlocks = [];
+            let pageToken = params.data.page_token;
+            let hasMore = true;
+            while (hasMore) {
+                const reqParams = { page_size: params.data.page_size || 500 };
+                if (pageToken)
+                    reqParams.page_token = pageToken;
+                const response = userAccessToken && params.useUAT
+                    ? await client.request({ method: 'GET', url: `/open-apis/docx/v1/documents/${docId}/blocks`, params: reqParams }, lark.withUserAccessToken(userAccessToken))
+                    : await client.request({
+                        method: 'GET',
+                        url: `/open-apis/docx/v1/documents/${docId}/blocks`,
+                        params: reqParams,
+                    });
+                const data = (_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : response;
+                if (data === null || data === void 0 ? void 0 : data.items)
+                    allBlocks.push(...data.items);
+                pageToken = data === null || data === void 0 ? void 0 : data.page_token;
+                hasMore = !!(data === null || data === void 0 ? void 0 : data.has_more) && !!pageToken;
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ items: allBlocks, total: allBlocks.length }) }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: JSON.stringify(((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) || (error === null || error === void 0 ? void 0 : error.message) || error) }],
+            };
+        }
+    },
+};
+// ─── Tool: batchCreateBlocks ──────────────────────────────────────────────────
+exports.larkDocxBatchCreateBlocksTool = {
+    project: 'docx',
+    name: 'docx.builtin.batchCreateBlocks',
+    accessTokens: ['user', 'tenant'],
+    description: '[Feishu/Lark]-Docs-Document-Batch Create Blocks-Creates multiple blocks (text, code, heading, list, image, mermaid, whiteboard) in a document. Auto-batches when >50 blocks. For image blocks, use docx.builtin.uploadImage afterwards to bind images. For whiteboard blocks, use docx.builtin.fillWhiteboard to fill content.',
+    schema: {
+        data: zod_1.z.object({
+            document_id: DocumentIdSchema,
+            parent_block_id: ParentBlockIdSchema,
+            index: IndexSchema,
+            blocks: zod_1.z
+                .array(BlockConfigSchema)
+                .describe('Array of block configurations. MUST be a JSON array, NOT a string.'),
+        }),
+        useUAT: zod_1.z.boolean().optional(),
+    },
+    customHandler: async (client, params, options) => {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            const { userAccessToken } = options || {};
+            const docId = extractDocumentId(params.data.document_id);
+            const parentBlockId = params.data.parent_block_id;
+            const startIndex = params.data.index;
+            const blocks = params.data.blocks;
+            if (typeof blocks === 'string') {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: 'ERROR: "blocks" was passed as a string. Provide a proper JSON array.' }],
+                };
+            }
+            const makeRequest = async (blockContents, index) => {
+                var _a;
+                const reqConfig = {
+                    method: 'POST',
+                    url: `/open-apis/docx/v1/documents/${docId}/blocks/${parentBlockId}/children`,
+                    params: { document_revision_id: -1 },
+                    data: { children: blockContents, index },
+                };
+                const response = userAccessToken && params.useUAT
+                    ? await client.request(reqConfig, lark.withUserAccessToken(userAccessToken))
+                    : await client.request(reqConfig);
+                return (_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : response;
+            };
+            // Build block contents
+            const allBlockContents = [];
+            for (const blockConfig of blocks) {
+                const content = (0, block_factory_1.createBlockContent)(blockConfig.blockType, blockConfig.options || {});
+                allBlockContents.push(content);
+            }
+            if (allBlockContents.length <= 50) {
+                const result = await makeRequest(allBlockContents, startIndex);
+                const imageBlocks = ((_a = result.children) === null || _a === void 0 ? void 0 : _a.filter((c) => c.block_type === 27)) || [];
+                const whiteboardBlocks = ((_b = result.children) === null || _b === void 0 ? void 0 : _b.filter((c) => c.block_type === 43)) || [];
+                const responseData = {
+                    ...result,
+                    nextIndex: startIndex + allBlockContents.length,
+                    totalBlocksCreated: allBlockContents.length,
+                };
+                if (imageBlocks.length > 0) {
+                    responseData.imageBlocksInfo = {
+                        count: imageBlocks.length,
+                        blockIds: imageBlocks.map((b) => b.block_id),
+                        reminder: 'Use docx.builtin.uploadImage to upload and bind images to these block IDs.',
+                    };
+                }
+                if (whiteboardBlocks.length > 0) {
+                    responseData.whiteboardBlocksInfo = {
+                        count: whiteboardBlocks.length,
+                        blocks: whiteboardBlocks.map((b) => { var _a; return ({ blockId: b.block_id, token: (_a = b.board) === null || _a === void 0 ? void 0 : _a.token }); }),
+                        reminder: 'Use docx.builtin.fillWhiteboard with the token as whiteboardId.',
+                    };
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(responseData) }] };
+            }
+            // Batch processing for >50 blocks
+            const batchSize = 50;
+            const totalBatches = Math.ceil(allBlockContents.length / batchSize);
+            const results = [];
+            let currentIndex = startIndex;
+            let createdCount = 0;
+            for (let i = 0; i < totalBatches; i++) {
+                const batch = allBlockContents.slice(i * batchSize, (i + 1) * batchSize);
+                try {
+                    const batchResult = await makeRequest(batch, currentIndex);
+                    results.push(batchResult);
+                    createdCount += batch.length;
+                    currentIndex = startIndex + createdCount;
+                }
+                catch (error) {
+                    return {
+                        isError: true,
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    msg: `Batch ${i + 1}/${totalBatches} failed. ${createdCount} blocks created. Retry from index ${currentIndex}.`,
+                                    error: ((_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.data) || (error === null || error === void 0 ? void 0 : error.message) || error,
+                                }),
+                            }],
+                    };
+                }
+            }
+            // Collect image/whiteboard blocks from all batches
+            const allImageBlocks = [];
+            const allWhiteboardBlocks = [];
+            for (const r of results) {
+                allImageBlocks.push(...(((_d = r.children) === null || _d === void 0 ? void 0 : _d.filter((c) => c.block_type === 27)) || []));
+                allWhiteboardBlocks.push(...(((_e = r.children) === null || _e === void 0 ? void 0 : _e.filter((c) => c.block_type === 43)) || []));
+            }
+            const responseData = {
+                totalBatches,
+                totalBlocksCreated: createdCount,
+                nextIndex: currentIndex,
+                lastBatchResult: results[results.length - 1],
+            };
+            if (allImageBlocks.length > 0) {
+                responseData.imageBlocksInfo = {
+                    count: allImageBlocks.length,
+                    blockIds: allImageBlocks.map((b) => b.block_id),
+                    reminder: 'Use docx.builtin.uploadImage to upload and bind images to these block IDs.',
+                };
+            }
+            if (allWhiteboardBlocks.length > 0) {
+                responseData.whiteboardBlocksInfo = {
+                    count: allWhiteboardBlocks.length,
+                    blocks: allWhiteboardBlocks.map((b) => { var _a; return ({ blockId: b.block_id, token: (_a = b.board) === null || _a === void 0 ? void 0 : _a.token }); }),
+                    reminder: 'Use docx.builtin.fillWhiteboard with the token as whiteboardId.',
+                };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(responseData) }] };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: JSON.stringify(((_f = error === null || error === void 0 ? void 0 : error.response) === null || _f === void 0 ? void 0 : _f.data) || (error === null || error === void 0 ? void 0 : error.message) || error) }],
+            };
+        }
+    },
+};
+// ─── Tool: updateBlockText ────────────────────────────────────────────────────
+exports.larkDocxUpdateBlockTextTool = {
+    project: 'docx',
+    name: 'docx.builtin.updateBlockText',
+    accessTokens: ['user', 'tenant'],
+    description: '[Feishu/Lark]-Docs-Document-Update Block Text-Updates the text content and styling of an existing block. Supports mixed text and equation elements with rich styling.',
+    schema: {
+        data: zod_1.z.object({
+            document_id: DocumentIdSchema,
+            block_id: BlockIdSchema,
+            text_elements: zod_1.z
+                .array(TextElementSchema)
+                .describe('Array of text/equation elements with styles. Example: [{text:"Hello",style:{bold:true}}]'),
+        }),
+        useUAT: zod_1.z.boolean().optional(),
+    },
+    customHandler: async (client, params, options) => {
+        var _a, _b;
+        try {
+            const { userAccessToken } = options || {};
+            const docId = extractDocumentId(params.data.document_id);
+            const blockId = params.data.block_id;
+            const elements = params.data.text_elements.map((item) => {
+                if (item.equation !== undefined) {
+                    return { equation: { content: item.equation, text_element_style: (0, block_factory_1.applyDefaultTextStyle)(item.style) } };
+                }
+                return { text_run: { content: item.text || '', text_element_style: (0, block_factory_1.applyDefaultTextStyle)(item.style) } };
+            });
+            const reqConfig = {
+                method: 'PATCH',
+                url: `/open-apis/docx/v1/documents/${docId}/blocks/${blockId}`,
+                params: { document_revision_id: -1 },
+                data: { update_text_elements: { elements } },
+            };
+            const response = userAccessToken && params.useUAT
+                ? await client.request(reqConfig, lark.withUserAccessToken(userAccessToken))
+                : await client.request(reqConfig);
+            return { content: [{ type: 'text', text: JSON.stringify((_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : response) }] };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: JSON.stringify(((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) || (error === null || error === void 0 ? void 0 : error.message) || error) }],
+            };
+        }
+    },
+};
+// ─── Tool: deleteBlocks ───────────────────────────────────────────────────────
+exports.larkDocxDeleteBlocksTool = {
+    project: 'docx',
+    name: 'docx.builtin.deleteBlocks',
+    accessTokens: ['user', 'tenant'],
+    description: '[Feishu/Lark]-Docs-Document-Delete Blocks-Deletes consecutive blocks by index range. To delete blocks 2,3,4 use startIndex=2, endIndex=5. To delete a single block at position 2, use startIndex=2, endIndex=3.',
+    schema: {
+        data: zod_1.z.object({
+            document_id: DocumentIdSchema,
+            parent_block_id: ParentBlockIdSchema,
+            start_index: zod_1.z.number().min(0).describe('Starting index (inclusive)'),
+            end_index: zod_1.z.number().min(1).describe('Ending index (exclusive)'),
+        }),
+        useUAT: zod_1.z.boolean().optional(),
+    },
+    customHandler: async (client, params, options) => {
+        var _a, _b;
+        try {
+            const { userAccessToken } = options || {};
+            const docId = extractDocumentId(params.data.document_id);
+            const parentBlockId = params.data.parent_block_id;
+            const reqConfig = {
+                method: 'DELETE',
+                url: `/open-apis/docx/v1/documents/${docId}/blocks/${parentBlockId}/children/batch_delete`,
+                data: { start_index: params.data.start_index, end_index: params.data.end_index },
+            };
+            const response = userAccessToken && params.useUAT
+                ? await client.request(reqConfig, lark.withUserAccessToken(userAccessToken))
+                : await client.request(reqConfig);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            msg: `Successfully deleted blocks from index ${params.data.start_index} to ${params.data.end_index - 1}`,
+                            ...((_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : response),
+                        }),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: JSON.stringify(((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) || (error === null || error === void 0 ? void 0 : error.message) || error) }],
+            };
+        }
+    },
+};
+// ─── Tool: createTable ────────────────────────────────────────────────────────
+exports.larkDocxCreateTableTool = {
+    project: 'docx',
+    name: 'docx.builtin.createTable',
+    accessTokens: ['user', 'tenant'],
+    description: '[Feishu/Lark]-Docs-Document-Create Table-Creates a table block with specified rows and columns. Cells can contain text, code, lists, images, etc. Multiple entries with same coordinates create multi-block cells. Image cells need docx.builtin.uploadImage afterwards.',
+    schema: {
+        data: zod_1.z.object({
+            document_id: DocumentIdSchema,
+            parent_block_id: ParentBlockIdSchema,
+            index: IndexSchema,
+            table_config: TableCreateSchema,
+        }),
+        useUAT: zod_1.z.boolean().optional(),
+    },
+    customHandler: async (client, params, options) => {
+        var _a, _b, _c;
+        try {
+            const { userAccessToken } = options || {};
+            const docId = extractDocumentId(params.data.document_id);
+            const parentBlockId = params.data.parent_block_id;
+            const tableConfig = params.data.table_config;
+            // Process cell contents through createBlockContent
+            const processedConfig = {
+                ...tableConfig,
+                cells: (_a = tableConfig.cells) === null || _a === void 0 ? void 0 : _a.map((cell) => ({
+                    ...cell,
+                    content: (0, block_factory_1.createBlockContent)(cell.content.blockType, cell.content.options),
+                })),
+            };
+            const tableStructure = (0, block_factory_1.createTableBlock)(processedConfig);
+            const reqConfig = {
+                method: 'POST',
+                url: `/open-apis/docx/v1/documents/${docId}/blocks/${parentBlockId}/descendant`,
+                params: { document_revision_id: -1 },
+                data: {
+                    children_id: tableStructure.children_id,
+                    descendants: tableStructure.descendants,
+                    index: params.data.index,
+                },
+            };
+            const response = userAccessToken && params.useUAT
+                ? await client.request(reqConfig, lark.withUserAccessToken(userAccessToken))
+                : await client.request(reqConfig);
+            const result = (_b = response === null || response === void 0 ? void 0 : response.data) !== null && _b !== void 0 ? _b : response;
+            // Extract image block mappings
+            const imageTokens = [];
+            if (tableStructure.imageBlocks.length > 0 && (result === null || result === void 0 ? void 0 : result.block_id_relations)) {
+                const idMap = new Map();
+                for (const rel of result.block_id_relations) {
+                    idMap.set(rel.temporary_block_id, rel.block_id);
+                }
+                for (const img of tableStructure.imageBlocks) {
+                    const blockId = idMap.get(img.localBlockId);
+                    if (blockId) {
+                        imageTokens.push({ row: img.coordinate.row, column: img.coordinate.column, blockId });
+                    }
+                }
+            }
+            const responseData = { ...result, tableSize: `${tableConfig.rowSize}x${tableConfig.columnSize}` };
+            if (imageTokens.length > 0) {
+                responseData.imageTokens = imageTokens;
+                responseData.imageReminder = 'Use docx.builtin.uploadImage to bind images to these block IDs.';
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(responseData) }] };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: JSON.stringify(((_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.data) || (error === null || error === void 0 ? void 0 : error.message) || error) }],
+            };
+        }
+    },
+};
+// ─── Tool: uploadImage ────────────────────────────────────────────────────────
+exports.larkDocxUploadImageTool = {
+    project: 'docx',
+    name: 'docx.builtin.uploadImage',
+    accessTokens: ['user', 'tenant'],
+    description: '[Feishu/Lark]-Docs-Document-Upload and Bind Image-Uploads images from local paths or URLs and binds them to existing empty image blocks. Use after creating image blocks with docx.builtin.batchCreateBlocks or docx.builtin.createTable.',
+    schema: {
+        data: zod_1.z.object({
+            document_id: DocumentIdSchema,
+            images: ImagesArraySchema,
+        }),
+        useUAT: zod_1.z.boolean().optional(),
+    },
+    customHandler: async (client, params, options) => {
+        var _a, _b, _c, _d;
+        try {
+            const { userAccessToken } = options || {};
+            const docId = extractDocumentId(params.data.document_id);
+            const results = [];
+            for (const { blockId, imagePathOrUrl, fileName: providedFileName } of params.data.images) {
+                try {
+                    // Step 1: Read image
+                    let imageBuffer;
+                    let detectedFileName;
+                    if (imagePathOrUrl.startsWith('http://') || imagePathOrUrl.startsWith('https://')) {
+                        const resp = await axios_1.default.get(imagePathOrUrl, { responseType: 'arraybuffer', timeout: 30000 });
+                        imageBuffer = Buffer.from(resp.data);
+                        const urlPath = new URL(imagePathOrUrl).pathname;
+                        detectedFileName = path.basename(urlPath) || `image_${Date.now()}.png`;
+                    }
+                    else {
+                        if (!fs.existsSync(imagePathOrUrl)) {
+                            results.push({ blockId, error: `File not found: ${imagePathOrUrl}` });
+                            continue;
+                        }
+                        imageBuffer = fs.readFileSync(imagePathOrUrl);
+                        detectedFileName = path.basename(imagePathOrUrl);
+                    }
+                    const finalFileName = providedFileName || detectedFileName;
+                    const file = stream_1.Readable.from(imageBuffer);
+                    // Step 2: Upload via SDK
+                    const uploadData = {
+                        file_name: finalFileName,
+                        parent_type: 'docx_image',
+                        parent_node: blockId,
+                        size: imageBuffer.length,
+                        file,
+                    };
+                    const uploadResponse = userAccessToken && params.useUAT
+                        ? await client.drive.media.uploadAll({ data: uploadData }, lark.withUserAccessToken(userAccessToken))
+                        : await client.drive.media.uploadAll({ data: uploadData });
+                    const fileToken = uploadResponse === null || uploadResponse === void 0 ? void 0 : uploadResponse.file_token;
+                    if (!fileToken) {
+                        results.push({ blockId, error: 'Upload failed: no file_token returned' });
+                        continue;
+                    }
+                    // Step 3: Bind image to block
+                    const bindConfig = {
+                        method: 'PATCH',
+                        url: `/open-apis/docx/v1/documents/${docId}/blocks/${blockId}`,
+                        params: { document_revision_id: -1 },
+                        data: { replace_image: { token: fileToken } },
+                    };
+                    const bindResponse = userAccessToken && params.useUAT
+                        ? await client.request(bindConfig, lark.withUserAccessToken(userAccessToken))
+                        : await client.request(bindConfig);
+                    results.push({
+                        blockId,
+                        fileToken,
+                        success: true,
+                        documentRevisionId: (_b = ((_a = bindResponse === null || bindResponse === void 0 ? void 0 : bindResponse.data) !== null && _a !== void 0 ? _a : bindResponse)) === null || _b === void 0 ? void 0 : _b.document_revision_id,
+                    });
+                }
+                catch (err) {
+                    results.push({ blockId, error: ((_c = err === null || err === void 0 ? void 0 : err.response) === null || _c === void 0 ? void 0 : _c.data) || (err === null || err === void 0 ? void 0 : err.message) || String(err) });
+                }
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ results }) }] };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: JSON.stringify(((_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.data) || (error === null || error === void 0 ? void 0 : error.message) || error) }],
+            };
+        }
+    },
+};
+// ─── Tool: fillWhiteboard ─────────────────────────────────────────────────────
+exports.larkDocxFillWhiteboardTool = {
+    project: 'docx',
+    name: 'docx.builtin.fillWhiteboard',
+    accessTokens: ['user', 'tenant'],
+    description: '[Feishu/Lark]-Docs-Document-Fill Whiteboard-Fills whiteboard blocks with PlantUML or Mermaid diagrams. Use after creating whiteboard blocks with docx.builtin.batchCreateBlocks. The whiteboardId is the token from the board.token field.',
+    schema: {
+        data: zod_1.z.object({
+            whiteboards: WhiteboardFillArraySchema,
+        }),
+        useUAT: zod_1.z.boolean().optional(),
+    },
+    customHandler: async (client, params, options) => {
+        var _a, _b, _c;
+        try {
+            const { userAccessToken } = options || {};
+            const whiteboards = params.data.whiteboards;
+            if (!whiteboards || whiteboards.length === 0) {
+                return { isError: true, content: [{ type: 'text', text: 'ERROR: whiteboards array is empty' }] };
+            }
+            const results = [];
+            let successCount = 0;
+            let failCount = 0;
+            for (const item of whiteboards) {
+                try {
+                    const reqConfig = {
+                        method: 'POST',
+                        url: `/open-apis/board/v1/whiteboards/${item.whiteboardId}/nodes/plantuml`,
+                        data: { plant_uml_code: item.code, style_type: 1, syntax_type: item.syntax_type },
+                    };
+                    const response = userAccessToken && params.useUAT
+                        ? await client.request(reqConfig, lark.withUserAccessToken(userAccessToken))
+                        : await client.request(reqConfig);
+                    const result = (_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : response;
+                    successCount++;
+                    results.push({
+                        whiteboardId: item.whiteboardId,
+                        syntaxType: item.syntax_type === 1 ? 'PlantUML' : 'Mermaid',
+                        status: 'success',
+                        nodeId: result === null || result === void 0 ? void 0 : result.node_id,
+                    });
+                }
+                catch (err) {
+                    failCount++;
+                    results.push({
+                        whiteboardId: item.whiteboardId,
+                        syntaxType: item.syntax_type === 1 ? 'PlantUML' : 'Mermaid',
+                        status: 'failed',
+                        error: ((_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.data) || (err === null || err === void 0 ? void 0 : err.message) || String(err),
+                    });
+                }
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ total: whiteboards.length, success: successCount, failed: failCount, results }),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: JSON.stringify(((_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.data) || (error === null || error === void 0 ? void 0 : error.message) || error) }],
+            };
+        }
+    },
+};
+// ─── Export all block tools ───────────────────────────────────────────────────
+exports.docxBlockTools = [
+    exports.larkDocxGetDocumentBlocksTool,
+    exports.larkDocxBatchCreateBlocksTool,
+    exports.larkDocxUpdateBlockTextTool,
+    exports.larkDocxDeleteBlocksTool,
+    exports.larkDocxCreateTableTool,
+    exports.larkDocxUploadImageTool,
+    exports.larkDocxFillWhiteboardTool,
+];