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

package/dist/{group-DQQsZ6Y0.js → group-BmS1Qwst.js}

@@ -1,7 +1,7 @@
 import { t as asOptionalObjectRecord } from "./string-normalize-R_0cKO7Q.js";
 import { d as resolveAccountBase } from "./config-C1qZbh0K.js";
 import { n as debugLog } from "./log-SDfMMBWe.js";
-import { A as getHomeDir, I as isWindows, N as getQQBotMediaPath, j as getQQBotDataDir } from "./outbound-Dfa2uOEp.js";
+import { I as getQQBotMediaPath, N as getHomeDir, P as getQQBotDataDir, z as isWindows } from "./outbound-BZHwMFUX.js";
 import { asBoolean, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs";
 import path from "node:path";

package/dist/{handler-runtime-BQ72YPsH.js → handler-runtime-rU03VA43.js}

@@ -1,6 +1,6 @@
-import { c as getMessageApi, t as accountToCreds } from "./sender-BHWpE_yH.js";
-import { o as ensurePlatformAdapter, s as getBridgeLogger } from "./config-schema-gMW9zKvQ.js";
-import { c as resolveQQBotExecApprovalConfig, d as buildExecApprovalText, f as buildPluginApprovalText, l as shouldHandleQQBotExecApprovalRequest, m as resolveApprovalTarget, o as isQQBotExecApprovalClientEnabled, s as matchesQQBotApprovalAccount, u as buildApprovalKeyboard } from "./channel-Bh0MrYvU.js";
+import { c as getMessageApi, t as accountToCreds } from "./sender-BfVLJJYp.js";
+import { o as ensurePlatformAdapter, s as getBridgeLogger } from "./config-schema-JZEf1dvB.js";
+import { c as resolveQQBotExecApprovalConfig, d as buildExecApprovalText, f as buildPluginApprovalText, l as shouldHandleQQBotExecApprovalRequest, m as resolveApprovalTarget, o as isQQBotExecApprovalClientEnabled, s as matchesQQBotApprovalAccount, u as buildApprovalKeyboard } from "./channel-BQM6pDlD.js";
 import { a as resolveQQBotAccount } from "./config-C1qZbh0K.js";
 import { resolveApprovalRequestSessionConversation } from "openclaw/plugin-sdk/approval-native-runtime";
 import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";

package/dist/{outbound-Dfa2uOEp.js → outbound-BZHwMFUX.js}

@@ -1,13 +1,16 @@
-import { A as getFileTypeName, D as downloadFile, E as checkFileSize, L as __exportAll, M as getMaxUploadSize, N as readFileAsync, O as fileExistsAsync, S as UploadDailyLimitExceededError, g as sendText$1, h as sendMedia$1, j as getImageMimeType, k as formatFileSize, t as accountToCreds, u as initApiConfig, w as UPLOAD_PREPARE_FALLBACK_CODE } from "./sender-BHWpE_yH.js";
+import { A as getFileTypeName, D as downloadFile, E as checkFileSize, L as __exportAll, M as getMaxUploadSize, N as readFileAsync, O as fileExistsAsync, S as UploadDailyLimitExceededError, g as sendText$1, h as sendMedia$1, j as getImageMimeType, k as formatFileSize, t as accountToCreds, u as initApiConfig, w as UPLOAD_PREPARE_FALLBACK_CODE } from "./sender-BfVLJJYp.js";
 import { c as getPlatformAdapter, i as normalizeOptionalString, n as normalizeLowercaseStringOrEmpty, s as sanitizeFileName } from "./string-normalize-R_0cKO7Q.js";
 import { a as formatErrorMessage, n as debugLog, r as debugWarn, t as debugError } from "./log-SDfMMBWe.js";
 import { r as parseTarget$1 } from "./target-parser-DagYRQkP.js";
-import * as fs$1 from "node:fs";
+import * as fs$2 from "node:fs";
 import * as os$1 from "node:os";
+import { randomUUID } from "node:crypto";
 import { pathExistsSync, resolveLocalPathFromRootsSync } from "openclaw/plugin-sdk/security-runtime";
 import * as path$1 from "node:path";
 import path from "node:path";
-import { getFileExtension } from "openclaw/plugin-sdk/media-mime";
+import { extensionForMime, getFileExtension } from "openclaw/plugin-sdk/media-mime";
+import { mkdir, writeFile } from "node:fs/promises";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
 import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/sandbox";
 //#region extensions/qqbot/src/engine/utils/platform.ts
 /**
@@ -32,10 +35,10 @@ import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/sandbox";
 function getHomeDir() {
 	try {
 		const home = os$1.homedir();
-		if (home && fs$1.existsSync(home)) return home;
+		if (home && fs$2.existsSync(home)) return home;
 	} catch {}
 	const envHome = process.env.HOME || process.env.USERPROFILE;
-	if (envHome && fs$1.existsSync(envHome)) return envHome;
+	if (envHome && fs$2.existsSync(envHome)) return envHome;
 	return getPlatformAdapter().getTempDir();
 }
 /**
@@ -76,7 +79,7 @@ function getQQBotDataPath(...subPaths) {
 /** Return a path under `~/.openclaw/qqbot`, creating it on demand. */
 function getQQBotDataDir(...subPaths) {
 	const dir = getQQBotDataPath(...subPaths);
-	if (!fs$1.existsSync(dir)) fs$1.mkdirSync(dir, { recursive: true });
+	if (!fs$2.existsSync(dir)) fs$2.mkdirSync(dir, { recursive: true });
 	return dir;
 }
 /**
@@ -94,7 +97,7 @@ function getQQBotMediaPath(...subPaths) {
 /** Return a path under `<openclaw-home>/.openclaw/media/qqbot`, creating it on demand. */
 function getQQBotMediaDir(...subPaths) {
 	const dir = getQQBotMediaPath(...subPaths);
-	if (!fs$1.existsSync(dir)) fs$1.mkdirSync(dir, { recursive: true });
+	if (!fs$2.existsSync(dir)) fs$2.mkdirSync(dir, { recursive: true });
 	return dir;
 }
 /**
@@ -163,14 +166,14 @@ function isLocalPath(p) {
 	if (p.startsWith(".\\") || p.startsWith("..\\")) return true;
 	return false;
 }
-function isPathWithinRoot(candidate, root) {
+function isPathWithinRoot$1(candidate, root) {
 	const relative = path$1.relative(root, candidate);
 	return relative === "" || !relative.startsWith("..") && !path$1.isAbsolute(relative);
 }
 /** Remap legacy or hallucinated QQ Bot local media paths to real files when possible. */
 function resolveQQBotLocalMediaPath(p) {
 	const normalized = normalizePath$1(p);
-	if (!isLocalPath(normalized) || fs$1.existsSync(normalized)) return normalized;
+	if (!isLocalPath(normalized) || fs$2.existsSync(normalized)) return normalized;
 	const osHomeDir = getHomeDir();
 	const openclawHomeDir = resolveOpenClawHome();
 	const mediaRoot = getQQBotMediaPath();
@@ -190,10 +193,10 @@ function resolveQQBotLocalMediaPath(p) {
 		}
 	];
 	for (const { from, to } of candidateRoots) {
-		if (!isPathWithinRoot(normalized, from)) continue;
+		if (!isPathWithinRoot$1(normalized, from)) continue;
 		const relative = path$1.relative(from, normalized);
 		const candidate = path$1.join(to, relative);
-		if (fs$1.existsSync(candidate)) {
+		if (fs$2.existsSync(candidate)) {
 			debugWarn(`[platform] Remapped missing QQBot media path ${normalized} -> ${candidate}`);
 			return candidate;
 		}
@@ -208,12 +211,12 @@ function resolveQQBotPayloadLocalFilePath(p) {
 	const candidate = resolveQQBotLocalMediaPath(p);
 	if (!candidate.trim()) return null;
 	const resolvedCandidate = path$1.resolve(candidate);
-	if (!fs$1.existsSync(resolvedCandidate)) return null;
-	const canonicalCandidate = fs$1.realpathSync(resolvedCandidate);
+	if (!fs$2.existsSync(resolvedCandidate)) return null;
+	const canonicalCandidate = fs$2.realpathSync(resolvedCandidate);
 	const allowedRoots = [getOpenClawMediaDir(), getQQBotMediaPath()];
 	for (const root of allowedRoots) {
 		const resolvedRoot = path$1.resolve(root);
-		if (isPathWithinRoot(canonicalCandidate, fs$1.existsSync(resolvedRoot) ? fs$1.realpathSync(resolvedRoot) : resolvedRoot)) return canonicalCandidate;
+		if (isPathWithinRoot$1(canonicalCandidate, fs$2.existsSync(resolvedRoot) ? fs$2.realpathSync(resolvedRoot) : resolvedRoot)) return canonicalCandidate;
 	}
 	return null;
 }
@@ -406,6 +409,46 @@ function buildFileTooLargeResult(fileType, fileSize) {
 	};
 }
 //#endregion
+//#region extensions/qqbot/src/engine/messaging/outbound-media-path.ts
+function mergeMediaLocalRoots(...groups) {
+	const roots = groups.flatMap((group) => group ?? []).map((root) => root.trim()).filter(Boolean);
+	return roots.length > 0 ? Array.from(new Set(roots)) : void 0;
+}
+function resolveOutboundMediaLocalRoots(ctx) {
+	return mergeMediaLocalRoots(ctx.mediaAccess?.localRoots, ctx.mediaLocalRoots);
+}
+function isPathWithinRoot(candidatePath, rootPath) {
+	const resolvedRoot = path.resolve(rootPath);
+	if (resolvedRoot === path.parse(resolvedRoot).root) return false;
+	const relative = path.relative(resolvedRoot, path.resolve(candidatePath));
+	return relative === "" || relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function resolvePathInsideWorkspace(workspaceDir, pathWithinWorkspace) {
+	const mappedPath = path.resolve(workspaceDir, pathWithinWorkspace);
+	return isPathWithinRoot(mappedPath, workspaceDir) ? mappedPath : null;
+}
+function isVirtualWorkspacePath(normalizedPath) {
+	return normalizedPath === "/workspace" || normalizedPath.startsWith("/workspace/");
+}
+function resolveWorkspaceScopedLocalRoots(roots, workspaceDir) {
+	if (!roots?.length) return;
+	const scopedRoots = roots.map((root) => root.trim()).filter(Boolean).map((root) => workspaceDir && isVirtualWorkspacePath(root) ? resolveWorkspacePathCandidate(root, workspaceDir) : root).filter((root) => Boolean(root));
+	return scopedRoots.length > 0 ? Array.from(new Set(scopedRoots)) : void 0;
+}
+function resolveWorkspacePathCandidate(normalizedPath, workspaceDir) {
+	if (!workspaceDir) return isVirtualWorkspacePath(normalizedPath) ? null : normalizedPath;
+	if (normalizedPath === "/workspace") return workspaceDir;
+	if (normalizedPath.startsWith("/workspace/")) return resolvePathInsideWorkspace(workspaceDir, normalizedPath.slice(11));
+	if (path.isAbsolute(normalizedPath)) return normalizedPath;
+	return resolvePathInsideWorkspace(workspaceDir, normalizedPath);
+}
+function resolveWorkspacePathCandidates(normalizedPath, workspaceDir) {
+	const mappedPath = resolveWorkspacePathCandidate(normalizedPath, workspaceDir);
+	if (!mappedPath) return [];
+	if (mappedPath === normalizedPath) return [normalizedPath];
+	return path.isAbsolute(normalizedPath) && !isVirtualWorkspacePath(normalizedPath) ? [normalizedPath, mappedPath] : [mappedPath];
+}
+//#endregion
 //#region extensions/qqbot/src/engine/messaging/trusted-media-path.ts
 let cachedTrustedTmpRoot;
 function trustedOpenClawTmpRoot() {
@@ -462,11 +505,15 @@ function parseTarget(to) {
 /** Build a media target from a normal outbound context. */
 function buildMediaTarget(ctx) {
 	const target = parseTarget(ctx.to);
+	const mediaLocalRoots = resolveOutboundMediaLocalRoots(ctx);
 	return {
 		targetType: target.type,
 		targetId: target.id,
 		account: ctx.account,
-		replyToId: ctx.replyToId ?? void 0
+		replyToId: ctx.replyToId ?? void 0,
+		...mediaLocalRoots ? { mediaLocalRoots } : {},
+		...ctx.mediaAccess ? { mediaAccess: ctx.mediaAccess } : {},
+		...ctx.mediaReadFile ? { mediaReadFile: ctx.mediaReadFile } : {}
 	};
 }
 /** Return true when public URLs should be passed through directly. */
@@ -480,19 +527,28 @@ const qqBotMediaKindLabel = {
 	file: "File",
 	media: "Media"
 };
+function isHttpUrl(pathValue) {
+	return pathValue.startsWith("http://") || pathValue.startsWith("https://");
+}
+function isDataUrl(pathValue) {
+	return pathValue.startsWith("data:");
+}
 function isHttpOrDataSource(pathValue) {
-	return pathValue.startsWith("http://") || pathValue.startsWith("https://") || pathValue.startsWith("data:");
+	return isHttpUrl(pathValue) || isDataUrl(pathValue);
 }
-function resolveMissingPathWithinMediaRoot(normalizedPath) {
+function resolveMissingPathWithinRoots(normalizedPath, allowedRoots) {
 	const resolvedCandidate = path.resolve(normalizedPath);
 	if (pathExistsSync(resolvedCandidate)) return null;
 	return resolveLocalPathFromRootsSync({
 		filePath: resolvedCandidate,
-		roots: [getQQBotMediaDir()],
-		label: "QQ Bot media storage",
+		roots: allowedRoots,
+		label: "QQ Bot local roots",
 		allowMissing: true
 	})?.path ?? null;
 }
+function isPathWithinAnyRoot(candidatePath, allowedRoots) {
+	return allowedRoots?.some((root) => root.trim() && isPathWithinRoot(candidatePath, root)) ?? false;
+}
 function resolveExistingPathWithinRoots(normalizedPath, allowedRoots) {
 	return resolveLocalPathFromRootsSync({
 		filePath: normalizedPath,
@@ -500,30 +556,166 @@ function resolveExistingPathWithinRoots(normalizedPath, allowedRoots) {
 		label: "QQ Bot local roots"
 	})?.path ?? null;
 }
+function resolveOutboundMediaReadFile(ctx) {
+	return ctx.mediaAccess?.readFile ?? ctx.mediaReadFile;
+}
+function resolveHostReadMediaAccess(ctx) {
+	const mediaLocalRoots = resolveWorkspaceScopedLocalRoots(resolveOutboundMediaLocalRoots(ctx), ctx.mediaAccess?.workspaceDir);
+	if (!ctx.mediaAccess && !mediaLocalRoots) return;
+	const { localRoots: _localRoots, ...mediaAccessWithoutRoots } = ctx.mediaAccess ?? {};
+	return {
+		...mediaAccessWithoutRoots,
+		...mediaLocalRoots ? { localRoots: mediaLocalRoots } : {}
+	};
+}
+function mediaFileTypeForKind(mediaKind) {
+	switch (mediaKind) {
+		case "image": return 1;
+		case "voice": return 3;
+		case "video": return 2;
+		default: return 4;
+	}
+}
+function senderKindForLoadedMedia(mediaKind, loadedKind) {
+	if (mediaKind === "image") return loadedKind === "image" ? "image" : null;
+	if (mediaKind === "video") return loadedKind === "video" ? "video" : null;
+	if (mediaKind === "file") return "file";
+	if (loadedKind === "image") return "image";
+	if (loadedKind === "video") return "video";
+	return "file";
+}
+function resolveHostReadMediaPath(ctx, mediaPath) {
+	const normalizedPath = normalizePath$1(mediaPath);
+	if (path.isAbsolute(normalizedPath)) {
+		if (normalizedPath === "/workspace" || normalizedPath.startsWith("/workspace/")) return ctx.mediaAccess?.workspaceDir ? resolveWorkspacePathCandidate(normalizedPath, ctx.mediaAccess.workspaceDir) : null;
+		if (isPathWithinAnyRoot(normalizedPath, resolveOutboundMediaLocalRoots(ctx))) return normalizedPath;
+		return null;
+	}
+	if (!ctx.mediaAccess?.workspaceDir) return null;
+	return resolveWorkspacePathCandidate(normalizedPath, ctx.mediaAccess.workspaceDir);
+}
+async function stageLoadedHostReadVoice(mediaPath, loaded) {
+	const stagedDir = getQQBotMediaDir("host-read", "voice");
+	await mkdir(stagedDir, { recursive: true });
+	const rawFileName = sanitizeFileName(loaded.fileName || path.basename(mediaPath) || "voice");
+	const ext = path.extname(rawFileName);
+	const inferredExt = extensionForMime(loaded.contentType);
+	const baseName = sanitizeFileName(path.basename(rawFileName, ext)) || "voice";
+	const stagedPath = path.join(stagedDir, `${baseName}-${randomUUID()}${ext || inferredExt || ".bin"}`);
+	await writeFile(stagedPath, loaded.buffer);
+	return stagedPath;
+}
+async function stageHostReadVoice(ctx, mediaPath) {
+	const mediaReadFile = resolveOutboundMediaReadFile(ctx);
+	if (!mediaReadFile || isHttpOrDataSource(mediaPath)) return null;
+	const hostReadMediaPath = resolveHostReadMediaPath(ctx, mediaPath);
+	if (!hostReadMediaPath) return null;
+	const mediaAccess = resolveHostReadMediaAccess(ctx);
+	const loaded = await loadOutboundMediaFromUrl(hostReadMediaPath, {
+		maxBytes: getMaxUploadSize(3),
+		mediaAccess,
+		mediaReadFile,
+		workspaceDir: mediaAccess?.workspaceDir
+	});
+	if (loaded.kind !== "audio") throw new Error(`Unsupported voice media type: ${loaded.kind ?? "unknown"}`);
+	return await stageLoadedHostReadVoice(mediaPath, loaded);
+}
+async function trySendViaHostRead(ctx, mediaPath, mediaKind) {
+	const mediaReadFile = resolveOutboundMediaReadFile(ctx);
+	if (!mediaReadFile || isHttpOrDataSource(mediaPath)) return null;
+	const hostReadMediaPath = resolveHostReadMediaPath(ctx, mediaPath);
+	if (!hostReadMediaPath) return null;
+	const mediaAccess = resolveHostReadMediaAccess(ctx);
+	try {
+		const loaded = await loadOutboundMediaFromUrl(hostReadMediaPath, {
+			maxBytes: getMaxUploadSize(mediaFileTypeForKind(mediaKind)),
+			mediaAccess,
+			mediaReadFile,
+			workspaceDir: mediaAccess?.workspaceDir
+		});
+		const kind = senderKindForLoadedMedia(mediaKind, loaded.kind);
+		if (!kind) return {
+			channel: "qqbot",
+			error: `Unsupported ${mediaKind} media type: ${loaded.kind ?? "unknown"}`
+		};
+		if (loaded.buffer.length === 0) return {
+			channel: "qqbot",
+			error: `File is empty: ${hostReadMediaPath}`
+		};
+		if (mediaKind === "media" && loaded.kind === "audio") {
+			const directUploadFormats = ctx.account.config?.audioFormatPolicy?.uploadDirectFormats ?? ctx.account.config?.voiceDirectUploadFormats;
+			const transcodeEnabled = ctx.account.config?.audioFormatPolicy?.transcodeEnabled !== false;
+			return await sendVoiceFromLocal(ctx, await stageLoadedHostReadVoice(mediaPath, loaded), directUploadFormats, transcodeEnabled);
+		}
+		const creds = accountToCreds(ctx.account);
+		const target = {
+			type: ctx.targetType,
+			id: ctx.targetId
+		};
+		if (target.type !== "c2c" && target.type !== "group") return {
+			channel: "qqbot",
+			error: `${qqBotMediaKindLabel[mediaKind]} not supported in channel`
+		};
+		const r = await sendMedia$1({
+			target,
+			creds,
+			kind,
+			source: {
+				buffer: loaded.buffer,
+				...loaded.fileName ? { fileName: sanitizeFileName(loaded.fileName) } : {},
+				...loaded.contentType ? { mime: loaded.contentType } : {}
+			},
+			msgId: ctx.replyToId,
+			...kind === "file" && loaded.fileName ? { fileName: sanitizeFileName(loaded.fileName) } : {}
+		});
+		return {
+			channel: "qqbot",
+			messageId: r.id,
+			timestamp: r.timestamp
+		};
+	} catch (err) {
+		if (err instanceof UploadDailyLimitExceededError) return buildDailyLimitExceededResult(err.filePath === "<buffer>" ? new UploadDailyLimitExceededError(hostReadMediaPath, err.fileSize, err.message) : err);
+		return {
+			channel: "qqbot",
+			error: formatErrorMessage(err)
+		};
+	}
+}
+async function sendAutoDetectedMedia(ctx, mediaPath) {
+	const hostReadResult = await trySendViaHostRead(ctx, mediaPath, "media");
+	if (hostReadResult) return hostReadResult;
+	return await sendDocument(ctx, mediaPath);
+}
 function resolveOutboundMediaPath(rawPath, mediaKind, options = {}) {
 	const normalizedPath = normalizePath$1(rawPath);
 	if (isHttpOrDataSource(normalizedPath)) return {
 		ok: true,
 		mediaPath: normalizedPath
 	};
-	const allowedPath = resolveTrustedOutboundMediaPath(normalizedPath, { allowMissing: options.allowMissingLocalPath });
-	if (allowedPath) return {
-		ok: true,
-		mediaPath: allowedPath
-	};
-	if (options.extraLocalRoots && options.extraLocalRoots.length > 0) {
-		const extraAllowedPath = resolveExistingPathWithinRoots(normalizedPath, options.extraLocalRoots);
-		if (extraAllowedPath) return {
+	const candidatePaths = resolveWorkspacePathCandidates(normalizedPath, options.workspaceDir);
+	for (const candidatePath of candidatePaths) {
+		const allowedPath = resolveTrustedOutboundMediaPath(candidatePath, { allowMissing: options.allowMissingLocalPath });
+		if (allowedPath) return {
 			ok: true,
-			mediaPath: extraAllowedPath
+			mediaPath: allowedPath
 		};
+		if (options.extraLocalRoots && options.extraLocalRoots.length > 0) {
+			const extraAllowedPath = resolveExistingPathWithinRoots(candidatePath, options.extraLocalRoots);
+			if (extraAllowedPath) return {
+				ok: true,
+				mediaPath: extraAllowedPath
+			};
+		}
 	}
 	if (options.allowMissingLocalPath) {
-		const allowedMissingPath = resolveMissingPathWithinMediaRoot(normalizedPath);
-		if (allowedMissingPath) return {
-			ok: true,
-			mediaPath: allowedMissingPath
-		};
+		const missingRoots = mergeMediaLocalRoots([getQQBotMediaDir()], options.extraLocalRoots);
+		if (missingRoots) for (const candidatePath of candidatePaths) {
+			const allowedMissingPath = resolveMissingPathWithinRoots(candidatePath, missingRoots);
+			if (allowedMissingPath) return {
+				ok: true,
+				mediaPath: allowedMissingPath
+			};
+		}
 	}
 	debugWarn(`blocked local ${mediaKind} path outside QQ Bot media storage`);
 	return {
@@ -535,15 +727,20 @@ function resolveOutboundMediaPath(rawPath, mediaKind, options = {}) {
 * Send a photo from a local file, public URL, or Base64 data URL.
 */
 async function sendPhoto(ctx, imagePath) {
-	const resolvedMediaPath = resolveOutboundMediaPath(imagePath, "image");
+	const hostReadResult = await trySendViaHostRead(ctx, imagePath, "image");
+	if (hostReadResult) return hostReadResult;
+	const resolvedMediaPath = resolveOutboundMediaPath(imagePath, "image", {
+		extraLocalRoots: resolveOutboundMediaLocalRoots(ctx),
+		workspaceDir: ctx.mediaAccess?.workspaceDir
+	});
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaPath = resolvedMediaPath.mediaPath;
 	const isLocal = isLocalPath(mediaPath);
-	const isHttp = mediaPath.startsWith("http://") || mediaPath.startsWith("https://");
-	const isData = mediaPath.startsWith("data:");
+	const isHttp = isHttpUrl(mediaPath);
+	const isData = isDataUrl(mediaPath);
 	if (isHttp && !shouldDirectUploadUrl(ctx.account)) {
 		debugLog(`sendPhoto: urlDirectUpload=false, downloading URL first...`);
 		const localFile = await downloadToFallbackDir(mediaPath, "sendPhoto");
@@ -663,13 +860,29 @@ async function sendPhotoFromLocal(ctx, mediaPath) {
 * URL handling respects `urlDirectUpload`, and local files are transcoded when needed.
 */
 async function sendVoice(ctx, voicePath, directUploadFormats, transcodeEnabled = true) {
-	const resolvedMediaPath = resolveOutboundMediaPath(voicePath, "voice", { allowMissingLocalPath: true });
+	let stagedHostReadVoice;
+	try {
+		stagedHostReadVoice = await stageHostReadVoice(ctx, voicePath);
+	} catch (err) {
+		return {
+			channel: "qqbot",
+			error: formatErrorMessage(err)
+		};
+	}
+	const resolvedMediaPath = stagedHostReadVoice ? {
+		ok: true,
+		mediaPath: stagedHostReadVoice
+	} : resolveOutboundMediaPath(voicePath, "voice", {
+		allowMissingLocalPath: true,
+		extraLocalRoots: resolveOutboundMediaLocalRoots(ctx),
+		workspaceDir: ctx.mediaAccess?.workspaceDir
+	});
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaPath = resolvedMediaPath.mediaPath;
-	if (mediaPath.startsWith("http://") || mediaPath.startsWith("https://")) {
+	if (isHttpUrl(mediaPath)) {
 		if (shouldDirectUploadUrl(ctx.account)) try {
 			const creds = accountToCreds(ctx.account);
 			const target = {
@@ -716,7 +929,8 @@ async function sendVoiceFromLocal(ctx, mediaPath, directUploadFormats, transcode
 		error: "Voice generate failed"
 	};
 	if (fileSize > getMaxUploadSize(3)) return buildFileTooLargeResult(3, fileSize);
-	const safeMediaPath = resolveTrustedOutboundMediaPath(mediaPath);
+	const extraLocalRoots = resolveOutboundMediaLocalRoots(ctx);
+	const safeMediaPath = resolveTrustedOutboundMediaPath(mediaPath) ?? (extraLocalRoots ? resolveExistingPathWithinRoots(mediaPath, extraLocalRoots) : null);
 	if (!safeMediaPath) {
 		debugWarn(`sendVoice: blocked local voice path outside QQ Bot media storage`);
 		return {
@@ -779,13 +993,18 @@ async function sendVoiceFromLocal(ctx, mediaPath, directUploadFormats, transcode
 }
 /** Send video from either a public URL or a local file. */
 async function sendVideoMsg(ctx, videoPath) {
-	const resolvedMediaPath = resolveOutboundMediaPath(videoPath, "video");
+	const hostReadResult = await trySendViaHostRead(ctx, videoPath, "video");
+	if (hostReadResult) return hostReadResult;
+	const resolvedMediaPath = resolveOutboundMediaPath(videoPath, "video", {
+		extraLocalRoots: resolveOutboundMediaLocalRoots(ctx),
+		workspaceDir: ctx.mediaAccess?.workspaceDir
+	});
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaPath = resolvedMediaPath.mediaPath;
-	const isHttp = mediaPath.startsWith("http://") || mediaPath.startsWith("https://");
+	const isHttp = isHttpUrl(mediaPath);
 	if (isHttp && !shouldDirectUploadUrl(ctx.account)) {
 		debugLog(`sendVideoMsg: urlDirectUpload=false, downloading URL first...`);
 		const localFile = await downloadToFallbackDir(mediaPath, "sendVideoMsg");
@@ -887,13 +1106,18 @@ async function sendVideoFromLocal(ctx, mediaPath) {
 }
 /** Send a file from a local path or public URL. */
 async function sendDocument(ctx, filePath, options = {}) {
-	const resolvedMediaPath = resolveOutboundMediaPath(filePath, "file", { extraLocalRoots: options.allowQQBotDataDownloads ? [getQQBotDataDir("downloads")] : void 0 });
+	const hostReadResult = await trySendViaHostRead(ctx, filePath, "file");
+	if (hostReadResult) return hostReadResult;
+	const resolvedMediaPath = resolveOutboundMediaPath(filePath, "file", {
+		extraLocalRoots: mergeMediaLocalRoots(options.allowQQBotDataDownloads ? [getQQBotDataDir("downloads")] : void 0, resolveOutboundMediaLocalRoots(ctx)),
+		workspaceDir: ctx.mediaAccess?.workspaceDir
+	});
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaPath = resolvedMediaPath.mediaPath;
-	const isHttp = mediaPath.startsWith("http://") || mediaPath.startsWith("https://");
+	const isHttp = isHttpUrl(mediaPath);
 	const fileName = sanitizeFileName(path.basename(mediaPath));
 	if (isHttp && !shouldDirectUploadUrl(ctx.account)) {
 		debugLog(`sendDocument: urlDirectUpload=false, downloading URL first...`);
@@ -918,7 +1142,7 @@ async function sendDocument(ctx, filePath, options = {}) {
 					kind: "file",
 					source: { url: mediaPath },
 					msgId: ctx.replyToId,
-					fileName
+					...fileName ? { fileName } : {}
 				});
 				return {
 					channel: "qqbot",
@@ -1435,7 +1659,10 @@ async function sendText(ctx) {
 		const mediaTarget = buildMediaTarget({
 			to,
 			account,
-			replyToId
+			replyToId,
+			mediaAccess: ctx.mediaAccess,
+			mediaLocalRoots: ctx.mediaLocalRoots,
+			mediaReadFile: ctx.mediaReadFile
 		});
 		let lastResult = { channel: "qqbot" };
 		for (const item of sendQueue) try {
@@ -1464,7 +1691,10 @@ async function sendText(ctx) {
 				mediaUrl: item.content,
 				accountId: account.accountId,
 				replyToId,
-				account
+				account,
+				mediaAccess: ctx.mediaAccess,
+				mediaLocalRoots: ctx.mediaLocalRoots,
+				mediaReadFile: ctx.mediaReadFile
 			});
 		} catch (err) {
 			const errMsg = formatErrorMessage(err);
@@ -1526,17 +1756,27 @@ async function sendMedia(ctx) {
 		channel: "qqbot",
 		error: "mediaUrl is required for sendMedia"
 	};
-	const resolvedMediaPath = resolveOutboundMediaPath(ctx.mediaUrl, "media", { allowMissingLocalPath: true });
+	const target = buildMediaTarget({
+		to,
+		account,
+		replyToId,
+		mediaAccess: ctx.mediaAccess,
+		mediaLocalRoots: ctx.mediaLocalRoots,
+		mediaReadFile: ctx.mediaReadFile
+	});
+	const resolvedMediaPath = !ctx.mediaAccess?.readFile && !ctx.mediaReadFile ? resolveOutboundMediaPath(ctx.mediaUrl, "media", {
+		allowMissingLocalPath: true,
+		extraLocalRoots: target.mediaLocalRoots ? [...target.mediaLocalRoots] : void 0,
+		workspaceDir: target.mediaAccess?.workspaceDir
+	}) : {
+		ok: true,
+		mediaPath: ctx.mediaUrl
+	};
 	if (!resolvedMediaPath.ok) return {
 		channel: "qqbot",
 		error: resolvedMediaPath.error
 	};
 	const mediaUrl = resolvedMediaPath.mediaPath;
-	const target = buildMediaTarget({
-		to,
-		account,
-		replyToId
-	});
 	if (isAudioFile(mediaUrl, mimeType)) {
 		const result = await sendVoice(target, mediaUrl, account.config?.audioFormatPolicy?.uploadDirectFormats ?? account.config?.voiceDirectUploadFormats, account.config?.audioFormatPolicy?.transcodeEnabled !== false);
 		if (!result.error) {
@@ -1561,7 +1801,7 @@ async function sendMedia(ctx) {
 		return result;
 	}
 	if (!isImageFile(mediaUrl, mimeType) && !isAudioFile(mediaUrl, mimeType) && !isVideoFile(mediaUrl, mimeType)) {
-		const result = await sendDocument(target, mediaUrl);
+		const result = await sendAutoDetectedMedia(target, mediaUrl);
 		if (!result.error && text?.trim()) await sendTextAfterMedia(target, text);
 		return result;
 	}
@@ -1622,4 +1862,4 @@ async function sendCronMessage(account, to, message) {
 	});
 }
 //#endregion
-export { getHomeDir as A, getMessageReplyConfig as C, OUTBOUND_ERROR_CODES as D, DEFAULT_MEDIA_SEND_ERROR as E, isLocalPath as F, isWindows as I, normalizePath$1 as L, getQQBotMediaDir as M, getQQBotMediaPath as N, setOutboundAudioPort as O, getTempDir as P, checkMessageReplyLimit as S, recordMessageReply as T, sendVideoMsg as _, sendText as a, resolveUserFacingMediaError as b, isCronReminderPayload as c, normalizeMediaTags as d, buildMediaTarget as f, sendPhoto as g, sendDocument as h, sendProactiveMessage as i, getQQBotDataDir as j, checkSilkWasmAvailable as k, isMediaPayload as l, resolveOutboundMediaPath as m, sendCronMessage as n, decodeMediaPath as o, parseTarget as p, sendMedia as r, encodePayloadForCron as s, outbound_exports as t, parseQQBotPayload as u, sendVoice as v, getMessageReplyStats as w, MESSAGE_REPLY_LIMIT as x, resolveTrustedOutboundMediaPath as y };
+export { OUTBOUND_ERROR_CODES as A, normalizePath$1 as B, resolveUserFacingMediaError as C, getMessageReplyStats as D, getMessageReplyConfig as E, getQQBotMediaDir as F, getQQBotMediaPath as I, getTempDir as L, checkSilkWasmAvailable as M, getHomeDir as N, recordMessageReply as O, getQQBotDataDir as P, isLocalPath as R, resolveWorkspaceScopedLocalRoots as S, checkMessageReplyLimit as T, sendVideoMsg as _, sendText as a, resolveOutboundMediaLocalRoots as b, isCronReminderPayload as c, normalizeMediaTags as d, buildMediaTarget as f, sendPhoto as g, sendDocument as h, sendProactiveMessage as i, setOutboundAudioPort as j, DEFAULT_MEDIA_SEND_ERROR as k, isMediaPayload as l, resolveOutboundMediaPath as m, sendCronMessage as n, decodeMediaPath as o, parseTarget as p, sendMedia as r, encodePayloadForCron as s, outbound_exports as t, parseQQBotPayload as u, sendVoice as v, MESSAGE_REPLY_LIMIT as w, resolveWorkspacePathCandidates as x, resolveTrustedOutboundMediaPath as y, isWindows as z };

package/dist/{runtime-BL0xZzWe.js → runtime-B4HWCOa-.js}

@@ -1,4 +1,4 @@
-import { v as setOpenClawVersion } from "./sender-BHWpE_yH.js";
+import { v as setOpenClawVersion } from "./sender-BfVLJJYp.js";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 //#region extensions/qqbot/src/bridge/runtime.ts
 const { setRuntime: _setRuntime, clearRuntime: resetQQBotRuntimeForTest, getRuntime: getQQBotRuntime } = createPluginRuntimeStore({

package/dist/runtime-api.js

@@ -1,2 +1,2 @@
-import { r as setQQBotRuntime, t as getQQBotRuntime } from "./runtime-BL0xZzWe.js";
+import { r as setQQBotRuntime, t as getQQBotRuntime } from "./runtime-B4HWCOa-.js";
 export { getQQBotRuntime, setQQBotRuntime };

package/dist/{sender-BHWpE_yH.js → sender-BfVLJJYp.js}

@@ -6,6 +6,7 @@ import { readProviderTextResponse, readResponseTextLimited } from "openclaw/plug
 import { fetchWithSsrFGuard, isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
 import * as crypto$1 from "node:crypto";
 import crypto from "node:crypto";
+import { sleep } from "openclaw/plugin-sdk/runtime-env";
 import { FsSafeError, openLocalFileSafely, readRegularFile, statRegularFileSync } from "openclaw/plugin-sdk/security-runtime";
 import * as path$1 from "node:path";
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
@@ -462,6 +463,17 @@ async function normalizeSource(raw, opts = {}) {
 //#endregion
 //#region extensions/qqbot/src/engine/api/retry.ts
 /**
+* Generic retry engine for QQ Bot API requests.
+*
+* Replaces the three separate retry implementations in the old `api.ts`:
+* - `apiRequestWithRetry` (upload retry with exponential backoff)
+* - `partFinishWithRetry` (part-finish retry + persistent retry on specific biz codes)
+* - `completeUploadWithRetry` (unconditional retry for complete-upload)
+*
+* All three patterns are expressed as a single `withRetry` function
+* parameterized by `RetryPolicy` and optional `PersistentRetryPolicy`.
+*/
+/**
 * Execute an async operation with configurable retry semantics.
 *
 * @param fn - The async operation to retry.
@@ -484,7 +496,7 @@ async function withRetry(fn, policy, persistentPolicy, logger) {
 		if (attempt < policy.maxRetries) {
 			const delay = policy.backoff === "exponential" ? policy.baseDelayMs * 2 ** attempt : policy.baseDelayMs;
 			logger?.debug?.(`[qqbot:retry] Attempt ${attempt + 1} failed, retrying in ${delay}ms: ${lastError.message.slice(0, 100)}`);
-			await sleep$1(delay);
+			await sleep(delay);
 		}
 	}
 	throw lastError;
@@ -514,16 +526,11 @@ async function persistentRetryLoop(fn, policy, logger) {
 		if (remaining <= 0) break;
 		const actualDelay = Math.min(policy.intervalMs, remaining);
 		(logger?.warn ?? logger?.error)?.(`[qqbot:retry] Persistent retry #${attempt}: retrying in ${actualDelay}ms (remaining=${Math.round(remaining / 1e3)}s)`);
-		await sleep$1(actualDelay);
+		await sleep(actualDelay);
 	}
 	logger?.error?.(`[qqbot:retry] Persistent retry timed out after ${policy.timeoutMs / 1e3}s (${attempt} attempts)`);
 	throw lastError ?? /* @__PURE__ */ new Error(`Persistent retry timed out (${policy.timeoutMs / 1e3}s)`);
 }
-function sleep$1(ms) {
-	return new Promise((resolve) => {
-		setTimeout(resolve, ms);
-	});
-}
 /** Standard upload retry: exponential backoff, skip 400/401/timeout errors. */
 const UPLOAD_RETRY_POLICY = {
 	maxRetries: 2,
@@ -967,11 +974,6 @@ async function runWithConcurrency(tasks, maxConcurrent) {
 		await Promise.all(batch.map((task) => task()));
 	}
 }
-function sleep(ms) {
-	return new Promise((resolve) => {
-		setTimeout(resolve, ms);
-	});
-}
 //#endregion
 //#region extensions/qqbot/src/engine/api/token.ts
 /**

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as qqbotSetupPlugin } from "./channel.setup-CldhUlTO.js";
+import { t as qqbotSetupPlugin } from "./channel.setup-2ItDYKhz.js";
 export { qqbotSetupPlugin };