@openclaw/qqbot 2026.7.1 → 2026.7.2-beta.2

package/dist/{sender-CjDuU-uz.js → sender-BAUHZqDW.js}

@@ -1,5 +1,5 @@
 import { c as getPlatformAdapter, i as normalizeOptionalString, s as sanitizeFileName } from "./string-normalize-R_0cKO7Q.js";
-import { a as formatErrorMessage, n as debugLog, r as debugWarn, t as debugError } from "./log-DEtcoDWe.js";
+import { a as formatErrorMessage, n as debugLog, r as debugWarn, t as debugError } from "./log-Da4jz75I.js";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import * as fs$1 from "node:fs";
 import os from "node:os";
@@ -7,11 +7,13 @@ import { readProviderTextResponse, readResponseTextLimited } from "openclaw/plug
 import { fetchWithSsrFGuard, isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
 import * as crypto$1 from "node:crypto";
 import crypto from "node:crypto";
-import { sleep } from "openclaw/plugin-sdk/runtime-env";
+import { sleep, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import pMap from "p-map";
 import { FsSafeError, openLocalFileSafely, readRegularFile, statRegularFileSync } from "openclaw/plugin-sdk/security-runtime";
 import * as path$1 from "node:path";
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 import { asDateTimestampMs, formatByteSize, isFutureDateTimestampMs, parseStrictPositiveInteger, resolveExpiresAtMsFromDurationSeconds, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { createChannelApiRetryRunner, resolveRetryConfig } from "openclaw/plugin-sdk/retry-runtime";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -244,6 +246,7 @@ const QQBOT_MEDIA_SSRF_POLICY = {
 	],
 	allowRfc2544BenchmarkRange: true
 };
+const QQBOT_REMOTE_MEDIA_RESPONSE_HEADER_TIMEOUT_MS = 12e4;
 /** Validate that a file is within the allowed upload size. */
 function checkFileSize(filePath, maxSize = MAX_UPLOAD_SIZE) {
 	try {
@@ -336,7 +339,8 @@ async function downloadFile(url, destDir, originalFilename) {
 		const fetched = await getPlatformAdapter().fetchMedia({
 			url: parsedUrl.toString(),
 			filePathHint: originalFilename,
-			ssrfPolicy: QQBOT_MEDIA_SSRF_POLICY
+			ssrfPolicy: QQBOT_MEDIA_SSRF_POLICY,
+			responseHeaderTimeoutMs: QQBOT_REMOTE_MEDIA_RESPONSE_HEADER_TIMEOUT_MS
 		});
 		let filename = normalizeOptionalString(originalFilename) ?? "";
 		if (!filename) filename = (normalizeOptionalString(fetched.fileName) ?? path$1.basename(parsedUrl.pathname)) || "download";
@@ -367,9 +371,11 @@ function tryParseDataUrl(value) {
 	if (!value.startsWith("data:")) return null;
 	const m = value.match(DATA_URL_RE);
 	if (!m) return null;
-	return {
-		mime: m[1],
-		data: m[2]
+	const mime = m[1];
+	const data = m[2];
+	return mime === void 0 || data === void 0 ? null : {
+		mime,
+		data
 	};
 }
 /**
@@ -487,23 +493,42 @@ async function normalizeSource(raw, opts = {}) {
 * @returns The result of the first successful invocation.
 */
 async function withRetry(fn, policy, persistentPolicy, logger) {
-	let lastError = null;
-	for (let attempt = 0; attempt <= policy.maxRetries; attempt++) try {
-		return await fn();
-	} catch (err) {
-		lastError = err instanceof Error ? err : new Error(formatErrorMessage(err));
-		if (persistentPolicy?.shouldPersistRetry(lastError)) {
-			(logger?.warn ?? logger?.error)?.(`[qqbot:retry] Hit persistent-retry trigger, entering persistent loop (timeout=${persistentPolicy.timeoutMs / 1e3}s)`);
-			return await persistentRetryLoop(fn, persistentPolicy, logger);
+	const persistentFailures = /* @__PURE__ */ new WeakSet();
+	const retryConfig = resolveRetryConfig(void 0, {
+		attempts: policy.maxRetries + 1,
+		minDelayMs: policy.baseDelayMs,
+		maxDelayMs: policy.backoff === "fixed" ? policy.baseDelayMs : 2147e6,
+		jitter: 0
+	});
+	return await createChannelApiRetryRunner({
+		retry: retryConfig,
+		strictShouldRetry: true,
+		retryAfterMs: () => void 0,
+		shouldRetry: (err, attempt) => {
+			const error = err instanceof Error ? err : new Error(formatErrorMessage(err));
+			const shouldRetry = !persistentFailures.has(error) && policy.shouldRetry?.(error, attempt - 1) !== false;
+			if (shouldRetry) {
+				const delayMs = policy.backoff === "fixed" ? retryConfig.minDelayMs : Math.min(retryConfig.minDelayMs * 2 ** (attempt - 1), retryConfig.maxDelayMs);
+				logger?.debug?.(`[qqbot:retry] Attempt ${attempt} failed, retrying in ${delayMs}ms: ${truncateUtf16Safe(error.message, 100)}`);
+			}
+			return shouldRetry;
 		}
-		if (policy.shouldRetry?.(lastError, attempt) === false) throw lastError;
-		if (attempt < policy.maxRetries) {
-			const delay = policy.backoff === "exponential" ? policy.baseDelayMs * 2 ** attempt : policy.baseDelayMs;
-			logger?.debug?.(`[qqbot:retry] Attempt ${attempt + 1} failed, retrying in ${delay}ms: ${truncateUtf16Safe(lastError.message, 100)}`);
-			await sleep(delay);
+	})(async () => {
+		try {
+			return await fn();
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(formatErrorMessage(err));
+			if (!persistentPolicy?.shouldPersistRetry(error)) throw error;
+			(logger?.warn ?? logger?.error)?.(`[qqbot:retry] Hit persistent-retry trigger, entering persistent loop (timeout=${persistentPolicy.timeoutMs / 1e3}s)`);
+			try {
+				return await persistentRetryLoop(fn, persistentPolicy, logger);
+			} catch (persistentError) {
+				const terminal = persistentError instanceof Error ? persistentError : new Error(formatErrorMessage(persistentError));
+				persistentFailures.add(terminal);
+				throw terminal;
+			}
 		}
-	}
-	throw lastError;
+	});
 }
 /**
 * Persistent retry loop: fixed-interval retries bounded by a total timeout.
@@ -791,7 +816,10 @@ var ChunkedMediaApi = class {
 					totalBytes: fileSize
 				});
 			};
-			await runWithConcurrency(parts.map((part) => () => uploadPart(part)), maxConcurrent);
+			await pMap(parts, uploadPart, {
+				concurrency: maxConcurrent,
+				stopOnError: true
+			});
 			this.logger?.info?.(`${prefix} all parts uploaded, completing...`);
 			const result = await this.callCompleteUpload(opts, upload_id);
 			this.logger?.info?.(`${prefix} completed: file_uuid=${result.file_uuid} ttl=${result.ttl}s`);
@@ -964,20 +992,6 @@ async function putToPresignedUrl(presignedUrl, data, partIndex, totalParts, logg
 	}
 	throw lastError ?? /* @__PURE__ */ new Error(`Part ${partIndex}/${totalParts} upload failed`);
 }
-/**
-* Batch-mode concurrency limiter. Deliberately simple: dispatch N tasks at
-* a time and wait for the whole batch to settle before the next batch.
-*
-* A pool / queue implementation would recover some throughput when tasks
-* have heavy variance, but part uploads are size-uniform (last part can be
-* short) so the extra complexity is not worth it.
-*/
-async function runWithConcurrency(tasks, maxConcurrent) {
-	for (let i = 0; i < tasks.length; i += maxConcurrent) {
-		const batch = tasks.slice(i, i + maxConcurrent);
-		await Promise.all(batch.map((task) => task()));
-	}
-}
 //#endregion
 //#region extensions/qqbot/src/engine/api/token.ts
 /**
@@ -990,6 +1004,7 @@ async function runWithConcurrency(tasks, maxConcurrent) {
 const TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
 const DEFAULT_TOKEN_EXPIRES_IN_SECONDS = 7200;
 const QQBOT_TOKEN_RESPONSE_LIMIT_BYTES = 8 * 1024;
+const QQBOT_TOKEN_REQUEST_TIMEOUT_MS = 3e4;
 /**
 * Host-scoped SSRF policy for the QQ Bot token endpoint.
 *
@@ -1094,6 +1109,7 @@ var TokenManager = class {
 		const controller = new AbortController();
 		this.refreshControllers.set(appId, controller);
 		const { signal } = controller;
+		const sleepAndYield = (ms) => sleepWithAbort(Number.isFinite(ms) ? Math.max(ms, 1) : 1, signal);
 		const loop = async () => {
 			this.logger?.info?.(`[qqbot:token:${appId}] Background refresh started`);
 			while (!signal.aborted) try {
@@ -1104,12 +1120,12 @@ var TokenManager = class {
 					const randomOffset = Math.random() * randomOffsetMs;
 					const refreshIn = Math.max(expiresIn - refreshAheadMs - randomOffset, minRefreshIntervalMs);
 					this.logger?.debug?.(`[qqbot:token:${appId}] Next refresh in ${Math.round(refreshIn / 1e3)}s`);
-					await this.abortableSleep(refreshIn, signal);
-				} else await this.abortableSleep(minRefreshIntervalMs, signal);
+					await sleepAndYield(refreshIn);
+				} else await sleepAndYield(minRefreshIntervalMs);
 			} catch (err) {
 				if (signal.aborted) break;
 				this.logger?.error?.(`[qqbot:token:${appId}] Background refresh failed: ${formatErrorMessage(err)}`);
-				await this.abortableSleep(retryDelayMs, signal);
+				await sleepAndYield(retryDelayMs);
 			}
 			this.refreshControllers.delete(appId);
 			this.logger?.info?.(`[qqbot:token:${appId}] Background refresh stopped`);
@@ -1142,6 +1158,7 @@ var TokenManager = class {
 				auditContext: "qqbot-token",
 				capture: false,
 				policy: QQBOT_TOKEN_SSRF_POLICY,
+				timeoutMs: QQBOT_TOKEN_REQUEST_TIMEOUT_MS,
 				init: {
 					method: "POST",
 					headers: {
@@ -1195,21 +1212,6 @@ var TokenManager = class {
 			await release?.();
 		}
 	}
-	abortableSleep(ms, signal) {
-		return new Promise((resolve, reject) => {
-			const timer = setTimeout(resolve, ms);
-			if (signal.aborted) {
-				clearTimeout(timer);
-				reject(/* @__PURE__ */ new Error("Aborted"));
-				return;
-			}
-			const onAbort = () => {
-				clearTimeout(timer);
-				reject(/* @__PURE__ */ new Error("Aborted"));
-			};
-			signal.addEventListener("abort", onAbort, { once: true });
-		});
-	}
 };
 //#endregion
 //#region extensions/qqbot/src/engine/api/media.ts
@@ -1570,7 +1572,7 @@ function getCachedFileInfo(contentHash, scope, targetId, fileType) {
 		cache.delete(key);
 		return null;
 	}
-	debugLog(`[upload-cache] Cache HIT: key=${key.slice(0, 40)}..., fileUuid=${entry.fileUuid}`);
+	debugLog(`[upload-cache] Cache HIT: key=${truncateUtf16Safe(key, 40)}..., fileUuid=${entry.fileUuid}`);
 	return entry.fileInfo;
 }
 /** Store an upload result in the cache. */
