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

package/dist/accounts-CCCdMen2.js

@@ -0,0 +1,203 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId, normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { coerceSecretRef } from "openclaw/plugin-sdk/provider-auth";
+//#region extensions/feishu/src/accounts.ts
+var accounts_exports = /* @__PURE__ */ __exportAll({
+	FeishuSecretRefUnavailableError: () => FeishuSecretRefUnavailableError,
+	inspectFeishuCredentials: () => inspectFeishuCredentials,
+	listEnabledFeishuAccounts: () => listEnabledFeishuAccounts,
+	listFeishuAccountIds: () => listFeishuAccountIds,
+	resolveDefaultFeishuAccountId: () => resolveDefaultFeishuAccountId,
+	resolveDefaultFeishuAccountSelection: () => resolveDefaultFeishuAccountSelection,
+	resolveFeishuAccount: () => resolveFeishuAccount,
+	resolveFeishuCredentials: () => resolveFeishuCredentials,
+	resolveFeishuRuntimeAccount: () => resolveFeishuRuntimeAccount
+});
+const { listAccountIds: listFeishuAccountIds, resolveDefaultAccountId, resolveAccountConfig: resolveMergedFeishuAccountConfig } = createAccountListHelpers("feishu", {
+	allowUnlistedDefaultAccount: true,
+	omitKeys: ["defaultAccount"],
+	nestedObjectKeys: ["tools"],
+	hasImplicitDefaultAccount: (cfg) => {
+		const feishu = cfg.channels?.feishu;
+		return hasConfiguredAccountValue(feishu?.appId) && hasConfiguredAccountValue(feishu?.appSecret);
+	}
+});
+function formatSecretRefLabel(ref) {
+	return `${ref.source}:${ref.provider}:${ref.id}`;
+}
+var FeishuSecretRefUnavailableError = class extends Error {
+	constructor(path, ref) {
+		super(`${path}: unresolved SecretRef "${formatSecretRefLabel(ref)}". Resolve this command against an active gateway runtime snapshot before reading it.`);
+		this.name = "FeishuSecretRefUnavailableError";
+		this.path = path;
+	}
+};
+function resolveFeishuSecretLike(params) {
+	const asString = normalizeOptionalString(params.value);
+	if (asString) return asString;
+	const ref = coerceSecretRef(params.value);
+	if (!ref) return;
+	if (params.mode === "inspect") {
+		if (params.allowEnvSecretRefRead && ref.source === "env") {
+			const envValue = normalizeOptionalString(process.env[ref.id]);
+			if (envValue) return envValue;
+		}
+		return;
+	}
+	throw new FeishuSecretRefUnavailableError(params.path, ref);
+}
+function resolveFeishuBaseCredentials(cfg, mode) {
+	const appId = resolveFeishuSecretLike({
+		value: cfg?.appId,
+		path: "channels.feishu.appId",
+		mode,
+		allowEnvSecretRefRead: true
+	});
+	const appSecret = resolveFeishuSecretLike({
+		value: cfg?.appSecret,
+		path: "channels.feishu.appSecret",
+		mode,
+		allowEnvSecretRefRead: true
+	});
+	if (!appId || !appSecret) return null;
+	return {
+		appId,
+		appSecret,
+		domain: cfg?.domain ?? "feishu"
+	};
+}
+function resolveFeishuEventSecrets(cfg, mode) {
+	return {
+		encryptKey: (cfg?.connectionMode ?? "websocket") === "webhook" ? resolveFeishuSecretLike({
+			value: cfg?.encryptKey,
+			path: "channels.feishu.encryptKey",
+			mode,
+			allowEnvSecretRefRead: true
+		}) : normalizeOptionalString(cfg?.encryptKey),
+		verificationToken: resolveFeishuSecretLike({
+			value: cfg?.verificationToken,
+			path: "channels.feishu.verificationToken",
+			mode,
+			allowEnvSecretRefRead: true
+		})
+	};
+}
+/**
+* Resolve the default account selection and its source.
+*/
+function resolveDefaultFeishuAccountSelection(cfg) {
+	const preferred = normalizeOptionalAccountId((cfg.channels?.feishu)?.defaultAccount);
+	if (preferred) return {
+		accountId: preferred,
+		source: "explicit-default"
+	};
+	const ids = listFeishuAccountIds(cfg);
+	if (ids.includes(DEFAULT_ACCOUNT_ID)) return {
+		accountId: DEFAULT_ACCOUNT_ID,
+		source: "mapped-default"
+	};
+	return {
+		accountId: ids[0] ?? DEFAULT_ACCOUNT_ID,
+		source: "fallback"
+	};
+}
+/**
+* Resolve the default account ID.
+*/
+function resolveDefaultFeishuAccountId(cfg) {
+	return resolveDefaultAccountId(cfg);
+}
+/**
+* Merge top-level config with account-specific config.
+* Account-specific fields override top-level fields.
+*/
+function mergeFeishuAccountConfig(cfg, accountId) {
+	const feishuCfg = cfg.channels?.feishu;
+	const merged = resolveMergedFeishuAccountConfig(cfg, accountId);
+	const topTools = feishuCfg?.tools;
+	if (merged.tools === void 0 && topTools !== void 0) return {
+		...merged,
+		tools: topTools
+	};
+	if (topTools?.bitable === false) return {
+		...merged,
+		tools: {
+			...merged.tools,
+			bitable: false
+		}
+	};
+	return merged;
+}
+function resolveFeishuCredentials(cfg, options) {
+	const mode = options?.mode ?? (options?.allowUnresolvedSecretRef ? "inspect" : "strict");
+	const base = resolveFeishuBaseCredentials(cfg, mode);
+	if (!base) return null;
+	const eventSecrets = resolveFeishuEventSecrets(cfg, mode);
+	return {
+		...base,
+		...eventSecrets
+	};
+}
+function inspectFeishuCredentials(cfg) {
+	return resolveFeishuCredentials(cfg, { mode: "inspect" });
+}
+function buildResolvedFeishuAccount(params) {
+	const hasExplicitAccountId = typeof params.accountId === "string" && params.accountId.trim() !== "";
+	const defaultSelection = hasExplicitAccountId ? null : resolveDefaultFeishuAccountSelection(params.cfg);
+	const accountId = hasExplicitAccountId ? normalizeAccountId(params.accountId) : defaultSelection?.accountId ?? DEFAULT_ACCOUNT_ID;
+	const selectionSource = hasExplicitAccountId ? "explicit" : defaultSelection?.source ?? "fallback";
+	const baseEnabled = (params.cfg.channels?.feishu)?.enabled !== false;
+	const merged = mergeFeishuAccountConfig(params.cfg, accountId);
+	const accountEnabled = merged.enabled !== false;
+	const enabled = baseEnabled && accountEnabled;
+	const baseCreds = resolveFeishuBaseCredentials(merged, params.baseMode);
+	const eventSecrets = resolveFeishuEventSecrets(merged, params.eventSecretMode);
+	const accountName = merged.name;
+	return {
+		accountId,
+		selectionSource,
+		enabled,
+		configured: Boolean(baseCreds),
+		name: typeof accountName === "string" ? accountName.trim() || void 0 : void 0,
+		appId: baseCreds?.appId,
+		appSecret: baseCreds?.appSecret,
+		encryptKey: eventSecrets.encryptKey,
+		verificationToken: eventSecrets.verificationToken,
+		domain: baseCreds?.domain ?? "feishu",
+		config: merged
+	};
+}
+/**
+* Resolve a read-only Feishu account snapshot for CLI/config surfaces.
+* Unresolved SecretRefs are treated as unavailable instead of throwing.
+*/
+function resolveFeishuAccount(params) {
+	return buildResolvedFeishuAccount({
+		...params,
+		baseMode: "inspect",
+		eventSecretMode: "inspect"
+	});
+}
+/**
+* Resolve a runtime Feishu account.
+* Required app credentials stay strict; event-only secrets can be required by callers.
+*/
+function resolveFeishuRuntimeAccount(params, options) {
+	return buildResolvedFeishuAccount({
+		...params,
+		baseMode: "strict",
+		eventSecretMode: options?.requireEventSecrets ? "strict" : "inspect"
+	});
+}
+/**
+* List all enabled and configured accounts.
+*/
+function listEnabledFeishuAccounts(cfg) {
+	return listFeishuAccountIds(cfg).map((accountId) => resolveFeishuAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled && account.configured);
+}
+//#endregion
+export { resolveDefaultFeishuAccountId as a, listFeishuAccountIds as i, inspectFeishuCredentials as n, resolveFeishuAccount as o, listEnabledFeishuAccounts as r, resolveFeishuRuntimeAccount as s, accounts_exports as t };

