@openclaw/feishu 2026.7.2-beta.1 → 2026.7.2-beta.3

package/dist/api.js

@@ -1,9 +1,10 @@
 import { r as listEnabledFeishuAccounts } from "./accounts-BDoGHJDk.js";
-import { a as setFeishuNamedAccountEnabled, i as feishuSetupAdapter, n as feishuSetupWizard, r as runFeishuLogin, t as feishuPlugin } from "./channel-DdPQ2HGh.js";
+import { a as setFeishuNamedAccountEnabled, i as feishuSetupAdapter, n as feishuSetupWizard, r as runFeishuLogin, t as feishuPlugin } from "./channel-BdnXYU6g.js";
+import { p as parseFeishuMarkdown, u as chunkFeishuMarkdown } from "./send-result-DfE5Fhz6.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-87BmeMpj.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
-import { r as createFeishuClient } from "./client-BUC-R2Wi.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-Bpe8ONK_.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-BHv8WW9i.js";
 import { n as getFeishuThreadBindingManager, r as testing, t as createFeishuThreadBindingManager } from "./thread-bindings-V0bwk0A1.js";
 import { n as handleFeishuSubagentEnded, r as handleFeishuSubagentSpawning, t as handleFeishuSubagentDeliveryTarget } from "./subagent-hooks-BKTOxB-T.js";
 import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
@@ -12,9 +13,9 @@ 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
@@ -565,6 +566,249 @@ 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;
@@ -572,19 +816,6 @@ 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 capturedUrl = match[1];
-		if (capturedUrl === void 0) continue;
-		const url = capturedUrl.trim();
-		if (url.startsWith("http://") || url.startsWith("https://")) urls.push(url);
-	}
-	return urls;
-}
 const BLOCK_TYPE_NAMES = {
 	1: "Page",
 	2: "Text",
@@ -725,83 +956,49 @@ async function insertBlocks(client, docToken, blocks, parentBlockId, index) {
 		skipped
 	};
 }
-/** 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) {
+async function convertMarkdownWithFallback(client, chunk, depth = 0) {
 	try {
-		return await convertMarkdown(client, markdown);
+		return {
+			...await convertMarkdown(client, chunk.markdown),
+			images: chunk.images
+		};
 	} catch (error) {
-		if (depth >= MAX_CONVERT_RETRY_DEPTH || markdown.length < 2) throw error;
-		const chunks = splitMarkdownBySize(markdown, Math.max(256, Math.floor(markdown.length / 2)));
+		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 (chunks.length <= 1) throw error;
 		const blocks = [];
 		const firstLevelBlockIds = [];
-		for (const chunk of chunks) {
-			const converted = await convertMarkdownWithFallback(client, chunk, depth + 1);
+		const images = [];
+		for (const fallbackChunk of chunks) {
+			const converted = await convertMarkdownWithFallback(client, fallbackChunk, depth + 1);
 			blocks.push(...converted.blocks);
 			firstLevelBlockIds.push(...converted.firstLevelBlockIds);
+			images.push(...converted.images);
 		}
 		return {
 			blocks,
-			firstLevelBlockIds
+			firstLevelBlockIds,
+			images
 		};
 	}
 }
 /** Convert markdown in chunks to avoid document.convert content size limits */
