@m1heng-clawd/feishu 0.1.15 → 0.1.17

package/src/task-tools/register.ts

@@ -6,19 +6,24 @@ import {
   addTaskToTasklist,
   addTasklistMembers,
   createSubtask,
+  createTaskComment,
   createTask,
   createTasklist,
   deleteTaskAttachment,
+  deleteTaskComment,
   deleteTask,
   deleteTasklist,
   getTaskAttachment,
+  getTaskComment,
   getTask,
   getTasklist,
+  listTaskComments,
   listTasklists,
   removeTaskFromTasklist,
   removeTasklistMembers,
   listTaskAttachments,
   uploadTaskAttachment,
+  updateTaskComment,
   updateTask,
   updateTasklist,
 } from "./actions.js";
@@ -36,26 +41,36 @@ import {
   type CreateTasklistParams,
   DeleteTaskAttachmentSchema,
   type DeleteTaskAttachmentParams,
+  DeleteTaskCommentSchema,
+  type DeleteTaskCommentParams,
   DeleteTaskSchema,
   type DeleteTaskParams,
   DeleteTasklistSchema,
   type DeleteTasklistParams,
   GetTaskAttachmentSchema,
   type GetTaskAttachmentParams,
+  GetTaskCommentSchema,
+  type GetTaskCommentParams,
   GetTaskSchema,
   type GetTaskParams,
   GetTasklistSchema,
   type GetTasklistParams,
   ListTaskAttachmentsSchema,
   type ListTaskAttachmentsParams,
+  ListTaskCommentsSchema,
+  type ListTaskCommentsParams,
   ListTasklistsSchema,
   type ListTasklistsParams,
   RemoveTaskFromTasklistSchema,
   type RemoveTaskFromTasklistParams,
   RemoveTasklistMembersSchema,
   type RemoveTasklistMembersParams,
+  CreateTaskCommentSchema,
+  type CreateTaskCommentParams,
   UploadTaskAttachmentSchema,
   type UploadTaskAttachmentParams,
+  UpdateTaskCommentSchema,
+  type UpdateTaskCommentParams,
   UpdateTaskSchema,
   UpdateTasklistSchema,
   type UpdateTaskParams,
@@ -259,5 +274,45 @@ export function registerFeishuTaskTools(api: OpenClawPluginApi) {
     run: async ({ client }, params) => updateTask(client, params),
   });
 
-  api.logger.debug?.("feishu_task: Registered task, tasklist, subtask, and attachment tools");
+  registerTaskTool<CreateTaskCommentParams>(api, {
+    name: "feishu_task_comment_create",
+    label: "Feishu Task Comment Create",
+    description: "Create a comment on a Feishu task (task v2)",
+    parameters: CreateTaskCommentSchema,
+    run: async ({ client }, params) => createTaskComment(client, params),
+  });
+
+  registerTaskTool<ListTaskCommentsParams>(api, {
+    name: "feishu_task_comment_list",
+    label: "Feishu Task Comment List",
+    description: "List comments for a Feishu task (task v2)",
+    parameters: ListTaskCommentsSchema,
+    run: async ({ client }, params) => listTaskComments(client, params),
+  });
+
+  registerTaskTool<GetTaskCommentParams>(api, {
+    name: "feishu_task_comment_get",
+    label: "Feishu Task Comment Get",
+    description: "Get a Feishu task comment by comment_id (task v2)",
+    parameters: GetTaskCommentSchema,
+    run: async ({ client }, params) => getTaskComment(client, params),
+  });
+
+  registerTaskTool<UpdateTaskCommentParams>(api, {
+    name: "feishu_task_comment_update",
+    label: "Feishu Task Comment Update",
+    description: "Update a Feishu task comment by comment_id (task v2 patch)",
+    parameters: UpdateTaskCommentSchema,
+    run: async ({ client }, params) => updateTaskComment(client, params),
+  });
+
+  registerTaskTool<DeleteTaskCommentParams>(api, {
+    name: "feishu_task_comment_delete",
+    label: "Feishu Task Comment Delete",
+    description: "Delete a Feishu task comment by comment_id (task v2)",
+    parameters: DeleteTaskCommentSchema,
+    run: async ({ client }, params) => deleteTaskComment(client, params),
+  });
+
+  api.logger.debug?.("feishu_task: Registered task, comment, tasklist, subtask, and attachment tools");
 }

package/src/task-tools/schemas.ts

@@ -1,6 +1,15 @@
 import { Type } from "@sinclair/typebox";
 import type { TaskClient } from "./common.js";
 
+// NOTE: Avoid Type.Union([Type.Literal(...)]) which compiles to anyOf.
+// Some providers reject anyOf in tool schemas; a flat string enum is safer.
+function stringEnum<T extends readonly string[]>(
+  values: T,
+  options: { description?: string; default?: T[number] } = {},
+) {
+  return Type.Unsafe<T[number]>({ type: "string", enum: [...values], ...options });
+}
+
 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]>;
