@openclaw/feishu 2026.7.2-beta.7 → 2026.7.34

package/dist/api.js

@@ -1,21 +1,19 @@
-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 { 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 { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
+import { r as listEnabledFeishuAccounts } from "./.setup/accounts-CfuPSCip.mjs";
+import { a as setFeishuNamedAccountEnabled, i as feishuSetupAdapter, n as feishuSetupWizard, r as runFeishuLogin, t as feishuPlugin } from "./.setup/channel-CiFS4inh.mjs";
+import { a as parseFeishuTargetId, i as parseFeishuDirectConversationId, n as buildFeishuModelOverrideParentCandidates, r as parseFeishuConversationId, t as buildFeishuConversationId } from "./.setup/conversation-id-CdLdoot3.mjs";
+import { t as getFeishuRuntime } from "./.setup/runtime-C5JxBWZp.mjs";
+import { a as toolExecutionErrorResult, d as createFeishuToolClient, f as resolveAnyEnabledFeishuToolsConfig, n as registerFeishuDriveTools, o as unknownToolActionResult, p as resolveFeishuToolAccount, u as registerFeishuChatTools } from "./.setup/drive-Cy1tmfSn.mjs";
+import { n as getFeishuThreadBindingManager, r as testing, t as createFeishuThreadBindingManager } from "./.setup/thread-bindings-V0bwk0A1.mjs";
+import { n as handleFeishuSubagentEnded, r as handleFeishuSubagentSpawning, t as handleFeishuSubagentDeliveryTarget } from "./.setup/subagent-hooks-BQhuBlyy.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, readStringValue, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
 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 { extensionForMime } from "openclaw/plugin-sdk/media-mime";
 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";
 import { createClackPrompter } from "openclaw/plugin-sdk/setup-runtime";
 //#region extensions/feishu/src/doc-schema.ts
@@ -233,7 +231,7 @@ function calculateAdaptiveColumnWidths(blocks, tableBlockId) {
 		const cellId = cellIds[row * column_size + col];
 		if (cellId) {
 			const length = getWeightedLength(getCellText(cellId));
-			maxLengths[col] = Math.max(maxLengths[col] ?? 0, length);
+			maxLengths[col] = Math.max(maxLengths[col], length);
 		}
 	}
 	const totalLength = maxLengths.reduce((a, b) => a + b, 0);
@@ -253,10 +251,8 @@ function calculateAdaptiveColumnWidths(blocks, tableBlockId) {
 		const perColumn = Math.floor(remaining / growable.length);
 		if (perColumn === 0) break;
 		for (const i of growable) {
-			const width = widths[i];
-			if (width === void 0) continue;
-			const add = Math.min(perColumn, MAX_COLUMN_WIDTH - width);
-			widths[i] = width + add;
+			const add = Math.min(perColumn, MAX_COLUMN_WIDTH - widths[i]);
+			widths[i] += add;
 			remaining -= add;
 		}
 	}
@@ -474,7 +470,8 @@ async function insertBlocksInBatches(client, docToken, blocks, firstLevelBlockId
 	}
 	if (currentBatch.blocks.length > 0) batches.push(currentBatch);
 	let currentIndex = startIndex;
-	for (const [i, batch] of batches.entries()) {
+	for (let i = 0; i < batches.length; i++) {
+		const batch = batches[i];
 		logger?.info?.(`feishu_doc: Inserting batch ${i + 1}/${batches.length} (${batch.blocks.length} blocks)...`);
 		const children = await insertBatch(client, docToken, batch.blocks, batch.firstLevelIds, parentBlockId, currentIndex);
 		allChildren.push(...children);
@@ -526,7 +523,6 @@ function parseColorMarkup(content) {
 	} else {
 		const tagStr = normalizeLowercaseStringOrEmpty(match[1]);
 		const text = match[2];
-		if (text === void 0) continue;
 		const tags = tagStr.split(/\s+/);
 		const segment = { text };
 		for (const tag of tags) if (tag.startsWith("bg:")) {
@@ -566,249 +562,6 @@ async function updateColorText(client, docToken, blockId, content) {
 	};
 }
 //#endregion
-//#region extensions/feishu/src/docx-markdown.ts
-const MAX_BREAK_PROBES = 32;
-const STABLE_LINE_CONTAINER_TYPES = /* @__PURE__ */ new Set([
-	"list",
-	"blockquote",
-	"code"
-]);
-function visitMarkdown(root, visitor) {
-	const pending = [root];
-	while (pending.length > 0) {
-		const node = pending.pop();
-		if (!node) continue;
-		visitor(node);
-		if (!node.children) continue;
-		for (let index = node.children.length - 1; index >= 0; index -= 1) {
-			const child = node.children[index];
-			if (child) pending.push(child);
-		}
-	}
-}
-function resolveRemoteImageUrl(value) {
-	if (!value) return;
-	try {
-		const url = new URL(value);
-		return url.protocol === "http:" || url.protocol === "https:" ? value : void 0;
-	} catch {
-		return;
-	}
-}
-function collectMarkdownImages(root) {
-	const definitions = /* @__PURE__ */ new Map();
-	visitMarkdown(root, (node) => {
-		if (node.type !== "definition" || !node.identifier || !node.url) return;
-		if (!definitions.has(node.identifier)) definitions.set(node.identifier, node.url);
-	});
-	const images = [];
-	visitMarkdown(root, (node) => {
-		if (node.type === "image") {
-			images.push({ url: resolveRemoteImageUrl(node.url) });
-			return;
-		}
-		if (node.type === "imageReference") images.push({ url: resolveRemoteImageUrl(node.identifier ? definitions.get(node.identifier) : void 0) });
-	});
-	return images;
-}
-function splitSourceAtOffsets(source, offsets) {
-	const chunks = [];
-	let start = 0;
-	for (const offset of offsets) {
-		if (offset <= start || offset >= source.length) continue;
-		chunks.push(source.slice(start, offset));
-		start = offset;
-	}
-	chunks.push(source.slice(start));
-	return chunks;
-}
-function headingOffsets(source, root) {
-	const offsets = [];
-	for (const node of root.children ?? []) {
-		if (node.type !== "heading" || node.depth === void 0 || node.depth > 2) continue;
-		const offset = node.position?.start.offset;
-		if (offset !== void 0 && source[offset] === "#") offsets.push(offset);
-	}
-	return offsets;
-}
-function blockBreakOffsets(root) {
-	const offsets = [];
-	for (const block of root.children ?? []) {
-		const blockStart = block.position?.start.offset;
-		if (blockStart !== void 0 && blockStart > 0) offsets.push(blockStart);
-	}
-	return offsets;
-}
-function paragraphBreakOffsets(source, root) {
-	const offsets = [];
-	for (const block of root.children ?? []) {
-		if (block.type !== "paragraph") continue;
-		for (const child of block.children ?? []) {
-			if (child.type !== "text") continue;
-			const start = child.position?.start.offset;
-			const end = child.position?.end.offset;
-			if (start === void 0 || end === void 0) continue;
-			for (let offset = start; offset < end; offset += 1) {
-				const char = source[offset];
-				if (char === " " || char === "	" || char === "\n" || char === "\r") offsets.push(offset + 1);
-			}
-		}
-	}
-	return offsets;
-}
-function lineBreakOffsets(source) {
-	const offsets = [];
-	for (let offset = 0; offset < source.length; offset += 1) if (source[offset] === "\n" && offset + 1 < source.length) offsets.push(offset + 1);
-	return offsets;
-}
-function nearestOffset(offsets, target, sourceLength) {
-	return offsets.filter((offset) => offset > 0 && offset < sourceLength).toSorted((left, right) => Math.abs(left - target) - Math.abs(right - target) || left - right);
-}
-function isStableParagraphBreak(source, offset) {
-	const before = parseFeishuMarkdown(source.slice(0, offset)).children?.at(-1);
-	const after = parseFeishuMarkdown(source.slice(offset)).children?.[0];
-	return before?.type === "paragraph" && after?.type === "paragraph";
-}
-function isStableContainerBreak(source, offset, containerType) {
-	const before = parseFeishuMarkdown(source.slice(0, offset)).children;
-	const after = parseFeishuMarkdown(source.slice(offset)).children;
-	return before?.length === 1 && after?.length === 1 && before[0]?.type === containerType && after[0]?.type === containerType;
-}
-function splitTableAtRow(source, root, target) {
-	const table = root.children?.length === 1 ? root.children[0] : void 0;
-	if (table?.type !== "table") return;
-	const rows = table.children ?? [];
-	const firstBodyOffset = rows[1]?.position?.start.offset;
-	const splitOffset = nearestOffset(rows.slice(2).map((row) => row.position?.start.offset).filter((offset) => offset !== void 0), target, source.length)[0];
-	if (firstBodyOffset === void 0 || splitOffset === void 0) return;
-	const tableStart = table.position?.start.offset ?? 0;
-	const repeatedHeader = source.slice(tableStart, firstBodyOffset);
-	const chunks = [source.slice(0, splitOffset), `${repeatedHeader}${source.slice(splitOffset)}`];
-	if (chunks.every((chunk) => parseFeishuMarkdown(chunk).children?.[0]?.type === "table")) return chunks;
-}
-function isFencedCodeSource(source) {
-	const firstLineEnd = source.indexOf("\n");
-	const firstLine = source.slice(0, firstLineEnd === -1 ? source.length : firstLineEnd);
-	let indent = 0;
-	while (indent < firstLine.length && firstLine[indent] === " ") indent += 1;
-	if (indent > 3) return false;
-	const marker = firstLine.slice(indent);
-	return marker.startsWith("```") || marker.startsWith("~~~");
-}
-function createDocxMarkdownChunk(markdown) {
-	return {
-		markdown,
-		images: collectMarkdownImages(parseFeishuMarkdown(markdown))
-	};
-}
-function createDocxMarkdownPlan(markdown) {
-	return { chunks: splitSourceAtOffsets(markdown, headingOffsets(markdown, parseFeishuMarkdown(markdown))).map(createDocxMarkdownChunk) };
-}
-function splitDocxMarkdownBySize(markdown, maxChars) {
-	if (markdown.length <= maxChars) return [markdown];
-	const root = parseFeishuMarkdown(markdown);
-	const target = Math.min(markdown.length - 1, Math.max(1, maxChars));
-	const splitOffset = nearestOffset(blockBreakOffsets(root), target, markdown.length)[0];
-	if (splitOffset !== void 0) return [markdown.slice(0, splitOffset), markdown.slice(splitOffset)];
-	const paragraphOffset = nearestOffset(paragraphBreakOffsets(markdown, root), target, markdown.length).slice(0, MAX_BREAK_PROBES).find((offset) => isStableParagraphBreak(markdown, offset));
-	if (paragraphOffset !== void 0) return [markdown.slice(0, paragraphOffset), markdown.slice(paragraphOffset)];
-	if (root.children?.length === 1 && root.children[0]?.type === "code" && isFencedCodeSource(markdown)) return chunkFeishuMarkdown(markdown, maxChars);
-	const tableChunks = splitTableAtRow(markdown, root, target);
-	if (tableChunks) return tableChunks;
-	const containerType = root.children?.length === 1 ? root.children[0]?.type : void 0;
-	if (containerType && STABLE_LINE_CONTAINER_TYPES.has(containerType)) {
-		const containerOffset = nearestOffset(lineBreakOffsets(markdown), target, markdown.length).slice(0, MAX_BREAK_PROBES).find((offset) => isStableContainerBreak(markdown, offset, containerType));
-		if (containerOffset !== void 0) return [markdown.slice(0, containerOffset), markdown.slice(containerOffset)];
-	}
-	return [markdown];
-}
-//#endregion
-//#region extensions/feishu/src/docx-upload-input.ts
-function decodeBase64Image(params) {
-	const estimatedBytes = estimateBase64DecodedBytes(params.payload);
-	if (estimatedBytes > params.maxBytes) throw new Error(`${params.oversizedLabel} exceeds limit: estimated ${estimatedBytes} bytes > ${params.maxBytes} bytes`);
-	const canonical = canonicalizeBase64(params.payload);
-	if (!canonical) throw new Error(params.invalidMessage);
-	return Buffer.from(canonical, "base64");
-}
-function resolveDataUriImage(image, maxBytes, fileName) {
-	const commaIndex = image.indexOf(",");
-	if (commaIndex === -1) throw new Error("Invalid data URI: missing comma separator.");
-	const metadata = image.slice(5, commaIndex).split(";");
-	if (!metadata.slice(1).map((value) => value.trim().toLowerCase()).includes("base64")) throw new Error("Invalid data URI: missing ';base64' marker. Expected format: data:image/png;base64,<base64data>");
-	const buffer = decodeBase64Image({
-		payload: image.slice(commaIndex + 1),
-		maxBytes,
-		invalidMessage: "Invalid data URI: base64 payload is malformed.",
-		oversizedLabel: "Image data URI"
-	});
-	const mime = metadata[0]?.trim();
-	const extension = extensionForMime(mime)?.slice(1) ?? "png";
-	return {
-		buffer,
-		fileName: fileName ?? `image.${extension}`
-	};
-}
-async function resolveLocalUpload(filePath, maxBytes, localRoots, fileName) {
-	return {
-		buffer: (await getFeishuRuntime().media.loadWebMedia(resolve(filePath), {
-			maxBytes,
-			optimizeImages: false,
-			localRoots
-		})).buffer,
-		fileName: fileName ?? basename(filePath)
-	};
-}
-function resolveImageLocalPath(image) {
-	const candidate = image.startsWith("~") ? `${homedir()}${image.slice(1)}` : image;
-	const unambiguousPath = image.startsWith("~") || image.startsWith("./") || image.startsWith("../");
-	const absolutePath = isAbsolute(image);
-	if (unambiguousPath || absolutePath && existsSync(candidate)) return candidate;
-	if (absolutePath) throw new Error(`File not found: "${candidate}". If you intended to pass image binary data, use a data URI instead: data:image/jpeg;base64,...`);
-}
-async function resolveRemoteUpload(input) {
-	const fetched = await getFeishuRuntime().channel.media.readRemoteMediaBuffer({
-		url: input.url,
-		maxBytes: input.maxBytes,
-		...input.remoteReadTimeoutMs !== void 0 ? {
-			responseHeaderTimeoutMs: input.remoteReadTimeoutMs,
-			readIdleTimeoutMs: input.remoteReadTimeoutMs
-		} : {}
-	});
-	const urlFileName = new URL(input.url).pathname.split("/").pop() || "upload.bin";
-	return {
-		buffer: fetched.buffer,
-		fileName: input.fileName ?? fetched.fileName ?? urlFileName
-	};
-}
-async function resolveDocxUploadInput(input) {
-	const sources = [
-		input.url && "url",
-		input.filePath && "file_path",
-		input.image && "image"
-	].filter((source) => Boolean(source));
-	if (sources.length !== 1) throw new Error(sources.length === 0 ? "Either url, file_path, or image (base64/data URI) must be provided" : `Provide only one upload source; got: ${sources.join(", ")}`);
-	if (input.url) return await resolveRemoteUpload({
-		...input,
-		url: input.url
-	});
-	if (input.filePath) return await resolveLocalUpload(input.filePath, input.maxBytes, input.localRoots, input.fileName);
-	const image = input.image;
-	if (!image) throw new Error("Image input must not be empty");
-	if (image.startsWith("data:")) return resolveDataUriImage(image, input.maxBytes, input.fileName);
-	const localPath = resolveImageLocalPath(image);
-	if (localPath) return await resolveLocalUpload(localPath, input.maxBytes, input.localRoots, input.fileName);
-	return {
-		buffer: decodeBase64Image({
-			payload: image,
-			maxBytes: input.maxBytes,
-			invalidMessage: "Invalid base64: image input is malformed. Use a data URI (data:image/png;base64,...) or a local file path instead.",
-			oversizedLabel: "Base64 image"
-		}),
-		fileName: input.fileName ?? "image.png"
-	};
-}
-//#endregion
 //#region extensions/feishu/src/docx.ts
 function resolveDocToolLocalRoots(ctx) {
 	if (ctx.fsPolicy?.workspaceOnly !== true) return;
@@ -816,6 +569,17 @@ function resolveDocToolLocalRoots(ctx) {
 	if (!workspaceDir) return [];
 	return [resolve(workspaceDir)];
 }
+/** Extract image URLs from markdown content */
+function extractImageUrls(markdown) {
+	const regex = /!\[[^\]]*\]\(([^)]+)\)/g;
+	const urls = [];
+	let match;
+	while ((match = regex.exec(markdown)) !== null) {
+		const url = match[1].trim();
+		if (url.startsWith("http://") || url.startsWith("https://")) urls.push(url);
+	}
+	return urls;
+}
 const BLOCK_TYPE_NAMES = {
 	1: "Page",
 	2: "Text",
@@ -910,7 +674,8 @@ function normalizeConvertedBlockTree(blocks, firstLevelIds) {
 		const parentId = typeof block?.parent_id === "string" ? block.parent_id : "";
 		return !childIds.has(blockId) && (!parentId || !byId.has(parentId));
 	}).toSorted((a, b) => (originalOrder.get(a.block_id ?? "__missing__") ?? 0) - (originalOrder.get(b.block_id ?? "__missing__") ?? 0)).map((block) => block.block_id).filter((blockId) => typeof blockId === "string");
-	const uniqueRootIds = uniqueStrings((firstLevelIds && firstLevelIds.length > 0 ? firstLevelIds : inferredTopLevelIds).filter((id) => typeof id === "string" && byId.has(id)));
+	const rootIds = (firstLevelIds && firstLevelIds.length > 0 ? firstLevelIds : inferredTopLevelIds).filter((id) => typeof id === "string" && byId.has(id));
+	const uniqueRootIds = uniqueStrings(rootIds);
 	const orderedBlocks = [];
 	const visited = /* @__PURE__ */ new Set();
 	const visit = (blockId) => {
@@ -956,49 +721,83 @@ async function insertBlocks(client, docToken, blocks, parentBlockId, index) {
 		skipped
 	};
 }
-async function convertMarkdownWithFallback(client, chunk, depth = 0) {
+/** Split markdown into chunks at top-level headings (# or ##) to stay within API content limits */
+function splitMarkdownByHeadings(markdown) {
+	const lines = markdown.split("\n");
+	const chunks = [];
+	let current = [];
+	let inFencedBlock = false;
+	for (const line of lines) {
+		if (/^(`{3,}|~{3,})/.test(line)) inFencedBlock = !inFencedBlock;
+		if (!inFencedBlock && /^#{1,2}\s/.test(line) && current.length > 0) {
+			chunks.push(current.join("\n"));
+			current = [];
+		}
+		current.push(line);
+	}
+	if (current.length > 0) chunks.push(current.join("\n"));
+	return chunks;
+}
+/** Split markdown by size, preferring to break outside fenced code blocks when possible */
+function splitMarkdownBySize(markdown, maxChars) {
+	if (markdown.length <= maxChars) return [markdown];
+	const lines = markdown.split("\n");
+	const chunks = [];
+	let current = [];
+	let currentLength = 0;
+	let inFencedBlock = false;
+	for (const line of lines) {
+		if (/^(`{3,}|~{3,})/.test(line)) inFencedBlock = !inFencedBlock;
+		const lineLength = line.length + 1;
+		const wouldExceed = currentLength + lineLength > maxChars;
+		if (current.length > 0 && wouldExceed && !inFencedBlock) {
+			chunks.push(current.join("\n"));
+			current = [];
+			currentLength = 0;
+		}
+		current.push(line);
+		currentLength += lineLength;
+	}
+	if (current.length > 0) chunks.push(current.join("\n"));
+	if (chunks.length > 1) return chunks;
+	const midpoint = Math.floor(lines.length / 2);
+	if (midpoint <= 0 || midpoint >= lines.length) return [markdown];
+	return [lines.slice(0, midpoint).join("\n"), lines.slice(midpoint).join("\n")];
+}
+async function convertMarkdownWithFallback(client, markdown, depth = 0) {
 	try {
-		return {
-			...await convertMarkdown(client, chunk.markdown),
-			images: chunk.images
-		};
+		return await convertMarkdown(client, markdown);
 	} catch (error) {
-		if (depth >= MAX_CONVERT_RETRY_DEPTH || chunk.markdown.length < 2) throw error;
-		const splitTarget = Math.max(256, Math.floor(chunk.markdown.length / 2));
-		const chunks = splitDocxMarkdownBySize(chunk.markdown, splitTarget).map(createDocxMarkdownChunk);
+		if (depth >= MAX_CONVERT_RETRY_DEPTH || markdown.length < 2) throw error;
+		const chunks = splitMarkdownBySize(markdown, Math.max(256, Math.floor(markdown.length / 2)));
 		if (chunks.length <= 1) throw error;
 		const blocks = [];
 		const firstLevelBlockIds = [];
-		const images = [];
-		for (const fallbackChunk of chunks) {
-			const converted = await convertMarkdownWithFallback(client, fallbackChunk, depth + 1);
+		for (const chunk of chunks) {
+			const converted = await convertMarkdownWithFallback(client, chunk, depth + 1);
 			blocks.push(...converted.blocks);
 			firstLevelBlockIds.push(...converted.firstLevelBlockIds);
-			images.push(...converted.images);
 		}
 		return {
 			blocks,
-			firstLevelBlockIds,
-			images
+			firstLevelBlockIds
 		};
 	}
 }
 /** Convert markdown in chunks to avoid document.convert content size limits */
-async function chunkedConvertMarkdown(client, chunks) {
+async function chunkedConvertMarkdown(client, markdown) {
+	const chunks = splitMarkdownByHeadings(markdown);
 	const allBlocks = [];
 	const allRootIds = [];
-	const allImages = [];
 	for (const chunk of chunks) {
-		const { blocks, firstLevelBlockIds, images } = await convertMarkdownWithFallback(client, chunk);
+		const { blocks, firstLevelBlockIds } = await convertMarkdownWithFallback(client, chunk);
 		const { orderedBlocks, rootIds } = normalizeConvertedBlockTree(blocks, firstLevelBlockIds);
 		allBlocks.push(...orderedBlocks);
 		allRootIds.push(...rootIds);
-		allImages.push(...images);
 	}
 	return {
 		blocks: allBlocks,
-		firstLevelBlockIds: allRootIds,
-		images: allImages
+		firstLevelBlockIds: allRootIds
 	};
 }
 /**
@@ -1056,21 +855,99 @@ async function uploadImageToDocx(client, blockId, imageBuffer, fileName, docToke
 	if (!fileToken) throw new Error("Image upload failed: no file_token returned");
 	return fileToken;
 }
-async function processImages(client, docToken, images, insertedBlocks, maxBytes, imageReadTimeoutMs) {
-	if (images.length === 0) return 0;
+async function downloadImage(url, maxBytes) {
+	return (await getFeishuRuntime().channel.media.readRemoteMediaBuffer({
+		url,
+		maxBytes
+	})).buffer;
+}
+async function resolveUploadInput(url, filePath, maxBytes, localRoots, explicitFileName, imageInput) {
+	const inputSources = [
+		url ? "url" : null,
+		filePath ? "file_path" : null,
+		imageInput ? "image" : null
+	].filter(Boolean);
+	if (inputSources.length > 1) throw new Error(`Provide only one image source; got: ${inputSources.join(", ")}`);
+	if (imageInput?.startsWith("data:")) {
+		const commaIdx = imageInput.indexOf(",");
+		if (commaIdx === -1) throw new Error("Invalid data URI: missing comma separator.");
+		const header = imageInput.slice(0, commaIdx);
+		const data = imageInput.slice(commaIdx + 1);
+		if (!header.includes(";base64")) throw new Error("Invalid data URI: missing ';base64' marker. Expected format: data:image/png;base64,<base64data>");
+		const trimmedData = data.trim();
+		if (trimmedData.length === 0 || !/^[A-Za-z0-9+/]+=*$/.test(trimmedData)) throw new Error(`Invalid data URI: base64 payload contains characters outside the standard alphabet.`);
+		const mimeMatch = header.match(/data:([^;]+)/);
+		const ext = extensionForMime(mimeMatch?.[1])?.slice(1) ?? "png";
+		const estimatedBytes = Math.ceil(trimmedData.length * 3 / 4);
+		if (estimatedBytes > maxBytes) throw new Error(`Image data URI exceeds limit: estimated ${estimatedBytes} bytes > ${maxBytes} bytes`);
+		return {
+			buffer: Buffer.from(trimmedData, "base64"),
+			fileName: explicitFileName ?? `image.${ext}`
+		};
+	}
+	if (imageInput) {
+		const candidate = imageInput.startsWith("~") ? imageInput.replace(/^~/, homedir()) : imageInput;
+		const unambiguousPath = imageInput.startsWith("~") || imageInput.startsWith("./") || imageInput.startsWith("../");
+		const absolutePath = isAbsolute(imageInput);
+		if (unambiguousPath || absolutePath && existsSync(candidate)) {
+			const resolvedPath = resolve(candidate);
+			return {
+				buffer: (await getFeishuRuntime().media.loadWebMedia(resolvedPath, {
+					maxBytes,
+					optimizeImages: false,
+					localRoots
+				})).buffer,
+				fileName: explicitFileName ?? basename(candidate)
+			};
+		}
+		if (absolutePath && !existsSync(candidate)) throw new Error(`File not found: "${candidate}". If you intended to pass image binary data, use a data URI instead: data:image/jpeg;base64,...`);
+	}
+	if (imageInput) {
+		const trimmed = imageInput.trim();
+		if (trimmed.length === 0 || !/^[A-Za-z0-9+/]+=*$/.test(trimmed)) throw new Error("Invalid base64: image input contains characters outside the standard base64 alphabet. Use a data URI (data:image/png;base64,...) or a local file path instead.");
+		const estimatedBytes = Math.ceil(trimmed.length * 3 / 4);
+		if (estimatedBytes > maxBytes) throw new Error(`Base64 image exceeds limit: estimated ${estimatedBytes} bytes > ${maxBytes} bytes`);
+		const buffer = Buffer.from(trimmed, "base64");
+		if (buffer.length === 0) throw new Error("Base64 image decoded to empty buffer; check the input.");
+		return {
+			buffer,
+			fileName: explicitFileName ?? "image.png"
+		};
+	}
+	if (!url && !filePath) throw new Error("Either url, file_path, or image (base64/data URI) must be provided");
+	if (url && filePath) throw new Error("Provide only one of url or file_path");
+	if (url) {
+		const fetched = await getFeishuRuntime().channel.media.readRemoteMediaBuffer({
+			url,
+			maxBytes
+		});
+		const guessed = new URL(url).pathname.split("/").pop() || "upload.bin";
+		return {
+			buffer: fetched.buffer,
+			fileName: explicitFileName || guessed
+		};
+	}
+	const resolvedFilePath = resolve(filePath);
+	return {
+		buffer: (await getFeishuRuntime().media.loadWebMedia(resolvedFilePath, {
+			maxBytes,
+			optimizeImages: false,
+			localRoots
+		})).buffer,
+		fileName: explicitFileName || basename(filePath)
+	};
+}
+async function processImages(client, docToken, markdown, insertedBlocks, maxBytes) {
+	const imageUrls = extractImageUrls(markdown);
+	if (imageUrls.length === 0) return 0;
 	const imageBlocks = insertedBlocks.filter((b) => b.block_type === 27);
 	let processed = 0;
-	for (let i = 0; i < Math.min(images.length, imageBlocks.length); i++) {
-		const url = images[i]?.url;
+	for (let i = 0; i < Math.min(imageUrls.length, imageBlocks.length); i++) {
+		const url = imageUrls[i];
 		const blockId = imageBlocks[i]?.block_id;
-		if (!url || !blockId) continue;
+		if (!blockId) continue;
 		try {
-			const upload = await resolveDocxUploadInput({
-				url,
-				maxBytes,
-				remoteReadTimeoutMs: imageReadTimeoutMs
-			});
-			const fileToken = await uploadImageToDocx(client, blockId, upload.buffer, upload.fileName, docToken);
+			const fileToken = await uploadImageToDocx(client, blockId, await downloadImage(url, maxBytes), new URL(url).pathname.split("/").pop() || `image_${i}.png`, docToken);
 			await client.docx.documentBlock.patch({
 				path: {
 					document_id: docToken,
@@ -1085,37 +962,7 @@ async function processImages(client, docToken, images, insertedBlocks, maxBytes,
 	}
 	return processed;
 }
-async function convertInsertAndProcessDocx(params) {
-	const { client, docToken, logger, target } = params;
-	logger?.info?.("feishu_doc: Converting markdown...");
-	const { blocks, firstLevelBlockIds, images } = await chunkedConvertMarkdown(client, createDocxMarkdownPlan(params.markdown).chunks);
-	await params.onConverted(blocks.length);
-	if (blocks.length === 0) return {
-		blocks,
-		inserted: [],
-		imagesProcessed: 0
-	};
-	const { orderedBlocks, rootIds } = normalizeConvertedBlockTree(blocks, firstLevelBlockIds);
-	logger?.info?.(`feishu_doc: Converted to ${blocks.length} blocks, inserting${target ? ` at index ${target.index}` : ""}...`);
-	const { children: inserted } = blocks.length > 1e3 ? await insertBlocksInBatches(client, docToken, orderedBlocks, rootIds, logger, target?.parentBlockId, target?.index) : await insertBlocksWithDescendant(client, docToken, orderedBlocks, rootIds, target);
-	const imagesProcessed = await processImages(client, docToken, images, inserted, params.maxBytes, params.imageReadTimeoutMs);
-	logger?.info?.(`feishu_doc: Done (${blocks.length} blocks, ${imagesProcessed} images)`);
-	return {
-		blocks,
-		inserted,
-		imagesProcessed
-	};
-}
-async function uploadImageBlock(client, docToken, maxBytes, imageReadTimeoutMs, localRoots, url, filePath, parentBlockId, filename, index, imageInput) {
-	const upload = await resolveDocxUploadInput({
-		url,
-		filePath,
-		image: imageInput,
-		maxBytes,
-		localRoots,
-		fileName: filename,
-		remoteReadTimeoutMs: imageReadTimeoutMs
-	});
+async function uploadImageBlock(client, docToken, maxBytes, localRoots, url, filePath, parentBlockId, filename, index, imageInput) {
 	const insertRes = await client.docx.documentBlockChildren.create({
 		path: {
 			document_id: docToken,
@@ -1133,6 +980,7 @@ async function uploadImageBlock(client, docToken, maxBytes, imageReadTimeoutMs,
 	if (insertRes.code !== 0) throw new Error(`Failed to create image block: ${insertRes.msg}`);
 	const imageBlockId = insertRes.data?.children?.find((b) => b.block_type === 27)?.block_id;
 	if (!imageBlockId) throw new Error("Failed to create image block");
+	const upload = await resolveUploadInput(url, filePath, maxBytes, localRoots, filename, imageInput);
 	const fileToken = await uploadImageToDocx(client, imageBlockId, upload.buffer, upload.fileName, docToken);
 	const patchRes = await client.docx.documentBlock.patch({
 		path: {
@@ -1152,14 +1000,8 @@ async function uploadImageBlock(client, docToken, maxBytes, imageReadTimeoutMs,
 }
 async function uploadFileBlock(client, docToken, maxBytes, localRoots, url, filePath, parentBlockId, filename) {
 	const blockId = parentBlockId ?? docToken;
-	const upload = await resolveDocxUploadInput({
-		url,
-		filePath,
-		maxBytes,
-		localRoots,
-		fileName: filename
-	});
-	const converted = await convertMarkdown(client, "[file](https://example.com/placeholder)");
+	const upload = await resolveUploadInput(url, filePath, maxBytes, localRoots, filename);
+	const converted = await convertMarkdown(client, `[${upload.fileName}](https://example.com/placeholder)`);
 	const { orderedBlocks } = normalizeConvertedBlockTree(converted.blocks, converted.firstLevelBlockIds);
 	const { children: inserted } = await insertBlocks(client, docToken, orderedBlocks, blockId);
 	const placeholderBlock = inserted[0];
@@ -1252,23 +1094,25 @@ async function createDoc(client, title, folderToken, options) {
 	let requesterPermissionAdded = false;
 	let requesterPermissionSkippedReason;
 	let requesterPermissionError;
-	if (shouldGrantToRequester) if (!requesterOpenId) requesterPermissionSkippedReason = "trusted requester identity unavailable";
-	else try {
-		await client.drive.permissionMember.create({
-			path: { token: docToken },
-			params: {
-				type: "docx",
-				need_notification: false
-			},
-			data: {
-				member_type: "openid",
-				member_id: requesterOpenId,
-				perm: requesterPermType
-			}
-		});
-		requesterPermissionAdded = true;
-	} catch (err) {
-		requesterPermissionError = formatErrorMessage(err);
+	if (shouldGrantToRequester) {
+		if (!requesterOpenId) requesterPermissionSkippedReason = "trusted requester identity unavailable";
+		else try {
+			await client.drive.permissionMember.create({
+				path: { token: docToken },
+				params: {
+					type: "docx",
+					need_notification: false
+				},
+				data: {
+					member_type: "openid",
+					member_id: requesterOpenId,
+					perm: requesterPermType
+				}
+			});
+			requesterPermissionAdded = true;
+		} catch (err) {
+			requesterPermissionError = formatErrorMessage(err);
+		}
 	}
 	return {
 		document_id: docToken,
@@ -1283,19 +1127,21 @@ async function createDoc(client, title, folderToken, options) {
 		}
 	};
 }
-async function writeDoc(client, docToken, markdown, maxBytes, imageReadTimeoutMs, logger) {
-	let deleted = 0;
-	const { blocks, imagesProcessed } = await convertInsertAndProcessDocx({
-		client,
-		docToken,
-		markdown,
-		maxBytes,
-		imageReadTimeoutMs,
-		logger,
-		onConverted: async () => {
-			deleted = await clearDocumentContent(client, docToken);
-		}
-	});
+async function writeDoc(client, docToken, markdown, maxBytes, logger) {
+	const deleted = await clearDocumentContent(client, docToken);
+	logger?.info?.("feishu_doc: Converting markdown...");
+	const { blocks, firstLevelBlockIds } = await chunkedConvertMarkdown(client, markdown);
+	if (blocks.length === 0) return {
+		success: true,
+		blocks_deleted: deleted,
+		blocks_added: 0,
+		images_processed: 0
+	};
+	logger?.info?.(`feishu_doc: Converted to ${blocks.length} blocks, inserting...`);
+	const { orderedBlocks, rootIds } = normalizeConvertedBlockTree(blocks, firstLevelBlockIds);
+	const { children: inserted } = blocks.length > 1e3 ? await insertBlocksInBatches(client, docToken, orderedBlocks, rootIds, logger) : await insertBlocksWithDescendant(client, docToken, orderedBlocks, rootIds);
+	const imagesProcessed = await processImages(client, docToken, markdown, inserted, maxBytes);
+	logger?.info?.(`feishu_doc: Done (${blocks.length} blocks, ${imagesProcessed} images)`);
 	return {
 		success: true,
 		blocks_deleted: deleted,
@@ -1303,18 +1149,15 @@ async function writeDoc(client, docToken, markdown, maxBytes, imageReadTimeoutMs
 		images_processed: imagesProcessed
 	};
 }
-async function appendDoc(client, docToken, markdown, maxBytes, imageReadTimeoutMs, logger) {
-	const { blocks, inserted, imagesProcessed } = await convertInsertAndProcessDocx({
-		client,
-		docToken,
-		markdown,
-		maxBytes,
-		imageReadTimeoutMs,
-		logger,
-		onConverted: (blockCount) => {
-			if (blockCount === 0) throw new Error("Content is empty");
-		}
-	});
+async function appendDoc(client, docToken, markdown, maxBytes, logger) {
+	logger?.info?.("feishu_doc: Converting markdown...");
+	const { blocks, firstLevelBlockIds } = await chunkedConvertMarkdown(client, markdown);
+	if (blocks.length === 0) throw new Error("Content is empty");
+	logger?.info?.(`feishu_doc: Converted to ${blocks.length} blocks, inserting...`);
+	const { orderedBlocks, rootIds } = normalizeConvertedBlockTree(blocks, firstLevelBlockIds);
+	const { children: inserted } = blocks.length > 1e3 ? await insertBlocksInBatches(client, docToken, orderedBlocks, rootIds, logger) : await insertBlocksWithDescendant(client, docToken, orderedBlocks, rootIds);
+	const imagesProcessed = await processImages(client, docToken, markdown, inserted, maxBytes);
+	logger?.info?.(`feishu_doc: Done (${blocks.length} blocks, ${imagesProcessed} images)`);
 	return {
 		success: true,
 		blocks_added: blocks.length,
@@ -1322,7 +1165,7 @@ async function appendDoc(client, docToken, markdown, maxBytes, imageReadTimeoutM
 		block_ids: inserted.map((b) => b.block_id)
 	};
 }
-async function insertDoc(client, docToken, markdown, afterBlockId, maxBytes, imageReadTimeoutMs, logger) {
+async function insertDoc(client, docToken, markdown, afterBlockId, maxBytes, logger) {
 	const blockInfo = await client.docx.documentBlock.get({ path: {
 		document_id: docToken,
 		block_id: afterBlockId
@@ -1345,21 +1188,18 @@ async function insertDoc(client, docToken, markdown, afterBlockId, maxBytes, ima
 	} while (pageToken);
 	const blockIndex = items.findIndex((item) => item.block_id === afterBlockId);
 	if (blockIndex === -1) throw new Error(`after_block_id "${afterBlockId}" was not found among the children of parent block "${parentId}". Use list_blocks to verify the block ID.`);
-	const { blocks, inserted, imagesProcessed } = await convertInsertAndProcessDocx({
-		client,
-		docToken,
-		markdown,
-		maxBytes,
-		imageReadTimeoutMs,
-		logger,
-		target: {
-			parentBlockId: parentId,
-			index: blockIndex + 1
-		},
-		onConverted: (blockCount) => {
-			if (blockCount === 0) throw new Error("Content is empty");
-		}
+	const insertIndex = blockIndex + 1;
+	logger?.info?.("feishu_doc: Converting markdown...");
+	const { blocks, firstLevelBlockIds } = await chunkedConvertMarkdown(client, markdown);
+	if (blocks.length === 0) throw new Error("Content is empty");
+	const { orderedBlocks, rootIds } = normalizeConvertedBlockTree(blocks, firstLevelBlockIds);
+	logger?.info?.(`feishu_doc: Converted to ${blocks.length} blocks, inserting at index ${insertIndex}...`);
+	const { children: inserted } = blocks.length > 1e3 ? await insertBlocksInBatches(client, docToken, orderedBlocks, rootIds, logger, parentId, insertIndex) : await insertBlocksWithDescendant(client, docToken, orderedBlocks, rootIds, {
+		parentBlockId: parentId,
+		index: insertIndex
 	});
+	const imagesProcessed = await processImages(client, docToken, markdown, inserted, maxBytes);
+	logger?.info?.(`feishu_doc: Done (${blocks.length} blocks, ${imagesProcessed} images)`);
 	return {
 		success: true,
 		blocks_added: blocks.length,
@@ -1568,15 +1408,6 @@ function registerFeishuDocTools(api) {
 			label: "Doc"
 		}
 	}).config?.mediaMaxMb ?? 30) * 1024 * 1024;
-	const getImageReadTimeoutMs = (params, defaultAccountId) => resolveConfiguredHttpTimeoutMs(resolveFeishuToolAccount({
-		api,
-		executeParams: params,
-		defaultAccountId,
-		requiredTool: {
-			family: "doc",
-			label: "Doc"
-		}
-	}));
 	if (toolsCfg.doc) {
 		api.registerTool((ctx) => {
 			const defaultAccountId = ctx.agentAccountId;
@@ -1590,13 +1421,12 @@ function registerFeishuDocTools(api) {
 				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." });
 						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 "write": return jsonResult(await writeDoc(client, p.doc_token, p.content, getMediaMaxBytes(p, defaultAccountId), api.logger));
+							case "append": return jsonResult(await appendDoc(client, p.doc_token, p.content, getMediaMaxBytes(p, defaultAccountId), api.logger));
+							case "insert": return jsonResult(await insertDoc(client, p.doc_token, p.content, p.after_block_id, getMediaMaxBytes(p, defaultAccountId), api.logger));
 							case "create": return jsonResult(await createDoc(client, p.title, p.folder_token, {
 								grantToRequester: p.grant_to_requester,
 								requesterOpenId: trustedRequesterOpenId
@@ -1608,7 +1438,7 @@ function registerFeishuDocTools(api) {
 							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_image": return jsonResult(await uploadImageBlock(client, p.doc_token, getMediaMaxBytes(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));
@@ -1634,14 +1464,15 @@ function registerFeishuDocTools(api) {
 			parameters: Type.Object({}),
 			async execute() {
 				try {
-					return jsonResult(await listAppScopes(createFeishuToolClient({
+					const result = await listAppScopes(createFeishuToolClient({
 						api,
 						defaultAccountId: ctx.agentAccountId,
 						requiredTool: {
 							family: "scopes",
 							label: "App Scopes"
 						}
-					})));
+					}));
+					return jsonResult(result);
 				} catch (err) {
 					return jsonResult({ error: formatErrorMessage(err) });
 				}
@@ -2066,23 +1897,17 @@ function parseBitableUrl(url) {
 		const u = new URL(url);
 		const tableId = u.searchParams.get("table") ?? void 0;
 		const wikiMatch = u.pathname.match(/\/wiki\/([A-Za-z0-9]+)/);
-		if (wikiMatch) {
-			const wikiPathSegment = wikiMatch[1];
-			return wikiPathSegment === void 0 ? null : {
-				token: wikiPathSegment,
-				tableId,
-				isWiki: true
-			};
-		}
+		if (wikiMatch) return {
+			token: wikiMatch[1],
+			tableId,
+			isWiki: true
+		};
 		const baseMatch = u.pathname.match(/\/base\/([A-Za-z0-9]+)/);
-		if (baseMatch) {
-			const basePathSegment = baseMatch[1];
-			return basePathSegment === void 0 ? null : {
-				token: basePathSegment,
-				tableId,
-				isWiki: false
-			};
-		}
+		if (baseMatch) return {
+			token: baseMatch[1],
+			tableId,
+			isWiki: false
+		};
 		return null;
 	} catch {
 		return null;
@@ -2319,7 +2144,7 @@ async function createApp(client, name, folderToken, logger) {
 	try {
 		const tablesRes = await client.bitable.appTable.list({ path: { app_token: appToken } });
 		if (tablesRes.code === 0 && tablesRes.data?.items && tablesRes.data.items.length > 0) {
-			tableId = tablesRes.data.items.at(0)?.table_id;
+			tableId = tablesRes.data.items[0].table_id ?? void 0;
 			if (tableId) {
 				const cleanup = await cleanupNewBitable(client, appToken, tableId, name, log);
 				cleanedRows = cleanup.cleanedRows;
@@ -2437,15 +2262,15 @@ 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,