@m1heng-clawd/feishu 0.1.14 → 0.1.15

package/src/reply-dispatcher.ts

@@ -16,6 +16,24 @@ import { FeishuStreamingSession } from "./streaming-card.js";
 import { resolveReceiveIdType } from "./targets.js";
 import { addTypingIndicator, removeTypingIndicator, type TypingIndicatorState } from "./typing.js";
 
+/** Maximum age (ms) for a message to receive a typing indicator reaction.
+ * Messages older than this are likely replays after context compaction (#30418). */
+const TYPING_INDICATOR_MAX_AGE_MS = 2 * 60_000;
+
+/** Minimum value to treat a timestamp as epoch-milliseconds vs epoch-seconds. */
+const MS_EPOCH_MIN = 1_000_000_000_000;
+
+/**
+ * Normalize a timestamp to epoch-milliseconds.
+ * Some Feishu payloads use epoch-seconds; values below 1e12 are treated as such.
+ */
+function normalizeEpochMs(timestamp: number | undefined): number | undefined {
+  if (!Number.isFinite(timestamp) || timestamp === undefined || timestamp <= 0) {
+    return undefined;
+  }
+  return timestamp < MS_EPOCH_MIN ? timestamp * 1000 : timestamp;
+}
+
 /** Detect if text contains markdown elements that benefit from card rendering */
 function shouldUseCard(text: string): boolean {
   return /```[\s\S]*?```/.test(text) || /\|.+\|[\r\n]+\|[-:| ]+\|/.test(text);
@@ -29,11 +47,14 @@ export type CreateFeishuReplyDispatcherParams = {
   replyToMessageId?: string;
   mentionTargets?: MentionTarget[];
   accountId?: string;
+  /** Epoch ms when the inbound message was created. Used to suppress typing
+   *  indicators on old/replayed messages after context compaction (#30418). */
+  messageCreateTimeMs?: number;
 };
 
 export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherParams) {
   const core = getFeishuRuntime();
-  const { cfg, agentId, chatId, replyToMessageId, mentionTargets, accountId } = params;
+  const { cfg, agentId, chatId, replyToMessageId, mentionTargets, accountId, messageCreateTimeMs } = params;
   const account = resolveFeishuAccount({ cfg, accountId });
   const prefixContext = createReplyPrefixContext({ cfg, agentId });
 
@@ -43,6 +64,21 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
       if (!replyToMessageId) {
         return;
       }
+      // Skip typing indicator for old messages — likely replays after context
+      // compaction that would flood users with stale notifications (#30418).
+      const normalizedCreateTime = normalizeEpochMs(messageCreateTimeMs);
+      if (
+        normalizedCreateTime !== undefined &&
+        Date.now() - normalizedCreateTime > TYPING_INDICATOR_MAX_AGE_MS
+      ) {
+        return;
+      }
+      // Feishu reactions persist until explicitly removed, so skip keepalive
+      // re-adds when a reaction already exists. Re-adding the same emoji
+      // triggers a new push notification for every call (#28660).
+      if (typingState?.reactionId) {
+        return;
+      }
       typingState = await addTypingIndicator({ cfg, messageId: replyToMessageId, accountId });
     },
     stop: async () => {
@@ -86,6 +122,46 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
   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 queueStreamingUpdate = (
+    nextText: string,
+    options?: { dedupeWithLastPartial?: boolean },
+  ) => {
+    if (!nextText) {
+      return;
+    }
+    if (options?.dedupeWithLastPartial && nextText === lastPartial) {
+      return;
+    }
+    if (options?.dedupeWithLastPartial) {
+      lastPartial = nextText;
+    }
+    mergeStreamingText(nextText);
+    partialUpdateQueue = partialUpdateQueue.then(async () => {
+      if (streamingStartPromise) {
+        await streamingStartPromise;
+      }
+      if (streaming?.isActive()) {
+        await streaming.update(streamText);
+      }
+    });
+  };
+
   const startStreaming = () => {
     if (!streamingEnabled || streamingStartPromise || streaming) {
       return;
@@ -148,7 +224,19 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
 
         const useCard = renderMode === "card" || (renderMode === "auto" && shouldUseCard(text));
 
-        if ((info?.kind === "block" || info?.kind === "final") && streamingEnabled && useCard) {
+        if (info?.kind === "block") {
+          // Drop internal block chunks unless we can safely consume them as
+          // streaming-card fallback content (#31723).
+          if (!(streamingEnabled && useCard)) {
+            return;
+          }
+          startStreaming();
+          if (streamingStartPromise) {
+            await streamingStartPromise;
+          }
+        }
+
+        if (info?.kind === "final" && streamingEnabled && useCard) {
           startStreaming();
           if (streamingStartPromise) {
             await streamingStartPromise;
@@ -156,6 +244,11 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
         }
 
         if (streaming?.isActive()) {
+          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);
+          }
           if (info?.kind === "final") {
             streamText = text;
             await closeStreaming();
@@ -219,19 +312,10 @@ export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherP
       onPartialReply: streamingEnabled
         ? (payload: ReplyPayload) => {
             const partialText = normalizeFeishuMarkdownLinks(payload.text ?? "");
-            if (!partialText || partialText === lastPartial) {
+            if (!partialText) {
               return;
             }
-            lastPartial = partialText;
-            streamText = partialText;
-            partialUpdateQueue = partialUpdateQueue.then(async () => {
-              if (streamingStartPromise) {
-                await streamingStartPromise;
-              }
-              if (streaming?.isActive()) {
-                await streaming.update(streamText);
-              }
-            });
+            queueStreamingUpdate(partialText, { dedupeWithLastPartial: true });
           }
         : undefined,
     },

package/src/send.ts

@@ -6,7 +6,7 @@ import { createFeishuClient } from "./client.js";
 import { normalizeFeishuMarkdownLinks } from "./text/markdown-links.js";
 import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";
 import { getFeishuRuntime } from "./runtime.js";
-import { resolveFeishuAccount } from "./accounts.js";
+import { listFeishuAccountIds, resolveFeishuAccount } from "./accounts.js";
 
 export type FeishuMessageInfo = {
   messageId: string;
@@ -18,6 +18,313 @@ export type FeishuMessageInfo = {
   createTime?: number;
 };
 
+const MERGE_FORWARD_NAME_CACHE_TTL_MS = 10 * 60 * 1000;
+const mergeForwardSenderNameCache = new Map<string, { name: string; expireAt: number }>();
+const mergeForwardBotNameCache = new Map<string, { name: string; expireAt: number }>();
+const mergeForwardAppNameCache = new Map<string, { name: string; expireAt: number }>();
+
+type MergeForwardMention = {
+  key?: string;
+  id?: string;
+  id_type?: string;
+  name?: string;
+};
+
+function escapeRegExp(raw: string): string {
+  return raw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function buildMentionDisplayName(mention: MergeForwardMention): string | undefined {
+  const mentionName = mention.name?.trim();
+  if (mentionName) return mentionName;
+  const mentionId = mention.id?.trim();
+  if (!mentionId) return undefined;
+  const mentionIdType = mention.id_type?.trim();
+  return mentionIdType ? `${mentionIdType}:${mentionId}` : mentionId;
+}
+
+function replaceFeishuMentionPlaceholders(raw: string, mentions?: MergeForwardMention[]): string {
+  if (!raw) return raw;
+  let text = raw;
+
+  if (Array.isArray(mentions)) {
+    for (const mention of mentions) {
+      const key = mention.key?.trim();
+      if (!key) continue;
+      const displayName = buildMentionDisplayName(mention);
+      if (!displayName) continue;
+      text = text.replace(new RegExp(escapeRegExp(key), "g"), `@${displayName}`);
+    }
+  }
+
+  // Feishu text payloads may keep unresolved placeholders like "@_user_1".
+  return text.replace(/@_user_\d+\b/g, "@mentioned");
+}
+
+async function resolveCurrentBotName(params: {
+  client: any;
+  appId: string;
+}): Promise<string | undefined> {
+  const cacheKey = `bot:${params.appId}`;
+  const now = Date.now();
+  const cached = mergeForwardBotNameCache.get(cacheKey);
+  if (cached && cached.expireAt > now) {
+    return cached.name;
+  }
+
+  if (typeof params.client?.request !== "function") return undefined;
+
+  try {
+    const response = await params.client.request({
+      method: "GET",
+      url: "/open-apis/bot/v3/info",
+      data: {},
+    });
+    const botName = response?.data?.bot?.app_name;
+    if (typeof botName === "string" && botName.trim()) {
+      const normalized = botName.trim();
+      mergeForwardBotNameCache.set(cacheKey, {
+        name: normalized,
+        expireAt: now + MERGE_FORWARD_NAME_CACHE_TTL_MS,
+      });
+      return normalized;
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function resolveAppNameById(params: {
+  client: any;
+  accountId: string;
+  appId: string;
+}): Promise<string | undefined> {
+  const appId = params.appId.trim();
+  if (!appId) return undefined;
+
+  const cacheKey = `${params.accountId}:${appId}`;
+  const now = Date.now();
+  const cached = mergeForwardAppNameCache.get(cacheKey);
+  if (cached && cached.expireAt > now) {
+    return cached.name;
+  }
+
+  if (typeof params.client?.request !== "function") return undefined;
+
+  try {
+    const response = await params.client.request({
+      method: "GET",
+      url: `/open-apis/application/v6/applications/${encodeURIComponent(appId)}`,
+      params: {
+        lang: "en_us",
+      },
+    });
+    const appName = response?.data?.app?.app_name;
+    if (typeof appName === "string" && appName.trim()) {
+      const normalized = appName.trim();
+      mergeForwardAppNameCache.set(cacheKey, {
+        name: normalized,
+        expireAt: now + MERGE_FORWARD_NAME_CACHE_TTL_MS,
+      });
+      return normalized;
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Resolves a configured account's display name and accountId key by appId.
+ * A single pass over the account list covers both the explicit-name lookup
+ * and the accountId fallback label, avoiding duplicate iteration.
+ */
+function resolveConfiguredAppLabel(params: {
+  cfg: ClawdbotConfig;
+  appId: string;
+}): { displayName: string | undefined; accountId: string | undefined } {
+  const targetAppId = params.appId.trim();
+  if (!targetAppId) return { displayName: undefined, accountId: undefined };
+
+  for (const accountId of listFeishuAccountIds(params.cfg)) {
+    const resolved = resolveFeishuAccount({ cfg: params.cfg, accountId });
+    if (!resolved.configured) continue;
+    if (resolved.appId !== targetAppId) continue;
+    return { displayName: resolved.name?.trim() || undefined, accountId };
+  }
+
+  return { displayName: undefined, accountId: undefined };
+}
+
+function replaceConfiguredAppIdTokens(params: {
+  content: string;
+  cfg: ClawdbotConfig;
+}): string {
+  if (!params.content) return params.content;
+  return params.content.replace(/\bapp_id:(cli_[a-z0-9]+)\b/g, (raw, appId: string) => {
+    const { displayName, accountId } = resolveConfiguredAppLabel({ cfg: params.cfg, appId });
+    return displayName ?? accountId ?? raw;
+  });
+}
+
+function extractPlainTextFromMessageBody(
+  rawContent: string,
+  msgType?: string,
+  mentions?: MergeForwardMention[],
+): string {
+  let content = rawContent;
+  try {
+    const parsed = JSON.parse(rawContent);
+    if (msgType === "text" && parsed.text) {
+      return replaceFeishuMentionPlaceholders(parsed.text, mentions);
+    }
+    if (typeof parsed.text === "string" && parsed.text.trim()) {
+      return replaceFeishuMentionPlaceholders(parsed.text, mentions);
+    }
+    if (typeof parsed.title === "string" && parsed.title.trim()) {
+      return parsed.title;
+    }
+    if (parsed.content || parsed.elements) {
+      // Extract plain text from rich text (post) or interactive (card) format.
+      // Both use nested arrays: Array<Array<{tag, text?, href?, ...}>>
+      const blocks = parsed.content ?? parsed.elements ?? [];
+      const lines: string[] = [];
+      for (const paragraph of blocks) {
+        if (!Array.isArray(paragraph)) continue;
+        const line = paragraph
+          .map((node: { tag?: string; text?: string; href?: string }) => {
+            if (node.tag === "text") return node.text ?? "";
+            if (node.tag === "a") return node.text ?? node.href ?? "";
+            if (node.tag === "at") return "";
+            if (node.tag === "img") return "[Image]";
+            return node.text ?? "";
+          })
+          .join("");
+        if (line.trim()) lines.push(line);
+      }
+      const extracted = (parsed.title ? parsed.title + "\n" : "") + lines.join("\n");
+      // Filter out Feishu's degraded card placeholder text
+      if (extracted.trim() && !extracted.includes("请升级至最新版本客户端")) {
+        content = extracted;
+      } else if (extracted.includes("请升级至最新版本客户端")) {
+        content = "[Card message]";
+      }
+    }
+  } catch {
+    // Keep raw content if parsing fails
+  }
+  return replaceFeishuMentionPlaceholders(content, mentions);
+}
+
+function extractSenderLabelFromMessageBody(rawContent: string): string | undefined {
+  try {
+    const parsed = JSON.parse(rawContent);
+    const senderName = parsed?.sender_name || parsed?.sender?.name;
+    if (typeof senderName === "string" && senderName.trim()) {
+      return senderName.trim();
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function buildMergeForwardSenderLabel(params: {
+  cfg: ClawdbotConfig;
+  rawContent: string;
+  client: any;
+  accountId: string;
+  sender?: {
+    id?: string;
+    id_type?: string;
+    sender_type?: string;
+  };
+}): Promise<string | undefined> {
+  const senderName = extractSenderLabelFromMessageBody(params.rawContent);
+  if (senderName) return Promise.resolve(senderName);
+
+  const senderId = params.sender?.id?.trim();
+  const senderIdType = params.sender?.id_type?.trim();
+  const senderType = params.sender?.sender_type?.trim();
+  if (!senderId) return Promise.resolve(undefined);
+
+  const localFallback = senderIdType ? `${senderIdType}:${senderId}` : senderId;
+
+  if (senderType === "app") {
+    const { displayName: configuredName, accountId: configuredAccountId } = resolveConfiguredAppLabel({
+      cfg: params.cfg,
+      appId: senderId,
+    });
+    if (configuredName) return Promise.resolve(configuredName);
+
+    if (senderIdType === "app_id") {
+      // For configured accounts, call /bot/v3/info with their own credentials to get the
+      // actual Feishu display name — no special application:read permissions required.
+      if (configuredAccountId !== undefined) {
+        const acct = resolveFeishuAccount({ cfg: params.cfg, accountId: configuredAccountId });
+        if (acct.configured) {
+          // Isolate client creation so a synchronous throw doesn't propagate to getMessageFeishu's
+          // outer catch and cause the entire message fetch to fail.
+          let botClient: ReturnType<typeof createFeishuClient>;
+          try {
+            botClient = createFeishuClient(acct);
+          } catch {
+            return Promise.resolve(configuredAccountId);
+          }
+          return resolveCurrentBotName({
+            client: botClient,
+            appId: senderId,
+          }).then((name) => name ?? configuredAccountId);
+        }
+      }
+      // Unconfigured bots: best-effort via application info API.
+      return resolveAppNameById({
+        client: params.client,
+        accountId: params.accountId,
+        appId: senderId,
+      }).then((name) => name ?? localFallback);
+    }
+    return Promise.resolve(localFallback);
+  }
+
+  // Best-effort contact lookup to recover missing sender names in merge_forward children.
+  // Supported id types for contact API lookup: open_id / user_id / union_id.
+  const lookupType =
+    senderIdType === "open_id" || senderIdType === "user_id" || senderIdType === "union_id"
+      ? senderIdType
+      : undefined;
+  const contactGet = params.client?.contact?.user?.get;
+  if (!lookupType || typeof contactGet !== "function") {
+    return Promise.resolve(localFallback);
+  }
+
+  const cacheKey = `${params.accountId}:${lookupType}:${senderId}`;
+  const now = Date.now();
+  const cached = mergeForwardSenderNameCache.get(cacheKey);
+  if (cached && cached.expireAt > now) {
+    return Promise.resolve(cached.name);
+  }
+
+  return contactGet({
+    path: { user_id: senderId },
+    params: { user_id_type: lookupType },
+  })
+    .then((res: any) => {
+      const resolvedName =
+        res?.data?.user?.name ||
+        res?.data?.user?.nickname;
+      const finalName =
+        typeof resolvedName === "string" && resolvedName.trim() ? resolvedName.trim() : localFallback;
+      mergeForwardSenderNameCache.set(cacheKey, {
+        name: finalName,
+        expireAt: now + MERGE_FORWARD_NAME_CACHE_TTL_MS,
+      });
+      return finalName;
+    })
+    .catch(() => localFallback);
+}
+
 /**
  * Get a message by its ID.
  * Useful for fetching quoted/replied message content.
@@ -52,6 +359,12 @@ export async function getMessageFeishu(params: {
             id_type?: string;
             sender_type?: string;
           };
+          mentions?: Array<{
+            key?: string;
+            id?: string;
+            id_type?: string;
+            name?: string;
+          }>;
           create_time?: string;
         }>;
       };
@@ -61,55 +374,60 @@ export async function getMessageFeishu(params: {
       return null;
     }
 
-    const item = response.data?.items?.[0];
-    if (!item) {
+    const items = response.data?.items;
+    if (!items || items.length === 0) {
       return null;
     }
 
-    // Parse content based on message type
-    let content = item.body?.content ?? "";
-    try {
-      const parsed = JSON.parse(content);
-      if (item.msg_type === "text" && parsed.text) {
-        content = parsed.text;
-      } else if (parsed.content || parsed.elements) {
-        // Extract plain text from rich text (post) or interactive (card) format.
-        // Both use nested arrays: Array<Array<{tag, text?, href?, ...}>>
-        const blocks = parsed.content ?? parsed.elements ?? [];
-        const lines: string[] = [];
-        for (const paragraph of blocks) {
-          if (!Array.isArray(paragraph)) continue;
-          const line = paragraph
-            .map((node: { tag?: string; text?: string; href?: string }) => {
-              if (node.tag === "text") return node.text ?? "";
-              if (node.tag === "a") return node.text ?? node.href ?? "";
-              if (node.tag === "at") return "";
-              if (node.tag === "img") return "[图片]";
-              return node.text ?? "";
-            })
-            .join("");
-          if (line.trim()) lines.push(line);
-        }
-        const extracted = (parsed.title ? parsed.title + "\n" : "") + lines.join("\n");
-        // Filter out Feishu's degraded card placeholder text
-        if (extracted.trim() && !extracted.includes("请升级至最新版本客户端")) {
-          content = extracted;
-        } else if (extracted.includes("请升级至最新版本客户端")) {
-          content = "[卡片消息]";
+    // For merge_forward type, items contains the merge message + child messages.
+    // Use child messages when present; otherwise fall back to first item for safety.
+    const isMergeForward = items[0]?.msg_type === "merge_forward";
+    const hasExpandedMergeForwardChildren = isMergeForward && items.length > 1;
+    const messagesToProcess = hasExpandedMergeForwardChildren ? items.slice(1) : items.slice(0, 1);
+
+    // Parse each message and combine content.
+    const parsedContents: string[] = [];
+    for (const item of messagesToProcess) {
+      const rawContent = item.body?.content ?? "";
+      const extractedContent = extractPlainTextFromMessageBody(rawContent, item.msg_type, item.mentions);
+      const content = isMergeForward
+        ? replaceConfiguredAppIdTokens({
+            content: extractedContent,
+            cfg,
+          })
+        : extractedContent;
+      if (content.trim()) {
+        // Add sender label only for merge_forward expanded child messages.
+        let prefix = "";
+        if (hasExpandedMergeForwardChildren) {
+          const senderLabel = await buildMergeForwardSenderLabel({
+            cfg,
+            rawContent,
+            client,
+            accountId: account.accountId,
+            sender: item.sender,
+          });
+          if (senderLabel) {
+            prefix = `[${senderLabel}] `;
+          }
         }
+        parsedContents.push(prefix + content.trim());
       }
-    } catch {
-      // Keep raw content if parsing fails
     }
 
+    const combinedContent = hasExpandedMergeForwardChildren
+      ? parsedContents.join("\n\n---\n\n")
+      : (parsedContents[0] ?? "");
+    const firstItem = items[0];
+
     return {
-      messageId: item.message_id ?? messageId,
-      chatId: item.chat_id ?? "",
-      senderId: item.sender?.id,
-      senderOpenId: item.sender?.id_type === "open_id" ? item.sender?.id : undefined,
-      content,
-      contentType: item.msg_type ?? "text",
-      createTime: item.create_time ? parseInt(item.create_time, 10) : undefined,
+      messageId: firstItem?.message_id ?? messageId,
+      chatId: firstItem?.chat_id ?? "",
+      senderId: firstItem?.sender?.id,
+      senderOpenId: firstItem?.sender?.id_type === "open_id" ? firstItem?.sender?.id : undefined,
+      content: combinedContent,
+      contentType: firstItem?.msg_type ?? "text",
+      createTime: firstItem?.create_time ? parseInt(firstItem.create_time, 10) : undefined,
     };
   } catch {
     return null;

package/src/streaming-card.ts

@@ -44,6 +44,25 @@ async function getToken(creds: Credentials): Promise<string> {
   return data.tenant_access_token;
 }
 
+export function mergeStreamingText(
+  previousText: string | undefined,
+  nextText: string | undefined,
+): string {
+  const previous = typeof previousText === "string" ? previousText : "";
+  const next = typeof nextText === "string" ? nextText : "";
+  if (!next) {
+    return previous;
+  }
+  if (!previous || next === previous || next.includes(previous)) {
+    return next;
+  }
+  if (previous.includes(next)) {
+    return previous;
+  }
+  // Fallback for fragmented partial chunks: append to avoid losing tokens.
+  return `${previous}${next}`;
+}
+
 function truncateSummary(text: string, max = 50): string {
   if (!text) {
     return "";
@@ -131,9 +150,13 @@ export class FeishuStreamingSession {
     if (!this.state || this.closed) {
       return;
     }
+    const mergedInput = mergeStreamingText(this.pendingText ?? this.state.currentText, text);
+    if (!mergedInput || mergedInput === this.state.currentText) {
+      return;
+    }
     const now = Date.now();
     if (now - this.lastUpdateTime < this.updateThrottleMs) {
-      this.pendingText = text;
+      this.pendingText = mergedInput;
       return;
     }
     this.pendingText = null;
@@ -143,7 +166,11 @@ export class FeishuStreamingSession {
       if (!this.state || this.closed) {
         return;
       }
-      this.state.currentText = text;
+      const mergedText = mergeStreamingText(this.state.currentText, mergedInput);
+      if (!mergedText || mergedText === this.state.currentText) {
+        return;
+      }
+      this.state.currentText = mergedText;
       this.state.sequence += 1;
       const apiBase = resolveApiBase(this.creds.domain);
       await fetch(`${apiBase}/cardkit/v1/cards/${this.state.cardId}/elements/content/content`, {
@@ -153,7 +180,7 @@ export class FeishuStreamingSession {
           "Content-Type": "application/json",
         },
         body: JSON.stringify({
-          content: text,
+          content: mergedText,
           sequence: this.state.sequence,
           uuid: `s_${this.state.cardId}_${this.state.sequence}`,
         }),
@@ -169,7 +196,8 @@ export class FeishuStreamingSession {
     this.closed = true;
     await this.queue;
 
-    const text = finalText ?? this.pendingText ?? this.state.currentText;
+    const pendingMerged = mergeStreamingText(this.state.currentText, this.pendingText ?? undefined);
+    const text = finalText ? mergeStreamingText(pendingMerged, finalText) : pendingMerged;
     const apiBase = resolveApiBase(this.creds.domain);
 
     if (text && text !== this.state.currentText) {