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

package/skills/feishu-wiki/SKILL.md

@@ -1,122 +1,26 @@
 ---
 name: feishu-wiki
 description: |
-  Feishu knowledge base navigation. Activate when user mentions knowledge base, wiki, or wiki links.
+  Feishu knowledge-base navigation workflows. Activate when the user mentions a knowledge base, wiki, or wiki link.
 ---
 
-# Feishu Wiki Tool
+# Feishu wiki
 
-Single tool `feishu_wiki` for knowledge base operations.
+Use the single `feishu_wiki` tool and its current action schema.
 
-Wiki `space_id` values are opaque strings. Always keep them quoted in tool calls, even when they contain only digits; passing a long numeric-looking ID as a number can corrupt the suffix due to JavaScript number precision limits.
+From `https://example.feishu.cn/wiki/ABC123def`, use `ABC123def` as `token`. Treat every `space_id` as an opaque quoted string, even when it contains only digits.
 
-## Token Extraction
+## Navigate
 
-From URL `https://xxx.feishu.cn/wiki/ABC123def` → `token` = `ABC123def`
+- Use `spaces` to enumerate accessible knowledge spaces and `nodes` for a space or parent node.
+- Continue pagination with the returned `page_token` while `has_more` is true, keeping the same space and parent.
+- Use `search` when the user provides a query but not an exact node.
+- Use `get` to resolve a wiki token to its `node_token`, `obj_token`, and `obj_type`.
 
-## Actions
+## Create and organize
 
-### List Knowledge Spaces
+Wiki creation supports only `docx`, `sheet`, and `bitable`; `docx` is the default. Resolve an exact space and parent before create, move, or rename operations, and confirm ambiguous or destructive reorganizations.
 
-```json
-{ "action": "spaces" }
-```
+## Wiki content workflow
 
-Returns one page of accessible wiki spaces plus `has_more` and `page_token`.
-Continue with the returned `page_token` while `has_more` is true:
-
-```json
-{ "action": "spaces", "page_token": "next-page-token" }
-```
-
-### List Nodes
-
-```json
-{ "action": "nodes", "space_id": "7xxx" }
-```
-
-With parent:
-
-```json
-{ "action": "nodes", "space_id": "7xxx", "parent_node_token": "wikcnXXX" }
-```
-
-Returns one page of nodes plus `has_more` and `page_token`. Continue with the
-same `space_id` and `parent_node_token`, adding the returned `page_token`, while
-`has_more` is true. Both list actions accept optional `page_size` from 1 to 50.
-
-### Get Node Details
-
-```json
-{ "action": "get", "token": "ABC123def" }
-```
-
-Returns: `node_token`, `obj_token`, `obj_type`, etc. Use `obj_token` with `feishu_doc` to read/write the document.
-
-### Create Node
-
-```json
-{ "action": "create", "space_id": "7xxx", "title": "New Page" }
-```
-
-With type and parent:
-
-```json
-{
-  "action": "create",
-  "space_id": "7xxx",
-  "title": "Sheet",
-  "obj_type": "sheet",
-  "parent_node_token": "wikcnXXX"
-}
-```
-
-`obj_type`: `docx` (default), `sheet`, `bitable`, `mindnote`, `file`, `doc`, `slides`
-
-### Move Node
-
-```json
-{ "action": "move", "space_id": "7xxx", "node_token": "wikcnXXX" }
-```
-
-To different location:
-
-```json
-{
-  "action": "move",
-  "space_id": "7xxx",
-  "node_token": "wikcnXXX",
-  "target_space_id": "7yyy",
-  "target_parent_token": "wikcnYYY"
-}
-```
-
-### Rename Node
-
-```json
-{ "action": "rename", "space_id": "7xxx", "node_token": "wikcnXXX", "title": "New Title" }
-```
-
-## Wiki-Doc Workflow
-
-To edit a wiki page:
-
-1. Get node: `{ "action": "get", "token": "wiki_token" }` → returns `obj_token`
-2. Read doc: `feishu_doc { "action": "read", "doc_token": "obj_token" }`
-3. Write doc: `feishu_doc { "action": "write", "doc_token": "obj_token", "content": "..." }`
-
-## Configuration
-
-```yaml
-channels:
-  feishu:
-    tools:
-      wiki: true # default: true
-      doc: true # required - wiki content uses feishu_doc
-```
-
-**Dependency:** This tool requires `feishu_doc` to be enabled. Wiki pages are documents - use `feishu_wiki` to navigate, then `feishu_doc` to read/edit content.
-
-## Permissions
-
-Required: `wiki:wiki` or `wiki:wiki:readonly`
+Wiki navigation is independent of the document tool. When `get` returns a `docx` object, use its `obj_token` as `doc_token` with `feishu_doc` to read or edit the page. Other object types require a currently available tool that supports that type; do not treat them as documents.

