@openclaw/feishu 2026.9.1-beta.1 → 2026.9.2

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as feishuPlugin } from "./channel-Dpgf8wLD.js";
+import { t as feishuPlugin } from "./channel-VytDDz_B.js";
 export { feishuPlugin };

package/dist/{channel.runtime-BIEERwaT.js → channel.runtime-CAD74kBO.js}

@@ -1,9 +1,9 @@
-import { o as resolveFeishuAccount, s as resolveFeishuRuntimeAccount } from "./accounts-RwSyseKr.js";
-import { c as listFeishuDirectoryPeers, o as feishuOutbound, s as listFeishuDirectoryGroups } from "./channel-Dpgf8wLD.js";
-import { d as editMessageFeishu, f as getMessageFeishu, g as sendMessageFeishu, l as sendStickerFeishu, m as sendCardFeishu } from "./presentation-card-C8Z7Tgru.js";
-import { r as createFeishuClient } from "./client-DalLmpMf.js";
-import { a as getFeishuMemberInfo, i as getChatMembers, n as buildFeishuDirectChatMembers, r as getChatInfo, t as assertFeishuChatMember } from "./chat-C1nuW5UY.js";
-import { t as probeFeishu } from "./probe-CfhhR_0a.js";
+import { o as resolveFeishuAccount, s as resolveFeishuRuntimeAccount } from "./accounts-cCMNFBKg.js";
+import { c as listFeishuDirectoryPeers, o as feishuOutbound, s as listFeishuDirectoryGroups } from "./channel-VytDDz_B.js";
+import { C as editMessageFeishu, D as sendMessageFeishu, E as sendCardFeishu, I as assertFeishuApiSuccess, b as sendStickerFeishu, w as getMessageFeishu } from "./reply-delivery-result-CYaKkbUN.js";
+import { r as createFeishuClient } from "./client-DMbIL3UH.js";
+import { a as getFeishuMemberInfo, i as getChatMembers, n as buildFeishuDirectChatMembers, r as getChatInfo, t as assertFeishuChatMember } from "./chat-DDhIcPQy.js";
+import { t as probeFeishu } from "./probe-D_SatdZl.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/feishu/src/directory.ts
 const MAX_FEISHU_DIRECTORY_PAGES = 100;
@@ -84,9 +84,6 @@ async function listFeishuDirectoryGroupsLive(params) {
 }
 //#endregion
 //#region extensions/feishu/src/pins.ts
-function assertFeishuPinApiSuccess(response, action) {
-	if (response.code !== 0) throw new Error(`Feishu ${action} failed: ${response.msg || `code ${response.code}`}`);
-}
 function normalizePin(pin) {
 	return {
 		messageId: pin.message_id,
@@ -103,7 +100,7 @@ async function createPinFeishu(params) {
 	});
 	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
 	const response = await createFeishuClient(account).im.pin.create({ data: { message_id: params.messageId } });
-	assertFeishuPinApiSuccess(response, "pin create");
+	assertFeishuApiSuccess(response, "Feishu pin create failed");
 	return response.data?.pin ? normalizePin(response.data.pin) : null;
 }
 async function removePinFeishu(params) {
@@ -112,7 +109,8 @@ async function removePinFeishu(params) {
 		accountId: params.accountId
 	});
 	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
