@openclaw/feishu 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/monitor.startup-CSUPT_U1.js

@@ -0,0 +1,143 @@
+import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
+import { r as registerFeishuAiAgent, t as probeFeishu } from "./probe-Za1kgUvx.js";
+import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
+//#region extensions/feishu/src/bot-identity-cache.ts
+const FEISHU_BOT_IDENTITY_CACHE_NAMESPACE = "feishu.bot-identity-cache";
+const FEISHU_BOT_IDENTITY_CACHE_MAX_ENTRIES = 128;
+function openFeishuBotIdentityCache() {
+	return getFeishuRuntime().state.openKeyedStore({
+		namespace: FEISHU_BOT_IDENTITY_CACHE_NAMESPACE,
+		maxEntries: FEISHU_BOT_IDENTITY_CACHE_MAX_ENTRIES
+	});
+}
+function parseCachedFeishuBotIdentity(value) {
+	if (!value || typeof value !== "object") return null;
+	const state = value;
+	const appId = normalizeOptionalString(state.appId);
+	const botOpenId = normalizeOptionalString(state.botOpenId);
+	const botName = normalizeOptionalString(state.botName);
+	const fetchedAt = normalizeOptionalString(state.fetchedAt);
+	if (!appId || !botOpenId || !fetchedAt || Number.isNaN(Date.parse(fetchedAt))) return null;
+	return {
+		appId,
+		botOpenId,
+		botName,
+		fetchedAt
+	};
+}
+async function readCachedFeishuBotIdentity(params) {
+	const appId = normalizeOptionalString(params.appId);
+	if (!appId) return null;
+	const cached = parseCachedFeishuBotIdentity(await openFeishuBotIdentityCache().lookup(normalizeAccountId(params.accountId)));
+	if (!cached || cached.appId !== appId) return null;
+	return {
+		botOpenId: cached.botOpenId,
+		botName: cached.botName,
+		fetchedAt: cached.fetchedAt
+	};
+}
+async function writeCachedFeishuBotIdentity(params) {
+	const appId = normalizeOptionalString(params.appId);
+	const botOpenId = normalizeOptionalString(params.botOpenId);
+	if (!appId || !botOpenId) return;
+	const botName = normalizeOptionalString(params.botName);
+	await openFeishuBotIdentityCache().register(normalizeAccountId(params.accountId), {
+		appId,
+		botOpenId,
+		botName,
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+//#endregion
+//#region extensions/feishu/src/monitor-startup-timeout.ts
+const FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS = 3e4;
+const FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV = "OPENCLAW_FEISHU_STARTUP_PROBE_TIMEOUT_MS";
+function resolveStartupProbeTimeoutMs(env = process.env) {
+	const raw = env[FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV];
+	if (raw) {
+		const parsed = parseStrictPositiveInteger(raw);
+		if (parsed !== void 0) return parsed;
+		console.warn(`[feishu] ${FEISHU_STARTUP_BOT_INFO_TIMEOUT_ENV}="${raw}" is invalid; using default ${FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS}ms`);
+	}
+	return FEISHU_STARTUP_BOT_INFO_TIMEOUT_DEFAULT_MS;
+}
+//#endregion
+//#region extensions/feishu/src/monitor.startup.ts
+const FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS = resolveStartupProbeTimeoutMs();
+function isTimeoutErrorMessage(message) {
+	const lower = normalizeLowercaseStringOrEmpty(message);
+	return lower.includes("timeout") || lower.includes("timed out");
+}
+function isAbortErrorMessage(message) {
+	return normalizeLowercaseStringOrEmpty(message).includes("aborted");
+}
+async function writeProviderBotIdentityCache(params) {
+	try {
+		await writeCachedFeishuBotIdentity({
+			accountId: params.account.accountId,
+			appId: params.account.appId,
+			botOpenId: params.botOpenId,
+			botName: params.botName
+		});
+	} catch {
+		params.runtime?.log?.(`feishu[${params.account.accountId}]: bot identity cache write failed; continuing startup`);
+	}
+}
+async function readProviderBotIdentityCache(params) {
+	try {
+		const cached = await readCachedFeishuBotIdentity({
+			accountId: params.account.accountId,
+			appId: params.account.appId
+		});
+		if (!cached) return {};
+		params.runtime?.log?.(`feishu[${params.account.accountId}]: using cached provider-verified bot identity while the fresh probe is unavailable`);
+		return {
+			botOpenId: cached.botOpenId,
+			botName: cached.botName,
+			source: "cache"
+		};
+	} catch {
+		params.runtime?.log?.(`feishu[${params.account.accountId}]: bot identity cache read failed; continuing without cached identity`);
+		return {};
+	}
+}
+async function fetchBotIdentityForMonitor(account, options = {}) {
+	if (options.abortSignal?.aborted) return {};
+	const timeoutMs = options.timeoutMs ?? FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS;
+	const result = await probeFeishu(account, {
+		timeoutMs,
+		abortSignal: options.abortSignal
+	});
+	const resultAppId = normalizeOptionalString(result.appId);
+	if (result.ok && resultAppId === account.appId) {
+		registerFeishuAiAgent(account, { abortSignal: options.abortSignal }).then((registration) => {
+			if (!registration.ok && registration.reason !== "aborted") (options.runtime?.log ?? console.log)(`feishu[${account.accountId}]: AI-agent registration unavailable (${registration.reason}); continuing with standard bot identity`);
+		}).catch(() => {
+			(options.runtime?.log ?? console.log)(`feishu[${account.accountId}]: AI-agent registration failed unexpectedly; continuing with standard bot identity`);
+		});
+		await writeProviderBotIdentityCache({
+			account,
+			botOpenId: result.botOpenId,
+			botName: result.botName,
+			runtime: options.runtime
+		});
+		return {
+			botOpenId: normalizeOptionalString(result.botOpenId),
+			botName: normalizeOptionalString(result.botName),
+			source: "provider"
+		};
+	}
+	if (result.ok) (options.runtime?.log ?? console.log)(`feishu[${account.accountId}]: bot info probe returned identity for a different app; ignoring stale result`);
+	const probeError = result.error ?? void 0;
+	if (options.abortSignal?.aborted || isAbortErrorMessage(probeError)) return {};
+	if (isTimeoutErrorMessage(probeError)) (options.runtime?.error ?? console.error)(`feishu[${account.accountId}]: bot info probe timed out after ${timeoutMs}ms; continuing startup`);
+	if (options.allowCachedFallback === false) return {};
+	return readProviderBotIdentityCache({
+		account,
+		runtime: options.runtime
+	});
+}
+//#endregion
+export { fetchBotIdentityForMonitor as t };

package/dist/{probe-BgboTHIn.js → probe-Za1kgUvx.js}

@@ -1,7 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { r as createFeishuClient } from "./client-87BmeMpj.js";
+import { r as createFeishuClient } from "./client-Dee7cKsS.js";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { createHash } from "node:crypto";
 //#region extensions/feishu/src/async.ts
 const RACE_TIMEOUT = Symbol("race-timeout");
 const RACE_ABORT = Symbol("race-abort");
@@ -63,7 +64,10 @@ function waitForAbortableDelay(delayMs, abortSignal) {
 }
 //#endregion
 //#region extensions/feishu/src/probe.ts
-var probe_exports = /* @__PURE__ */ __exportAll({ probeFeishu: () => probeFeishu });
+var probe_exports = /* @__PURE__ */ __exportAll({
+	probeFeishu: () => probeFeishu,
+	registerFeishuAiAgent: () => registerFeishuAiAgent
+});
 /** Cache probe results to reduce repeated health-check calls.
 * Gateway health checks call probeFeishu() every minute; without caching this
 * burns ~43,200 calls/month, easily exceeding Feishu's free-tier quota.
@@ -74,6 +78,15 @@ const PROBE_SUCCESS_TTL_MS = 600 * 1e3;
 const PROBE_ERROR_TTL_MS = 60 * 1e3;
 const MAX_PROBE_CACHE_SIZE = 64;
 const FEISHU_PROBE_REQUEST_TIMEOUT_MS = 1e4;
+function buildProbeCacheKey(creds) {
+	const identity = [
+		creds.accountId ?? null,
+		creds.appId,
+		creds.appSecret,
+		creds.domain ?? null
+	];
+	return createHash("sha256").update(JSON.stringify(identity)).digest("hex");
+}
 function setCachedProbeResult(cacheKey, result, ttlMs) {
 	const expiresAt = resolveExpiresAtMsFromDurationMs(ttlMs);
 	if (expiresAt === void 0) {
@@ -101,7 +114,7 @@ async function probeFeishu(creds, options = {}) {
 		error: "probe aborted"
 	};
 	const timeoutMs = options.timeoutMs ?? FEISHU_PROBE_REQUEST_TIMEOUT_MS;
-	const cacheKey = creds.accountId ?? `${creds.appId}:${creds.appSecret.slice(0, 8)}`;
+	const cacheKey = buildProbeCacheKey(creds);
 	const cached = probeCache.get(cacheKey);
 	if (cached) {
 		const now = asDateTimestampMs(Date.now());
@@ -111,9 +124,8 @@ async function probeFeishu(creds, options = {}) {
 	}
 	try {
 		const responseResult = await raceWithTimeoutAndAbort(createFeishuClient(creds).request({
-			method: "POST",
-			url: "/open-apis/bot/v1/openclaw_bot/ping",
-			data: { needBotInfo: true },
+			method: "GET",
+			url: "/open-apis/bot/v3/info",
 			timeout: timeoutMs
 		}), {
 			timeoutMs,
@@ -140,12 +152,17 @@ async function probeFeishu(creds, options = {}) {
 			appId: creds.appId,
 			error: `API error: ${response.msg || `code ${response.code}`}`
 		}, PROBE_ERROR_TTL_MS);
-		const botInfo = response.data?.pingBotInfo;
+		const botInfo = response.bot ?? response.data?.bot;
+		if (!botInfo?.open_id) return setCachedProbeResult(cacheKey, {
+			ok: false,
+			appId: creds.appId,
+			error: "API response missing bot open_id"
+		}, PROBE_ERROR_TTL_MS);
 		return setCachedProbeResult(cacheKey, {
 			ok: true,
 			appId: creds.appId,
-			botName: botInfo?.botName,
-			botOpenId: botInfo?.botID
+			botName: botInfo.app_name,
+			botOpenId: botInfo.open_id
 		}, PROBE_SUCCESS_TTL_MS);
 	} catch (err) {
 		return setCachedProbeResult(cacheKey, {
@@ -155,5 +172,48 @@ async function probeFeishu(creds, options = {}) {
 		}, PROBE_ERROR_TTL_MS);
 	}
 }
+/**
+* Preserve Feishu's optional AI-agent registration without coupling it to health or
+* identity. Monitor startup calls this once per account and never awaits it.
+*/
+async function registerFeishuAiAgent(creds, options = {}) {
+	if (!creds?.appId || !creds?.appSecret) return {
+		ok: false,
+		reason: "missing-credentials"
+	};
+	if (options.abortSignal?.aborted) return {
+		ok: false,
+		reason: "aborted"
+	};
+	const timeoutMs = options.timeoutMs ?? FEISHU_PROBE_REQUEST_TIMEOUT_MS;
+	try {
+		const responseResult = await raceWithTimeoutAndAbort(createFeishuClient(creds).request({
+			method: "POST",
+			url: "/open-apis/bot/v1/openclaw_bot/ping",
+			data: { needBotInfo: true },
+			timeout: timeoutMs
+		}), {
+			timeoutMs,
+			abortSignal: options.abortSignal
+		});
+		if (responseResult.status === "aborted" || options.abortSignal?.aborted) return {
+			ok: false,
+			reason: "aborted"
+		};
+		if (responseResult.status === "timeout") return {
+			ok: false,
+			reason: "timeout"
+		};
+		return responseResult.value.code === 0 ? { ok: true } : {
+			ok: false,
+			reason: "api-error"
+		};
+	} catch {
+		return {
+			ok: false,
+			reason: "request-error"
+		};
+	}
+}
 //#endregion
-export { waitForAbortableDelay as i, probe_exports as n, raceWithTimeoutAndAbort as r, probeFeishu as t };
+export { waitForAbortableDelay as a, raceWithTimeoutAndAbort as i, probe_exports as n, registerFeishuAiAgent as r, probeFeishu as t };

package/dist/runtime-api.js

@@ -6,8 +6,7 @@ import { PAIRING_APPROVED_MESSAGE, buildProbeChannelStatusSummary, createDefault
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
 import { DEFAULT_ACCOUNT_ID, buildChannelConfigSchema, createActionGate, createDedupeCache } from "openclaw/plugin-sdk/core";
-import { buildAgentMediaPayload } from "openclaw/plugin-sdk/agent-media-payload";
 import { evaluateSupplementalContextVisibility, filterSupplementalContextItems, resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
 import { isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText } from "openclaw/plugin-sdk/webhook-ingress";
-export { DEFAULT_ACCOUNT_ID, PAIRING_APPROVED_MESSAGE, buildAgentMediaPayload, buildChannelConfigSchema, buildProbeChannelStatusSummary, chunkTextForOutbound, createActionGate, createChannelPairingController, createDedupeCache, createDefaultChannelRuntimeState, createReplyPrefixContext, evaluateSupplementalContextVisibility, filterSupplementalContextItems, getSessionEntry, isRequestBodyLimitError, normalizeAgentId, readJsonFileWithFallback, readRequestBodyWithLimit, requestBodyErrorToText, resolveChannelContextVisibilityMode, setFeishuRuntime };
+export { DEFAULT_ACCOUNT_ID, PAIRING_APPROVED_MESSAGE, buildChannelConfigSchema, buildProbeChannelStatusSummary, chunkTextForOutbound, createActionGate, createChannelPairingController, createDedupeCache, createDefaultChannelRuntimeState, createReplyPrefixContext, evaluateSupplementalContextVisibility, filterSupplementalContextItems, getSessionEntry, isRequestBodyLimitError, normalizeAgentId, readJsonFileWithFallback, readRequestBodyWithLimit, requestBodyErrorToText, resolveChannelContextVisibilityMode, setFeishuRuntime };

package/dist/{security-audit-BIeA3W3Q.js → security-audit-D7WK_BHh.js}

@@ -1,4 +1,4 @@
-import "./security-audit-shared-BIHeF-S_.js";
+import "./security-audit-shared-BgpY7AiJ.js";
 //#region extensions/feishu/src/message-action-contract.ts
 const messageActionTargetAliases = {
 	read: { aliases: ["messageId"] },

package/dist/{security-audit-shared-BIHeF-S_.js → security-audit-shared-BgpY7AiJ.js}

@@ -1,25 +1,20 @@
+import { asOptionalRecord, hasNonEmptyString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
 //#region extensions/feishu/src/security-audit-shared.ts
-function asRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function hasNonEmptyString(value) {
-	return typeof value === "string" && value.trim().length > 0;
-}
 function isFeishuDocToolEnabled(cfg) {
-	const feishu = asRecord(asRecord(cfg.channels)?.feishu);
+	const feishu = asOptionalRecord(asOptionalRecord(cfg.channels)?.feishu);
 	if (!feishu || feishu.enabled === false) return false;
-	const baseTools = asRecord(feishu.tools);
+	const baseTools = asOptionalRecord(feishu.tools);
 	const baseDocEnabled = baseTools?.doc !== false;
 	const baseAppId = hasNonEmptyString(feishu.appId);
 	const baseAppSecret = hasConfiguredSecretInput(feishu.appSecret, cfg.secrets?.defaults);
 	const baseConfigured = baseAppId && baseAppSecret;
-	const accounts = asRecord(feishu.accounts);
+	const accounts = asOptionalRecord(feishu.accounts);
 	if (!accounts || Object.keys(accounts).length === 0) return baseDocEnabled && baseConfigured;
 	for (const accountValue of Object.values(accounts)) {
-		const account = asRecord(accountValue) ?? {};
+		const account = asOptionalRecord(accountValue) ?? {};
 		if (account.enabled === false) continue;
-		if (!((asRecord(account.tools) ?? baseTools)?.doc !== false)) continue;
+		if (!((asOptionalRecord(account.tools) ?? baseTools)?.doc !== false)) continue;
 		if ((hasNonEmptyString(account.appId) || baseAppId) && (hasConfiguredSecretInput(account.appSecret, cfg.secrets?.defaults) || baseAppSecret)) return true;
 	}
 	return false;

package/dist/security-contract-api.js

@@ -1,2 +1,2 @@
-import { t as collectFeishuSecurityAuditFindings } from "./security-audit-shared-BIHeF-S_.js";
+import { t as collectFeishuSecurityAuditFindings } from "./security-audit-shared-BgpY7AiJ.js";
 export { collectFeishuSecurityAuditFindings };

package/dist/{send-result-DfE5Fhz6.js → send-result-Bcofg0Vv.js}

@@ -1,4 +1,4 @@
-import { d as isRecord$1 } from "./accounts-BDoGHJDk.js";
+import { d as isRecord$1 } from "./accounts-CKhCa76b.js";
 import { r as normalizeFeishuTarget, t as detectIdType } from "./targets-BUjQ1TcA.js";
 import { compileAllowlist, resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
 import { ToolAuthorizationError } from "openclaw/plugin-sdk/channel-actions";

package/dist/session-binding-contract-api.js

@@ -1,2 +1,2 @@
-import { r as testing, t as createFeishuThreadBindingManager } from "./thread-bindings-V0bwk0A1.js";
+import { r as testing, t as createFeishuThreadBindingManager } from "./thread-bindings-Dqs_A0du.js";
 export { createFeishuThreadBindingManager, testing as feishuThreadBindingTesting };

package/dist/setup-api.js

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

package/dist/{subagent-hooks-BKTOxB-T.js → subagent-hooks-DL2SC5zX.js}

@@ -1,7 +1,7 @@
 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-BeJL-wq7.js";
-import { n as getFeishuThreadBindingManager } from "./thread-bindings-V0bwk0A1.js";
+import { n as getFeishuThreadBindingManager } from "./thread-bindings-Dqs_A0du.js";
 import { normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/feishu/src/subagent-hooks.ts
 var subagent_hooks_exports = /* @__PURE__ */ __exportAll({

package/dist/subagent-hooks-api.js

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

package/dist/{thread-bindings-V0bwk0A1.js → thread-bindings-Dqs_A0du.js}

@@ -1,6 +1,7 @@
 import { registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/conversation-runtime";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
 //#region extensions/feishu/src/thread-bindings.ts
 const FEISHU_THREAD_BINDINGS_STATE_KEY = Symbol.for("openclaw.feishuThreadBindingsState");
 let state;
@@ -94,7 +95,7 @@ function createFeishuThreadBindingManager(params) {
 				deliveryThreadId: typeof metadata?.deliveryThreadId === "string" && metadata.deliveryThreadId.trim() ? metadata.deliveryThreadId.trim() : existingLocal?.deliveryThreadId,
 				targetKind: toFeishuTargetKind(targetKind),
 				targetSessionKey: normalizedTargetSessionKey,
-				agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim() ? metadata.agentId.trim() : existingLocal?.agentId ?? resolveAgentIdFromSessionKey(normalizedTargetSessionKey),
+				agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim() ? metadata.agentId.trim() : existingLocal?.agentId ?? resolveAgentIdFromSessionKey(normalizedTargetSessionKey, resolveDefaultAgentId(params.cfg)),
 				label: typeof metadata?.label === "string" && metadata.label.trim() ? metadata.label.trim() : existingLocal?.label,
 				boundBy: typeof metadata?.boundBy === "string" && metadata.boundBy.trim() ? metadata.boundBy.trim() : existingLocal?.boundBy,
 				boundAt: now,

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

@@ -705,10 +705,22 @@ await lark.registerApp({
     addons: { scopes: { tenant: ['drive:drive.metadata:readonly'] } },
     onQRCodeReady(info) { /* ... */ },
 });
+
+// Minimal base: drop the default template (bot capability only, no business
+// scopes) and show only the explicitly declared items. With `preset: false`
+// an otherwise-empty addons is valid.
+await lark.registerApp({
+    addons: {
+        preset: false,
+        scopes: { tenant: ['im:message:send_as_bot'] },
+    },
+    onQRCodeReady(info) { /* ... */ },
+});
 ```
 
 Notes:
 
+- `addons.preset` selects the template base: `true` / omitted keeps the platform default template and layers the declared items on top (additive — the default behavior); `false` drops the default template and starts from the minimal base (bot capability only, no business scopes), showing only the explicitly declared items. Only with `preset: false` may `addons` be otherwise empty (minimal base, zero increments); otherwise at least one scope, event or callback is required.
 - `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.
@@ -728,6 +740,7 @@ Notes:
 | 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.preset | Template base selector. `true`/omitted: keep the platform default template and layer the declared items on top; `false`: drop the default template and use the minimal base (bot capability only, no business scopes). With `false`, an otherwise-empty `addons` is valid | boolean | No | `true` |
 | 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 | - |

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

@@ -765,10 +765,21 @@ await lark.registerApp({
     addons: { scopes: { tenant: ['drive:drive.metadata:readonly'] } },
     onQRCodeReady(info) { /* ... */ },
 });
+
+// 最小基座：丢弃默认模板（仅保留机器人能力，无业务权限），仅展示显式声明的配置项。
+// 传入 `preset: false` 时，即使 addons 没有其他配置项也是合法的。
+await lark.registerApp({
+    addons: {
+        preset: false,
+        scopes: { tenant: ['im:message:send_as_bot'] },
+    },
+    onQRCodeReady(info) { /* ... */ },
+});
 ```
 
 注意：
 
+- `addons.preset` 用于选择模板基座：`true` / 不传表示保留平台默认模板，并在其上叠加声明的配置项（增量，默认行为）；`false` 表示丢弃默认模板，从最小基座（仅机器人能力，无业务权限）开始，仅展示显式声明的配置项。仅当 `preset: false` 时 `addons` 可以不含其他配置项（最小基座、零增量），否则至少需包含一个权限、事件或回调。
 - `addons` 仅支持在基础模板上**增量叠加**，不支持删减基础权限。
 - 仅支持 5 类公开配置（应用/用户身份权限、应用/用户身份事件、回调）。敏感配置（事件订阅方式与回调地址、`security.*`、加密 key 等）不能通过 `addons` 传入，需调用[更新应用开发配置 OpenAPI](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/application-v7/application-v7/application-config/patch)。
 - SDK 只校验数据形状，不校验权限点/事件/回调名称是否存在；平台目录中不存在的名称会被确认页忽略。
@@ -788,6 +799,7 @@ await lark.registerApp({
 | appPreset.name | 应用名称，支持 `{user}` 占位符（替换为扫码用户名称）                                                              | string      | 否  | -                        |
 | appPreset.desc | 应用描述，支持 `{user}` 占位符                                                                          | string      | 否  | -                        |
 | addons         | 增量权限/事件/回调配置，预填到扫码后的确认页，用户确认后生效。详见上方「自定义权限/事件/回调」                                              | AppAddons   | 否  | -                        |
+| addons.preset  | 模板基座选择。`true`/不传：保留平台默认模板，在其上叠加声明的配置项；`false`：丢弃默认模板，使用最小基座（仅机器人能力，无业务权限）。传 `false` 时 `addons` 可不含其他配置项       | boolean     | 否  | `true`                   |
 | 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[]    | 否  | -                        |