package/dist/api.js

@@ -1,19 +1,18 @@
-import { r as listEnabledFeishuAccounts } from "./accounts-u9X5Wsan.js";
-import { a as setFeishuNamedAccountEnabled, i as feishuSetupAdapter, n as feishuSetupWizard, r as runFeishuLogin, t as feishuPlugin } from "./channel-CScE82zY.js";
-import { p as parseFeishuMarkdown, u as chunkFeishuMarkdown } from "./send-result-B9_BpUPx.js";
-import { a as parseFeishuTargetId, i as parseFeishuDirectConversationId, n as buildFeishuModelOverrideParentCandidates, r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-BeJL-wq7.js";
-import { r as createFeishuClient, s as resolveConfiguredHttpTimeoutMs } from "./client-Dcbs6vml.js";
+import { r as listEnabledFeishuAccounts } from "./accounts-CCCdMen2.js";
+import { a as setFeishuNamedAccountEnabled, i as feishuSetupAdapter, n as feishuSetupWizard, r as runFeishuLogin, t as feishuPlugin } from "./channel-Ceq80_zP.js";
+import { p as parseFeishuMarkdown, u as chunkFeishuMarkdown } from "./send-result-DEAycmOk.js";
+import { a as parseFeishuTargetId, i as parseFeishuDirectConversationId, n as buildFeishuModelOverrideParentCandidates, r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-VYgGQ-GX.js";
+import { s as resolveConfiguredHttpTimeoutMs } from "./client-Hp7uo_cl.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
-import { a as toolExecutionErrorResult, f as registerFeishuChatTools, g as resolveToolsConfig, h as resolveFeishuToolAccount, m as resolveAnyEnabledFeishuToolsConfig, n as registerFeishuDriveTools, o as unknownToolActionResult, p as createFeishuToolClient } from "./drive-hSi_Utp0.js";
-import { n as getFeishuThreadBindingManager, r as testing, t as createFeishuThreadBindingManager } from "./thread-bindings-N3wkgkIN.js";
-import { n as handleFeishuSubagentEnded, r as handleFeishuSubagentSpawning, t as handleFeishuSubagentDeliveryTarget } from "./subagent-hooks-Cx1cX7rW.js";
+import { C as resolveFeishuToolAccount, S as resolveAnyEnabledFeishuToolsConfig, b as unknownToolActionResult, n as registerFeishuDriveTools, u as registerFeishuChatTools, v as feishuExternalToolResult, x as createFeishuToolClient, y as toolExecutionErrorResult } from "./drive-BVYM_Y4k.js";
+import { n as getFeishuThreadBindingManager, t as createFeishuThreadBindingManager } from "./thread-bindings-CptM_YU6.js";
+import { n as handleFeishuSubagentEnded, t as handleFeishuSubagentDeliveryTarget } from "./subagent-hooks-KUi-7vUy.js";
 import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, readStringValue, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, isAbsolute, resolve } from "node:path";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
 import { canonicalizeBase64, estimateBase64DecodedBytes, extensionForMime } from "openclaw/plugin-sdk/media-runtime";
 import { readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
@@ -1584,42 +1583,43 @@ function registerFeishuDocTools(api) {
 			const trustedRequesterOpenId = ctx.messageChannel === "feishu" ? normalizeOptionalString(ctx.requesterSenderId) : void 0;
 			return {
 				name: "feishu_doc",
+				resultContentSource: "network",
 				label: "Feishu Doc",
 				description: "Feishu document operations. Actions: read, write, append, insert, create, list_blocks, get_block, update_block, delete_block, create_table, write_table_cells, create_table_with_values, insert_table_row, insert_table_column, delete_table_rows, delete_table_columns, merge_table_cells, upload_image, upload_file, color_text",
 				parameters: FeishuDocSchema,
 				async execute(_toolCallId, params) {
 					const p = params;
 					try {
-						if (p.action === "create" && Object.hasOwn(p, "content")) return jsonResult({ error: "Feishu document creation does not support content. Call action \"create\" first, then call action \"write\" with the returned document_id as doc_token." });
+						if (p.action === "create" && Object.hasOwn(p, "content")) return feishuExternalToolResult({ error: "Feishu document creation does not support content. Call action \"create\" first, then call action \"write\" with the returned document_id as doc_token." });
 						const client = getClient(p, defaultAccountId);
 						switch (p.action) {
-							case "read": return jsonResult(await readDoc(client, p.doc_token));
-							case "write": return jsonResult(await writeDoc(client, p.doc_token, p.content, getMediaMaxBytes(p, defaultAccountId), getImageReadTimeoutMs(p, defaultAccountId), api.logger));
-							case "append": return jsonResult(await appendDoc(client, p.doc_token, p.content, getMediaMaxBytes(p, defaultAccountId), getImageReadTimeoutMs(p, defaultAccountId), api.logger));
-							case "insert": return jsonResult(await insertDoc(client, p.doc_token, p.content, p.after_block_id, getMediaMaxBytes(p, defaultAccountId), getImageReadTimeoutMs(p, defaultAccountId), api.logger));
-							case "create": return jsonResult(await createDoc(client, p.title, p.folder_token, {
+							case "read": return feishuExternalToolResult(await readDoc(client, p.doc_token));
+							case "write": return feishuExternalToolResult(await writeDoc(client, p.doc_token, p.content, getMediaMaxBytes(p, defaultAccountId), getImageReadTimeoutMs(p, defaultAccountId), api.logger));
+							case "append": return feishuExternalToolResult(await appendDoc(client, p.doc_token, p.content, getMediaMaxBytes(p, defaultAccountId), getImageReadTimeoutMs(p, defaultAccountId), api.logger));
+							case "insert": return feishuExternalToolResult(await insertDoc(client, p.doc_token, p.content, p.after_block_id, getMediaMaxBytes(p, defaultAccountId), getImageReadTimeoutMs(p, defaultAccountId), api.logger));
+							case "create": return feishuExternalToolResult(await createDoc(client, p.title, p.folder_token, {
 								grantToRequester: p.grant_to_requester,
 								requesterOpenId: trustedRequesterOpenId
 							}));
-							case "list_blocks": return jsonResult(await listBlocks(client, p.doc_token));
-							case "get_block": return jsonResult(await getBlock(client, p.doc_token, p.block_id));
-							case "update_block": return jsonResult(await updateBlock(client, p.doc_token, p.block_id, p.content));
-							case "delete_block": return jsonResult(await deleteBlock(client, p.doc_token, p.block_id));
-							case "create_table": return jsonResult(await createTable(client, p.doc_token, p.row_size, p.column_size, p.parent_block_id, p.column_width));
-							case "write_table_cells": return jsonResult(await writeTableCells(client, p.doc_token, p.table_block_id, p.values));
-							case "create_table_with_values": return jsonResult(await createTableWithValues(client, p.doc_token, p.row_size, p.column_size, p.values, p.parent_block_id, p.column_width));
-							case "upload_image": return jsonResult(await uploadImageBlock(client, p.doc_token, getMediaMaxBytes(p, defaultAccountId), getImageReadTimeoutMs(p, defaultAccountId), mediaLocalRoots, p.url, p.file_path, p.parent_block_id, p.filename, p.index, p.image));
-							case "upload_file": return jsonResult(await uploadFileBlock(client, p.doc_token, getMediaMaxBytes(p, defaultAccountId), mediaLocalRoots, p.url, p.file_path, p.parent_block_id, p.filename));
-							case "color_text": return jsonResult(await updateColorText(client, p.doc_token, p.block_id, p.content));
-							case "insert_table_row": return jsonResult(await insertTableRow(client, p.doc_token, p.block_id, p.row_index));
-							case "insert_table_column": return jsonResult(await insertTableColumn(client, p.doc_token, p.block_id, p.column_index));
-							case "delete_table_rows": return jsonResult(await deleteTableRows(client, p.doc_token, p.block_id, p.row_start, p.row_count));
-							case "delete_table_columns": return jsonResult(await deleteTableColumns(client, p.doc_token, p.block_id, p.column_start, p.column_count));
-							case "merge_table_cells": return jsonResult(await mergeTableCells(client, p.doc_token, p.block_id, p.row_start, p.row_end, p.column_start, p.column_end));
-							default: return jsonResult({ error: "Unknown action" });
+							case "list_blocks": return feishuExternalToolResult(await listBlocks(client, p.doc_token));
+							case "get_block": return feishuExternalToolResult(await getBlock(client, p.doc_token, p.block_id));
+							case "update_block": return feishuExternalToolResult(await updateBlock(client, p.doc_token, p.block_id, p.content));
+							case "delete_block": return feishuExternalToolResult(await deleteBlock(client, p.doc_token, p.block_id));
+							case "create_table": return feishuExternalToolResult(await createTable(client, p.doc_token, p.row_size, p.column_size, p.parent_block_id, p.column_width));
+							case "write_table_cells": return feishuExternalToolResult(await writeTableCells(client, p.doc_token, p.table_block_id, p.values));
+							case "create_table_with_values": return feishuExternalToolResult(await createTableWithValues(client, p.doc_token, p.row_size, p.column_size, p.values, p.parent_block_id, p.column_width));
+							case "upload_image": return feishuExternalToolResult(await uploadImageBlock(client, p.doc_token, getMediaMaxBytes(p, defaultAccountId), getImageReadTimeoutMs(p, defaultAccountId), mediaLocalRoots, p.url, p.file_path, p.parent_block_id, p.filename, p.index, p.image));
+							case "upload_file": return feishuExternalToolResult(await uploadFileBlock(client, p.doc_token, getMediaMaxBytes(p, defaultAccountId), mediaLocalRoots, p.url, p.file_path, p.parent_block_id, p.filename));
+							case "color_text": return feishuExternalToolResult(await updateColorText(client, p.doc_token, p.block_id, p.content));
+							case "insert_table_row": return feishuExternalToolResult(await insertTableRow(client, p.doc_token, p.block_id, p.row_index));
+							case "insert_table_column": return feishuExternalToolResult(await insertTableColumn(client, p.doc_token, p.block_id, p.column_index));
+							case "delete_table_rows": return feishuExternalToolResult(await deleteTableRows(client, p.doc_token, p.block_id, p.row_start, p.row_count));
+							case "delete_table_columns": return feishuExternalToolResult(await deleteTableColumns(client, p.doc_token, p.block_id, p.column_start, p.column_count));
+							case "merge_table_cells": return feishuExternalToolResult(await mergeTableCells(client, p.doc_token, p.block_id, p.row_start, p.row_end, p.column_start, p.column_end));
+							default: return feishuExternalToolResult({ error: "Unknown action" });
 						}
 					} catch (err) {
-						return jsonResult({ error: formatErrorMessage(err) });
+						return feishuExternalToolResult({ error: formatErrorMessage(err) });
 					}
 				}
 			};
@@ -1629,12 +1629,13 @@ function registerFeishuDocTools(api) {
 	if (toolsCfg.scopes) {
 		api.registerTool((ctx) => ({
 			name: "feishu_app_scopes",
+			resultContentSource: "network",
 			label: "Feishu App Scopes",
 			description: "List current app permissions (scopes). Use to debug permission issues or check available capabilities.",
 			parameters: Type.Object({}),
 			async execute() {
 				try {
-					return jsonResult(await listAppScopes(createFeishuToolClient({
+					return feishuExternalToolResult(await listAppScopes(createFeishuToolClient({
 						api,
 						defaultAccountId: ctx.agentAccountId,
 						requiredTool: {
@@ -1643,7 +1644,7 @@ function registerFeishuDocTools(api) {
 						}
 					})));
 				} catch (err) {
-					return jsonResult({ error: formatErrorMessage(err) });
+					return feishuExternalToolResult({ error: formatErrorMessage(err) });
 				}
 			}
 		}), { name: "feishu_app_scopes" });
@@ -1843,6 +1844,7 @@ function registerFeishuWikiTools(api) {
 		const defaultAccountId = ctx.agentAccountId;
 		return {
 			name: "feishu_wiki",
+			resultContentSource: "network",
 			label: "Feishu Wiki",
 			description: "Feishu knowledge base operations. Actions: spaces, nodes, get, create, move, rename",
 			parameters: FeishuWikiSchema,
@@ -1859,27 +1861,27 @@ function registerFeishuWikiTools(api) {
 						}
 					});
 					switch (p.action) {
-						case "spaces": return jsonResult(await listSpaces(createClient(), readWikiPageSize(p), p.page_token));
+						case "spaces": return feishuExternalToolResult(await listSpaces(createClient(), readWikiPageSize(p), p.page_token));
 						case "nodes": {
 							const spaceId = requireWikiSpaceId(p.space_id, "space_id");
-							return jsonResult(await listNodes(createClient(), spaceId, p.parent_node_token, readWikiPageSize(p), p.page_token));
+							return feishuExternalToolResult(await listNodes(createClient(), spaceId, p.parent_node_token, readWikiPageSize(p), p.page_token));
 						}
-						case "get": return jsonResult(await getNode(createClient(), p.token));
+						case "get": return feishuExternalToolResult(await getNode(createClient(), p.token));
 						case "search":
 							optionalWikiSpaceId(p.space_id, "space_id");
 							createClient();
-							return jsonResult({ error: "Search is not available. Use feishu_wiki with action: 'nodes' to browse or action: 'get' to lookup by token." });
+							return feishuExternalToolResult({ error: "Search is not available. Use feishu_wiki with action: 'nodes' to browse or action: 'get' to lookup by token." });
 						case "create": {
 							const spaceId = requireWikiSpaceId(p.space_id, "space_id");
-							return jsonResult(await createNode(createClient(), spaceId, p.title, p.obj_type, p.parent_node_token));
+							return feishuExternalToolResult(await createNode(createClient(), spaceId, p.title, p.obj_type, p.parent_node_token));
 						}
 						case "move": {
 							const spaceId = requireWikiSpaceId(p.space_id, "space_id");
-							return jsonResult(await moveNode(createClient(), spaceId, p.node_token, optionalWikiSpaceId(p.target_space_id, "target_space_id"), p.target_parent_token));
+							return feishuExternalToolResult(await moveNode(createClient(), spaceId, p.node_token, optionalWikiSpaceId(p.target_space_id, "target_space_id"), p.target_parent_token));
 						}
 						case "rename": {
 							const spaceId = requireWikiSpaceId(p.space_id, "space_id");
-							return jsonResult(await renameNode(createClient(), spaceId, p.node_token, p.title));
+							return feishuExternalToolResult(await renameNode(createClient(), spaceId, p.node_token, p.title));
 						}
 						default: return unknownToolActionResult(p.action);
 					}
@@ -1994,6 +1996,7 @@ function registerFeishuPermTools(api) {
 		const defaultAccountId = ctx.agentAccountId;
 		return {
 			name: "feishu_perm",
+			resultContentSource: "network",
 			label: "Feishu Perm",
 			description: "Feishu permission management. Actions: list, add, remove",
 			parameters: FeishuPermSchema,
@@ -2010,9 +2013,9 @@ function registerFeishuPermTools(api) {
 						}
 					});
 					switch (p.action) {
-						case "list": return jsonResult(await listMembers(client, p.token, p.type));
-						case "add": return jsonResult(await addMember(client, p.token, p.type, p.member_type, p.member_id, p.perm));
-						case "remove": return jsonResult(await removeMember(client, p.token, p.type, p.member_type, p.member_id));
+						case "list": return feishuExternalToolResult(await listMembers(client, p.token, p.type));
+						case "add": return feishuExternalToolResult(await addMember(client, p.token, p.type, p.member_type, p.member_id, p.perm));
+						case "remove": return feishuExternalToolResult(await removeMember(client, p.token, p.type, p.member_type, p.member_id));
 						default: return unknownToolActionResult(p.action);
 					}
 				} catch (err) {
@@ -2437,29 +2440,30 @@ function registerFeishuBitableTools(api) {
 	const accounts = listEnabledFeishuAccounts(api.config);
 	if (accounts.length === 0) return;
 	if (!resolveAnyEnabledFeishuToolsConfig(accounts).bitable) return;
-	const getClient = (params, defaultAccountId) => {
-		const account = resolveFeishuToolAccount({
-			api,
-			executeParams: params,
-			defaultAccountId
-		});
-		if (!resolveToolsConfig(account.config.tools).bitable) throw new Error(`Feishu Bitable tools are disabled for account "${account.accountId}"`);
-		return createFeishuClient(account);
-	};
+	const getClient = (params, defaultAccountId) => createFeishuToolClient({
+		api,
+		executeParams: params,
+		defaultAccountId,
+		requiredTool: {
+			family: "bitable",
+			label: "Bitable"
+		}
+	});
 	const registerBitableTool = (params) => {
 		api.registerTool((ctx) => ({
 			name: params.name,
+			resultContentSource: "network",
 			label: params.label,
 			description: params.description,
 			parameters: params.parameters,
 			async execute(_toolCallId, rawParams) {
 				try {
-					return jsonResult(await params.execute({
+					return feishuExternalToolResult(await params.execute({
 						params: rawParams,
 						defaultAccountId: ctx.agentAccountId
 					}));
 				} catch (err) {
-					return jsonResult({ error: formatErrorMessage(err) });
+					return feishuExternalToolResult({ error: formatErrorMessage(err) });
 				}
 			}
 		}), { name: params.name });
@@ -2541,7 +2545,4 @@ function registerFeishuBitableTools(api) {
 	});
 }
 //#endregion
-//#region extensions/feishu/api.ts
-const feishuSessionBindingAdapterChannels = ["feishu"];
-//#endregion
-export { testing as __testing, testing as feishuThreadBindingTesting, testing, buildFeishuConversationId, buildFeishuModelOverrideParentCandidates, createClackPrompter, createFeishuThreadBindingManager, feishuPlugin, feishuSessionBindingAdapterChannels, feishuSetupAdapter, feishuSetupWizard, getFeishuThreadBindingManager, handleFeishuSubagentDeliveryTarget, handleFeishuSubagentEnded, handleFeishuSubagentSpawning, parseFeishuConversationId, parseFeishuDirectConversationId, parseFeishuTargetId, registerFeishuBitableTools, registerFeishuChatTools, registerFeishuDocTools, registerFeishuDriveTools, registerFeishuPermTools, registerFeishuWikiTools, runFeishuLogin, setFeishuNamedAccountEnabled };
+export { buildFeishuConversationId, buildFeishuModelOverrideParentCandidates, createClackPrompter, createFeishuThreadBindingManager, feishuPlugin, feishuSetupAdapter, feishuSetupWizard, getFeishuThreadBindingManager, handleFeishuSubagentDeliveryTarget, handleFeishuSubagentEnded, parseFeishuConversationId, parseFeishuDirectConversationId, parseFeishuTargetId, registerFeishuBitableTools, registerFeishuChatTools, registerFeishuDocTools, registerFeishuDriveTools, registerFeishuPermTools, registerFeishuWikiTools, runFeishuLogin, setFeishuNamedAccountEnabled };