@liselvins/lark-mcp 0.1.0

package/dist/mcp-tool/mcp-tool.d.ts

@@ -0,0 +1,52 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { LarkMcpToolOptions, McpTool, SettableValue, ToolNameCase } from './types';
+import { LarkAuthHandler } from '../auth';
+/**
+ * Feishu/Lark MCP
+ */
+export declare class LarkMcpTool {
+    private client;
+    private userAccessToken;
+    private auth;
+    private options;
+    private allTools;
+    /**
+     * Feishu/Lark MCP
+     * @param options Feishu/Lark Client Options
+     */
+    constructor(options: LarkMcpToolOptions, auth?: LarkAuthHandler);
+    /**
+     * Get MCP Tools
+     * @returns MCP Tool Definition Array
+     */
+    getTools(): McpTool[];
+    /**
+     * Update User Access Token
+     * @param userAccessToken User Access Token
+     */
+    updateUserAccessToken(userAccessToken: string | SettableValue): void;
+    private getUserAccessToken;
+    private setUserAccessToken;
+    reAuthorize(): Promise<{
+        userAccessToken?: string;
+        authorizeUrl?: string;
+    }>;
+    ensureGetUserAccessToken(): Promise<{
+        userAccessToken?: string;
+        authorizeUrl?: string;
+    }>;
+    getReAuthorizeMessage(authorizeUrl?: string, errorCode?: number, errorText?: string): {
+        isError: boolean;
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    };
+    /**
+     * Register Tools to MCP Server
+     * @param server MCP Server Instance
+     */
+    registerMcpServer(server: McpServer, options?: {
+        toolNameCase?: ToolNameCase;
+    }): void;
+}

