@openclaw/feishu 2026.5.2 → 2026.5.3-beta.2

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

@@ -1,79 +0,0 @@
-import type { OpenClawPluginApi } from "../runtime-api.js";
-
-type ToolContextLike = {
-  agentAccountId?: string;
-};
-
-export type ToolLike = {
-  name: string;
-  execute: (
-    toolCallId: string,
-    params: unknown,
-  ) => Promise<{ details: Record<string, unknown> }> | { details: Record<string, unknown> };
-};
-
-type RegisteredTool = {
-  tool: unknown;
-  opts?: { name?: string };
-};
-
-function toToolList(value: unknown): unknown[] {
-  if (!value) {
-    return [];
-  }
-  return Array.isArray(value) ? value : [value];
-}
-
-function asToolLike(tool: unknown, fallbackName?: string): ToolLike {
-  const candidate = tool as Partial<ToolLike>;
-  const name = candidate.name ?? fallbackName;
-  const execute = candidate.execute;
-  if (!name || typeof execute !== "function") {
-    throw new Error(`Resolved tool is missing required fields (name=${String(name)})`);
-  }
-  return {
-    name,
-    execute: (toolCallId, params) => execute(toolCallId, params),
-  };
-}
-
-export function createToolFactoryHarness(cfg: OpenClawPluginApi["config"]) {
-  const registered: RegisteredTool[] = [];
-
-  const api: Pick<OpenClawPluginApi, "config" | "logger" | "registerTool"> = {
-    config: cfg,
-    logger: {
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-      debug: () => {},
-    },
-    registerTool: (tool, opts) => {
-      registered.push({ tool, opts });
-    },
-  };
-
-  const resolveTool = (name: string, ctx: ToolContextLike = {}): ToolLike => {
-    for (const entry of registered) {
-      if (entry.opts?.name === name && typeof entry.tool !== "function") {
-        return asToolLike(entry.tool, name);
-      }
-
-      if (typeof entry.tool === "function") {
-        const builtTools = toToolList(entry.tool(ctx));
-        const hit = builtTools.find((tool) => (tool as { name?: string }).name === name);
-        if (hit) {
-          return asToolLike(hit, name);
-        }
-      } else if ((entry.tool as { name?: string }).name === name) {
-        return asToolLike(entry.tool, name);
-      }
-    }
-    throw new Error(`Tool not registered: ${name}`);
-  };
-
-  return {
-    api: api as OpenClawPluginApi,
-    resolveTool,
-  };
-}

package/src/tool-result.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  jsonToolResult,
-  toolExecutionErrorResult,
-  unknownToolActionResult,
-} from "./tool-result.js";
-
-describe("jsonToolResult", () => {
-  it("formats tool result with text content and details", () => {
-    const payload = { ok: true, id: "abc" };
-    expect(jsonToolResult(payload)).toEqual({
-      content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
-      details: payload,
-    });
-  });
-
-  it("formats unknown action errors", () => {
-    expect(unknownToolActionResult("create")).toEqual({
-      content: [
-        { type: "text", text: JSON.stringify({ error: "Unknown action: create" }, null, 2) },
-      ],
-      details: { error: "Unknown action: create" },
-    });
-  });
-
-  it("formats execution errors", () => {
-    expect(toolExecutionErrorResult(new Error("boom"))).toEqual({
-      content: [{ type: "text", text: JSON.stringify({ error: "boom" }, null, 2) }],
-      details: { error: "boom" },
-    });
-  });
-});

package/src/tool-result.ts

@@ -1,16 +0,0 @@
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-
-export function jsonToolResult(data: unknown) {
-  return {
-    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  };
-}
-
-export function unknownToolActionResult(action: unknown) {
-  return jsonToolResult({ error: `Unknown action: ${String(action)}` });
-}
-
-export function toolExecutionErrorResult(error: unknown) {
-  return jsonToolResult({ error: formatErrorMessage(error) });
-}

