feishu-mcp 0.2.2 → 0.2.7

package/dist/modules/member/toolApi/memberToolApi.js

@@ -0,0 +1,54 @@
+import { Logger } from '../../../utils/logger.js';
+import { UserSearchQueriesSchema, GetFeishuUsersUserIdsParamSchema, } from '../../../types/memberSchema.js';
+/**
+ * 按名称搜索或按 ID 批量获取飞书用户
+ */
+export async function getUsers(params, api) {
+    const byQuery = 'queries' in params && params.queries != null && params.queries.length > 0;
+    const byId = 'userIdsParam' in params && params.userIdsParam != null && params.userIdsParam.length > 0;
+    if (!byQuery && !byId) {
+        throw new Error('Provide exactly one of: queries (search by name) or userIdsParam (get by ID list).');
+    }
+    if (byQuery && byId) {
+        throw new Error('Provide exactly one of: queries or userIdsParam, not both.');
+    }
+    if (byQuery) {
+        const queries = params.queries;
+        const parsed = UserSearchQueriesSchema.safeParse(queries);
+        if (!parsed.success) {
+            throw new Error(`参数校验失败: ${parsed.error.message}`);
+        }
+        Logger.info(`getUsers invoked: by query, ${parsed.data.length} queries`);
+        const results = [];
+        for (const { query, pageToken } of parsed.data) {
+            const q = query.trim();
+            const result = await api.searchUsers(q, pageToken);
+            const users = Array.isArray(result) ? result : result?.users ?? result?.data?.users ?? [];
+            const nextToken = result?.page_token ?? result?.pageToken;
+            results.push({ query: q, users, ...(nextToken && { pageToken: nextToken }) });
+        }
+        return results;
+    }
+    if (byId) {
+        const userIdsParam = params.userIdsParam;
+        const parsed = GetFeishuUsersUserIdsParamSchema.safeParse(userIdsParam);
+        if (!parsed.success) {
+            throw new Error(`参数校验失败: ${parsed.error.message}`);
+        }
+        Logger.info(`getUsers invoked: by id, ${parsed.data.length} items`);
+        const byType = new Map();
+        for (const { id, idType } of parsed.data) {
+            const t = idType ?? 'open_id';
+            if (!byType.has(t))
+                byType.set(t, []);
+            byType.get(t).push(id);
+        }
+        const allItems = [];
+        for (const [idType, ids] of byType) {
+            const res = await api.getUsersBatch(ids, idType);
+            allItems.push(...(res.items ?? []));
+        }
+        return { items: allItems };
+    }
+    throw new Error('Unexpected state.');
+}

package/dist/modules/member/tools/memberTools.js

