@m1heng-clawd/feishu 0.1.15 → 0.1.17

package/src/reaction-tools/actions.ts

@@ -0,0 +1,127 @@
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import { runFeishuApiCall, type FeishuApiResponse } from "../tools-common/feishu-api.js";
+import type { FeishuReactionParams } from "./schemas.js";
+
+interface ReactionCreateResponse extends FeishuApiResponse {
+  data?: { reaction_id?: string };
+}
+
+interface ReactionListResponse extends FeishuApiResponse {
+  data?: {
+    items?: Array<{
+      reaction_id?: string;
+      reaction_type?: { emoji_type?: string };
+      operator_type?: string;
+      operator_id?: { open_id?: string; user_id?: string; union_id?: string };
+    }>;
+    has_more?: boolean;
+    page_token?: string;
+  };
+}
+
+export async function runReactionAction(
+  client: Lark.Client,
+  params: FeishuReactionParams,
+): Promise<unknown> {
+  switch (params.action) {
+    case "add":
+      return addReaction(client, params);
+    case "remove":
+      return removeReaction(client, params);
+    case "list":
+      return listReactions(client, params);
+  }
+}
+
+async function addReaction(client: Lark.Client, params: FeishuReactionParams) {
+  if (!params.emoji_type) {
+    throw new Error("emoji_type is required for action=add");
+  }
+
+  const response = await runFeishuApiCall<ReactionCreateResponse>(
+    "Feishu add reaction",
+    () =>
+      client.im.messageReaction.create({
+        path: { message_id: params.message_id },
+        data: { reaction_type: { emoji_type: params.emoji_type! } },
+      }) as Promise<ReactionCreateResponse>,
+  );
+
+  return {
+    ok: true,
+    action: "add",
+    message_id: params.message_id,
+    emoji_type: params.emoji_type,
+    reaction_id: response.data?.reaction_id ?? null,
+  };
+}
+
+async function removeReaction(client: Lark.Client, params: FeishuReactionParams) {
+  if (!params.reaction_id) {
+    throw new Error("reaction_id is required for action=remove");
+  }
+
+  await runFeishuApiCall<FeishuApiResponse>(
+    "Feishu remove reaction",
+    () =>
+      client.im.messageReaction.delete({
+        path: {
+          message_id: params.message_id,
+          reaction_id: params.reaction_id!,
+        },
+      }) as Promise<FeishuApiResponse>,
+  );
+
+  return {
+    ok: true,
+    action: "remove",
+    message_id: params.message_id,
+    reaction_id: params.reaction_id,
+  };
+}
+
+async function listReactions(client: Lark.Client, params: FeishuReactionParams) {
+  const allItems: Array<{
+    reaction_id: string;
+    emoji_type: string;
+    operator_type: string;
+    operator_id: string;
+  }> = [];
+
+  let pageToken: string | undefined;
+  do {
+    const response = await runFeishuApiCall<ReactionListResponse>(
+      "Feishu list reactions",
+      () =>
+        client.im.messageReaction.list({
+          path: { message_id: params.message_id },
+          params: {
+            ...(params.emoji_type ? { reaction_type: params.emoji_type } : {}),
+            ...(pageToken ? { page_token: pageToken } : {}),
+            page_size: 50,
+          },
+        }) as Promise<ReactionListResponse>,
+    );
+
+    for (const item of response.data?.items ?? []) {
+      allItems.push({
+        reaction_id: item.reaction_id ?? "",
+        emoji_type: item.reaction_type?.emoji_type ?? "",
+        operator_type: item.operator_type ?? "user",
+        operator_id:
+          item.operator_id?.open_id ?? item.operator_id?.user_id ?? item.operator_id?.union_id ?? "",
+      });
+    }
+
+    pageToken = response.data?.has_more ? (response.data.page_token ?? undefined) : undefined;
+  } while (pageToken);
+
+  return {
+    ok: true,
+    action: "list",
+    message_id: params.message_id,
+    emoji_type_filter: params.emoji_type ?? null,
+    total: allItems.length,
+    reactions: allItems,
+  };
+}

package/src/reaction-tools/index.ts

@@ -0,0 +1,2 @@
+export { registerFeishuReactionTools } from "./register.js";
+export { FeishuReactionSchema, type FeishuReactionParams } from "./schemas.js";

package/src/reaction-tools/register.ts