@@ -75,6 +84,7 @@ export const TASK_UPDATE_FIELD_VALUES = [
   "mode",
   "is_milestone",
 ] as const;
+export const TASK_COMMENT_UPDATE_FIELD_VALUES = ["content"] as const;
 export const TASKLIST_UPDATE_FIELD_VALUES = ["name", "owner", "archive_tasklist"] as const;
 
 export type CreateTaskParams = {
@@ -245,23 +255,19 @@ const TasklistRefSchema = Type.Object({
   section_guid: Type.Optional(Type.String({ description: "Section GUID in tasklist" })),
 });
 
-const TaskUpdateFieldSchema = Type.Union(
-  TASK_UPDATE_FIELD_VALUES.map((field) => Type.Literal(field)),
-);
+const TaskUpdateFieldSchema = stringEnum(TASK_UPDATE_FIELD_VALUES);
 
-const TasklistMemberRoleSchema = Type.Union(
-  [Type.Literal("owner"), Type.Literal("editor"), Type.Literal("viewer")],
-  { description: "Member role (owner/editor/viewer)" },
-);
+const TaskCommentUpdateFieldSchema = stringEnum(TASK_COMMENT_UPDATE_FIELD_VALUES);
 
-const TasklistUpdateFieldSchema = Type.Union(
-  TASKLIST_UPDATE_FIELD_VALUES.map((field) => Type.Literal(field)),
-);
+const TasklistMemberRoleSchema = stringEnum(["owner", "editor", "viewer"] as const, {
+  description: "Member role (owner/editor/viewer)",
+});
 
-const TasklistOriginOwnerRoleSchema = Type.Union(
-  [Type.Literal("editor"), Type.Literal("viewer"), Type.Literal("none")],
-  { description: "Role for original owner after owner transfer" },
-);
+const TasklistUpdateFieldSchema = stringEnum(TASKLIST_UPDATE_FIELD_VALUES);
+
+const TasklistOriginOwnerRoleSchema = stringEnum(["editor", "viewer", "none"] as const, {
+  description: "Role for original owner after owner transfer",
+});
 
 const TasklistMemberSchema = Type.Object({
   id: Type.String({ description: "Member ID (with type controlled by user_id_type)" }),
@@ -372,9 +378,7 @@ export const ListTaskCommentsSchema = Type.Object({
   ),
   page_token: Type.Optional(Type.String({ description: "Pagination token" })),
   direction: Type.Optional(
-    Type.Union([Type.Literal("asc"), Type.Literal("desc")], {
-      description: "Sort direction",
-    }),
+    stringEnum(["asc", "desc"] as const, { description: "Sort direction" }),
   ),
   user_id_type: Type.Optional(
     Type.String({ description: "User ID type for returned creators" }),
@@ -399,9 +403,10 @@ export const UpdateTaskCommentSchema = Type.Object({
   comment_id: Type.String({ description: "Comment ID to update" }),
   comment: TaskCommentUpdateContentSchema,
   update_fields: Type.Optional(
-    Type.Array(Type.String(), {
+    Type.Array(TaskCommentUpdateFieldSchema, {
       description: "Fields to update. If omitted, this tool infers from keys in comment (content)",
       minItems: 1,
+      uniqueItems: true,
     }),
   ),
   user_id_type: Type.Optional(

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

@@ -4,6 +4,8 @@ export type FeishuToolContext = {
   channel: "feishu";
   accountId: string;
   sessionKey?: string;
+  senderOpenId?: string;
+  chatId?: string;
 };
 
 const toolContextStorage = new AsyncLocalStorage<FeishuToolContext>();

package/src/tools-config.ts

@@ -14,6 +14,8 @@ export const DEFAULT_TOOLS_CONFIG: Required<FeishuToolsConfig> = {
   task: true,
   chat: true,
   urgent: true,
+  message: true,
+  reaction: true,
 };
 
 /**

package/src/types.ts

@@ -76,6 +76,10 @@ export type FeishuToolsConfig = {
   chat?: boolean;
   /** Enable the feishu_urgent tool (buzz/urgent notifications). Enabled by default. */
   urgent?: boolean;
+  /** Enable the feishu_message tool (get/list messages). Enabled by default. */
+  message?: boolean;
+  /** Enable the feishu_reaction tool (add/remove/list emoji reactions). Enabled by default. */
+  reaction?: boolean;
 };
 
 export type DynamicAgentCreationConfig = {

package/src/wiki-tools/actions.ts

@@ -7,6 +7,13 @@ const WIKI_ACCESS_HINT =
   "To grant wiki access: Open wiki space -> Settings -> Members -> Add the bot. " +
   "See: https://open.feishu.cn/document/server-docs/docs/wiki-v2/wiki-qa#a40ad4ca";
 
+function requireString(value: unknown, field: string): string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} is required`);
+  }
+  return value;
+}
+
 async function listSpaces(client: WikiClient) {
   const res = await runWikiApiCall("wiki.space.list", () => client.wiki.space.list({}));
   const spaces =
@@ -140,26 +147,37 @@ export async function runWikiAction(client: WikiClient, params: FeishuWikiParams
     case "spaces":
       return listSpaces(client);
     case "nodes":
-      return listNodes(client, params.space_id, params.parent_node_token);
+      return listNodes(client, requireString(params.space_id, "space_id"), params.parent_node_token);
     case "get":
-      return getNode(client, params.token);
+      return getNode(client, requireString(params.token, "token"));
     case "search":
       return {
         error:
           "Search is not available. Use feishu_wiki with action: 'nodes' to browse or action: 'get' to lookup by token.",
       };
     case "create":
-      return createNode(client, params.space_id, params.title, params.obj_type, params.parent_node_token);
+      return createNode(
+        client,
+        requireString(params.space_id, "space_id"),
+        requireString(params.title, "title"),
+        params.obj_type,
+        params.parent_node_token,
+      );
     case "move":
       return moveNode(
         client,
-        params.space_id,
-        params.node_token,
+        requireString(params.space_id, "space_id"),
+        requireString(params.node_token, "node_token"),
         params.target_space_id,
         params.target_parent_token,
       );
     case "rename":
-      return renameNode(client, params.space_id, params.node_token, params.title);
+      return renameNode(
+        client,
+        requireString(params.space_id, "space_id"),
+        requireString(params.node_token, "node_token"),
+        requireString(params.title, "title"),
+      );
     default:
       return { error: `Unknown action: ${(params as any).action}` };
   }

package/src/wiki-tools/schemas.ts

@@ -1,55 +1,36 @@
 import { Type, type Static } from "@sinclair/typebox";
 
-export const FeishuWikiSchema = Type.Union([
-  Type.Object({
-    action: Type.Literal("spaces"),
-  }),
-  Type.Object({
-    action: Type.Literal("nodes"),
-    space_id: Type.String({ description: "Knowledge space ID" }),
-    parent_node_token: Type.Optional(
-      Type.String({ description: "Parent node token (optional, omit for root)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("get"),
-    token: Type.String({ description: "Wiki node token (from URL /wiki/XXX)" }),
-  }),
-  Type.Object({
-    action: Type.Literal("search"),
-    query: Type.String({ description: "Search query" }),
-    space_id: Type.Optional(Type.String({ description: "Limit search to this space (optional)" })),
-  }),
-  Type.Object({
-    action: Type.Literal("create"),
-    space_id: Type.String({ description: "Knowledge space ID" }),
-    title: Type.String({ description: "Node title" }),
-    obj_type: Type.Optional(
-      Type.Union([Type.Literal("docx"), Type.Literal("sheet"), Type.Literal("bitable")], {
-        description: "Object type (default: docx)",
-      }),
-    ),
-    parent_node_token: Type.Optional(
-      Type.String({ description: "Parent node token (optional, omit for root)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("move"),
-    space_id: Type.String({ description: "Source knowledge space ID" }),
-    node_token: Type.String({ description: "Node token to move" }),
-    target_space_id: Type.Optional(
-      Type.String({ description: "Target space ID (optional, same space if omitted)" }),
-    ),
-    target_parent_token: Type.Optional(
-      Type.String({ description: "Target parent node token (optional, root if omitted)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("rename"),
-    space_id: Type.String({ description: "Knowledge space ID" }),
-    node_token: Type.String({ description: "Node token to rename" }),
-    title: Type.String({ description: "New title" }),
-  }),
-]);
+function stringEnum<T extends readonly string[]>(
+  values: T,
+  options: { description?: string; default?: T[number] } = {},
+) {
+  return Type.Unsafe<T[number]>({ type: "string", enum: [...values], ...options });
+}
+
+const WIKI_ACTION_VALUES = ["spaces", "nodes", "get", "search", "create", "move", "rename"] as const;
+const WIKI_OBJ_TYPE_VALUES = ["docx", "sheet", "bitable"] as const;
+
+export const FeishuWikiSchema = Type.Object({
+  action: stringEnum(WIKI_ACTION_VALUES, { description: "Wiki action" }),
+  space_id: Type.Optional(Type.String({ description: "Knowledge space ID" })),
+  parent_node_token: Type.Optional(
+    Type.String({ description: "Parent node token (optional, omit for root)" }),
+  ),
+  token: Type.Optional(Type.String({ description: "Wiki node token (from URL /wiki/XXX)" })),
+  query: Type.Optional(Type.String({ description: "Search query" })),
+  title: Type.Optional(Type.String({ description: "Node title / new title" })),
+  obj_type: Type.Optional(
+    stringEnum(WIKI_OBJ_TYPE_VALUES, {
+      description: "Object type for create action (default: docx)",
+    }),
+  ),
+  node_token: Type.Optional(Type.String({ description: "Node token" })),
+  target_space_id: Type.Optional(
+    Type.String({ description: "Target space ID (optional, same space if omitted)" }),
+  ),
+  target_parent_token: Type.Optional(
+    Type.String({ description: "Target parent node token (optional, root if omitted)" }),
+  ),
+});
 
 export type FeishuWikiParams = Static<typeof FeishuWikiSchema>;