@milerliu/feishu 0.1.16 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milerliu/feishu",
-  "version": "0.1.16",
+  "version": "0.2.0",
   "type": "module",
   "description": "OpenClaw Feishu/Lark channel plugin",
   "license": "MIT",

package/src/send.ts

@@ -18,8 +18,8 @@ export type FeishuMessageInfo = {
 
 /**
  * Send text with streaming effect using Feishu streaming update card.
- * This creates an initial card and then streams updates to it.
  * Uses the official Feishu streaming update card API.
+ * Reference: https://open.feishu.cn/document/cardkit-v1/streaming-updates-openapi-overview
  */
 export async function sendStreamingMessageFeishu(params: {
   cfg: ClawdbotConfig;
@@ -48,34 +48,76 @@ export async function sendStreamingMessageFeishu(params: {
     rawText = buildMentionedMessage(mentions, rawText);
   }
 
-  // Create interactive card with streaming_update enabled
-  const card = {
-    header: {
-      title: {
-        tag: "plain_text",
-        content: "AI 回复",
+  // Create streaming card according to official docs
+  // Reference: https://open.feishu.cn/document/cardkit-v1/streaming-updates-openapi-overview
+  const streamingCard = {
+    schema: "2.0",
+    config: {
+      streaming_mode: true,
+      streaming_config: {
+        print_frequency_ms: {
+          default: 30,
+        },
+        print_step: {
+          default: 2,
+        },
+        print_strategy: "fast",
+      },
+      summary: {
+        content: "AI 正在生成内容...",
       },
     },
-    config: {
-      wide_screen_mode: true,
-      streaming_update: true,
+    body: {
+      elements: [
+        {
+          tag: "markdown",
+          content: "",
+          element_id: "ai_response",
+        },
+      ],
     },
-    elements: [
-      {
-        tag: "markdown",
-        content: rawText,
-      },
-    ],
   };
 
-  const cardContent = JSON.stringify(card);
+  const cardContent = JSON.stringify(streamingCard);
+
+  // Step 1: Create card instance
+  let cardResponse;
+  try {
+    cardResponse = await (client as any).cardkit.v1.card.create({
+      data: {
+        type: "adaptive",
+        data: cardContent,
+      },
+    });
+  } catch (error) {
+    console.error("Failed to create streaming card:", error);
+    // Fallback to regular card
+    const fallbackCard = buildMarkdownCard(rawText);
+    return sendCardFeishu({ cfg, to, card: fallbackCard });
+  }
+
+  if (cardResponse.code !== 0) {
+    console.error(`Card creation failed: ${cardResponse.msg}`);
+    // Fallback to regular card
+    const fallbackCard = buildMarkdownCard(rawText);
+    return sendCardFeishu({ cfg, to, card: fallbackCard });
+  }
+
+  const cardId = cardResponse.data?.card_id;
+  if (!cardId) {
+    console.error("No card_id returned");
+    // Fallback to regular card
+    const fallbackCard = buildMarkdownCard(rawText);
+    return sendCardFeishu({ cfg, to, card: fallbackCard });
+  }
 
-  // Create the card message
+  // Step 2: Send card to chat
+  const messageContent = JSON.stringify({ card_id: cardId });
   const messageResponse = await client.im.message.create({
     params: { receive_id_type: receiveIdType },
     data: {
       receive_id: receiveId,
-      content: cardContent,
+      content: messageContent,
       msg_type: "interactive",
     },
   });
@@ -86,17 +128,56 @@ export async function sendStreamingMessageFeishu(params: {
 
   const messageId = messageResponse.data?.message_id ?? "unknown";
 
-  // Now update the message multiple times for streaming effect
-  // Use im.v1.message.update API
-  const chunkSize = 500;
+  // Step 3: Stream updates using batch_update
+  // Split text into chunks for streaming effect
+  const chunkSize = 10; // Small chunks for streaming effect
   const chunks: string[] = [];
   for (let i = 0; i < rawText.length; i += chunkSize) {
     chunks.push(rawText.slice(i, i + chunkSize));
   }
 
-  // Send updates with delay
+  let cumulativeContent = "";
+  let sequence = 0;
+
   for (let i = 0; i < chunks.length; i++) {
-    const updateCard = {
+    cumulativeContent += chunks[i];
+    sequence = i;
+
+    const actions = JSON.stringify([
+      {
+        action_name: "update_content",
+        action_param: {
+          tag: "markdown",
+          content: cumulativeContent,
+          element_id: "ai_response",
+        },
+      },
+    ]);
+
+    try {
+      await (client as any).cardkit.v1.card.batch_update({
+        path: { card_id: cardId },
+        data: {
+          uuid: `stream-${Date.now()}-${i}`,
+          sequence,
+          actions,
+        },
+      });
+
+      // Small delay between updates for streaming effect
+      if (i < chunks.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+    } catch (error) {
+      console.error(`Streaming update failed at chunk ${i}: ${error}`);
+    }
+  }
+
+  return {
+    messageId,
+    chatId: receiveId,
+  };
+}
       header: {
         title: {
           tag: "plain_text",
@@ -309,19 +390,38 @@ export async function sendCardFeishu(params: SendFeishuCardParams): Promise<Feis
   }
 
   const receiveIdType = resolveReceiveIdType(receiveId);
-  const content = JSON.stringify(card);
+  
+  // Extract content from card for post message
+  const markdownContent = card.elements?.[0]?.content || "";
+  
+  // Build post-type rich text message
+  const postContent = {
+    zh_cn: {
+      title: "AI 回复",
+      content: [
+        [
+          {
+            tag: "text",
+            text: markdownContent,
+          },
+        ],
+      ],
+    },
+  };
+  
+  const content = JSON.stringify(postContent);
 
   if (replyToMessageId) {
     const response = await client.im.message.reply({
       path: { message_id: replyToMessageId },
       data: {
         content,
-        msg_type: "interactive",
+        msg_type: "post",
       },
     });
 
     if (response.code !== 0) {
-      throw new Error(`Feishu card reply failed: ${response.msg || `code ${response.code}`}`);
+      throw new Error(`Feishu post reply failed: ${response.msg || `code ${response.code}`}`);
     }
 
     return {
@@ -335,12 +435,12 @@ export async function sendCardFeishu(params: SendFeishuCardParams): Promise<Feis
     data: {
       receive_id: receiveId,
       content,
-      msg_type: "interactive",
+      msg_type: "post",
     },
   });
 
   if (response.code !== 0) {
-    throw new Error(`Feishu card send failed: ${response.msg || `code ${response.code}`}`);
+    throw new Error(`Feishu post send failed: ${response.msg || `code ${response.code}`}`);
   }
 
   return {