@openclaw/feishu 2026.7.1 → 2026.7.2-beta.1

package/dist/doctor-contract-DXH5hux1.js

@@ -0,0 +1,97 @@
+import { asObjectRecord, defineChannelAliasMigration } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/feishu/src/doctor-contract.ts
+const streamingAliasMigration = defineChannelAliasMigration({
+	channelId: "feishu",
+	streaming: { defaultMode: "partial" },
+	accountStreamingReplacesRoot: true
+});
+const LEGACY_COALESCE_FIELDS = [
+	"enabled",
+	"minDelayMs",
+	"maxDelayMs"
+];
+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 sanitizeFeishuCoalesce(cfg, changes) {
+	const channels = cfg.channels;
+	const entry = asObjectRecord(channels?.feishu);
+	if (!entry) return cfg;
+	const root = sanitizeLegacyCoalesceFields({
+		entry,
+		pathPrefix: "channels.feishu",
+		changes
+	});
+	let updated = root.entry;
+	let changed = root.changed;
+	const accounts = asObjectRecord(updated.accounts);
+	if (accounts) {
+		let accountsChanged = false;
+		const nextAccounts = { ...accounts };
+		for (const [accountId, rawAccount] of Object.entries(accounts)) {
+			const account = asObjectRecord(rawAccount);
+			if (!account) continue;
+			const sanitized = sanitizeLegacyCoalesceFields({
+				entry: account,
+				pathPrefix: `channels.feishu.accounts.${accountId}`,
+				changes
+			});
+			if (sanitized.changed) {
+				nextAccounts[accountId] = sanitized.entry;
+				accountsChanged = true;
+			}
+		}
+		if (accountsChanged) {
+			updated = {
+				...updated,
+				accounts: nextAccounts
+			};
+			changed = true;
+		}
+	}
+	if (!changed) return cfg;
+	return {
+		...cfg,
+		channels: {
+			...channels,
+			feishu: updated
+		}
+	};
+}
+const legacyConfigRules = streamingAliasMigration.legacyConfigRules;
+function normalizeCompatibilityConfig({ cfg }) {
+	const aliases = streamingAliasMigration.normalizeChannelConfig({ cfg });
+	return {
+		config: sanitizeFeishuCoalesce(aliases.config, aliases.changes),
+		changes: aliases.changes
+	};
+}
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/doctor-contract-api.js

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

package/dist/{drive-D0lIhxqZ.js → drive-Bpe8ONK_.js}

@@ -1,7 +1,8 @@
-import { c as encodeQuery, d as isRecord$1, i as listFeishuAccountIds, l as extractReplyText, m as readString, o as resolveFeishuAccount, r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount, u as formatFeishuApiError, v as parseFeishuCommentTarget } from "./accounts-Bs5uJ4h0.js";
-import { r as createFeishuClient } from "./client-B7EAV_Ss.js";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { c as encodeQuery, d as isRecord$1, i as listFeishuAccountIds, l as extractReplyText, m as readString, o as resolveFeishuAccount, r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount, u as formatFeishuApiError, v as parseFeishuCommentTarget } from "./accounts-BDoGHJDk.js";
+import { k as resolveFeishuChatType, m as authorizeFeishuChatMemberRead, p as assertFeishuChatReadAllowed, y as resolveFeishuChatReadPreliminaryAuthorization } from "./send-result-CPS7AozW.js";
+import { r as createFeishuClient } from "./client-BUC-R2Wi.js";
 import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
@@ -95,22 +96,13 @@ function resolveAnyEnabledFeishuToolsConfig(accounts) {
 	}
 	return merged;
 }