package/dist/accounts-u9X5Wsan.js

@@ -1,469 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { isRecord, normalizeOptionalString, normalizeStringEntries, readStringValue } 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";
-import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
-//#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}` : "";
-}
-const readString = readStringValue;
-const normalizeString = normalizeOptionalString;
-const isRecord$1 = isRecord;
-function formatFeishuApiError(error, options = {}) {
-	if (!isRecord$1(error)) return typeof error === "string" ? error : JSON.stringify(error);
-	const config = isRecord$1(error.config) ? error.config : void 0;
-	const response = isRecord$1(error.response) ? error.response : void 0;
-	const responseData = isRecord$1(response?.data) ? response?.data : void 0;
-	const feishuLogId = readString(responseData?.log_id) || (options.includeNestedErrorLogId ? readString(isRecord$1(responseData?.error) ? responseData.error.log_id : void 0) : void 0);
-	const nestedError = isRecord$1(responseData?.error) ? responseData.error : void 0;
-	return JSON.stringify({
-		message: typeof error.message === "string" ? error.message : typeof error === "string" ? error : JSON.stringify(error),
-		code: readString(error.code),
-		method: readString(config?.method),
-		url: readString(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 : readString(responseData?.code),
-		feishu_msg: readString(responseData?.msg),
-		feishu_log_id: feishuLogId,
-		feishu_troubleshooter: readString(responseData?.troubleshooter) || readString(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$1(element.docs_link) ? element.docs_link : void 0;
-	return normalizeString(docsLink?.url) || normalizeString(docsLink?.link) || normalizeString(element.url) || normalizeString(element.link) || void 0;
-}
-function readMentionUserId(element) {
-	const mention = isRecord$1(element.mention) ? element.mention : void 0;
-	const person = isRecord$1(element.person) ? element.person : void 0;
-	return normalizeString(person?.user_id) || normalizeString(mention?.user_id) || normalizeString(mention?.open_id) || normalizeString(element.mention_user) || normalizeString(element.user_id) || void 0;
-}
-function readMentionDisplayText(element, userId) {
-	const mention = isRecord$1(element.mention) ? element.mention : void 0;
-	const mentionName = normalizeString(mention?.name) || normalizeString(mention?.display_name) || normalizeString(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$1(element.text_run) ? readString(element.text_run.content) || readString(element.text_run.text) : void 0) || readString(element.text) || readString(element.content) || readString(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 = normalizeString(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) => normalizeString(value)).filter((value) => Boolean(value)));
-	const linkedDocumentKeys = /* @__PURE__ */ new Set();
-	let botMentioned = false;
-	for (const rawElement of elements) {
-		if (!isRecord$1(rawElement)) continue;
-		const element = rawElement;
-		const type = normalizeString(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$1(reply.content)) return;
-	return parseCommentContentElements({ elements: Array.isArray(reply.content.elements) ? reply.content.elements : [] }).plainText;
-}
-//#endregion
-//#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 = normalizeString(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 = normalizeString(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
-		}) : normalizeString(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 { normalizeCommentFileType as _, resolveDefaultFeishuAccountId as a, encodeQuery as c, isRecord$1 as d, normalizeString as f, buildFeishuCommentTarget as g, requestFeishuApi as h, listFeishuAccountIds as i, extractReplyText as l, readString as m, inspectFeishuCredentials as n, resolveFeishuAccount as o, parseCommentContentElements as p, listEnabledFeishuAccounts as r, resolveFeishuRuntimeAccount as s, accounts_exports as t, formatFeishuApiError as u, parseFeishuCommentTarget as v };