@openclaw/feishu 2026.3.12 → 2026.5.1-beta.1

package/src/processing-claims.ts

@@ -0,0 +1,59 @@
+const EVENT_DEDUP_TTL_MS = 5 * 60 * 1000;
+const EVENT_MEMORY_MAX_SIZE = 2_000;
+
+const processingClaims = new Map<string, number>();
+
+function resolveEventDedupeKey(
+  namespace: string,
+  messageId: string | undefined | null,
+): string | null {
+  const trimmed = messageId?.trim();
+  return trimmed ? `${namespace}:${trimmed}` : null;
+}
+
+function pruneProcessingClaims(now: number): void {
+  const cutoff = now - EVENT_DEDUP_TTL_MS;
+  for (const [key, seenAt] of processingClaims) {
+    if (seenAt < cutoff) {
+      processingClaims.delete(key);
+    }
+  }
+  while (processingClaims.size > EVENT_MEMORY_MAX_SIZE) {
+    const oldestKey = processingClaims.keys().next().value;
+    if (!oldestKey) {
+      return;
+    }
+    processingClaims.delete(oldestKey);
+  }
+}
+
+export function tryBeginFeishuMessageProcessing(
+  messageId: string | undefined | null,
+  namespace = "global",
+): boolean {
+  const key = resolveEventDedupeKey(namespace, messageId);
+  if (!key) {
+    return true;
+  }
+  const now = Date.now();
+  pruneProcessingClaims(now);
+  if (processingClaims.has(key)) {
+    processingClaims.delete(key);
+    processingClaims.set(key, now);
+    pruneProcessingClaims(now);
+    return false;
+  }
+  processingClaims.set(key, now);
+  pruneProcessingClaims(now);
+  return true;
+}
+
+export function releaseFeishuMessageProcessing(
+  messageId: string | undefined | null,
+  namespace = "global",
+): void {
+  const key = resolveEventDedupeKey(namespace, messageId);
+  if (key) {
+    processingClaims.delete(key);
+  }
+}

package/src/qr-terminal.ts

@@ -0,0 +1 @@
+export { renderQrTerminal } from "openclaw/plugin-sdk/media-runtime";

package/src/reactions.ts