@@ -0,0 +1,26 @@
+import { formatErrorMessage } from '../../../utils/error.js';
+import { Logger } from '../../../utils/logger.js';
+import { errorResponse } from '../../document/tools/toolHelpers.js';
+import { getUsers } from '../toolApi/index.js';
+import { UserSearchQueriesSchema, GetFeishuUsersUserIdsParamSchema, } from '../../../types/memberSchema.js';
+/**
+ * 注册飞书成员 MCP 工具
+ * get_feishu_users：统一按「名称搜索」或「ID 批量获取」两种方式查询用户
+ */
+export function registerMemberTools(server, feishuService) {
+    server.tool('get_feishu_users', 'Get Feishu users by either (1) name search or (2) user IDs. Provide exactly one: queries [{ query, pageToken? }, ...] (1–20 items; pageToken per query for pagination), OR userIdsParam [{ id, idType }, ...] (1–50 items) to batch get by ID. Returns user list with basic info: open_id, user_id, name, department_ids, email, mobile, status, avatar, etc.', {
+        queries: UserSearchQueriesSchema.optional(),
+        userIdsParam: GetFeishuUsersUserIdsParamSchema.optional(),
+    }, async ({ queries, userIdsParam }) => {
+        try {
+            const params = queries != null && queries.length > 0 ? { queries } : { userIdsParam: userIdsParam };
+            const result = await getUsers(params, feishuService);
+            const text = Array.isArray(result) ? JSON.stringify(result, null, 2) : JSON.stringify(result, null, 2);
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (error) {
+            Logger.error('get_feishu_users 失败:', error);
+            return errorResponse(`get_feishu_users 失败: ${formatErrorMessage(error)}`);
+        }
+    });
+}

package/dist/modules/task/index.js

@@ -0,0 +1,11 @@
+import { MODULE_SCOPES } from '../../services/constants/feishuScopes.js';
+import { registerTaskTools } from './tools/taskTools.js';
+export const taskModule = {
+    id: 'task',
+    name: '飞书任务',
+    description: '飞书任务查询、创建、更新、删除功能',
+    requiredScopes: MODULE_SCOPES.task,
+    registerTools(server, apiService) {
+        registerTaskTools(server, apiService);
+    },
+};

package/dist/modules/task/services/FeishuTaskService.js

@@ -0,0 +1,271 @@
+import { FeishuBaseApiService } from '../../../services/feishu/FeishuBaseApiService.js';
+import { Logger } from '../../../utils/logger.js';
+/**
+ * 飞书任务 API 服务
+ * 封装飞书任务 v2 API（/task/v2/...）
+ */
+export class FeishuTaskService extends FeishuBaseApiService {
+    constructor(authService) {
+        super(authService);
+    }
+    async createTask(params) {
+        Logger.info(`创建任务: ${params.summary}`);
+        const body = { summary: params.summary };
+        if (params.description !== undefined)
+            body.description = params.description;
+        if (params.due !== undefined)
+            body.due = params.due;
+        if (params.completed_at !== undefined)
+            body.completed_at = params.completed_at;
+        if (params.members?.length)
+            body.members = params.members;
+        if (params.repeat_rule !== undefined)
+            body.repeat_rule = params.repeat_rule;
+        if (params.start !== undefined)
+            body.start = params.start;
+        if (params.mode !== undefined)
+            body.mode = params.mode;
+        if (params.is_milestone !== undefined)
+            body.is_milestone = params.is_milestone;
+        return this.post('/task/v2/tasks', body);
+    }
+    /**
+     * 在父任务下创建子任务。请求体与创建任务一致。
+     * POST /task/v2/tasks/:task_guid/subtasks
+     */
+    async createSubtask(parentTaskGuid, params) {
+        Logger.info(`创建子任务: ${params.summary}, parent: ${parentTaskGuid}`);
+        const body = { summary: params.summary };
+        if (params.description !== undefined)
+            body.description = params.description;
+        if (params.due !== undefined)
+            body.due = params.due;
+        if (params.completed_at !== undefined)
+            body.completed_at = params.completed_at;
+        if (params.members?.length)
+            body.members = params.members;
+        if (params.repeat_rule !== undefined)
+            body.repeat_rule = params.repeat_rule;
+        if (params.start !== undefined)
+            body.start = params.start;
+        if (params.mode !== undefined)
+            body.mode = params.mode;
+        if (params.is_milestone !== undefined)
+            body.is_milestone = params.is_milestone;
+        return this.post(`/task/v2/tasks/${parentTaskGuid}/subtasks`, body);
+    }
+    /**
+     * 按嵌套结构创建任务（含 subTasks）。深度优先：先创建父任务再递归创建子任务。
+     * 根节点可带 parentTaskGuid 挂到已有任务下。返回嵌套结果及按路径索引的错误列表。
+     */
+    async createTasksNested(rootItems, options) {
+        const maxDepth = options?.maxDepth ?? FeishuTaskService.DEFAULT_MAX_NESTING_DEPTH;
+        const errors = [];
+        const createOne = async (item, parentGuid, path, depth) => {
+            const params = {
+                summary: item.summary,
+                description: item.description,
+                due: item.due,
+                completed_at: item.completed_at,
+                members: item.members,
+                repeat_rule: item.repeat_rule,
+                start: item.start,
+                mode: item.mode,
+                is_milestone: item.is_milestone,
+            };
+            let created;
+            try {
+                const res = parentGuid
+                    ? await this.createSubtask(parentGuid, params)
+                    : await this.createTask(params);
+                created = parentGuid ? (res?.subtask ?? res) : (res?.task ?? res);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                errors.push({ path, error: msg });
+                Logger.warn(`创建任务失败 [${path}]: ${msg}`);
+                return null;
+            }
+            const result = { task: created };
+            const children = item.subTasks;
+            if (children?.length && depth < maxDepth) {
+                result.subTasks = [];
+                for (let i = 0; i < children.length; i++) {
+                    const childPath = `${path}.subTasks[${i}]`;
+                    const childResult = await createOne(children[i], created.guid, childPath, depth + 1);
+                    if (childResult)
+                        result.subTasks.push(childResult);
+                }
+            }
+            else if (children?.length && depth >= maxDepth) {
+                Logger.warn(`跳过嵌套子任务 [${path}]: 超过最大深度 ${maxDepth}`);
+            }
+            return result;
+        };
+        const results = [];
+        for (let i = 0; i < rootItems.length; i++) {
+            const item = rootItems[i];
+            const one = await createOne(item, item.parentTaskGuid, `[${i}]`, 0);
+            if (one)
+                results.push(one);
+        }
+        return { results, errors };
+    }
+    async updateTask(taskGuid, params) {
+        Logger.info(`更新任务: ${taskGuid}`);
+        const task = {};
+        const updateFields = [];
+        if (params.summary !== undefined) {
+            task.summary = params.summary;
+            updateFields.push('summary');
+        }
+        if (params.description !== undefined) {
+            task.description = params.description;
+            updateFields.push('description');
+        }
+        if (params.due !== undefined) {
+            task.due = params.due;
+            updateFields.push('due');
+        }
+        if (params.completed_at !== undefined) {
+            task.completed_at = params.completed_at;
+            updateFields.push('completed_at');
+        }
+        if (params.repeat_rule !== undefined) {
+            task.repeat_rule = params.repeat_rule;
+            updateFields.push('repeat_rule');
+        }
+        if (params.start !== undefined) {
+            task.start = params.start;
+            updateFields.push('start');
+        }
+        if (params.mode !== undefined) {
+            task.mode = params.mode;
+            updateFields.push('mode');
+        }
+        if (params.is_milestone !== undefined) {
+            task.is_milestone = params.is_milestone;
+            updateFields.push('is_milestone');
+        }
+        if (updateFields.length === 0) {
+            throw new Error('update_task requires at least one field to update');
+        }
+        return this.patch(`/task/v2/tasks/${taskGuid}`, { task, update_fields: updateFields });
+    }
+    /**
+     * 添加任务成员（负责人或关注人）。单次最多 50 个（去重后）；已存在成员会被忽略。
+     * POST /task/v2/tasks/:task_guid/add_members
+     */
+    async addTaskMembers(taskGuid, members) {
+        if (!members.length)
+            throw new Error('addTaskMembers requires at least one member');
+        Logger.info(`添加任务成员: ${taskGuid}, ${members.length} 人`);
+        const res = await this.post(`/task/v2/tasks/${taskGuid}/add_members`, { members });
+        return res?.data?.task ?? res?.task ?? res;
+    }
+    /**
+     * 移除任务成员（负责人或关注人）。单次 1～500 个；非任务成员会被忽略。
+     * POST /task/v2/tasks/:task_guid/remove_members
+     */
+    async removeTaskMembers(taskGuid, members) {
+        if (!members.length)
+            throw new Error('removeTaskMembers requires at least one member');
+        Logger.info(`移除任务成员: ${taskGuid}, ${members.length} 人`);
+        const res = await this.post(`/task/v2/tasks/${taskGuid}/remove_members`, { members });
+        return res?.data?.task ?? res?.task ?? res;
+    }
+    /**
+     * 添加任务提醒。任务须已设置截止时间(due)；当前每任务仅支持 1 个提醒，已有提醒时需先调用 removeTaskReminders。
+     * POST /task/v2/tasks/:task_guid/add_reminders
+     */
+    async addTaskReminder(taskGuid, relativeFireMinute) {
+        if (relativeFireMinute < 0)
+            throw new Error('addTaskReminder relativeFireMinute must be >= 0');
+        Logger.info(`添加任务提醒: ${taskGuid}, 截止前 ${relativeFireMinute} 分钟`);
+        const res = await this.post(`/task/v2/tasks/${taskGuid}/add_reminders`, {
+            reminders: [{ relative_fire_minute: relativeFireMinute }],
+        });
+        return res?.data?.task ?? res?.task ?? res;
+    }
+    /**
+     * 移除任务提醒。reminder_ids 来自任务详情的 reminders[].id；若提醒不存在会直接返回成功。
+     * POST /task/v2/tasks/:task_guid/remove_reminders
+     */
+    async removeTaskReminders(taskGuid, reminderIds) {
+        if (!reminderIds.length)
+            throw new Error('removeTaskReminders requires at least one reminder id');
+        Logger.info(`移除任务提醒: ${taskGuid}, ${reminderIds.length} 个`);
+        const res = await this.post(`/task/v2/tasks/${taskGuid}/remove_reminders`, { reminder_ids: reminderIds });
+        return res?.data?.task ?? res?.task ?? res;
+    }
+    /**
+     * 删除任务。删除后无法再获取。需任务可编辑权限。
+     * DELETE /task/v2/tasks/:task_guid
+     */
+    async deleteTask(taskGuid) {
+        Logger.info(`删除任务: ${taskGuid}`);
+        await this.delete(`/task/v2/tasks/${taskGuid}`);
+    }
+    /** 列取“我负责的”任务，分页。GET /task/v2/tasks，需 user_access_token。 */
+    async listTasks(pageToken, completed, pageSize = 50) {
+        const params = { page_size: pageSize, type: 'my_tasks' };
+        if (pageToken)
+            params.page_token = pageToken;
+        if (completed !== undefined)
+            params.completed = completed;
+        const res = await this.get('/task/v2/tasks', params);
+        return {
+            items: res?.items ?? [],
+            page_token: res?.page_token,
+            has_more: Boolean(res?.has_more),
+        };
+    }
+    /** 精简任务项，仅保留常用字段，减少干扰。 */
+    static slimTaskItem(task) {
+        if (!task || typeof task !== 'object')
+            return task;
+        return {
+            guid: task.guid,
+            summary: task.summary,
+            description: task.description,
+            due: task.due,
+            reminders: task.reminders,
+            creator: task.creator,
+            members: task.members,
+            completed_at: task.completed_at,
+            status: task.status,
+            task_id: task.task_id,
+            created_at: task.created_at,
+            updated_at: task.updated_at,
+            url: task.url,
+            start: task.start,
+            repeat_rule: task.repeat_rule,
+            parent_task_guid: task.parent_task_guid,
+            subtask_count: task.subtask_count,
+            is_milestone: task.is_milestone,
+            mode: task.mode,
+        };
+    }
+    /** 列取任务，每次拉取 2 页（共最多 100 条），返回精简后的 items。 */
+    async listTasksTwoPages(pageToken, completed) {
+        const PAGE_SIZE = 50;
+        const first = await this.listTasks(pageToken, completed, PAGE_SIZE);
+        const items = first.items.map(FeishuTaskService.slimTaskItem);
+        let nextToken = first.page_token;
+        let hasMore = first.has_more;
+        if (first.has_more && first.items.length === PAGE_SIZE) {
+            const second = await this.listTasks(first.page_token, completed, PAGE_SIZE);
+            items.push(...second.items.map(FeishuTaskService.slimTaskItem));
+            nextToken = second.page_token;
+            hasMore = second.has_more;
+        }
+        return { items, page_token: nextToken, has_more: hasMore };
+    }
+}
+/** subTasks 最大嵌套层数，防止递归过深。 */
+Object.defineProperty(FeishuTaskService, "DEFAULT_MAX_NESTING_DEPTH", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 10
+});

