@milerliu/feishu 0.1.5 → 0.1.9

package/package.json

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

package/src/reply-dispatcher.ts

@@ -118,8 +118,8 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
         // Only include @mentions in the first chunk (avoid duplicate @s)
         let isFirstChunk = true;
 
-        // Streaming mode: use streaming card for better experience
-        if (streamingEnabled && useCard && !replyToMessageId) {
+        // Streaming mode: use streaming card for all messages (regardless of content type)
+        if (streamingEnabled) {
           params.runtime.log?.(`feishu deliver: using streaming mode for text (${text.length} chars)`);
           await sendStreamingMessageFeishu({
             cfg,

package/src/send.ts

@@ -91,70 +91,49 @@ export async function sendStreamingMessageFeishu(params: {
 
   const messageId = response.data?.message_id ?? "unknown";
 
-  // Extract card_id from response if available
+  // Extract card_id from response
   const cardData = response.data as Record<string, unknown> | undefined;
   const cardId = cardData?.card_id as string | undefined;
 
   if (!cardId) {
     console.warn('No card_id returned, falling back to regular card send');
-    // Fallback: send as regular card if no card_id
     const fallbackCard = buildMarkdownCard(messageText);
     return sendCardFeishu({ cfg, to, card: fallbackCard });
   }
 
-  // Stream the content updates using card_id
-  // Split content into chunks for streaming effect
-  const chunkSize = 300; // Smaller chunks for smoother streaming
+  // Stream content updates using Feishu cardkit batch_update API
+  const chunkSize = 300;
   const chunks: string[] = [];
-
   for (let i = 0; i < messageText.length; i += chunkSize) {
     chunks.push(messageText.slice(i, i + chunkSize));
   }
 
-  // Send updates with small delay between each using the correct API
+  // Send updates with small delay
   for (let i = 0; i < chunks.length; i++) {
     const partialContent = chunks.slice(0, i + 1).join("");
-
-    const updateCard = {
-      header: {
-        title: {
-          tag: "plain_text",
-          content: "AI 回复",
-        },
-      },
-      config: {
-        wide_screen_mode: true,
-        streaming_update: true,
-      },
-      elements: [
-        {
-          tag: "markdown",
-          content: partialContent,
-        },
-      ],
-    };
-
-    const updateContent = JSON.stringify(updateCard);
-
-    // Use PATCH /im/message/:message_id with card_id for streaming update
-    // Note: This is the official streaming update method
+    
     try {
-      const updateResponse = await (client.im.message as Record<string, unknown>).patch?.({
-        path: { message_id: messageId },
+      // Use cardkit v1 API for batch update
+      const updateResponse = await (client as any).cardkit.v1.cards.batch_update({
+        path: { card_id: cardId },
         data: {
-          msg_type: "interactive",
-          content: updateContent,
+          card: {
+            header: {
+              title: { tag: "plain_text", content: "AI 回复" },
+            },
+            config: { wide_screen_mode: true, streaming_update: true },
+            elements: [{ tag: "markdown", content: partialContent }],
+          },
         },
-      }) ?? { code: -1, msg: "API not available" };
+      });
 
-      if ((updateResponse as Record<string, unknown>).code !== 0) {
-        console.error(`Feishu streaming update failed: ${(updateResponse as Record<string, unknown>).msg}`);
+      if (updateResponse.code !== 0) {
+        console.error(`Cardkit batch update failed: ${updateResponse.msg}`);
       }
     } catch (err) {
-      console.error(`Feishu streaming update error: ${err}`);
+      console.error(`Cardkit update error: ${err}`);
     }
 
-    // Add small delay between updates for streaming effect
     if (i < chunks.length - 1) {
       await new Promise((resolve) => setTimeout(resolve, 150));
     }