@m1heng-clawd/feishu 0.1.16 → 0.1.18

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/text/markdown-links.ts

@@ -91,8 +91,23 @@ function normalizeNonCodeSegments(text: string): string {
     .join("");
 }
 
+function normalizeCodeBlockFences(block: string): string {
+  const lines = block.split("\n");
+  return lines
+    .map((line) => {
+      // Fix opening and closing fences: remove leading whitespace
+      if (line.match(/^\s*```/)) {
+        return line.replace(/^\s+/, "");
+      }
+      return line;
+    })
+    .join("\n");
+}
+
 export function normalizeFeishuMarkdownLinks(text: string): string {
-  if (!text || (!text.includes("http://") && !text.includes("https://"))) {
+  if (!text) return text;
+  text = normalizeCodeBlockFences(text);
+  if (!text.includes("http://") && !text.includes("https://")) {
     return text;
   }
 

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

@@ -5,6 +5,7 @@ export type FeishuToolContext = {
   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 = {