package/dist/mcp-tool/mcp-tool.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LarkMcpTool = void 0;
+const node_sdk_1 = require("@larksuiteoapi/node-sdk");
+const types_1 = require("./types");
+const tools_1 = require("./tools");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const auth_1 = require("../auth");
+const safe_json_parse_1 = require("../utils/safe-json-parse");
+const constants_2 = require("../utils/constants");
+const logger_1 = require("../utils/logger");
+/**
+ * Feishu/Lark MCP
+ */
+class LarkMcpTool {
+    /**
+     * Feishu/Lark MCP
+     * @param options Feishu/Lark Client Options
+     */
+    constructor(options, auth) {
+        var _a;
+        // Lark Client
+        this.client = null;
+        // User Access Token
+        this.userAccessToken = {};
+        // All Tools
+        this.allTools = [];
+        this.options = options;
+        this.auth = auth;
+        if (options.client) {
+            this.client = options.client;
+        }
+        else if (options.appId && options.appSecret) {
+            this.client = new node_sdk_1.Client({ appId: options.appId, appSecret: options.appSecret, ...options });
+        }
+        const isZH = ((_a = options.toolsOptions) === null || _a === void 0 ? void 0 : _a.language) === 'zh';
+        const filterOptions = {
+            allowTools: constants_1.defaultToolNames,
+            tokenMode: this.options.tokenMode || types_1.TokenMode.AUTO,
+            ...options.toolsOptions,
+        };
+        this.allTools = (0, utils_1.filterTools)(isZH ? tools_1.AllToolsZh : tools_1.AllTools, filterOptions);
+        logger_1.logger.info(`[LarkMcpTool] Initialized with ${this.allTools.length} tools, tokenMode: ${this.options.tokenMode}`);
+    }
+    /**
+     * Get MCP Tools
+     * @returns MCP Tool Definition Array
+     */
+    getTools() {
+        return this.allTools;
+    }
+    /**
+     * Update User Access Token
+     * @param userAccessToken User Access Token
+     */
+    updateUserAccessToken(userAccessToken) {
+        if (typeof userAccessToken === 'string') {
+            this.userAccessToken.value = userAccessToken;
+        }
+        else {
+            this.userAccessToken = userAccessToken;
+        }
+    }
+    async getUserAccessToken() {
+        if (this.userAccessToken.getter) {
+            return await this.userAccessToken.getter();
+        }
+        return this.userAccessToken.value;
+    }
+    async setUserAccessToken(userAccessToken) {
+        this.userAccessToken.value = userAccessToken;
+        if (this.userAccessToken.setter) {
+            await this.userAccessToken.setter(userAccessToken);
+        }
+    }
+    async reAuthorize() {
+        const userAccessToken = await this.getUserAccessToken();
+        // if not enable oauth mode, return empty object
+        if (!this.auth || !this.options.oauth) {
+            return {};
+        }
+        logger_1.logger.info(`[LarkMcpTool] Re-authorizing user access token`);
+        const { authorizeUrl, accessToken } = await this.auth.reAuthorize(userAccessToken);
+        if (accessToken) {
+            logger_1.logger.info(`[LarkMcpTool] Successfully re-authorized user access token`);
+            this.setUserAccessToken(accessToken);
+            return { userAccessToken: accessToken };
+        }
+        return { authorizeUrl };
+    }
+    async ensureGetUserAccessToken() {
+        var _a;
+        const userAccessToken = await this.getUserAccessToken();
+        if (!this.auth) {
+            return { userAccessToken };
+        }
+        const { valid, isExpired, token } = await (0, auth_1.isTokenValid)(userAccessToken);
+        if (valid) {
+            return { userAccessToken };
+        }
+        logger_1.logger.info(`[LarkMcpTool] UserAccessToken is invalid or expired, trying to get new token...`);
+        try {
+            if (isExpired && ((_a = token === null || token === void 0 ? void 0 : token.extra) === null || _a === void 0 ? void 0 : _a.refreshToken)) {
+                logger_1.logger.info(`[LarkMcpTool] UserAccessToken is expired, trying to use refreshToken to refresh...`);
+                const newToken = await this.auth.refreshToken(token.token);
+                if (newToken === null || newToken === void 0 ? void 0 : newToken.access_token) {
+                    this.setUserAccessToken(newToken.access_token);
+                    return { userAccessToken: newToken.access_token };
+                }
+            }
+        }
+        catch (error) {
+            logger_1.logger.error(`[LarkMcpTool] Failed to refreshToken: ${error}`);
+        }
+        // reAuthorize
+        return await this.reAuthorize();
+    }
+    getReAuthorizeMessage(authorizeUrl, errorCode, errorText) {
+        var _a;
+        const errorMessage = errorCode === constants_2.OAPI_MCP_ERROR_CODE.USER_ACCESS_TOKEN_UNAUTHORIZED
+            ? 'Current user_access_token lacks required permissions. Please ensure the corresponding permissions are enabled in the developer console, then re-authorize using the following Authorization URL or login command.'
+            : 'Current user_access_token is invalid or expired';
+        const instruction = authorizeUrl
+            ? [
+                'Please open the following URL in your browser to complete the authorization:',
+                `Note: Ensure the redirect URL (${(_a = this.auth) === null || _a === void 0 ? void 0 : _a.callbackUrl}) is configured in your app's security settings.`,
+                `   If not configured, go to: ${this.options.domain}/app/${this.options.appId}/safe`,
+                'Authorization URL:',
+                authorizeUrl,
+                'This authorization link expires in 60 seconds. Generating a new link will immediately invalidate this one.',
+            ]
+                .join('\n')
+                .trim()
+            : '';
+        const reAuthorizeMessage = {
+            errorCode,
+            errorMessage,
+            instruction,
+            rawErrorText: errorText,
+        };
+        return {
+            isError: true,
+            content: [{ type: 'text', text: JSON.stringify(reAuthorizeMessage) }],
+        };
+    }
+    /**
+     * Register Tools to MCP Server
+     * @param server MCP Server Instance
+     */
+    registerMcpServer(server, options) {
+        for (const tool of this.allTools) {
+            server.tool((0, utils_1.caseTransf)(tool.name, options === null || options === void 0 ? void 0 : options.toolNameCase), tool.description, tool.schema, async (params) => {
+                var _a, _b, _c, _d, _e;
+                try {
+                    if (!this.client) {
+                        return {
+                            isError: true,
+                            content: [{ type: 'text', text: JSON.stringify({ msg: 'Client not initialized' }) }],
+                        };
+                    }
+                    const handler = tool.customHandler || utils_1.larkOapiHandler;
+                    const shouldUseUAT = (0, utils_1.getShouldUseUAT)(this.options.tokenMode, (_a = params === null || params === void 0 ? void 0 : params.useUAT) !== null && _a !== void 0 ? _a : false);
+                    if (shouldUseUAT) {
+                        const { userAccessToken, authorizeUrl } = await this.ensureGetUserAccessToken();
+                        if (!userAccessToken) {
+                            return this.getReAuthorizeMessage(authorizeUrl);
+                        }
+                        logger_1.logger.info(`[LarkMcpTool] Calling tool: ${tool.name}`);
+                        const result = await handler(this.client, { ...params, useUAT: shouldUseUAT }, { userAccessToken, tool });
+                        const errorCode = (0, safe_json_parse_1.safeJsonParse)((_c = (_b = result.content) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.text, { code: 0 }).code;
+                        if (result.isError &&
+                            [
+                                constants_2.OAPI_MCP_ERROR_CODE.USER_ACCESS_TOKEN_UNAUTHORIZED,
+                                constants_2.OAPI_MCP_ERROR_CODE.USER_ACCESS_TOKEN_INVALID,
+                            ].includes(errorCode)) {
+                            logger_1.logger.info(`[LarkMcpTool] User access token unauthorized the scope or invalid, reAuthorize, errorCode: ${errorCode}`);
+                            // user access token unauthorized the scope or invalid, reAuthorize
+                            const { authorizeUrl } = await this.reAuthorize();
+                            return this.getReAuthorizeMessage(authorizeUrl, errorCode, (_e = (_d = result.content) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.text);
+                        }
+                        return result;
+                    }
+                    logger_1.logger.info(`[LarkMcpTool] Calling tool: ${tool.name}`);
+                    return handler(this.client, { ...params, useUAT: shouldUseUAT }, { tool });
+                }
+                catch (error) {
+                    logger_1.logger.error(`[LarkMcpTool] Failed to call tool: ${tool.name}, error: ${error}`);
+                    return {
+                        isError: true,
+                        content: [{ type: 'text', text: JSON.stringify(error === null || error === void 0 ? void 0 : error.message) }],
+                    };
+                }
+            });
+        }
+    }
+}
+exports.LarkMcpTool = LarkMcpTool;

package/dist/mcp-tool/tools/en/builtin-tools/docx/block-factory.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Block Factory for creating Feishu document block structures.
+ * Ported from Feishu-MCP's blockFactory.ts to work within Feishu-openapi-mcp's builtin tool architecture.
+ */
+export interface TextElementStyle {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    inline_code?: boolean;
+    text_color?: number;
+    background_color?: number;
+}
+export interface TextContent {
+    text: string;
+    style?: TextElementStyle;
+}
+export interface EquationContent {
+    equation: string;
+    style?: TextElementStyle;
+}
+export type TextElement = TextContent | EquationContent;
+export interface FeishuBlock {
+    block_type: number;
+    [key: string]: any;
+}
+export declare enum BlockType {
+    TEXT = "text",
+    CODE = "code",
+    HEADING = "heading",
+    LIST = "list",
+    IMAGE = "image",
+    MERMAID = "mermaid",
+    WHITEBOARD = "whiteboard"
+}
+export declare enum AlignType {
+    LEFT = 1,
+    CENTER = 2,
+    RIGHT = 3
+}
+declare function getDefaultTextElementStyle(): TextElementStyle;
+declare function applyDefaultTextStyle(style?: TextElementStyle): TextElementStyle;
+declare function createTextBlock(options: {
+    textContents: TextElement[];
+    align?: AlignType;
+}): FeishuBlock;
+declare function createCodeBlock(options: {
+    code: string;
+    language?: number;
+    wrap?: boolean;
+}): FeishuBlock;
+declare function createHeadingBlock(options: {
+    text: string;
+    level?: number;
+    align?: AlignType;
+}): FeishuBlock;
+declare function createListBlock(options: {
+    text: string;
+    isOrdered?: boolean;
+    align?: AlignType;
+}): FeishuBlock;
+declare function createImageBlock(options?: {
+    width?: number;
+    height?: number;
+}): FeishuBlock;
+declare function createMermaidBlock(options?: {
+    code?: string;
+}): FeishuBlock;
+declare function createWhiteboardBlock(options?: {
+    align?: AlignType;
+}): FeishuBlock;
+export interface TableImageBlock {
+    coordinate: {
+        row: number;
+        column: number;
+    };
+    localBlockId: string;
+}
+declare function createTableBlock(options: {
+    columnSize: number;
+    rowSize: number;
+    cells?: Array<{
+        coordinate: {
+            row: number;
+            column: number;
+        };
+        content: any;
+    }>;
+}): {
+    children_id: string[];
+    descendants: any[];
+    imageBlocks: TableImageBlock[];
+};
+/**
+ * Convert a blockType + options pair into a concrete FeishuBlock structure.
+ * This mirrors Feishu-MCP's FeishuApiService.createBlockContent().
+ */
+export declare function createBlockContent(blockType: string, options: any): FeishuBlock;
+export { applyDefaultTextStyle, getDefaultTextElementStyle, createTextBlock, createCodeBlock, createHeadingBlock, createListBlock, createImageBlock, createMermaidBlock, createWhiteboardBlock, createTableBlock, };

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

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * Block Factory for creating Feishu document block structures.
+ * Ported from Feishu-MCP's blockFactory.ts to work within Feishu-openapi-mcp's builtin tool architecture.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlignType = exports.BlockType = void 0;
+exports.createBlockContent = createBlockContent;
+exports.applyDefaultTextStyle = applyDefaultTextStyle;
+exports.getDefaultTextElementStyle = getDefaultTextElementStyle;
+exports.createTextBlock = createTextBlock;
+exports.createCodeBlock = createCodeBlock;
+exports.createHeadingBlock = createHeadingBlock;
+exports.createListBlock = createListBlock;
+exports.createImageBlock = createImageBlock;
+exports.createMermaidBlock = createMermaidBlock;
+exports.createWhiteboardBlock = createWhiteboardBlock;
+exports.createTableBlock = createTableBlock;
+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 || (exports.BlockType = BlockType = {}));
+var AlignType;
+(function (AlignType) {
+    AlignType[AlignType["LEFT"] = 1] = "LEFT";
+    AlignType[AlignType["CENTER"] = 2] = "CENTER";
+    AlignType[AlignType["RIGHT"] = 3] = "RIGHT";
+})(AlignType || (exports.AlignType = AlignType = {}));
+function getDefaultTextElementStyle() {
+    return {
+        bold: false,
+        inline_code: false,
+        italic: false,
+        strikethrough: false,
+        underline: false,
+    };
+}
+function applyDefaultTextStyle(style) {
+    const defaultStyle = getDefaultTextElementStyle();
+    return style ? { ...defaultStyle, ...style } : defaultStyle;
+}
+function createTextBlock(options) {
+    const { textContents, align = AlignType.LEFT } = options;
+    return {
+        block_type: 2,
+        text: {
+            elements: textContents.map((content) => {
+                if ('equation' in content) {
+                    return {
+                        equation: {
+                            content: content.equation,
+                            text_element_style: applyDefaultTextStyle(content.style),
+                        },
+                    };
+                }
+                return {
+                    text_run: {
+                        content: content.text,
+                        text_element_style: applyDefaultTextStyle(content.style),
+                    },
+                };
+            }),
+            style: { align, folded: false },
+        },
+    };
+}
+function createCodeBlock(options) {
+    const { code, language = 0, wrap = false } = options;
+    const safeLanguage = language >= 1 && language <= 75 ? language : 1;
+    return {
+        block_type: 14,
+        code: {
+            elements: [{ text_run: { content: code, text_element_style: getDefaultTextElementStyle() } }],
+            style: { language: safeLanguage, wrap },
+        },
+    };
+}
+function createHeadingBlock(options) {
+    const { text, level = 1, align = AlignType.LEFT } = options;
+    const safeLevel = Math.max(1, Math.min(9, level));
+    const blockType = 2 + safeLevel;
+    const headingKey = `heading${safeLevel}`;
+    const block = { block_type: blockType };
+    block[headingKey] = {
+        elements: [{ text_run: { content: text, text_element_style: getDefaultTextElementStyle() } }],
+        style: { align, folded: false },
+    };
+    return block;
+}
+function createListBlock(options) {
+    const { text, isOrdered = false, align = AlignType.LEFT } = options;
+    const blockType = isOrdered ? 13 : 12;
+    const propertyKey = isOrdered ? 'ordered' : 'bullet';
+    const block = { block_type: blockType };
+    block[propertyKey] = {
+        elements: [{ text_run: { content: text, text_element_style: getDefaultTextElementStyle() } }],
+        style: { align, folded: false },
+    };
+    return block;
+}
+function createImageBlock(options = {}) {
+    const { width = 100, height = 100 } = options;
+    return { block_type: 27, image: { width, height, token: '' } };
+}
+function createMermaidBlock(options = {}) {
+    return {
+        block_type: 40,
+        add_ons: {
+            component_id: '',
+            component_type_id: 'blk_631fefbbae02400430b8f9f4',
+            record: JSON.stringify({ data: options.code }),
+        },
+    };
+}
+function createWhiteboardBlock(options = {}) {
+    const { align = AlignType.CENTER } = options;
+    return { block_type: 43, board: { align } };
+}
+function createTableBlock(options) {
+    const { columnSize, rowSize, cells = [] } = options;
+    const tableId = `table_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const imageBlocks = [];
+    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((c) => c.coordinate.row === row && c.coordinate.column === col);
+            const cellContentBlocks = [];
+            const cellContentIds = [];
+            if (cellConfigs.length > 0) {
+                cellConfigs.forEach((cellConfig, index) => {
+                    const cellContentId = `${cellId}_child_${index}`;
+                    cellContentBlocks.push({ block_id: cellContentId, ...cellConfig.content, children: [] });
+                    cellContentIds.push(cellContentId);
+                    if (cellConfig.content.block_type === 27) {
+                        imageBlocks.push({ coordinate: cellConfig.coordinate, localBlockId: cellContentId });
+                    }
+                });
+            }
+            else {
+                const cellContentId = `${cellId}_child`;
+                cellContentBlocks.push({
+                    block_id: cellContentId,
+                    ...createTextBlock({ textContents: [{ text: '' }] }),
+                    children: [],
+                });
+                cellContentIds.push(cellContentId);
+            }
+            tableCells.push(cellId);
+            descendants.push({ block_id: cellId, block_type: 32, table_cell: {}, children: cellContentIds });
+            descendants.push(...cellContentBlocks);
+        }
+    }
+    descendants.unshift({
+        block_id: tableId,
+        block_type: 31,
+        table: { property: { row_size: rowSize, column_size: columnSize } },
+        children: tableCells,
+    });
+    return { children_id: [tableId], descendants, imageBlocks };
+}
+/**
+ * Convert a blockType + options pair into a concrete FeishuBlock structure.
+ * This mirrors Feishu-MCP's FeishuApiService.createBlockContent().
+ */
+function createBlockContent(blockType, options) {
+    // Handle headingN shorthand (e.g. "heading1", "heading2")
+    let resolvedType = blockType;
+    if (typeof blockType === 'string' && blockType.startsWith('heading')) {
+        const match = blockType.match(/^heading([1-9])$/);
+        if (match) {
+            const level = parseInt(match[1], 10);
+            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;
+            }
+            resolvedType = BlockType.HEADING;
+        }
+    }
+    switch (resolvedType) {
+        case BlockType.TEXT: {
+            if (options === null || options === void 0 ? void 0 : options.text) {
+                const t = options.text;
+                const textStyles = (t.textStyles || []).map((item) => {
+                    if (item.equation !== undefined) {
+                        return { equation: item.equation, style: applyDefaultTextStyle(item.style) };
+                    }
+                    return { text: item.text || '', style: applyDefaultTextStyle(item.style) };
+                });
+                return createTextBlock({ textContents: textStyles, align: t.align || 1 });
+            }
+            return createTextBlock({ textContents: [{ text: '' }] });
+        }
+        case BlockType.CODE: {
+            if (options === null || options === void 0 ? void 0 : options.code) {
+                const c = options.code;
+                return createCodeBlock({ code: c.code || '', language: c.language || 0, wrap: c.wrap || false });
+            }
+            return createCodeBlock({ code: '' });
+        }
+        case BlockType.HEADING: {
+            if (options === null || options === void 0 ? void 0 : options.heading) {
+                const h = options.heading;
+                const safeAlign = [1, 2, 3].includes(h.align) ? h.align : 1;
+                return createHeadingBlock({ text: h.content || '', level: h.level || 1, align: safeAlign });
+            }
+            return createHeadingBlock({ text: '' });
+        }
+        case BlockType.LIST: {
+            if (options === null || options === void 0 ? void 0 : options.list) {
+                const l = options.list;
+                const safeAlign = [1, 2, 3].includes(l.align) ? l.align : 1;
+                return createListBlock({ text: l.content || '', isOrdered: l.isOrdered || false, align: safeAlign });
+            }
+            return createListBlock({ text: '' });
+        }
+        case BlockType.IMAGE: {
+            if (options === null || options === void 0 ? void 0 : options.image) {
+                return createImageBlock({ width: options.image.width || 100, height: options.image.height || 100 });
+            }
+            return createImageBlock();
+        }
+        case BlockType.MERMAID: {
+            if (options === null || options === void 0 ? void 0 : options.mermaid) {
+                return createMermaidBlock({ code: options.mermaid.code });
+            }
+            return createMermaidBlock();
+        }
+        case BlockType.WHITEBOARD: {
+            if (options === null || options === void 0 ? void 0 : options.whiteboard) {
+                const safeAlign = [1, 2, 3].includes(options.whiteboard.align) ? options.whiteboard.align : 2;
+                return createWhiteboardBlock({ align: safeAlign });
+            }
+            return createWhiteboardBlock();
+        }
+        default:
+            // Fallback: try to detect block type from options keys
+            if (options === null || options === void 0 ? void 0 : options.text)
+                return createBlockContent(BlockType.TEXT, options);
+            if (options === null || options === void 0 ? void 0 : options.code)
+                return createBlockContent(BlockType.CODE, options);
+            if (options === null || options === void 0 ? void 0 : options.heading)
+                return createBlockContent(BlockType.HEADING, options);
+            if (options === null || options === void 0 ? void 0 : options.list)
+                return createBlockContent(BlockType.LIST, options);
+            if (options === null || options === void 0 ? void 0 : options.image)
+                return createBlockContent(BlockType.IMAGE, options);
+            if (options === null || options === void 0 ? void 0 : options.mermaid)
+                return createBlockContent(BlockType.MERMAID, options);
+            if (options === null || options === void 0 ? void 0 : options.whiteboard)
+                return createBlockContent(BlockType.WHITEBOARD, options);
+            throw new Error(`Unsupported block type: ${blockType}`);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { McpTool } from '../../../../types';
+export type docxBlockToolName = 'docx.builtin.getDocumentBlocks' | 'docx.builtin.batchCreateBlocks' | 'docx.builtin.updateBlockText' | 'docx.builtin.deleteBlocks' | 'docx.builtin.createTable' | 'docx.builtin.uploadImage' | 'docx.builtin.fillWhiteboard';
+export declare const larkDocxGetDocumentBlocksTool: McpTool;
+export declare const larkDocxBatchCreateBlocksTool: McpTool;
+export declare const larkDocxUpdateBlockTextTool: McpTool;
+export declare const larkDocxDeleteBlocksTool: McpTool;
+export declare const larkDocxCreateTableTool: McpTool;
+export declare const larkDocxUploadImageTool: McpTool;
+export declare const larkDocxFillWhiteboardTool: McpTool;
+export declare const docxBlockTools: McpTool[];