@danyow/lark-mcp 0.5.1

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/builtin.d.ts

@@ -0,0 +1,5 @@
+import { McpTool } from '../../../../types';
+export type docxBuiltinToolName = 'docx.builtin.search' | 'docx.builtin.import';
+export declare const larkDocxBuiltinSearchTool: McpTool;
+export declare const larkDocxBuiltinImportTool: McpTool;
+export declare const docxBuiltinTools: McpTool[];

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

@@ -0,0 +1,219 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.docxBuiltinTools = exports.larkDocxBuiltinImportTool = exports.larkDocxBuiltinSearchTool = void 0;
+const lark = __importStar(require("@larksuiteoapi/node-sdk"));
+const stream_1 = require("stream");
+const zod_1 = require("zod");
+exports.larkDocxBuiltinSearchTool = {
+    project: 'docx',
+    name: 'docx.builtin.search',
+    accessTokens: ['user'],
+    description: '[Feishu/Lark]-Docs-Document-Search Document-Search cloud documents, only supports user_access_token',
+    schema: {
+        data: zod_1.z.object({
+            search_key: zod_1.z.string().describe('Search keyword'),
+            count: zod_1.z
+                .number()
+                .describe('Specify the number of files returned in the search. Value range is [0,50].')
+                .optional(),
+            offset: zod_1.z
+                .number()
+                .describe('Specifies the search offset. The minimum value is 0, which means no offset. The sum of this parameter and the number of returned files must not be greater than or equal to 200 (i.e., offset + count < 200).')
+                .optional(),
+            owner_ids: zod_1.z.array(zod_1.z.string()).describe('Open ID of the file owner').optional(),
+            chat_ids: zod_1.z.array(zod_1.z.string()).describe('ID of the group where the file is located').optional(),
+            docs_types: zod_1.z
+                .array(zod_1.z.enum(['doc', 'sheet', 'slides', 'bitable', 'mindnote', 'file']))
+                .describe('File types, supports the following enumerations: doc: old version document; sheet: spreadsheet; slides: slides; bitable: multi-dimensional table; mindnote: mind map; file: file')
+                .optional(),
+        }),
+        useUAT: zod_1.z
+            .boolean()
+            .describe('Whether to use user identity for the request, false means using application identity')
+            .optional(),
+    },
+    customHandler: async (client, params, options) => {
+        var _a;
+        try {
+            const { userAccessToken } = options || {};
+            if (!userAccessToken) {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: JSON.stringify({ msg: 'User access token is not configured' }) }],
+                };
+            }
+            const response = await client.request({
+                method: 'POST',
+                url: '/open-apis/suite/docs-api/search/object',
+                data: params.data,
+            }, lark.withUserAccessToken(userAccessToken));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify((_a = response.data) !== null && _a !== void 0 ? _a : response),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(error.response.data),
+                    },
+                ],
+            };
+        }
+    },
+};
+exports.larkDocxBuiltinImportTool = {
+    project: 'docx',
+    name: 'docx.builtin.import',
+    accessTokens: ['user', 'tenant'],
+    description: '[Feishu/Lark]-Docs-Document-Import Document-Import cloud document, maximum 20MB',
+    schema: {
+        data: zod_1.z
+            .object({
+            markdown: zod_1.z.string().describe('Markdown file content'),
+            file_name: zod_1.z.string().describe('File name').max(27).optional(),
+        })
+            .describe('Request body'),
+        useUAT: zod_1.z.boolean().describe('Use user identity for the request, otherwise use application identity').optional(),
+    },
+    customHandler: async (client, params, options) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        try {
+            const { userAccessToken } = options || {};
+            const file = stream_1.Readable.from(params.data.markdown);
+            const data = {
+                file_name: 'docx.md',
+                parent_type: 'ccm_import_open',
+                parent_node: '/',
+                size: Buffer.byteLength(params.data.markdown),
+                file,
+                extra: JSON.stringify({ obj_type: 'docx', file_extension: 'md' }),
+            };
+            const response = userAccessToken && params.useUAT
+                ? await client.drive.media.uploadAll({ data }, lark.withUserAccessToken(userAccessToken))
+                : await client.drive.media.uploadAll({ data });
+            if (!(response === null || response === void 0 ? void 0 : response.file_token)) {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ msg: 'Document import failed, please check the markdown file content' }),
+                        },
+                    ],
+                };
+            }
+            const importData = {
+                file_extension: 'md',
+                file_name: params.data.file_name,
+                file_token: response === null || response === void 0 ? void 0 : response.file_token,
+                type: 'docx',
+                point: {
+                    mount_type: 1,
+                    mount_key: '',
+                },
+            };
+            const importResponse = userAccessToken && params.useUAT
+                ? await client.drive.importTask.create({ data: importData }, lark.withUserAccessToken(userAccessToken))
+                : await client.drive.importTask.create({ data: importData });
+            const taskId = (_a = importResponse.data) === null || _a === void 0 ? void 0 : _a.ticket;
+            if (!taskId) {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ msg: 'Document import failed, please check the markdown file content' }),
+                        },
+                    ],
+                };
+            }
+            for (let i = 0; i < 5; i++) {
+                const taskResponse = userAccessToken && params.useUAT
+                    ? await client.drive.importTask.get({ path: { ticket: taskId } }, lark.withUserAccessToken(userAccessToken))
+                    : await client.drive.importTask.get({ path: { ticket: taskId } });
+                if (((_c = (_b = taskResponse.data) === null || _b === void 0 ? void 0 : _b.result) === null || _c === void 0 ? void 0 : _c.job_status) === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify((_d = taskResponse.data) !== null && _d !== void 0 ? _d : taskResponse),
+                            },
+                        ],
+                    };
+                }
+                else if (((_f = (_e = taskResponse.data) === null || _e === void 0 ? void 0 : _e.result) === null || _f === void 0 ? void 0 : _f.job_status) !== 1 && ((_h = (_g = taskResponse.data) === null || _g === void 0 ? void 0 : _g.result) === null || _h === void 0 ? void 0 : _h.job_status) !== 2) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(taskResponse.data),
+                            },
+                        ],
+                    };
+                }
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ msg: 'Document import failed, please try again later' }),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(((_j = error === null || error === void 0 ? void 0 : error.response) === null || _j === void 0 ? void 0 : _j.data) || error),
+                    },
+                ],
+            };
+        }
+    },
+};
+exports.docxBuiltinTools = [exports.larkDocxBuiltinSearchTool, exports.larkDocxBuiltinImportTool];

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