@@ -1580,7 +1582,7 @@ function setCachedFileInfo(contentHash, scope, targetId, fileType, fileInfo, fil
 		for (const [k, v] of cache) if (!isFutureDateTimestampMs(v.expiresAt, { nowMs: now })) cache.delete(k);
 		if (cache.size >= MAX_CACHE_SIZE) {
 			const keys = Array.from(cache.keys());
-			for (let i = 0; i < keys.length / 2; i++) cache.delete(keys[i]);
+			for (const key of keys.slice(0, Math.ceil(keys.length / 2))) cache.delete(key);
 		}
 	}
 	const key = buildCacheKey(contentHash, scope, targetId, fileType);
@@ -1595,7 +1597,147 @@ function setCachedFileInfo(contentHash, scope, targetId, fileType, fileInfo, fil
 		fileUuid,
 		expiresAt
 	});
-	debugLog(`[upload-cache] Cache SET: key=${key.slice(0, 40)}..., ttl=${effectiveTtl}s, uuid=${fileUuid}`);
+	debugLog(`[upload-cache] Cache SET: key=${truncateUtf16Safe(key, 40)}..., ttl=${effectiveTtl}s, uuid=${fileUuid}`);
+}
+//#endregion
+//#region extensions/qqbot/src/engine/messaging/reply-limiter.ts
+const DEFAULT_LIMIT = 5;
+const DEFAULT_TTL_MS = 3600 * 1e3;
+const DEFAULT_MAX_TRACKED = 1e4;
+/**
+* Per-account reply limiter with automatic eviction.
+*
+* Usage:
+* ```ts
+* const limiter = new ReplyLimiter({ limit: 5, ttlMs: 3600000 });
+* const claim = limiter.claim(messageId);
+* if (claim.allowed) {
+*   await sendPassiveReply(...);
+* } else if (claim.shouldFallbackToProactive) {
+*   await sendProactiveMessage(...);
+* }
+* ```
+*/
+var ReplyLimiter = class {
+	constructor(config) {
+		this.tracker = /* @__PURE__ */ new Map();
+		this.limit = config?.limit ?? DEFAULT_LIMIT;
+		this.ttlMs = config?.ttlMs ?? DEFAULT_TTL_MS;
+		this.maxTracked = config?.maxTrackedMessages ?? DEFAULT_MAX_TRACKED;
+	}
+	/** Check whether a passive reply is allowed while leaving `reserve` slots unused. */
+	checkLimit(messageId, reserve = 0) {
+		const now = Date.now();
+		this.evictIfNeeded(now);
+		const record = this.tracker.get(messageId);
+		if (!record) {
+			if (this.limit > reserve) return {
+				allowed: true,
+				remaining: this.limit,
+				shouldFallbackToProactive: false
+			};
+			return {
+				allowed: false,
+				remaining: this.limit,
+				shouldFallbackToProactive: true,
+				fallbackReason: "limit_exceeded",
+				message: `Passive reply budget reserved (${reserve} of ${this.limit} remaining); sending proactively instead`
+			};
+		}
+		if (now - record.firstReplyAt > this.ttlMs) return {
+			allowed: false,
+			remaining: 0,
+			shouldFallbackToProactive: true,
+			fallbackReason: "expired",
+			message: `Message is older than ${this.ttlMs / (3600 * 1e3)}h; sending as a proactive message instead`
+		};
+		const remaining = this.limit - (record?.count ?? 0);
+		if (remaining <= reserve) return {
+			allowed: false,
+			remaining,
+			shouldFallbackToProactive: true,
+			fallbackReason: "limit_exceeded",
+			message: reserve > 0 ? `Passive reply budget reserved (${reserve} of ${this.limit} remaining); sending proactively instead` : `Passive reply limit reached (${this.limit} per hour); sending proactively instead`
+		};
+		return {
+			allowed: true,
+			remaining,
+			shouldFallbackToProactive: false
+		};
+	}
+	/** Atomically reserve one passive-reply slot before starting the request. */
+	claim(messageId, reserve = 0) {
+		const check = this.checkLimit(messageId, reserve);
+		if (!check.allowed) return check;
+		this.record(messageId);
+		return {
+			...check,
+			remaining: check.remaining - 1
+		};
+	}
+	/** Record one passive reply against a message. */
+	record(messageId) {
+		const now = Date.now();
+		const existing = this.tracker.get(messageId);
+		if (!existing) this.tracker.set(messageId, {
+			count: 1,
+			firstReplyAt: now
+		});
+		else if (now - existing.firstReplyAt > this.ttlMs) this.tracker.set(messageId, {
+			count: 1,
+			firstReplyAt: now
+		});
+		else existing.count++;
+	}
+	/** Return diagnostic stats. */
+	getStats() {
+		let totalReplies = 0;
+		for (const record of this.tracker.values()) totalReplies += record.count;
+		return {
+			trackedMessages: this.tracker.size,
+			totalReplies
+		};
+	}
+	/** Return limiter configuration. */
+	getConfig() {
+		return {
+			limit: this.limit,
+			ttlMs: this.ttlMs,
+			ttlHours: this.ttlMs / (3600 * 1e3)
+		};
+	}
+	/** Clear all tracked records. */
+	clear() {
+		this.tracker.clear();
+	}
+	/** Opportunistically evict expired records to keep the tracker bounded. */
+	evictIfNeeded(now) {
+		if (this.tracker.size <= this.maxTracked) return;
+		for (const [id, rec] of this.tracker) if (now - rec.firstReplyAt > this.ttlMs) this.tracker.delete(id);
+	}
+};
+//#endregion
+//#region extensions/qqbot/src/engine/messaging/outbound-reply.ts
+const replyLimiter = new ReplyLimiter();
+const MESSAGE_REPLY_LIMIT = 5;
+function checkMessageReplyLimit(messageId) {
+	return replyLimiter.checkLimit(messageId);
+}
+function recordMessageReply(messageId) {
+	replyLimiter.record(messageId);
+	debugLog(`[qqbot] recordMessageReply: ${messageId}, count=${replyLimiter.getStats().totalReplies}`);
+}
+/** Reserve one slot before a passive request so concurrent sends share one budget. */
+function claimMessageReply(messageId, reserve = 0) {
+	const result = replyLimiter.claim(messageId, reserve);
+	if (result.allowed) debugLog(`[qqbot] claimMessageReply: ${messageId}, remaining=${result.remaining}/5`);
+	return result;
+}
+function getMessageReplyStats() {
+	return replyLimiter.getStats();
+}
+function getMessageReplyConfig() {
+	return replyLimiter.getConfig();
 }
 //#endregion
 //#region extensions/qqbot/src/engine/messaging/sender.ts