-//#endregion
-//#region extensions/feishu/src/chat-schema.ts
-const CHAT_ACTION_VALUES = [
-	"members",
-	"info",
-	"member_info"
-];
-const MEMBER_ID_TYPE_VALUES = [
-	"open_id",
-	"user_id",
-	"union_id"
-];
 const FeishuChatSchema = Type.Object({
-	action: Type.Unsafe({
+	action: Type.Enum([
+		"members",
+		"info",
+		"member_info"
+	], {
 		type: "string",
-		enum: [...CHAT_ACTION_VALUES],
 		description: "Action to run: members | info | member_info"
 	}),
 	chat_id: Type.Optional(Type.String({ description: "Chat ID (from URL or event payload)" })),
@@ -120,9 +112,12 @@ const FeishuChatSchema = Type.Object({
 		description: "Page size (1-100, default 50)"
 	}),
 	page_token: Type.Optional(Type.String({ description: "Pagination token" })),
-	member_id_type: Type.Optional(Type.Unsafe({
+	member_id_type: Type.Optional(Type.Enum([
+		"open_id",
+		"user_id",
+		"union_id"
+	], {
 		type: "string",
-		enum: [...MEMBER_ID_TYPE_VALUES],
 		description: "Member ID type (default: open_id)"
 	}))
 });
@@ -134,6 +129,19 @@ function readChatPageSize(params) {
 		message: "page_size must be a positive integer between 1 and 100"
 	});
 }
+function buildFeishuDirectChatMembers(authorization) {
+	return {
+		chat_id: authorization.chatId,
+		has_more: false,
+		page_token: void 0,
+		members: [{
+			member_id: authorization.memberId,
+			name: void 0,
+			tenant_key: void 0,
+			member_id_type: authorization.memberIdType
+		}]
+	};
+}
 async function getChatInfo(client, chatId) {
 	const res = await client.im.chat.get({ path: { chat_id: chatId } });
 	if (res.code !== 0) throw new Error(res.msg);
@@ -154,6 +162,49 @@ async function getChatInfo(client, chatId) {
 		avatar: chat?.avatar
 	};
 }
+function authorizeFeishuChatInfo(params) {
+	assertFeishuChatReadAllowed({
+		cfg: params.cfg,
+		account: params.account,
+		chatId: params.chatId,
+		chatType: resolveFeishuChatType(params.chat),
+		ctx: params.ctx
+	});
+}
+async function getAuthorizedFeishuChatInfo(params) {
+	const preliminary = resolveFeishuChatReadPreliminaryAuthorization({
+		cfg: params.cfg,
+		account: params.account,
+		chatId: params.chatId,
+		ctx: params.ctx
+	});
+	if (preliminary.decision === "deny") assertFeishuChatReadAllowed({
+		cfg: params.cfg,
+		account: params.account,
+		chatId: preliminary.chatId,
+		ctx: params.ctx
+	});
+	let chat;
+	try {
+		chat = await getChatInfo(params.client, preliminary.chatId);
+	} catch (error) {
+		if (preliminary.decision === "needs-metadata") assertFeishuChatReadAllowed({
+			cfg: params.cfg,
+			account: params.account,
+			chatId: preliminary.chatId,
+			ctx: params.ctx
+		});
+		throw error;
+	}
+	authorizeFeishuChatInfo({
+		cfg: params.cfg,
+		account: params.account,
+		chatId: preliminary.chatId,
+		chat,
+		ctx: params.ctx
+	});
+	return chat;
+}
 async function getChatMembers(client, chatId, pageSize, pageToken, memberIdType) {
 	const page_size = pageSize ? Math.max(1, Math.min(100, pageSize)) : 50;
 	const res = await client.im.chatMembers.get({
@@ -177,6 +228,19 @@ async function getChatMembers(client, chatId, pageSize, pageToken, memberIdType)
 		})) ?? []
 	};
 }
+async function assertFeishuChatMember(client, chatId, memberId, memberIdType = "open_id") {
+	let pageToken;
+	const seenPageTokens = /* @__PURE__ */ new Set();
+	while (true) {
+		const members = await getChatMembers(client, chatId, 100, pageToken, memberIdType);
+		if (members.members.some((member) => member.member_id === memberId)) return;
+		if (!members.has_more || !members.page_token) break;
+		if (seenPageTokens.has(members.page_token)) throw new Error(`Feishu chat member pagination repeated token for chat ${chatId}`);
+		seenPageTokens.add(members.page_token);
+		pageToken = members.page_token;
+	}
+	throw new Error(`Member ${memberId} is not a member of chat ${chatId}`);
+}
 async function getFeishuMemberInfo(client, memberId, memberIdType = "open_id") {
 	const res = await client.contact.user.get({
 		path: { user_id: memberId },
@@ -219,12 +283,11 @@ async function getFeishuMemberInfo(client, memberId, memberIdType = "open_id") {
 }
 function registerFeishuChatTools(api) {
 	if (!api.config) return;
-	const accounts = listEnabledFeishuAccounts(api.config);
+	const cfg = api.config;
+	const accounts = listEnabledFeishuAccounts(cfg);
 	if (accounts.length === 0) return;
-	const firstAccount = accounts[0];
-	if (!resolveToolsConfig(firstAccount.config.tools).chat) return;
-	const getClient = () => createFeishuClient(firstAccount);
-	api.registerTool({
+	if (!resolveAnyEnabledFeishuToolsConfig(accounts).chat) return;
+	api.registerTool((toolContext) => ({
 		name: "feishu_chat",
 		label: "Feishu Chat",
 		description: "Feishu chat operations. Actions: members, info, member_info",
@@ -233,24 +296,80 @@ function registerFeishuChatTools(api) {
 			const rawParams = params;
 			const p = params;
 			try {
-				const client = getClient();
+				const account = resolveFeishuToolAccount({
+					api,
+					defaultAccountId: toolContext.agentAccountId,
+					requiredTool: {
+						family: "chat",
+						label: "chat"
+					}
+				});
+				const client = createFeishuClient(account);
 				switch (p.action) {
 					case "members":
 						if (!p.chat_id) return jsonResult({ error: "chat_id is required for action members" });
+						{
+							const chat = await getAuthorizedFeishuChatInfo({
+								client,
+								cfg,
+								account,
+								chatId: p.chat_id,
+								ctx: toolContext
+							});
+							const authorization = authorizeFeishuChatMemberRead({
+								cfg,
+								account,
+								chatId: p.chat_id,
+								chatType: resolveFeishuChatType(chat),
+								ctx: toolContext,
+								memberIdType: p.member_id_type
+							});
+							if (authorization.kind === "direct") return jsonResult(buildFeishuDirectChatMembers(authorization));
+						}
 						return jsonResult(await getChatMembers(client, p.chat_id, readChatPageSize(rawParams), p.page_token, p.member_id_type));
 					case "info":
 						if (!p.chat_id) return jsonResult({ error: "chat_id is required for action info" });
-						return jsonResult(await getChatInfo(client, p.chat_id));
+						return jsonResult(await getAuthorizedFeishuChatInfo({
+							client,
+							cfg,
+							account,
+							chatId: p.chat_id,
+							ctx: toolContext
+						}));
 					case "member_info":
 						if (!p.member_id) return jsonResult({ error: "member_id is required for action member_info" });
-						return jsonResult(await getFeishuMemberInfo(client, p.member_id, p.member_id_type ?? "open_id"));
+						if (!p.chat_id) return jsonResult({ error: "chat_id is required for action member_info" });
+						{
+							const chat = await getAuthorizedFeishuChatInfo({
+								client,
+								cfg,
+								account,
+								chatId: p.chat_id,
+								ctx: toolContext
+							});
+							const authorization = authorizeFeishuChatMemberRead({
+								cfg,
+								account,
+								chatId: p.chat_id,
+								chatType: resolveFeishuChatType(chat),
+								ctx: toolContext,
+								memberId: p.member_id,
+								memberIdType: p.member_id_type
+							});
+							if (authorization.kind === "group") {
+								const memberIdType = p.member_id_type ?? "open_id";
+								await assertFeishuChatMember(client, p.chat_id, p.member_id, memberIdType);
+								return jsonResult(await getFeishuMemberInfo(client, p.member_id, memberIdType));
+							}
+							return jsonResult(await getFeishuMemberInfo(client, authorization.memberId, authorization.memberIdType));
+						}
 					default: return jsonResult({ error: `Unknown action: ${String(p.action)}` });
 				}
 			} catch (err) {
 				return jsonResult({ error: formatFeishuApiError(err, { includeNestedErrorLogId: true }) });
 			}
 		}
-	}, { name: "feishu_chat" });
+	}), { name: "feishu_chat" });
 }
 //#endregion
 //#region extensions/feishu/src/tool-result.ts
@@ -656,10 +775,10 @@ async function listFolder(client, params = {}) {
 		next_page_token: res.data?.next_page_token
 	};
 }
-async function getFileInfo(client, fileToken, folderToken) {
-	const res = await client.drive.file.list({ params: folderToken ? { folder_token: folderToken } : {} });
+async function getRootFileInfo(client, fileToken) {
+	const res = await client.drive.file.list({ params: {} });
 	if (res.code !== 0) throw new Error(res.msg);
-	const file = res.data?.files?.find((f) => f.token === fileToken);
+	const file = res.data?.files?.find((candidate) => candidate.token === fileToken);
 	if (!file) throw new Error(`File not found: ${fileToken}`);
 	return {
 		token: file.token,
@@ -671,6 +790,35 @@ async function getFileInfo(client, fileToken, folderToken) {
 		owner_id: file.owner_id
 	};
 }
+async function getFileInfo(client, fileToken, type) {
+	if (type === "shortcut") return getRootFileInfo(client, fileToken);
+	let res;
+	try {
+		res = await client.drive.meta.batchQuery({ data: {
+			request_docs: [{
+				doc_token: fileToken,
+				doc_type: type
+			}],
+			with_url: true
+		} });
+	} catch (error) {
+		if (extractDriveApiErrorMeta(error).feishuCode === 99991672) return getRootFileInfo(client, fileToken);
+		throw error;
+	}
+	if (res.code === 99991672) return getRootFileInfo(client, fileToken);
+	if (res.code !== 0) throw new Error(res.msg);
+	const file = res.data?.metas?.find((meta) => meta.doc_token === fileToken || meta.request_doc_info?.doc_token === fileToken);
+	if (!file) throw new Error(`File not found: ${fileToken}`);
+	return {
+		token: file.doc_token,
+		name: file.title,
+		type: file.doc_type,
+		url: file.url,
+		created_time: file.create_time,
+		modified_time: file.latest_modify_time,
+		owner_id: file.owner_id
+	};
+}
 async function createFolder(client, name, folderToken) {
 	let effectiveToken = folderToken && folderToken !== "0" ? folderToken : "0";
 	if (effectiveToken === "0") try {
@@ -883,7 +1031,7 @@ function registerFeishuDriveTools(api) {
 							page_size: p.page_size,
 							page_token: p.page_token
 						}));
-						case "info": return jsonResult(await getFileInfo(client, p.file_token));
+						case "info": return jsonResult(await getFileInfo(client, p.file_token, p.type));
 						case "create_folder": return jsonResult(await createFolder(client, p.name, p.folder_token));
 						case "move": return jsonResult(await moveFile(client, p.file_token, p.type, p.folder_token));
 						case "delete": return jsonResult(await deleteFile(client, p.file_token, p.type));
@@ -921,4 +1069,4 @@ function registerFeishuDriveTools(api) {
 	}, { name: "feishu_drive" });
 }
 //#endregion
-export { toolExecutionErrorResult as a, getChatMembers as c, createFeishuToolClient as d, resolveAnyEnabledFeishuToolsConfig as f, createCommentTypingReactionLifecycle as i, getFeishuMemberInfo as l, resolveToolsConfig as m, registerFeishuDriveTools as n, unknownToolActionResult as o, resolveFeishuToolAccount as p, cleanupAmbientCommentTypingReaction as r, getChatInfo as s, deliverCommentThreadText as t, registerFeishuChatTools as u };
+export { toolExecutionErrorResult as a, buildFeishuDirectChatMembers as c, getFeishuMemberInfo as d, registerFeishuChatTools as f, resolveToolsConfig as g, resolveFeishuToolAccount as h, createCommentTypingReactionLifecycle as i, getChatInfo as l, resolveAnyEnabledFeishuToolsConfig as m, registerFeishuDriveTools as n, unknownToolActionResult as o, createFeishuToolClient as p, cleanupAmbientCommentTypingReaction as r, assertFeishuChatMember as s, deliverCommentThreadText as t, getChatMembers as u };

package/dist/{monitor-CsbheK9J.js → monitor-M3iYtoh4.js}

@@ -1,8 +1,8 @@
-import { r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount } from "./accounts-Bs5uJ4h0.js";
-import { f as fetchBotIdentityForMonitor } from "./monitor.state-DAHbcR2N.js";
+import { r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount } from "./accounts-BDoGHJDk.js";
+import { t as fetchBotIdentityForMonitor } from "./monitor.startup-DpZzunQn.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/feishu/src/monitor.ts
-const loadMonitorAccountRuntime = createLazyRuntimeModule(() => import("./monitor.account-Dr7do33p.js"));
+const loadMonitorAccountRuntime = createLazyRuntimeModule(() => import("./monitor.account-F99J862T.js"));
 async function monitorFeishuProvider(opts = {}) {
 	const cfg = opts.config;
 	if (!cfg) throw new Error("Config is required for Feishu monitor");