@@ -0,0 +1,4 @@
+import { McpTool } from '../../../../types';
+export type driveBuiltinToolName = 'drive.v1.exportTask.download';
+export declare const larkDriveExportTaskDownloadTool: McpTool;
+export declare const driveBuiltinTools: McpTool[];

package/dist/mcp-tool/tools/en/builtin-tools/drive/builtin.js

@@ -0,0 +1,159 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driveBuiltinTools = exports.larkDriveExportTaskDownloadTool = void 0;
+const lark = __importStar(require("@larksuiteoapi/node-sdk"));
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+exports.larkDriveExportTaskDownloadTool = {
+    project: 'drive',
+    name: 'drive.v1.exportTask.download',
+    sdkName: 'drive.v1.exportTask.download',
+    path: '/open-apis/drive/v1/export_tasks/file/:file_token/download',
+    httpMethod: 'GET',
+    accessTokens: ['user', 'tenant'],
+    supportFileDownload: true,
+    description: '[Feishu/Lark]-Docs-Space-File-Export docs-Download export file-Download the exported file using the file_token returned from the export task. The file will be saved to the specified output directory and the local file path will be returned. Note: The exported file will be deleted 10 minutes after the export task completes.',
+    schema: {
+        path: zod_1.z.object({
+            file_token: zod_1.z
+                .string()
+                .describe('The file token returned from the export task (drive.v1.exportTask.get). This token is used to download the exported file.'),
+        }),
+        params: zod_1.z.object({
+            output_dir: zod_1.z
+                .string()
+                .describe('The directory where the downloaded file will be saved. If not specified, defaults to system temp directory.')
+                .optional(),
+            file_name: zod_1.z
+                .string()
+                .describe('The name for the downloaded file (including extension, e.g., "document.xlsx"). If not specified, uses the original file name from the export task.')
+                .optional(),
+        }).optional(),
+        useUAT: zod_1.z.boolean().describe('Use user access token, otherwise use tenant access token').optional(),
+    },
+    customHandler: async (client, params, options) => {
+        var _a, _b, _c, _d;
+        try {
+            const { userAccessToken } = options || {};
+            const fileToken = (_a = params === null || params === void 0 ? void 0 : params.path) === null || _a === void 0 ? void 0 : _a.file_token;
+            if (!fileToken) {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: JSON.stringify({ msg: 'file_token is required' }) }],
+                };
+            }
+            // Determine output directory and filename
+            const outputDir = ((_b = params === null || params === void 0 ? void 0 : params.params) === null || _b === void 0 ? void 0 : _b.output_dir) || os.tmpdir();
+            const fileName = ((_c = params === null || params === void 0 ? void 0 : params.params) === null || _c === void 0 ? void 0 : _c.file_name) || `export_${fileToken}`;
+            // Ensure output directory exists
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            const filePath = path.join(outputDir, fileName);
+            // Use SDK's built-in download method which returns writeFile/getReadableStream
+            let response;
+            if (userAccessToken && (params === null || params === void 0 ? void 0 : params.useUAT)) {
+                response = await client.drive.exportTask.download({ path: { file_token: fileToken } }, lark.withUserAccessToken(userAccessToken));
+            }
+            else {
+                response = await client.drive.exportTask.download({ path: { file_token: fileToken } });
+            }
+            // Use the SDK's writeFile method to save the file
+            if (response === null || response === void 0 ? void 0 : response.writeFile) {
+                await response.writeFile(filePath);
+            }
+            else if (response === null || response === void 0 ? void 0 : response.getReadableStream) {
+                // Fallback to stream if writeFile is not available
+                const readableStream = response.getReadableStream();
+                const writableStream = fs.createWriteStream(filePath);
+                await new Promise((resolve, reject) => {
+                    readableStream.pipe(writableStream);
+                    writableStream.on('finish', resolve);
+                    writableStream.on('error', reject);
+                    readableStream.on('error', reject);
+                });
+            }
+            else {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: JSON.stringify({
+                                msg: 'Failed to download file: SDK response does not contain writeFile or getReadableStream',
+                                debug: { responseKeys: response ? Object.keys(response) : [] }
+                            }) }],
+                };
+            }
+            // Check if file was created and get stats
+            if (!fs.existsSync(filePath)) {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: JSON.stringify({ msg: 'Failed to download file: file was not created' }) }],
+                };
+            }
+            const stats = fs.statSync(filePath);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            file_path: filePath,
+                            file_name: fileName,
+                            file_size: stats.size,
+                            message: `File downloaded successfully to ${filePath}`,
+                        }),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            msg: 'Failed to download export file',
+                            error: ((_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) || String(error),
+                        }),
+                    },
+                ],
+            };
+        }
+    },
+};
+exports.driveBuiltinTools = [exports.larkDriveExportTaskDownloadTool];

