stableclaw 2026.4.6 → 2026.4.8

package/dist/gateway-CWPyH-P7.js

@@ -1,2575 +0,0 @@
-import { C as textToSpeech } from "./speech-runtime-CNvOkPw4.js";
-import { $ as getQQBotMediaDir, A as getAccessToken, B as sendChannelMessage, C as formatDuration, D as textToSilk, E as resolveTTSConfig, F as sendC2CImageMessage, G as sendGroupVideoMessage, H as sendGroupFileMessage, I as sendC2CInputNotify, K as sendGroupVoiceMessage, L as sendC2CMessage, M as initApiConfig, N as onMessageSent, O as PLUGIN_USER_AGENT, P as sendC2CFileMessage, Q as getQQBotDataDir, R as sendC2CVideoMessage, S as convertSilkToWav, T as isVoiceAttachment, U as sendGroupImageMessage, V as sendDmMessage, W as sendGroupMessage, X as stopBackgroundTokenRefresh, Y as startBackgroundTokenRefresh, _ as normalizeMediaTags, at as sanitizeFileName, b as formatFileSize, c as sendPhoto, d as sendVideoMsg, et as isLocalPath, f as sendVoice, g as parseQQBotPayload, h as isMediaPayload, it as runDiagnostics, j as getGatewayUrl, k as clearTokenCache, m as isCronReminderPayload, nt as normalizePath, o as sendDocument, ot as debugError, p as encodePayloadForCron, rt as resolveQQBotPayloadLocalFilePath, s as sendMedia, st as debugLog, v as MAX_UPLOAD_SIZE, w as isGlobalTTSAvailable, x as audioFileToSilkBase64, y as downloadFile, z as sendC2CVoiceMessage } from "./outbound-hgMEZIU9.js";
-import { t as getQQBotRuntime } from "./runtime-BpHrcXgA.js";
-import { a as chunkText, i as TEXT_CHUNK_LIMIT, n as matchSlashCommand, r as qqbotPlugin } from "./slash-commands-CRuXC74L.js";
-import { a as recordKnownUser, n as flushKnownUsers } from "./known-users-DjerpGCB.js";
-import * as fs from "node:fs";
-import fsSync from "node:fs";
-import path from "node:path";
-import crypto from "node:crypto";
-import WebSocket$1 from "ws";
-import { Buffer as Buffer$1 } from "buffer";
-//#region extensions/qqbot/src/stt.ts
-/**
-* OpenAI-compatible STT used at the plugin layer.
-*
-* This avoids pushing raw WAV PCM into the framework media-understanding pipeline.
-*/
-function resolveSTTConfig(cfg) {
-	const c = cfg;
-	const channelStt = c?.channels?.qqbot?.stt;
-	if (channelStt && channelStt.enabled !== false) {
-		const providerId = channelStt?.provider || "openai";
-		const providerCfg = c?.models?.providers?.[providerId];
-		const baseUrl = channelStt?.baseUrl || providerCfg?.baseUrl;
-		const apiKey = channelStt?.apiKey || providerCfg?.apiKey;
-		const model = channelStt?.model || "whisper-1";
-		if (baseUrl && apiKey) return {
-			baseUrl: baseUrl.replace(/\/+$/, ""),
-			apiKey,
-			model
-		};
-	}
-	const audioModelEntry = c?.tools?.media?.audio?.models?.[0];
-	if (audioModelEntry) {
-		const providerId = audioModelEntry?.provider || "openai";
-		const providerCfg = c?.models?.providers?.[providerId];
-		const baseUrl = audioModelEntry?.baseUrl || providerCfg?.baseUrl;
-		const apiKey = audioModelEntry?.apiKey || providerCfg?.apiKey;
-		const model = audioModelEntry?.model || "whisper-1";
-		if (baseUrl && apiKey) return {
-			baseUrl: baseUrl.replace(/\/+$/, ""),
-			apiKey,
-			model
-		};
-	}
-	return null;
-}
-async function transcribeAudio(audioPath, cfg) {
-	const sttCfg = resolveSTTConfig(cfg);
-	if (!sttCfg) return null;
-	const fileBuffer = fs.readFileSync(audioPath);
-	const fileName = sanitizeFileName(path.basename(audioPath));
-	const mime = fileName.endsWith(".wav") ? "audio/wav" : fileName.endsWith(".mp3") ? "audio/mpeg" : fileName.endsWith(".ogg") ? "audio/ogg" : "application/octet-stream";
-	const form = new FormData();
-	form.append("file", new Blob([fileBuffer], { type: mime }), fileName);
-	form.append("model", sttCfg.model);
-	const resp = await fetch(`${sttCfg.baseUrl}/audio/transcriptions`, {
-		method: "POST",
-		headers: { Authorization: `Bearer ${sttCfg.apiKey}` },
-		body: form
-	});
-	if (!resp.ok) {
-		const detail = await resp.text().catch(() => "");
-		throw new Error(`STT failed (HTTP ${resp.status}): ${detail.slice(0, 300)}`);
-	}
-	return (await resp.json()).text?.trim() || null;
-}
-//#endregion
-//#region extensions/qqbot/src/inbound-attachments.ts
-const EMPTY_RESULT = {
-	attachmentInfo: "",
-	imageUrls: [],
-	imageMediaTypes: [],
-	voiceAttachmentPaths: [],
-	voiceAttachmentUrls: [],
-	voiceAsrReferTexts: [],
-	voiceTranscripts: [],
-	voiceTranscriptSources: [],
-	attachmentLocalPaths: []
-};
-/** Download, convert, transcribe, and classify inbound attachments. */
-async function processAttachments(attachments, ctx) {
-	if (!attachments?.length) return EMPTY_RESULT;
-	const { accountId, cfg, log } = ctx;
-	const downloadDir = getQQBotMediaDir("downloads");
-	const prefix = `[qqbot:${accountId}]`;
-	const imageUrls = [];
-	const imageMediaTypes = [];
-	const voiceAttachmentPaths = [];
-	const voiceAttachmentUrls = [];
-	const voiceAsrReferTexts = [];
-	const voiceTranscripts = [];
-	const voiceTranscriptSources = [];
-	const attachmentLocalPaths = [];
-	const otherAttachments = [];
-	const downloadTasks = attachments.map(async (att) => {
-		const attUrl = att.url?.startsWith("//") ? `https:${att.url}` : att.url;
-		const isVoice = isVoiceAttachment(att);
-		const wavUrl = isVoice && att.voice_wav_url ? att.voice_wav_url.startsWith("//") ? `https:${att.voice_wav_url}` : att.voice_wav_url : "";
-		let localPath = null;
-		let audioPath = null;
-		if (isVoice && wavUrl) {
-			const wavLocalPath = await downloadFile(wavUrl, downloadDir);
-			if (wavLocalPath) {
-				localPath = wavLocalPath;
-				audioPath = wavLocalPath;
-				log?.info(`${prefix} Voice attachment: ${att.filename}, downloaded WAV directly (skip SILK→WAV)`);
-			} else log?.error(`${prefix} Failed to download voice_wav_url, falling back to original URL`);
-		}
-		if (!localPath) localPath = await downloadFile(attUrl, downloadDir, att.filename);
-		return {
-			att,
-			attUrl,
-			isVoice,
-			localPath,
-			audioPath
-		};
-	});
-	const processTasks = (await Promise.all(downloadTasks)).map(async ({ att, attUrl, isVoice, localPath, audioPath }) => {
-		const asrReferText = typeof att.asr_refer_text === "string" ? att.asr_refer_text.trim() : "";
-		const voiceSourceUrl = (isVoice && att.voice_wav_url ? att.voice_wav_url.startsWith("//") ? `https:${att.voice_wav_url}` : att.voice_wav_url : "") || attUrl;
-		const meta = {
-			voiceUrl: isVoice && voiceSourceUrl ? voiceSourceUrl : void 0,
-			asrReferText: isVoice && asrReferText ? asrReferText : void 0
-		};
-		if (localPath) if (att.content_type?.startsWith("image/")) {
-			log?.info(`${prefix} Downloaded attachment to: ${localPath}`);
-			return {
-				localPath,
-				type: "image",
-				contentType: att.content_type,
-				meta
-			};
-		} else if (isVoice) {
-			log?.info(`${prefix} Downloaded attachment to: ${localPath}`);
-			return processVoiceAttachment(localPath, audioPath, att, asrReferText, cfg, downloadDir, log, prefix);
-		} else {
-			log?.info(`${prefix} Downloaded attachment to: ${localPath}`);
-			return {
-				localPath,
-				type: "other",
-				filename: att.filename,
-				meta
-			};
-		}
-		else {
-			log?.error(`${prefix} Failed to download: ${attUrl}`);
-			if (att.content_type?.startsWith("image/")) return {
-				localPath: null,
-				type: "image-fallback",
-				attUrl,
-				contentType: att.content_type,
-				meta
-			};
-			else if (isVoice && asrReferText) {
-				log?.info(`${prefix} Voice attachment download failed, using asr_refer_text fallback`);
-				return {
-					localPath: null,
-					type: "voice-fallback",
-					transcript: asrReferText,
-					meta
-				};
-			} else return {
-				localPath: null,
-				type: "other-fallback",
-				filename: att.filename ?? att.content_type,
-				meta
-			};
-		}
-	});
-	const processResults = await Promise.all(processTasks);
-	for (const result of processResults) {
-		if (result.meta.voiceUrl) voiceAttachmentUrls.push(result.meta.voiceUrl);
-		if (result.meta.asrReferText) voiceAsrReferTexts.push(result.meta.asrReferText);
-		if (result.type === "image" && result.localPath) {
-			imageUrls.push(result.localPath);
-			imageMediaTypes.push(result.contentType);
-			attachmentLocalPaths.push(result.localPath);
-		} else if (result.type === "voice" && result.localPath) {
-			voiceAttachmentPaths.push(result.localPath);
-			voiceTranscripts.push(result.transcript);
-			voiceTranscriptSources.push(result.transcriptSource);
-			attachmentLocalPaths.push(result.localPath);
-		} else if (result.type === "other" && result.localPath) {
-			otherAttachments.push(`[Attachment: ${result.localPath}]`);
-			attachmentLocalPaths.push(result.localPath);
-		} else if (result.type === "image-fallback") {
-			imageUrls.push(result.attUrl);
-			imageMediaTypes.push(result.contentType);
-			attachmentLocalPaths.push(null);
-		} else if (result.type === "voice-fallback") {
-			voiceTranscripts.push(result.transcript);
-			voiceTranscriptSources.push("asr");
-			attachmentLocalPaths.push(null);
-		} else if (result.type === "other-fallback") {
-			otherAttachments.push(`[Attachment: ${result.filename}] (download failed)`);
-			attachmentLocalPaths.push(null);
-		}
-	}
-	return {
-		attachmentInfo: otherAttachments.length > 0 ? "\n" + otherAttachments.join("\n") : "",
-		imageUrls,
-		imageMediaTypes,
-		voiceAttachmentPaths,
-		voiceAttachmentUrls,
-		voiceAsrReferTexts,
-		voiceTranscripts,
-		voiceTranscriptSources,
-		attachmentLocalPaths
-	};
-}
-/** Format voice transcripts into user-visible text. */
-function formatVoiceText(transcripts) {
-	if (transcripts.length === 0) return "";
-	return transcripts.length === 1 ? `[Voice message] ${transcripts[0]}` : transcripts.map((t, i) => `[Voice ${i + 1}] ${t}`).join("\n");
-}
-async function processVoiceAttachment(localPath, audioPath, att, asrReferText, cfg, downloadDir, log, prefix) {
-	const wavUrl = att.voice_wav_url ? att.voice_wav_url.startsWith("//") ? `https:${att.voice_wav_url}` : att.voice_wav_url : "";
-	const attUrl = att.url?.startsWith("//") ? `https:${att.url}` : att.url;
-	const meta = {
-		voiceUrl: wavUrl || attUrl || void 0,
-		asrReferText: asrReferText || void 0
-	};
-	if (!resolveSTTConfig(cfg)) {
-		if (asrReferText) {
-			log?.info(`${prefix} Voice attachment: ${att.filename} (STT not configured, using asr_refer_text fallback)`);
-			return {
-				localPath,
-				type: "voice",
-				transcript: asrReferText,
-				transcriptSource: "asr",
-				meta
-			};
-		}
-		log?.info(`${prefix} Voice attachment: ${att.filename} (STT not configured, skipping transcription)`);
-		return {
-			localPath,
-			type: "voice",
-			transcript: "[Voice message - transcription unavailable because STT is not configured]",
-			transcriptSource: "fallback",
-			meta
-		};
-	}
-	if (!audioPath) {
-		log?.info(`${prefix} Voice attachment: ${att.filename}, converting SILK→WAV...`);
-		try {
-			const wavResult = await convertSilkToWav(localPath, downloadDir);
-			if (wavResult) {
-				audioPath = wavResult.wavPath;
-				log?.info(`${prefix} Voice converted: ${wavResult.wavPath} (${formatDuration(wavResult.duration)})`);
-			} else audioPath = localPath;
-		} catch (convertErr) {
-			log?.error(`${prefix} Voice conversion failed: ${convertErr}`);
-			if (asrReferText) return {
-				localPath,
-				type: "voice",
-				transcript: asrReferText,
-				transcriptSource: "asr",
-				meta
-			};
-			return {
-				localPath,
-				type: "voice",
-				transcript: "[Voice message - format conversion failed]",
-				transcriptSource: "fallback",
-				meta
-			};
-		}
-	}
-	try {
-		const transcript = await transcribeAudio(audioPath, cfg);
-		if (transcript) {
-			log?.info(`${prefix} STT transcript: ${transcript.slice(0, 100)}...`);
-			return {
-				localPath,
-				type: "voice",
-				transcript,
-				transcriptSource: "stt",
-				meta
-			};
-		}
-		if (asrReferText) {
-			log?.info(`${prefix} STT returned empty result, using asr_refer_text fallback`);
-			return {
-				localPath,
-				type: "voice",
-				transcript: asrReferText,
-				transcriptSource: "asr",
-				meta
-			};
-		}
-		log?.info(`${prefix} STT returned empty result`);
-		return {
-			localPath,
-			type: "voice",
-			transcript: "[Voice message - transcription returned an empty result]",
-			transcriptSource: "fallback",
-			meta
-		};
-	} catch (sttErr) {
-		log?.error(`${prefix} STT failed: ${sttErr}`);
-		if (asrReferText) return {
-			localPath,
-			type: "voice",
-			transcript: asrReferText,
-			transcriptSource: "asr",
-			meta
-		};
-		return {
-			localPath,
-			type: "voice",
-			transcript: "[Voice message - transcription failed]",
-			transcriptSource: "fallback",
-			meta
-		};
-	}
-}
-//#endregion
-//#region extensions/qqbot/src/message-queue.ts
-const MESSAGE_QUEUE_SIZE = 1e3;
-const PER_USER_QUEUE_SIZE = 20;
-const MAX_CONCURRENT_USERS = 10;
-/**
-* Create a per-user concurrent queue.
-* Messages are serialized per user and processed in parallel across users.
-*/
-function createMessageQueue(ctx) {
-	const { accountId, log } = ctx;
-	const userQueues = /* @__PURE__ */ new Map();
-	const activeUsers = /* @__PURE__ */ new Set();
-	let messagesProcessed = 0;
-	let handleMessageFnRef = null;
-	let totalEnqueued = 0;
-	const getMessagePeerId = (msg) => {
-		if (msg.type === "guild") return `guild:${msg.channelId ?? "unknown"}`;
-		if (msg.type === "group") return `group:${msg.groupOpenid ?? "unknown"}`;
-		return `dm:${msg.senderId}`;
-	};
-	const drainUserQueue = async (peerId) => {
-		if (activeUsers.has(peerId)) return;
-		if (activeUsers.size >= MAX_CONCURRENT_USERS) {
-			log?.info(`[qqbot:${accountId}] Max concurrent users (${MAX_CONCURRENT_USERS}) reached, ${peerId} will wait`);
-			return;
-		}
-		const queue = userQueues.get(peerId);
-		if (!queue || queue.length === 0) {
-			userQueues.delete(peerId);
-			return;
-		}
-		activeUsers.add(peerId);
-		try {
-			while (queue.length > 0 && !ctx.isAborted()) {
-				const msg = queue.shift();
-				totalEnqueued = Math.max(0, totalEnqueued - 1);
-				try {
-					if (handleMessageFnRef) {
-						await handleMessageFnRef(msg);
-						messagesProcessed++;
-					}
-				} catch (err) {
-					log?.error(`[qqbot:${accountId}] Message processor error for ${peerId}: ${err}`);
-				}
-			}
-		} finally {
-			activeUsers.delete(peerId);
-			userQueues.delete(peerId);
-			for (const [waitingPeerId, waitingQueue] of userQueues) {
-				if (activeUsers.size >= MAX_CONCURRENT_USERS) break;
-				if (waitingQueue.length > 0 && !activeUsers.has(waitingPeerId)) drainUserQueue(waitingPeerId);
-			}
-		}
-	};
-	const enqueue = (msg) => {
-		const peerId = getMessagePeerId(msg);
-		let queue = userQueues.get(peerId);
-		if (!queue) {
-			queue = [];
-			userQueues.set(peerId, queue);
-		}
-		if (queue.length >= PER_USER_QUEUE_SIZE) {
-			const dropped = queue.shift();
-			log?.error(`[qqbot:${accountId}] Per-user queue full for ${peerId}, dropping oldest message ${dropped?.messageId}`);
-		}
-		totalEnqueued++;
-		if (totalEnqueued > MESSAGE_QUEUE_SIZE) log?.error(`[qqbot:${accountId}] Global queue limit reached (${totalEnqueued}), message from ${peerId} may be delayed`);
-		queue.push(msg);
-		log?.debug?.(`[qqbot:${accountId}] Message enqueued for ${peerId}, user queue: ${queue.length}, active users: ${activeUsers.size}`);
-		drainUserQueue(peerId);
-	};
-	const startProcessor = (handleMessageFn) => {
-		handleMessageFnRef = handleMessageFn;
-		log?.info(`[qqbot:${accountId}] Message processor started (per-user concurrency, max ${MAX_CONCURRENT_USERS} users)`);
-	};
-	const getSnapshot = (senderPeerId) => {
-		let totalPending = 0;
-		for (const [, q] of userQueues) totalPending += q.length;
-		const senderQueue = userQueues.get(senderPeerId);
-		return {
-			totalPending,
-			activeUsers: activeUsers.size,
-			maxConcurrentUsers: MAX_CONCURRENT_USERS,
-			senderPending: senderQueue ? senderQueue.length : 0
-		};
-	};
-	const clearUserQueue = (peerId) => {
-		const queue = userQueues.get(peerId);
-		if (!queue || queue.length === 0) return 0;
-		const droppedCount = queue.length;
-		queue.length = 0;
-		totalEnqueued = Math.max(0, totalEnqueued - droppedCount);
-		return droppedCount;
-	};
-	const executeImmediate = (msg) => {
-		if (handleMessageFnRef) handleMessageFnRef(msg).catch((err) => {
-			log?.error(`[qqbot:${accountId}] Immediate execution error: ${err}`);
-		});
-	};
-	return {
-		enqueue,
-		startProcessor,
-		getSnapshot,
-		getMessagePeerId,
-		clearUserQueue,
-		executeImmediate
-	};
-}
-//#endregion
-//#region extensions/qqbot/src/utils/image-size.ts
-/**
-* Image dimension helpers for QQ Bot markdown image syntax.
-*
-* QQ Bot markdown images use `![#widthpx #heightpx](url)`.
-*/
-/** Default dimensions used when probing fails. */
-const DEFAULT_IMAGE_SIZE = {
-	width: 512,
-	height: 512
-};
-/**
-* Parse image dimensions from the PNG header.
-*/
-function parsePngSize(buffer) {
-	if (buffer.length < 24) return null;
-	if (buffer[0] !== 137 || buffer[1] !== 80 || buffer[2] !== 78 || buffer[3] !== 71) return null;
-	return {
-		width: buffer.readUInt32BE(16),
-		height: buffer.readUInt32BE(20)
-	};
-}
-/** Parse image dimensions from JPEG SOF0/SOF2 markers. */
-function parseJpegSize(buffer) {
-	if (buffer.length < 4) return null;
-	if (buffer[0] !== 255 || buffer[1] !== 216) return null;
-	let offset = 2;
-	while (offset < buffer.length - 9) {
-		if (buffer[offset] !== 255) {
-			offset++;
-			continue;
-		}
-		const marker = buffer[offset + 1];
-		if (marker === 192 || marker === 194) {
-			if (offset + 9 <= buffer.length) {
-				const height = buffer.readUInt16BE(offset + 5);
-				return {
-					width: buffer.readUInt16BE(offset + 7),
-					height
-				};
-			}
-		}
-		if (offset + 3 < buffer.length) {
-			const blockLength = buffer.readUInt16BE(offset + 2);
-			offset += 2 + blockLength;
-		} else break;
-	}
-	return null;
-}
-/** Parse image dimensions from the GIF header. */
-function parseGifSize(buffer) {
-	if (buffer.length < 10) return null;
-	const signature = buffer.toString("ascii", 0, 6);
-	if (signature !== "GIF87a" && signature !== "GIF89a") return null;
-	return {
-		width: buffer.readUInt16LE(6),
-		height: buffer.readUInt16LE(8)
-	};
-}
-/** Parse image dimensions from WebP headers. */
-function parseWebpSize(buffer) {
-	if (buffer.length < 30) return null;
-	const riff = buffer.toString("ascii", 0, 4);
-	const webp = buffer.toString("ascii", 8, 12);
-	if (riff !== "RIFF" || webp !== "WEBP") return null;
-	const chunkType = buffer.toString("ascii", 12, 16);
-	if (chunkType === "VP8 ") {
-		if (buffer.length >= 30 && buffer[23] === 157 && buffer[24] === 1 && buffer[25] === 42) return {
-			width: buffer.readUInt16LE(26) & 16383,
-			height: buffer.readUInt16LE(28) & 16383
-		};
-	}
-	if (chunkType === "VP8L") {
-		if (buffer.length >= 25 && buffer[20] === 47) {
-			const bits = buffer.readUInt32LE(21);
-			return {
-				width: (bits & 16383) + 1,
-				height: (bits >> 14 & 16383) + 1
-			};
-		}
-	}
-	if (chunkType === "VP8X") {
-		if (buffer.length >= 30) return {
-			width: (buffer[24] | buffer[25] << 8 | buffer[26] << 16) + 1,
-			height: (buffer[27] | buffer[28] << 8 | buffer[29] << 16) + 1
-		};
-	}
-	return null;
-}
-/** Parse image dimensions from raw image bytes. */
-function parseImageSize(buffer) {
-	return parsePngSize(buffer) ?? parseJpegSize(buffer) ?? parseGifSize(buffer) ?? parseWebpSize(buffer);
-}
-/**
-* Fetch image dimensions from a public URL using only the first 64 KB.
-*/
-async function getImageSizeFromUrl(url, timeoutMs = 5e3) {
-	try {
-		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-		const response = await fetch(url, {
-			signal: controller.signal,
-			headers: {
-				Range: "bytes=0-65535",
-				"User-Agent": "QQBot-Image-Size-Detector/1.0"
-			}
-		});
-		clearTimeout(timeoutId);
-		if (!response.ok && response.status !== 206) {
-			debugLog(`[image-size] Failed to fetch ${url}: ${response.status}`);
-			return null;
-		}
-		const arrayBuffer = await response.arrayBuffer();
-		const size = parseImageSize(Buffer$1.from(arrayBuffer));
-		if (size) debugLog(`[image-size] Got size from URL: ${size.width}x${size.height} - ${url.slice(0, 60)}...`);
-		return size;
-	} catch (err) {
-		debugLog(`[image-size] Error fetching ${url.slice(0, 60)}...: ${err}`);
-		return null;
-	}
-}
-/** Parse image dimensions from a Base64 data URL. */
-function getImageSizeFromDataUrl(dataUrl) {
-	try {
-		const matches = dataUrl.match(/^data:image\/[^;]+;base64,(.+)$/);
-		if (!matches) return null;
-		const base64Data = matches[1];
-		const size = parseImageSize(Buffer$1.from(base64Data, "base64"));
-		if (size) debugLog(`[image-size] Got size from Base64: ${size.width}x${size.height}`);
-		return size;
-	} catch (err) {
-		debugLog(`[image-size] Error parsing Base64: ${err}`);
-		return null;
-	}
-}
-/**
-* Resolve image dimensions from either an HTTP URL or a Base64 data URL.
-*/
-async function getImageSize(source) {
-	if (source.startsWith("data:")) return getImageSizeFromDataUrl(source);
-	if (source.startsWith("http://") || source.startsWith("https://")) return getImageSizeFromUrl(source);
-	return null;
-}
-/** Format a markdown image with QQ Bot width/height annotations. */
-function formatQQBotMarkdownImage(url, size) {
-	const { width, height } = size ?? DEFAULT_IMAGE_SIZE;
-	return `![#${width}px #${height}px](${url})`;
-}
-/** Return true when markdown already contains QQ Bot size annotations. */
-function hasQQBotImageSize(markdownImage) {
-	return /!\[#\d+px\s+#\d+px\]/.test(markdownImage);
-}
-//#endregion
-//#region extensions/qqbot/src/utils/text-parsing.ts
-/** Replace QQ face tags with readable text labels. */
-function parseFaceTags(text) {
-	if (!text) return text;
-	return text.replace(/<faceType=\d+,faceId="[^"]*",ext="([^"]*)">/g, (_match, ext) => {
-		try {
-			const decoded = Buffer.from(ext, "base64").toString("utf-8");
-			return `[Emoji: ${JSON.parse(decoded).text || "unknown emoji"}]`;
-		} catch {
-			return _match;
-		}
-	});
-}
-/** Remove internal framework markers before sending text outward. */
-function filterInternalMarkers(text) {
-	if (!text) return text;
-	let result = text.replace(/\[\[[a-z_]+:\s*[^\]]*\]\]/gi, "");
-	result = result.replace(/@(?:image|voice|video|file):[a-zA-Z0-9_.-]+/g, "");
-	result = result.replace(/\n{3,}/g, "\n\n").trim();
-	return result;
-}
-/** Parse quote-related ref indices from `message_scene.ext`. */
-function parseRefIndices(ext) {
-	if (!ext || ext.length === 0) return {};
-	let refMsgIdx;
-	let msgIdx;
-	for (const item of ext) if (item.startsWith("ref_msg_idx=")) refMsgIdx = item.slice(12);
-	else if (item.startsWith("msg_idx=")) msgIdx = item.slice(8);
-	return {
-		refMsgIdx,
-		msgIdx
-	};
-}
-/** Build attachment summaries for ref-index caching. */
-function buildAttachmentSummaries(attachments, localPaths) {
-	if (!attachments || attachments.length === 0) return void 0;
-	return attachments.map((att, idx) => {
-		const ct = att.content_type?.toLowerCase() ?? "";
-		let type = "unknown";
-		if (ct.startsWith("image/")) type = "image";
-		else if (ct === "voice" || ct.startsWith("audio/") || ct.includes("silk") || ct.includes("amr")) type = "voice";
-		else if (ct.startsWith("video/")) type = "video";
-		else if (ct.startsWith("application/") || ct.startsWith("text/")) type = "file";
-		return {
-			type,
-			filename: att.filename,
-			contentType: att.content_type,
-			localPath: localPaths?.[idx] ?? void 0
-		};
-	});
-}
-//#endregion
-//#region extensions/qqbot/src/outbound-deliver.ts
-/**
-* Outbound delivery helpers.
-*
-* The gateway deliver callback uses two pipelines:
-* 1. `parseAndSendMediaTags` handles `<qqimg/qqvoice/qqvideo/qqfile/qqmedia>` tags in order.
-* 2. `sendPlainReply` handles plain replies, including markdown images and mixed text/media.
-*/
-/**
-* Parse media tags from the reply text and send them in order.
-*
-* @returns `true` when media tags were found and handled; `false` when the caller
-* should continue through the plain-text pipeline.
-*/
-async function parseAndSendMediaTags(replyText, event, actx, sendWithRetry, consumeQuoteRef) {
-	const { account, log } = actx;
-	const prefix = `[qqbot:${account.accountId}]`;
-	const text = normalizeMediaTags(replyText);
-	const mediaTagMatches = [...text.matchAll(/<(qqimg|qqvoice|qqvideo|qqfile|qqmedia)>([^<>]+)<\/(?:qqimg|qqvoice|qqvideo|qqfile|qqmedia|img)>/gi)];
-	if (mediaTagMatches.length === 0) return {
-		handled: false,
-		normalizedText: text
-	};
-	const tagCounts = mediaTagMatches.reduce((acc, m) => {
-		const t = m[1].toLowerCase();
-		acc[t] = (acc[t] ?? 0) + 1;
-		return acc;
-	}, {});
-	log?.info(`${prefix} Detected media tags: ${Object.entries(tagCounts).map(([k, v]) => `${v} <${k}>`).join(", ")}`);
-	const sendQueue = [];
-	let lastIndex = 0;
-	const regex2 = /<(qqimg|qqvoice|qqvideo|qqfile|qqmedia)>([^<>]+)<\/(?:qqimg|qqvoice|qqvideo|qqfile|qqmedia|img)>/gi;
-	let match;
-	while ((match = regex2.exec(text)) !== null) {
-		const textBefore = text.slice(lastIndex, match.index).replace(/\n{3,}/g, "\n\n").trim();
-		if (textBefore) sendQueue.push({
-			type: "text",
-			content: filterInternalMarkers(textBefore)
-		});
-		const tagName = match[1].toLowerCase();
-		let mediaPath = decodeMediaPath(match[2]?.trim() ?? "", log, prefix);
-		if (mediaPath) {
-			const itemType = {
-				qqmedia: "media",
-				qqvoice: "voice",
-				qqvideo: "video",
-				qqfile: "file"
-			}[tagName] ?? "image";
-			sendQueue.push({
-				type: itemType,
-				content: mediaPath
-			});
-			log?.info(`${prefix} Found ${itemType} in <${tagName}>: ${mediaPath}`);
-		}
-		lastIndex = match.index + match[0].length;
-	}
-	const textAfter = text.slice(lastIndex).replace(/\n{3,}/g, "\n\n").trim();
-	if (textAfter) sendQueue.push({
-		type: "text",
-		content: filterInternalMarkers(textAfter)
-	});
-	log?.info(`${prefix} Send queue: ${sendQueue.map((item) => item.type).join(" -> ")}`);
-	const mediaTarget = {
-		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,
-		logPrefix: prefix
-	};
-	for (const item of sendQueue) if (item.type === "text") await sendTextChunks(item.content, event, actx, sendWithRetry, consumeQuoteRef);
-	else if (item.type === "image") {
-		const result = await sendPhoto(mediaTarget, item.content);
-		if (result.error) log?.error(`${prefix} sendPhoto error: ${result.error}`);
-	} else if (item.type === "voice") await sendVoiceWithTimeout(mediaTarget, item.content, account, log, prefix);
-	else if (item.type === "video") {
-		const result = await sendVideoMsg(mediaTarget, item.content);
-		if (result.error) log?.error(`${prefix} sendVideoMsg error: ${result.error}`);
-	} else if (item.type === "file") {
-		const result = await sendDocument(mediaTarget, item.content);
-		if (result.error) log?.error(`${prefix} sendDocument error: ${result.error}`);
-	} else if (item.type === "media") {
-		const result = await sendMedia({
-			to: actx.qualifiedTarget,
-			text: "",
-			mediaUrl: item.content,
-			accountId: account.accountId,
-			replyToId: event.messageId,
-			account
-		});
-		if (result.error) log?.error(`${prefix} sendMedia(auto) error: ${result.error}`);
-	}
-	return {
-		handled: true,
-		normalizedText: text
-	};
-}
-/**
-* Send a reply that does not contain structured media tags.
-* Handles markdown image embeds, Base64 media, plain-text chunking, and local media routing.
-*/
-async function sendPlainReply(payload, replyText, event, actx, sendWithRetry, consumeQuoteRef, toolMediaUrls) {
-	const { account, qualifiedTarget, log } = actx;
-	const prefix = `[qqbot:${account.accountId}]`;
-	const collectedImageUrls = [];
-	const localMediaToSend = [];
-	const collectImageUrl = (url) => {
-		if (!url) return false;
-		const isHttpUrl = url.startsWith("http://") || url.startsWith("https://");
-		const isDataUrl = url.startsWith("data:image/");
-		if (isHttpUrl || isDataUrl) {
-			if (!collectedImageUrls.includes(url)) {
-				collectedImageUrls.push(url);
-				log?.info(`${prefix} Collected ${isDataUrl ? "Base64" : "media URL"}: ${isDataUrl ? `(length: ${url.length})` : url.slice(0, 80) + "..."}`);
-			}
-			return true;
-		}
-		if (isLocalPath(url)) {
-			if (!localMediaToSend.includes(url)) {
-				localMediaToSend.push(url);
-				log?.info(`${prefix} Collected local media for auto-routing: ${url}`);
-			}
-			return true;
-		}
-		return false;
-	};
-	if (payload.mediaUrls?.length) for (const url of payload.mediaUrls) collectImageUrl(url);
-	if (payload.mediaUrl) collectImageUrl(payload.mediaUrl);
-	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://")) {
-				collectedImageUrls.push(url);
-				log?.info(`${prefix} Extracted HTTP image from markdown: ${url.slice(0, 80)}...`);
-			} else if (isLocalPath(url)) {
-				if (!localMediaToSend.includes(url)) {
-					localMediaToSend.push(url);
-					log?.info(`${prefix} Collected local media from markdown for auto-routing: ${url}`);
-				}
-			}
-		}
-	}
-	const bareUrlMatches = [...replyText.matchAll(/(?<![(\["'])(https?:\/\/[^\s)"'<>]+\.(?:png|jpg|jpeg|gif|webp)(?:\?[^\s"'<>]*)?)/gi)];
-	for (const m of bareUrlMatches) {
-		const url = m[1];
-		if (url && !collectedImageUrls.includes(url)) {
-			collectedImageUrls.push(url);
-			log?.info(`${prefix} Extracted bare image URL: ${url.slice(0, 80)}...`);
-		}
-	}
-	const useMarkdown = account.markdownSupport === true;
-	log?.info(`${prefix} Markdown mode: ${useMarkdown}, images: ${collectedImageUrls.length}`);
-	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 (useMarkdown) await sendMarkdownReply(textWithoutImages, collectedImageUrls, mdMatches, bareUrlMatches, event, actx, sendWithRetry, consumeQuoteRef);
-	else await sendPlainTextReply(textWithoutImages, collectedImageUrls, mdMatches, bareUrlMatches, event, actx, sendWithRetry, consumeQuoteRef);
-	if (localMediaToSend.length > 0) {
-		log?.info(`${prefix} Sending ${localMediaToSend.length} local media via sendMedia auto-routing`);
-		for (const mediaPath of localMediaToSend) try {
-			const result = await sendMedia({
-				to: qualifiedTarget,
-				text: "",
-				mediaUrl: mediaPath,
-				accountId: account.accountId,
-				replyToId: event.messageId,
-				account
-			});
-			if (result.error) log?.error(`${prefix} sendMedia(auto) error for ${mediaPath}: ${result.error}`);
-			else log?.info(`${prefix} Sent local media: ${mediaPath}`);
-		} catch (err) {
-			log?.error(`${prefix} sendMedia(auto) failed for ${mediaPath}: ${err}`);
-		}
-	}
-	if (toolMediaUrls.length > 0) {
-		log?.info(`${prefix} Forwarding ${toolMediaUrls.length} tool-collected media URL(s) after block deliver`);
-		for (const mediaUrl of toolMediaUrls) try {
-			const result = await sendMedia({
-				to: qualifiedTarget,
-				text: "",
-				mediaUrl,
-				accountId: account.accountId,
-				replyToId: event.messageId,
-				account
-			});
-			if (result.error) log?.error(`${prefix} Tool media forward error: ${result.error}`);
-			else log?.info(`${prefix} Forwarded tool media: ${mediaUrl.slice(0, 80)}...`);
-		} catch (err) {
-			log?.error(`${prefix} Tool media forward failed: ${err}`);
-		}
-		toolMediaUrls.length = 0;
-	}
-}
-/** Decode a media path by stripping `MEDIA:`, expanding `~`, and unescaping. */
-function decodeMediaPath(raw, log, prefix) {
-	let mediaPath = raw;
-	if (mediaPath.startsWith("MEDIA:")) mediaPath = mediaPath.slice(6);
-	mediaPath = normalizePath(mediaPath);
-	mediaPath = mediaPath.replace(/\\\\/g, "\\");
-	const isWinLocal = /^[a-zA-Z]:[\\/]/.test(mediaPath) || mediaPath.startsWith("\\\\");
-	try {
-		const hasOctal = /\\[0-7]{1,3}/.test(mediaPath);
-		const hasNonASCII = /[\u0080-\u00FF]/.test(mediaPath);
-		if (!isWinLocal && (hasOctal || hasNonASCII)) {
-			log?.debug?.(`${prefix} Decoding path with mixed encoding: ${mediaPath}`);
-			let decoded = mediaPath.replace(/\\([0-7]{1,3})/g, (_, octal) => {
-				return String.fromCharCode(parseInt(octal, 8));
-			});
-			const bytes = [];
-			for (let i = 0; i < decoded.length; i++) {
-				const code = decoded.charCodeAt(i);
-				if (code <= 255) bytes.push(code);
-				else {
-					const charBytes = Buffer.from(decoded[i], "utf8");
-					bytes.push(...charBytes);
-				}
-			}
-			const utf8Decoded = Buffer.from(bytes).toString("utf8");
-			if (!utf8Decoded.includes("�") || utf8Decoded.length < decoded.length) {
-				mediaPath = utf8Decoded;
-				log?.debug?.(`${prefix} Successfully decoded path: ${mediaPath}`);
-			}
-		}
-	} catch (decodeErr) {
-		log?.error(`${prefix} Path decode error: ${decodeErr}`);
-	}
-	return mediaPath;
-}
-/** Shared helper for sending chunked text replies. */
-async function sendTextChunks(text, event, actx, sendWithRetry, consumeQuoteRef) {
-	const { account, log } = actx;
-	const prefix = `[qqbot:${account.accountId}]`;
-	const chunks = getQQBotRuntime().channel.text.chunkMarkdownText(text, TEXT_CHUNK_LIMIT);
-	for (const chunk of chunks) try {
-		await sendWithRetry(async (token) => {
-			const ref = consumeQuoteRef();
-			if (event.type === "c2c") return await sendC2CMessage(account.appId, token, event.senderId, chunk, event.messageId, ref);
-			else if (event.type === "group" && event.groupOpenid) return await sendGroupMessage(account.appId, token, event.groupOpenid, chunk, event.messageId);
-			else if (event.type === "dm" && event.guildId) return await sendDmMessage(token, event.guildId, chunk, event.messageId);
-			else if (event.channelId) return await sendChannelMessage(token, event.channelId, chunk, event.messageId);
-		});
-		log?.info(`${prefix} Sent text chunk (${chunk.length}/${text.length} chars): ${chunk.slice(0, 50)}...`);
-	} catch (err) {
-		log?.error(`${prefix} Failed to send text chunk: ${err}`);
-	}
-}
-/** Send voice with a 45s timeout guard. */
-async function sendVoiceWithTimeout(target, voicePath, account, log, prefix) {
-	const uploadFormats = account.config?.audioFormatPolicy?.uploadDirectFormats ?? account.config?.voiceDirectUploadFormats;
-	const transcodeEnabled = account.config?.audioFormatPolicy?.transcodeEnabled !== false;
-	const voiceTimeout = 45e3;
-	const ac = new AbortController();
-	try {
-		const result = await Promise.race([sendVoice(target, voicePath, uploadFormats, transcodeEnabled).then((r) => {
-			if (ac.signal.aborted) {
-				log?.info(`${prefix} sendVoice completed after timeout, suppressing late delivery`);
-				return {
-					channel: "qqbot",
-					error: "Voice send completed after timeout (suppressed)"
-				};
-			}
-			return r;
-		}), new Promise((resolve) => setTimeout(() => {
-			ac.abort();
-			resolve({
-				channel: "qqbot",
-				error: "Voice send timed out and was skipped"
-			});
-		}, voiceTimeout))]);
-		if (result.error) log?.error(`${prefix} sendVoice error: ${result.error}`);
-	} catch (err) {
-		log?.error(`${prefix} sendVoice unexpected error: ${err}`);
-	}
-}
-/** Send in markdown mode. */
-async function sendMarkdownReply(textWithoutImages, imageUrls, mdMatches, bareUrlMatches, event, actx, sendWithRetry, consumeQuoteRef) {
-	const { account, log } = actx;
-	const prefix = `[qqbot:${account.accountId}]`;
-	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);
-	log?.info(`${prefix} Image classification: httpUrls=${httpImageUrls.length}, base64=${base64ImageUrls.length}`);
-	if (base64ImageUrls.length > 0) {
-		log?.info(`${prefix} Sending ${base64ImageUrls.length} image(s) via Rich Media API...`);
-		for (const imageUrl of base64ImageUrls) try {
-			await sendWithRetry(async (token) => {
-				if (event.type === "c2c") await sendC2CImageMessage(account.appId, token, event.senderId, imageUrl, event.messageId);
-				else if (event.type === "group" && event.groupOpenid) await sendGroupImageMessage(account.appId, token, event.groupOpenid, imageUrl, event.messageId);
-				else if (event.type === "dm" && event.guildId) log?.info(`${prefix} DM does not support rich media image, skipping Base64 image`);
-				else if (event.channelId) log?.info(`${prefix} Channel does not support rich media, skipping Base64 image`);
-			});
-			log?.info(`${prefix} Sent Base64 image via Rich Media API (size: ${imageUrl.length} chars)`);
-		} catch (imgErr) {
-			log?.error(`${prefix} Failed to send Base64 image via Rich Media API: ${imgErr}`);
-		}
-	}
-	const existingMdUrls = new Set(mdMatches.map((m) => m[2]));
-	const imagesToAppend = [];
-	for (const url of httpImageUrls) if (!existingMdUrls.has(url)) try {
-		const size = await getImageSize(url);
-		imagesToAppend.push(formatQQBotMarkdownImage(url, size));
-		log?.info(`${prefix} Formatted HTTP image: ${size ? `${size.width}x${size.height}` : "default size"} - ${url.slice(0, 60)}...`);
-	} catch (err) {
-		log?.info(`${prefix} Failed to get image size, using default: ${err}`);
-		imagesToAppend.push(formatQQBotMarkdownImage(url, null));
-	}
-	let result = textWithoutImages;
-	for (const m of mdMatches) {
-		const fullMatch = m[0];
-		const imgUrl = m[2];
-		if ((imgUrl.startsWith("http://") || imgUrl.startsWith("https://")) && !hasQQBotImageSize(fullMatch)) try {
-			const size = await getImageSize(imgUrl);
-			result = result.replace(fullMatch, formatQQBotMarkdownImage(imgUrl, size));
-			log?.info(`${prefix} Updated image with size: ${size ? `${size.width}x${size.height}` : "default"} - ${imgUrl.slice(0, 60)}...`);
-		} catch (err) {
-			log?.info(`${prefix} Failed to get image size for existing md, using default: ${err}`);
-			result = result.replace(fullMatch, formatQQBotMarkdownImage(imgUrl, null));
-		}
-	}
-	for (const m of bareUrlMatches) result = result.replace(m[0], "").trim();
-	if (imagesToAppend.length > 0) {
-		result = result.trim();
-		result = result ? result + "\n\n" + imagesToAppend.join("\n") : imagesToAppend.join("\n");
-	}
-	if (result.trim()) {
-		const mdChunks = chunkText(result, TEXT_CHUNK_LIMIT);
-		for (const chunk of mdChunks) try {
-			await sendWithRetry(async (token) => {
-				const ref = consumeQuoteRef();
-				if (event.type === "c2c") return await sendC2CMessage(account.appId, token, event.senderId, chunk, event.messageId, ref);
-				else if (event.type === "group" && event.groupOpenid) return await sendGroupMessage(account.appId, token, event.groupOpenid, chunk, event.messageId);
-				else if (event.type === "dm" && event.guildId) return await sendDmMessage(token, event.guildId, chunk, event.messageId);
-				else if (event.channelId) return await sendChannelMessage(token, event.channelId, chunk, event.messageId);
-			});
-			log?.info(`${prefix} Sent markdown chunk (${chunk.length}/${result.length} chars) with ${httpImageUrls.length} HTTP images (${event.type})`);
-		} catch (err) {
-			log?.error(`${prefix} Failed to send markdown message chunk: ${err}`);
-		}
-	}
-}
-/** Send in plain-text mode. */
-async function sendPlainTextReply(textWithoutImages, imageUrls, mdMatches, bareUrlMatches, event, actx, sendWithRetry, consumeQuoteRef) {
-	const { account, log } = actx;
-	const prefix = `[qqbot:${account.accountId}]`;
-	const imgMediaTarget = {
-		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,
-		logPrefix: prefix
-	};
-	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();
-	if (result && event.type !== "c2c") result = result.replace(/([a-zA-Z0-9])\.([a-zA-Z0-9])/g, "$1_$2");
-	try {
-		for (const imageUrl of imageUrls) try {
-			const imgResult = await sendPhoto(imgMediaTarget, imageUrl);
-			if (imgResult.error) log?.error(`${prefix} Failed to send image: ${imgResult.error}`);
-			else log?.info(`${prefix} Sent image via sendPhoto: ${imageUrl.slice(0, 80)}...`);
-		} catch (imgErr) {
-			log?.error(`${prefix} Failed to send image: ${imgErr}`);
-		}
-		if (result.trim()) {
-			const plainChunks = chunkText(result, TEXT_CHUNK_LIMIT);
-			for (const chunk of plainChunks) {
-				await sendWithRetry(async (token) => {
-					const ref = consumeQuoteRef();
-					if (event.type === "c2c") return await sendC2CMessage(account.appId, token, event.senderId, chunk, event.messageId, ref);
-					else if (event.type === "group" && event.groupOpenid) return await sendGroupMessage(account.appId, token, event.groupOpenid, chunk, event.messageId);
-					else if (event.channelId) return await sendChannelMessage(token, event.channelId, chunk, event.messageId);
-				});
-				log?.info(`${prefix} Sent text chunk (${chunk.length}/${result.length} chars) (${event.type})`);
-			}
-		}
-	} catch (err) {
-		log?.error(`${prefix} Send failed: ${err}`);
-	}
-}
-//#endregion
-//#region extensions/qqbot/src/ref-index-store.ts
-const STORAGE_DIR = getQQBotDataDir("data");
-const REF_INDEX_FILE = path.join(STORAGE_DIR, "ref-index.jsonl");
-const MAX_ENTRIES = 5e4;
-const TTL_MS = 10080 * 60 * 1e3;
-const COMPACT_THRESHOLD_RATIO = 2;
-let cache = null;
-let totalLinesOnDisk = 0;
-/** Lazily load the JSONL store into memory. */
-function loadFromFile() {
-	if (cache !== null) return cache;
-	cache = /* @__PURE__ */ new Map();
-	totalLinesOnDisk = 0;
-	try {
-		if (!fsSync.existsSync(REF_INDEX_FILE)) return cache;
-		const lines = fsSync.readFileSync(REF_INDEX_FILE, "utf-8").split("\n");
-		const now = Date.now();
-		let expired = 0;
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (!trimmed) continue;
-			totalLinesOnDisk++;
-			try {
-				const entry = JSON.parse(trimmed);
-				if (!entry.k || !entry.v || !entry.t) continue;
-				if (now - entry.t > TTL_MS) {
-					expired++;
-					continue;
-				}
-				cache.set(entry.k, {
-					...entry.v,
-					_createdAt: entry.t
-				});
-			} catch {}
-		}
-		debugLog(`[ref-index-store] Loaded ${cache.size} entries from ${totalLinesOnDisk} lines (${expired} expired)`);
-		if (shouldCompact()) compactFile();
-	} catch (err) {
-		debugError(`[ref-index-store] Failed to load: ${err}`);
-		cache = /* @__PURE__ */ new Map();
-	}
-	return cache;
-}
-/** Append one record to the JSONL file. */
-function appendLine(line) {
-	try {
-		ensureDir$1();
-		fsSync.appendFileSync(REF_INDEX_FILE, JSON.stringify(line) + "\n", "utf-8");
-		totalLinesOnDisk++;
-	} catch (err) {
-		debugError(`[ref-index-store] Failed to append: ${err}`);
-	}
-}
-function ensureDir$1() {
-	if (!fsSync.existsSync(STORAGE_DIR)) fsSync.mkdirSync(STORAGE_DIR, { recursive: true });
-}
-function shouldCompact() {
-	if (!cache) return false;
-	return totalLinesOnDisk > cache.size * COMPACT_THRESHOLD_RATIO && totalLinesOnDisk > 1e3;
-}
-function compactFile() {
-	if (!cache) return;
-	const before = totalLinesOnDisk;
-	try {
-		ensureDir$1();
-		const tmpPath = REF_INDEX_FILE + ".tmp";
-		const lines = [];
-		for (const [key, entry] of cache) {
-			const line = {
-				k: key,
-				v: {
-					content: entry.content,
-					senderId: entry.senderId,
-					senderName: entry.senderName,
-					timestamp: entry.timestamp,
-					isBot: entry.isBot,
-					attachments: entry.attachments
-				},
-				t: entry._createdAt
-			};
-			lines.push(JSON.stringify(line));
-		}
-		fsSync.writeFileSync(tmpPath, lines.join("\n") + "\n", "utf-8");
-		fsSync.renameSync(tmpPath, REF_INDEX_FILE);
-		totalLinesOnDisk = cache.size;
-		debugLog(`[ref-index-store] Compacted: ${before} lines → ${totalLinesOnDisk} lines`);
-	} catch (err) {
-		debugError(`[ref-index-store] Compact failed: ${err}`);
-	}
-}
-function evictIfNeeded() {
-	if (!cache || cache.size < MAX_ENTRIES) return;
-	const now = Date.now();
-	for (const [key, entry] of cache) if (now - entry._createdAt > TTL_MS) cache.delete(key);
-	if (cache.size >= MAX_ENTRIES) {
-		const toRemove = [...cache.entries()].sort((a, b) => a[1]._createdAt - b[1]._createdAt).slice(0, cache.size - MAX_ENTRIES + 1e3);
-		for (const [key] of toRemove) cache.delete(key);
-		debugLog(`[ref-index-store] Evicted ${toRemove.length} oldest entries`);
-	}
-}
-/** Persist a refIdx mapping for one message. */
-function setRefIndex(refIdx, entry) {
-	const store = loadFromFile();
-	evictIfNeeded();
-	const now = Date.now();
-	store.set(refIdx, {
-		content: entry.content,
-		senderId: entry.senderId,
-		senderName: entry.senderName,
-		timestamp: entry.timestamp,
-		isBot: entry.isBot,
-		attachments: entry.attachments,
-		_createdAt: now
-	});
-	appendLine({
-		k: refIdx,
-		v: {
-			content: entry.content,
-			senderId: entry.senderId,
-			senderName: entry.senderName,
-			timestamp: entry.timestamp,
-			isBot: entry.isBot,
-			attachments: entry.attachments
-		},
-		t: now
-	});
-	if (shouldCompact()) compactFile();
-}
-/** Look up one quoted message by refIdx. */
-function getRefIndex(refIdx) {
-	const store = loadFromFile();
-	const entry = store.get(refIdx);
-	if (!entry) return null;
-	if (Date.now() - entry._createdAt > TTL_MS) {
-		store.delete(refIdx);
-		return null;
-	}
-	return {
-		content: entry.content,
-		senderId: entry.senderId,
-		senderName: entry.senderName,
-		timestamp: entry.timestamp,
-		isBot: entry.isBot,
-		attachments: entry.attachments
-	};
-}
-/** Format a ref-index entry into text suitable for model context. */
-function formatRefEntryForAgent(entry) {
-	const parts = [];
-	if (entry.content.trim()) parts.push(entry.content);
-	if (entry.attachments?.length) for (const att of entry.attachments) {
-		const sourceHint = att.localPath ? ` (${att.localPath})` : att.url ? ` (${att.url})` : "";
-		switch (att.type) {
-			case "image":
-				parts.push(`[image${att.filename ? `: ${att.filename}` : ""}${sourceHint}]`);
-				break;
-			case "voice":
-				if (att.transcript) {
-					const sourceTag = att.transcriptSource ? ` - ${{
-						stt: "local STT",
-						asr: "platform ASR",
-						tts: "TTS source",
-						fallback: "fallback text"
-					}[att.transcriptSource] || att.transcriptSource}` : "";
-					parts.push(`[voice message (content: "${att.transcript}"${sourceTag})${sourceHint}]`);
-				} else parts.push(`[voice message${sourceHint}]`);
-				break;
-			case "video":
-				parts.push(`[video${att.filename ? `: ${att.filename}` : ""}${sourceHint}]`);
-				break;
-			case "file":
-				parts.push(`[file${att.filename ? `: ${att.filename}` : ""}${sourceHint}]`);
-				break;
-			default: parts.push(`[attachment${att.filename ? `: ${att.filename}` : ""}${sourceHint}]`);
-		}
-	}
-	return parts.join(" ") || "[empty message]";
-}
-/** Compact the store before process exit when needed. */
-function flushRefIndex() {
-	if (cache && shouldCompact()) compactFile();
-}
-//#endregion
-//#region extensions/qqbot/src/reply-dispatcher.ts
-/** Send a message and retry once if the token appears to have expired. */
-async function sendWithTokenRetry(appId, clientSecret, sendFn, log, accountId) {
-	try {
-		return await sendFn(await getAccessToken(appId, clientSecret));
-	} catch (err) {
-		const errMsg = String(err);
-		if (errMsg.includes("401") || errMsg.includes("token") || errMsg.includes("access_token")) {
-			log?.info(`[qqbot:${accountId}] Token may be expired, refreshing...`);
-			clearTokenCache(appId);
-			return await sendFn(await getAccessToken(appId, clientSecret));
-		} else throw err;
-	}
-}
-/** Route a text message to the correct QQ target type. */
-async function sendTextToTarget(ctx, text, refIdx) {
-	const { target, account } = ctx;
-	await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-		if (target.type === "c2c") await sendC2CMessage(account.appId, token, target.senderId, text, target.messageId, refIdx);
-		else if (target.type === "group" && target.groupOpenid) await sendGroupMessage(account.appId, token, target.groupOpenid, text, target.messageId);
-		else if (target.channelId) await sendChannelMessage(token, target.channelId, text, target.messageId);
-		else if (target.type === "dm" && target.guildId) await sendDmMessage(token, target.guildId, text, target.messageId);
-	}, ctx.log, account.accountId);
-}
-/** Best-effort delivery for error text back to the user. */
-async function sendErrorToTarget(ctx, errorText) {
-	try {
-		await sendTextToTarget(ctx, errorText);
-	} catch (sendErr) {
-		ctx.log?.error(`[qqbot:${ctx.account.accountId}] Failed to send error message: ${sendErr}`);
-	}
-}
-/**
-* Handle a structured payload prefixed with `QQBOT_PAYLOAD:`.
-* Returns true when the reply was handled here, otherwise false.
-*/
-async function handleStructuredPayload(ctx, replyText, recordActivity) {
-	const { target, account, cfg, log } = ctx;
-	const payloadResult = parseQQBotPayload(replyText);
-	if (!payloadResult.isPayload) return false;
-	if (payloadResult.error) {
-		log?.error(`[qqbot:${account.accountId}] Payload parse error: ${payloadResult.error}`);
-		return true;
-	}
-	if (!payloadResult.payload) return true;
-	const parsedPayload = payloadResult.payload;
-	log?.info(`[qqbot:${account.accountId}] Detected structured payload, type: ${parsedPayload.type}`);
-	if (isCronReminderPayload(parsedPayload)) {
-		log?.info(`[qqbot:${account.accountId}] Processing cron_reminder payload`);
-		const cronMessage = encodePayloadForCron(parsedPayload);
-		const confirmText = `⏰ Reminder scheduled. It will be sent at the configured time: "${parsedPayload.content}"`;
-		try {
-			await sendTextToTarget(ctx, confirmText);
-			log?.info(`[qqbot:${account.accountId}] Cron reminder confirmation sent, cronMessage: ${cronMessage}`);
-		} catch (err) {
-			log?.error(`[qqbot:${account.accountId}] Failed to send cron confirmation: ${err}`);
-		}
-		recordActivity();
-		return true;
-	}
-	if (isMediaPayload(parsedPayload)) {
-		log?.info(`[qqbot:${account.accountId}] Processing media payload, mediaType: ${parsedPayload.mediaType}`);
-		if (parsedPayload.mediaType === "image") await handleImagePayload(ctx, parsedPayload);
-		else if (parsedPayload.mediaType === "audio") await handleAudioPayload(ctx, parsedPayload);
-		else if (parsedPayload.mediaType === "video") await handleVideoPayload(ctx, parsedPayload);
-		else if (parsedPayload.mediaType === "file") await handleFilePayload(ctx, parsedPayload);
-		else log?.error(`[qqbot:${account.accountId}] Unknown media type: ${parsedPayload.mediaType}`);
-		recordActivity();
-		return true;
-	}
-	log?.error(`[qqbot:${account.accountId}] Unknown payload type: ${parsedPayload.type}`);
-	return true;
-}
-function validateStructuredPayloadLocalPath(ctx, payloadPath, mediaType) {
-	const allowedPath = resolveQQBotPayloadLocalFilePath(payloadPath);
-	if (allowedPath) return allowedPath;
-	ctx.log?.error(`[qqbot:${ctx.account.accountId}] Blocked ${mediaType} payload local path outside QQ Bot media storage`);
-	return null;
-}
-function isRemoteHttpUrl(p) {
-	return p.startsWith("http://") || p.startsWith("https://");
-}
-function isInlineImageDataUrl(p) {
-	return /^data:image\/[^;]+;base64,/i.test(p);
-}
-function sanitizeForLog(value, maxLen = 200) {
-	return value.replace(/[\r\n\t\0]/g, " ").slice(0, maxLen);
-}
-function describeMediaTargetForLog(pathValue, isHttpUrl) {
-	if (!isHttpUrl) return "<local-file>";
-	try {
-		const url = new URL(pathValue);
-		url.username = "";
-		url.password = "";
-		const urlId = crypto.createHash("sha256").update(url.toString()).digest("hex").slice(0, 12);
-		return sanitizeForLog(`${url.protocol}//${url.host}#${urlId}`);
-	} catch {
-		return "<invalid-url>";
-	}
-}
-async function readStructuredPayloadLocalFile(filePath) {
-	const openFlags = fsSync.constants.O_RDONLY | ("O_NOFOLLOW" in fsSync.constants ? fsSync.constants.O_NOFOLLOW : 0);
-	const handle = await fsSync.promises.open(filePath, openFlags);
-	try {
-		const stat = await handle.stat();
-		if (!stat.isFile()) throw new Error("Path is not a regular file");
-		if (stat.size > 20971520) throw new Error(`File is too large (${formatFileSize(stat.size)}); QQ Bot API limit is ${formatFileSize(MAX_UPLOAD_SIZE)}`);
-		return handle.readFile();
-	} finally {
-		await handle.close();
-	}
-}
-async function handleImagePayload(ctx, payload) {
-	const { target, account, log } = ctx;
-	const normalizedPath = normalizePath(payload.path);
-	let imageUrl;
-	if (payload.source === "file") imageUrl = validateStructuredPayloadLocalPath(ctx, normalizedPath, "image");
-	else if (isRemoteHttpUrl(normalizedPath) || isInlineImageDataUrl(normalizedPath)) imageUrl = normalizedPath;
-	else {
-		log?.error(`[qqbot:${account.accountId}] Image payload URL must use http(s) or data:image/: ${sanitizeForLog(payload.path)}`);
-		return;
-	}
-	if (!imageUrl) return;
-	const originalImagePath = payload.source === "file" ? imageUrl : void 0;
-	if (payload.source === "file") try {
-		const fileBuffer = await readStructuredPayloadLocalFile(imageUrl);
-		const base64Data = fileBuffer.toString("base64");
-		const ext = path.extname(imageUrl).toLowerCase();
-		const mimeType = {
-			".jpg": "image/jpeg",
-			".jpeg": "image/jpeg",
-			".png": "image/png",
-			".gif": "image/gif",
-			".webp": "image/webp",
-			".bmp": "image/bmp"
-		}[ext];
-		if (!mimeType) {
-			log?.error(`[qqbot:${account.accountId}] Unsupported image format: ${ext}`);
-			return;
-		}
-		imageUrl = `data:${mimeType};base64,${base64Data}`;
-		log?.info(`[qqbot:${account.accountId}] Converted local image to Base64 (size: ${formatFileSize(fileBuffer.length)})`);
-	} catch (readErr) {
-		log?.error(`[qqbot:${account.accountId}] Failed to read local image: ${readErr}`);
-		return;
-	}
-	try {
-		await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-			if (target.type === "c2c") await sendC2CImageMessage(account.appId, token, target.senderId, imageUrl, target.messageId, void 0, originalImagePath);
-			else if (target.type === "group" && target.groupOpenid) await sendGroupImageMessage(account.appId, token, target.groupOpenid, imageUrl, target.messageId);
-			else if (target.type === "dm" && target.guildId) await sendDmMessage(token, target.guildId, `![](${payload.path})`, target.messageId);
-			else if (target.channelId) await sendChannelMessage(token, target.channelId, `![](${payload.path})`, target.messageId);
-		}, log, account.accountId);
-		log?.info(`[qqbot:${account.accountId}] Sent image via media payload`);
-		if (payload.caption) await sendTextToTarget(ctx, payload.caption);
-	} catch (err) {
-		log?.error(`[qqbot:${account.accountId}] Failed to send image: ${err}`);
-	}
-}
-async function handleAudioPayload(ctx, payload) {
-	const { target, account, cfg, log } = ctx;
-	try {
-		const ttsText = payload.caption || payload.path;
-		if (!ttsText?.trim()) {
-			log?.error(`[qqbot:${account.accountId}] Voice missing text`);
-			return;
-		}
-		let silkBase64;
-		let silkPath;
-		let duration;
-		let providerLabel;
-		const ttsCfg = resolveTTSConfig(cfg);
-		if (ttsCfg) {
-			log?.info(`[qqbot:${account.accountId}] TTS (plugin): "${ttsText.slice(0, 50)}..." via ${ttsCfg.model}`);
-			const result = await textToSilk(ttsText, ttsCfg, getQQBotDataDir("tts"));
-			silkBase64 = result.silkBase64;
-			silkPath = result.silkPath;
-			duration = result.duration;
-			providerLabel = ttsCfg.model;
-		} else {
-			if (!isGlobalTTSAvailable(cfg)) {
-				log?.error(`[qqbot:${account.accountId}] TTS not configured (neither plugin channels.qqbot.tts nor global messages.tts)`);
-				return;
-			}
-			log?.info(`[qqbot:${account.accountId}] TTS (global fallback): "${ttsText.slice(0, 50)}..."`);
-			const globalResult = await textToSpeech({
-				text: ttsText,
-				cfg,
-				channel: "qqbot"
-			});
-			if (!globalResult.success || !globalResult.audioPath) {
-				log?.error(`[qqbot:${account.accountId}] Global TTS failed: ${globalResult.error ?? "unknown"}`);
-				return;
-			}
-			log?.info(`[qqbot:${account.accountId}] Global TTS returned: provider=${globalResult.provider}, format=${globalResult.outputFormat}, path=${globalResult.audioPath}`);
-			providerLabel = globalResult.provider ?? "global";
-			const base64 = await audioFileToSilkBase64(globalResult.audioPath);
-			if (!base64) {
-				log?.error(`[qqbot:${account.accountId}] Failed to convert global TTS audio to SILK`);
-				return;
-			}
-			silkBase64 = base64;
-			silkPath = globalResult.audioPath;
-			duration = 0;
-		}
-		if (!silkBase64) {
-			log?.error(`[qqbot:${account.accountId}] TTS produced no audio output`);
-			return;
-		}
-		log?.info(`[qqbot:${account.accountId}] TTS done (${providerLabel}): ${duration ? formatDuration(duration) : "N/A"}, file: ${silkPath ?? "N/A"}`);
-		await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-			if (target.type === "c2c") await sendC2CVoiceMessage(account.appId, token, target.senderId, silkBase64, void 0, target.messageId, ttsText, silkPath);
-			else if (target.type === "group" && target.groupOpenid) await sendGroupVoiceMessage(account.appId, token, target.groupOpenid, silkBase64, void 0, target.messageId);
-			else if (target.type === "dm" && target.guildId) {
-				log?.error(`[qqbot:${account.accountId}] Voice not supported in DM, sending text fallback`);
-				await sendDmMessage(token, target.guildId, ttsText, target.messageId);
-			} else if (target.channelId) {
-				log?.error(`[qqbot:${account.accountId}] Voice not supported in channel, sending text fallback`);
-				await sendChannelMessage(token, target.channelId, ttsText, target.messageId);
-			}
-		}, log, account.accountId);
-		log?.info(`[qqbot:${account.accountId}] Voice message sent`);
-	} catch (err) {
-		log?.error(`[qqbot:${account.accountId}] TTS/voice send failed: ${err}`);
-	}
-}
-async function handleVideoPayload(ctx, payload) {
-	const { target, account, log } = ctx;
-	try {
-		const originalPath = payload.path ?? "";
-		const normalizedPath = normalizePath(originalPath);
-		const isHttpUrl = isRemoteHttpUrl(normalizedPath);
-		const videoPath = isHttpUrl ? normalizedPath : validateStructuredPayloadLocalPath(ctx, originalPath, "video");
-		if (!videoPath) return;
-		if (!videoPath.trim()) {
-			log?.error(`[qqbot:${account.accountId}] Video missing path`);
-			return;
-		}
-		log?.info(`[qqbot:${account.accountId}] Video send: ${describeMediaTargetForLog(videoPath, isHttpUrl)}`);
-		await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-			if (isHttpUrl) {
-				if (target.type === "c2c") await sendC2CVideoMessage(account.appId, token, target.senderId, videoPath, void 0, target.messageId);
-				else if (target.type === "group" && target.groupOpenid) await sendGroupVideoMessage(account.appId, token, target.groupOpenid, videoPath, void 0, target.messageId);
-				else if (target.type === "dm") log?.error(`[qqbot:${account.accountId}] Video not supported in DM`);
-				else if (target.channelId) log?.error(`[qqbot:${account.accountId}] Video not supported in channel`);
-			} else {
-				const fileBuffer = await readStructuredPayloadLocalFile(videoPath);
-				const videoBase64 = fileBuffer.toString("base64");
-				log?.info(`[qqbot:${account.accountId}] Read local video (${formatFileSize(fileBuffer.length)}): ${describeMediaTargetForLog(videoPath, false)}`);
-				if (target.type === "c2c") await sendC2CVideoMessage(account.appId, token, target.senderId, void 0, videoBase64, target.messageId, void 0, videoPath);
-				else if (target.type === "group" && target.groupOpenid) await sendGroupVideoMessage(account.appId, token, target.groupOpenid, void 0, videoBase64, target.messageId);
-				else if (target.type === "dm") log?.error(`[qqbot:${account.accountId}] Video not supported in DM`);
-				else if (target.channelId) log?.error(`[qqbot:${account.accountId}] Video not supported in channel`);
-			}
-		}, log, account.accountId);
-		log?.info(`[qqbot:${account.accountId}] Video message sent`);
-		if (payload.caption) await sendTextToTarget(ctx, payload.caption);
-	} catch (err) {
-		log?.error(`[qqbot:${account.accountId}] Video send failed: ${err}`);
-	}
-}
-async function handleFilePayload(ctx, payload) {
-	const { target, account, log } = ctx;
-	try {
-		const originalPath = payload.path ?? "";
-		const normalizedPath = normalizePath(originalPath);
-		const isHttpUrl = isRemoteHttpUrl(normalizedPath);
-		const filePath = isHttpUrl ? normalizedPath : validateStructuredPayloadLocalPath(ctx, originalPath, "file");
-		if (!filePath) return;
-		if (!filePath.trim()) {
-			log?.error(`[qqbot:${account.accountId}] File missing path`);
-			return;
-		}
-		const fileName = sanitizeFileName(path.basename(filePath));
-		log?.info(`[qqbot:${account.accountId}] File send: ${describeMediaTargetForLog(filePath, isHttpUrl)} (${isHttpUrl ? "URL" : "local"})`);
-		await sendWithTokenRetry(account.appId, account.clientSecret, async (token) => {
-			if (isHttpUrl) {
-				if (target.type === "c2c") await sendC2CFileMessage(account.appId, token, target.senderId, void 0, filePath, target.messageId, fileName);
-				else if (target.type === "group" && target.groupOpenid) await sendGroupFileMessage(account.appId, token, target.groupOpenid, void 0, filePath, target.messageId, fileName);
-				else if (target.type === "dm") log?.error(`[qqbot:${account.accountId}] File not supported in DM`);
-				else if (target.channelId) log?.error(`[qqbot:${account.accountId}] File not supported in channel`);
-			} else {
-				const fileBase64 = (await readStructuredPayloadLocalFile(filePath)).toString("base64");
-				if (target.type === "c2c") await sendC2CFileMessage(account.appId, token, target.senderId, fileBase64, void 0, target.messageId, fileName, filePath);
-				else if (target.type === "group" && target.groupOpenid) await sendGroupFileMessage(account.appId, token, target.groupOpenid, fileBase64, void 0, target.messageId, fileName);
-				else if (target.type === "dm") log?.error(`[qqbot:${account.accountId}] File not supported in DM`);
-				else if (target.channelId) log?.error(`[qqbot:${account.accountId}] File not supported in channel`);
-			}
-		}, log, account.accountId);
-		log?.info(`[qqbot:${account.accountId}] File message sent`);
-	} catch (err) {
-		log?.error(`[qqbot:${account.accountId}] File send failed: ${err}`);
-	}
-}
-//#endregion
-//#region extensions/qqbot/src/session-store.ts
-const SESSION_DIR = getQQBotDataDir("sessions");
-const SESSION_EXPIRE_TIME = 300 * 1e3;
-const SAVE_THROTTLE_MS = 1e3;
-const throttleState = /* @__PURE__ */ new Map();
-/** Ensure the session directory exists. */
-function ensureDir() {
-	if (!fsSync.existsSync(SESSION_DIR)) fsSync.mkdirSync(SESSION_DIR, { recursive: true });
-}
-/** Return the session file path for one account. */
-function getSessionPath(accountId) {
-	const safeId = accountId.replace(/[^a-zA-Z0-9_-]/g, "_");
-	return path.join(SESSION_DIR, `session-${safeId}.json`);
-}
-/** Load a saved session, rejecting expired or mismatched appId entries. */
-function loadSession(accountId, expectedAppId) {
-	const filePath = getSessionPath(accountId);
-	try {
-		if (!fsSync.existsSync(filePath)) return null;
-		const data = fsSync.readFileSync(filePath, "utf-8");
-		const state = JSON.parse(data);
-		const now = Date.now();
-		if (now - state.savedAt > SESSION_EXPIRE_TIME) {
-			debugLog(`[session-store] Session expired for ${accountId}, age: ${Math.round((now - state.savedAt) / 1e3)}s`);
-			try {
-				fsSync.unlinkSync(filePath);
-			} catch {}
-			return null;
-		}
-		if (expectedAppId && state.appId && state.appId !== expectedAppId) {
-			debugLog(`[session-store] appId mismatch for ${accountId}: saved=${state.appId}, current=${expectedAppId}. Discarding stale session.`);
-			try {
-				fsSync.unlinkSync(filePath);
-			} catch {}
-			return null;
-		}
-		if (!state.sessionId || state.lastSeq === null || state.lastSeq === void 0) {
-			debugLog(`[session-store] Invalid session data for ${accountId}`);
-			return null;
-		}
-		debugLog(`[session-store] Loaded session for ${accountId}: sessionId=${state.sessionId}, lastSeq=${state.lastSeq}, appId=${state.appId ?? "unknown"}, age=${Math.round((now - state.savedAt) / 1e3)}s`);
-		return state;
-	} catch (err) {
-		debugError(`[session-store] Failed to load session for ${accountId}: ${err}`);
-		return null;
-	}
-}
-/** Save session state with throttling. */
-function saveSession(state) {
-	const { accountId } = state;
-	let throttle = throttleState.get(accountId);
-	if (!throttle) {
-		throttle = {
-			pendingState: null,
-			lastSaveTime: 0,
-			throttleTimer: null
-		};
-		throttleState.set(accountId, throttle);
-	}
-	const now = Date.now();
-	const timeSinceLastSave = now - throttle.lastSaveTime;
-	if (timeSinceLastSave >= SAVE_THROTTLE_MS) {
-		doSaveSession(state);
-		throttle.lastSaveTime = now;
-		throttle.pendingState = null;
-		if (throttle.throttleTimer) {
-			clearTimeout(throttle.throttleTimer);
-			throttle.throttleTimer = null;
-		}
-	} else {
-		throttle.pendingState = state;
-		if (!throttle.throttleTimer) {
-			const delay = SAVE_THROTTLE_MS - timeSinceLastSave;
-			throttle.throttleTimer = setTimeout(() => {
-				const t = throttleState.get(accountId);
-				if (t && t.pendingState) {
-					doSaveSession(t.pendingState);
-					t.lastSaveTime = Date.now();
-					t.pendingState = null;
-				}
-				if (t) t.throttleTimer = null;
-			}, delay);
-		}
-	}
-}
-/** Write one session file to disk immediately. */
-function doSaveSession(state) {
-	const filePath = getSessionPath(state.accountId);
-	try {
-		ensureDir();
-		const stateToSave = {
-			...state,
-			savedAt: Date.now()
-		};
-		fsSync.writeFileSync(filePath, JSON.stringify(stateToSave, null, 2), "utf-8");
-		debugLog(`[session-store] Saved session for ${state.accountId}: sessionId=${state.sessionId}, lastSeq=${state.lastSeq}`);
-	} catch (err) {
-		debugError(`[session-store] Failed to save session for ${state.accountId}: ${err}`);
-	}
-}
-/** Clear a saved session and any pending throttle state. */
-function clearSession(accountId) {
-	const filePath = getSessionPath(accountId);
-	const throttle = throttleState.get(accountId);
-	if (throttle) {
-		if (throttle.throttleTimer) clearTimeout(throttle.throttleTimer);
-		throttleState.delete(accountId);
-	}
-	try {
-		if (fsSync.existsSync(filePath)) {
-			fsSync.unlinkSync(filePath);
-			debugLog(`[session-store] Cleared session for ${accountId}`);
-		}
-	} catch (err) {
-		debugError(`[session-store] Failed to clear session for ${accountId}: ${err}`);
-	}
-}
-//#endregion
-//#region extensions/qqbot/src/typing-keepalive.ts
-/** Periodically refresh C2C typing state while a response is still in progress. */
-const TYPING_INTERVAL_MS = 5e4;
-var TypingKeepAlive = class {
-	constructor(getToken, clearCache, openid, msgId, log, logPrefix = "[qqbot]") {
-		this.getToken = getToken;
-		this.clearCache = clearCache;
-		this.openid = openid;
-		this.msgId = msgId;
-		this.log = log;
-		this.logPrefix = logPrefix;
-		this.timer = null;
-		this.stopped = false;
-	}
-	/** Start periodic keep-alive sends. */
-	start() {
-		if (this.stopped) return;
-		this.timer = setInterval(() => {
-			if (this.stopped) {
-				this.stop();
-				return;
-			}
-			this.send().catch(() => {});
-		}, TYPING_INTERVAL_MS);
-	}
-	/** Stop periodic keep-alive sends. */
-	stop() {
-		this.stopped = true;
-		if (this.timer) {
-			clearInterval(this.timer);
-			this.timer = null;
-		}
-	}
-	async send() {
-		try {
-			await sendC2CInputNotify(await this.getToken(), this.openid, this.msgId, 60);
-			this.log?.debug?.(`${this.logPrefix} Typing keep-alive sent to ${this.openid}`);
-		} catch (err) {
-			try {
-				this.clearCache();
-				await sendC2CInputNotify(await this.getToken(), this.openid, this.msgId, 60);
-			} catch {
-				this.log?.debug?.(`${this.logPrefix} Typing keep-alive failed for ${this.openid}: ${err}`);
-			}
-		}
-	}
-};
-//#endregion
-//#region extensions/qqbot/src/gateway.ts
-const INTENTS = {
-	GUILDS: 1,
-	GUILD_MEMBERS: 2,
-	PUBLIC_GUILD_MESSAGES: 1 << 30,
-	DIRECT_MESSAGE: 4096,
-	GROUP_AND_C2C: 1 << 25
-};
-const FULL_INTENTS = INTENTS.PUBLIC_GUILD_MESSAGES | INTENTS.DIRECT_MESSAGE | INTENTS.GROUP_AND_C2C;
-const FULL_INTENTS_DESC = "groups + DMs + channels";
-const RECONNECT_DELAYS = [
-	1e3,
-	2e3,
-	5e3,
-	1e4,
-	3e4,
-	6e4
-];
-const RATE_LIMIT_DELAY = 6e4;
-const MAX_RECONNECT_ATTEMPTS = 100;
-const MAX_QUICK_DISCONNECT_COUNT = 3;
-const QUICK_DISCONNECT_THRESHOLD = 5e3;
-/**
-* Start the Gateway WebSocket connection with automatic reconnect support.
-*/
-async function startGateway(ctx) {
-	const { account, abortSignal, cfg, onReady, onError, log } = ctx;
-	if (!account.appId || !account.clientSecret) throw new Error("QQBot not configured (missing appId or clientSecret)");
-	const diag = await runDiagnostics();
-	if (diag.warnings.length > 0) for (const w of diag.warnings) log?.info(`[qqbot:${account.accountId}] ${w}`);
-	initApiConfig(account.appId, { markdownSupport: account.markdownSupport });
-	log?.info(`[qqbot:${account.accountId}] API config: markdownSupport=${account.markdownSupport === true}`);
-	onMessageSent(account.appId, (refIdx, meta) => {
-		log?.info(`[qqbot:${account.accountId}] onMessageSent called: refIdx=${refIdx}, mediaType=${meta.mediaType}, ttsText=${meta.ttsText?.slice(0, 30)}`);
-		const attachments = [];
-		if (meta.mediaType) {
-			const localPath = meta.mediaLocalPath;
-			const filename = localPath ? path.basename(localPath) : void 0;
-			const attachment = {
-				type: meta.mediaType,
-				...localPath ? { localPath } : {},
-				...filename ? { filename } : {},
-				...meta.mediaUrl ? { url: meta.mediaUrl } : {}
-			};
-			if (meta.mediaType === "voice" && meta.ttsText) {
-				attachment.transcript = meta.ttsText;
-				attachment.transcriptSource = "tts";
-				log?.info(`[qqbot:${account.accountId}] Saving voice transcript (TTS): ${meta.ttsText.slice(0, 50)}`);
-			}
-			attachments.push(attachment);
-		}
-		setRefIndex(refIdx, {
-			content: meta.text ?? "",
-			senderId: account.accountId,
-			senderName: account.accountId,
-			timestamp: Date.now(),
-			isBot: true,
-			...attachments.length > 0 ? { attachments } : {}
-		});
-		log?.info(`[qqbot:${account.accountId}] Cached outbound refIdx: ${refIdx}, attachments=${JSON.stringify(attachments)}`);
-	});
-	const ttsCfg = resolveTTSConfig(cfg);
-	if (ttsCfg) {
-		const maskedKey = ttsCfg.apiKey.length > 8 ? `${ttsCfg.apiKey.slice(0, 4)}****${ttsCfg.apiKey.slice(-4)}` : "****";
-		log?.info(`[qqbot:${account.accountId}] TTS configured (plugin): model=${ttsCfg.model}, voice=${ttsCfg.voice}, authStyle=${ttsCfg.authStyle ?? "bearer"}, baseUrl=${ttsCfg.baseUrl}`);
-		log?.info(`[qqbot:${account.accountId}] TTS apiKey: ${maskedKey}${ttsCfg.queryParams ? `, queryParams=${JSON.stringify(ttsCfg.queryParams)}` : ""}${ttsCfg.speed !== void 0 ? `, speed=${ttsCfg.speed}` : ""}`);
-	} else if (isGlobalTTSAvailable(cfg)) {
-		const globalProvider = cfg.messages?.tts?.provider ?? "auto";
-		log?.info(`[qqbot:${account.accountId}] TTS configured (global fallback): provider=${globalProvider}`);
-	} else log?.info(`[qqbot:${account.accountId}] TTS not configured (voice messages will be unavailable)`);
-	let reconnectAttempts = 0;
-	let isAborted = false;
-	let currentWs = null;
-	let heartbeatInterval = null;
-	let sessionId = null;
-	let lastSeq = null;
-	let lastConnectTime = 0;
-	let quickDisconnectCount = 0;
-	let isConnecting = false;
-	let reconnectTimer = null;
-	let shouldRefreshToken = false;
-	const savedSession = loadSession(account.accountId, account.appId);
-	if (savedSession) {
-		sessionId = savedSession.sessionId;
-		lastSeq = savedSession.lastSeq;
-		log?.info(`[qqbot:${account.accountId}] Restored session from storage: sessionId=${sessionId}, lastSeq=${lastSeq}`);
-	}
-	const msgQueue = createMessageQueue({
-		accountId: account.accountId,
-		log,
-		isAborted: () => isAborted
-	});
-	const URGENT_COMMANDS = ["/stop"];
-	const trySlashCommandOrEnqueue = async (msg) => {
-		const content = (msg.content ?? "").trim();
-		if (!content.startsWith("/")) {
-			msgQueue.enqueue(msg);
-			return;
-		}
-		const contentLower = content.toLowerCase();
-		if (URGENT_COMMANDS.some((cmd) => contentLower === cmd.toLowerCase() || contentLower.startsWith(cmd.toLowerCase() + " "))) {
-			log?.info(`[qqbot:${account.accountId}] Urgent command detected: ${content.slice(0, 20)}, executing immediately`);
-			const peerId = msgQueue.getMessagePeerId(msg);
-			const droppedCount = msgQueue.clearUserQueue(peerId);
-			if (droppedCount > 0) log?.info(`[qqbot:${account.accountId}] Dropped ${droppedCount} queued messages for ${peerId} due to urgent command`);
-			msgQueue.executeImmediate(msg);
-			return;
-		}
-		const receivedAt = Date.now();
-		const peerId = msgQueue.getMessagePeerId(msg);
-		const cmdCtx = {
-			type: msg.type,
-			senderId: msg.senderId,
-			senderName: msg.senderName,
-			messageId: msg.messageId,
-			eventTimestamp: msg.timestamp,
-			receivedAt,
-			rawContent: content,
-			args: "",
-			channelId: msg.channelId,
-			groupOpenid: msg.groupOpenid,
-			accountId: account.accountId,
-			appId: account.appId,
-			accountConfig: account.config,
-			commandAuthorized: true,
-			queueSnapshot: msgQueue.getSnapshot(peerId)
-		};
-		try {
-			const reply = await matchSlashCommand(cmdCtx);
-			if (reply === null) {
-				msgQueue.enqueue(msg);
-				return;
-			}
-			log?.info(`[qqbot:${account.accountId}] Slash command matched: ${content}, replying directly`);
-			const token = await getAccessToken(account.appId, account.clientSecret);
-			const isFileResult = typeof reply === "object" && reply !== null && "filePath" in reply;
-			const replyText = isFileResult ? reply.text : reply;
-			const replyFile = isFileResult ? reply.filePath : null;
-			if (msg.type === "c2c") await sendC2CMessage(account.appId, token, msg.senderId, replyText, msg.messageId);
-			else if (msg.type === "group" && msg.groupOpenid) await sendGroupMessage(account.appId, token, msg.groupOpenid, replyText, msg.messageId);
-			else if (msg.channelId) await sendChannelMessage(token, msg.channelId, replyText, msg.messageId);
-			else if (msg.type === "dm" && msg.guildId) await sendDmMessage(token, msg.guildId, replyText, msg.messageId);
-			if (replyFile) try {
-				await sendDocument({
-					targetType: msg.type === "group" ? "group" : msg.type === "dm" ? "dm" : msg.type === "c2c" ? "c2c" : "channel",
-					targetId: msg.type === "group" ? msg.groupOpenid || msg.senderId : msg.type === "dm" ? msg.guildId || msg.senderId : msg.type === "c2c" ? msg.senderId : msg.channelId || msg.senderId,
-					account,
-					replyToId: msg.messageId,
-					logPrefix: `[qqbot:${account.accountId}]`
-				}, replyFile);
-				log?.info(`[qqbot:${account.accountId}] Slash command file sent: ${replyFile}`);
-			} catch (fileErr) {
-				log?.error(`[qqbot:${account.accountId}] Failed to send slash command file: ${fileErr}`);
-			}
-		} catch (err) {
-			log?.error(`[qqbot:${account.accountId}] Slash command error: ${err}`);
-			msgQueue.enqueue(msg);
-		}
-	};
-	abortSignal.addEventListener("abort", () => {
-		isAborted = true;
-		if (reconnectTimer) {
-			clearTimeout(reconnectTimer);
-			reconnectTimer = null;
-		}
-		cleanup();
-		stopBackgroundTokenRefresh(account.appId);
-		flushKnownUsers();
-		flushRefIndex();
-	});
-	const cleanup = () => {
-		if (heartbeatInterval) {
-			clearInterval(heartbeatInterval);
-			heartbeatInterval = null;
-		}
-		if (currentWs && (currentWs.readyState === WebSocket$1.OPEN || currentWs.readyState === WebSocket$1.CONNECTING)) currentWs.close();
-		currentWs = null;
-	};
-	const getReconnectDelay = () => {
-		return RECONNECT_DELAYS[Math.min(reconnectAttempts, RECONNECT_DELAYS.length - 1)];
-	};
-	const scheduleReconnect = (customDelay) => {
-		if (isAborted || reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-			log?.error(`[qqbot:${account.accountId}] Max reconnect attempts reached or aborted`);
-			return;
-		}
-		if (reconnectTimer) {
-			clearTimeout(reconnectTimer);
-			reconnectTimer = null;
-		}
-		const delay = customDelay ?? getReconnectDelay();
-		reconnectAttempts++;
-		log?.info(`[qqbot:${account.accountId}] Reconnecting in ${delay}ms (attempt ${reconnectAttempts})`);
-		reconnectTimer = setTimeout(() => {
-			reconnectTimer = null;
-			if (!isAborted) connect();
-		}, delay);
-	};
-	const connect = async () => {
-		if (isConnecting) {
-			log?.debug?.(`[qqbot:${account.accountId}] Already connecting, skip`);
-			return;
-		}
-		isConnecting = true;
-		try {
-			cleanup();
-			if (shouldRefreshToken) {
-				log?.info(`[qqbot:${account.accountId}] Refreshing token...`);
-				clearTokenCache(account.appId);
-				shouldRefreshToken = false;
-			}
-			const accessToken = await getAccessToken(account.appId, account.clientSecret);
-			log?.info(`[qqbot:${account.accountId}] ✅ Access token obtained successfully`);
-			const gatewayUrl = await getGatewayUrl(accessToken);
-			log?.info(`[qqbot:${account.accountId}] Connecting to ${gatewayUrl}`);
-			const ws = new WebSocket$1(gatewayUrl, { headers: { "User-Agent": PLUGIN_USER_AGENT } });
-			currentWs = ws;
-			const pluginRuntime = getQQBotRuntime();
-			const handleMessage = async (event) => {
-				log?.debug?.(`[qqbot:${account.accountId}] Received message: ${JSON.stringify(event)}`);
-				log?.info(`[qqbot:${account.accountId}] Processing message from ${event.senderId}: ${event.content}`);
-				if (event.attachments?.length) log?.info(`[qqbot:${account.accountId}] Attachments: ${event.attachments.length}`);
-				pluginRuntime.channel.activity.record({
-					channel: "qqbot",
-					accountId: account.accountId,
-					direction: "inbound"
-				});
-				const isC2C = event.type === "c2c" || event.type === "dm";
-				const typing = { keepAlive: null };
-				const inputNotifyPromise = (async () => {
-					if (!isC2C) return void 0;
-					try {
-						let token = await getAccessToken(account.appId, account.clientSecret);
-						try {
-							const notifyResponse = await sendC2CInputNotify(token, event.senderId, event.messageId, 60);
-							log?.info(`[qqbot:${account.accountId}] Sent input notify to ${event.senderId}${notifyResponse.refIdx ? `, got refIdx=${notifyResponse.refIdx}` : ""}`);
-							typing.keepAlive = new TypingKeepAlive(() => getAccessToken(account.appId, account.clientSecret), () => clearTokenCache(account.appId), event.senderId, event.messageId, log, `[qqbot:${account.accountId}]`);
-							typing.keepAlive.start();
-							return notifyResponse.refIdx;
-						} catch (notifyErr) {
-							const errMsg = String(notifyErr);
-							if (errMsg.includes("token") || errMsg.includes("401") || errMsg.includes("11244")) {
-								log?.info(`[qqbot:${account.accountId}] InputNotify token expired, refreshing...`);
-								clearTokenCache(account.appId);
-								token = await getAccessToken(account.appId, account.clientSecret);
-								const notifyResponse = await sendC2CInputNotify(token, event.senderId, event.messageId, 60);
-								typing.keepAlive = new TypingKeepAlive(() => getAccessToken(account.appId, account.clientSecret), () => clearTokenCache(account.appId), event.senderId, event.messageId, log, `[qqbot:${account.accountId}]`);
-								typing.keepAlive.start();
-								return notifyResponse.refIdx;
-							} else throw notifyErr;
-						}
-					} catch (err) {
-						log?.error(`[qqbot:${account.accountId}] sendC2CInputNotify error: ${err}`);
-						return;
-					}
-				})();
-				const isGroupChat = event.type === "guild" || event.type === "group";
-				const peerId = event.type === "guild" ? event.channelId ?? "unknown" : event.type === "group" ? event.groupOpenid ?? "unknown" : event.senderId;
-				const route = pluginRuntime.channel.routing.resolveAgentRoute({
-					cfg,
-					channel: "qqbot",
-					accountId: account.accountId,
-					peer: {
-						kind: isGroupChat ? "group" : "direct",
-						id: peerId
-					}
-				});
-				const envelopeOptions = pluginRuntime.channel.reply.resolveEnvelopeFormatOptions(cfg);
-				const systemPrompts = [];
-				if (account.systemPrompt) systemPrompts.push(account.systemPrompt);
-				const { attachmentInfo, imageUrls, imageMediaTypes, voiceAttachmentPaths, voiceAttachmentUrls, voiceAsrReferTexts, voiceTranscripts, voiceTranscriptSources, attachmentLocalPaths } = await processAttachments(event.attachments, {
-					accountId: account.accountId,
-					cfg,
-					log
-				});
-				const voiceText = formatVoiceText(voiceTranscripts);
-				const hasAsrReferFallback = voiceTranscriptSources.includes("asr");
-				const parsedContent = parseFaceTags(event.content);
-				const userContent = voiceText ? (parsedContent.trim() ? `${parsedContent}\n${voiceText}` : voiceText) + attachmentInfo : parsedContent + attachmentInfo;
-				let replyToId;
-				let replyToBody;
-				let replyToSender;
-				let replyToIsQuote = false;
-				if (event.refMsgIdx) {
-					const refEntry = getRefIndex(event.refMsgIdx);
-					if (refEntry) {
-						replyToId = event.refMsgIdx;
-						replyToBody = formatRefEntryForAgent(refEntry);
-						replyToSender = refEntry.senderName ?? refEntry.senderId;
-						replyToIsQuote = true;
-						log?.info(`[qqbot:${account.accountId}] Quote detected: refMsgIdx=${event.refMsgIdx}, sender=${replyToSender}, content="${replyToBody.slice(0, 80)}..."`);
-					} else {
-						log?.info(`[qqbot:${account.accountId}] Quote detected but refMsgIdx not in cache: ${event.refMsgIdx}`);
-						replyToId = event.refMsgIdx;
-						replyToIsQuote = true;
-					}
-				}
-				const inputNotifyRefIdx = await inputNotifyPromise;
-				const currentMsgIdx = event.msgIdx ?? inputNotifyRefIdx;
-				if (currentMsgIdx) {
-					const attSummaries = buildAttachmentSummaries(event.attachments, attachmentLocalPaths);
-					if (attSummaries && voiceTranscripts.length > 0) {
-						let voiceIdx = 0;
-						for (const att of attSummaries) if (att.type === "voice" && voiceIdx < voiceTranscripts.length) {
-							att.transcript = voiceTranscripts[voiceIdx];
-							if (voiceIdx < voiceTranscriptSources.length) att.transcriptSource = voiceTranscriptSources[voiceIdx];
-							voiceIdx++;
-						}
-					}
-					setRefIndex(currentMsgIdx, {
-						content: parsedContent,
-						senderId: event.senderId,
-						senderName: event.senderName,
-						timestamp: new Date(event.timestamp).getTime(),
-						attachments: attSummaries
-					});
-					log?.info(`[qqbot:${account.accountId}] Cached msgIdx=${currentMsgIdx} for future reference (source: ${event.msgIdx ? "message_scene.ext" : "InputNotify"})`);
-				}
-				const body = pluginRuntime.channel.reply.formatInboundEnvelope({
-					channel: "qqbot",
-					from: event.senderName ?? event.senderId,
-					timestamp: new Date(event.timestamp).getTime(),
-					body: userContent,
-					chatType: isGroupChat ? "group" : "direct",
-					sender: {
-						id: event.senderId,
-						name: event.senderName
-					},
-					envelope: envelopeOptions,
-					...imageUrls.length > 0 ? { imageUrls } : {}
-				});
-				const uniqueVoicePaths = [...new Set(voiceAttachmentPaths)];
-				const uniqueVoiceUrls = [...new Set(voiceAttachmentUrls)];
-				const uniqueVoiceAsrReferTexts = [...new Set(voiceAsrReferTexts)].filter(Boolean);
-				const sttTranscriptCount = voiceTranscriptSources.filter((s) => s === "stt").length;
-				const asrFallbackCount = voiceTranscriptSources.filter((s) => s === "asr").length;
-				const fallbackCount = voiceTranscriptSources.filter((s) => s === "fallback").length;
-				if (voiceAttachmentPaths.length > 0 || voiceAttachmentUrls.length > 0 || uniqueVoiceAsrReferTexts.length > 0) {
-					const asrPreview = uniqueVoiceAsrReferTexts.length > 0 ? uniqueVoiceAsrReferTexts[0].slice(0, 50) : "";
-					log?.info(`[qqbot:${account.accountId}] Voice input summary: local=${uniqueVoicePaths.length}, remote=${uniqueVoiceUrls.length}, asrReferTexts=${uniqueVoiceAsrReferTexts.length}, transcripts=${voiceTranscripts.length}, source(stt/asr/fallback)=${sttTranscriptCount}/${asrFallbackCount}/${fallbackCount}` + (asrPreview ? `, asr_preview="${asrPreview}${uniqueVoiceAsrReferTexts[0].length > 50 ? "..." : ""}"` : ""));
-				}
-				const qualifiedTarget = isGroupChat ? event.type === "guild" ? `qqbot:channel:${event.channelId}` : `qqbot:group:${event.groupOpenid}` : event.type === "dm" ? `qqbot:dm:${event.guildId}` : `qqbot:c2c:${event.senderId}`;
-				const hasTTS = !!resolveTTSConfig(cfg) || isGlobalTTSAvailable(cfg);
-				let quotePart = "";
-				if (replyToIsQuote) if (replyToBody) quotePart = `[Quoted message begins]\n${replyToBody}\n[Quoted message ends]\n`;
-				else quotePart = `[Quoted message begins]\nOriginal content unavailable\n[Quoted message ends]\n`;
-				const staticParts = [`[QQBot] to=${qualifiedTarget}`];
-				if (hasTTS) staticParts.push("voice synthesis enabled");
-				const staticInstruction = staticParts.join(" | ");
-				systemPrompts.unshift(staticInstruction);
-				const dynLines = [];
-				if (imageUrls.length > 0) dynLines.push(`- Images: ${imageUrls.join(", ")}`);
-				if (uniqueVoicePaths.length > 0 || uniqueVoiceUrls.length > 0) dynLines.push(`- Voice: ${[...uniqueVoicePaths, ...uniqueVoiceUrls].join(", ")}`);
-				if (uniqueVoiceAsrReferTexts.length > 0) dynLines.push(`- ASR: ${uniqueVoiceAsrReferTexts.join(" | ")}`);
-				const dynamicCtx = dynLines.length > 0 ? dynLines.join("\n") + "\n" : "";
-				const userMessage = `${quotePart}${userContent}`;
-				const agentBody = userContent.startsWith("/") ? userContent : `${systemPrompts.join("\n")}\n\n${dynamicCtx}${userMessage}`;
-				log?.info(`[qqbot:${account.accountId}] agentBody length: ${agentBody.length}`);
-				const fromAddress = event.type === "guild" ? `qqbot:channel:${event.channelId}` : event.type === "group" ? `qqbot:group:${event.groupOpenid}` : `qqbot:c2c:${event.senderId}`;
-				const toAddress = fromAddress;
-				const rawAllowFrom = account.config?.allowFrom ?? [];
-				const normalizedAllowFrom = qqbotPlugin.config?.formatAllowFrom ? qqbotPlugin.config.formatAllowFrom({
-					cfg,
-					accountId: account.accountId,
-					allowFrom: rawAllowFrom
-				}) : rawAllowFrom.map((e) => e.replace(/^qqbot:/i, "").toUpperCase());
-				const normalizedSenderId = event.senderId.replace(/^qqbot:/i, "").toUpperCase();
-				const commandAuthorized = normalizedAllowFrom.length === 0 || normalizedAllowFrom.some((e) => e === "*") || normalizedAllowFrom.includes(normalizedSenderId);
-				const localMediaPaths = [];
-				const localMediaTypes = [];
-				const remoteMediaUrls = [];
-				const remoteMediaTypes = [];
-				for (let i = 0; i < imageUrls.length; i++) {
-					const u = imageUrls[i];
-					const t = imageMediaTypes[i] ?? "image/png";
-					if (u.startsWith("http://") || u.startsWith("https://")) {
-						remoteMediaUrls.push(u);
-						remoteMediaTypes.push(t);
-					} else {
-						localMediaPaths.push(u);
-						localMediaTypes.push(t);
-					}
-				}
-				const ctxPayload = pluginRuntime.channel.reply.finalizeInboundContext({
-					Body: body,
-					BodyForAgent: agentBody,
-					RawBody: event.content,
-					CommandBody: event.content,
-					From: fromAddress,
-					To: toAddress,
-					SessionKey: route.sessionKey,
-					AccountId: route.accountId,
-					ChatType: isGroupChat ? "group" : "direct",
-					SenderId: event.senderId,
-					SenderName: event.senderName,
-					Provider: "qqbot",
-					Surface: "qqbot",
-					MessageSid: event.messageId,
-					Timestamp: new Date(event.timestamp).getTime(),
-					OriginatingChannel: "qqbot",
-					OriginatingTo: toAddress,
-					QQChannelId: event.channelId,
-					QQGuildId: event.guildId,
-					QQGroupOpenid: event.groupOpenid,
-					QQVoiceAsrReferAvailable: hasAsrReferFallback,
-					QQVoiceTranscriptSources: voiceTranscriptSources,
-					QQVoiceAttachmentPaths: uniqueVoicePaths,
-					QQVoiceAttachmentUrls: uniqueVoiceUrls,
-					QQVoiceAsrReferTexts: uniqueVoiceAsrReferTexts,
-					QQVoiceInputStrategy: "prefer_audio_stt_then_asr_fallback",
-					CommandAuthorized: commandAuthorized,
-					...localMediaPaths.length > 0 ? {
-						MediaPaths: localMediaPaths,
-						MediaPath: localMediaPaths[0],
-						MediaTypes: localMediaTypes,
-						MediaType: localMediaTypes[0]
-					} : {},
-					...remoteMediaUrls.length > 0 ? {
-						MediaUrls: remoteMediaUrls,
-						MediaUrl: remoteMediaUrls[0]
-					} : {},
-					...replyToId ? {
-						ReplyToId: replyToId,
-						ReplyToBody: replyToBody,
-						ReplyToSender: replyToSender,
-						ReplyToIsQuote: replyToIsQuote
-					} : {}
-				});
-				const replyCtx = {
-					target: {
-						type: event.type,
-						senderId: event.senderId,
-						messageId: event.messageId,
-						channelId: event.channelId,
-						guildId: event.guildId,
-						groupOpenid: event.groupOpenid
-					},
-					account,
-					cfg,
-					log
-				};
-				const sendWithRetry = (sendFn) => sendWithTokenRetry(account.appId, account.clientSecret, sendFn, log, account.accountId);
-				const sendErrorMessage = (errorText) => sendErrorToTarget(replyCtx, errorText);
-				try {
-					const messagesConfig = pluginRuntime.channel.reply.resolveEffectiveMessagesConfig(cfg, route.agentId);
-					let hasResponse = false;
-					let hasBlockResponse = false;
-					let toolDeliverCount = 0;
-					const toolTexts = [];
-					const toolMediaUrls = [];
-					let toolFallbackSent = false;
-					const responseTimeout = 12e4;
-					const toolOnlyTimeout = 6e4;
-					const maxToolRenewals = 3;
-					let toolRenewalCount = 0;
-					let timeoutId = null;
-					let toolOnlyTimeoutId = null;
-					const sendToolFallback = async () => {
-						if (toolMediaUrls.length > 0) {
-							log?.info(`[qqbot:${account.accountId}] Tool fallback: forwarding ${toolMediaUrls.length} media URL(s) from tool deliver(s)`);
-							const mediaTimeout = 45e3;
-							for (const mediaUrl of toolMediaUrls) {
-								const ac = new AbortController();
-								try {
-									const result = await Promise.race([sendMedia({
-										to: qualifiedTarget,
-										text: "",
-										mediaUrl,
-										accountId: account.accountId,
-										replyToId: event.messageId,
-										account
-									}).then((r) => {
-										if (ac.signal.aborted) {
-											log?.info(`[qqbot:${account.accountId}] Tool fallback sendMedia completed after timeout, suppressing late delivery`);
-											return {
-												channel: "qqbot",
-												error: "Media send completed after timeout (suppressed)"
-											};
-										}
-										return r;
-									}), new Promise((resolve) => setTimeout(() => {
-										ac.abort();
-										resolve({
-											channel: "qqbot",
-											error: `Tool fallback media send timeout (${mediaTimeout / 1e3}s)`
-										});
-									}, mediaTimeout))]);
-									if (result.error) log?.error(`[qqbot:${account.accountId}] Tool fallback sendMedia error: ${result.error}`);
-								} catch (err) {
-									log?.error(`[qqbot:${account.accountId}] Tool fallback sendMedia failed: ${err}`);
-								}
-							}
-							return;
-						}
-						if (toolTexts.length > 0) {
-							const text = toolTexts.slice(-3).join("\n---\n").slice(0, 2e3);
-							log?.info(`[qqbot:${account.accountId}] Tool fallback: forwarding tool text (${text.length} chars)`);
-							await sendErrorMessage(text);
-							return;
-						}
-						log?.info(`[qqbot:${account.accountId}] Tool fallback: no media or text collected from ${toolDeliverCount} tool deliver(s), silently dropping`);
-					};
-					const timeoutPromise = new Promise((_, reject) => {
-						timeoutId = setTimeout(() => {
-							if (!hasResponse) reject(/* @__PURE__ */ new Error("Response timeout"));
-						}, responseTimeout);
-					});
-					const dispatchPromise = pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-						ctx: ctxPayload,
-						cfg,
-						dispatcherOptions: {
-							responsePrefix: messagesConfig.responsePrefix,
-							deliver: async (payload, info) => {
-								hasResponse = true;
-								log?.info(`[qqbot:${account.accountId}] deliver called, kind: ${info.kind}, payload keys: ${Object.keys(payload).join(", ")}`);
-								if (info.kind === "tool") {
-									toolDeliverCount++;
-									const toolText = (payload.text ?? "").trim();
-									if (toolText) toolTexts.push(toolText);
-									if (payload.mediaUrls?.length) toolMediaUrls.push(...payload.mediaUrls);
-									if (payload.mediaUrl && !toolMediaUrls.includes(payload.mediaUrl)) toolMediaUrls.push(payload.mediaUrl);
-									log?.info(`[qqbot:${account.accountId}] Collected tool deliver #${toolDeliverCount}: text=${toolText.length} chars, media=${toolMediaUrls.length} URLs`);
-									if (hasBlockResponse && toolMediaUrls.length > 0) {
-										log?.info(`[qqbot:${account.accountId}] Block already sent, immediately forwarding ${toolMediaUrls.length} tool media URL(s)`);
-										const urlsToSend = [...toolMediaUrls];
-										toolMediaUrls.length = 0;
-										for (const mediaUrl of urlsToSend) try {
-											const result = await sendMedia({
-												to: qualifiedTarget,
-												text: "",
-												mediaUrl,
-												accountId: account.accountId,
-												replyToId: event.messageId,
-												account
-											});
-											if (result.error) log?.error(`[qqbot:${account.accountId}] Tool media immediate forward error: ${result.error}`);
-											else log?.info(`[qqbot:${account.accountId}] Forwarded tool media (post-block): ${mediaUrl.slice(0, 80)}...`);
-										} catch (err) {
-											log?.error(`[qqbot:${account.accountId}] Tool media immediate forward failed: ${err}`);
-										}
-										return;
-									}
-									if (toolFallbackSent) return;
-									if (toolOnlyTimeoutId) if (toolRenewalCount < maxToolRenewals) {
-										clearTimeout(toolOnlyTimeoutId);
-										toolRenewalCount++;
-										log?.info(`[qqbot:${account.accountId}] Tool-only timer renewed (${toolRenewalCount}/${maxToolRenewals})`);
-									} else {
-										log?.info(`[qqbot:${account.accountId}] Tool-only timer renewal limit reached (${maxToolRenewals}), waiting for timeout`);
-										return;
-									}
-									toolOnlyTimeoutId = setTimeout(async () => {
-										if (!hasBlockResponse && !toolFallbackSent) {
-											toolFallbackSent = true;
-											log?.error(`[qqbot:${account.accountId}] Tool-only timeout: ${toolDeliverCount} tool deliver(s) but no block within ${toolOnlyTimeout / 1e3}s, sending fallback`);
-											try {
-												await sendToolFallback();
-											} catch (sendErr) {
-												log?.error(`[qqbot:${account.accountId}] Failed to send tool-only fallback: ${sendErr}`);
-											}
-										}
-									}, toolOnlyTimeout);
-									return;
-								}
-								hasBlockResponse = true;
-								typing.keepAlive?.stop();
-								if (timeoutId) {
-									clearTimeout(timeoutId);
-									timeoutId = null;
-								}
-								if (toolOnlyTimeoutId) {
-									clearTimeout(toolOnlyTimeoutId);
-									toolOnlyTimeoutId = null;
-								}
-								if (toolDeliverCount > 0) log?.info(`[qqbot:${account.accountId}] Block deliver after ${toolDeliverCount} tool deliver(s)`);
-								const quoteRef = event.msgIdx;
-								let quoteRefUsed = false;
-								const consumeQuoteRef = () => {
-									if (quoteRef && !quoteRefUsed) {
-										quoteRefUsed = true;
-										return quoteRef;
-									}
-								};
-								let replyText = payload.text ?? "";
-								const deliverEvent = {
-									type: event.type,
-									senderId: event.senderId,
-									messageId: event.messageId,
-									channelId: event.channelId,
-									groupOpenid: event.groupOpenid,
-									msgIdx: event.msgIdx
-								};
-								const deliverActx = {
-									account,
-									qualifiedTarget,
-									log
-								};
-								const mediaResult = await parseAndSendMediaTags(replyText, deliverEvent, deliverActx, sendWithRetry, consumeQuoteRef);
-								if (mediaResult.handled) {
-									pluginRuntime.channel.activity.record({
-										channel: "qqbot",
-										accountId: account.accountId,
-										direction: "outbound"
-									});
-									return;
-								}
-								replyText = mediaResult.normalizedText;
-								const recordOutboundActivity = () => pluginRuntime.channel.activity.record({
-									channel: "qqbot",
-									accountId: account.accountId,
-									direction: "outbound"
-								});
-								if (await handleStructuredPayload(replyCtx, replyText, recordOutboundActivity)) return;
-								await sendPlainReply(payload, replyText, deliverEvent, deliverActx, sendWithRetry, consumeQuoteRef, toolMediaUrls);
-								pluginRuntime.channel.activity.record({
-									channel: "qqbot",
-									accountId: account.accountId,
-									direction: "outbound"
-								});
-							},
-							onError: async (err) => {
-								log?.error(`[qqbot:${account.accountId}] Dispatch error: ${err}`);
-								hasResponse = true;
-								if (timeoutId) {
-									clearTimeout(timeoutId);
-									timeoutId = null;
-								}
-								const errMsg = String(err);
-								if (errMsg.includes("401") || errMsg.includes("key") || errMsg.includes("auth")) log?.error(`[qqbot:${account.accountId}] AI auth error: ${errMsg}`);
-								else log?.error(`[qqbot:${account.accountId}] AI process error: ${errMsg}`);
-							}
-						},
-						replyOptions: { disableBlockStreaming: true }
-					});
-					try {
-						await Promise.race([dispatchPromise, timeoutPromise]);
-					} catch (err) {
-						if (timeoutId) clearTimeout(timeoutId);
-						if (!hasResponse) log?.error(`[qqbot:${account.accountId}] No response within timeout`);
-					} finally {
-						if (toolOnlyTimeoutId) {
-							clearTimeout(toolOnlyTimeoutId);
-							toolOnlyTimeoutId = null;
-						}
-						if (toolDeliverCount > 0 && !hasBlockResponse && !toolFallbackSent) {
-							toolFallbackSent = true;
-							log?.error(`[qqbot:${account.accountId}] Dispatch completed with ${toolDeliverCount} tool deliver(s) but no block deliver, sending fallback`);
-							await sendToolFallback();
-						}
-					}
-				} catch (err) {
-					log?.error(`[qqbot:${account.accountId}] Message processing failed: ${err}`);
-				} finally {
-					typing.keepAlive?.stop();
-				}
-			};
-			ws.on("open", () => {
-				log?.info(`[qqbot:${account.accountId}] WebSocket connected`);
-				isConnecting = false;
-				reconnectAttempts = 0;
-				lastConnectTime = Date.now();
-				msgQueue.startProcessor(handleMessage);
-				startBackgroundTokenRefresh(account.appId, account.clientSecret, { log });
-			});
-			ws.on("message", async (data) => {
-				try {
-					const rawData = data.toString();
-					const { op, d, s, t } = JSON.parse(rawData);
-					if (s) {
-						lastSeq = s;
-						if (sessionId) saveSession({
-							sessionId,
-							lastSeq,
-							lastConnectedAt: lastConnectTime,
-							intentLevelIndex: 0,
-							accountId: account.accountId,
-							savedAt: Date.now(),
-							appId: account.appId
-						});
-					}
-					log?.debug?.(`[qqbot:${account.accountId}] Received op=${op} t=${t}`);
-					switch (op) {
-						case 10:
-							log?.info(`[qqbot:${account.accountId}] Hello received`);
-							if (sessionId && lastSeq !== null) {
-								log?.info(`[qqbot:${account.accountId}] Attempting to resume session ${sessionId}`);
-								ws.send(JSON.stringify({
-									op: 6,
-									d: {
-										token: `QQBot ${accessToken}`,
-										session_id: sessionId,
-										seq: lastSeq
-									}
-								}));
-							} else {
-								log?.info(`[qqbot:${account.accountId}] Sending identify with intents: ${FULL_INTENTS} (${FULL_INTENTS_DESC})`);
-								ws.send(JSON.stringify({
-									op: 2,
-									d: {
-										token: `QQBot ${accessToken}`,
-										intents: FULL_INTENTS,
-										shard: [0, 1]
-									}
-								}));
-							}
-							const interval = d.heartbeat_interval;
-							if (heartbeatInterval) clearInterval(heartbeatInterval);
-							heartbeatInterval = setInterval(() => {
-								if (ws.readyState === WebSocket$1.OPEN) {
-									ws.send(JSON.stringify({
-										op: 1,
-										d: lastSeq
-									}));
-									log?.debug?.(`[qqbot:${account.accountId}] Heartbeat sent`);
-								}
-							}, interval);
-							break;
-						case 0:
-							log?.info(`[qqbot:${account.accountId}] 📩 Dispatch event: t=${t}, d=${JSON.stringify(d)}`);
-							if (t === "READY") {
-								sessionId = d.session_id;
-								log?.info(`[qqbot:${account.accountId}] Ready with ${FULL_INTENTS_DESC}, session: ${sessionId}`);
-								saveSession({
-									sessionId,
-									lastSeq,
-									lastConnectedAt: Date.now(),
-									intentLevelIndex: 0,
-									accountId: account.accountId,
-									savedAt: Date.now(),
-									appId: account.appId
-								});
-								onReady?.(d);
-							} else if (t === "RESUMED") {
-								log?.info(`[qqbot:${account.accountId}] Session resumed`);
-								onReady?.(d);
-								if (sessionId) saveSession({
-									sessionId,
-									lastSeq,
-									lastConnectedAt: Date.now(),
-									intentLevelIndex: 0,
-									accountId: account.accountId,
-									savedAt: Date.now(),
-									appId: account.appId
-								});
-							} else if (t === "C2C_MESSAGE_CREATE") {
-								const event = d;
-								recordKnownUser({
-									openid: event.author.user_openid,
-									type: "c2c",
-									accountId: account.accountId
-								});
-								const c2cRefs = parseRefIndices(event.message_scene?.ext);
-								trySlashCommandOrEnqueue({
-									type: "c2c",
-									senderId: event.author.user_openid,
-									content: event.content,
-									messageId: event.id,
-									timestamp: event.timestamp,
-									attachments: event.attachments,
-									refMsgIdx: c2cRefs.refMsgIdx,
-									msgIdx: c2cRefs.msgIdx
-								});
-							} else if (t === "AT_MESSAGE_CREATE") {
-								const event = d;
-								const guildRefs = parseRefIndices(event.message_scene?.ext);
-								trySlashCommandOrEnqueue({
-									type: "guild",
-									senderId: event.author.id,
-									senderName: event.author.username,
-									content: event.content,
-									messageId: event.id,
-									timestamp: event.timestamp,
-									channelId: event.channel_id,
-									guildId: event.guild_id,
-									attachments: event.attachments,
-									refMsgIdx: guildRefs.refMsgIdx,
-									msgIdx: guildRefs.msgIdx
-								});
-							} else if (t === "DIRECT_MESSAGE_CREATE") {
-								const event = d;
-								const dmRefs = parseRefIndices(event.message_scene?.ext);
-								trySlashCommandOrEnqueue({
-									type: "dm",
-									senderId: event.author.id,
-									senderName: event.author.username,
-									content: event.content,
-									messageId: event.id,
-									timestamp: event.timestamp,
-									guildId: event.guild_id,
-									attachments: event.attachments,
-									refMsgIdx: dmRefs.refMsgIdx,
-									msgIdx: dmRefs.msgIdx
-								});
-							} else if (t === "GROUP_AT_MESSAGE_CREATE") {
-								const event = d;
-								recordKnownUser({
-									openid: event.author.member_openid,
-									type: "group",
-									groupOpenid: event.group_openid,
-									accountId: account.accountId
-								});
-								const groupRefs = parseRefIndices(event.message_scene?.ext);
-								trySlashCommandOrEnqueue({
-									type: "group",
-									senderId: event.author.member_openid,
-									content: event.content,
-									messageId: event.id,
-									timestamp: event.timestamp,
-									groupOpenid: event.group_openid,
-									attachments: event.attachments,
-									refMsgIdx: groupRefs.refMsgIdx,
-									msgIdx: groupRefs.msgIdx
-								});
-							}
-							break;
-						case 11:
-							log?.debug?.(`[qqbot:${account.accountId}] Heartbeat ACK`);
-							break;
-						case 7:
-							log?.info(`[qqbot:${account.accountId}] Server requested reconnect`);
-							cleanup();
-							scheduleReconnect();
-							break;
-						case 9:
-							const canResume = d;
-							log?.error(`[qqbot:${account.accountId}] Invalid session (${FULL_INTENTS_DESC}), can resume: ${canResume}, raw: ${rawData}`);
-							if (!canResume) {
-								sessionId = null;
-								lastSeq = null;
-								clearSession(account.accountId);
-								shouldRefreshToken = true;
-								log?.info(`[qqbot:${account.accountId}] Will refresh token and retry with full intents (${FULL_INTENTS_DESC})`);
-							}
-							cleanup();
-							scheduleReconnect(3e3);
-							break;
-					}
-				} catch (err) {
-					log?.error(`[qqbot:${account.accountId}] Message parse error: ${err}`);
-				}
-			});
-			ws.on("close", (code, reason) => {
-				log?.info(`[qqbot:${account.accountId}] WebSocket closed: ${code} ${reason.toString()}`);
-				isConnecting = false;
-				if (code === 4914 || code === 4915) {
-					log?.error(`[qqbot:${account.accountId}] Bot is ${code === 4914 ? "offline/sandbox-only" : "banned"}. Please contact QQ platform.`);
-					cleanup();
-					return;
-				}
-				if (code === 4004) {
-					log?.info(`[qqbot:${account.accountId}] Invalid token (4004), will refresh token and reconnect`);
-					shouldRefreshToken = true;
-					cleanup();
-					if (!isAborted) scheduleReconnect();
-					return;
-				}
-				if (code === 4008) {
-					log?.info(`[qqbot:${account.accountId}] Rate limited (4008), waiting ${RATE_LIMIT_DELAY}ms before reconnect`);
-					cleanup();
-					if (!isAborted) scheduleReconnect(RATE_LIMIT_DELAY);
-					return;
-				}
-				if (code === 4006 || code === 4007 || code === 4009) {
-					log?.info(`[qqbot:${account.accountId}] Error ${code} (${{
-						4006: "session no longer valid",
-						4007: "invalid seq on resume",
-						4009: "session timed out"
-					}[code]}), will re-identify`);
-					sessionId = null;
-					lastSeq = null;
-					clearSession(account.accountId);
-					shouldRefreshToken = true;
-				} else if (code >= 4900 && code <= 4913) {
-					log?.info(`[qqbot:${account.accountId}] Internal error (${code}), will re-identify`);
-					sessionId = null;
-					lastSeq = null;
-					clearSession(account.accountId);
-					shouldRefreshToken = true;
-				}
-				const connectionDuration = Date.now() - lastConnectTime;
-				if (connectionDuration < QUICK_DISCONNECT_THRESHOLD && lastConnectTime > 0) {
-					quickDisconnectCount++;
-					log?.info(`[qqbot:${account.accountId}] Quick disconnect detected (${connectionDuration}ms), count: ${quickDisconnectCount}`);
-					if (quickDisconnectCount >= MAX_QUICK_DISCONNECT_COUNT) {
-						log?.error(`[qqbot:${account.accountId}] Too many quick disconnects. This may indicate a permission issue.`);
-						log?.error(`[qqbot:${account.accountId}] Please check: 1) AppID/Secret correct 2) Bot permissions on QQ Open Platform`);
-						quickDisconnectCount = 0;
-						cleanup();
-						if (!isAborted && code !== 1e3) scheduleReconnect(RATE_LIMIT_DELAY);
-						return;
-					}
-				} else quickDisconnectCount = 0;
-				cleanup();
-				if (!isAborted && code !== 1e3) scheduleReconnect();
-			});
-			ws.on("error", (err) => {
-				log?.error(`[qqbot:${account.accountId}] WebSocket error: ${err.message}`);
-				onError?.(err);
-			});
-		} catch (err) {
-			isConnecting = false;
-			const errMsg = String(err);
-			log?.error(`[qqbot:${account.accountId}] Connection failed: ${err}`);
-			if (errMsg.includes("Too many requests") || errMsg.includes("100001")) {
-				log?.info(`[qqbot:${account.accountId}] Rate limited, waiting ${RATE_LIMIT_DELAY}ms before retry`);
-				scheduleReconnect(RATE_LIMIT_DELAY);
-			} else scheduleReconnect();
-		}
-	};
-	await connect();
-	return new Promise((resolve) => {
-		abortSignal.addEventListener("abort", () => resolve());
-	});
-}
-//#endregion
-export { startGateway };