@actagent/feishu 2026.6.2

package/src/processing-claims.ts

@@ -0,0 +1,60 @@
+// Feishu plugin module implements processing claims behavior.
+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,2 @@
+// Feishu plugin module implements qr terminal behavior.
+export { renderQrTerminal } from "actagent/plugin-sdk/media-runtime";

package/src/reactions.ts

@@ -0,0 +1,124 @@
+// Feishu plugin module implements reactions behavior.
+import type { ACTAgentBotConfig } from "../runtime-api.js";
+import { resolveFeishuRuntimeAccount } from "./accounts.js";
+import { createFeishuClient } from "./client.js";
+
+type FeishuReaction = {
+  reactionId: string;
+  emojiType: string;
+  operatorType: "app" | "user";
+  operatorId: string;
+};
+
+function resolveConfiguredFeishuClient(params: { cfg: ACTAgentBotConfig; 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"
+ * @see https://open.feishu.cn/document/server-docs/im-v1/message-reaction/emojis-introduce
+ */
+export async function addReactionFeishu(params: {
+  cfg: ACTAgentBotConfig;
+  messageId: string;
+  emojiType: string;
+  accountId?: string;
+}): Promise<{ reactionId: string }> {
+  const { cfg, messageId, emojiType, accountId } = params;
+  const client = resolveConfiguredFeishuClient({ cfg, accountId });
+
+  const response = (await client.im.messageReaction.create({
+    path: { message_id: messageId },
+    data: {
+      reaction_type: {
+        emoji_type: emojiType,
+      },
+    },
+  })) as {
+    code?: number;
+    msg?: string;
+    data?: { reaction_id?: string };
+  };
+
+  assertFeishuReactionApiSuccess(response, "add reaction");
+
+  const reactionId = response.data?.reaction_id;
+  if (!reactionId) {
+    throw new Error("Feishu add reaction failed: no reaction_id returned");
+  }
+
+  return { reactionId };
+}
+
+/**
+ * Remove a reaction from a message.
+ */
+export async function removeReactionFeishu(params: {
+  cfg: ACTAgentBotConfig;
+  messageId: string;
+  reactionId: string;
+  accountId?: string;
+}): Promise<void> {
+  const { cfg, messageId, reactionId, accountId } = params;
+  const client = resolveConfiguredFeishuClient({ cfg, accountId });
+
+  const response = (await client.im.messageReaction.delete({
+    path: {
+      message_id: messageId,
+      reaction_id: reactionId,
+    },
+  })) as { code?: number; msg?: string };
+
+  assertFeishuReactionApiSuccess(response, "remove reaction");
+}
+
+/**
+ * List all reactions for a message.
+ */
+export async function listReactionsFeishu(params: {
+  cfg: ACTAgentBotConfig;
+  messageId: string;
+  emojiType?: string;
+  accountId?: string;
+}): Promise<FeishuReaction[]> {
+  const { cfg, messageId, emojiType, accountId } = params;
+  const client = resolveConfiguredFeishuClient({ cfg, accountId });
+
+  const response = (await client.im.messageReaction.list({
+    path: { message_id: messageId },
+    params: emojiType ? { reaction_type: emojiType } : undefined,
+  })) as {
+    code?: number;
+    msg?: string;
+    data?: {
+      items?: Array<{
+        reaction_id?: string;
+        reaction_type?: { emoji_type?: string };
+        operator_type?: string;
+        operator_id?: { open_id?: string; user_id?: string; union_id?: string };
+      }>;
+    };
+  };
+
+  assertFeishuReactionApiSuccess(response, "list reactions");
+
+  const items = response.data?.items ?? [];
+  return items.map((item) => ({
+    reactionId: item.reaction_id ?? "",
+    emojiType: item.reaction_type?.emoji_type ?? "",
+    operatorType: item.operator_type === "app" ? "app" : "user",
+    operatorId:
+      item.operator_id?.open_id ?? item.operator_id?.user_id ?? item.operator_id?.union_id ?? "",
+  }));
+}

package/src/reasoning-preview.test.ts

@@ -0,0 +1,114 @@
+// Feishu tests cover reasoning preview plugin behavior.
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ACTAgentBotConfig } from "./bot-runtime-api.js";
+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,
+  };
+});
+
+afterAll(() => {
+  vi.doUnmock("./bot-runtime-api.js");
+  vi.resetModules();
+});
+
+describe("resolveFeishuReasoningPreviewEnabled", () => {
+  const emptyCfg: ACTAgentBotConfig = {};
+
+  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({
+        cfg: emptyCfg,
+        agentId: "main",
+        storePath: "/tmp/feishu-sessions.json",
+        sessionKey: "agent:main:feishu:dm:ou_sender_1",
+      }),
+    ).toBe(true);
+    expect(
+      resolveFeishuReasoningPreviewEnabled({
+        cfg: emptyCfg,
+        agentId: "main",
+        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({
+        cfg: emptyCfg,
+        agentId: "main",
+        storePath: "/tmp/feishu-sessions.json",
+        sessionKey: "agent:main:feishu:dm:ou_sender_1",
+      }),
+    ).toBe(false);
+    expect(
+      resolveFeishuReasoningPreviewEnabled({
+        cfg: emptyCfg,
+        agentId: "main",
+        storePath: "/tmp/feishu-sessions.json",
+      }),
+    ).toBe(false);
+  });
+
+  it("falls back to configured stream defaults", () => {
+    loadSessionStoreMock.mockReturnValue({
+      "agent:main:feishu:dm:ou_sender_1": {},
+      "agent:main:feishu:dm:ou_sender_2": { reasoningLevel: "off" },
+    });
+
+    const cfg: ACTAgentBotConfig = {
+      agents: {
+        defaults: { reasoningDefault: "stream" },
+        list: [{ id: "Ops", reasoningDefault: "off" }],
+      },
+    };
+
+    expect(
+      resolveFeishuReasoningPreviewEnabled({
+        cfg,
+        agentId: "main",
+        storePath: "/tmp/feishu-sessions.json",
+        sessionKey: "agent:main:feishu:dm:ou_sender_1",
+      }),
+    ).toBe(true);
+    expect(
+      resolveFeishuReasoningPreviewEnabled({
+        cfg,
+        agentId: "ops",
+        storePath: "/tmp/feishu-sessions.json",
+      }),
+    ).toBe(false);
+    expect(
+      resolveFeishuReasoningPreviewEnabled({
+        cfg,
+        agentId: "main",
+        storePath: "/tmp/feishu-sessions.json",
+        sessionKey: "agent:main:feishu:dm:ou_sender_2",
+      }),
+    ).toBe(false);
+  });
+});