package/dist/mcp-tool/tools/en/builtin-tools/im/buildin.d.ts

@@ -0,0 +1,4 @@
+import { McpTool } from '../../../../types';
+export type imBuiltinToolName = 'im.builtin.batchSend';
+export declare const larkImBuiltinBatchSendTool: McpTool;
+export declare const imBuiltinTools: McpTool[];

package/dist/mcp-tool/tools/en/builtin-tools/im/buildin.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imBuiltinTools = exports.larkImBuiltinBatchSendTool = void 0;
+const zod_1 = require("zod");
+exports.larkImBuiltinBatchSendTool = {
+    project: 'im',
+    name: 'im.builtin.batchSend',
+    accessTokens: ['tenant'],
+    description: '[Feishu/Lark] - Batch send messages - Supports batch sending messages to multiple users and departments, supports text and card',
+    schema: {
+        data: zod_1.z.object({
+            msg_type: zod_1.z
+                .enum(['text', 'post', 'image', 'interactive', 'share_chat'])
+                .describe('Message type. If msg_type is text, image, post, or share_chat, the message content should be passed in the content parameter. If msg_type is interactive, the message content should be passed in the card parameter. Rich text type (post) messages do not support md tags.'),
+            content: zod_1.z
+                .any()
+                .describe('Message content, JSON structure. The value of this parameter corresponds to msg_type. For example, if msg_type is text, this parameter should be the text content.')
+                .optional(),
+            card: zod_1.z
+                .any()
+                .describe('Card content, JSON structure. The value of this parameter corresponds to msg_type. Only when msg_type is interactive, the card content should be passed in this parameter. When msg_type is not interactive, the message content should be passed in the content parameter.')
+                .optional(),
+            open_ids: zod_1.z.array(zod_1.z.string()).describe('List of recipient open_ids').optional(),
+            user_ids: zod_1.z.array(zod_1.z.string()).describe('List of recipient user_ids').optional(),
+            union_ids: zod_1.z.array(zod_1.z.string()).describe('List of recipient union_ids').optional(),
+            department_ids: zod_1.z
+                .array(zod_1.z.string())
+                .describe('List of department IDs. The list supports both department_id and open_department_id')
+                .optional(),
+        }),
+    },
+    customHandler: async (client, params) => {
+        var _a, _b;
+        try {
+            const { data } = params;
+            const response = await client.request({
+                method: 'POST',
+                url: '/open-apis/message/v4/batch_send',
+                data,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify((_a = 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),
+                    },
+                ],
+            };
+        }
+    },
+};
+exports.imBuiltinTools = [exports.larkImBuiltinBatchSendTool];

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

@@ -0,0 +1,5 @@
+import { docxBuiltinToolName } from './docx/builtin';
+import { driveBuiltinToolName } from './drive/builtin';
+import { imBuiltinToolName } from './im/buildin';
+export declare const BuiltinTools: import("../../..").McpTool[];
+export type BuiltinToolName = docxBuiltinToolName | driveBuiltinToolName | imBuiltinToolName;

package/dist/mcp-tool/tools/en/builtin-tools/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltinTools = void 0;
+const builtin_1 = require("./docx/builtin");
+const builtin_2 = require("./drive/builtin");
+const buildin_1 = require("./im/buildin");
+exports.BuiltinTools = [...builtin_1.docxBuiltinTools, ...builtin_2.driveBuiltinTools, ...buildin_1.imBuiltinTools];