@@ -0,0 +1,51 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { hasFeishuToolEnabledForAnyAccount, withFeishuToolClient } from "../tools-common/tool-exec.js";
+import { errorResult, json } from "../tools-common/feishu-api.js";
+import { runReactionAction } from "./actions.js";
+import { FeishuReactionSchema, type FeishuReactionParams } from "./schemas.js";
+
+export function registerFeishuReactionTools(api: OpenClawPluginApi) {
+  if (!api.config) {
+    api.logger.debug?.("feishu_reaction: No config available, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config)) {
+    api.logger.debug?.("feishu_reaction: No Feishu accounts configured, skipping");
+    return;
+  }
+
+  if (!hasFeishuToolEnabledForAnyAccount(api.config, "reaction")) {
+    api.logger.debug?.("feishu_reaction: reaction tool disabled in config");
+    return;
+  }
+
+  api.registerTool(
+    {
+      name: "feishu_reaction",
+      label: "Feishu Reaction",
+      description:
+        "Add, remove, or list emoji reactions on Feishu messages. " +
+        "Supported actions: add (add an emoji reaction), remove (remove a reaction by ID), list (list all reactions). " +
+        "Common emoji types: THUMBSUP, THUMBSDOWN, HEART, SMILE, GRINNING, FIRE, CLAP, OK, CHECK, CROSS, PARTY, PRAY. " +
+        "To react to a previous message, first use feishu_message list to find the target message_id.",
+      parameters: FeishuReactionSchema,
+      async execute(_toolCallId, params) {
+        const p = params as FeishuReactionParams;
+        try {
+          return await withFeishuToolClient({
+            api,
+            toolName: "feishu_reaction",
+            requiredTool: "reaction",
+            run: async ({ client }) => json(await runReactionAction(client, p)),
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      },
+    },
+    { name: "feishu_reaction" },
+  );
+
+  api.logger.debug?.("feishu_reaction: Registered feishu_reaction tool");
+}

package/src/reaction-tools/schemas.ts

@@ -0,0 +1,34 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+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 ACTION_VALUES = ["add", "remove", "list"] as const;
+
+export const FeishuReactionSchema = Type.Object({
+  action: stringEnum(ACTION_VALUES, {
+    description:
+      "Action to perform: add (add emoji reaction to a message), remove (remove a reaction by reaction_id), list (list all reactions on a message).",
+  }),
+  message_id: Type.String({
+    description: "Feishu message ID (e.g. om_xxx). Use feishu_message list to find message_ids from chat history.",
+  }),
+  emoji_type: Type.Optional(
+    Type.String({
+      description:
+        "Emoji type to add or filter by (e.g. THUMBSUP, HEART, SMILE, GRINNING, FIRE, CLAP, OK, CHECK, CROSS). " +
+        "Required for action=add. Optional filter for action=list.",
+    }),
+  ),
+  reaction_id: Type.Optional(
+    Type.String({
+      description: "Reaction ID to remove. Required for action=remove. Obtained from add or list results.",
+    }),
+  ),
+});
+
+export type FeishuReactionParams = Static<typeof FeishuReactionSchema>;

package/src/reply-dispatcher.ts

@@ -12,7 +12,7 @@ import { buildMentionedCardContent, type MentionTarget } from "./mention.js";
 import { normalizeFeishuMarkdownLinks } from "./text/markdown-links.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { sendMarkdownCardFeishu, sendMessageFeishu } from "./send.js";
-import { FeishuStreamingSession } from "./streaming-card.js";
+import { FeishuStreamingSession, mergeStreamingText } from "./streaming-card.js";
 import { resolveReceiveIdType } from "./targets.js";
 import { addTypingIndicator, removeTypingIndicator, type TypingIndicatorState } from "./typing.js";
 
@@ -119,39 +119,15 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
   let streaming: FeishuStreamingSession | null = null;
   let streamText = "";
   let lastPartial = "";
+  let streamingCompleted = false;
   let partialUpdateQueue: Promise<void> = Promise.resolve();
   let streamingStartPromise: Promise<void> | null = null;
 
-  const mergeStreamingText = (nextText: string) => {
-    if (!streamText) {
-      streamText = nextText;
-      return;
-    }
-    if (nextText.startsWith(streamText)) {
-      // Handle cumulative partial payloads where nextText already includes prior text.
-      streamText = nextText;
-      return;
-    }
-    if (streamText.endsWith(nextText)) {
-      return;
-    }
-    streamText += nextText;
+  const mergeIntoStreamText = (nextText: string) => {
+    streamText = mergeStreamingText(streamText, nextText);
   };
 
-  const queueStreamingUpdate = (
-    nextText: string,
-    options?: { dedupeWithLastPartial?: boolean },
-  ) => {
-    if (!nextText) {
-      return;
-    }
-    if (options?.dedupeWithLastPartial && nextText === lastPartial) {
-      return;
-    }
-    if (options?.dedupeWithLastPartial) {
-      lastPartial = nextText;
-    }
-    mergeStreamingText(nextText);
+  const enqueueStreamingFlush = () => {
     partialUpdateQueue = partialUpdateQueue.then(async () => {
       if (streamingStartPromise) {
         await streamingStartPromise;
@@ -163,7 +139,7 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
   };
 
   const startStreaming = () => {
-    if (!streamingEnabled || streamingStartPromise || streaming) {
+    if (!streamingEnabled || streamingStartPromise || streaming || streamingCompleted) {
       return;
     }
     streamingStartPromise = (async () => {
@@ -198,6 +174,7 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
         text = buildMentionedCardContent(mentionTargets, text);
       }
       await streaming.close(normalizeFeishuMarkdownLinks(text));
+      streamingCompleted = true;
     }
     streaming = null;
     streamingStartPromise = null;
@@ -247,7 +224,8 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
           if (info?.kind === "block") {
             // Some runtimes emit block payloads without onPartial/final callbacks.
             // Mirror block text into streamText so onIdle close still sends content.
-            queueStreamingUpdate(text);
+            mergeIntoStreamText(text);
+            enqueueStreamingFlush();
           }
           if (info?.kind === "final") {
             streamText = text;
@@ -256,6 +234,13 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
           return;
         }
 
+        // Streaming card already delivered the content — skip regular send to
+        // avoid a duplicate card when the runtime delivers a second payload
+        // after the streaming session has closed (#399).
+        if (streamingCompleted) {
+          return;
+        }
+
         let first = true;
         if (useCard) {
           for (const chunk of core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode)) {
@@ -312,10 +297,15 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
       onPartialReply: streamingEnabled
         ? (payload: ReplyPayload) => {
             const partialText = normalizeFeishuMarkdownLinks(payload.text ?? "");
-            if (!partialText) {
+            if (!partialText || partialText === lastPartial) {
               return;
             }
-            queueStreamingUpdate(partialText, { dedupeWithLastPartial: true });
+            lastPartial = partialText;
+            // Partials are cumulative — replace streamText directly instead of
+            // merging, which avoids duplication when segment boundaries shift
+            // (e.g. after a tool call mid-stream).
+            streamText = partialText;
+            enqueueStreamingFlush();
           }
         : undefined,
     },

package/src/streaming-card.ts

@@ -44,6 +44,21 @@ async function getToken(creds: Credentials): Promise<string> {
   return data.tenant_access_token;
 }
 
+/**
+ * Find the length of the longest suffix of `a` that equals a prefix of `b`.
+ * Used to detect partial overlaps between consecutive streaming segments.
+ * Capped at 500 chars to keep cost bounded.
+ */
+function findOverlapLength(a: string, b: string): number {
+  const max = Math.min(a.length, b.length, 500);
+  for (let len = max; len > 0; len--) {
+    if (a.endsWith(b.slice(0, len))) {
+      return len;
+    }
+  }
+  return 0;
+}
+
 export function mergeStreamingText(
   previousText: string | undefined,
   nextText: string | undefined,
@@ -59,7 +74,14 @@ export function mergeStreamingText(
   if (previous.includes(next)) {
     return previous;
   }
-  // Fallback for fragmented partial chunks: append to avoid losing tokens.
+  // Detect partial overlap: the end of previous matches the start of next.
+  // This happens when partials are cumulative within a segment but don't
+  // include prior segments (e.g. after a tool call mid-stream).
+  const overlap = findOverlapLength(previous, next);
+  if (overlap > 0) {
+    return previous + next.slice(overlap);
+  }
+  // No overlap — truly incremental chunk, just append.
   return `${previous}${next}`;
 }
 
@@ -147,30 +169,30 @@ export class FeishuStreamingSession {
   }
 
   async update(text: string): Promise<void> {
-    if (!this.state || this.closed) {
+    if (!this.state || this.closed || !text) {
       return;
     }
-    const mergedInput = mergeStreamingText(this.pendingText ?? this.state.currentText, text);
-    if (!mergedInput || mergedInput === this.state.currentText) {
+    // Caller sends cumulative full text — no merge needed, just throttle.
+    if (text === this.state.currentText) {
       return;
     }
     const now = Date.now();
     if (now - this.lastUpdateTime < this.updateThrottleMs) {
-      this.pendingText = mergedInput;
+      this.pendingText = text;
       return;
     }
     this.pendingText = null;
     this.lastUpdateTime = now;
 
+    const toSend = text;
     this.queue = this.queue.then(async () => {
       if (!this.state || this.closed) {
         return;
       }
-      const mergedText = mergeStreamingText(this.state.currentText, mergedInput);
-      if (!mergedText || mergedText === this.state.currentText) {
+      if (toSend === this.state.currentText) {
         return;
       }
-      this.state.currentText = mergedText;
+      this.state.currentText = toSend;
       this.state.sequence += 1;
       const apiBase = resolveApiBase(this.creds.domain);
       await fetch(`${apiBase}/cardkit/v1/cards/${this.state.cardId}/elements/content/content`, {
@@ -180,7 +202,7 @@ export class FeishuStreamingSession {
           "Content-Type": "application/json",
         },
         body: JSON.stringify({
-          content: mergedText,
+          content: toSend,
           sequence: this.state.sequence,
           uuid: `s_${this.state.cardId}_${this.state.sequence}`,
         }),
@@ -196,8 +218,9 @@ export class FeishuStreamingSession {
     this.closed = true;
     await this.queue;
 
-    const pendingMerged = mergeStreamingText(this.state.currentText, this.pendingText ?? undefined);
-    const text = finalText ? mergeStreamingText(pendingMerged, finalText) : pendingMerged;
+    // finalText is authoritative when provided (from deliver kind=final).
+    // Fall back to pending or current text when closing via onIdle.
+    const text = finalText || this.pendingText || this.state.currentText;
     const apiBase = resolveApiBase(this.creds.domain);
 
     if (text && text !== this.state.currentText) {

package/src/task-tools/actions.ts

@@ -3,26 +3,33 @@ import os from "node:os";
 import path from "node:path";
 import type { TaskClient } from "./common.js";
 import {
+  TASK_COMMENT_UPDATE_FIELD_VALUES,
   TASKLIST_UPDATE_FIELD_VALUES,
   TASK_UPDATE_FIELD_VALUES,
   type AddTaskToTasklistParams,
   type AddTasklistMembersParams,
+  type CreateTaskCommentParams,
   type CreateTasklistParams,
-  CreateSubtaskParams,
-  CreateTaskParams,
-  DeleteTaskAttachmentParams,
-  GetTaskAttachmentParams,
-  GetTaskParams,
+  type CreateSubtaskParams,
+  type CreateTaskParams,
+  type DeleteTaskAttachmentParams,
+  type DeleteTaskCommentParams,
+  type GetTaskAttachmentParams,
+  type GetTaskCommentParams,
+  type GetTaskParams,
   type GetTasklistParams,
-  ListTaskAttachmentsParams,
+  type ListTaskAttachmentsParams,
+  type ListTaskCommentsParams,
   type ListTasklistsParams,
   type RemoveTaskFromTasklistParams,
   type RemoveTasklistMembersParams,
-  TaskUpdateTask,
+  type TaskCommentPatchComment,
+  type TaskUpdateTask,
   type TasklistPatchTasklist,
-  UploadTaskAttachmentParams,
+  type UploadTaskAttachmentParams,
+  type UpdateTaskCommentParams,
   type UpdateTasklistParams,
-  UpdateTaskParams,
+  type UpdateTaskParams,
 } from "./schemas.js";
 import {
   DEFAULT_TASK_ATTACHMENT_FILENAME,
@@ -36,6 +43,7 @@ import { getFeishuRuntime } from "../runtime.js";
 import { runTaskApiCall } from "./common.js";
 
 const SUPPORTED_PATCH_FIELDS = new Set<string>(TASK_UPDATE_FIELD_VALUES);
+const SUPPORTED_COMMENT_PATCH_FIELDS = new Set<string>(TASK_COMMENT_UPDATE_FIELD_VALUES);
 const SUPPORTED_TASKLIST_PATCH_FIELDS = new Set<string>(TASKLIST_UPDATE_FIELD_VALUES);
 
 function omitUndefined<T extends Record<string, unknown>>(obj: T): T {
@@ -50,10 +58,16 @@ function inferUpdateFields(task: TaskUpdateTask): string[] {
   );
 }
 
+function inferCommentUpdateFields(comment: TaskCommentPatchComment): string[] {
+  return Object.keys(comment).filter((field) =>
+    SUPPORTED_COMMENT_PATCH_FIELDS.has(field),
+  );
+}
+
 function ensureSupportedUpdateFields(
   updateFields: string[],
   supported: Set<string>,
-  resource: "task" | "tasklist",
+  resource: "task" | "comment" | "tasklist",
 ) {
   const invalid = updateFields.filter((field) => !supported.has(field));
   if (invalid.length > 0) {
@@ -102,6 +116,20 @@ function formatTasklist(tasklist: Record<string, unknown> | undefined) {
   };
 }
 
+function formatComment(comment: Record<string, unknown> | undefined) {
+  if (!comment) return undefined;
+  return {
+    id: comment.id,
+    content: comment.content,
+    creator: comment.creator,
+    reply_to_comment_id: comment.reply_to_comment_id,
+    created_at: comment.created_at,
+    updated_at: comment.updated_at,
+    resource_type: comment.resource_type,
+    resource_id: comment.resource_id,
+  };
+}
+
 function formatAttachment(attachment: Record<string, unknown> | undefined) {
   if (!attachment) return undefined;
   return {
@@ -307,6 +335,113 @@ export async function getTask(client: TaskClient, params: GetTaskParams) {
   };
 }
 
+export async function createTaskComment(client: TaskClient, params: CreateTaskCommentParams) {
+  const res = await runTaskApiCall("task.v2.comment.create", () =>
+    client.task.v2.comment.create({
+      data: omitUndefined({
+        content: params.content,
+        reply_to_comment_id: params.reply_to_comment_id,
+        resource_type: "task",
+        resource_id: params.task_guid,
+      }),
+      params: omitUndefined({
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  return {
+    comment: formatComment((res.data?.comment ?? undefined) as Record<string, unknown> | undefined),
+  };
+}
+
+export async function listTaskComments(client: TaskClient, params: ListTaskCommentsParams) {
+  const res = await runTaskApiCall("task.v2.comment.list", () =>
+    client.task.v2.comment.list({
+      params: omitUndefined({
+        resource_type: "task",
+        resource_id: params.task_guid,
+        page_size: params.page_size,
+        page_token: params.page_token,
+        direction: params.direction,
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  const items = (res.data?.items ?? []) as Record<string, unknown>[];
+
+  return {
+    items: items.map((item) => formatComment(item)),
+    page_token: res.data?.page_token,
+    has_more: res.data?.has_more,
+  };
+}
+
+export async function getTaskComment(client: TaskClient, params: GetTaskCommentParams) {
+  const res = await runTaskApiCall("task.v2.comment.get", () =>
+    client.task.v2.comment.get({
+      path: { comment_id: params.comment_id },
+      params: omitUndefined({
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  return {
+    comment: formatComment((res.data?.comment ?? undefined) as Record<string, unknown> | undefined),
+  };
+}
+
+export async function updateTaskComment(client: TaskClient, params: UpdateTaskCommentParams) {
+  const comment = omitUndefined(params.comment as Record<string, unknown>) as TaskCommentPatchComment;
+  const updateFields = params.update_fields?.length
+    ? params.update_fields
+    : inferCommentUpdateFields(comment);
+
+  if (params.update_fields?.length) {
+    ensureSupportedUpdateFields(updateFields, SUPPORTED_COMMENT_PATCH_FIELDS, "comment");
+  }
+
+  if (Object.keys(comment).length === 0) {
+    throw new Error("comment update payload is empty");
+  }
+  if (updateFields.length === 0) {
+    throw new Error("no valid update_fields provided or inferred from comment payload");
+  }
+
+  const res = await runTaskApiCall("task.v2.comment.patch", () =>
+    client.task.v2.comment.patch({
+      path: { comment_id: params.comment_id },
+      data: {
+        comment,
+        update_fields: updateFields,
+      },
+      params: omitUndefined({
+        user_id_type: params.user_id_type,
+      }),
+    }),
+  );
+
+  return {
+    comment: formatComment((res.data?.comment ?? undefined) as Record<string, unknown> | undefined),
+    update_fields: updateFields,
+  };
+}
+
+export async function deleteTaskComment(client: TaskClient, params: DeleteTaskCommentParams) {
+  await runTaskApiCall("task.v2.comment.delete", () =>
+    client.task.v2.comment.delete({
+      path: { comment_id: params.comment_id },
+    }),
+  );
+
+  return {
+    success: true,
+    comment_id: params.comment_id,
+  };
+}
+
 export async function getTasklist(client: TaskClient, params: GetTasklistParams) {
   const res = await runTaskApiCall("task.v2.tasklist.get", () =>
     client.task.v2.tasklist.get({