@m1heng-clawd/feishu 0.1.8 → 0.1.10

package/src/task-tools/actions.ts

@@ -0,0 +1,137 @@
+import type { TaskClient } from "./common.js";
+import type {
+  CreateTaskParams,
+  GetTaskParams,
+  TaskUpdateTask,
+  UpdateTaskParams,
+} from "./schemas.js";
+import { runTaskApiCall } from "./common.js";
+
+const SUPPORTED_PATCH_FIELDS = new Set<keyof TaskUpdateTask>([
+  "summary",
+  "description",
+  "due",
+  "start",
+  "extra",
+  "completed_at",
+  "repeat_rule",
+  "mode",
+  "is_milestone",
+]);
+
+function omitUndefined<T extends Record<string, unknown>>(obj: T): T {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, value]) => value !== undefined),
+  ) as T;
+}
+
+function inferUpdateFields(task: TaskUpdateTask): string[] {
+  return Object.keys(task).filter((field) =>
+    SUPPORTED_PATCH_FIELDS.has(field as keyof TaskUpdateTask),
+  );
+}
+
+function formatTask(task: Record<string, unknown> | undefined) {
+  if (!task) return undefined;
+  return {
+    guid: task.guid,
+    task_id: task.task_id,
+    summary: task.summary,
+    description: task.description,
+    status: task.status,
+    url: task.url,
+    created_at: task.created_at,
+    updated_at: task.updated_at,
+    completed_at: task.completed_at,
+    due: task.due,
+    start: task.start,
+    is_milestone: task.is_milestone,
+    members: task.members,
+    tasklists: task.tasklists,
+  };
+}
+
+export async function createTask(client: TaskClient, params: CreateTaskParams) {
+  const res = await runTaskApiCall("task.v2.task.create", () =>
+    client.task.v2.task.create({
+      data: omitUndefined({
+        summary: params.summary,
+        description: params.description,
+        due: params.due,
+        start: params.start,
+        extra: params.extra,
+        completed_at: params.completed_at,
+        members: params.members,
+        repeat_rule: params.repeat_rule,
+        tasklists: params.tasklists,
+        mode: params.mode,
+        is_milestone: params.is_milestone,
+      }),
+      params: omitUndefined({
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  return {
+    task: formatTask((res.data?.task ?? undefined) as Record<string, unknown> | undefined),
+  };
+}
+
+export async function deleteTask(client: TaskClient, taskGuid: string) {
+  await runTaskApiCall("task.v2.task.delete", () =>
+    client.task.v2.task.delete({
+      path: { task_guid: taskGuid },
+    }),
+  );
+
+  return {
+    success: true,
+    task_guid: taskGuid,
+  };
+}
+
+export async function getTask(client: TaskClient, params: GetTaskParams) {
+  const res = await runTaskApiCall("task.v2.task.get", () =>
+    client.task.v2.task.get({
+      path: { task_guid: params.task_guid },
+      params: omitUndefined({
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  return {
+    task: formatTask((res.data?.task ?? undefined) as Record<string, unknown> | undefined),
+  };
+}
+
+export async function updateTask(client: TaskClient, params: UpdateTaskParams) {
+  const task = omitUndefined(params.task as Record<string, unknown>) as TaskUpdateTask;
+  const updateFields = params.update_fields?.length ? params.update_fields : inferUpdateFields(task);
+
+  if (Object.keys(task).length === 0) {
+    throw new Error("task update payload is empty");
+  }
+  if (updateFields.length === 0) {
+    throw new Error("no valid update_fields provided or inferred from task payload");
+  }
+
+  const res = await runTaskApiCall("task.v2.task.patch", () =>
+    client.task.v2.task.patch({
+      path: { task_guid: params.task_guid },
+      data: {
+        task,
+        update_fields: updateFields,
+      },
+      params: omitUndefined({
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  return {
+    task: formatTask((res.data?.task ?? undefined) as Record<string, unknown> | undefined),
+    update_fields: updateFields,
+  };
+}

package/src/task-tools/common.ts

@@ -0,0 +1,18 @@
+import { createFeishuClient } from "../client.js";
+import {
+  errorResult,
+  json,
+  runFeishuApiCall,
+  type FeishuApiResponse,
+} from "../tools-common/feishu-api.js";
+
+export type TaskClient = ReturnType<typeof createFeishuClient>;
+
+export { json, errorResult };
+
+export async function runTaskApiCall<T extends FeishuApiResponse>(
+  context: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return runFeishuApiCall(context, fn);
+}

package/src/task-tools/register.ts

@@ -0,0 +1,101 @@
+import type { TSchema } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "../tools-common/tool-exec.js";
+import { createTask, deleteTask, getTask, updateTask } from "./actions.js";
+import { errorResult, json, type TaskClient } from "./common.js";
+import {
+  CreateTaskSchema,
+  type CreateTaskParams,
+  DeleteTaskSchema,
+  type DeleteTaskParams,
+  GetTaskSchema,
+  type GetTaskParams,
+  UpdateTaskSchema,
+  type UpdateTaskParams,
+} from "./schemas.js";
+
+type ToolSpec<P> = {
+  name: string;
+  label: string;
+  description: string;
+  parameters: TSchema;
+  run: (client: TaskClient, params: P) => Promise<unknown>;
+};
+
+function registerTaskTool<P>(
+  api: OpenClawPluginApi,
+  spec: ToolSpec<P>,
+) {
+  api.registerTool(
+    {
+      name: spec.name,
+      label: spec.label,
+      description: spec.description,
+      parameters: spec.parameters,
+      async execute(_toolCallId, params) {
+        try {
+          return await withFeishuToolClient({
+            api,
+            toolName: spec.name,
+            requiredTool: "task",
+            run: async ({ client }) => json(await spec.run(client as TaskClient, params as P)),
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    },
+    { name: spec.name },
+  );
+}
+
+export function registerFeishuTaskTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_task: No config available, skipping task tools");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
+    api.logger.debug?.("feishu_task: No Feishu accounts configured, skipping task tools");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "task")) {
+    api.logger.debug?.("feishu_task: task tools disabled in config");
+    return;
+  }
+
+  registerTaskTool<CreateTaskParams>(api, {
+    name: "feishu_task_create",
+    label: "Feishu Task Create",
+    description: "Create a Feishu task (task v2)",
+    parameters: CreateTaskSchema,
+    run: (client, params) => createTask(client, params),
+  });
+
+  registerTaskTool<DeleteTaskParams>(api, {
+    name: "feishu_task_delete",
+    label: "Feishu Task Delete",
+    description: "Delete a Feishu task by task_guid (task v2)",
+    parameters: DeleteTaskSchema,
+    run: (client, { task_guid }) => deleteTask(client, task_guid),
+  });
+
+  registerTaskTool<GetTaskParams>(api, {
+    name: "feishu_task_get",
+    label: "Feishu Task Get",
+    description: "Get Feishu task details by task_guid (task v2)",
+    parameters: GetTaskSchema,
+    run: (client, params) => getTask(client, params),
+  });
+
+  registerTaskTool<UpdateTaskParams>(api, {
+    name: "feishu_task_update",
+    label: "Feishu Task Update",
+    description: "Update a Feishu task by task_guid (task v2 patch)",
+    parameters: UpdateTaskSchema,
+    run: (client, params) => updateTask(client, params),
+  });
+
+  api.logger.debug?.("feishu_task: Registered 4 task tools");
+}

package/src/task-tools/schemas.ts

@@ -0,0 +1,138 @@
+import { Type } from "@sinclair/typebox";
+import type { TaskClient } from "./common.js";
+
+type TaskCreatePayload = NonNullable<Parameters<TaskClient["task"]["v2"]["task"]["create"]>[0]>;
+type TaskUpdatePayload = NonNullable<Parameters<TaskClient["task"]["v2"]["task"]["patch"]>[0]>;
+type TaskDeletePayload = NonNullable<Parameters<TaskClient["task"]["v2"]["task"]["delete"]>[0]>;
+type TaskGetPayload = NonNullable<Parameters<TaskClient["task"]["v2"]["task"]["get"]>[0]>;
+
+export type TaskCreateData = TaskCreatePayload["data"];
+export type TaskUpdateData = TaskUpdatePayload["data"];
+export type TaskUpdateTask = NonNullable<TaskUpdateData["task"]>;
+
+export type CreateTaskParams = {
+  summary: TaskCreateData["summary"];
+  description?: TaskCreateData["description"];
+  due?: TaskCreateData["due"];
+  start?: TaskCreateData["start"];
+  extra?: TaskCreateData["extra"];
+  completed_at?: TaskCreateData["completed_at"];
+  members?: TaskCreateData["members"];
+  repeat_rule?: TaskCreateData["repeat_rule"];
+  tasklists?: TaskCreateData["tasklists"];
+  mode?: TaskCreateData["mode"];
+  is_milestone?: TaskCreateData["is_milestone"];
+  user_id_type?: NonNullable<TaskCreatePayload["params"]>["user_id_type"];
+};
+
+export type DeleteTaskParams = {
+  task_guid: TaskDeletePayload["path"]["task_guid"];
+};
+
+export type GetTaskParams = {
+  task_guid: TaskGetPayload["path"]["task_guid"];
+  user_id_type?: NonNullable<TaskGetPayload["params"]>["user_id_type"];
+};
+
+export type UpdateTaskParams = {
+  task_guid: TaskUpdatePayload["path"]["task_guid"];
+  task: TaskUpdateTask;
+  update_fields?: TaskUpdateData["update_fields"];
+  user_id_type?: NonNullable<TaskUpdatePayload["params"]>["user_id_type"];
+};
+
+const TaskDateSchema = Type.Object({
+  timestamp: Type.Optional(
+    Type.String({
+      description:
+        "Unix timestamp in milliseconds (string), e.g. \"1735689600000\" (13-digit ms)",
+    }),
+  ),
+  is_all_day: Type.Optional(Type.Boolean({ description: "Whether this is an all-day date" })),
+});
+
+const TaskMemberSchema = Type.Object({
+  id: Type.String({ description: "Member ID (with type controlled by user_id_type)" }),
+  type: Type.Optional(Type.String({ description: "Member type (usually \"user\")" })),
+  role: Type.String({ description: "Member role, e.g. \"assignee\"" }),
+  name: Type.Optional(Type.String({ description: "Optional display name" })),
+});
+
+const TasklistRefSchema = Type.Object({
+  tasklist_guid: Type.Optional(Type.String({ description: "Tasklist GUID" })),
+  section_guid: Type.Optional(Type.String({ description: "Section GUID in tasklist" })),
+});
+
+export const CreateTaskSchema = Type.Object({
+  summary: Type.String({ description: "Task title/summary" }),
+  description: Type.Optional(Type.String({ description: "Task description" })),
+  due: Type.Optional(TaskDateSchema),
+  start: Type.Optional(TaskDateSchema),
+  extra: Type.Optional(Type.String({ description: "Custom opaque metadata string" })),
+  completed_at: Type.Optional(
+    Type.String({
+      description: "Completion time as Unix timestamp in milliseconds (string, 13-digit ms)",
+    }),
+  ),
+  members: Type.Optional(Type.Array(TaskMemberSchema, { description: "Initial task members" })),
+  repeat_rule: Type.Optional(Type.String({ description: "Task repeat rule" })),
+  tasklists: Type.Optional(
+    Type.Array(TasklistRefSchema, { description: "Attach the task to tasklists/sections" }),
+  ),
+  mode: Type.Optional(Type.Number({ description: "Task mode value from Feishu Task API" })),
+  is_milestone: Type.Optional(Type.Boolean({ description: "Whether task is a milestone" })),
+  user_id_type: Type.Optional(
+    Type.String({
+      description: "User ID type for member IDs, e.g. open_id/user_id/union_id",
+    }),
+  ),
+});
+
+export const DeleteTaskSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to delete" }),
+});
+
+export const GetTaskSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to retrieve" }),
+  user_id_type: Type.Optional(
+    Type.String({
+      description: "User ID type in returned members, e.g. open_id/user_id/union_id",
+    }),
+  ),
+});
+
+const TaskUpdateContentSchema = Type.Object(
+  {
+    summary: Type.Optional(Type.String({ description: "Updated summary" })),
+    description: Type.Optional(Type.String({ description: "Updated description" })),
+    due: Type.Optional(TaskDateSchema),
+    start: Type.Optional(TaskDateSchema),
+    extra: Type.Optional(Type.String({ description: "Updated extra metadata" })),
+    completed_at: Type.Optional(
+      Type.String({
+        description: "Updated completion time (Unix timestamp in milliseconds, string, 13-digit ms)",
+      }),
+    ),
+    repeat_rule: Type.Optional(Type.String({ description: "Updated repeat rule" })),
+    mode: Type.Optional(Type.Number({ description: "Updated task mode" })),
+    is_milestone: Type.Optional(Type.Boolean({ description: "Updated milestone flag" })),
+  },
+  { minProperties: 1 },
+);
+
+export const UpdateTaskSchema = Type.Object({
+  task_guid: Type.String({ description: "Task GUID to update" }),
+  task: TaskUpdateContentSchema,
+  update_fields: Type.Optional(
+    Type.Array(Type.String(), {
+      description:
+        "Fields to update. If omitted, this tool infers from keys in task (e.g. summary, description, due, start)",
+      minItems: 1,
+    }),
+  ),
+  user_id_type: Type.Optional(
+    Type.String({
+      description: "User ID type when task body contains user-related fields",
+    }),
+  ),
+});

package/src/task.ts

@@ -0,0 +1 @@
+export { registerFeishuTaskTools } from "./task-tools/register.js";

package/src/tools-common/feishu-api.ts

@@ -0,0 +1,184 @@
+/**
+ * Minimal response shape shared by Feishu OpenAPI endpoints.
+ * Most endpoints return success when `code` is `0` (or omitted).
+ */
+export type FeishuApiResponse = {
+  code?: number;
+  msg?: string;
+  log_id?: string;
+  logId?: string;
+};
+
+type FeishuErrorInfo = {
+  code?: number;
+  msg?: string;
+  logId?: string;
+};
+
+type RunFeishuApiCallOptions = {
+  /** Feishu error codes that should be treated as transient and retried. */
+  retryableCodes?: Iterable<number>;
+  /** Retry delays in milliseconds. Number of entries controls retry attempts. */
+  backoffMs?: number[];
+};
+
+/**
+ * Standard tool result payload:
+ * - `content` for model-visible text output
+ * - `details` for structured downstream access
+ */
+export function json(data: unknown) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+    details: data,
+  };
+}
+
+/** Convert any thrown value into the standard JSON error envelope. */
+export function errorResult(err: unknown) {
+  return json({ error: err instanceof Error ? err.message : String(err) });
+}
+
+/** Small async sleep utility used by retry backoff. */
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Extract Feishu error fields (`code`, `msg`, `log_id`) from different throw shapes.
+ * Handles nested SDK error arrays and axios-style `response.data`.
+ */
+function extractFeishuErrorInfo(err: unknown): FeishuErrorInfo | null {
+  if (!err) return null;
+
+  // Feishu SDK may throw nested array structures like:
+  // [axiosError, { code, msg, log_id, ... }]
+  if (Array.isArray(err)) {
+    for (let i = err.length - 1; i >= 0; i -= 1) {
+      const info = extractFeishuErrorInfo(err[i]);
+      if (info) return info;
+    }
+    return null;
+  }
+
+  if (typeof err !== "object") return null;
+
+  const obj = err as Record<string, unknown>;
+  const codeValue = obj.code;
+  const msgValue = obj.msg ?? obj.message;
+  const logIdValue = obj.log_id ?? obj.logId;
+
+  const hasCode = typeof codeValue === "number";
+  const hasMsg = typeof msgValue === "string";
+  const hasLogId = typeof logIdValue === "string";
+
+  if (hasCode || hasMsg || hasLogId) {
+    return {
+      code: hasCode ? codeValue : undefined,
+      msg: hasMsg ? (msgValue as string) : undefined,
+      logId: hasLogId ? (logIdValue as string) : undefined,
+    };
+  }
+
+  const responseData = (obj.response as { data?: unknown } | undefined)?.data;
+  if (responseData) return extractFeishuErrorInfo(responseData);
+
+  return null;
+}
+
+function assertFeishuOk<T extends FeishuApiResponse>(response: T, context: string): T {
+  if (response.code === undefined || response.code === 0) return response;
+
+  const message = response.msg || `code ${response.code}`;
+  const detail = response.log_id ?? response.logId;
+  const error = new Error(
+    detail
+      ? `${context} failed: ${message}, code=${response.code}, log_id=${detail}`
+      : `${context} failed: ${message}, code=${response.code}`,
+  ) as Error & { code?: number; log_id?: string; logId?: string };
+  error.code = response.code;
+  if (detail) {
+    error.log_id = detail;
+    error.logId = detail;
+  }
+  throw error;
+}
+
+/**
+ * Normalize unknown errors to a readable, context-aware Error message.
+ * Preserves Feishu `code/log_id` details when available.
+ */
+function toError(err: unknown, context: string): Error {
+  if (err instanceof Error) {
+    const info = extractFeishuErrorInfo(err);
+    if (!info) return err;
+    const details = [
+      info.msg || `code ${info.code}`,
+      info.code !== undefined ? `code=${info.code}` : undefined,
+      info.logId ? `log_id=${info.logId}` : undefined,
+    ]
+      .filter(Boolean)
+      .join(", ");
+    return new Error(`${context} failed: ${details}`);
+  }
+
+  const info = extractFeishuErrorInfo(err);
+  if (info) {
+    const details = [
+      info.msg || `code ${info.code}`,
+      info.code !== undefined ? `code=${info.code}` : undefined,
+      info.logId ? `log_id=${info.logId}` : undefined,
+    ]
+      .filter(Boolean)
+      .join(", ");
+    return new Error(`${context} failed: ${details}`);
+  }
+
+  return new Error(`${context} failed: ${String(err)}`);
+}
+
+/**
+ * Execute a Feishu API call with shared success/error handling.
+ *
+ * Behavior:
+ * - Treats `code === 0` (or undefined) as success.
+ * - Converts non-zero responses and thrown values into normalized Errors.
+ * - Optionally retries only for configured transient error codes.
+ *
+ * Retry model:
+ * - Attempts = `backoffMs.length + 1`
+ * - Delay before each retry uses the corresponding `backoffMs` entry.
+ */
+export async function runFeishuApiCall<T extends FeishuApiResponse>(
+  context: string,
+  fn: () => Promise<T>,
+  options?: RunFeishuApiCallOptions,
+): Promise<T> {
+  const retryableCodes = new Set(options?.retryableCodes ?? []);
+  const backoffMs = options?.backoffMs ?? [];
+  const maxAttempts = backoffMs.length + 1;
+  let attempt = 0;
+  let lastErr: unknown = null;
+
+  while (attempt < maxAttempts) {
+    try {
+      const response = await fn();
+      return assertFeishuOk(response, context);
+    } catch (err) {
+      lastErr = err;
+      const info = extractFeishuErrorInfo(err);
+      const retryable =
+        retryableCodes.size > 0 && info?.code !== undefined && retryableCodes.has(info.code);
+      const exhausted = attempt >= maxAttempts - 1;
+      if (!retryable || exhausted) {
+        throw toError(err, context);
+      }
+
+      const waitMs = backoffMs[Math.min(attempt, backoffMs.length - 1)];
+      await sleep(waitMs);
+      attempt += 1;
+    }
+  }
+
+  throw toError(lastErr, context);
+}

package/src/tools-common/tool-context.ts

@@ -0,0 +1,23 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export type FeishuToolContext = {
+  channel: "feishu";
+  accountId: string;
+  sessionKey?: string;
+};
+
+const toolContextStorage = new AsyncLocalStorage<FeishuToolContext>();
+
+export function runWithFeishuToolContext<T>(
+  context: FeishuToolContext,
+  fn: () => T,
+): T {
+  // Propagate the active Feishu account through async boundaries so tool execution
+  // can resolve the correct account without changing OpenClaw core APIs.
+  return toolContextStorage.run(context, fn);
+}
+
+export function getCurrentFeishuToolContext(): FeishuToolContext | undefined {
+  // Returns undefined when execution is outside a message-dispatch context.
+  return toolContextStorage.getStore();
+}

package/src/tools-common/tool-exec.ts

@@ -0,0 +1,73 @@
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import type { ClawdbotConfig, OpenClawPluginApi } from "openclaw/plugin-sdk";
+import {
+  listEnabledFeishuAccounts,
+  resolveDefaultFeishuAccountId,
+  resolveFeishuAccount,
+} from "../accounts.js";
+import { createFeishuClient } from "../client.js";
+import { resolveToolsConfig } from "../tools-config.js";
+import { getCurrentFeishuToolContext } from "./tool-context.js";
+import type { FeishuToolsConfig, ResolvedFeishuAccount } from "../types.js";
+
+export type FeishuToolFlag = keyof Required<FeishuToolsConfig>;
+
+export function hasFeishuToolEnabledForAnyAccount(
+  cfg: ClawdbotConfig,
+  requiredTool?: FeishuToolFlag,
+): boolean {
+  // Tool registration is global (one definition), so we only need to know whether
+  // at least one enabled account can use the tool.
+  const accounts = listEnabledFeishuAccounts(cfg);
+  if (accounts.length === 0) {
+    return false;
+  }
+  if (!requiredTool) {
+    return true;
+  }
+  return accounts.some((account) => resolveToolsConfig(account.config.tools)[requiredTool]);
+}
+
+export function resolveToolAccount(cfg: ClawdbotConfig): ResolvedFeishuAccount {
+  const context = getCurrentFeishuToolContext();
+  if (context?.channel === "feishu" && context.accountId) {
+    // Message-driven path: use the account from AsyncLocalStorage context.
+    return resolveFeishuAccount({ cfg, accountId: context.accountId });
+  }
+  // Non-session path (e.g. background/manual invocation): fall back to default account.
+  return resolveFeishuAccount({ cfg, accountId: resolveDefaultFeishuAccountId(cfg) });
+}
+
+export async function withFeishuToolClient<T>(params: {
+  api: OpenClawPluginApi;
+  toolName: string;
+  requiredTool?: FeishuToolFlag;
+  run: (args: { client: Lark.Client; account: ResolvedFeishuAccount }) => Promise<T>;
+}): Promise<T> {
+  if (!params.api.config) {
+    throw new Error("Feishu config is not available");
+  }
+
+  // Resolve account at execution time (not registration time).
+  const account = resolveToolAccount(params.api.config);
+
+  if (!account.enabled) {
+    throw new Error(`Feishu account "${account.accountId}" is disabled`);
+  }
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" is not configured`);
+  }
+
+  if (params.requiredTool) {
+    // Enforce per-account tool toggles, even though the tool is registered globally.
+    const toolsCfg = resolveToolsConfig(account.config.tools);
+    if (!toolsCfg[params.requiredTool]) {
+      throw new Error(
+        `Feishu tool "${params.toolName}" is disabled for account "${account.accountId}"`,
+      );
+    }
+  }
+
+  const client = createFeishuClient(account);
+  return params.run({ client, account });
+}

package/src/tools-config.ts

@@ -2,7 +2,7 @@ import type { FeishuToolsConfig } from "./types.js";
 
 /**
  * Default tool configuration.
- * - doc, wiki, drive, scopes: enabled by default
+ * - doc, wiki, drive, scopes, task: enabled by default
  * - perm: disabled by default (sensitive operation)
  */
 export const DEFAULT_TOOLS_CONFIG: Required<FeishuToolsConfig> = {
@@ -11,6 +11,7 @@ export const DEFAULT_TOOLS_CONFIG: Required<FeishuToolsConfig> = {
   drive: true,
   perm: false,
   scopes: true,
+  task: true,
 };
 
 /**