@openclaw/qqbot 2026.7.1-beta.1 → 2026.7.1-beta.2

package/dist/{gateway-BgfQAYxB.js → gateway-CjdB3B6n.js}

@@ -1,13 +1,13 @@
-import { C as getNextMsgSeq, D as downloadFile, F as StreamInputMode, I as StreamInputState, M as getMaxUploadSize, P as StreamContentType, T as openLocalFile, a as createRawInputNotifyFn, b as stopBackgroundTokenRefresh, c as getMessageApi, d as initSender, f as onMessageSent, g as sendText, h as sendMedia, i as clearTokenCache, j as getImageMimeType, k as formatFileSize, l as getPluginUserAgent, m as sendInputNotify, n as acknowledgeInteraction, o as getAccessToken, p as registerAccount, r as buildDeliveryTarget, s as getGatewayUrl, t as accountToCreds, u as initApiConfig, x as withTokenRetry, y as startBackgroundTokenRefresh } from "./sender-BHWpE_yH.js";
+import { C as getNextMsgSeq, D as downloadFile, F as StreamInputMode, I as StreamInputState, M as getMaxUploadSize, P as StreamContentType, T as openLocalFile, a as createRawInputNotifyFn, b as stopBackgroundTokenRefresh, c as getMessageApi, d as initSender, f as onMessageSent, g as sendText, h as sendMedia, i as clearTokenCache, j as getImageMimeType, k as formatFileSize, l as getPluginUserAgent, m as sendInputNotify, n as acknowledgeInteraction, o as getAccessToken, p as registerAccount, r as buildDeliveryTarget, s as getGatewayUrl, t as accountToCreds, u as initApiConfig, x as withTokenRetry, y as startBackgroundTokenRefresh } from "./sender-BfVLJJYp.js";
 import { c as getPlatformAdapter, i as normalizeOptionalString$1, n as normalizeLowercaseStringOrEmpty$1, o as readStringField, s as sanitizeFileName, t as asOptionalObjectRecord } from "./string-normalize-R_0cKO7Q.js";
-import { c as setBridgeLogger, o as ensurePlatformAdapter } from "./config-schema-gMW9zKvQ.js";
-import { a as authorizeQQBotApprovalAction, i as toGatewayAccount, n as createQQBotMarkdownChunker, p as parseApprovalButtonData, r as openQQBotSyncKeyedStore } from "./channel-Bh0MrYvU.js";
+import { c as setBridgeLogger, o as ensurePlatformAdapter } from "./config-schema-JZEf1dvB.js";
+import { a as authorizeQQBotApprovalAction, i as toGatewayAccount, n as createQQBotMarkdownChunker, p as parseApprovalButtonData, r as openQQBotSyncKeyedStore } from "./channel-BQM6pDlD.js";
 import { d as resolveAccountBase } from "./config-C1qZbh0K.js";
 import { a as formatErrorMessage, i as formatDuration, n as debugLog, r as debugWarn, t as debugError } from "./log-SDfMMBWe.js";
-import { n as getQQBotRuntimeForEngine, t as getQQBotRuntime } from "./runtime-BL0xZzWe.js";
+import { n as getQQBotRuntimeForEngine, t as getQQBotRuntime } from "./runtime-B4HWCOa-.js";
 import { t as buildQQBotStateKey } from "./state-keys-CQKlAFyo.js";
-import { a as resolveMentionPatterns, c as getPluginVersion, d as PRIVATE_CHAT_ONLY_TEXT, f as classifyCoreCommandForGroup, i as resolveGroupSettings, l as initCommands, n as resolveGroupCommandLevelFromAccountConfig, r as resolveGroupConfig, s as getFrameworkVersion, u as matchSlashCommand } from "./group-DQQsZ6Y0.js";
-import { A as getHomeDir, E as DEFAULT_MEDIA_SEND_ERROR, F as isLocalPath, I as isWindows, L as normalizePath, M as getQQBotMediaDir, O as setOutboundAudioPort, P as getTempDir, _ as sendVideoMsg, b as resolveUserFacingMediaError, c as isCronReminderPayload, d as normalizeMediaTags, g as sendPhoto, h as sendDocument, j as getQQBotDataDir, k as checkSilkWasmAvailable, l as isMediaPayload, o as decodeMediaPath, r as sendMedia$1, s as encodePayloadForCron, u as parseQQBotPayload, v as sendVoice, y as resolveTrustedOutboundMediaPath } from "./outbound-Dfa2uOEp.js";
+import { a as resolveMentionPatterns, c as getPluginVersion, d as PRIVATE_CHAT_ONLY_TEXT, f as classifyCoreCommandForGroup, i as resolveGroupSettings, l as initCommands, n as resolveGroupCommandLevelFromAccountConfig, r as resolveGroupConfig, s as getFrameworkVersion, u as matchSlashCommand } from "./group-BmS1Qwst.js";
+import { B as normalizePath, C as resolveUserFacingMediaError, F as getQQBotMediaDir, L as getTempDir, M as checkSilkWasmAvailable, N as getHomeDir, P as getQQBotDataDir, R as isLocalPath, S as resolveWorkspaceScopedLocalRoots, _ as sendVideoMsg, b as resolveOutboundMediaLocalRoots, c as isCronReminderPayload, d as normalizeMediaTags, g as sendPhoto, h as sendDocument, j as setOutboundAudioPort, k as DEFAULT_MEDIA_SEND_ERROR, l as isMediaPayload, o as decodeMediaPath, r as sendMedia$1, s as encodePayloadForCron, u as parseQQBotPayload, v as sendVoice, x as resolveWorkspacePathCandidates, y as resolveTrustedOutboundMediaPath, z as isWindows } from "./outbound-BZHwMFUX.js";
 import { n as runWithRequestContext } from "./request-context-Bm7PTBD1.js";
 import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { isImplicitSameChatApprovalAuthorization } from "openclaw/plugin-sdk/approval-auth-runtime";