package/src/tools-config.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { FeishuConfigSchema } from "./config-schema.js";
-import { resolveToolsConfig } from "./tools-config.js";
-
-describe("feishu tools config", () => {
-  it("enables chat tool by default", () => {
-    const resolved = resolveToolsConfig(undefined);
-    expect(resolved.chat).toBe(true);
-  });
-
-  it("accepts tools.chat in config schema", () => {
-    const parsed = FeishuConfigSchema.parse({
-      enabled: true,
-      tools: {
-        chat: false,
-      },
-    });
-
-    expect(parsed.tools?.chat).toBe(false);
-  });
-});

package/src/tools-config.ts

@@ -1,22 +0,0 @@
-import type { FeishuToolsConfig } from "./types.js";
-
-/**
- * Default tool configuration.
- * - doc, chat, wiki, drive, scopes: enabled by default
- * - perm: disabled by default (sensitive operation)
- */
-const DEFAULT_TOOLS_CONFIG: Required<FeishuToolsConfig> = {
-  doc: true,
-  chat: true,
-  wiki: true,
-  drive: true,
-  perm: false,
-  scopes: true,
-};
-
-/**
- * Resolve tools config with defaults.
- */
-export function resolveToolsConfig(cfg?: FeishuToolsConfig): Required<FeishuToolsConfig> {
-  return { ...DEFAULT_TOOLS_CONFIG, ...cfg };
-}

package/src/types.ts

@@ -1,104 +0,0 @@
-import type { BaseProbeResult } from "openclaw/plugin-sdk/core";
-import type { FeishuConfigSchema, FeishuAccountConfigSchema, z } from "./config-schema.js";
-import type { MentionTarget } from "./mention-target.types.js";
-
-export type FeishuConfig = z.infer<typeof FeishuConfigSchema>;
-export type FeishuAccountConfig = z.infer<typeof FeishuAccountConfigSchema>;
-
-export type FeishuDomain = "feishu" | "lark" | (string & {});
-
-export type FeishuDefaultAccountSelectionSource =
-  | "explicit-default"
-  | "mapped-default"
-  | "fallback";
-type FeishuAccountSelectionSource = "explicit" | FeishuDefaultAccountSelectionSource;
-
-export type ResolvedFeishuAccount = {
-  accountId: string;
-  selectionSource: FeishuAccountSelectionSource;
-  enabled: boolean;
-  configured: boolean;
-  name?: string;
-  appId?: string;
-  appSecret?: string;
-  encryptKey?: string;
-  verificationToken?: string;
-  domain: FeishuDomain;
-  /** Merged config (top-level defaults + account-specific overrides) */
-  config: FeishuConfig;
-};
-
-export type FeishuIdType = "open_id" | "user_id" | "union_id" | "chat_id";
-
-export type FeishuMessageContext = {
-  chatId: string;
-  messageId: string;
-  replyTargetMessageId?: string;
-  suppressReplyTarget?: boolean;
-  senderId: string;
-  senderOpenId: string;
-  senderName?: string;
-  chatType: FeishuChatType;
-  mentionedBot: boolean;
-  hasAnyMention?: boolean;
-  rootId?: string;
-  parentId?: string;
-  threadId?: string;
-  content: string;
-  contentType: string;
-  /** Mention forward targets (excluding the bot itself) */
-  mentionTargets?: MentionTarget[];
-};
-
-export type FeishuSendResult = {
-  messageId: string;
-  chatId: string;
-};
-
-export type FeishuChatType = "p2p" | "group" | "topic_group" | "private";
-
-export function isFeishuGroupChatType(chatType: FeishuChatType | undefined): boolean {
-  return chatType === "group" || chatType === "topic_group";
-}
-
-export type FeishuMessageInfo = {
-  messageId: string;
-  chatId: string;
-  chatType?: FeishuChatType;
-  senderId?: string;
-  senderOpenId?: string;
-  senderType?: string;
-  content: string;
-  contentType: string;
-  createTime?: number;
-  /** Feishu thread ID (omt_xxx) — present when the message belongs to a topic thread. */
-  threadId?: string;
-};
-
-export interface FeishuProbeResult extends BaseProbeResult {
-  appId?: string;
-  botName?: string;
-  botOpenId?: string;
-}
-
-export type FeishuMediaInfo = {
-  path: string;
-  contentType?: string;
-  placeholder: string;
-};
-
-export type FeishuToolsConfig = {
-  doc?: boolean;
-  chat?: boolean;
-  wiki?: boolean;
-  drive?: boolean;
-  perm?: boolean;
-  scopes?: boolean;
-};
-
-export type DynamicAgentCreationConfig = {
-  enabled?: boolean;
-  workspaceTemplate?: string;
-  agentDirTemplate?: string;
-  maxAgents?: number;
-};