@@ -1837,17 +1979,26 @@ function notifyMediaHook(appId, result, meta) {
 * Handles passive (with msgId) and proactive (without msgId) modes.
 */
 async function sendText(target, content, creds, opts) {
-	const api = resolveAccount(creds.appId).messageApi;
+	const ctx = resolveAccount(creds.appId);
+	const api = ctx.messageApi;
 	const c = {
 		appId: creds.appId,
 		clientSecret: creds.clientSecret
 	};
+	let msgId = opts?.msgId;
+	if (msgId) {
+		const passive = claimMessageReply(msgId);
+		if (!passive.allowed) {
+			ctx.logger.warn?.(`Passive reply unavailable for ${target.type}; falling back to a send without msg_id: ${passive.message}`);
+			msgId = void 0;
+		}
+	}
 	if (target.type === "c2c" || target.type === "group") {
 		const scope = target.type;
-		if (opts?.msgId) return api.sendMessage(scope, target.id, content, c, {
-			msgId: opts.msgId,
-			messageReference: opts.messageReference,
-			forcePlainText: opts.forcePlainText
+		if (msgId) return api.sendMessage(scope, target.id, content, c, {
+			msgId,
+			messageReference: opts?.messageReference,
+			forcePlainText: opts?.forcePlainText
 		});
 		return api.sendProactiveMessage(scope, target.id, content, c, { forcePlainText: opts?.forcePlainText });
 	}
@@ -1855,13 +2006,13 @@ async function sendText(target, content, creds, opts) {
 		guildId: target.id,
 		content,
 		creds: c,
-		msgId: opts?.msgId
+		msgId
 	});
 	return api.sendChannelMessage({
 		channelId: target.id,
 		content,
 		creds: c,
-		msgId: opts?.msgId
+		msgId
 	});
 }
 /**
@@ -1969,8 +2120,16 @@ async function sendMediaInternal(ctx, opts) {
 	try {
 		const uploadResult = await dispatchUpload(ctx, scope, opts.target.id, KIND_TO_FILE_TYPE[opts.kind], source, c, opts.fileName);
 		const msgContent = opts.kind === "image" || opts.kind === "video" ? opts.content : void 0;
+		let msgId = opts.msgId;
+		if (msgId) {
+			const passive = claimMessageReply(msgId);
+			if (!passive.allowed) {
+				ctx.logger.warn?.(`Passive media reply unavailable for ${scope}; falling back to proactive send: ${passive.message}`);
+				msgId = void 0;
+			}
+		}
 		const result = await ctx.mediaApi.sendMediaMessage(scope, opts.target.id, uploadResult.file_info, c, {
-			msgId: opts.msgId,
+			msgId,
 			content: msgContent
 		});
 		notifyMediaHook(opts.creds.appId, result, buildOutboundMeta(opts, source));
@@ -2082,4 +2241,4 @@ function supportsRichMedia(targetType) {
 	return targetType === "c2c" || targetType === "group";
 }
 //#endregion
-export { getFileTypeName as A, getNextMsgSeq as C, downloadFile as D, checkFileSize as E, StreamInputMode as F, StreamInputState as I, __exportAll as L, getMaxUploadSize as M, readFileAsync as N, fileExistsAsync as O, StreamContentType as P, UploadDailyLimitExceededError as S, openLocalFile as T, sender_exports as _, createRawInputNotifyFn as a, stopBackgroundTokenRefresh as b, getMessageApi as c, initSender as d, onMessageSent as f, sendText as g, sendMedia as h, clearTokenCache as i, getImageMimeType as j, formatFileSize as k, getPluginUserAgent as l, sendInputNotify as m, acknowledgeInteraction as n, getAccessToken as o, registerAccount as p, buildDeliveryTarget as r, getGatewayUrl as s, accountToCreds as t, initApiConfig as u, setOpenClawVersion as v, UPLOAD_PREPARE_FALLBACK_CODE as w, withTokenRetry as x, startBackgroundTokenRefresh as y };
+export { UPLOAD_PREPARE_FALLBACK_CODE as A, StreamContentType as B, checkMessageReplyLimit as C, recordMessageReply as D, getMessageReplyStats as E, formatFileSize as F, StreamInputState as H, getFileTypeName as I, getImageMimeType as L, checkFileSize as M, downloadFile as N, UploadDailyLimitExceededError as O, fileExistsAsync as P, getMaxUploadSize as R, MESSAGE_REPLY_LIMIT as S, getMessageReplyConfig as T, __exportAll as U, StreamInputMode as V, sender_exports as _, createRawInputNotifyFn as a, stopBackgroundTokenRefresh as b, getMessageApi as c, initSender as d, onMessageSent as f, sendText as g, sendMedia as h, clearTokenCache as i, openLocalFile as j, getNextMsgSeq as k, getPluginUserAgent as l, sendInputNotify as m, acknowledgeInteraction as n, getAccessToken as o, registerAccount as p, buildDeliveryTarget as r, getGatewayUrl as s, accountToCreds as t, initApiConfig as u, setOpenClawVersion as v, claimMessageReply as w, withTokenRetry as x, startBackgroundTokenRefresh as y, readFileAsync as z };

package/dist/setup-plugin-api.js

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

package/dist/state-keys-jLJ2SmJA.js

@@ -0,0 +1,225 @@
+import crypto from "node:crypto";
+import { asObjectRecord } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/qqbot/src/doctor-contract.ts
+const RESTRICTED_GROUP_TOOLS = { deny: [
+	"exec",
+	"read",
+	"write"
+] };
+function hasLegacyStreamingValue(value) {
+	const entry = asObjectRecord(value);
+	if (!entry) return false;
+	return typeof entry.streaming === "boolean" || asObjectRecord(entry.streaming)?.c2cStreamApi !== void 0;
+}
+function hasLegacyAccountStreamingValues(value) {
+	const accounts = asObjectRecord(value);
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => hasLegacyStreamingValue(account));
+}
+function migrateStreamingValue(params) {
+	const streaming = params.entry.streaming;
+	const path = `${params.pathPrefix}.streaming`;
+	if (typeof streaming === "boolean") {
+		const next = streaming ? {
+			mode: "partial",
+			nativeTransport: true
+		} : { mode: "off" };
+		params.changes.push(`Moved ${path} (boolean) → ${path}.mode (${next.mode}).`);
+		if (streaming) params.changes.push(`Moved ${path} (boolean) → ${path}.nativeTransport.`);
+		return {
+			entry: {
+				...params.entry,
+				streaming: next
+			},
+			changed: true
+		};
+	}
+	const streamingRecord = asObjectRecord(streaming);
+	if (!streamingRecord || streamingRecord.c2cStreamApi === void 0) return {
+		entry: params.entry,
+		changed: false
+	};
+	const { c2cStreamApi, ...rest } = streamingRecord;
+	const next = { ...rest };
+	if (next.nativeTransport === void 0) {
+		next.nativeTransport = c2cStreamApi;
+		params.changes.push(`Moved ${path}.c2cStreamApi → ${path}.nativeTransport.`);
+	} else params.changes.push(`Removed ${path}.c2cStreamApi (${path}.nativeTransport already set).`);
+	return {
+		entry: {
+			...params.entry,
+			streaming: next
+		},
+		changed: true
+	};
+}
+function hasLegacyGroupToolPolicy(value) {
+	const groups = asObjectRecord(value);
+	if (!groups) return false;
+	return Object.values(groups).some((group) => asObjectRecord(group)?.toolPolicy !== void 0);
+}
+function hasLegacyAccountGroupToolPolicy(value) {
+	const accounts = asObjectRecord(value);
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => hasLegacyGroupToolPolicy(asObjectRecord(account)?.groups));
+}
+function migrateToolPolicy(value) {
+	if (value === "none") return { deny: ["*"] };
+	if (value === "full") return { allow: [] };
+	if (value === "restricted") return { ...RESTRICTED_GROUP_TOOLS };
+}
+function describeToolPolicy(value) {
+	return typeof value === "string" ? value : String(value);
+}
+function migrateGroups(params) {
+	let changed = false;
+	const nextGroups = { ...params.groups };
+	for (const [groupId, rawGroup] of Object.entries(params.groups)) {
+		const group = asObjectRecord(rawGroup);
+		if (!group || group.toolPolicy === void 0) continue;
+		const { toolPolicy, ...rest } = group;
+		const nextGroup = { ...rest };
+		const policy = migrateToolPolicy(toolPolicy);
+		const path = `${params.pathPrefix}.${groupId}`;
+		if (nextGroup.tools !== void 0) params.changes.push(`Removed ${path}.toolPolicy (${path}.tools already exists).`);
+		else if (policy) {
+			nextGroup.tools = policy;
+			params.changes.push(`Moved ${path}.toolPolicy=${describeToolPolicy(toolPolicy)} to ${path}.tools.`);
+		} else params.changes.push(`Removed unsupported ${path}.toolPolicy=${describeToolPolicy(toolPolicy)}.`);
+		nextGroups[groupId] = nextGroup;
+		changed = true;
+	}
+	return {
+		groups: nextGroups,
+		changed
+	};
+}
+const legacyConfigRules = [
+	{
+		path: ["channels", "qqbot"],
+		message: "channels.qqbot.streaming (boolean) and channels.qqbot.streaming.c2cStreamApi are legacy; use channels.qqbot.streaming.{mode,nativeTransport}. Run \"openclaw doctor --fix\".",
+		match: hasLegacyStreamingValue
+	},
+	{
+		path: [
+			"channels",
+			"qqbot",
+			"accounts"
+		],
+		message: "channels.qqbot.accounts.<id>.streaming (boolean) and streaming.c2cStreamApi are legacy; use channels.qqbot.accounts.<id>.streaming.{mode,nativeTransport}. Run \"openclaw doctor --fix\".",
+		match: hasLegacyAccountStreamingValues
+	},
+	{
+		path: [
+			"channels",
+			"qqbot",
+			"groups"
+		],
+		message: "channels.qqbot.groups.<id>.toolPolicy is legacy and was ignored by QQBot group tool enforcement; use channels.qqbot.groups.<id>.tools instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyGroupToolPolicy
+	},
+	{
+		path: [
+			"channels",
+			"qqbot",
+			"accounts"
+		],
+		message: "channels.qqbot.accounts.<id>.groups.<groupId>.toolPolicy is legacy and was ignored by QQBot group tool enforcement; use channels.qqbot.accounts.<id>.groups.<groupId>.tools instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyAccountGroupToolPolicy
+	}
+];
+function normalizeCompatibilityConfig({ cfg }) {
+	const rawEntry = asObjectRecord(cfg.channels?.qqbot);
+	if (!rawEntry) return {
+		config: cfg,
+		changes: []
+	};
+	const changes = [];
+	let updated = rawEntry;
+	let changed = false;
+	const rootStreaming = migrateStreamingValue({
+		entry: updated,
+		pathPrefix: "channels.qqbot",
+		changes
+	});
+	updated = rootStreaming.entry;
+	changed = changed || rootStreaming.changed;
+	const groups = asObjectRecord(updated.groups);
+	if (groups) {
+		const migrated = migrateGroups({
+			groups,
+			pathPrefix: "channels.qqbot.groups",
+			changes
+		});
+		if (migrated.changed) {
+			updated = {
+				...updated,
+				groups: migrated.groups
+			};
+			changed = true;
+		}
+	}
+	const accounts = asObjectRecord(updated.accounts);
+	if (accounts) {
+		let accountsChanged = false;
+		const nextAccounts = { ...accounts };
+		for (const [accountId, rawAccount] of Object.entries(accounts)) {
+			const account = asObjectRecord(rawAccount);
+			if (!account) continue;
+			const accountStreaming = migrateStreamingValue({
+				entry: account,
+				pathPrefix: `channels.qqbot.accounts.${accountId}`,
+				changes
+			});
+			let nextAccount = accountStreaming.entry;
+			let accountChanged = accountStreaming.changed;
+			const accountGroups = asObjectRecord(nextAccount.groups);
+			if (accountGroups) {
+				const migrated = migrateGroups({
+					groups: accountGroups,
+					pathPrefix: `channels.qqbot.accounts.${accountId}.groups`,
+					changes
+				});
+				if (migrated.changed) {
+					nextAccount = {
+						...nextAccount,
+						groups: migrated.groups
+					};
+					accountChanged = true;
+				}
+			}
+			if (accountChanged) {
+				nextAccounts[accountId] = nextAccount;
+				accountsChanged = true;
+			}
+		}
+		if (accountsChanged) {
+			updated = {
+				...updated,
+				accounts: nextAccounts
+			};
+			changed = true;
+		}
+	}
+	if (!changed) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config: {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				qqbot: updated
+			}
+		},
+		changes
+	};
+}
+//#endregion
+//#region extensions/qqbot/src/engine/utils/state-keys.ts
+function buildQQBotStateKey(...parts) {
+	return crypto.createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+}
+//#endregion
+export { legacyConfigRules as n, normalizeCompatibilityConfig as r, buildQQBotStateKey as t };