package/src/reasoning-preview.ts

@@ -0,0 +1,29 @@
+// Feishu plugin module implements reasoning preview behavior.
+import { resolveFeishuConfigReasoningDefault } from "./agent-config.js";
+import { loadSessionStore, resolveSessionStoreEntry } from "./bot-runtime-api.js";
+import type { ACTAgentBotConfig } from "./bot-runtime-api.js";
+
+export function resolveFeishuReasoningPreviewEnabled(params: {
+  cfg: ACTAgentBotConfig;
+  agentId: string;
+  storePath: string;
+  sessionKey?: string;
+}): boolean {
+  const configDefault = resolveFeishuConfigReasoningDefault(params.cfg, params.agentId);
+
+  if (!params.sessionKey) {
+    return configDefault === "stream";
+  }
+
+  try {
+    const store = loadSessionStore(params.storePath, { skipCache: true });
+    const level = resolveSessionStoreEntry({ store, sessionKey: params.sessionKey }).existing
+      ?.reasoningLevel;
+    if (level === "on" || level === "stream" || level === "off") {
+      return level === "stream";
+    }
+  } catch {
+    return false;
+  }
+  return configDefault === "stream";
+}

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

@@ -0,0 +1,8 @@
+// Feishu API module exposes the plugin public contract.
+export {
+  createReplyPrefixContext,
+  type ACTAgentBotConfig,
+  type OutboundIdentity,
+  type ReplyPayload,
+  type RuntimeEnv,
+} from "../runtime-api.js";