package/src/typing.test.ts

@@ -1,144 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isFeishuBackoffError, getBackoffCodeFromResponse, FeishuBackoffError } from "./typing.js";
-
-describe("isFeishuBackoffError", () => {
-  it("returns true for HTTP 429 (AxiosError shape)", () => {
-    const err = { response: { status: 429, data: {} } };
-    expect(isFeishuBackoffError(err)).toBe(true);
-  });
-
-  it("returns true for Feishu quota exceeded code 99991403", () => {
-    const err = { response: { status: 200, data: { code: 99991403 } } };
-    expect(isFeishuBackoffError(err)).toBe(true);
-  });
-
-  it("returns true for Feishu rate limit code 99991400", () => {
-    const err = { response: { status: 200, data: { code: 99991400 } } };
-    expect(isFeishuBackoffError(err)).toBe(true);
-  });
-
-  it("returns true for SDK error with code 429", () => {
-    const err = { code: 429, message: "too many requests" };
-    expect(isFeishuBackoffError(err)).toBe(true);
-  });
-
-  it("returns true for SDK error with top-level code 99991403", () => {
-    const err = { code: 99991403, message: "quota exceeded" };
-    expect(isFeishuBackoffError(err)).toBe(true);
-  });
-
-  it("returns false for other HTTP errors (e.g. 500)", () => {
-    const err = { response: { status: 500, data: {} } };
-    expect(isFeishuBackoffError(err)).toBe(false);
-  });
-
-  it("returns false for non-rate-limit Feishu codes", () => {
-    const err = { response: { status: 200, data: { code: 99991401 } } };
-    expect(isFeishuBackoffError(err)).toBe(false);
-  });
-
-  it("returns false for generic Error", () => {
-    expect(isFeishuBackoffError(new Error("network timeout"))).toBe(false);
-  });
-
-  it("returns false for null", () => {
-    expect(isFeishuBackoffError(null)).toBe(false);
-  });
-
-  it("returns false for undefined", () => {
-    expect(isFeishuBackoffError(undefined)).toBe(false);
-  });
-
-  it("returns false for string", () => {
-    expect(isFeishuBackoffError("429")).toBe(false);
-  });
-
-  it("returns true for 429 even without data", () => {
-    const err = { response: { status: 429 } };
-    expect(isFeishuBackoffError(err)).toBe(true);
-  });
-});
-
-describe("getBackoffCodeFromResponse", () => {
-  it("returns backoff code for response with quota exceeded code", () => {
-    const response = { code: 99991403, msg: "quota exceeded", data: null };
-    expect(getBackoffCodeFromResponse(response)).toBe(response.code);
-  });
-
-  it("returns backoff code for response with rate limit code", () => {
-    const response = { code: 99991400, msg: "rate limit", data: null };
-    expect(getBackoffCodeFromResponse(response)).toBe(response.code);
-  });
-
-  it("returns backoff code for response with code 429", () => {
-    const response = { code: 429, msg: "too many requests", data: null };
-    expect(getBackoffCodeFromResponse(response)).toBe(response.code);
-  });
-
-  it("returns undefined for successful response (code 0)", () => {
-    const response = { code: 0, msg: "success", data: { reaction_id: "r1" } };
-    expect(getBackoffCodeFromResponse(response)).toBeUndefined();
-  });
-
-  it("returns undefined for other error codes", () => {
-    const response = { code: 99991401, msg: "other error", data: null };
-    expect(getBackoffCodeFromResponse(response)).toBeUndefined();
-  });
-
-  it("returns undefined for null", () => {
-    expect(getBackoffCodeFromResponse(null)).toBeUndefined();
-  });
-
-  it("returns undefined for undefined", () => {
-    expect(getBackoffCodeFromResponse(undefined)).toBeUndefined();
-  });
-
-  it("returns undefined for response without code field", () => {
-    const response = { data: { reaction_id: "r1" } };
-    expect(getBackoffCodeFromResponse(response)).toBeUndefined();
-  });
-});
-
-describe("FeishuBackoffError", () => {
-  it("is detected by isFeishuBackoffError via .code property", () => {
-    const err = new FeishuBackoffError(99991403);
-    expect(isFeishuBackoffError(err)).toBe(true);
-  });
-
-  it("is detected for rate limit code 99991400", () => {
-    const err = new FeishuBackoffError(99991400);
-    expect(isFeishuBackoffError(err)).toBe(true);
-  });
-
-  it("has correct name and message", () => {
-    const err = new FeishuBackoffError(99991403);
-    expect(err.name).toBe("FeishuBackoffError");
-    expect(err.message).toBe("Feishu API backoff: code 99991403");
-    expect(err.code).toBe(99991403);
-  });
-
-  it("is an instance of Error", () => {
-    const err = new FeishuBackoffError(99991403);
-    expect(err instanceof Error).toBe(true);
-  });
-
-  it("survives catch-and-rethrow pattern", () => {
-    // Simulates the exact pattern in addTypingIndicator/removeTypingIndicator:
-    // thrown inside try, caught by catch, isFeishuBackoffError must match
-    let caught: unknown;
-    try {
-      try {
-        throw new FeishuBackoffError(99991403);
-      } catch (err) {
-        if (isFeishuBackoffError(err)) {
-          throw err; // re-thrown — this is the fix
-        }
-        // would be silently swallowed with plain Error
-        caught = "swallowed";
-      }
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(FeishuBackoffError);
-  });
-});

package/src/typing.ts

@@ -1,214 +0,0 @@
-import type { ClawdbotConfig, RuntimeEnv } from "../runtime-api.js";
-import { resolveFeishuRuntimeAccount } from "./accounts.js";
-import { createFeishuClient } from "./client.js";
-import { getFeishuRuntime } from "./runtime.js";
-
-// Feishu emoji types for typing indicator
-// See: https://open.feishu.cn/document/server-docs/im-v1/message-reaction/emojis-introduce
-// Full list: https://github.com/go-lark/lark/blob/main/emoji.go
-const TYPING_EMOJI = "Typing"; // Typing indicator emoji
-
-/**
- * Feishu API error codes that indicate the caller should back off.
- * These must propagate to the typing circuit breaker so the keepalive loop
- * can trip and stop retrying.
- *
- * - 99991400: Rate limit (too many requests per second)
- * - 99991403: Monthly API call quota exceeded
- * - 429: Standard HTTP 429 returned as a Feishu SDK error code
- *
- * @see https://open.feishu.cn/document/server-docs/api-call-guide/generic-error-code
- */
-const FEISHU_BACKOFF_CODES = new Set([99991400, 99991403, 429]);
-
-/**
- * Custom error class for Feishu backoff conditions detected from non-throwing
- * SDK responses. Carries a numeric `.code` so that `isFeishuBackoffError()`
- * recognises it when the error is caught downstream.
- */
-export class FeishuBackoffError extends Error {
-  code: number;
-  constructor(code: number) {
-    super(`Feishu API backoff: code ${code}`);
-    this.name = "FeishuBackoffError";
-    this.code = code;
-  }
-}
-
-export type TypingIndicatorState = {
-  messageId: string;
-  reactionId: string | null;
-};
-
-type FeishuMessageReactionCreateResponse = Awaited<
-  ReturnType<ReturnType<typeof createFeishuClient>["im"]["messageReaction"]["create"]>
->;
-
-/**
- * Check whether an error represents a rate-limit or quota-exceeded condition
- * from the Feishu API that should stop the typing keepalive loop.
- *
- * Handles two shapes:
- * 1. AxiosError with `response.status` and `response.data.code`
- * 2. Feishu SDK error with a top-level `code` property
- */
-export function isFeishuBackoffError(err: unknown): boolean {
-  if (typeof err !== "object" || err === null) {
-    return false;
-  }
-
-  // AxiosError shape: err.response.status / err.response.data.code
-  const response = (err as { response?: { status?: number; data?: { code?: number } } }).response;
-  if (response) {
-    if (response.status === 429) {
-      return true;
-    }
-    if (typeof response.data?.code === "number" && FEISHU_BACKOFF_CODES.has(response.data.code)) {
-      return true;
-    }
-  }
-
-  // Feishu SDK error shape: err.code
-  const code = (err as { code?: number }).code;
-  if (typeof code === "number" && FEISHU_BACKOFF_CODES.has(code)) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Check whether a Feishu SDK response object contains a backoff error code.
- *
- * The Feishu SDK sometimes returns a normal response (no throw) with an
- * API-level error code in the response body. This must be detected so the
- * circuit breaker can trip. See codex review on #28157.
- */
-export function getBackoffCodeFromResponse(response: unknown): number | undefined {
-  if (typeof response !== "object" || response === null) {
-    return undefined;
-  }
-  const code = (response as { code?: number }).code;
-  if (typeof code === "number" && FEISHU_BACKOFF_CODES.has(code)) {
-    return code;
-  }
-  return undefined;
-}
-
-/**
- * Add a typing indicator (reaction) to a message.
- *
- * Rate-limit and quota errors are re-thrown so the circuit breaker in
- * `createTypingCallbacks` (typing-start-guard) can trip and stop the
- * keepalive loop. See #28062.
- *
- * Also checks for backoff codes in non-throwing SDK responses (#28157).
- */
-export async function addTypingIndicator(params: {
-  cfg: ClawdbotConfig;
-  messageId: string;
-  accountId?: string;
-  runtime?: RuntimeEnv;
-}): Promise<TypingIndicatorState> {
-  const { cfg, messageId, accountId, runtime } = params;
-  const account = resolveFeishuRuntimeAccount({ cfg, accountId });
-  if (!account.configured) {
-    return { messageId, reactionId: null };
-  }
-
-  const client = createFeishuClient(account);
-
-  try {
-    const response = await client.im.messageReaction.create({
-      path: { message_id: messageId },
-      data: {
-        reaction_type: { emoji_type: TYPING_EMOJI },
-      },
-    });
-
-    // Feishu SDK may return a normal response with an API-level error code
-    // instead of throwing. Detect backoff codes and throw to trip the breaker.
-    const backoffCode = getBackoffCodeFromResponse(response);
-    if (backoffCode !== undefined) {
-      if (getFeishuRuntime().logging.shouldLogVerbose()) {
-        runtime?.log?.(
-          `[feishu] typing indicator response contains backoff code ${backoffCode}, stopping keepalive`,
-        );
-      }
-      throw new FeishuBackoffError(backoffCode);
-    }
-
-    const typedResponse: FeishuMessageReactionCreateResponse = response;
-    const reactionId = typedResponse.data?.reaction_id ?? null;
-    return { messageId, reactionId };
-  } catch (err) {
-    if (isFeishuBackoffError(err)) {
-      if (getFeishuRuntime().logging.shouldLogVerbose()) {
-        runtime?.log?.("[feishu] typing indicator hit rate-limit/quota, stopping keepalive");
-      }
-      throw err;
-    }
-    // Silently fail for other non-critical errors (e.g. message deleted, permission issues)
-    if (getFeishuRuntime().logging.shouldLogVerbose()) {
-      runtime?.log?.(`[feishu] failed to add typing indicator: ${String(err)}`);
-    }
-    return { messageId, reactionId: null };
-  }
-}
-
-/**
- * Remove a typing indicator (reaction) from a message.
- *
- * Rate-limit and quota errors are re-thrown for the same reason as above.
- */
-export async function removeTypingIndicator(params: {
-  cfg: ClawdbotConfig;
-  state: TypingIndicatorState;
-  accountId?: string;
-  runtime?: RuntimeEnv;
-}): Promise<void> {
-  const { cfg, state, accountId, runtime } = params;
-  if (!state.reactionId) {
-    return;
-  }
-
-  const account = resolveFeishuRuntimeAccount({ cfg, accountId });
-  if (!account.configured) {
-    return;
-  }
-
-  const client = createFeishuClient(account);
-
-  try {
-    const result = await client.im.messageReaction.delete({
-      path: {
-        message_id: state.messageId,
-        reaction_id: state.reactionId,
-      },
-    });
-
-    // Check for backoff codes in non-throwing SDK responses
-    const backoffCode = getBackoffCodeFromResponse(result);
-    if (backoffCode !== undefined) {
-      if (getFeishuRuntime().logging.shouldLogVerbose()) {
-        runtime?.log?.(
-          `[feishu] typing indicator removal response contains backoff code ${backoffCode}, stopping keepalive`,
-        );
-      }
-      throw new FeishuBackoffError(backoffCode);
-    }
-  } catch (err) {
-    if (isFeishuBackoffError(err)) {
-      if (getFeishuRuntime().logging.shouldLogVerbose()) {
-        runtime?.log?.(
-          "[feishu] typing indicator removal hit rate-limit/quota, stopping keepalive",
-        );
-      }
-      throw err;
-    }
-    // Silently fail for other non-critical errors
-    if (getFeishuRuntime().logging.shouldLogVerbose()) {
-      runtime?.log?.(`[feishu] failed to remove typing indicator: ${String(err)}`);
-    }
-  }
-}

package/src/wiki-schema.ts

@@ -1,55 +0,0 @@
-import { Type, type Static } from "typebox";
-
-export const FeishuWikiSchema = Type.Union([
-  Type.Object({
-    action: Type.Literal("spaces"),
-  }),
-  Type.Object({
-    action: Type.Literal("nodes"),
-    space_id: Type.String({ description: "Knowledge space ID" }),
-    parent_node_token: Type.Optional(
-      Type.String({ description: "Parent node token (optional, omit for root)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("get"),
-    token: Type.String({ description: "Wiki node token (from URL /wiki/XXX)" }),
-  }),
-  Type.Object({
-    action: Type.Literal("search"),
-    query: Type.String({ description: "Search query" }),
-    space_id: Type.Optional(Type.String({ description: "Limit search to this space (optional)" })),
-  }),
-  Type.Object({
-    action: Type.Literal("create"),
-    space_id: Type.String({ description: "Knowledge space ID" }),
-    title: Type.String({ description: "Node title" }),
-    obj_type: Type.Optional(
-      Type.Union([Type.Literal("docx"), Type.Literal("sheet"), Type.Literal("bitable")], {
-        description: "Object type (default: docx)",
-      }),
-    ),
-    parent_node_token: Type.Optional(
-      Type.String({ description: "Parent node token (optional, omit for root)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("move"),
-    space_id: Type.String({ description: "Source knowledge space ID" }),
-    node_token: Type.String({ description: "Node token to move" }),
-    target_space_id: Type.Optional(
-      Type.String({ description: "Target space ID (optional, same space if omitted)" }),
-    ),
-    target_parent_token: Type.Optional(
-      Type.String({ description: "Target parent node token (optional, root if omitted)" }),
-    ),
-  }),
-  Type.Object({
-    action: Type.Literal("rename"),
-    space_id: Type.String({ description: "Knowledge space ID" }),
-    node_token: Type.String({ description: "Node token to rename" }),
-    title: Type.String({ description: "New title" }),
-  }),
-]);
-
-export type FeishuWikiParams = Static<typeof FeishuWikiSchema>;