@@ -1,14 +1,28 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
-import { resolveFeishuAccount } from "./accounts.js";
+import type { ClawdbotConfig } from "../runtime-api.js";
+import { resolveFeishuRuntimeAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 
-export type FeishuReaction = {
+type FeishuReaction = {
   reactionId: string;
   emojiType: string;
   operatorType: "app" | "user";
   operatorId: string;
 };
 
+function resolveConfiguredFeishuClient(params: { cfg: ClawdbotConfig; accountId?: string }) {
+  const account = resolveFeishuRuntimeAccount(params);
+  if (!account.configured) {
+    throw new Error(`Feishu account "${account.accountId}" not configured`);
+  }
+  return createFeishuClient(account);
+}
+
+function assertFeishuReactionApiSuccess(response: { code?: number; msg?: string }, action: string) {
+  if (response.code !== 0) {
+    throw new Error(`Feishu ${action} failed: ${response.msg || `code ${response.code}`}`);
+  }
+}
+
 /**
  * Add a reaction (emoji) to a message.
  * @param emojiType - Feishu emoji type, e.g., "SMILE", "THUMBSUP", "HEART"
@@ -21,12 +35,7 @@ export async function addReactionFeishu(params: {
   accountId?: string;
 }): Promise<{ reactionId: string }> {
   const { cfg, messageId, emojiType, accountId } = params;
-  const account = resolveFeishuAccount({ cfg, accountId });
-  if (!account.configured) {
-    throw new Error(`Feishu account "${account.accountId}" not configured`);
-  }
-
-  const client = createFeishuClient(account);
+  const client = resolveConfiguredFeishuClient({ cfg, accountId });
 
   const response = (await client.im.messageReaction.create({
     path: { message_id: messageId },
@@ -41,9 +50,7 @@ export async function addReactionFeishu(params: {
     data?: { reaction_id?: string };
   };
 
-  if (response.code !== 0) {
-    throw new Error(`Feishu add reaction failed: ${response.msg || `code ${response.code}`}`);
-  }
+  assertFeishuReactionApiSuccess(response, "add reaction");
 
   const reactionId = response.data?.reaction_id;
   if (!reactionId) {
@@ -63,12 +70,7 @@ export async function removeReactionFeishu(params: {
   accountId?: string;
 }): Promise<void> {
   const { cfg, messageId, reactionId, accountId } = params;
-  const account = resolveFeishuAccount({ cfg, accountId });
-  if (!account.configured) {
-    throw new Error(`Feishu account "${account.accountId}" not configured`);
-  }
-
-  const client = createFeishuClient(account);
+  const client = resolveConfiguredFeishuClient({ cfg, accountId });
 
   const response = (await client.im.messageReaction.delete({
     path: {
@@ -77,9 +79,7 @@ export async function removeReactionFeishu(params: {
     },
   })) as { code?: number; msg?: string };
 
-  if (response.code !== 0) {
-    throw new Error(`Feishu remove reaction failed: ${response.msg || `code ${response.code}`}`);
-  }
+  assertFeishuReactionApiSuccess(response, "remove reaction");
 }
 
 /**
@@ -92,12 +92,7 @@ export async function listReactionsFeishu(params: {
   accountId?: string;
 }): Promise<FeishuReaction[]> {
   const { cfg, messageId, emojiType, accountId } = params;
-  const account = resolveFeishuAccount({ cfg, accountId });
-  if (!account.configured) {
-    throw new Error(`Feishu account "${account.accountId}" not configured`);
-  }
-
-  const client = createFeishuClient(account);
+  const client = resolveConfiguredFeishuClient({ cfg, accountId });
 
   const response = (await client.im.messageReaction.list({
     path: { message_id: messageId },
@@ -115,9 +110,7 @@ export async function listReactionsFeishu(params: {
     };
   };
 
-  if (response.code !== 0) {
-    throw new Error(`Feishu list reactions failed: ${response.msg || `code ${response.code}`}`);
-  }
+  assertFeishuReactionApiSuccess(response, "list reactions");
 
   const items = response.data?.items ?? [];
   return items.map((item) => ({
@@ -128,33 +121,3 @@ export async function listReactionsFeishu(params: {
       item.operator_id?.open_id ?? item.operator_id?.user_id ?? item.operator_id?.union_id ?? "",
   }));
 }
-
-/**
- * Common Feishu emoji types for convenience.
- * @see https://open.feishu.cn/document/server-docs/im-v1/message-reaction/emojis-introduce
- */
-export const FeishuEmoji = {
-  // Common reactions
-  THUMBSUP: "THUMBSUP",
-  THUMBSDOWN: "THUMBSDOWN",
-  HEART: "HEART",
-  SMILE: "SMILE",
-  GRINNING: "GRINNING",
-  LAUGHING: "LAUGHING",
-  CRY: "CRY",
-  ANGRY: "ANGRY",
-  SURPRISED: "SURPRISED",
-  THINKING: "THINKING",
-  CLAP: "CLAP",
-  OK: "OK",
-  FIST: "FIST",
-  PRAY: "PRAY",
-  FIRE: "FIRE",
-  PARTY: "PARTY",
-  CHECK: "CHECK",
-  CROSS: "CROSS",
-  QUESTION: "QUESTION",
-  EXCLAMATION: "EXCLAMATION",
-} as const;
-
-export type FeishuEmojiType = (typeof FeishuEmoji)[keyof typeof FeishuEmoji];

package/src/reasoning-preview.test.ts

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { resolveFeishuReasoningPreviewEnabled } from "./reasoning-preview.js";
+
+const { loadSessionStoreMock } = vi.hoisted(() => ({
+  loadSessionStoreMock: vi.fn(),
+}));
+
+vi.mock("./bot-runtime-api.js", async () => {
+  const actual =
+    await vi.importActual<typeof import("./bot-runtime-api.js")>("./bot-runtime-api.js");
+  return {
+    ...actual,
+    loadSessionStore: loadSessionStoreMock,
+  };
+});
+
+describe("resolveFeishuReasoningPreviewEnabled", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("enables previews only for stream reasoning sessions", () => {
+    loadSessionStoreMock.mockReturnValue({
+      "agent:main:feishu:dm:ou_sender_1": { reasoningLevel: "stream" },
+      "agent:main:feishu:dm:ou_sender_2": { reasoningLevel: "on" },
+    });
+
+    expect(
+      resolveFeishuReasoningPreviewEnabled({
+        storePath: "/tmp/feishu-sessions.json",
+        sessionKey: "agent:main:feishu:dm:ou_sender_1",
+      }),
+    ).toBe(true);
+    expect(
+      resolveFeishuReasoningPreviewEnabled({
+        storePath: "/tmp/feishu-sessions.json",
+        sessionKey: "agent:main:feishu:dm:ou_sender_2",
+      }),
+    ).toBe(false);
+  });
+
+  it("returns false for missing sessions or load failures", () => {
+    loadSessionStoreMock.mockImplementationOnce(() => {
+      throw new Error("disk unavailable");
+    });
+
+    expect(
+      resolveFeishuReasoningPreviewEnabled({
+        storePath: "/tmp/feishu-sessions.json",
+        sessionKey: "agent:main:feishu:dm:ou_sender_1",
+      }),
+    ).toBe(false);
+    expect(
+      resolveFeishuReasoningPreviewEnabled({
+        storePath: "/tmp/feishu-sessions.json",
+      }),
+    ).toBe(false);
+  });
+});

package/src/reasoning-preview.ts

@@ -0,0 +1,20 @@
+import { loadSessionStore, resolveSessionStoreEntry } from "./bot-runtime-api.js";
+
+export function resolveFeishuReasoningPreviewEnabled(params: {
+  storePath: string;
+  sessionKey?: string;
+}): boolean {
+  if (!params.sessionKey) {
+    return false;
+  }
+
+  try {
+    const store = loadSessionStore(params.storePath, { skipCache: true });
+    return (
+      resolveSessionStoreEntry({ store, sessionKey: params.sessionKey }).existing
+        ?.reasoningLevel === "stream"
+    );
+  } catch {
+    return false;
+  }
+}

package/src/reply-dispatcher-runtime-api.ts

@@ -0,0 +1,7 @@
+export {
+  createReplyPrefixContext,
+  type ClawdbotConfig,
+  type OutboundIdentity,
+  type ReplyPayload,
+  type RuntimeEnv,
+} from "../runtime-api.js";