-async function chunkedConvertMarkdown(client, markdown) {
-	const chunks = splitMarkdownByHeadings(markdown);
+async function chunkedConvertMarkdown(client, chunks) {
 	const allBlocks = [];
 	const allRootIds = [];
+	const allImages = [];
 	for (const chunk of chunks) {
-		const { blocks, firstLevelBlockIds } = await convertMarkdownWithFallback(client, chunk);
+		const { blocks, firstLevelBlockIds, images } = await convertMarkdownWithFallback(client, chunk);
 		const { orderedBlocks, rootIds } = normalizeConvertedBlockTree(blocks, firstLevelBlockIds);
 		allBlocks.push(...orderedBlocks);
 		allRootIds.push(...rootIds);
+		allImages.push(...images);
 	}
 	return {
 		blocks: allBlocks,
-		firstLevelBlockIds: allRootIds
+		firstLevelBlockIds: allRootIds,
+		images: allImages
 	};
 }
 /**
@@ -859,98 +1056,21 @@ async function uploadImageToDocx(client, blockId, imageBuffer, fileName, docToke
 	if (!fileToken) throw new Error("Image upload failed: no file_token returned");
 	return fileToken;
 }
-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 ext = extensionForMime(header.match(/data:([^;]+)/)?.[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;
+async function processImages(client, docToken, images, insertedBlocks, maxBytes, imageReadTimeoutMs) {
+	if (images.length === 0) return 0;
 	const imageBlocks = insertedBlocks.filter((b) => b.block_type === 27);
 	let processed = 0;
-	for (let i = 0; i < Math.min(imageUrls.length, imageBlocks.length); i++) {
-		const url = imageUrls[i];
+	for (let i = 0; i < Math.min(images.length, imageBlocks.length); i++) {
+		const url = images[i]?.url;
 		const blockId = imageBlocks[i]?.block_id;
 		if (!url || !blockId) continue;
 		try {
-			const fileToken = await uploadImageToDocx(client, blockId, await downloadImage(url, maxBytes), new URL(url).pathname.split("/").pop() || `image_${i}.png`, docToken);
+			const upload = await resolveDocxUploadInput({
+				url,
+				maxBytes,
+				remoteReadTimeoutMs: imageReadTimeoutMs
+			});
+			const fileToken = await uploadImageToDocx(client, blockId, upload.buffer, upload.fileName, docToken);
 			await client.docx.documentBlock.patch({
 				path: {
 					document_id: docToken,
@@ -965,7 +1085,16 @@ async function processImages(client, docToken, markdown, insertedBlocks, maxByte
 	}
 	return processed;
 }
-async function uploadImageBlock(client, docToken, maxBytes, localRoots, url, filePath, parentBlockId, filename, index, imageInput) {
+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
+	});
 	const insertRes = await client.docx.documentBlockChildren.create({
 		path: {
 			document_id: docToken,
@@ -983,7 +1112,6 @@ async function uploadImageBlock(client, docToken, maxBytes, localRoots, url, fil
 	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: {
@@ -1003,8 +1131,14 @@ async function uploadImageBlock(client, docToken, maxBytes, localRoots, url, fil
 }
 async function uploadFileBlock(client, docToken, maxBytes, localRoots, url, filePath, parentBlockId, filename) {
 	const blockId = parentBlockId ?? docToken;
-	const upload = await resolveUploadInput(url, filePath, maxBytes, localRoots, filename);
-	const converted = await convertMarkdown(client, `[${upload.fileName}](https://example.com/placeholder)`);
+	const upload = await resolveDocxUploadInput({
+		url,
+		filePath,
+		maxBytes,
+		localRoots,
+		fileName: filename
+	});
+	const converted = await convertMarkdown(client, "[file](https://example.com/placeholder)");
 	const { orderedBlocks } = normalizeConvertedBlockTree(converted.blocks, converted.firstLevelBlockIds);
 	const { children: inserted } = await insertBlocks(client, docToken, orderedBlocks, blockId);
 	const placeholderBlock = inserted[0];
@@ -1128,10 +1262,11 @@ async function createDoc(client, title, folderToken, options) {
 		}
 	};
 }
-async function writeDoc(client, docToken, markdown, maxBytes, logger) {
-	const deleted = await clearDocumentContent(client, docToken);
+async function writeDoc(client, docToken, markdown, maxBytes, imageReadTimeoutMs, logger) {
+	const markdownPlan = createDocxMarkdownPlan(markdown);
 	logger?.info?.("feishu_doc: Converting markdown...");
-	const { blocks, firstLevelBlockIds } = await chunkedConvertMarkdown(client, markdown);
+	const { blocks, firstLevelBlockIds, images } = await chunkedConvertMarkdown(client, markdownPlan.chunks);
+	const deleted = await clearDocumentContent(client, docToken);
 	if (blocks.length === 0) return {
 		success: true,
 		blocks_deleted: deleted,
@@ -1141,7 +1276,7 @@ async function writeDoc(client, docToken, markdown, maxBytes, logger) {
 	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);
+	const imagesProcessed = await processImages(client, docToken, images, inserted, maxBytes, imageReadTimeoutMs);
 	logger?.info?.(`feishu_doc: Done (${blocks.length} blocks, ${imagesProcessed} images)`);
 	return {
 		success: true,
@@ -1150,14 +1285,15 @@ async function writeDoc(client, docToken, markdown, maxBytes, logger) {
 		images_processed: imagesProcessed
 	};
 }
-async function appendDoc(client, docToken, markdown, maxBytes, logger) {
+async function appendDoc(client, docToken, markdown, maxBytes, imageReadTimeoutMs, logger) {
+	const markdownPlan = createDocxMarkdownPlan(markdown);
 	logger?.info?.("feishu_doc: Converting markdown...");
-	const { blocks, firstLevelBlockIds } = await chunkedConvertMarkdown(client, markdown);
+	const { blocks, firstLevelBlockIds, images } = await chunkedConvertMarkdown(client, markdownPlan.chunks);
 	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);
+	const imagesProcessed = await processImages(client, docToken, images, inserted, maxBytes, imageReadTimeoutMs);
 	logger?.info?.(`feishu_doc: Done (${blocks.length} blocks, ${imagesProcessed} images)`);
 	return {
 		success: true,
@@ -1166,7 +1302,8 @@ async function appendDoc(client, docToken, markdown, maxBytes, logger) {
 		block_ids: inserted.map((b) => b.block_id)
 	};
 }
-async function insertDoc(client, docToken, markdown, afterBlockId, maxBytes, logger) {
+async function insertDoc(client, docToken, markdown, afterBlockId, maxBytes, imageReadTimeoutMs, logger) {
+	const markdownPlan = createDocxMarkdownPlan(markdown);
 	const blockInfo = await client.docx.documentBlock.get({ path: {
 		document_id: docToken,
 		block_id: afterBlockId
@@ -1191,7 +1328,7 @@ async function insertDoc(client, docToken, markdown, afterBlockId, maxBytes, log
 	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 insertIndex = blockIndex + 1;
 	logger?.info?.("feishu_doc: Converting markdown...");
-	const { blocks, firstLevelBlockIds } = await chunkedConvertMarkdown(client, markdown);
+	const { blocks, firstLevelBlockIds, images } = await chunkedConvertMarkdown(client, markdownPlan.chunks);
 	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}...`);
@@ -1199,7 +1336,7 @@ async function insertDoc(client, docToken, markdown, afterBlockId, maxBytes, log
 		parentBlockId: parentId,
 		index: insertIndex
 	});
-	const imagesProcessed = await processImages(client, docToken, markdown, inserted, maxBytes);
+	const imagesProcessed = await processImages(client, docToken, images, inserted, maxBytes, imageReadTimeoutMs);
 	logger?.info?.(`feishu_doc: Done (${blocks.length} blocks, ${imagesProcessed} images)`);
 	return {
 		success: true,
@@ -1409,6 +1546,15 @@ 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;
@@ -1425,9 +1571,9 @@ function registerFeishuDocTools(api) {
 						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), 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 "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, {
 								grantToRequester: p.grant_to_requester,
 								requesterOpenId: trustedRequesterOpenId
@@ -1439,7 +1585,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), 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), 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));