@openclaw/feishu 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{send-BcPh0I15.js → send-DzLGqjEt.js}

@@ -1,10 +1,10 @@
-import { d as isRecord$1, h as requestFeishuApi, s as resolveFeishuRuntimeAccount } from "./accounts-Cfzht2Hc.js";
+import { d as isRecord$1, h as requestFeishuApi, s as resolveFeishuRuntimeAccount } from "./accounts-Bs5uJ4h0.js";
 import { i as resolveReceiveIdType, r as normalizeFeishuTarget } from "./targets-BUjQ1TcA.js";
-import { i as toFeishuSendResult, r as resolveFeishuReceiptKind, t as assertFeishuMessageApiSuccess } from "./send-result-DSsIa4-p.js";
+import { i as toFeishuSendResult, o as resolveFeishuCardTemplate, r as resolveFeishuReceiptKind, t as assertFeishuMessageApiSuccess } from "./send-result-BMQw-YhV.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
 import { r as createFeishuClient } from "./client-BwgAJuvo.js";
 import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
-import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { isRecord, normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { convertMarkdownTables } from "openclaw/plugin-sdk/text-chunking";
 import fs from "node:fs";
 import path from "node:path";
@@ -73,7 +73,7 @@ const FEISHU_MEDIA_HTTP_TIMEOUT_MS = 12e4;
 const FEISHU_VOICE_FILE_NAME = "voice.ogg";
 const FEISHU_VOICE_SAMPLE_RATE_HZ = 48e3;
 const FEISHU_VOICE_BITRATE = "64k";
-const FEISHU_TRANSCODABLE_AUDIO_EXTS = new Set([
+const FEISHU_TRANSCODABLE_AUDIO_EXTS = /* @__PURE__ */ new Set([
 	".aac",
 	".aiff",
 	".alac",
@@ -501,12 +501,14 @@ async function prepareFeishuVoiceMedia(params) {
 		return params;
 	}
 }
-async function probeAudioDurationMs(buffer) {
+async function probeMediaDurationMs(params) {
 	try {
 		return await withTempWorkspace({
 			rootDir: resolvePreferredOpenClawTmpDir(),
-			prefix: "feishu-audio-probe-"
+			prefix: "feishu-media-probe-"
 		}, async (workspace) => {
+			const ext = normalizeLowercaseStringOrEmpty(path.extname(params.fileName));
+			const inferredExt = ext && ext.length <= 12 ? ext : mediaKindFromMime(params.contentType) === "video" ? ".mp4" : ".ogg";
 			const stdout = await runFfprobe([
 				"-v",
 				"error",
@@ -514,17 +516,21 @@ async function probeAudioDurationMs(buffer) {
 				"format=duration",
 				"-of",
 				"csv=p=0",
-				await workspace.write("input.ogg", buffer)
+				await workspace.write(`input${inferredExt}`, params.buffer)
 			], { timeoutMs: 5e3 });
 			const seconds = Number.parseFloat(stdout.trim());
 			if (!Number.isFinite(seconds) || seconds <= 0) return;
 			return Math.max(1, Math.round(seconds * 1e3));
 		});
 	} catch (err) {
-		console.warn("[feishu] failed to probe audio duration; voice bubble will omit it:", err);
+		console.warn("[feishu] failed to probe media duration; upload will omit it:", err);
 		return;
 	}
 }
+async function maybeProbeUploadDurationMs(params) {
+	if (params.msgType !== "audio" && params.msgType !== "media") return;
+	return await probeMediaDurationMs(params);
+}
 /**
 * Upload and send media (image or file) from URL, local path, or buffer.
 * When mediaUrl is a local path, mediaLocalRoots (from core outbound context)
@@ -586,7 +592,12 @@ async function sendMediaFeishu(params) {
 			...voiceIntentDegradedToFile ? { voiceIntentDegradedToFile: true } : {}
 		};
 	}
-	const durationMs = routing.msgType === "audio" ? await probeAudioDurationMs(buffer) : void 0;
+	const durationMs = await maybeProbeUploadDurationMs({
+		buffer,
+		fileName: name,
+		contentType,
+		msgType: routing.msgType
+	});
 	const { fileKey } = await uploadFileFeishu({
 		cfg,
 		file: buffer,
@@ -630,7 +641,7 @@ function isFeishuBroadcastMention(mention) {
 function extractMentionTargets(event, botOpenId) {
 	return (event.message.mentions ?? []).filter((m) => {
 		if (isFeishuBroadcastMention(m)) return false;
-		if (botOpenId && m.id.open_id === botOpenId) return false;
+		if (m.id.open_id === botOpenId) return false;
 		return Boolean(m.id.open_id);
 	}).map((m) => ({
 		openId: m.id.open_id,
@@ -647,11 +658,13 @@ function extractMentionTargets(event, botOpenId) {
 function isMentionForwardRequest(event, botOpenId) {
 	const mentions = event.message.mentions ?? [];
 	if (mentions.length === 0) return false;
+	const normalizedBotOpenId = botOpenId?.trim();
+	if (!normalizedBotOpenId) return false;
 	const isDirectMessage = !isFeishuGroupChatType(event.message.chat_type);
 	const userMentions = mentions.filter((m) => !isFeishuBroadcastMention(m));
-	const hasOtherMention = userMentions.some((m) => m.id.open_id !== botOpenId);
+	const hasOtherMention = userMentions.some((m) => m.id.open_id !== normalizedBotOpenId);
 	if (isDirectMessage) return hasOtherMention;
-	return userMentions.some((m) => m.id.open_id === botOpenId) && hasOtherMention;
+	return userMentions.some((m) => m.id.open_id === normalizedBotOpenId) && hasOtherMention;
 }
 /**
 * Format @mention for card message (lark_md)
@@ -723,7 +736,7 @@ function renderCodeBlockElement(element) {
 	const code = (toStringOrEmpty(element.text) || toStringOrEmpty(element.content)).replace(/\r\n/g, "\n");
 	return `\`\`\`${language}\n${code}${code.endsWith("\n") ? "" : "\n"}\`\`\``;
 }
-function renderElement(element, imageKeys, mediaKeys, mentionedOpenIds) {
+function renderElement(element, imageKeys, mediaKeys, mentionedOpenIds, renderMediaPlaceholders) {
 	if (!isRecord$1(element)) return escapeMarkdownText(toStringOrEmpty(element));
 	switch (normalizeLowercaseStringOrEmpty(toStringOrEmpty(element.tag))) {
 		case "text": return renderTextElement(element);
@@ -737,7 +750,7 @@ function renderElement(element, imageKeys, mediaKeys, mentionedOpenIds) {
 		case "img": {
 			const imageKey = normalizeFeishuExternalKey(toStringOrEmpty(element.image_key));
 			if (imageKey) imageKeys.push(imageKey);
-			return "![image]";
+			return renderMediaPlaceholders ? "![image]" : "";
 		}
 		case "media": {
 			const fileKey = normalizeFeishuExternalKey(toStringOrEmpty(element.file_key));
@@ -748,7 +761,7 @@ function renderElement(element, imageKeys, mediaKeys, mentionedOpenIds) {
 					fileName
 				});
 			}
-			return "[media]";
+			return renderMediaPlaceholders ? "[media]" : "";
 		}
 		case "emotion": return renderEmotionElement(element);
 		case "md":
@@ -789,7 +802,7 @@ function resolvePostPayload(parsed) {
 	if (wrappedPost) return wrappedPost;
 	return resolveLocalePayload(parsed);
 }
-function parsePostContent(content) {
+function parsePostContent(content, options = {}) {
 	try {
 		const payload = resolvePostPayload(JSON.parse(content));
 		if (!payload) return {
@@ -805,11 +818,11 @@ function parsePostContent(content) {
 		for (const paragraph of payload.content) {
 			if (!Array.isArray(paragraph)) continue;
 			let renderedParagraph = "";
-			for (const element of paragraph) renderedParagraph += renderElement(element, imageKeys, mediaKeys, mentionedOpenIds);
+			for (const element of paragraph) renderedParagraph += renderElement(element, imageKeys, mediaKeys, mentionedOpenIds, options.renderMediaPlaceholders !== false);
 			paragraphs.push(renderedParagraph);
 		}
 		return {
-			textContent: [escapeMarkdownText(payload.title.trim()), paragraphs.join("\n").trim()].filter(Boolean).join("\n\n").trim() || FALLBACK_POST_TEXT,
+			textContent: [escapeMarkdownText(payload.title.trim()), paragraphs.join("\n").trim()].filter(Boolean).join("\n\n").trim() || (options.emptyTextFallback ?? FALLBACK_POST_TEXT),
 			imageKeys,
 			mediaKeys,
 			mentionedOpenIds
@@ -825,24 +838,9 @@ function parsePostContent(content) {
 }
 //#endregion
 //#region extensions/feishu/src/send.ts
-const WITHDRAWN_REPLY_ERROR_CODES = new Set([230011, 231003]);
+const WITHDRAWN_REPLY_ERROR_CODES = /* @__PURE__ */ new Set([230011, 231003]);
 const INTERACTIVE_CARD_FALLBACK_TEXT = "[Interactive Card]";
 const POST_FALLBACK_TEXT = "[Rich text message]";
-const FEISHU_CARD_TEMPLATES = new Set([
-	"blue",
-	"green",
-	"red",
-	"orange",
-	"purple",
-	"indigo",
-	"wathet",
-	"turquoise",
-	"yellow",
-	"grey",
-	"carmine",
-	"violet",
-	"lime"
-]);
 function shouldFallbackFromReplyTarget(response) {
 	if (response.code !== void 0 && WITHDRAWN_REPLY_ERROR_CODES.has(response.code)) return true;
 	const msg = normalizeLowercaseStringOrEmpty(response.msg);
@@ -1191,11 +1189,6 @@ function buildMarkdownCard(text) {
 		}] }
 	};
 }
-function resolveFeishuCardTemplate(template) {
-	const normalized = normalizeOptionalLowercaseString(template);
-	if (!normalized || !FEISHU_CARD_TEMPLATES.has(normalized)) return;
-	return normalized;
-}
 /**
 * Build a Feishu interactive card with optional header and note footer.
 * When header/note are omitted, behaves identically to buildMarkdownCard.
@@ -1265,4 +1258,4 @@ async function sendMarkdownCardFeishu(params) {
 	});
 }
 //#endregion
-export { normalizeFeishuExternalKey as _, sendCardFeishu as a, sendStructuredCardFeishu as c, isFeishuBroadcastMention as d, isMentionForwardRequest as f, shouldSuppressFeishuTextForVoiceMedia as g, sendMediaFeishu as h, resolveFeishuCardTemplate as i, parsePostContent as l, saveMessageResourceFeishu as m, getMessageFeishu as n, sendMarkdownCardFeishu as o, isFeishuGroupChatType as p, listFeishuThreadMessages as r, sendMessageFeishu as s, editMessageFeishu as t, extractMentionTargets as u, resolveFeishuIdentityEmoji as v, resolveFeishuIdentityHeaderTitle as y };
+export { resolveFeishuIdentityEmoji as _, sendMarkdownCardFeishu as a, parsePostContent as c, isMentionForwardRequest as d, isFeishuGroupChatType as f, normalizeFeishuExternalKey as g, shouldSuppressFeishuTextForVoiceMedia as h, sendCardFeishu as i, extractMentionTargets as l, sendMediaFeishu as m, getMessageFeishu as n, sendMessageFeishu as o, saveMessageResourceFeishu as p, listFeishuThreadMessages as r, sendStructuredCardFeishu as s, editMessageFeishu as t, isFeishuBroadcastMention as u, resolveFeishuIdentityHeaderTitle as v };

package/dist/send-result-BMQw-YhV.js

@@ -0,0 +1,287 @@
+import { d as isRecord$1 } from "./accounts-Bs5uJ4h0.js";
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { isRecord, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/feishu/src/card-interaction.ts
+const FEISHU_CARD_INTERACTION_VERSION = "ocf1";
+function isInteractionKind(value) {
+	return value === "button" || value === "quick" || value === "meta";
+}
+function isMetadataValue(value) {
+	return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function createFeishuCardInteractionEnvelope(envelope) {
+	return {
+		oc: FEISHU_CARD_INTERACTION_VERSION,
+		...envelope
+	};
+}
+function buildFeishuCardActionTextFallback(event) {
+	const actionValue = event.action.value;
+	if (isRecord$1(actionValue)) {
+		if (typeof actionValue.text === "string") return actionValue.text;
+		if (typeof actionValue.command === "string") return actionValue.command;
+		return JSON.stringify(actionValue);
+	}
+	return String(actionValue);
+}
+function decodeFeishuCardAction(params) {
+	const { event, now = Date.now() } = params;
+	const actionValue = event.action.value;
+	if (!isRecord$1(actionValue) || actionValue.oc !== "ocf1") return {
+		kind: "legacy",
+		text: buildFeishuCardActionTextFallback(event)
+	};
+	if (!isInteractionKind(actionValue.k) || typeof actionValue.a !== "string" || !actionValue.a) return {
+		kind: "invalid",
+		reason: "malformed"
+	};
+	if (actionValue.q !== void 0 && typeof actionValue.q !== "string") return {
+		kind: "invalid",
+		reason: "malformed"
+	};
+	if (actionValue.m !== void 0) {
+		if (!isRecord$1(actionValue.m)) return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		for (const value of Object.values(actionValue.m)) if (!isMetadataValue(value)) return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+	}
+	if (actionValue.c !== void 0) {
+		if (!isRecord$1(actionValue.c)) return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.u !== void 0 && typeof actionValue.c.u !== "string") return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.h !== void 0 && typeof actionValue.c.h !== "string") return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.s !== void 0 && typeof actionValue.c.s !== "string") return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.e !== void 0 && !Number.isFinite(actionValue.c.e)) return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (actionValue.c.t !== void 0 && actionValue.c.t !== "p2p" && actionValue.c.t !== "group") return {
+			kind: "invalid",
+			reason: "malformed"
+		};
+		if (typeof actionValue.c.e === "number" && actionValue.c.e < now) return {
+			kind: "invalid",
+			reason: "stale"
+		};
+		const expectedUser = actionValue.c.u?.trim();
+		if (expectedUser && expectedUser !== (event.operator.open_id ?? "").trim()) return {
+			kind: "invalid",
+			reason: "wrong_user"
+		};
+		const expectedChat = actionValue.c.h?.trim();
+		if (expectedChat && expectedChat !== (event.context.chat_id ?? "").trim()) return {
+			kind: "invalid",
+			reason: "wrong_conversation"
+		};
+	}
+	return {
+		kind: "structured",
+		envelope: actionValue
+	};
+}
+//#endregion
+//#region extensions/feishu/src/native-card.ts
+const FEISHU_CARD_TEMPLATES = /* @__PURE__ */ new Set([
+	"blue",
+	"green",
+	"red",
+	"orange",
+	"purple",
+	"indigo",
+	"wathet",
+	"turquoise",
+	"yellow",
+	"grey",
+	"carmine",
+	"violet",
+	"lime"
+]);
+function resolveFeishuCardTemplate(template) {
+	const normalized = normalizeOptionalLowercaseString(template);
+	if (!normalized || !FEISHU_CARD_TEMPLATES.has(normalized)) return;
+	return normalized;
+}
+function escapeFeishuCardMarkdownText(text) {
+	return text.replace(/[&<>]/g, (char) => {
+		switch (char) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			default: return char;
+		}
+	});
+}
+function escapeFeishuCardPlainText(text) {
+	return escapeFeishuCardMarkdownText(text).replace(/([\\`*_{}[\]()#+\-!|>~])/g, "\\$1");
+}
+function resolveSafeFeishuButtonUrl(url) {
+	const trimmed = typeof url === "string" ? url.trim() : "";
+	if (!trimmed) return;
+	try {
+		const parsed = new URL(trimmed);
+		return parsed.protocol === "https:" || parsed.protocol === "http:" ? trimmed : void 0;
+	} catch {
+		return;
+	}
+}
+function sanitizeNativeFeishuButtonBehavior(behavior) {
+	if (!isRecord(behavior)) return;
+	if (behavior.type === "open_url") {
+		const safeUrl = resolveSafeFeishuButtonUrl(behavior.default_url) ?? resolveSafeFeishuButtonUrl(behavior.url);
+		return safeUrl ? {
+			type: "open_url",
+			default_url: safeUrl
+		} : void 0;
+	}
+	if (behavior.type === "callback" && isRecord(behavior.value) && behavior.value.oc === "ocf1") return {
+		type: "callback",
+		value: behavior.value
+	};
+}
+function sanitizeNativeFeishuCardButton(button) {
+	if (!isRecord(button)) return;
+	const text = isRecord(button.text) && typeof button.text.content === "string" ? button.text.content : void 0;
+	if (!text?.trim()) return;
+	const style = button.type === "danger" ? "danger" : button.type === "primary" || button.type === "success" ? "primary" : void 0;
+	const behaviors = Array.isArray(button.behaviors) ? button.behaviors.map((behavior) => sanitizeNativeFeishuButtonBehavior(behavior)).filter((behavior) => Boolean(behavior)) : [];
+	const rootSafeUrl = resolveSafeFeishuButtonUrl(button.url);
+	if (rootSafeUrl) behaviors.push({
+		type: "open_url",
+		default_url: rootSafeUrl
+	});
+	if (isRecord(button.value) && button.value.oc === "ocf1") behaviors.push({
+		type: "callback",
+		value: button.value
+	});
+	if (behaviors.length === 0) return;
+	return {
+		tag: "button",
+		text: {
+			tag: "plain_text",
+			content: text
+		},
+		type: style === "danger" ? "danger" : style === "primary" ? "primary" : "default",
+		behaviors
+	};
+}
+function sanitizeNativeFeishuCardElements(element) {
+	if (!isRecord(element) || typeof element.tag !== "string") return [];
+	if (element.tag === "hr") return [{ tag: "hr" }];
+	if (element.tag === "markdown" && typeof element.content === "string") return [{
+		tag: "markdown",
+		content: escapeFeishuCardMarkdownText(element.content)
+	}];
+	if (element.tag === "div" && isRecord(element.text)) {
+		const text = element.text;
+		if (text.tag === "lark_md" && typeof text.content === "string") return [{
+			tag: "markdown",
+			content: escapeFeishuCardMarkdownText(text.content)
+		}];
+		if (text.tag === "plain_text" && typeof text.content === "string") return [{
+			tag: "markdown",
+			content: escapeFeishuCardPlainText(text.content)
+		}];
+		return [];
+	}
+	if (element.tag === "button") {
+		const button = sanitizeNativeFeishuCardButton(element);
+		return button ? [button] : [];
+	}
+	if (element.tag === "action" && Array.isArray(element.actions)) return element.actions.map((action) => sanitizeNativeFeishuCardButton(action)).filter((action) => Boolean(action));
+	return [];
+}
+function sanitizeNativeFeishuCard(card) {
+	const normalizedCard = card.type === "interactive" && isRecord(card.card) ? card.card : card;
+	const body = isRecord(normalizedCard.body) ? normalizedCard.body : void 0;
+	const elements = (Array.isArray(body?.elements) ? body.elements : Array.isArray(normalizedCard.elements) ? normalizedCard.elements : []).flatMap((element) => sanitizeNativeFeishuCardElements(element)).filter((element) => Boolean(element));
+	if (elements.length === 0) return;
+	const header = isRecord(normalizedCard.header) ? normalizedCard.header : void 0;
+	const title = isRecord(header?.title) && typeof header.title.content === "string" ? header.title.content : void 0;
+	return {
+		schema: "2.0",
+		config: { width_mode: "fill" },
+		...title?.trim() ? { header: {
+			title: {
+				tag: "plain_text",
+				content: title
+			},
+			template: resolveFeishuCardTemplate(typeof header?.template === "string" ? header.template : void 0) ?? "blue"
+		} } : {},
+		body: { elements }
+	};
+}
+function readNativeFeishuCardJson(text, options) {
+	let trimmed = text?.trim();
+	const responsePrefix = options?.responsePrefix;
+	if (trimmed && responsePrefix && trimmed.startsWith(responsePrefix)) {
+		const suffix = trimmed.slice(responsePrefix.length);
+		if (/^\s+\{/.test(suffix)) trimmed = suffix.trimStart();
+	}
+	if (!trimmed?.startsWith("{") || !trimmed.endsWith("}")) return;
+	try {
+		const parsed = JSON.parse(trimmed);
+		return isRecord(parsed) ? sanitizeNativeFeishuCard(parsed) : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region extensions/feishu/src/send-result.ts
+function resolveFeishuReceiptKind(msgType) {
+	switch (msgType) {
+		case "audio": return "voice";
+		case "image":
+		case "media":
+		case "file": return "media";
+		case "interactive": return "card";
+		case "post":
+		case "text": return "text";
+		default: return "unknown";
+	}
+}
+function createFeishuSendReceipt(params) {
+	const messageId = params.messageId?.trim();
+	const chatId = params.chatId.trim();
+	return createMessageReceiptFromOutboundResults({
+		results: messageId ? [{
+			channel: "feishu",
+			messageId,
+			chatId,
+			conversationId: chatId
+		}] : [],
+		...chatId ? { threadId: chatId } : {},
+		kind: params.kind ?? "unknown"
+	});
+}
+function assertFeishuMessageApiSuccess(response, errorPrefix) {
+	if (response.code !== 0) throw new Error(`${errorPrefix}: ${response.msg || `code ${response.code}`}`);
+}
+function toFeishuSendResult(response, chatId, kind) {
+	const messageId = response.data?.message_id ?? "unknown";
+	return {
+		messageId,
+		chatId,
+		receipt: createFeishuSendReceipt({
+			messageId,
+			chatId,
+			kind
+		})
+	};
+}
+//#endregion
+export { readNativeFeishuCardJson as a, FEISHU_CARD_INTERACTION_VERSION as c, decodeFeishuCardAction as d, toFeishuSendResult as i, buildFeishuCardActionTextFallback as l, createFeishuSendReceipt as n, resolveFeishuCardTemplate as o, resolveFeishuReceiptKind as r, sanitizeNativeFeishuCard as s, assertFeishuMessageApiSuccess as t, createFeishuCardInteractionEnvelope as u };

package/dist/{session-conversation-CZSMgac-.js → session-conversation-BYuoVJwl.js}

@@ -1,4 +1,4 @@
-import { r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-DuL575sn.js";
+import { r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-CdLdoot3.js";
 //#region extensions/feishu/src/session-conversation.ts
 function resolveFeishuParentConversationCandidates(rawId) {
 	const parsed = parseFeishuConversationId({ conversationId: rawId });

package/dist/session-key-api.js

@@ -1,2 +1,2 @@
-import { t as resolveFeishuSessionConversation } from "./session-conversation-CZSMgac-.js";
+import { t as resolveFeishuSessionConversation } from "./session-conversation-BYuoVJwl.js";
 export { resolveFeishuSessionConversation as resolveSessionConversation };

package/dist/setup-api.js

@@ -1,2 +1,2 @@
-import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-C1Uun9zo.js";
+import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-DwCydAeD.js";
 export { feishuPlugin, feishuSetupAdapter, feishuSetupWizard };

package/dist/{subagent-hooks-1pqt5tAA.js → subagent-hooks-B2iWPYJ1.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { r as normalizeFeishuTarget } from "./targets-BUjQ1TcA.js";
-import { r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-DuL575sn.js";
+import { r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-CdLdoot3.js";
 import { n as getFeishuThreadBindingManager } from "./thread-bindings-V0bwk0A1.js";
 import { normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/feishu/src/subagent-hooks.ts

package/dist/subagent-hooks-api.js

@@ -1,9 +1,6 @@
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/feishu/subagent-hooks-api.ts
-let feishuSubagentHooksPromise = null;
-function loadFeishuSubagentHooksModule() {
-	feishuSubagentHooksPromise ??= import("./subagent-hooks-1pqt5tAA.js").then((n) => n.i);
-	return feishuSubagentHooksPromise;
-}
+const loadFeishuSubagentHooksModule = createLazyRuntimeModule(() => import("./subagent-hooks-B2iWPYJ1.js").then((n) => n.i));
 function registerFeishuSubagentHooks(api) {
 	api.on("subagent_delivery_target", async (event) => {
 		const { handleFeishuSubagentDeliveryTarget } = await loadFeishuSubagentHooksModule();

package/node_modules/@larksuiteoapi/node-sdk/README.md

@@ -681,6 +681,38 @@ try {
 }
 ```
 
+#### Custom scopes/events/callbacks (addons) and updating an existing app
+
+When creating an app, use `addons` to **incrementally** request scopes, event subscriptions and callbacks on top of the platform base template. They are pre-filled into the confirm page shown after the user scans the QR code, and take effect once the user confirms:
+
+```typescript
+// Create: incrementally request scopes/events/callbacks, and only allow
+// creating a new app (selecting an existing app is disabled)
+const result = await lark.registerApp({
+    addons: {
+        scopes: { tenant: ['im:message:send_as_bot'], user: ['calendar:calendar:read'] },
+        events: { items: { tenant: ['im.message.receive_v1'] } },
+        callbacks: { items: ['card.action.trigger'] },
+    },
+    createOnly: true,
+    onQRCodeReady(info) { /* ... */ },
+});
+
+// Update: pass the appId of an existing app to let the user re-scan and
+// confirm, incrementally granting scopes to that app
+await lark.registerApp({
+    appId: 'cli_xxx',
+    addons: { scopes: { tenant: ['drive:drive.metadata:readonly'] } },
+    onQRCodeReady(info) { /* ... */ },
+});
+```
+
+Notes:
+
+- `addons` is **additive only**: items are merged on top of the base template; base permissions can never be removed.
+- Only the 5 public config types (tenant/user scopes, tenant/user events, callbacks) are supported. Sensitive config (event subscription type and request URLs, `security.*`, encrypt keys, etc.) cannot travel via `addons` — use the [update application config OpenAPI](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/application-v7/application-v7/application-config/patch) instead.
+- The SDK only validates the shape, not the item names; names unknown to the platform catalog are silently ignored by the confirm page.
+
 #### `registerApp` parameters
 
 | Parameter | Description | Type | Required | Default |
@@ -695,6 +727,14 @@ try {
 | appPreset.avatar | App avatar URL(s). 1-6 URLs supported; the first one is selected by default. Allowed formats: png / jpg / jpeg / webp / gif (gif is sampled to a single frame, not animated) | string \| string[] | No | - |
 | appPreset.name | App name. Supports the `{user}` placeholder (replaced with the scanning user's name) | string | No | - |
 | appPreset.desc | App description. Supports the `{user}` placeholder | string | No | - |
+| addons | Incremental scopes/events/callbacks pre-filled into the confirm page, effective after user confirmation. See "Custom scopes/events/callbacks" above | AppAddons | No | - |
+| addons.scopes.tenant | App-identity (tenant) scopes, e.g. `im:message:send_as_bot` | string[] | No | - |
+| addons.scopes.user | User-identity scopes, e.g. `calendar:calendar:read` | string[] | No | - |
+| addons.events.items.tenant | App-identity events, e.g. `im.message.receive_v1` | string[] | No | - |
+| addons.events.items.user | User-identity events, e.g. `calendar.calendar.event.changed_v4` | string[] | No | - |
+| addons.callbacks.items | Callbacks, e.g. `card.action.trigger` | string[] | No | - |
+| createOnly | When `true`, the landing page only allows creating a new app — the "select existing app" entry is hidden, preventing accidental overwrite of an existing app's config. Takes precedence over `appId` when both are set | boolean | No | - |
+| appId | App ID (`cli_` prefix) of an existing app. When set, the flow updates that app's config: the confirm page shows the diff brought by `addons` and the user explicitly re-authorizes. Ignored when `createOnly` is `true` — the page still runs the create-new-app flow | string | No | - |
 
 #### Return value
 

package/node_modules/@larksuiteoapi/node-sdk/README.zh.md

@@ -743,6 +743,36 @@ try {
 }
 ```
 
+#### 自定义权限/事件/回调（addons）与更新已有应用
+
+创建应用时，可通过 `addons` 在平台基础模板上**增量**申请权限、事件订阅和回调，这些配置会预填到用户扫码后的确认页中，用户确认后生效：
+
+```typescript
+// 创建：增量申请权限/事件/回调，且只允许创建新应用（不可选择已有应用）
+const result = await lark.registerApp({
+    addons: {
+        scopes: { tenant: ['im:message:send_as_bot'], user: ['calendar:calendar:read'] },
+        events: { items: { tenant: ['im.message.receive_v1'] } },
+        callbacks: { items: ['card.action.trigger'] },
+    },
+    createOnly: true,
+    onQRCodeReady(info) { /* ... */ },
+});
+
+// 更新：传入已有应用的 appId，让用户重新扫码确认，为该应用增量开通权限
+await lark.registerApp({
+    appId: 'cli_xxx',
+    addons: { scopes: { tenant: ['drive:drive.metadata:readonly'] } },
+    onQRCodeReady(info) { /* ... */ },
+});
+```
+
+注意：
+
+- `addons` 仅支持在基础模板上**增量叠加**，不支持删减基础权限。
+- 仅支持 5 类公开配置（应用/用户身份权限、应用/用户身份事件、回调）。敏感配置（事件订阅方式与回调地址、`security.*`、加密 key 等）不能通过 `addons` 传入，需调用[更新应用开发配置 OpenAPI](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/application-v7/application-v7/application-config/patch)。
+- SDK 只校验数据形状，不校验权限点/事件/回调名称是否存在；平台目录中不存在的名称会被确认页忽略。
+
 #### `registerApp`参数
 
 | 参数             | 描述                                                                                       | 类型          | 必须 | 默认                       |
@@ -757,6 +787,14 @@ try {
 | appPreset.avatar | 应用头像 URL，支持 1-6 个；传多个时默认选中第一个。支持 png / jpg / jpeg / webp / gif（gif 自动取一帧，不保留动图）           | string \| string[] | 否  | -                |
 | appPreset.name | 应用名称，支持 `{user}` 占位符（替换为扫码用户名称）                                                              | string      | 否  | -                        |
 | appPreset.desc | 应用描述，支持 `{user}` 占位符                                                                          | string      | 否  | -                        |
+| addons         | 增量权限/事件/回调配置，预填到扫码后的确认页，用户确认后生效。详见上方「自定义权限/事件/回调」                                              | AppAddons   | 否  | -                        |
+| addons.scopes.tenant | 应用身份权限列表，如 `im:message:send_as_bot`                                                          | string[]    | 否  | -                        |
+| addons.scopes.user | 用户身份权限列表，如 `calendar:calendar:read`                                                            | string[]    | 否  | -                        |
+| addons.events.items.tenant | 应用身份事件列表，如 `im.message.receive_v1`                                                      | string[]    | 否  | -                        |
+| addons.events.items.user | 用户身份事件列表，如 `calendar.calendar.event.changed_v4`                                           | string[]    | 否  | -                        |
+| addons.callbacks.items | 回调列表，如 `card.action.trigger`                                                                  | string[]    | 否  | -                        |
+| createOnly     | 为 `true` 时落地页仅允许创建新应用，隐藏「选择已有应用」入口，避免误选已有应用导致其配置被覆盖。与 `appId` 同时传入时优先级更高                          | boolean     | 否  | -                        |
+| appId          | 已有应用的 App ID（`cli_` 开头）。传入后流程变为更新该应用的配置：确认页展示 `addons` 带来的权限 diff，用户确认后生效。`createOnly` 为 `true` 时被忽略，仍走创建新应用流程 | string      | 否  | -                        |
 
 #### 返回值