@@ -17,7 +17,7 @@ import * as os$1 from "node:os";
 import { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
 import crypto from "node:crypto";
-import { readRegularFileSync } from "openclaw/plugin-sdk/security-runtime";
+import { readRegularFileSync, resolveLocalPathFromRootsSync } from "openclaw/plugin-sdk/security-runtime";
 import * as path$1 from "node:path";
 import path from "node:path";
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
@@ -26,6 +26,7 @@ import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { resolveRuntimeServiceVersion } from "openclaw/plugin-sdk/cli-runtime";
 import WebSocket from "ws";
 import { resolveAmbientNodeProxyAgent } from "openclaw/plugin-sdk/extension-shared";
+import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
 import { buildChannelInboundEventContext } from "openclaw/plugin-sdk/channel-inbound";
 import { SILENT_REPLY_TOKEN, isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { Buffer as Buffer$1 } from "node:buffer";
@@ -3298,15 +3299,30 @@ function hasQQBotImageSize(markdownImage) {
 //#region extensions/qqbot/src/engine/messaging/outbound-deliver.ts
 /** Maximum text length for a single QQ Bot message. */
 const TEXT_CHUNK_LIMIT = 5e3;
-function resolveMediaTargetContext(event, account) {
+function resolveMediaTargetContext(event, actx) {
+	const { account } = actx;
 	return {
 		targetType: event.type === "c2c" ? "c2c" : event.type === "group" ? "group" : event.type === "dm" ? "dm" : "channel",
 		targetId: event.type === "c2c" ? event.senderId : event.type === "group" ? event.groupOpenid : event.type === "dm" ? event.guildId : event.channelId,
 		account,
-		replyToId: event.messageId
+		replyToId: event.messageId,
+		...actx.mediaAccess ? { mediaAccess: actx.mediaAccess } : {},
+		...actx.mediaLocalRoots ? { mediaLocalRoots: actx.mediaLocalRoots } : {},
+		...actx.mediaReadFile ? { mediaReadFile: actx.mediaReadFile } : {}
 	};
 }
+function isHttpUrl(value) {
+	return value.startsWith("http://") || value.startsWith("https://");
+}
+function isImageDataUrl(value) {
+	return value.startsWith("data:image/");
+}
+function isBareRelativeMediaPath(value) {
+	const trimmed = value.trim();
+	return Boolean(trimmed) && !trimmed.startsWith("#") && !trimmed.startsWith("//") && !/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed);
+}
 async function autoMediaBatch(params) {
+	let sentCount = 0;
 	for (const mediaUrl of params.mediaUrls) try {
 		const result = await params.mediaSender.sendMedia({
 			to: params.qualifiedTarget,
@@ -3314,17 +3330,22 @@ async function autoMediaBatch(params) {
 			mediaUrl,
 			accountId: params.account.accountId,
 			replyToId: params.replyToId,
-			account: params.account
+			account: params.account,
+			...params.mediaAccess ? { mediaAccess: params.mediaAccess } : {},
+			...params.mediaLocalRoots ? { mediaLocalRoots: params.mediaLocalRoots } : {},
+			...params.mediaReadFile ? { mediaReadFile: params.mediaReadFile } : {}
 		});
 		if (result.error) {
 			params.log?.error(params.onResultError(mediaUrl, result.error));
 			continue;
 		}
+		sentCount++;
 		const successMessage = params.onSuccess?.(mediaUrl);
 		if (successMessage) params.log?.info(successMessage);
 	} catch (err) {
 		params.log?.error(params.onThrownError(mediaUrl, formatErrorMessage(err)));
 	}
+	return sentCount;
 }
 async function sendTextChunkToTarget(params) {
 	const { account, event, text, consumeQuoteRef, allowDm, forcePlainText } = params;
@@ -3390,16 +3411,18 @@ async function sendWithResultLogging(params) {
 		const result = await params.run();
 		if (result.error) {
 			params.log?.error(params.onError(result.error));
-			return;
+			return false;
 		}
 		const successMessage = params.onSuccess?.();
 		if (successMessage) params.log?.info(successMessage);
+		return true;
 	} catch (err) {
 		params.log?.error(params.onError(formatErrorMessage(err)));
+		return false;
 	}
 }
 async function sendPhotoWithLogging(params) {
-	await sendWithResultLogging({
+	return await sendWithResultLogging({
 		run: async () => await params.mediaSender.sendPhoto(params.target, params.imageUrl),
 		log: params.log,
 		onSuccess: params.onSuccess ? () => params.onSuccess?.(params.imageUrl) : void 0,
@@ -3431,9 +3454,14 @@ async function sendVoiceWithTimeout(target, voicePath, account, mediaSender, log
 				});
 			}, voiceTimeout);
 		})]);
-		if (result.error) log?.error(`sendVoice error: ${result.error}`);
+		if (result.error) {
+			log?.error(`sendVoice error: ${result.error}`);
+			return false;
+		}
+		return true;
 	} catch (err) {
 		log?.error(`sendVoice unexpected error: ${formatErrorMessage(err)}`);
+		return false;
 	}
 }
 /**
@@ -3489,38 +3517,62 @@ async function parseAndSendMediaTags(replyText, event, actx, sendWithRetry, cons
 		content: filterInternalMarkers(textAfter)
 	});
 	log?.debug?.(`Send queue: ${sendQueue.map((item) => item.type).join(" -> ")}`);
-	const mediaTarget = resolveMediaTargetContext(event, account);
-	for (const item of sendQueue) if (item.type === "text") await sendTextChunks(item.content, event, actx, sendWithRetry, consumeQuoteRef, deps);
-	else if (item.type === "image") await sendPhotoWithLogging({
-		target: mediaTarget,
-		imageUrl: item.content,
-		mediaSender: deps.mediaSender,
-		log,
-		onError: (error) => `sendPhoto error: ${error}`
-	});
-	else if (item.type === "voice") await sendVoiceWithTimeout(mediaTarget, item.content, account, deps.mediaSender, log);
-	else if (item.type === "video") await sendWithResultLogging({
-		run: async () => await deps.mediaSender.sendVideoMsg(mediaTarget, item.content),
-		log,
-		onError: (error) => `sendVideoMsg error: ${error}`
-	});
-	else if (item.type === "file") await sendWithResultLogging({
-		run: async () => await deps.mediaSender.sendDocument(mediaTarget, item.content),
-		log,
-		onError: (error) => `sendDocument error: ${error}`
-	});
-	else if (item.type === "media") await sendWithResultLogging({
-		run: async () => await deps.mediaSender.sendMedia({
-			to: actx.qualifiedTarget,
-			text: "",
-			mediaUrl: item.content,
-			accountId: account.accountId,
-			replyToId: event.messageId,
-			account
-		}),
-		log,
-		onError: (error) => `sendMedia(auto) error: ${error}`
-	});
+	const mediaTarget = resolveMediaTargetContext(event, actx);
+	let deliveredVisibleOutput = false;
+	for (const item of sendQueue) if (item.type === "text") {
+		await sendTextChunks(item.content, event, actx, sendWithRetry, consumeQuoteRef, deps);
+		if (item.content.trim()) deliveredVisibleOutput = true;
+	} else if (item.type === "image") {
+		const sent = await sendPhotoWithLogging({
+			target: mediaTarget,
+			imageUrl: item.content,
+			mediaSender: deps.mediaSender,
+			log,
+			onError: (error) => `sendPhoto error: ${error}`
+		});
+		deliveredVisibleOutput = deliveredVisibleOutput || sent;
+	} else if (item.type === "voice") {
+		const sent = await sendVoiceWithTimeout(mediaTarget, item.content, account, deps.mediaSender, log);
+		deliveredVisibleOutput = deliveredVisibleOutput || sent;
+	} else if (item.type === "video") {
+		const sent = await sendWithResultLogging({
+			run: async () => await deps.mediaSender.sendVideoMsg(mediaTarget, item.content),
+			log,
+			onError: (error) => `sendVideoMsg error: ${error}`
+		});
+		deliveredVisibleOutput = deliveredVisibleOutput || sent;
+	} else if (item.type === "file") {
+		const sent = await sendWithResultLogging({
+			run: async () => await deps.mediaSender.sendDocument(mediaTarget, item.content),
+			log,
+			onError: (error) => `sendDocument error: ${error}`
+		});
+		deliveredVisibleOutput = deliveredVisibleOutput || sent;
+	} else if (item.type === "media") {
+		const sent = await sendWithResultLogging({
+			run: async () => await deps.mediaSender.sendMedia({
+				to: actx.qualifiedTarget,
+				text: "",
+				mediaUrl: item.content,
+				accountId: account.accountId,
+				replyToId: event.messageId,
+				account,
+				...actx.mediaAccess ? { mediaAccess: actx.mediaAccess } : {},
+				...actx.mediaLocalRoots ? { mediaLocalRoots: actx.mediaLocalRoots } : {},
+				...actx.mediaReadFile ? { mediaReadFile: actx.mediaReadFile } : {}
+			}),
+			log,
+			onError: (error) => `sendMedia(auto) error: ${error}`
+		});
+		deliveredVisibleOutput = deliveredVisibleOutput || sent;
+	}
+	if (!deliveredVisibleOutput) {
+		await sendTextChunks(DEFAULT_MEDIA_SEND_ERROR, event, actx, sendWithRetry, consumeQuoteRef, deps);
+		return {
+			handled: true,
+			normalizedText: ""
+		};
+	}
 	return {
 		handled: true,
 		normalizedText: text
@@ -3534,18 +3586,18 @@ async function sendPlainReply(payload, replyText, event, actx, sendWithRetry, co
 	const { account, qualifiedTarget, log } = actx;
 	const collectedImageUrls = [];
 	const localMediaToSend = [];
-	const collectImageUrl = (url) => {
+	const collectImageUrl = (url, allowBareRelativeMedia = false) => {
 		if (!url) return false;
-		const isHttpUrl = url.startsWith("http://") || url.startsWith("https://");
-		const isDataUrl = url.startsWith("data:image/");
-		if (isHttpUrl || isDataUrl) {
+		const isRemoteHttpUrl = isHttpUrl(url);
+		const isDataUrl = isImageDataUrl(url);
+		if (isRemoteHttpUrl || isDataUrl) {
 			if (!collectedImageUrls.includes(url)) {
 				collectedImageUrls.push(url);
 				log?.debug?.(`Collected ${isDataUrl ? "Base64" : "media URL"}: ${isDataUrl ? `(length: ${url.length})` : url.slice(0, 80) + "..."}`);
 			}
 			return true;
 		}
-		if (isLocalPath(url)) {
+		if (isLocalPath(url) || allowBareRelativeMedia && isBareRelativeMediaPath(url)) {
 			if (!localMediaToSend.includes(url)) {
 				localMediaToSend.push(url);
 				log?.debug?.(`Collected local media for auto-routing: ${url}`);
@@ -3554,13 +3606,13 @@ async function sendPlainReply(payload, replyText, event, actx, sendWithRetry, co
 		}
 		return false;
 	};
-	if (payload.mediaUrls?.length) for (const url of payload.mediaUrls) collectImageUrl(url);
-	if (payload.mediaUrl) collectImageUrl(payload.mediaUrl);
+	if (payload.mediaUrls?.length) for (const url of payload.mediaUrls) collectImageUrl(url, true);
+	if (payload.mediaUrl) collectImageUrl(payload.mediaUrl, true);
 	const mdMatches = [...replyText.matchAll(/!\[([^\]]*)\]\(([^)]+)\)/gi)];
 	for (const m of mdMatches) {
 		const url = m[2]?.trim();
 		if (url && !collectedImageUrls.includes(url)) {
-			if (url.startsWith("http://") || url.startsWith("https://")) {
+			if (isHttpUrl(url)) {
 				collectedImageUrls.push(url);
 				log?.debug?.(`Extracted HTTP image from markdown: ${url.slice(0, 80)}...`);
 			} else if (isLocalPath(url)) {
@@ -3584,37 +3636,51 @@ async function sendPlainReply(payload, replyText, event, actx, sendWithRetry, co
 	let textWithoutImages = filterInternalMarkers(replyText);
 	for (const m of mdMatches) {
 		const url = m[2]?.trim();
-		if (url && !url.startsWith("http://") && !url.startsWith("https://") && !isLocalPath(url)) textWithoutImages = textWithoutImages.replace(m[0], "").trim();
+		if (url && !isHttpUrl(url) && !isLocalPath(url)) textWithoutImages = textWithoutImages.replace(m[0], "").trim();
 	}
 	if (useMarkdown) await sendMarkdownReply(textWithoutImages, collectedImageUrls, mdMatches, bareUrlMatches, event, actx, sendWithRetry, consumeQuoteRef, deps);
 	else await sendPlainTextReply(textWithoutImages, collectedImageUrls, mdMatches, bareUrlMatches, event, actx, sendWithRetry, consumeQuoteRef, deps);
+	const hasVisibleTextOrInlineImage = Boolean(textWithoutImages.trim() || collectedImageUrls.length > 0);
+	let sentMediaCount = 0;
+	let sentFailureFallback = false;
 	if (localMediaToSend.length > 0) {
 		log?.debug?.(`Sending ${localMediaToSend.length} local media via sendMedia auto-routing`);
-		await autoMediaBatch({
+		sentMediaCount += await autoMediaBatch({
 			qualifiedTarget,
 			account,
 			replyToId: event.messageId,
 			mediaUrls: localMediaToSend,
 			mediaSender: deps.mediaSender,
+			...actx.mediaAccess ? { mediaAccess: actx.mediaAccess } : {},
+			...actx.mediaLocalRoots ? { mediaLocalRoots: actx.mediaLocalRoots } : {},
+			...actx.mediaReadFile ? { mediaReadFile: actx.mediaReadFile } : {},
 			log,
 			onSuccess: (mediaPath) => `Sent local media: ${mediaPath}`,
 			onResultError: (mediaPath, error) => `sendMedia(auto) error for ${mediaPath}: ${error}`,
 			onThrownError: (mediaPath, error) => `sendMedia(auto) failed for ${mediaPath}: ${error}`
 		});
+		if (!hasVisibleTextOrInlineImage && sentMediaCount === 0) {
+			await sendTextChunks(DEFAULT_MEDIA_SEND_ERROR, event, actx, sendWithRetry, consumeQuoteRef, deps);
+			sentFailureFallback = true;
+		}
 	}
 	if (toolMediaUrls.length > 0) {
 		log?.debug?.(`Forwarding ${toolMediaUrls.length} tool-collected media URL(s) after block deliver`);
-		await autoMediaBatch({
+		sentMediaCount += await autoMediaBatch({
 			qualifiedTarget,
 			account,
 			replyToId: event.messageId,
 			mediaUrls: toolMediaUrls,
 			mediaSender: deps.mediaSender,
+			...actx.mediaAccess ? { mediaAccess: actx.mediaAccess } : {},
+			...actx.mediaLocalRoots ? { mediaLocalRoots: actx.mediaLocalRoots } : {},
+			...actx.mediaReadFile ? { mediaReadFile: actx.mediaReadFile } : {},
 			log,
 			onSuccess: (mediaUrl) => `Forwarded tool media: ${mediaUrl.slice(0, 80)}...`,
 			onResultError: (_mediaUrl, error) => `Tool media forward error: ${error}`,
 			onThrownError: (_mediaUrl, error) => `Tool media forward failed: ${error}`
 		});
+		if (!hasVisibleTextOrInlineImage && sentMediaCount === 0 && !sentFailureFallback) await sendTextChunks(DEFAULT_MEDIA_SEND_ERROR, event, actx, sendWithRetry, consumeQuoteRef, deps);
 		toolMediaUrls.length = 0;
 	}
 }
@@ -3622,8 +3688,8 @@ async function sendMarkdownReply(textWithoutImages, imageUrls, mdMatches, bareUr
 	const { account, log } = actx;
 	const httpImageUrls = [];
 	const base64ImageUrls = [];
-	for (const url of imageUrls) if (url.startsWith("data:image/")) base64ImageUrls.push(url);
-	else if (url.startsWith("http://") || url.startsWith("https://")) httpImageUrls.push(url);
+	for (const url of imageUrls) if (isImageDataUrl(url)) base64ImageUrls.push(url);
+	else if (isHttpUrl(url)) httpImageUrls.push(url);
 	log?.debug?.(`Image classification: httpUrls=${httpImageUrls.length}, base64=${base64ImageUrls.length}`);
 	if (base64ImageUrls.length > 0) {
 		log?.debug?.(`Sending ${base64ImageUrls.length} image(s) via Rich Media API...`);
@@ -3659,7 +3725,7 @@ async function sendMarkdownReply(textWithoutImages, imageUrls, mdMatches, bareUr
 	for (const m of mdMatches) {
 		const fullMatch = m[0];
 		const imgUrl = m[2];
-		if ((imgUrl.startsWith("http://") || imgUrl.startsWith("https://")) && !hasQQBotImageSize(fullMatch)) try {
+		if (isHttpUrl(imgUrl) && !hasQQBotImageSize(fullMatch)) try {
 			const size = await getImageSize(imgUrl);
 			result = result.replace(fullMatch, formatQQBotMarkdownImage(imgUrl, size));
 			log?.debug?.(`Updated image with size: ${size ? `${size.width}x${size.height}` : "default"} - ${imgUrl.slice(0, 60)}...`);
@@ -3687,7 +3753,7 @@ async function sendMarkdownReply(textWithoutImages, imageUrls, mdMatches, bareUr
 }
 async function sendPlainTextReply(textWithoutImages, imageUrls, mdMatches, bareUrlMatches, event, actx, sendWithRetry, consumeQuoteRef, deps) {
 	const { account, log } = actx;
-	const imgMediaTarget = resolveMediaTargetContext(event, account);
+	const imgMediaTarget = resolveMediaTargetContext(event, actx);
 	let result = textWithoutImages;
 	for (const m of mdMatches) result = result.replace(m[0], "").trim();
 	for (const m of bareUrlMatches) result = result.replace(m[0], "").trim();
@@ -3798,13 +3864,27 @@ function formatMediaTypeLabel(mediaType) {
 	return mediaType[0].toUpperCase() + mediaType.slice(1);
 }
 function validateStructuredPayloadLocalPath(ctx, payloadPath, mediaType) {
-	const allowedPath = resolveTrustedOutboundMediaPath(payloadPath);
-	if (allowedPath) return allowedPath;
+	const candidatePaths = resolveWorkspacePathCandidates(normalizePath(payloadPath), ctx.mediaAccess?.workspaceDir);
+	const localRoots = resolveWorkspaceScopedLocalRoots(resolveOutboundMediaLocalRoots(ctx), ctx.mediaAccess?.workspaceDir);
+	const allowMissingHostRead = Boolean(resolveStructuredPayloadReadFile(ctx));
+	for (const candidatePath of candidatePaths) {
+		const allowedPath = resolveTrustedOutboundMediaPath(candidatePath, { allowMissing: allowMissingHostRead });
+		if (allowedPath) return allowedPath;
+		if (localRoots) {
+			const scopedPath = resolveLocalPathFromRootsSync({
+				filePath: candidatePath,
+				roots: localRoots,
+				label: "QQ Bot local roots",
+				allowMissing: allowMissingHostRead
+			})?.path;
+			if (scopedPath) return scopedPath;
+		}
+	}
 	ctx.log?.error(`Blocked ${mediaType} payload local path outside QQ Bot media storage`);
 	return null;
 }
 function isRemoteHttpUrl(p) {
-	return p.startsWith("http://") || p.startsWith("https://");
+	return /^https?:\/\//i.test(p);
 }
 function isInlineImageDataUrl(p) {
 	return /^data:image\/[^;]+;base64,/i.test(p);
@@ -3839,14 +3919,48 @@ function describeMediaTargetForLog(pathValue, isHttpUrl) {
 		return "<invalid-url>";
 	}
 }
-/**
-* Read a local file into memory for image base64 inlining.
-*
-* Non-image media (video / file) should pass `source: { localPath }` to
-* `sender.sendMedia` directly — the sender pipeline handles chunked
-* routing once this function validates the per-type ceiling.
-*/
-async function readLocalFileForInlineBase64(filePath, fileType) {
+function resolveStructuredPayloadReadFile(ctx) {
+	return ctx.mediaAccess?.readFile ?? ctx.mediaReadFile;
+}
+function assertBufferWithinTypeLimit(buffer, fileType) {
+	const maxSize = getMaxUploadSize(fileType);
+	if (buffer.length > maxSize) throw new Error(`File is too large (${formatFileSize(buffer.length)}); QQ Bot API limit is ${formatFileSize(maxSize)}`);
+}
+function imageBufferMatchesMime(buffer, mimeType) {
+	if (mimeType === "image/png") return buffer.subarray(0, 8).equals(Buffer.from([
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	]));
+	if (mimeType === "image/jpeg") return buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255;
+	if (mimeType === "image/gif") {
+		const header = buffer.subarray(0, 6).toString("ascii");
+		return header === "GIF87a" || header === "GIF89a";
+	}
+	if (mimeType === "image/webp") return buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP";
+	if (mimeType === "image/bmp") return buffer.subarray(0, 2).toString("ascii") === "BM";
+	return false;
+}
+async function readLocalFileForInlineBase64(ctx, filePath, fileType) {
+	const mediaReadFile = resolveStructuredPayloadReadFile(ctx);
+	if (mediaReadFile) {
+		let buffer = null;
+		try {
+			buffer = await mediaReadFile(filePath);
+		} catch (err) {
+			ctx.log?.debug?.(`Structured payload host read failed: ${formatErrorMessage(err)}`);
+		}
+		if (buffer !== null) {
+			assertBufferWithinTypeLimit(buffer, fileType);
+			if (buffer.length === 0) throw new Error(`File is empty: ${filePath}`);
+			return buffer;
+		}
+	}
 	const opened = await openLocalFile(filePath, { maxSize: getMaxUploadSize(fileType) });
 	try {
 		return await opened.handle.readFile();
@@ -3854,15 +3968,20 @@ async function readLocalFileForInlineBase64(filePath, fileType) {
 		await opened.close();
 	}
 }
-/**
-* Enforce the per-{@link MediaFileType} upload ceiling before handing a
-* local path to `sender.sendMedia`. The sender's internal `normalizeSource`
-* uses an unlimited cap so it can accept whatever size the policy layer
-* (outbound / reply-dispatcher) approves; the policy gate lives here.
-*
-* Returns the validated byte size. Throws via {@link openLocalFile} with a
-* human-readable "File is too large" message when exceeding the ceiling.
-*/
+async function readPayloadFileBuffer(ctx, filePath, fileType) {
+	const mediaReadFile = resolveStructuredPayloadReadFile(ctx);
+	if (!mediaReadFile) return null;
+	let buffer;
+	try {
+		buffer = await mediaReadFile(filePath);
+	} catch (err) {
+		ctx.log?.debug?.(`Structured payload host read failed: ${formatErrorMessage(err)}`);
+		return null;
+	}
+	assertBufferWithinTypeLimit(buffer, fileType);
+	if (buffer.length === 0) throw new Error(`File is empty: ${filePath}`);
+	return buffer;
+}
 async function assertLocalFileWithinTypeLimit(filePath, fileType) {
 	const opened = await openLocalFile(filePath, { maxSize: getMaxUploadSize(fileType) });
 	try {
@@ -3884,15 +4003,15 @@ async function handleImagePayload(ctx, payload) {
 	if (!imageUrl) return;
 	const originalImagePath = payload.source === "file" ? imageUrl : void 0;
 	if (payload.source === "file") try {
-		const fileBuffer = await readLocalFileForInlineBase64(imageUrl, 1);
-		const base64Data = fileBuffer.toString("base64");
+		const fileBuffer = await readLocalFileForInlineBase64(ctx, imageUrl, 1);
 		const mimeType = getImageMimeType(imageUrl);
 		if (!mimeType) {
 			const ext = normalizeLowercaseStringOrEmpty$1(path.extname(imageUrl));
 			log?.error(`Unsupported image format: ${ext}`);
 			return;
 		}
-		imageUrl = `data:${mimeType};base64,${base64Data}`;
+		if (!imageBufferMatchesMime(fileBuffer, mimeType)) throw new Error(`File is not an image: ${imageUrl}`);
+		imageUrl = `data:${mimeType};base64,${fileBuffer.toString("base64")}`;
 		log?.debug?.(`Converted local image to Base64 (size: ${formatFileSize(fileBuffer.length)})`);
 	} catch (readErr) {
 		log?.error(`Failed to read local image: ${readErr instanceof Error ? readErr.message : JSON.stringify(readErr)}`);
@@ -3910,8 +4029,8 @@ async function handleImagePayload(ctx, payload) {
 				msgId: target.messageId,
 				localPathForMeta: originalImagePath
 			});
-			else if (deliveryTarget.type === "dm") await sendText(deliveryTarget, `![](${payload.path})`, creds, { msgId: target.messageId });
-			else await sendText(deliveryTarget, `![](${payload.path})`, creds, { msgId: target.messageId });
+			else if (deliveryTarget.type === "dm") await sendText(deliveryTarget, `![](${imageUrl})`, creds, { msgId: target.messageId });
+			else await sendText(deliveryTarget, `![](${imageUrl})`, creds, { msgId: target.messageId });
 		}, log, account.accountId);
 		log?.debug?.(`Sent image via media payload`);
 		if (payload.caption) await sendTextToTarget(ctx, payload.caption);
@@ -4001,6 +4120,20 @@ async function handleVideoPayload(ctx, payload) {
 				msgId: target.messageId
 			});
 			else {
+				const payloadBuffer = await readPayloadFileBuffer(ctx, videoPath, 2);
+				if (payloadBuffer) {
+					await sendMedia({
+						target: deliveryTarget,
+						creds,
+						kind: "video",
+						source: {
+							buffer: payloadBuffer,
+							fileName: sanitizeFileName(path.basename(videoPath))
+						},
+						msgId: target.messageId
+					});
+					return;
+				}
 				const size = await assertLocalFileWithinTypeLimit(videoPath, 2);
 				log?.debug?.(`Video local (${formatFileSize(size)}): ${describeMediaTargetForLog(videoPath, false)}`);
 				await sendMedia({
@@ -4044,6 +4177,21 @@ async function handleFilePayload(ctx, payload) {
 				fileName
 			});
 			else {
+				const payloadBuffer = await readPayloadFileBuffer(ctx, filePath, 4);
+				if (payloadBuffer) {
+					await sendMedia({
+						target: deliveryTarget,
+						creds,
+						kind: "file",
+						source: {
+							buffer: payloadBuffer,
+							fileName
+						},
+						msgId: target.messageId,
+						fileName
+					});
+					return;
+				}
 				const size = await assertLocalFileWithinTypeLimit(filePath, 4);
 				log?.debug?.(`File local (${formatFileSize(size)}): ${describeMediaTargetForLog(filePath, false)}`);
 				await sendMedia({
@@ -4186,7 +4334,7 @@ function findFirstClosedMediaTag(text, log) {
 * 媒体发送失败时，通过 onSendText 发送兜底文本通知用户。
 */
 async function executeSendQueue(queue, ctx, options = {}) {
-	const { mediaTarget, qualifiedTarget, account, replyToId, log } = ctx;
+	const { mediaTarget, qualifiedTarget, account, replyToId, log, mediaAccess, mediaLocalRoots, mediaReadFile } = ctx;
 	const prefix = mediaTarget.logPrefix ?? `[qqbot:${account.accountId}]`;
 	/** 媒体发送失败时的兜底：通过 onSendText 发送错误文本给用户 */
 	const sendFallbackText = async (errorMsg) => {
@@ -4255,7 +4403,10 @@ async function executeSendQueue(queue, ctx, options = {}) {
 				mediaUrl: item.content,
 				accountId: account.accountId,
 				replyToId,
-				account
+				account,
+				...mediaAccess ? { mediaAccess } : {},
+				...mediaLocalRoots ? { mediaLocalRoots } : {},
+				...mediaReadFile ? { mediaReadFile } : {}
 			});
 			if (result.error) {
 				log?.error(`${prefix} sendMedia(auto) error: ${result.error}`);
@@ -5035,18 +5186,25 @@ var StreamingController = class {
 */
 function toMediaSendContext(ctx) {
 	const { account, event, log } = ctx;
+	const mediaAccessContext = {
+		...ctx.mediaAccess ? { mediaAccess: ctx.mediaAccess } : {},
+		...ctx.mediaLocalRoots ? { mediaLocalRoots: ctx.mediaLocalRoots } : {},
+		...ctx.mediaReadFile ? { mediaReadFile: ctx.mediaReadFile } : {}
+	};
 	return {
 		mediaTarget: {
 			targetType: event.type,
 			targetId: event.type === "c2c" ? event.senderId : event.type === "group" ? event.groupOpenid : event.channelId,
 			account,
 			replyToId: event.messageId,
-			logPrefix: `[qqbot:${account.accountId}]`
+			logPrefix: `[qqbot:${account.accountId}]`,
+			...mediaAccessContext
 		},
 		qualifiedTarget: event.type === "group" ? `qqbot:group:${event.groupOpenid}` : `qqbot:c2c:${event.senderId}`,
 		account,
 		replyToId: event.messageId,
-		log
+		log,
+		...mediaAccessContext
 	};
 }
 /**
@@ -5551,6 +5709,9 @@ function blockReplyTextForDelivery(payload) {
 function isSilentBlockReply(payload) {
 	return !hasReplyMedia(payload) && isSilentBlockReplyText((payload.text ?? "").trim());
 }
+function isMediaOnlyBlockReply(payload) {
+	return hasReplyMedia(payload) && isSilentBlockReplyText((payload.text ?? "").trim());
+}
 /**
 * Dispatch the AI reply for the given inbound context.
 *
@@ -5560,6 +5721,13 @@ function isSilentBlockReply(payload) {
 async function dispatchOutbound(inbound, deps) {
 	const { runtime, cfg, account, log } = deps;
 	const { event, qualifiedTarget } = inbound;
+	const openClawCfg = cfg;
+	const routeAgentId = inbound.route.agentId ?? resolveDefaultAgentId(openClawCfg);
+	const workspaceDir = resolveAgentWorkspaceDir(openClawCfg, routeAgentId);
+	const gatewayMediaContext = workspaceDir ? {
+		mediaAccess: { workspaceDir },
+		mediaLocalRoots: [workspaceDir]
+	} : {};
 	const replyCtx = {
 		target: {
 			type: event.type,
@@ -5571,7 +5739,8 @@ async function dispatchOutbound(inbound, deps) {
 		},
 		account,
 		cfg,
-		log
+		log,
+		...gatewayMediaContext
 	};
 	const sendWithRetry = (sendFn) => sendWithTokenRetry(account.appId, account.clientSecret, sendFn, log, account.accountId);
 	const sendErrorMessage = (errorText) => sendErrorToTarget(replyCtx, errorText);
@@ -5609,7 +5778,8 @@ async function dispatchOutbound(inbound, deps) {
 				mediaUrl,
 				accountId: account.accountId,
 				replyToId: event.messageId,
-				account
+				account,
+				...gatewayMediaContext
 			}).then((r) => {
 				if (ac.signal.aborted) return {
 					channel: "qqbot",
@@ -5633,13 +5803,10 @@ async function dispatchOutbound(inbound, deps) {
 		}
 	};
 	const sendToolFallback = async () => {
-		if (toolMediaUrls.length > 0) {
-			for (const mediaUrl of toolMediaUrls) await sendToolMediaWithTimeout(mediaUrl, {
-				resultError: "Tool fallback error",
-				thrownError: "Tool fallback failed"
-			});
-			return;
-		}
+		if (toolMediaUrls.length > 0) for (const mediaUrl of toolMediaUrls) await sendToolMediaWithTimeout(mediaUrl, {
+			resultError: "Tool fallback error",
+			thrownError: "Tool fallback failed"
+		});
 		if (toolTexts.length > 0) await sendErrorMessage(toolTexts.slice(-3).join("\n---\n").slice(0, 2e3));
 	};
 	const hasPendingToolFallbackPayload = () => toolTexts.length > 0 || toolMediaUrls.length > 0;
@@ -5731,7 +5898,8 @@ async function dispatchOutbound(inbound, deps) {
 			}, {
 				account,
 				qualifiedTarget,
-				log
+				log,
+				...gatewayMediaContext
 			}, sendWithRetry, () => void 0, deliverDeps);
 		}
 	};
@@ -5740,7 +5908,7 @@ async function dispatchOutbound(inbound, deps) {
 		accountId: account.accountId,
 		direction: "outbound"
 	});
-	const messagesConfig = runtime.channel.reply.resolveEffectiveMessagesConfig(cfg, inbound.route.agentId);
+	const messagesConfig = runtime.channel.reply.resolveEffectiveMessagesConfig(cfg, routeAgentId);
 	const useOfficialC2cStream = shouldUseOfficialC2cStream(account, event.type === "c2c" ? "c2c" : event.type === "group" ? "group" : "channel");
 	const deliverToolProgressImmediately = shouldDeliverToolProgressImmediately(account, useOfficialC2cStream);
 	let streamingController = null;
@@ -5760,12 +5928,12 @@ async function dispatchOutbound(inbound, deps) {
 				groupOpenid: event.groupOpenid,
 				channelId: event.channelId
 			},
-			log
+			log,
+			...gatewayMediaContext
 		}
 	});
 	const cfgWithSession = cfg;
-	const agentId = inbound.route.agentId ?? "default";
-	const storePath = runtime.channel.session.resolveStorePath(cfgWithSession.session?.store, { agentId });
+	const storePath = runtime.channel.session.resolveStorePath(cfgWithSession.session?.store, { agentId: routeAgentId });
 	const dispatchPromise = runtime.channel.inbound.run({
 		channel: "qqbot",
 		accountId: inbound.route.accountId,
@@ -5811,7 +5979,8 @@ async function dispatchOutbound(inbound, deps) {
 									}, {
 										account,
 										qualifiedTarget,
-										log
+										log,
+										...gatewayMediaContext
 									}, sendWithRetry, () => void 0, deliverDeps);
 									recordOutbound();
 									return;
@@ -5829,7 +5998,8 @@ async function dispatchOutbound(inbound, deps) {
 											mediaUrl,
 											accountId: account.accountId,
 											replyToId: event.messageId,
-											account
+											account,
+											...gatewayMediaContext
 										});
 									} catch {}
 									return;
@@ -5844,7 +6014,7 @@ async function dispatchOutbound(inbound, deps) {
 								return;
 							}
 							hasVisibleBlockResponse = true;
-							if (streamingController && !streamingController.isTerminalPhase) {
+							if (streamingController && !streamingController.isTerminalPhase && !isMediaOnlyBlockReply(payload)) {
 								try {
 									await streamingController.onDeliver(payload);
 								} catch (err) {
@@ -5881,7 +6051,8 @@ async function dispatchOutbound(inbound, deps) {
 							const deliverActx = {
 								account,
 								qualifiedTarget,
-								log
+								log,
+								...gatewayMediaContext
 							};
 							const mediaResult = await parseAndSendMediaTags(replyText, deliverEvent, deliverActx, sendWithRetry, consumeQuoteRef, deliverDeps);
 							if (mediaResult.handled) {
@@ -6002,7 +6173,7 @@ async function buildCtxPayload(inbound, runtime, cfg) {
 			id: inbound.peerId
 		},
 		route: {
-			agentId: inbound.route.agentId ?? "main",
+			agentId: inbound.route.agentId ?? resolveDefaultAgentId(cfg),
 			routeSessionKey: inbound.route.sessionKey,
 			accountId: inbound.route.accountId
 		},