@openclaw/feishu 2026.3.1 → 2026.3.7

package/src/send.reply-fallback.test.ts

@@ -102,4 +102,78 @@ describe("Feishu reply fallback for withdrawn/deleted targets", () => {
 
     expect(createMock).not.toHaveBeenCalled();
   });
+
+  it("falls back to create when reply throws a withdrawn SDK error", async () => {
+    const sdkError = Object.assign(new Error("request failed"), { code: 230011 });
+    replyMock.mockRejectedValue(sdkError);
+    createMock.mockResolvedValue({
+      code: 0,
+      data: { message_id: "om_thrown_fallback" },
+    });
+
+    const result = await sendMessageFeishu({
+      cfg: {} as never,
+      to: "user:ou_target",
+      text: "hello",
+      replyToMessageId: "om_parent",
+    });
+
+    expect(replyMock).toHaveBeenCalledTimes(1);
+    expect(createMock).toHaveBeenCalledTimes(1);
+    expect(result.messageId).toBe("om_thrown_fallback");
+  });
+
+  it("falls back to create when card reply throws a not-found AxiosError", async () => {
+    const axiosError = Object.assign(new Error("Request failed"), {
+      response: { status: 200, data: { code: 231003, msg: "The message is not found" } },
+    });
+    replyMock.mockRejectedValue(axiosError);
+    createMock.mockResolvedValue({
+      code: 0,
+      data: { message_id: "om_axios_fallback" },
+    });
+
+    const result = await sendCardFeishu({
+      cfg: {} as never,
+      to: "user:ou_target",
+      card: { schema: "2.0" },
+      replyToMessageId: "om_parent",
+    });
+
+    expect(replyMock).toHaveBeenCalledTimes(1);
+    expect(createMock).toHaveBeenCalledTimes(1);
+    expect(result.messageId).toBe("om_axios_fallback");
+  });
+
+  it("re-throws non-withdrawn thrown errors for text messages", async () => {
+    const sdkError = Object.assign(new Error("rate limited"), { code: 99991400 });
+    replyMock.mockRejectedValue(sdkError);
+
+    await expect(
+      sendMessageFeishu({
+        cfg: {} as never,
+        to: "user:ou_target",
+        text: "hello",
+        replyToMessageId: "om_parent",
+      }),
+    ).rejects.toThrow("rate limited");
+
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it("re-throws non-withdrawn thrown errors for card messages", async () => {
+    const sdkError = Object.assign(new Error("permission denied"), { code: 99991401 });
+    replyMock.mockRejectedValue(sdkError);
+
+    await expect(
+      sendCardFeishu({
+        cfg: {} as never,
+        to: "user:ou_target",
+        card: { schema: "2.0" },
+        replyToMessageId: "om_parent",
+      }),
+    ).rejects.toThrow("permission denied");
+
+    expect(createMock).not.toHaveBeenCalled();
+  });
 });

package/src/send.test.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { getMessageFeishu } from "./send.js";
 

package/src/send.ts

@@ -1,4 +1,4 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk/feishu";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import type { MentionTarget } from "./mention.js";
@@ -19,6 +19,61 @@ function shouldFallbackFromReplyTarget(response: { code?: number; msg?: string }
   return msg.includes("withdrawn") || msg.includes("not found");
 }
 