package/dist/modules/task/toolApi/__tests__/taskToolApi.test.js

@@ -0,0 +1,98 @@
+import { createTasks, listTasks, updateTask, deleteTasks } from '../taskToolApi.js';
+function createMockApi() {
+    const calls = [];
+    return {
+        createTasksNested: async (rootItems) => {
+            calls.push({ method: 'createTasksNested', args: [rootItems] });
+            return { results: rootItems.map((r) => ({ task: { guid: 'mock', summary: r.summary } })), errors: [] };
+        },
+        listTasks: async (pageToken, completed) => {
+            calls.push({ method: 'listTasks', args: [pageToken, completed] });
+            return { items: [], has_more: false };
+        },
+        updateTask: async (taskGuid, params) => {
+            calls.push({ method: 'updateTask', args: [taskGuid, params] });
+            return { task: { guid: taskGuid } };
+        },
+        addTaskMembers: async () => ({}),
+        removeTaskMembers: async () => ({}),
+        addTaskReminder: async () => ({}),
+        removeTaskReminders: async () => ({}),
+        deleteTasks: async (guids) => {
+            calls.push({ method: 'deleteTasks', args: [guids] });
+            return { deleted: guids, errors: [] };
+        },
+        get _calls() {
+            return calls;
+        },
+    };
+}
+describe('taskToolApi', () => {
+    describe('createTasks', () => {
+        it('应校验参数并转换 TaskCreateItem 为 RootNestedCreateItem', async () => {
+            const mockApi = createMockApi();
+            const taskItems = [
+                {
+                    summary: '任务1',
+                    assigneeIds: ['ou_xxx'],
+                    description: '描述',
+                },
+            ];
+            const result = await createTasks(taskItems, mockApi);
+            const calls = mockApi._calls;
+            expect(calls).toHaveLength(1);
+            expect(calls[0].method).toBe('createTasksNested');
+            const rootItems = calls[0].args[0];
+            expect(rootItems).toHaveLength(1);
+            expect(rootItems[0].summary).toBe('任务1');
+            expect(rootItems[0].members).toEqual([{ id: 'ou_xxx', type: 'user', role: 'assignee' }]);
+            expect(rootItems[0].description).toBe('描述');
+            expect(result.results).toHaveLength(1);
+        });
+        it('空数组应抛出校验错误', async () => {
+            const mockApi = createMockApi();
+            await expect(createTasks([], mockApi)).rejects.toThrow(/参数校验失败/);
+            expect(mockApi._calls).toHaveLength(0);
+        });
+    });
+    describe('listTasks', () => {
+        it('应透传 pageToken 和 completed', async () => {
+            const mockApi = createMockApi();
+            await listTasks({ pageToken: 'pt', completed: true }, mockApi);
+            const calls = mockApi._calls;
+            expect(calls[0].args).toEqual(['pt', true]);
+        });
+    });
+    describe('updateTask', () => {
+        it('至少需要一项更新', async () => {
+            const mockApi = createMockApi();
+            await expect(updateTask({ taskGuid: 'g1' }, mockApi)).rejects.toThrow(/至少需要一项更新/);
+        });
+        it('应正确转换字段更新', async () => {
+            const mockApi = createMockApi();
+            await updateTask({
+                taskGuid: 'g1',
+                summary: '新标题',
+                dueTimestamp: '123',
+                isDueAllDay: true,
+            }, mockApi);
+            const calls = mockApi._calls;
+            expect(calls[0].args).toEqual([
+                'g1',
+                { summary: '新标题', due: { timestamp: '123', is_all_day: true } },
+            ]);
+        });
+    });
+    describe('deleteTasks', () => {
+        it('应校验 taskGuids 并调用 deleteTasks', async () => {
+            const mockApi = createMockApi();
+            const result = await deleteTasks(['g1'], mockApi);
+            expect(mockApi._calls[0].args[0]).toEqual(['g1']);
+            expect(result.deleted).toEqual(['g1']);
+        });
+        it('空数组应抛出校验错误', async () => {
+            const mockApi = createMockApi();
+            await expect(deleteTasks([], mockApi)).rejects.toThrow(/参数校验失败/);
+        });
+    });
+});

