@milerliu/feishu 0.1.11 → 0.1.13

package/package.json

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

package/src/send.ts

@@ -41,88 +41,116 @@ export async function sendStreamingMessageFeishu(params: {
   }
 
   const receiveIdType = resolveReceiveIdType(receiveId);
-  const tableMode = getFeishuRuntime().channel.text.resolveMarkdownTableMode({
-    cfg,
-    channel: "feishu",
-  });
 
-  // Build message content (with @mention support)
+  // Build message content with @mention support
   let rawText = text ?? "";
   if (mentions && mentions.length > 0) {
-    rawText = buildMentionedCardContent(mentions, rawText);
+    rawText = buildMentionedMessage(mentions, rawText);
   }
-  const messageText = getFeishuRuntime().channel.text.convertMarkdownTables(rawText, tableMode);
 
-  // Build initial card with streaming_update header for proper streaming behavior
+  // Create streaming card
+  // Using inline card (type: "adaptive") instead of template for dynamic content
   const initialCard = {
-    header: {
-      title: {
-        tag: "plain_text",
-        content: "AI 回复",
-      },
-    },
+    type: "adaptive",
     config: {
       wide_screen_mode: true,
-      streaming_update: true, // Enable streaming update mode
+      streaming_update: true,
     },
     elements: [
       {
         tag: "markdown",
-        content: "",
+        content: rawText,
       },
     ],
   };
 
-  const content = JSON.stringify(initialCard);
+  const cardContent = JSON.stringify(initialCard);
 
-  // Create initial card with empty content
-  const response = await client.im.message.create({
-    params: { receive_id_type: receiveIdType },
+  // Create card instance
+  const cardResponse = await (client as any).cardkit.v1.card.create({
     data: {
-      receive_id: receiveId,
-      content,
-      msg_type: "interactive",
+      type: "adaptive",
+      data: cardContent,
     },
   });
 
-  if (response.code !== 0) {
-    throw new Error(`Feishu streaming card creation failed: ${response.msg || `code ${response.code}`}`);
+  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 messageId = response.data?.message_id ?? "unknown";
-
-  // Extract card_id from response
-  const cardData = response.data as Record<string, unknown> | undefined;
-  const cardId = cardData?.card_id as string | undefined;
-
+  const cardId = cardResponse.data?.card_id;
   if (!cardId) {
-    console.warn('No card_id returned, falling back to regular card send');
-    const fallbackCard = buildMarkdownCard(messageText);
+    console.error('No card_id returned');
+    const fallbackCard = buildMarkdownCard(rawText);
     return sendCardFeishu({ cfg, to, card: fallbackCard });
   }
 
-  // Send multiple messages with delay to simulate streaming effect
-  const chunkSize = 500;
-  const chunks: string[] = [];
-  for (let i = 0; i < messageText.length; i += chunkSize) {
-    chunks.push(messageText.slice(i, i + chunkSize));
+  // Send the card as a message
+  const messageContent = JSON.stringify({ card_id: cardId });
+  const messageResponse = await client.im.message.create({
+    params: { receive_id_type: receiveIdType },
+    data: {
+      receive_id: receiveId,
+      content: messageContent,
+      msg_type: "interactive",
+    },
+  });
+
+  if (messageResponse.code !== 0) {
+    throw new Error(`Failed to send streaming card: ${messageResponse.msg || `code ${messageResponse.code}`}`);
   }
 
-  // Send first message
-  const firstCard = buildMarkdownCard(chunks[0]);
-  const firstResult = await sendCardFeishu({ cfg, to, card: firstCard });
+  const messageId = messageResponse.data?.message_id ?? "unknown";
 
-  // Send remaining chunks as separate messages
-  for (let i = 1; i < chunks.length; i++) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    const chunkCard = buildMarkdownCard(chunks[i]);
-    await sendCardFeishu({ cfg, to, card: chunkCard });
+  // Now perform streaming updates using batch_update
+  // Split text into chunks for streaming
+  const chunkSize = 300;
+  const chunks: string[] = [];
+  for (let i = 0; i < rawText.length; i += chunkSize) {
+    chunks.push(rawText.slice(i, i + chunkSize));
   }
 
-  return {
-    messageId: firstResult.messageId,
-    chatId: receiveId,
-  };
+  // Perform streaming updates
+  for (let i = 0; i < chunks.length; i++) {
+    const uuid = crypto.randomUUID?.() ?? `${Date.now()}-${i}`;
+    const sequence = i;
+    
+    const updateAction = JSON.stringify({
+      tag: "markdown",
+      content: chunks[i],
+    });
+
+    const actions = JSON.stringify([
+      {
+        action_name: "update_content",
+        action_param: {
+          tag: "markdown",
+          content: chunks[i],
+        },
+      },
+    ]);
+
+    try {
+      await (client as any).cardkit.v1.card.batch_update({
+        path: { card_id: cardId },
+        data: {
+          uuid,
+          sequence,
+          actions,
+        },
+      });
+
+      // Delay between updates for streaming effect
+      if (i < chunks.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    } catch (err) {
+      console.error(`Streaming update failed at chunk ${i}: ${err}`);
+    }
+  }
 
   return {
     messageId,