-	assertFeishuPinApiSuccess(await createFeishuClient(account).im.pin.delete({ path: { message_id: params.messageId } }), "pin delete");
+	const response = await createFeishuClient(account).im.pin.delete({ path: { message_id: params.messageId } });
+	assertFeishuApiSuccess(response, "Feishu pin delete failed");
 }
 async function listPinsFeishu(params) {
 	const account = resolveFeishuRuntimeAccount({
@@ -127,7 +125,7 @@ async function listPinsFeishu(params) {
 		...typeof params.pageSize === "number" ? { page_size: Math.max(1, Math.min(100, Math.floor(params.pageSize))) } : {},
 		...params.pageToken ? { page_token: params.pageToken } : {}
 	} });
-	assertFeishuPinApiSuccess(response, "pin list");
+	assertFeishuApiSuccess(response, "Feishu pin list failed");
 	return {
 		chatId: params.chatId,
 		pins: (response.data?.items ?? []).map(normalizePin),
@@ -142,9 +140,6 @@ function resolveConfiguredFeishuClient(params) {
 	if (!account.configured) throw new Error(`Feishu account "${account.accountId}" not configured`);
 	return createFeishuClient(account);
 }
-function assertFeishuReactionApiSuccess(response, action) {
-	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"
@@ -159,7 +154,7 @@ async function addReactionFeishu(params) {
 		path: { message_id: messageId },
 		data: { reaction_type: { emoji_type: emojiType } }
 	});
-	assertFeishuReactionApiSuccess(response, "add reaction");
+	assertFeishuApiSuccess(response, "Feishu add reaction failed");
 	const reactionId = response.data?.reaction_id;
 	if (!reactionId) throw new Error("Feishu add reaction failed: no reaction_id returned");
 	return { reactionId };
@@ -169,13 +164,14 @@ async function addReactionFeishu(params) {
 */
 async function removeReactionFeishu(params) {
 	const { cfg, messageId, reactionId, accountId } = params;
-	assertFeishuReactionApiSuccess(await resolveConfiguredFeishuClient({
+	const response = await resolveConfiguredFeishuClient({
 		cfg,
 		accountId
 	}).im.messageReaction.delete({ path: {
 		message_id: messageId,
 		reaction_id: reactionId
-	} }), "remove reaction");
+	} });
+	assertFeishuApiSuccess(response, "Feishu remove reaction failed");
 }
 /**
 * List all reactions for a message.
@@ -197,7 +193,7 @@ async function listReactionsFeishu(params) {
 				...pageToken ? { page_token: pageToken } : {}
 			} : void 0
 		});
-		assertFeishuReactionApiSuccess(response, "list reactions");
+		assertFeishuApiSuccess(response, "Feishu list reactions failed");
 		for (const item of response.data?.items ?? []) reactions.push({
 			reactionId: item.reaction_id ?? "",
 			emojiType: item.reaction_type?.emoji_type ?? "",

package/dist/{chat-C1nuW5UY.js → chat-DDhIcPQy.js}

@@ -1,6 +1,5 @@
-import { r as listEnabledFeishuAccounts } from "./accounts-RwSyseKr.js";
-import { A as feishuExternalToolResult, B as formatFeishuApiError, F as resolveFeishuToolAccount, P as resolveAnyEnabledFeishuToolsConfig, et as assertFeishuChatReadAllowed, gt as resolveFeishuChatType, ot as resolveFeishuChatReadPreliminaryAuthorization, tt as authorizeFeishuChatMemberRead } from "./presentation-card-C8Z7Tgru.js";
-import { r as createFeishuClient } from "./client-DalLmpMf.js";
+import { Et as resolveFeishuChatType, H as feishuExternalToolResult, K as resolveAnyEnabledFeishuToolsConfig, Q as formatFeishuApiError, dt as authorizeFeishuChatMemberRead, gt as resolveFeishuChatReadPreliminaryAuthorization, q as resolveFeishuToolAccount, ut as assertFeishuChatReadAllowed } from "./reply-delivery-result-CYaKkbUN.js";
+import { r as createFeishuClient } from "./client-DMbIL3UH.js";
 import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
 import { readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
 import { Type } from "typebox";
@@ -192,9 +191,7 @@ async function getFeishuMemberInfo(client, memberId, memberIdType = "open_id") {
 function registerFeishuChatTools(api) {
 	if (!api.config) return;
 	const cfg = api.config;
-	const accounts = listEnabledFeishuAccounts(cfg);
-	if (accounts.length === 0) return;
-	if (!resolveAnyEnabledFeishuToolsConfig(accounts).chat) return;
+	if (!resolveAnyEnabledFeishuToolsConfig(cfg).chat) return;
 	api.registerTool((toolContext) => ({
 		name: "feishu_chat",
 		resultContentSource: "network",
@@ -238,13 +235,16 @@ function registerFeishuChatTools(api) {
 						return feishuExternalToolResult(await getChatMembers(client, p.chat_id, readChatPageSize(rawParams), p.page_token, p.member_id_type));
 					case "info":
 						if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action info" });
-						return feishuExternalToolResult(await getAuthorizedFeishuChatInfo({
-							client,
-							cfg,
-							account,
-							chatId: p.chat_id,
-							ctx: toolContext
-						}));
+						{
+							const chat = await getAuthorizedFeishuChatInfo({
+								client,
+								cfg,
+								account,
+								chatId: p.chat_id,
+								ctx: toolContext
+							});
+							return feishuExternalToolResult(chat);
+						}
 					case "member_info":
 						if (!p.member_id) return feishuExternalToolResult({ error: "member_id is required for action member_info" });
 						if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action member_info" });

package/dist/{client-DalLmpMf.js → client-DMbIL3UH.js}

@@ -2,6 +2,7 @@ import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { createRequire } from "node:module";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import * as Lark from "@larksuiteoapi/node-sdk";
+import { bufferToBlobPart } from "openclaw/plugin-sdk/blob-runtime";
 import { isRecord } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
 import { readPluginPackageVersion, resolveAmbientNodeProxyAgent } from "openclaw/plugin-sdk/extension-shared";
 //#region extensions/feishu/src/client-timeout.ts
@@ -32,7 +33,8 @@ var client_exports = /* @__PURE__ */ __exportAll({
 	createFeishuWSClient: () => createFeishuWSClient,
 	getFeishuUserAgent: () => getFeishuUserAgent
 });
-const FEISHU_USER_AGENT = `openclaw-feishu-builtin/${readPluginPackageVersion({ require: createRequire(import.meta.url) })}/${process.platform}`;
+const require = createRequire(import.meta.url);
+const FEISHU_USER_AGENT = `openclaw-feishu-builtin/${readPluginPackageVersion({ require })}/${process.platform}`;
 const FEISHU_SDK_ORIGIN = "https://open.feishu.cn";
 const FEISHU_WS_CONFIG = { pingTimeout: 3 };
 /** User-Agent header value for all Feishu API requests. */
@@ -99,11 +101,6 @@ function stringifyMultipartFieldValue(value) {
 		default: return;
 	}
 }
-function bufferToBlobPart(value) {
-	const bytes = new Uint8Array(value.byteLength);
-	bytes.set(value);
-	return bytes;
-}
 function normalizeMultipartUploadData(opts) {
 	if (!isMultipartFormRequest(opts) || !isRecord(opts.data) || !isFeishuMessageMediaUploadRequest(opts, opts.data)) return opts;
 	const form = new FormData();

package/dist/contract-api.js

@@ -1,4 +1,4 @@
 import { a as parseFeishuTargetId, i as parseFeishuDirectConversationId, r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-VYgGQ-GX.js";
-import { t as messageActionTargetAliases } from "./security-audit-D6Fz2h6p.js";
-import { t as collectFeishuSecurityAuditFindings } from "./security-audit-shared-BgpY7AiJ.js";
+import { t as messageActionTargetAliases } from "./security-audit-DKfR4Cv3.js";
+import { t as collectFeishuSecurityAuditFindings } from "./security-audit-shared-CK5rVR-1.js";
 export { buildFeishuConversationId, collectFeishuSecurityAuditFindings, messageActionTargetAliases, parseFeishuConversationId, parseFeishuDirectConversationId, parseFeishuTargetId };

package/dist/doctor-contract-api.js

@@ -1,2 +1,2 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-bEQXIXyP.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-w6FpMypv.js";
 export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/doctor-contract-w6FpMypv.js

@@ -0,0 +1,465 @@
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { ContextVisibilityModeSchema, DmPolicySchema, GroupPolicySchema, ReplyToModeSchema, buildChannelConfigSchema, buildGroupEntrySchema, buildMultiAccountChannelSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import { z } from "zod";
+import { buildSecretInputSchema, hasConfiguredSecretInput as hasConfiguredSecretInput$1 } from "openclaw/plugin-sdk/secret-input";
+import { asObjectRecord, defineChannelAliasMigration, defineKeyMoveMigration, defineStrayPluginEntryConfigMigration, hasLegacyAccountStreamingAliases, normalizeChannelConfigEntries } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+//#region extensions/feishu/src/external-keys.ts
+const FEISHU_EXTERNAL_KEY_PATTERN = /^(?!\s)(?![\s\S]*\s$)(?![\s\S]*\.\.)[^\p{Cc}\p{Cs}/\\]{1,512}$/u;
+function normalizeFeishuExternalKey(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.trim();
+	return FEISHU_EXTERNAL_KEY_PATTERN.test(normalized) ? normalized : void 0;
+}
+//#endregion
+//#region extensions/feishu/src/webhook-path.ts
+const DEFAULT_FEISHU_WEBHOOK_PATH = "/feishu/events";
+/** Normalize trusted configuration only; incoming request targets must remain unmodified. */
+function normalizeFeishuWebhookPath(value) {
+	const configured = value?.trim();
+	if (!configured) return DEFAULT_FEISHU_WEBHOOK_PATH;
+	try {
+		const parsed = new URL(configured, "http://localhost");
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+		const emptyQuery = !parsed.search && parsed.href.endsWith("?") && !configured.includes("#") ? "?" : "";
+		return `${parsed.pathname}${parsed.search}${emptyQuery}`;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region extensions/feishu/src/config-schema.ts
+const ChannelActionsSchema = z.object({
+	reactions: z.boolean().optional(),
+	sticker: z.boolean().optional()
+}).strict().optional();
+const MAX_STICKER_SETS = 32;
+const MAX_STICKERS_PER_SET = 256;
+function canonicalTextPattern(maxLength) {
+	return new RegExp(`^(?!\\s)(?![\\s\\S]*\\s$)[^\\p{Cs}]{1,${maxLength}}$`, "u");
+}
+const FeishuStickerSetSchema = z.record(z.string().regex(FEISHU_EXTERNAL_KEY_PATTERN), z.array(z.string().regex(canonicalTextPattern(64))).min(1).max(8)).refine((set) => Object.keys(set).length <= MAX_STICKERS_PER_SET, { message: `At most ${MAX_STICKERS_PER_SET} stickers per bot set are allowed` }).meta({ maxProperties: MAX_STICKERS_PER_SET });
+const FeishuStickerSetsSchema = z.record(z.string().regex(canonicalTextPattern(128)), FeishuStickerSetSchema).refine((sets) => Object.keys(sets).length <= MAX_STICKER_SETS, { message: `At most ${MAX_STICKER_SETS} bot sticker sets are allowed` }).meta({ maxProperties: MAX_STICKER_SETS });
+const FeishuGroupPolicySchema = z.union([GroupPolicySchema, z.literal("allowall").transform(() => "open")]);
+const FeishuDomainSchema = z.union([z.enum(["feishu", "lark"]), z.string().regex(/^[Hh][Tt][Tt][Pp][Ss]:\/\//).url()]);
+const FeishuConnectionModeSchema = z.enum(["websocket", "webhook"]);
+const FeishuWebhookPathSchema = z.string().refine((value) => normalizeFeishuWebhookPath(value) === value, { message: "webhookPath must be a canonical HTTP request path; run \"openclaw doctor --fix\" to repair it" });
+const TtsOverrideSchema = z.object({
+	auto: z.enum([
+		"off",
+		"always",
+		"inbound",
+		"tagged"
+	]).optional(),
+	enabled: z.boolean().optional(),
+	mode: z.enum(["final", "all"]).optional(),
+	provider: z.string().optional(),
+	persona: z.string().optional(),
+	personas: z.record(z.string(), z.record(z.string(), z.unknown())).optional(),
+	summaryModel: z.string().optional(),
+	modelOverrides: z.record(z.string(), z.unknown()).optional(),
+	providers: z.record(z.string(), z.record(z.string(), z.unknown())).optional(),
+	prefsPath: z.string().optional(),
+	maxTextLength: z.number().int().min(1).optional(),
+	timeoutMs: z.number().int().min(1e3).max(12e4).optional()
+}).strict().optional();
+const ToolPolicySchema = z.object({
+	allow: z.array(z.string()).optional(),
+	deny: z.array(z.string()).optional()
+}).strict().optional();
+const DmConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	systemPrompt: z.string().optional()
+}).strict().optional();
+const MarkdownConfigSchema = z.object({
+	mode: z.enum([
+		"native",
+		"escape",
+		"strip"
+	]).optional(),
+	tableMode: z.enum([
+		"native",
+		"ascii",
+		"simple"
+	]).optional()
+}).strict().optional();
+const RenderModeSchema = z.enum([
+	"auto",
+	"raw",
+	"card"
+]).optional();
+const BlockStreamingCoalesceSchema = z.object({
+	minChars: z.number().int().positive().optional(),
+	maxChars: z.number().int().positive().optional(),
+	idleMs: z.number().int().nonnegative().optional()
+}).strict().optional();
+const FeishuStreamingSchema = z.object({
+	mode: z.enum(["off", "partial"]).optional(),
+	chunkMode: z.enum(["length", "newline"]).optional(),
+	block: z.object({
+		enabled: z.boolean().optional(),
+		coalesce: BlockStreamingCoalesceSchema
+	}).strict().optional()
+}).strict().optional();
+const ChannelHeartbeatVisibilitySchema = z.object({
+	visibility: z.enum(["visible", "hidden"]).optional(),
+	intervalMs: z.number().int().positive().optional()
+}).strict().optional();
+/**
+* Dynamic agent creation configuration.
+* When enabled, a new agent is created for each unique DM user.
+*/
+const DynamicAgentCreationSchema = z.object({
+	enabled: z.boolean().optional(),
+	workspaceTemplate: z.string().optional(),
+	agentDirTemplate: z.string().optional(),
+	maxAgents: z.number().int().positive().optional()
+}).strict().optional();
+/**
+* Feishu tools configuration.
+* Controls which tool categories are enabled.
+*
+* Dependencies:
+* - wiki requires doc (wiki content is edited via doc tools)
+* - perm can work independently but is typically used with drive
+*/
+const FeishuToolsConfigSchema = z.object({
+	doc: z.boolean().optional(),
+	chat: z.boolean().optional(),
+	wiki: z.boolean().optional(),
+	drive: z.boolean().optional(),
+	perm: z.boolean().optional(),
+	scopes: z.boolean().optional(),
+	bitable: z.boolean().optional()
+}).strict().optional();
+/**
+* Group session scope for routing Feishu group messages.
+* - "group" (default): one session per group chat
+* - "group_sender": one session per (group + sender)
+* - "group_topic": one session per group topic thread (falls back to group if no topic)
+* - "group_topic_sender": one session per (group + topic thread + sender),
+*   falls back to (group + sender) if no topic
+*/
+const GroupSessionScopeSchema = z.enum([
+	"group",
+	"group_sender",
+	"group_topic",
+	"group_topic_sender"
+]).optional();
+/**
+* @deprecated Use groupSessionScope instead.
+*
+* Topic session isolation mode for group chats.
+* - "disabled" (default): All messages in a group share one session
+* - "enabled": Messages in different topics get separate sessions
+*
+* Topic routing uses Feishu topic-group `thread_id` when the event identifies a
+* native topic group, and keeps `root_id` precedence for normal groups so
+* reply-created threads stay on the initiating message session.
+*/
+const TopicSessionModeSchema = z.enum(["disabled", "enabled"]).optional();
+const ReactionNotificationModeSchema = z.enum([
+	"off",
+	"own",
+	"all"
+]).optional();
+/**
+* Reply-in-thread mode for group chats.
+* - "disabled" (default): Bot replies are normal inline replies
+* - "enabled": Bot replies create or continue a Feishu topic thread
+*
+* When enabled, the Feishu reply API is called with `reply_in_thread: true`,
+* causing the reply to appear as a topic (话题) under the original message.
+*/
+const ReplyInThreadSchema = z.enum(["disabled", "enabled"]).optional();
+const FeishuGroupSchema = buildGroupEntrySchema({
+	tools: ToolPolicySchema,
+	groupSessionScope: GroupSessionScopeSchema,
+	topicSessionMode: TopicSessionModeSchema,
+	replyInThread: ReplyInThreadSchema
+}).omit({ toolsBySender: true });
+const FeishuSharedConfigShape = {
+	webhookHost: z.string().optional(),
+	webhookPort: z.number().int().positive().optional(),
+	capabilities: z.array(z.string()).optional(),
+	markdown: MarkdownConfigSchema,
+	configWrites: z.boolean().optional(),
+	contextVisibility: ContextVisibilityModeSchema.optional(),
+	replyToMode: ReplyToModeSchema.optional(),
+	responsePrefix: z.string().optional(),
+	dmPolicy: DmPolicySchema.optional(),
+	allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+	groupPolicy: FeishuGroupPolicySchema.optional(),
+	groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+	groupSenderAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+	requireMention: z.boolean().optional(),
+	groups: z.record(z.string(), FeishuGroupSchema.optional()).optional(),
+	historyLimit: z.number().int().min(0).optional(),
+	dmHistoryLimit: z.number().int().min(0).optional(),
+	dms: z.record(z.string(), DmConfigSchema).optional(),
+	textChunkLimit: z.number().int().positive().optional(),
+	mediaMaxMb: z.number().positive().optional(),
+	httpTimeoutMs: z.number().int().positive().max(3e5).optional(),
+	heartbeatVisibility: ChannelHeartbeatVisibilitySchema,
+	renderMode: RenderModeSchema,
+	streaming: FeishuStreamingSchema,
+	tools: FeishuToolsConfigSchema,
+	actions: ChannelActionsSchema,
+	replyInThread: ReplyInThreadSchema,
+	reactionNotifications: ReactionNotificationModeSchema,
+	typingIndicator: z.boolean().optional(),
+	resolveSenderNames: z.boolean().optional(),
+	allowBots: z.boolean().optional(),
+	vcAutoJoin: z.boolean().optional(),
+	tts: TtsOverrideSchema
+};
+/**
+* Per-account configuration.
+* All fields are optional - missing fields inherit from top-level config.
+*/
+const FeishuAccountConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	name: z.string().optional(),
+	appId: z.string().optional(),
+	appSecret: buildSecretInputSchema().optional(),
+	encryptKey: buildSecretInputSchema().optional(),
+	verificationToken: buildSecretInputSchema().optional(),
+	domain: FeishuDomainSchema.optional(),
+	connectionMode: FeishuConnectionModeSchema.optional(),
+	webhookPath: FeishuWebhookPathSchema.optional(),
+	...FeishuSharedConfigShape,
+	groupSessionScope: GroupSessionScopeSchema,
+	topicSessionMode: TopicSessionModeSchema
+}).strict();
+const FeishuConfigSchemaBase = z.object({
+	enabled: z.boolean().optional(),
+	defaultAccount: z.string().optional(),
+	stickerSets: FeishuStickerSetsSchema.optional(),
+	appId: z.string().optional(),
+	appSecret: buildSecretInputSchema().optional(),
+	encryptKey: buildSecretInputSchema().optional(),
+	verificationToken: buildSecretInputSchema().optional(),
+	domain: FeishuDomainSchema.optional().default("feishu"),
+	connectionMode: FeishuConnectionModeSchema.optional().default("websocket"),
+	webhookPath: FeishuWebhookPathSchema.optional().default(DEFAULT_FEISHU_WEBHOOK_PATH),
+	...FeishuSharedConfigShape,
+	dmPolicy: DmPolicySchema.optional().default("pairing"),
+	reactionNotifications: ReactionNotificationModeSchema.optional().default("own"),
+	groupPolicy: FeishuGroupPolicySchema.optional().default("allowlist"),
+	requireMention: z.boolean().optional(),
+	groupSessionScope: GroupSessionScopeSchema,
+	topicSessionMode: TopicSessionModeSchema,
+	dynamicAgentCreation: DynamicAgentCreationSchema,
+	typingIndicator: z.boolean().optional().default(true),
+	resolveSenderNames: z.boolean().optional().default(true)
+}).strict();
+const FeishuConfigSchema = buildMultiAccountChannelSchema(FeishuConfigSchemaBase, {
+	accountSchema: FeishuAccountConfigSchema,
+	optionalAccount: true
+}).superRefine((value, ctx) => {
+	const defaultAccount = value.defaultAccount?.trim();
+	if (defaultAccount && value.accounts && Object.keys(value.accounts).length > 0) {
+		const normalizedDefaultAccount = normalizeAccountId(defaultAccount);
+		if (!Object.hasOwn(value.accounts, normalizedDefaultAccount)) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["defaultAccount"],
+			message: `channels.feishu.defaultAccount="${defaultAccount}" does not match a configured account key`
+		});
+	}
+	const defaultConnectionMode = value.connectionMode ?? "websocket";
+	const defaultVerificationTokenConfigured = hasConfiguredSecretInput$1(value.verificationToken);
+	const defaultEncryptKeyConfigured = hasConfiguredSecretInput$1(value.encryptKey);
+	if (defaultConnectionMode === "webhook") {
+		if (!defaultVerificationTokenConfigured) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["verificationToken"],
+			message: "channels.feishu.connectionMode=\"webhook\" requires channels.feishu.verificationToken"
+		});
+		if (!defaultEncryptKeyConfigured) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["encryptKey"],
+			message: "channels.feishu.connectionMode=\"webhook\" requires channels.feishu.encryptKey"
+		});
+	}
+	for (const [accountId, account] of Object.entries(value.accounts ?? {})) {
+		if (!account) continue;
+		if ((account.connectionMode ?? defaultConnectionMode) !== "webhook") continue;
+		const accountVerificationTokenConfigured = hasConfiguredSecretInput$1(account.verificationToken) || defaultVerificationTokenConfigured;
+		const accountEncryptKeyConfigured = hasConfiguredSecretInput$1(account.encryptKey) || defaultEncryptKeyConfigured;
+		if (!accountVerificationTokenConfigured) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: [
+				"accounts",
+				accountId,
+				"verificationToken"
+			],
+			message: `channels.feishu.accounts.${accountId}.connectionMode="webhook" requires a verificationToken (account-level or top-level)`
+		});
+		if (!accountEncryptKeyConfigured) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: [
+				"accounts",
+				accountId,
+				"encryptKey"
+			],
+			message: `channels.feishu.accounts.${accountId}.connectionMode="webhook" requires an encryptKey (account-level or top-level)`
+		});
+	}
+	if (value.dmPolicy === "open") {
+		if (!(value.allowFrom ?? []).some((entry) => String(entry).trim() === "*")) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["allowFrom"],
+			message: "channels.feishu.dmPolicy=\"open\" requires channels.feishu.allowFrom to include \"*\""
+		});
+	}
+});
+const FeishuChannelConfigSchema = buildChannelConfigSchema(FeishuConfigSchema, { jsonSchemaMode: "input" });
+//#endregion
+//#region extensions/feishu/src/doctor-contract.ts
+const streamingAliasMigration = defineChannelAliasMigration({
+	channelId: "feishu",
+	streaming: { defaultMode: "partial" },
+	accountStreamingReplacesRoot: true
+});
+const LEGACY_COALESCE_FIELDS = [
+	"enabled",
+	"minDelayMs",
+	"maxDelayMs"
+];
+const LEGACY_HEARTBEAT_FIELDS = ["visibility", "intervalMs"];
+const toolsBaseMigration = defineKeyMoveMigration({
+	from: ["tools", "base"],
+	to: ["tools", "bitable"],
+	match: (value) => typeof value === "boolean",
+	sourceOwn: false
+});
+function sanitizeLegacyHeartbeatFields(params) {
+	const heartbeat = asObjectRecord(params.entry.heartbeat);
+	if (!heartbeat || Object.keys(heartbeat).length > 0 && !LEGACY_HEARTBEAT_FIELDS.some((field) => Object.hasOwn(heartbeat, field))) return {
+		entry: params.entry,
+		changed: false
+	};
+	const next = { ...params.entry };
+	delete next.heartbeat;
+	params.changes.push(`Removed ${params.pathPrefix}.heartbeat (legacy Feishu fields were never read by runtime).`);
+	return {
+		entry: next,
+		changed: true
+	};
+}
+function sanitizeLegacyCoalesceFields(params) {
+	const streaming = asObjectRecord(params.entry.streaming);
+	const block = asObjectRecord(streaming?.block);
+	const coalesce = asObjectRecord(block?.coalesce);
+	if (!streaming || !block || !coalesce) return {
+		entry: params.entry,
+		changed: false
+	};
+	const removed = LEGACY_COALESCE_FIELDS.filter((field) => coalesce[field] !== void 0);
+	if (removed.length === 0) return {
+		entry: params.entry,
+		changed: false
+	};
+	const nextCoalesce = { ...coalesce };
+	for (const field of removed) delete nextCoalesce[field];
+	params.changes.push(`Removed ${params.pathPrefix}.streaming.block.coalesce.{${removed.join(",")}} (legacy Feishu-only fields; block delivery reads minChars/maxChars/idleMs).`);
+	return {
+		entry: {
+			...params.entry,
+			streaming: {
+				...streaming,
+				block: {
+					...block,
+					coalesce: nextCoalesce
+				}
+			}
+		},
+		changed: true
+	};
+}
+function hasLegacyWebhookPath(value) {
+	const path = asObjectRecord(value)?.webhookPath;
+	return typeof path === "string" && normalizeFeishuWebhookPath(path) !== path;
+}
+function normalizeLegacyWebhookPath(params) {
+	const path = params.entry.webhookPath;
+	if (typeof path !== "string") return {
+		entry: params.entry,
+		changed: false
+	};
+	const normalized = normalizeFeishuWebhookPath(path);
+	const canonical = normalized ?? "/feishu/events";
+	if (canonical === path) return {
+		entry: params.entry,
+		changed: false
+	};
+	params.changes.push(normalized === null ? `Reset invalid ${params.pathPrefix}.webhookPath to ${DEFAULT_FEISHU_WEBHOOK_PATH}.` : `Normalized ${params.pathPrefix}.webhookPath to its HTTP request path.`);
+	return {
+		entry: {
+			...params.entry,
+			webhookPath: canonical
+		},
+		changed: true
+	};
+}
+function normalizeFeishuLegacyConfigEntries(cfg, changes) {
+	return normalizeChannelConfigEntries({
+		cfg,
+		channelId: "feishu",
+		changes,
+		normalizeEntry: (params) => {
+			const tools = toolsBaseMigration.normalize(params);
+			const coalesce = sanitizeLegacyCoalesceFields({
+				...params,
+				entry: tools.entry
+			});
+			const heartbeat = sanitizeLegacyHeartbeatFields({
+				...params,
+				entry: coalesce.entry
+			});
+			const webhook = normalizeLegacyWebhookPath({
+				...params,
+				entry: heartbeat.entry
+			});
+			return {
+				entry: webhook.entry,
+				changed: tools.changed || coalesce.changed || heartbeat.changed || webhook.changed
+			};
+		}
+	}).config;
+}
+const feishuStrayEntryConfigMigration = defineStrayPluginEntryConfigMigration({
+	pluginId: "feishu",
+	channelId: "feishu",
+	validateMergedChannelConfig: (merged) => FeishuConfigSchema.safeParse(merged).success
+});
+const legacyConfigRules = [
+	...streamingAliasMigration.legacyConfigRules,
+	feishuStrayEntryConfigMigration.legacyConfigRule,
+	{
+		path: ["channels", "feishu"],
+		message: "channels.feishu[.accounts.<id>].webhookPath must be a canonical HTTP request path; run \"openclaw doctor --fix\".",
+		match: (value) => {
+			const entry = asObjectRecord(value);
+			return hasLegacyWebhookPath(entry) || hasLegacyAccountStreamingAliases(entry?.accounts, hasLegacyWebhookPath);
+		}
+	},
+	{
+		path: ["channels", "feishu"],
+		message: "channels.feishu[.accounts.<id>].tools.base is legacy; use tools.bitable. Run \"openclaw doctor --fix\".",
+		match: (value) => {
+			const entry = asObjectRecord(value);
+			return toolsBaseMigration.hasLegacy(entry) || hasLegacyAccountStreamingAliases(entry?.accounts, toolsBaseMigration.hasLegacy);
+		}
+	}
+];
+function normalizeCompatibilityConfig({ cfg }) {
+	const aliases = streamingAliasMigration.normalizeChannelConfig({ cfg });
+	const entries = normalizeFeishuLegacyConfigEntries(aliases.config, aliases.changes);
+	const stray = feishuStrayEntryConfigMigration.normalizeConfig({ cfg: entries });
+	return {
+		config: stray.config,
+		changes: [...aliases.changes, ...stray.changes]
+	};
+}
+//#endregion
+export { normalizeFeishuWebhookPath as a, DEFAULT_FEISHU_WEBHOOK_PATH as i, normalizeCompatibilityConfig as n, normalizeFeishuExternalKey as o, FeishuChannelConfigSchema as r, legacyConfigRules as t };