@openclaw-plugins/feishu-plus 0.1.7-fork.1

package/src/reply-dispatcher.ts

@@ -0,0 +1,225 @@
+import {
+  createReplyPrefixContext,
+  createTypingCallbacks,
+  logTypingFailure,
+  type ClawdbotConfig,
+  type RuntimeEnv,
+  type ReplyPayload,
+} from "openclaw/plugin-sdk";
+import { getFeishuRuntime } from "./runtime.js";
+import { sendMessageFeishu, sendMarkdownCardFeishu } from "./send.js";
+import type { FeishuConfig } from "./types.js";
+import type { MentionTarget } from "./mention.js";
+import { resolveFeishuAccount } from "./accounts.js";
+import {
+  addTypingIndicator,
+  removeTypingIndicator,
+  type TypingIndicatorState,
+} from "./typing.js";
+import { createFeishuStreamingHandler, FeishuStream } from "./stream.js";
+
+/**
+ * Detect if text contains markdown elements that benefit from card rendering.
+ * Used by auto render mode.
+ */
+function shouldUseCard(text: string): boolean {
+  // Code blocks (fenced)
+  if (/```[\s\S]*?```/.test(text)) return true;
+  // Tables (at least header + separator row with |)
+  if (/\|.+\|[\r\n]+\|[-:| ]+\|/.test(text)) return true;
+  return false;
+}
+
+export type CreateFeishuReplyDispatcherParams = {
+  cfg: ClawdbotConfig;
+  agentId: string;
+  runtime: RuntimeEnv;
+  chatId: string;
+  replyToMessageId?: string;
+  /** Mention targets, will be auto-included in replies */
+  mentionTargets?: MentionTarget[];
+  /** Account ID for multi-account support */
+  accountId?: string;
+  /** Enable streaming mode for card-based real-time updates */
+  enableStreaming?: boolean;
+};
+
+export function createFeishuReplyDispatcher(params: CreateFeishuReplyDispatcherParams) {
+  const core = getFeishuRuntime();
+  const { cfg, agentId, chatId, replyToMessageId, mentionTargets, accountId, enableStreaming } = params;
+
+  // Resolve account for config access
+  const account = resolveFeishuAccount({ cfg, accountId });
+
+  const prefixContext = createReplyPrefixContext({
+    cfg,
+    agentId,
+  });
+
+  // Feishu doesn't have a native typing indicator API.
+  // We use message reactions as a typing indicator substitute.
+  let typingState: TypingIndicatorState | null = null;
+
+  // Streaming state
+  let streamInstance: FeishuStream | null = null;
+  let streamingMessageId: string | null = null;
+
+  const typingCallbacks = createTypingCallbacks({
+    start: async () => {
+      // Skip typing indicator when streaming is enabled
+      if (enableStreaming) {
+        params.runtime.log?.(`feishu[${account.accountId}]: streaming enabled, skipping typing indicator`);
+        return;
+      }
+      if (!replyToMessageId) return;
+      typingState = await addTypingIndicator({ cfg, messageId: replyToMessageId, accountId });
+      params.runtime.log?.(`feishu[${account.accountId}]: added typing indicator reaction`);
+    },
+    stop: async () => {
+      if (!typingState) return;
+      await removeTypingIndicator({ cfg, state: typingState, accountId });
+      typingState = null;
+      params.runtime.log?.(`feishu[${account.accountId}]: removed typing indicator reaction`);
+    },
+    onStartError: (err) => {
+      logTypingFailure({
+        log: (message) => params.runtime.log?.(message),
+        channel: "feishu",
+        action: "start",
+        error: err,
+      });
+    },
+    onStopError: (err) => {
+      logTypingFailure({
+        log: (message) => params.runtime.log?.(message),
+        channel: "feishu",
+        action: "stop",
+        error: err,
+      });
+    },
+  });
+
+  const textChunkLimit = core.channel.text.resolveTextChunkLimit({
+    cfg,
+    channel: "feishu",
+    defaultLimit: 4000,
+  });
+  const chunkMode = core.channel.text.resolveChunkMode(cfg, "feishu");
+  const tableMode = core.channel.text.resolveMarkdownTableMode({
+    cfg,
+    channel: "feishu",
+  });
+
+  const { dispatcher, replyOptions, markDispatchIdle } =
+    core.channel.reply.createReplyDispatcherWithTyping({
+      responsePrefix: prefixContext.responsePrefix,
+      responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+      humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
+      onReplyStart: typingCallbacks.onReplyStart,
+      deliver: async (payload: ReplyPayload) => {
+        params.runtime.log?.(`feishu[${account.accountId}] deliver called: text=${payload.text?.slice(0, 100)}`);
+        const text = payload.text ?? "";
+        if (!text.trim()) {
+          params.runtime.log?.(`feishu[${account.accountId}] deliver: empty text, skipping`);
+          return;
+        }
+
+        // Check render mode: auto (default), raw, or card
+        const feishuCfg = account.config;
+        const renderMode = feishuCfg?.renderMode ?? "auto";
+
+        // Determine if we should use card for this message
+        const useCard =
+          renderMode === "card" || (renderMode === "auto" && shouldUseCard(text));
+
+        // Only include @mentions in the first chunk (avoid duplicate @s)
+        let isFirstChunk = true;
+
+        if (useCard) {
+          // Card mode: send as interactive card with markdown rendering
+          const chunks = core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode);
+          params.runtime.log?.(`feishu[${account.accountId}] deliver: sending ${chunks.length} card chunks to ${chatId}`);
+          for (const chunk of chunks) {
+            await sendMarkdownCardFeishu({
+              cfg,
+              to: chatId,
+              text: chunk,
+              replyToMessageId,
+              mentions: isFirstChunk ? mentionTargets : undefined,
+              accountId,
+            });
+            isFirstChunk = false;
+          }
+        } else {
+          // Raw mode: send as plain text with table conversion
+          const converted = core.channel.text.convertMarkdownTables(text, tableMode);
+          const chunks = core.channel.text.chunkTextWithMode(converted, textChunkLimit, chunkMode);
+          params.runtime.log?.(`feishu[${account.accountId}] deliver: sending ${chunks.length} text chunks to ${chatId}`);
+          for (const chunk of chunks) {
+            await sendMessageFeishu({
+              cfg,
+              to: chatId,
+              text: chunk,
+              replyToMessageId,
+              mentions: isFirstChunk ? mentionTargets : undefined,
+              accountId,
+            });
+            isFirstChunk = false;
+          }
+        }
+      },
+      onError: (err, info) => {
+        params.runtime.error?.(`feishu[${account.accountId}] ${info.kind} reply failed: ${String(err)}`);
+        typingCallbacks.onIdle?.();
+      },
+      onIdle: typingCallbacks.onIdle,
+      // Enable partial reply callback for streaming
+      onPartialReply: enableStreaming
+        ? async (text: string, isFinal: boolean) => {
+            // Initialize stream on first partial reply
+            if (!streamInstance) {
+              // Send initial card message
+              const result = await sendMarkdownCardFeishu({
+                cfg,
+                to: chatId,
+                text: text,
+                replyToMessageId,
+                mentions: mentionTargets,
+                accountId,
+              });
+              streamingMessageId = result.messageId;
+              
+              // Create stream handler for subsequent updates
+              if (streamingMessageId) {
+                const handler = createFeishuStreamingHandler({
+                  cfg,
+                  messageId: streamingMessageId,
+                  accountId,
+                });
+                streamInstance = handler.stream;
+              }
+            } else if (streamInstance) {
+              // Update existing stream
+              if (isFinal) {
+                await streamInstance.finalize(text);
+                streamInstance.destroy();
+                streamInstance = null;
+              } else {
+                await streamInstance.update(text);
+              }
+            }
+          }
+        : undefined,
+    });
+
+  return {
+    dispatcher,
+    replyOptions: {
+      ...replyOptions,
+      onModelSelected: prefixContext.onModelSelected,
+    },
+    markDispatchIdle,
+    // Expose stream instance for external control
+    streamInstance: () => streamInstance,
+  };
+}

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setFeishuRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getFeishuRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error("Feishu runtime not initialized");
+  }
+  return runtime;
+}