package/dist/modules/task/toolApi/index.js

@@ -0,0 +1 @@
+export { createTasks, listTasks, updateTask, deleteTasks } from './taskToolApi.js';

package/dist/modules/task/toolApi/taskToolApi.js

@@ -0,0 +1,128 @@
+import { Logger } from '../../../utils/logger.js';
+import { TaskCreateBatchSchema, TaskDeleteBatchSchema, } from '../../../types/taskSchema.js';
+function toNested(item) {
+    const members = [];
+    if (item.assigneeIds?.length) {
+        members.push(...item.assigneeIds.map((id) => ({ id, type: 'user', role: 'assignee' })));
+    }
+    if (item.followerIds?.length) {
+        members.push(...item.followerIds.map((id) => ({ id, type: 'user', role: 'follower' })));
+    }
+    return {
+        summary: item.summary,
+        ...(item.parentTaskGuid !== undefined && { parentTaskGuid: item.parentTaskGuid }),
+        ...(item.description !== undefined && { description: item.description }),
+        ...(item.dueTimestamp !== undefined && { due: { timestamp: item.dueTimestamp, is_all_day: item.isDueAllDay } }),
+        ...(item.completedAt !== undefined && { completed_at: item.completedAt }),
+        ...(members.length > 0 && { members }),
+        ...(item.repeatRule !== undefined && { repeat_rule: item.repeatRule }),
+        ...(item.startTimestamp !== undefined && {
+            start: { timestamp: item.startTimestamp, is_all_day: item.isStartAllDay },
+        }),
+        ...(item.mode !== undefined && { mode: item.mode }),
+        ...(item.isMilestone !== undefined && { is_milestone: item.isMilestone }),
+        ...(item.subTasks?.length && { subTasks: item.subTasks.map(toNested) }),
+    };
+}
+/**
+ * 批量创建飞书任务（含嵌套子任务）
+ */
+export async function createTasks(taskItems, api) {
+    const parsed = TaskCreateBatchSchema.safeParse(taskItems);
+    if (!parsed.success) {
+        throw new Error(`参数校验失败: ${parsed.error.message}`);
+    }
+    Logger.info(`createTasks invoked: ${parsed.data.length} top-level items`);
+    const rootItems = parsed.data.map(toNested);
+    const result = await api.createTasksNested(rootItems);
+    return result;
+}
+/**
+ * 列取飞书任务（我负责的）
+ */
+export async function listTasks(options, api) {
+    Logger.info(`listTasks invoked: pageToken=${options?.pageToken ? 'yes' : 'no'}, completed=${options?.completed ?? 'all'}`);
+    return api.listTasks(options?.pageToken, options?.completed);
+}
+/**
+ * 更新飞书任务
+ */
+export async function updateTask(params, api) {
+    const { taskGuid, ...rest } = params;
+    const hasFieldUpdate = rest.summary !== undefined ||
+        rest.description !== undefined ||
+        rest.dueTimestamp !== undefined ||
+        rest.completedAt !== undefined ||
+        rest.repeatRule !== undefined ||
+        rest.startTimestamp !== undefined ||
+        rest.mode !== undefined ||
+        rest.isMilestone !== undefined;
+    const hasAdd = (rest.addAssigneeIds?.length ?? 0) + (rest.addFollowerIds?.length ?? 0) > 0;
+    const hasRemove = (rest.removeAssigneeIds?.length ?? 0) + (rest.removeFollowerIds?.length ?? 0) > 0;
+    const hasAddReminder = rest.addReminderRelativeMinutes !== undefined;
+    const hasRemoveReminder = (rest.removeReminderIds?.length ?? 0) > 0;
+    if (!hasFieldUpdate && !hasAdd && !hasRemove && !hasAddReminder && !hasRemoveReminder) {
+        throw new Error('至少需要一项更新：summary/description/due/completed_at/repeat_rule/start/mode/is_milestone、成员 add/remove、或提醒 addReminderRelativeMinutes/removeReminderIds');
+    }
+    Logger.info(`updateTask invoked: taskGuid=${taskGuid}`);
+    let result;
+    if (hasFieldUpdate) {
+        const updateParams = {};
+        if (rest.summary !== undefined)
+            updateParams.summary = rest.summary;
+        if (rest.description !== undefined)
+            updateParams.description = rest.description;
+        if (rest.dueTimestamp !== undefined)
+            updateParams.due = { timestamp: rest.dueTimestamp, is_all_day: rest.isDueAllDay };
+        if (rest.completedAt !== undefined)
+            updateParams.completed_at = rest.completedAt;
+        if (rest.repeatRule !== undefined)
+            updateParams.repeat_rule = rest.repeatRule;
+        if (rest.startTimestamp !== undefined)
+            updateParams.start = { timestamp: rest.startTimestamp, is_all_day: rest.isStartAllDay };
+        if (rest.mode !== undefined)
+            updateParams.mode = rest.mode;
+        if (rest.isMilestone !== undefined)
+            updateParams.is_milestone = rest.isMilestone;
+        result = await api.updateTask(taskGuid, updateParams);
+    }
+    if (hasAdd) {
+        const members = [];
+        if (rest.addAssigneeIds?.length) {
+            members.push(...rest.addAssigneeIds.map((id) => ({ id, type: 'user', role: 'assignee' })));
+        }
+        if (rest.addFollowerIds?.length) {
+            members.push(...rest.addFollowerIds.map((id) => ({ id, type: 'user', role: 'follower' })));
+        }
+        result = await api.addTaskMembers(taskGuid, members);
+    }
+    if (hasRemove) {
+        const members = [];
+        if (rest.removeAssigneeIds?.length) {
+            members.push(...rest.removeAssigneeIds.map((id) => ({ id, type: 'user', role: 'assignee' })));
+        }
+        if (rest.removeFollowerIds?.length) {
+            members.push(...rest.removeFollowerIds.map((id) => ({ id, type: 'user', role: 'follower' })));
+        }
+        result = await api.removeTaskMembers(taskGuid, members);
+    }
+    if (hasRemoveReminder) {
+        result = await api.removeTaskReminders(taskGuid, rest.removeReminderIds);
+    }
+    if (hasAddReminder) {
+        result = await api.addTaskReminder(taskGuid, rest.addReminderRelativeMinutes);
+    }
+    const taskEntity = result != null && typeof result === 'object' && 'task' in result && result.task != null ? result.task : result;
+    return taskEntity;
+}
+/**
+ * 批量删除飞书任务
+ */
+export async function deleteTasks(taskGuids, api) {
+    const parsed = TaskDeleteBatchSchema.safeParse(taskGuids);
+    if (!parsed.success) {
+        throw new Error(`参数校验失败: ${parsed.error.message}`);
+    }
+    Logger.info(`deleteTasks invoked: ${parsed.data.length} tasks`);
+    return api.deleteTasks(parsed.data);
+}