@openclaw/feishu 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/doctor-contract-api.js

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

package/dist/doctor-contract-bEQXIXyP.js

@@ -0,0 +1,158 @@
+import { asObjectRecord, defineChannelAliasMigration, defineKeyMoveMigration, hasLegacyAccountStreamingAliases, normalizeChannelConfigEntries } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+//#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/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 legacyConfigRules = [
+	...streamingAliasMigration.legacyConfigRules,
+	{
+		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 });
+	return {
+		config: normalizeFeishuLegacyConfigEntries(aliases.config, aliases.changes),
+		changes: aliases.changes
+	};
+}
+//#endregion
+export { normalizeFeishuWebhookPath as i, normalizeCompatibilityConfig as n, DEFAULT_FEISHU_WEBHOOK_PATH as r, legacyConfigRules as t };

package/dist/{drive-hSi_Utp0.js → drive-B0JkoiRj.js}

@@ -1,13 +1,15 @@
-import { a as resolveDefaultFeishuAccountId, 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-u9X5Wsan.js";
-import { A as resolveFeishuChatType, b as resolveFeishuChatReadPreliminaryAuthorization, h as authorizeFeishuChatMemberRead, m as assertFeishuChatReadAllowed } from "./send-result-B9_BpUPx.js";
-import { r as createFeishuClient } from "./client-Dcbs6vml.js";
+import { a as resolveDefaultFeishuAccountId, i as listFeishuAccountIds, o as resolveFeishuAccount, r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount } from "./accounts-CCCdMen2.js";
+import { A as resolveFeishuChatType, b as resolveFeishuChatReadPreliminaryAuthorization, h as authorizeFeishuChatMemberRead, m as assertFeishuChatReadAllowed } from "./send-result-DEAycmOk.js";
+import { r as createFeishuClient } from "./client-Hp7uo_cl.js";
 import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { jsonResult } from "openclaw/plugin-sdk/tool-results";
+import { isRecord, normalizeOptionalString, normalizeStringEntries, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { Type } from "typebox";
+import { wrapExternalContent } from "openclaw/plugin-sdk/security-runtime";
+import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
+import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 //#region extensions/feishu/src/tools-config.ts
 /**
 * Default tool configuration.
@@ -99,6 +101,26 @@ function resolveAnyEnabledFeishuToolsConfig(accounts) {
 	}
 	return merged;
 }
+//#endregion
+//#region extensions/feishu/src/tool-result.ts
+function feishuExternalToolResult(details) {
+	return {
+		content: [{
+			type: "text",
+			text: wrapExternalContent(JSON.stringify(details, null, 2), {
+				source: "api",
+				includeWarning: false
+			})
+		}],
+		details
+	};
+}
+function unknownToolActionResult(action) {
+	return jsonResult({ error: `Unknown action: ${String(action)}` });
+}
+function toolExecutionErrorResult(error) {
+	return feishuExternalToolResult({ error: formatErrorMessage(error) });
+}
 const FeishuChatSchema = Type.Object({
 	action: Type.Enum([
 		"members",
@@ -125,6 +147,267 @@ const FeishuChatSchema = Type.Object({
 	}))
 });
 //#endregion
+//#region extensions/feishu/src/comment-target.ts
+const FEISHU_COMMENT_FILE_TYPES = [
+	"doc",
+	"docx",
+	"file",
+	"sheet",
+	"slides"
+];
+function normalizeCommentFileType(value) {
+	return typeof value === "string" && FEISHU_COMMENT_FILE_TYPES.includes(value) ? value : void 0;
+}
+function buildFeishuCommentTarget(params) {
+	return `comment:${params.fileType}:${params.fileToken}:${params.commentId}`;
+}
+function parseFeishuCommentTarget(raw) {
+	const trimmed = raw?.trim();
+	if (!trimmed?.startsWith("comment:")) return null;
+	const parts = trimmed.split(":");
+	if (parts.length !== 4) return null;
+	const fileType = normalizeCommentFileType(parts[1]);
+	const fileToken = parts[2]?.trim();
+	const commentId = parts[3]?.trim();
+	if (!fileType || !fileToken || !commentId) return null;
+	return {
+		fileType,
+		fileToken,
+		commentId
+	};
+}
+//#endregion
+//#region extensions/feishu/src/send-rate-limit.ts
+const FEISHU_SEND_RATE_LIMIT_CODES = /* @__PURE__ */ new Set([230020, 11232]);
+function getFeishuSendRateLimitCode(error) {
+	if (!isRecord(error)) return;
+	const response = isRecord(error.response) ? error.response : void 0;
+	if (response?.status === 429) return 429;
+	const code = (isRecord(response?.data) ? response.data : void 0)?.code;
+	return typeof code === "number" && FEISHU_SEND_RATE_LIMIT_CODES.has(code) ? code : void 0;
+}
+function getFeishuSendRateLimitCodeFromResponse(response) {
+	if (!isRecord(response)) return;
+	const code = response.code;
+	return typeof code === "number" && FEISHU_SEND_RATE_LIMIT_CODES.has(code) ? code : void 0;
+}
+//#endregion
+//#region extensions/feishu/src/comment-shared.ts
+function encodeQuery(params) {
+	const query = new URLSearchParams();
+	for (const [key, value] of Object.entries(params)) {
+		const trimmed = value?.trim();
+		if (trimmed) query.set(key, trimmed);
+	}
+	const queryString = query.toString();
+	return queryString ? `?${queryString}` : "";
+}
+function formatFeishuApiError(error, options = {}) {
+	if (!isRecord(error)) return typeof error === "string" ? error : JSON.stringify(error);
+	const config = isRecord(error.config) ? error.config : void 0;
+	const response = isRecord(error.response) ? error.response : void 0;
+	const responseData = isRecord(response?.data) ? response?.data : void 0;
+	const feishuLogId = readStringValue(responseData?.log_id) || (options.includeNestedErrorLogId ? readStringValue(isRecord(responseData?.error) ? responseData.error.log_id : void 0) : void 0);
+	const nestedError = isRecord(responseData?.error) ? responseData.error : void 0;
+	return JSON.stringify({
+		message: typeof error.message === "string" ? error.message : typeof error === "string" ? error : JSON.stringify(error),
+		code: readStringValue(error.code),
+		method: readStringValue(config?.method),
+		url: readStringValue(config?.url),
+		...options.includeConfigParams ? { params: config?.params } : {},
+		http_status: typeof response?.status === "number" ? response.status : void 0,
+		feishu_code: typeof responseData?.code === "number" ? responseData.code : readStringValue(responseData?.code),
+		feishu_msg: readStringValue(responseData?.msg),
+		feishu_log_id: feishuLogId,
+		feishu_troubleshooter: readStringValue(responseData?.troubleshooter) || readStringValue(nestedError?.troubleshooter)
+	});
+}
+function formatFeishuApiFailure(error, errorPrefix, options = {}) {
+	return `${errorPrefix}: ${formatFeishuApiError(error, options) || "unknown error"}`;
+}
+function createFeishuApiError(error, errorPrefix, options = {}) {
+	return new Error(formatFeishuApiFailure(error, errorPrefix, options), { cause: error });
+}
+const FEISHU_SEND_RETRY_BASE_MS = 500;
+async function requestFeishuApi(request, errorPrefix, options = {}) {
+	try {
+		return await retryAsync(async () => {
+			const result = await request();
+			const fulfilledRateLimit = getFeishuSendRateLimitCodeFromResponse(result);
+			if (fulfilledRateLimit !== void 0) throw Object.assign(/* @__PURE__ */ new Error(`Request fulfilled with rate-limit code ${fulfilledRateLimit}`), { response: {
+				status: 200,
+				data: result
+			} });
+			return result;
+		}, {
+			attempts: 3,
+			minDelayMs: options.retryDelayMs ?? FEISHU_SEND_RETRY_BASE_MS,
+			shouldRetry: (error) => getFeishuSendRateLimitCode(error) !== void 0
+		});
+	} catch (error) {
+		throw createFeishuApiError(error, errorPrefix, options);
+	}
+}
+function readDocsLinkUrl(element) {
+	const docsLink = isRecord(element.docs_link) ? element.docs_link : void 0;
+	return normalizeOptionalString(docsLink?.url) || normalizeOptionalString(docsLink?.link) || normalizeOptionalString(element.url) || normalizeOptionalString(element.link) || void 0;
+}
+function readMentionUserId(element) {
+	const mention = isRecord(element.mention) ? element.mention : void 0;
+	return normalizeOptionalString((isRecord(element.person) ? element.person : void 0)?.user_id) || normalizeOptionalString(mention?.user_id) || normalizeOptionalString(mention?.open_id) || normalizeOptionalString(element.mention_user) || normalizeOptionalString(element.user_id) || void 0;
+}
+function readMentionDisplayText(element, userId) {
+	const mention = isRecord(element.mention) ? element.mention : void 0;
+	const mentionName = normalizeOptionalString(mention?.name) || normalizeOptionalString(mention?.display_name) || normalizeOptionalString(element.name);
+	return mentionName ? `@${mentionName}` : `@${userId}`;
+}
+function normalizeCommentText(parts) {
+	return parts.join("").trim() || void 0;
+}
+function normalizeCommentSemanticText(parts) {
+	return parts.join("").replace(/\s+/g, " ").trim() || void 0;
+}
+function readElementTextPreservingWhitespace(element) {
+	return (isRecord(element.text_run) ? readStringValue(element.text_run.content) || readStringValue(element.text_run.text) : void 0) || readStringValue(element.text) || readStringValue(element.content) || readStringValue(element.name) || void 0;
+}
+const FEISHU_LINK_TOKEN_MIN_LENGTH = 22;
+const FEISHU_LINK_TOKEN_MAX_LENGTH = 28;
+const COMMENT_LINK_KIND_ALIASES = /* @__PURE__ */ new Map([
+	["doc", "doc"],
+	["docs", "doc"],
+	["docx", "docx"],
+	["sheet", "sheet"],
+	["sheets", "sheet"],
+	["slide", "slides"],
+	["slides", "slides"],
+	["file", "file"],
+	["files", "file"],
+	["wiki", "wiki"],
+	["mindnote", "mindnote"],
+	["mindnotes", "mindnote"],
+	["bitable", "bitable"],
+	["base", "base"]
+]);
+function isCommentFileType(value) {
+	return typeof value === "string" && FEISHU_COMMENT_FILE_TYPES.includes(value);
+}
+function isReasonableFeishuLinkToken(token) {
+	return typeof token === "string" && token.length >= FEISHU_LINK_TOKEN_MIN_LENGTH && token.length <= FEISHU_LINK_TOKEN_MAX_LENGTH;
+}
+function parseCommentLinkedDocumentPath(pathname) {
+	const segments = normalizeStringEntries(pathname.split("/"));
+	const offset = segments[0]?.toLowerCase() === "space" ? 1 : 0;
+	const kind = COMMENT_LINK_KIND_ALIASES.get(segments[offset]?.toLowerCase() ?? "");
+	const token = normalizeOptionalString(segments[offset + 1]);
+	if (!kind || !isReasonableFeishuLinkToken(token)) return null;
+	return {
+		urlKind: kind,
+		token
+	};
+}
+function hasResolvedLinkedDocumentReference(link) {
+	return link.urlKind !== "unknown" && (Boolean(link.resolvedObjToken) || Boolean(link.wikiNodeToken));
+}
+function resolveCommentLinkedDocumentFromUrl(params) {
+	const link = {
+		rawUrl: params.rawUrl,
+		urlKind: "unknown"
+	};
+	try {
+		const parsedPath = parseCommentLinkedDocumentPath(new URL(params.rawUrl).pathname);
+		if (!parsedPath) return link;
+		const { urlKind, token } = parsedPath;
+		link.urlKind = urlKind;
+		if (urlKind === "wiki") {
+			link.urlKind = "wiki";
+			link.wikiNodeToken = token;
+		} else {
+			link.resolvedObjType = urlKind;
+			link.resolvedObjToken = token;
+		}
+		if (link.resolvedObjType && link.resolvedObjToken && isCommentFileType(link.resolvedObjType) && params.currentDocument?.fileType === link.resolvedObjType && params.currentDocument.fileToken === link.resolvedObjToken) link.isCurrentDocument = true;
+		else if (link.resolvedObjType && link.resolvedObjToken && isCommentFileType(link.resolvedObjType)) link.isCurrentDocument = false;
+	} catch {
+		return link;
+	}
+	return link;
+}
+function parseCommentContentElements(params) {
+	const elements = Array.isArray(params.elements) ? params.elements : [];
+	const plainTextParts = [];
+	const semanticTextParts = [];
+	const mentions = [];
+	const linkedDocuments = [];
+	const botIds = new Set(Array.from(params.botOpenIds ?? []).map((value) => normalizeOptionalString(value)).filter((value) => Boolean(value)));
+	const linkedDocumentKeys = /* @__PURE__ */ new Set();
+	let botMentioned = false;
+	for (const rawElement of elements) {
+		if (!isRecord(rawElement)) continue;
+		const element = rawElement;
+		const type = normalizeOptionalString(element.type);
+		const text = (type === "text_run" ? readElementTextPreservingWhitespace(element) : void 0) || (type === "text" ? readElementTextPreservingWhitespace(element) : void 0) || (type === "docs_link" || type === "link" ? readDocsLinkUrl(element) : void 0) || (type === "mention" || type === "mention_user" || type === "person" ? (() => {
+			const userId = readMentionUserId(element);
+			return userId ? readMentionDisplayText(element, userId) : void 0;
+		})() : void 0) || readElementTextPreservingWhitespace(element) || void 0;
+		if (type === "mention" || type === "mention_user" || type === "person") {
+			const userId = readMentionUserId(element);
+			if (userId) {
+				const displayText = readMentionDisplayText(element, userId);
+				const isBotMention = botIds.has(userId);
+				mentions.push({
+					userId,
+					displayText,
+					isBotMention
+				});
+				plainTextParts.push(displayText);
+				if (!isBotMention) semanticTextParts.push(displayText);
+				else botMentioned = true;
+				continue;
+			}
+		}
+		if (type === "docs_link" || type === "link") {
+			const rawUrl = readDocsLinkUrl(element);
+			if (rawUrl) {
+				plainTextParts.push(rawUrl);
+				semanticTextParts.push(rawUrl);
+				const linkedDocument = resolveCommentLinkedDocumentFromUrl({
+					rawUrl,
+					currentDocument: params.currentDocument
+				});
+				if (hasResolvedLinkedDocumentReference(linkedDocument)) {
+					const key = [
+						linkedDocument.rawUrl,
+						linkedDocument.urlKind,
+						linkedDocument.resolvedObjType,
+						linkedDocument.resolvedObjToken,
+						linkedDocument.wikiNodeToken
+					].join(":");
+					if (!linkedDocumentKeys.has(key)) {
+						linkedDocumentKeys.add(key);
+						linkedDocuments.push(linkedDocument);
+					}
+				}
+				continue;
+			}
+		}
+		if (text) {
+			plainTextParts.push(text);
+			semanticTextParts.push(text);
+		}
+	}
+	return {
+		plainText: normalizeCommentText(plainTextParts),
+		semanticText: normalizeCommentSemanticText(semanticTextParts),
+		mentions,
+		linkedDocuments,
+		botMentioned
+	};
+}
+function extractReplyText(reply) {
+	if (!reply || !isRecord(reply.content)) return;
+	return parseCommentContentElements({ elements: Array.isArray(reply.content.elements) ? reply.content.elements : [] }).plainText;
+}
+//#endregion
 //#region extensions/feishu/src/chat.ts
 function readChatPageSize(params) {
 	return readPositiveIntegerParam(params, "page_size", {
@@ -292,6 +575,7 @@ function registerFeishuChatTools(api) {
 	if (!resolveAnyEnabledFeishuToolsConfig(accounts).chat) return;
 	api.registerTool((toolContext) => ({
 		name: "feishu_chat",
+		resultContentSource: "network",
 		label: "Feishu Chat",
 		description: "Feishu chat operations. Actions: members, info, member_info",
 		parameters: FeishuChatSchema,
@@ -310,7 +594,7 @@ function registerFeishuChatTools(api) {
 				const client = createFeishuClient(account);
 				switch (p.action) {
 					case "members":
-						if (!p.chat_id) return jsonResult({ error: "chat_id is required for action members" });
+						if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action members" });
 						{
 							const chat = await getAuthorizedFeishuChatInfo({
 								client,
@@ -327,12 +611,12 @@ function registerFeishuChatTools(api) {
 								ctx: toolContext,
 								memberIdType: p.member_id_type
 							});
-							if (authorization.kind === "direct") return jsonResult(buildFeishuDirectChatMembers(authorization));
+							if (authorization.kind === "direct") return feishuExternalToolResult(buildFeishuDirectChatMembers(authorization));
 						}
-						return jsonResult(await getChatMembers(client, p.chat_id, readChatPageSize(rawParams), p.page_token, p.member_id_type));
+						return feishuExternalToolResult(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 getAuthorizedFeishuChatInfo({
+						if (!p.chat_id) return feishuExternalToolResult({ error: "chat_id is required for action info" });
+						return feishuExternalToolResult(await getAuthorizedFeishuChatInfo({
 							client,
 							cfg,
 							account,
@@ -340,8 +624,8 @@ function registerFeishuChatTools(api) {
 							ctx: toolContext
 						}));
 					case "member_info":
-						if (!p.member_id) return jsonResult({ error: "member_id is required for action member_info" });
-						if (!p.chat_id) return jsonResult({ error: "chat_id is required for action 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" });
 						{
 							const chat = await getAuthorizedFeishuChatInfo({
 								client,
@@ -362,27 +646,19 @@ function registerFeishuChatTools(api) {
 							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 feishuExternalToolResult(await getFeishuMemberInfo(client, p.member_id, memberIdType));
 							}
-							return jsonResult(await getFeishuMemberInfo(client, authorization.memberId, authorization.memberIdType));
+							return feishuExternalToolResult(await getFeishuMemberInfo(client, authorization.memberId, authorization.memberIdType));
 						}
-					default: return jsonResult({ error: `Unknown action: ${String(p.action)}` });
+					default: return feishuExternalToolResult({ error: `Unknown action: ${String(p.action)}` });
 				}
 			} catch (err) {
-				return jsonResult({ error: formatFeishuApiError(err, { includeNestedErrorLogId: true }) });
+				return feishuExternalToolResult({ error: formatFeishuApiError(err, { includeNestedErrorLogId: true }) });
 			}
 		}
 	}), { name: "feishu_chat" });
 }
 //#endregion
-//#region extensions/feishu/src/tool-result.ts
-function unknownToolActionResult(action) {
-	return jsonResult({ error: `Unknown action: ${String(action)}` });
-}
-function toolExecutionErrorResult(error) {
-	return jsonResult({ error: formatErrorMessage(error) });
-}
-//#endregion
 //#region extensions/feishu/src/comment-reaction.ts
 const COMMENT_TYPING_REACTION_TYPE = "Typing";
 const COMMENT_REACTION_TIMEOUT_MS = 3e4;
@@ -726,15 +1002,15 @@ function formatDriveApiError(error) {
 	return formatFeishuApiError(error, { includeConfigParams: true });
 }
 function extractDriveApiErrorMeta(error) {
-	if (!isRecord$1(error)) return { message: typeof error === "string" ? error : JSON.stringify(error) };
-	const response = isRecord$1(error.response) ? error.response : void 0;
-	const responseData = isRecord$1(response?.data) ? response?.data : void 0;
+	if (!isRecord(error)) return { message: typeof error === "string" ? error : JSON.stringify(error) };
+	const response = isRecord(error.response) ? error.response : void 0;
+	const responseData = isRecord(response?.data) ? response?.data : void 0;
 	return {
 		message: typeof error.message === "string" ? error.message : typeof error === "string" ? error : JSON.stringify(error),
 		httpStatus: typeof response?.status === "number" ? response.status : void 0,
-		feishuCode: typeof responseData?.code === "number" ? responseData.code : readString(responseData?.code),
-		feishuMsg: readString(responseData?.msg),
-		feishuLogId: readString(responseData?.log_id)
+		feishuCode: typeof responseData?.code === "number" ? responseData.code : readStringValue(responseData?.code),
+		feishuMsg: readStringValue(responseData?.msg),
+		feishuLogId: readStringValue(responseData?.log_id)
 	};
 }
 function isReplyNotAllowedError(error) {
@@ -1013,6 +1289,7 @@ function registerFeishuDriveTools(api) {
 		const defaultAccountId = ctx.agentAccountId;
 		return {
 			name: "feishu_drive",
+			resultContentSource: "network",
 			label: "Feishu Drive",
 			description: "Feishu cloud storage operations. Actions: list, info, create_folder, move, delete, list_comments, list_comment_replies, add_comment, reply_comment",
 			parameters: FeishuDriveSchema,
@@ -1029,21 +1306,21 @@ function registerFeishuDriveTools(api) {
 						}
 					});
 					switch (p.action) {
-						case "list": return jsonResult(await listFolder(client, {
+						case "list": return feishuExternalToolResult(await listFolder(client, {
 							folder_token: p.folder_token,
 							page_size: p.page_size,
 							page_token: p.page_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));
-						case "list_comments": return jsonResult(await listComments(client, applyCommentFileTypeDefault(applyAmbientCommentDefaults(p, ctx), "list_comments")));
-						case "list_comment_replies": return jsonResult(await listCommentReplies(client, applyCommentFileTypeDefault(applyAmbientCommentDefaults(p, ctx), "list_comment_replies")));
+						case "info": return feishuExternalToolResult(await getFileInfo(client, p.file_token, p.type));
+						case "create_folder": return feishuExternalToolResult(await createFolder(client, p.name, p.folder_token));
+						case "move": return feishuExternalToolResult(await moveFile(client, p.file_token, p.type, p.folder_token));
+						case "delete": return feishuExternalToolResult(await deleteFile(client, p.file_token, p.type));
+						case "list_comments": return feishuExternalToolResult(await listComments(client, applyCommentFileTypeDefault(applyAmbientCommentDefaults(p, ctx), "list_comments")));
+						case "list_comment_replies": return feishuExternalToolResult(await listCommentReplies(client, applyCommentFileTypeDefault(applyAmbientCommentDefaults(p, ctx), "list_comment_replies")));
 						case "add_comment": {
 							const resolved = applyAddCommentDefaults(applyAddCommentAmbientDefaults(p, ctx));
 							try {
-								return jsonResult(await addComment(client, resolved));
+								return feishuExternalToolResult(await addComment(client, resolved));
 							} finally {
 								cleanupAmbientCommentTypingReaction({
 									client: getDriveInternalClient(client),
@@ -1054,7 +1331,7 @@ function registerFeishuDriveTools(api) {
 						case "reply_comment": {
 							const resolved = applyCommentFileTypeDefault(applyAmbientCommentDefaults(p, ctx), "reply_comment");
 							try {
-								return jsonResult(await deliverCommentThreadText(client, resolved));
+								return feishuExternalToolResult(await deliverCommentThreadText(client, resolved));
 							} finally {
 								cleanupAmbientCommentTypingReaction({
 									client: getDriveInternalClient(client),
@@ -1072,4 +1349,4 @@ function registerFeishuDriveTools(api) {
 	}, { name: "feishu_drive" });
 }
 //#endregion
-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 };
+export { resolveFeishuToolAccount as C, resolveAnyEnabledFeishuToolsConfig as S, parseFeishuCommentTarget as _, assertFeishuChatMember as a, unknownToolActionResult as b, getChatMembers as c, encodeQuery as d, extractReplyText as f, normalizeCommentFileType as g, buildFeishuCommentTarget as h, createCommentTypingReactionLifecycle as i, getFeishuMemberInfo as l, requestFeishuApi as m, registerFeishuDriveTools as n, buildFeishuDirectChatMembers as o, parseCommentContentElements as p, cleanupAmbientCommentTypingReaction as r, getChatInfo as s, deliverCommentThreadText as t, registerFeishuChatTools as u, feishuExternalToolResult as v, resolveToolsConfig as w, createFeishuToolClient as x, toolExecutionErrorResult as y };