+/** Check whether a thrown error indicates a withdrawn/not-found reply target. */
+function isWithdrawnReplyError(err: unknown): boolean {
+  if (typeof err !== "object" || err === null) {
+    return false;
+  }
+  // SDK error shape: err.code
+  const code = (err as { code?: number }).code;
+  if (typeof code === "number" && WITHDRAWN_REPLY_ERROR_CODES.has(code)) {
+    return true;
+  }
+  // AxiosError shape: err.response.data.code
+  const response = (err as { response?: { data?: { code?: number; msg?: string } } }).response;
+  if (
+    typeof response?.data?.code === "number" &&
+    WITHDRAWN_REPLY_ERROR_CODES.has(response.data.code)
+  ) {
+    return true;
+  }
+  return false;
+}
+
+type FeishuCreateMessageClient = {
+  im: {
+    message: {
+      create: (opts: {
+        params: { receive_id_type: "chat_id" | "email" | "open_id" | "union_id" | "user_id" };
+        data: { receive_id: string; content: string; msg_type: string };
+      }) => Promise<{ code?: number; msg?: string; data?: { message_id?: string } }>;
+    };
+  };
+};
+
+/** Send a direct message as a fallback when a reply target is unavailable. */
+async function sendFallbackDirect(
+  client: FeishuCreateMessageClient,
+  params: {
+    receiveId: string;
+    receiveIdType: "chat_id" | "email" | "open_id" | "union_id" | "user_id";
+    content: string;
+    msgType: string;
+  },
+  errorPrefix: string,
+): Promise<FeishuSendResult> {
+  const response = await client.im.message.create({
+    params: { receive_id_type: params.receiveIdType },
+    data: {
+      receive_id: params.receiveId,
+      content: params.content,
+      msg_type: params.msgType,
+    },
+  });
+  assertFeishuMessageApiSuccess(response, errorPrefix);
+  return toFeishuSendResult(response, params.receiveId);
+}
+
 export type FeishuMessageInfo = {
   messageId: string;
   chatId: string;
@@ -239,41 +294,33 @@ export async function sendMessageFeishu(
 
   const { content, msgType } = buildFeishuPostMessagePayload({ messageText });
 
+  const directParams = { receiveId, receiveIdType, content, msgType };
+
   if (replyToMessageId) {
-    const response = await client.im.message.reply({
-      path: { message_id: replyToMessageId },
-      data: {
-        content,
-        msg_type: msgType,
-        ...(replyInThread ? { reply_in_thread: true } : {}),
-      },
-    });
-    if (shouldFallbackFromReplyTarget(response)) {
-      const fallback = await client.im.message.create({
-        params: { receive_id_type: receiveIdType },
+    let response: { code?: number; msg?: string; data?: { message_id?: string } };
+    try {
+      response = await client.im.message.reply({
+        path: { message_id: replyToMessageId },
         data: {
-          receive_id: receiveId,
           content,
           msg_type: msgType,
+          ...(replyInThread ? { reply_in_thread: true } : {}),
         },
       });
-      assertFeishuMessageApiSuccess(fallback, "Feishu send failed");
-      return toFeishuSendResult(fallback, receiveId);
+    } catch (err) {
+      if (!isWithdrawnReplyError(err)) {
+        throw err;
+      }
+      return sendFallbackDirect(client, directParams, "Feishu send failed");
+    }
+    if (shouldFallbackFromReplyTarget(response)) {
+      return sendFallbackDirect(client, directParams, "Feishu send failed");
     }
     assertFeishuMessageApiSuccess(response, "Feishu reply failed");
     return toFeishuSendResult(response, receiveId);
   }
 
-  const response = await client.im.message.create({
-    params: { receive_id_type: receiveIdType },
-    data: {
-      receive_id: receiveId,
-      content,
-      msg_type: msgType,
-    },
-  });
-  assertFeishuMessageApiSuccess(response, "Feishu send failed");
-  return toFeishuSendResult(response, receiveId);
+  return sendFallbackDirect(client, directParams, "Feishu send failed");
 }
 
 export type SendFeishuCardParams = {
@@ -291,41 +338,33 @@ export async function sendCardFeishu(params: SendFeishuCardParams): Promise<Feis
   const { client, receiveId, receiveIdType } = resolveFeishuSendTarget({ cfg, to, accountId });
   const content = JSON.stringify(card);
 
+  const directParams = { receiveId, receiveIdType, content, msgType: "interactive" };
+
   if (replyToMessageId) {
-    const response = await client.im.message.reply({
-      path: { message_id: replyToMessageId },
-      data: {
-        content,
-        msg_type: "interactive",
-        ...(replyInThread ? { reply_in_thread: true } : {}),
-      },
-    });
-    if (shouldFallbackFromReplyTarget(response)) {
-      const fallback = await client.im.message.create({
-        params: { receive_id_type: receiveIdType },
+    let response: { code?: number; msg?: string; data?: { message_id?: string } };
+    try {
+      response = await client.im.message.reply({
+        path: { message_id: replyToMessageId },
         data: {
-          receive_id: receiveId,
           content,
           msg_type: "interactive",
+          ...(replyInThread ? { reply_in_thread: true } : {}),
         },
       });
-      assertFeishuMessageApiSuccess(fallback, "Feishu card send failed");
-      return toFeishuSendResult(fallback, receiveId);
+    } catch (err) {
+      if (!isWithdrawnReplyError(err)) {
+        throw err;
+      }
+      return sendFallbackDirect(client, directParams, "Feishu card send failed");
+    }
+    if (shouldFallbackFromReplyTarget(response)) {
+      return sendFallbackDirect(client, directParams, "Feishu card send failed");
     }
     assertFeishuMessageApiSuccess(response, "Feishu card reply failed");
     return toFeishuSendResult(response, receiveId);
   }
 
-  const response = await client.im.message.create({
-    params: { receive_id_type: receiveIdType },
-    data: {
-      receive_id: receiveId,
-      content,
-      msg_type: "interactive",
-    },
-  });
-  assertFeishuMessageApiSuccess(response, "Feishu card send failed");
-  return toFeishuSendResult(response, receiveId);
+  return sendFallbackDirect(client, directParams, "Feishu card send failed");
 }
 
 export async function updateCardFeishu(params: {

package/src/streaming-card.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { mergeStreamingText, resolveStreamingCardSendMode } from "./streaming-card.js";
+
+describe("mergeStreamingText", () => {
+  it("prefers the latest full text when it already includes prior text", () => {
+    expect(mergeStreamingText("hello", "hello world")).toBe("hello world");
+  });
+
+  it("keeps previous text when the next partial is empty or redundant", () => {
+    expect(mergeStreamingText("hello", "")).toBe("hello");
+    expect(mergeStreamingText("hello world", "hello")).toBe("hello world");
+  });
+
+  it("appends fragmented chunks without injecting newlines", () => {
+    expect(mergeStreamingText("hello wor", "ld")).toBe("hello world");
+    expect(mergeStreamingText("line1", "line2")).toBe("line1line2");
+  });
+
+  it("merges overlap between adjacent partial snapshots", () => {
+    expect(mergeStreamingText("好的，让我", "让我再读取一遍")).toBe("好的，让我再读取一遍");
+    expect(mergeStreamingText("revision_id: 552", "2，一点变化都没有")).toBe(
+      "revision_id: 552，一点变化都没有",
+    );
+    expect(mergeStreamingText("abc", "cabc")).toBe("cabc");
+  });
+});
+
+describe("resolveStreamingCardSendMode", () => {
+  it("prefers message.reply when reply target and root id both exist", () => {
+    expect(
+      resolveStreamingCardSendMode({
+        replyToMessageId: "om_parent",
+        rootId: "om_topic_root",
+      }),
+    ).toBe("reply");
+  });
+
+  it("falls back to root create when reply target is absent", () => {
+    expect(
+      resolveStreamingCardSendMode({
+        rootId: "om_topic_root",
+      }),
+    ).toBe("root_create");
+  });
+
+  it("uses create mode when no reply routing fields are provided", () => {
+    expect(resolveStreamingCardSendMode()).toBe("create");
+    expect(
+      resolveStreamingCardSendMode({
+        replyInThread: true,
+      }),
+    ).toBe("create");
+  });
+});

package/src/streaming-card.ts

@@ -3,7 +3,7 @@
  */
 
 import type { Client } from "@larksuiteoapi/node-sdk";
-import { fetchWithSsrFGuard } from "openclaw/plugin-sdk";
+import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/feishu";
 import type { FeishuDomain } from "./types.js";
 
 type Credentials = { appId: string; appSecret: string; domain?: FeishuDomain };
@@ -16,6 +16,13 @@ export type StreamingCardHeader = {
   template?: string;
 };
 
+type StreamingStartOptions = {
+  replyToMessageId?: string;
+  replyInThread?: boolean;
+  rootId?: string;
+  header?: StreamingCardHeader;
+};
+
 // Token cache (keyed by domain + appId)
 const tokenCache = new Map<string, { token: string; expiresAt: number }>();
 
@@ -60,6 +67,10 @@ async function getToken(creds: Credentials): Promise<string> {
     policy: { allowedHostnames: resolveAllowedHostnames(creds.domain) },
     auditContext: "feishu.streaming-card.token",
   });
+  if (!response.ok) {
+    await release();
+    throw new Error(`Token request failed with HTTP ${response.status}`);
+  }
   const data = (await response.json()) as {
     code: number;
     msg: string;
@@ -85,6 +96,52 @@ function truncateSummary(text: string, max = 50): string {
   return clean.length <= max ? clean : clean.slice(0, max - 3) + "...";
 }
 
+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) {
+    return next;
+  }
+  if (next.startsWith(previous)) {
+    return next;
+  }
+  if (previous.startsWith(next)) {
+    return previous;
+  }
+  if (next.includes(previous)) {
+    return next;
+  }
+  if (previous.includes(next)) {
+    return previous;
+  }
+
+  // Merge partial overlaps, e.g. "这" + "这是" => "这是".
+  const maxOverlap = Math.min(previous.length, next.length);
+  for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+    if (previous.slice(-overlap) === next.slice(0, overlap)) {
+      return `${previous}${next.slice(overlap)}`;
+    }
+  }
+  // Fallback for fragmented partial chunks: append as-is to avoid losing tokens.
+  return `${previous}${next}`;
+}
+
+export function resolveStreamingCardSendMode(options?: StreamingStartOptions) {
+  if (options?.replyToMessageId) {
+    return "reply";
+  }
+  if (options?.rootId) {
+    return "root_create";
+  }
+  return "create";
+}
+
 /** Streaming card session manager */
 export class FeishuStreamingSession {
   private client: Client;
@@ -106,12 +163,7 @@ export class FeishuStreamingSession {
   async start(
     receiveId: string,
     receiveIdType: "open_id" | "user_id" | "union_id" | "email" | "chat_id" = "chat_id",
-    options?: {
-      replyToMessageId?: string;
-      replyInThread?: boolean;
-      rootId?: string;
-      header?: StreamingCardHeader;
-    },
+    options?: StreamingStartOptions,
   ): Promise<void> {
     if (this.state) {
       return;
@@ -123,7 +175,7 @@ export class FeishuStreamingSession {
       config: {
         streaming_mode: true,
         summary: { content: "[Generating...]" },
-        streaming_config: { print_frequency_ms: { default: 50 }, print_step: { default: 2 } },
+        streaming_config: { print_frequency_ms: { default: 50 }, print_step: { default: 1 } },
       },
       body: {
         elements: [{ tag: "markdown", content: "⏳ Thinking...", element_id: "content" }],
@@ -150,6 +202,10 @@ export class FeishuStreamingSession {
       policy: { allowedHostnames: resolveAllowedHostnames(this.creds.domain) },
       auditContext: "feishu.streaming-card.create",
     });
+    if (!createRes.ok) {
+      await releaseCreate();
+      throw new Error(`Create card request failed with HTTP ${createRes.status}`);
+    }
     const createData = (await createRes.json()) as {
       code: number;
       msg: string;
@@ -162,28 +218,31 @@ export class FeishuStreamingSession {
     const cardId = createData.data.card_id;
     const cardContent = JSON.stringify({ type: "card", data: { card_id: cardId } });
 
-    // Topic-group replies require root_id routing. Prefer create+root_id when available.
+    // Prefer message.reply when we have a reply target — reply_in_thread
+    // reliably routes streaming cards into Feishu topics, whereas
+    // message.create with root_id may silently ignore root_id for card
+    // references (card_id format).
     let sendRes;
-    if (options?.rootId) {
-      const createData = {
-        receive_id: receiveId,
-        msg_type: "interactive",
-        content: cardContent,
-        root_id: options.rootId,
-      };
-      sendRes = await this.client.im.message.create({
-        params: { receive_id_type: receiveIdType },
-        data: createData,
-      });
-    } else if (options?.replyToMessageId) {
+    const sendOptions = options ?? {};
+    const sendMode = resolveStreamingCardSendMode(sendOptions);
+    if (sendMode === "reply") {
       sendRes = await this.client.im.message.reply({
-        path: { message_id: options.replyToMessageId },
+        path: { message_id: sendOptions.replyToMessageId! },
         data: {
           msg_type: "interactive",
           content: cardContent,
-          ...(options.replyInThread ? { reply_in_thread: true } : {}),
+          ...(sendOptions.replyInThread ? { reply_in_thread: true } : {}),
         },
       });
+    } else if (sendMode === "root_create") {
+      // root_id is undeclared in the SDK types but accepted at runtime
+      sendRes = await this.client.im.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: Object.assign(
+          { receive_id: receiveId, msg_type: "interactive", content: cardContent },
+          { root_id: sendOptions.rootId },
+        ),
+      });
     } else {
       sendRes = await this.client.im.message.create({
         params: { receive_id_type: receiveIdType },
@@ -235,10 +294,15 @@ 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;
+    }
+
     // Throttle: skip if updated recently, but remember pending text
     const now = Date.now();
     if (now - this.lastUpdateTime < this.updateThrottleMs) {
-      this.pendingText = text;
+      this.pendingText = mergedInput;
       return;
     }
     this.pendingText = null;
@@ -248,8 +312,12 @@ export class FeishuStreamingSession {
       if (!this.state || this.closed) {
         return;
       }
-      this.state.currentText = text;
-      await this.updateCardContent(text, (e) => this.log?.(`Update failed: ${String(e)}`));
+      const mergedText = mergeStreamingText(this.state.currentText, mergedInput);
+      if (!mergedText || mergedText === this.state.currentText) {
+        return;
+      }
+      this.state.currentText = mergedText;
+      await this.updateCardContent(mergedText, (e) => this.log?.(`Update failed: ${String(e)}`));
     });
     await this.queue;
   }
@@ -261,8 +329,8 @@ export class FeishuStreamingSession {
     this.closed = true;
     await this.queue;
 
-    // Use finalText, or pending throttled text, or current text
-    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);
 
     // Only send final update if content differs from what's already displayed

package/src/targets.test.ts

@@ -13,6 +13,18 @@ describe("resolveReceiveIdType", () => {
   it("defaults unprefixed IDs to user_id", () => {
     expect(resolveReceiveIdType("u_123")).toBe("user_id");
   });
+
+  it("treats explicit group targets as chat_id", () => {
+    expect(resolveReceiveIdType("group:oc_123")).toBe("chat_id");
+  });
+
+  it("treats explicit channel targets as chat_id", () => {
+    expect(resolveReceiveIdType("channel:oc_123")).toBe("chat_id");
+  });
+
+  it("treats dm-prefixed open IDs as open_id", () => {
+    expect(resolveReceiveIdType("dm:ou_123")).toBe("open_id");
+  });
 });
 
 describe("normalizeFeishuTarget", () => {
@@ -25,9 +37,20 @@ describe("normalizeFeishuTarget", () => {
     expect(normalizeFeishuTarget("feishu:chat:oc_123")).toBe("oc_123");
   });
 
+  it("normalizes group/channel prefixes to chat ids", () => {
+    expect(normalizeFeishuTarget("group:oc_123")).toBe("oc_123");
+    expect(normalizeFeishuTarget("feishu:group:oc_123")).toBe("oc_123");
+    expect(normalizeFeishuTarget("channel:oc_456")).toBe("oc_456");
+    expect(normalizeFeishuTarget("lark:channel:oc_456")).toBe("oc_456");
+  });
+
   it("accepts provider-prefixed raw ids", () => {
     expect(normalizeFeishuTarget("feishu:ou_123")).toBe("ou_123");
   });
+
+  it("strips provider and dm prefixes", () => {
+    expect(normalizeFeishuTarget("lark:dm:ou_123")).toBe("ou_123");
+  });
 });
 
 describe("looksLikeFeishuId", () => {
@@ -38,4 +61,10 @@ describe("looksLikeFeishuId", () => {
   it("accepts provider-prefixed chat targets", () => {
     expect(looksLikeFeishuId("lark:chat:oc_123")).toBe(true);
   });
+
+  it("accepts group/channel targets", () => {
+    expect(looksLikeFeishuId("feishu:group:oc_123")).toBe(true);
+    expect(looksLikeFeishuId("group:oc_123")).toBe(true);
+    expect(looksLikeFeishuId("channel:oc_456")).toBe(true);
+  });
 });

package/src/targets.ts

@@ -33,9 +33,18 @@ export function normalizeFeishuTarget(raw: string): string | null {
   if (lowered.startsWith("chat:")) {
     return withoutProvider.slice("chat:".length).trim() || null;
   }
+  if (lowered.startsWith("group:")) {
+    return withoutProvider.slice("group:".length).trim() || null;
+  }
+  if (lowered.startsWith("channel:")) {
+    return withoutProvider.slice("channel:".length).trim() || null;
+  }
   if (lowered.startsWith("user:")) {
     return withoutProvider.slice("user:".length).trim() || null;
   }
+  if (lowered.startsWith("dm:")) {
+    return withoutProvider.slice("dm:".length).trim() || null;
+  }
   if (lowered.startsWith("open_id:")) {
     return withoutProvider.slice("open_id:".length).trim() || null;
   }
@@ -56,6 +65,21 @@ export function formatFeishuTarget(id: string, type?: FeishuIdType): string {
 
 export function resolveReceiveIdType(id: string): "chat_id" | "open_id" | "user_id" {
   const trimmed = id.trim();
+  const lowered = trimmed.toLowerCase();
+  if (
+    lowered.startsWith("chat:") ||
+    lowered.startsWith("group:") ||
+    lowered.startsWith("channel:")
+  ) {
+    return "chat_id";
+  }
+  if (lowered.startsWith("open_id:")) {
+    return "open_id";
+  }
+  if (lowered.startsWith("user:") || lowered.startsWith("dm:")) {
+    const normalized = trimmed.replace(/^(user|dm):/i, "").trim();
+    return normalized.startsWith(OPEN_ID_PREFIX) ? "open_id" : "user_id";
+  }
   if (trimmed.startsWith(CHAT_ID_PREFIX)) {
     return "chat_id";
   }
@@ -70,7 +94,7 @@ export function looksLikeFeishuId(raw: string): boolean {
   if (!trimmed) {
     return false;
   }
-  if (/^(chat|user|open_id):/i.test(trimmed)) {
+  if (/^(chat|group|channel|user|dm|open_id):/i.test(trimmed)) {
     return true;
   }
   if (trimmed.startsWith(CHAT_ID_PREFIX)) {

package/src/tool-account-routing.test.ts

@@ -1,4 +1,4 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/feishu";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { registerFeishuBitableTools } from "./bitable.js";
 import { registerFeishuDriveTools } from "./drive.js";
@@ -35,12 +35,12 @@ function createConfig(params: {
         accounts: {
           a: {
             appId: "app-a",
-            appSecret: "sec-a",
+            appSecret: "sec-a", // pragma: allowlist secret
             tools: params.toolsA,
           },
           b: {
             appId: "app-b",
-            appSecret: "sec-b",
+            appSecret: "sec-b", // pragma: allowlist secret
             tools: params.toolsB,
           },
         },

package/src/tool-account.ts

@@ -1,5 +1,5 @@
 import type * as Lark from "@larksuiteoapi/node-sdk";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/feishu";
 import { resolveFeishuAccount } from "./accounts.js";
 import { createFeishuClient } from "./client.js";
 import { resolveToolsConfig } from "./tools-config.js";

package/src/tool-factory-test-harness.ts

@@ -1,4 +1,4 @@
-import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk/feishu";
 
 type ToolContextLike = {
   agentAccountId?: string;