@openclaw/qqbot 2026.6.8 → 2026.6.9-beta.1

package/dist/api.js

@@ -1,8 +1,8 @@
-import { t as qqbotPlugin } from "./channel-M0rnT4bN.js";
+import { t as qqbotPlugin } from "./channel-91Y8ZcpJ.js";
 import { a as resolveQQBotAccount, i as resolveDefaultQQBotAccountId, n as applyQQBotAccountConfig, r as listQQBotAccountIds, t as DEFAULT_ACCOUNT_ID } from "./config-ZEfgeoL4.js";
 import { t as qqbotSetupPlugin } from "./channel.setup-CQ_DFfPx.js";
 import { t as getFrameworkCommands } from "./slash-commands-impl-DVApdSop.js";
 import { n as registerRemindTool, r as registerChannelTool, t as registerQQBotTools } from "./tools-2d9t-N1b.js";
-import { t as registerQQBotFull } from "./channel-entry-CfzBEypJ.js";
-import { C as getMessageReplyStats, D as setOutboundAudioPort, E as OUTBOUND_ERROR_CODES, S as getMessageReplyConfig, T as DEFAULT_MEDIA_SEND_ERROR, _ as sendVideoMsg, a as sendText, b as MESSAGE_REPLY_LIMIT, f as buildMediaTarget, g as sendPhoto, h as sendDocument, i as sendProactiveMessage, m as resolveOutboundMediaPath, n as sendCronMessage, p as parseTarget, r as sendMedia, v as sendVoice, w as recordMessageReply, x as checkMessageReplyLimit, y as resolveUserFacingMediaError } from "./outbound-C9wV892v.js";
+import { t as registerQQBotFull } from "./channel-entry-D_eHXHMg.js";
+import { C as getMessageReplyConfig, D as OUTBOUND_ERROR_CODES, E as DEFAULT_MEDIA_SEND_ERROR, O as setOutboundAudioPort, S as checkMessageReplyLimit, T as recordMessageReply, _ as sendVideoMsg, a as sendText, b as resolveUserFacingMediaError, f as buildMediaTarget, g as sendPhoto, h as sendDocument, i as sendProactiveMessage, m as resolveOutboundMediaPath, n as sendCronMessage, p as parseTarget, r as sendMedia, v as sendVoice, w as getMessageReplyStats, x as MESSAGE_REPLY_LIMIT } from "./outbound-DN8kX1G3.js";
 export { DEFAULT_ACCOUNT_ID, DEFAULT_MEDIA_SEND_ERROR, MESSAGE_REPLY_LIMIT, OUTBOUND_ERROR_CODES, applyQQBotAccountConfig, buildMediaTarget, checkMessageReplyLimit, getFrameworkCommands, getMessageReplyConfig, getMessageReplyStats, listQQBotAccountIds, parseTarget, qqbotPlugin, qqbotSetupPlugin, recordMessageReply, registerChannelTool, registerQQBotFull, registerQQBotTools, registerRemindTool, resolveDefaultQQBotAccountId, resolveOutboundMediaPath, resolveQQBotAccount, resolveUserFacingMediaError, sendCronMessage, sendDocument, sendMedia, sendPhoto, sendProactiveMessage, sendText, sendVideoMsg, sendVoice, setOutboundAudioPort };

package/dist/{channel-M0rnT4bN.js → channel-91Y8ZcpJ.js}

@@ -296,6 +296,9 @@ function canResolveTarget(request) {
 		bundledFallback: true
 	})?.id != null;
 }
+function resolveNativeDeliveryState(params) {
+	return isNativeDeliveryEnabled(params) ? { kind: "enabled" } : { kind: "disabled" };
+}
 function createQQBotApprovalCapability() {
 	return createChannelApprovalCapability({
 		authorizeActorAction: ({ cfg, accountId, senderId, approvalKind }) => authorizeQQBotApprovalAction({
@@ -304,18 +307,8 @@ function createQQBotApprovalCapability() {
 			senderId,
 			approvalKind
 		}),
-		getActionAvailabilityState: ({ cfg, accountId }) => {
-			return isNativeDeliveryEnabled({
-				cfg,
-				accountId
-			}) ? { kind: "enabled" } : { kind: "disabled" };
-		},
-		getExecInitiatingSurfaceState: ({ cfg, accountId }) => {
-			return isNativeDeliveryEnabled({
-				cfg,
-				accountId
-			}) ? { kind: "enabled" } : { kind: "disabled" };
-		},
+		getActionAvailabilityState: resolveNativeDeliveryState,
+		getExecInitiatingSurfaceState: resolveNativeDeliveryState,
 		describeExecApprovalSetup: ({ accountId }) => {
 			return `QQBot native exec approvals are enabled by default. To restrict who can approve, configure \`${accountId && accountId !== "default" ? `channels.qqbot.accounts.${accountId}` : "channels.qqbot"}.execApprovals.approvers\` with QQ user OpenIDs.`;
 		},
@@ -377,7 +370,7 @@ function createQQBotApprovalCapability() {
 			},
 			load: async () => {
 				ensurePlatformAdapter();
-				return (await import("./handler-runtime-BZCDG_mN.js")).qqbotApprovalNativeRuntime;
+				return (await import("./handler-runtime-BzeYyTXb.js")).qqbotApprovalNativeRuntime;
 			}
 		})
 	});
@@ -649,6 +642,412 @@ function clearAccountCredentials(cfg, accountId) {
 	};
 }
 //#endregion
+//#region extensions/qqbot/src/engine/messaging/markdown-table-chunking.ts
+const QQBOT_MARKDOWN_SAFE_CHUNK_BYTE_LIMIT = 3600;
+function chunkQQBotMarkdownText(text, limit, baseChunker) {
+	const chunker = createQQBotMarkdownChunker(baseChunker);
+	return [...chunker.chunkText(text, limit), ...chunker.flushPendingText(limit)];
+}
+function createQQBotMarkdownChunker(baseChunker) {
+	const state = new QQBotMarkdownChunkingState(baseChunker);
+	return {
+		chunkText: (text, limit) => state.chunkText(text, limit),
+		flushPendingText: (limit) => state.flushPendingText(limit)
+	};
+}
+var QQBotMarkdownChunkingState = class {
+	constructor(baseChunker) {
+		this.baseChunker = baseChunker;
+		this.activeTable = null;
+		this.pendingHeaderLine = null;
+		this.pendingHeaderCells = [];
+		this.tableLines = [];
+		this.textLines = [];
+		this.pendingRowFragment = null;
+		this.activeFence = null;
+		this.pendingTextFenceOpenLine = null;
+		this.pendingFenceLineFragment = null;
+	}
+	chunkText(text, limit) {
+		if (!text) return [];
+		if (limit <= 0) return this.baseChunker(text, limit);
+		const chunkLimit = resolveQQBotMarkdownChunkLimit(limit);
+		const chunks = [];
+		const textWithPendingRow = this.consumePendingRowPrefix(text);
+		const textWithPendingFenceLine = this.consumePendingFenceLinePrefix(textWithPendingRow);
+		const hasTrailingNewline = textWithPendingFenceLine.endsWith("\n");
+		const lines = textWithPendingFenceLine.split("\n");
+		for (const [index, line] of lines.entries()) {
+			const isTrailingSplitLine = index === lines.length - 1 && line === "";
+			this.consumeLine(line, {
+				limit: chunkLimit,
+				chunks,
+				hasTrailingNewline,
+				isTrailingSplitLine,
+				isLastLine: index === lines.length - 1
+			});
+		}
+		this.flushText(chunks, chunkLimit);
+		this.flushTable(chunks);
+		return chunks;
+	}
+	flushPendingText(limit) {
+		const chunkLimit = resolveQQBotMarkdownChunkLimit(limit);
+		const chunks = [];
+		this.flushPendingRowFragment(chunks, chunkLimit);
+		this.flushPendingFenceLineFragment();
+		this.flushPendingHeaderAsText();
+		this.flushText(chunks, chunkLimit);
+		this.flushTable(chunks);
+		return chunks;
+	}
+	consumeLine(line, params) {
+		const fence = parseFenceLine(line);
+		if (fence) {
+			this.endTable(params.chunks);
+			if (!this.activeFence) {
+				this.pushTextLine(line);
+				this.activeFence = fence;
+				this.clearPendingTableHeader();
+				return;
+			}
+			if (isClosingFenceLine(line, this.activeFence)) {
+				this.pushFenceTextLine(line);
+				this.activeFence = null;
+				this.clearPendingTableHeader();
+				return;
+			}
+			this.pushFenceTextLine(line);
+			this.clearPendingTableHeader();
+			return;
+		}
+		if (this.activeFence) {
+			if (params.isLastLine && !params.hasTrailingNewline) {
+				this.pendingFenceLineFragment = mergeFenceLineFragments(this.pendingFenceLineFragment, line);
+				return;
+			}
+			this.pushFenceTextLine(line);
+			return;
+		}
+		if (isIncompleteTableRowFragment(line) || this.activeTable && isShortTableRowLine(line, this.activeTable)) {
+			if (params.isLastLine) {
+				this.flushText(params.chunks, params.limit);
+				this.pendingRowFragment = mergeRowFragments(this.pendingRowFragment, line);
+				return;
+			}
+			this.pushTextLine(renderMalformedPipeLineAsText(line));
+			return;
+		}
+		if (this.pendingHeaderLine && isTableSeparatorLine(line)) {
+			this.flushText(params.chunks, params.limit);
+			this.activeTable = {
+				header: this.pendingHeaderLine,
+				separator: line,
+				cells: this.pendingHeaderCells
+			};
+			this.pendingHeaderLine = null;
+			this.pendingHeaderCells = [];
+			this.ensureTableHeader();
+			return;
+		}
+		if (isTableRowLine(line) && this.activeTable && !isTableSeparatorLine(line)) {
+			this.flushText(params.chunks, params.limit);
+			this.appendTableRow(line, params.limit, params.chunks);
+			return;
+		}
+		if (this.activeTable) {
+			if (!line.trim() && params.isTrailingSplitLine) return;
+			this.endTable(params.chunks);
+		}
+		if (isTableRowLine(line) && !isTableSeparatorLine(line)) {
+			this.flushText(params.chunks, params.limit);
+			this.pendingHeaderLine = line;
+			this.pendingHeaderCells = splitTableCells(line);
+			return;
+		}
+		this.flushPendingHeaderAsText();
+		this.pushTextLine(line);
+	}
+	pushTextLine(line) {
+		this.textLines.push(line);
+	}
+	pushFenceTextLine(line) {
+		if (this.textLines.length === 0 && this.activeFence) this.pendingTextFenceOpenLine = this.activeFence.openLine;
+		this.textLines.push(line);
+	}
+	appendTableRow(line, limit, chunks) {
+		if (utf8ByteLength([
+			this.activeTable.header,
+			this.activeTable.separator,
+			line
+		].join("\n")) > limit) {
+			this.dropHeaderOnlyTableChunk();
+			this.flushTable(chunks);
+			this.pushOversizedTableRow(line, limit, chunks);
+			return;
+		}
+		this.ensureTableHeader();
+		if (utf8ByteLength([...this.tableLines, line].join("\n")) <= limit) {
+			this.tableLines.push(line);
+			return;
+		}
+		this.flushTable(chunks);
+		this.ensureTableHeader();
+		this.tableLines.push(line);
+	}
+	pushOversizedTableRow(line, limit, chunks) {
+		pushBaseChunks(chunks, renderTableRowAsFields(this.activeTable.cells, splitTableCells(line)), limit, this.baseChunker);
+	}
+	ensureTableHeader() {
+		if (this.tableLines.length > 0 || !this.activeTable) return;
+		this.tableLines.push(this.activeTable.header, this.activeTable.separator);
+	}
+	flushText(chunks, limit) {
+		if (this.textLines.length === 0) return;
+		if (this.flushFenceText(chunks, limit)) return;
+		let text = this.textLines.join("\n");
+		this.textLines = [];
+		if (this.pendingTextFenceOpenLine) {
+			text = `${this.pendingTextFenceOpenLine}\n${text}`;
+			this.pendingTextFenceOpenLine = null;
+		}
+		if (this.activeFence) text = `${text}\n${this.activeFence.closeLine}`;
+		if (!text) return;
+		pushBaseChunks(chunks, text, limit, this.baseChunker);
+	}
+	flushFenceText(chunks, limit) {
+		const pendingFenceOpenLine = this.pendingTextFenceOpenLine;
+		const firstLineFence = pendingFenceOpenLine ? null : parseFenceLine(this.textLines[0] ?? "");
+		const fence = pendingFenceOpenLine ? parseFenceLine(pendingFenceOpenLine) : firstLineFence;
+		if (!fence) return false;
+		const bodyLines = pendingFenceOpenLine ? [...this.textLines] : this.textLines.slice(1);
+		this.textLines = [];
+		this.pendingTextFenceOpenLine = null;
+		if (bodyLines.length > 0 && isClosingFenceLine(bodyLines[bodyLines.length - 1], fence)) bodyLines.pop();
+		if (this.activeFence && bodyLines.length === 0) return true;
+		pushFenceLineChunks({
+			chunks,
+			openLine: fence.openLine,
+			closeLine: fence.closeLine,
+			bodyLines,
+			limit,
+			baseChunker: this.baseChunker
+		});
+		return true;
+	}
+	consumePendingFenceLinePrefix(text) {
+		if (!this.pendingFenceLineFragment) return text;
+		const separator = shouldJoinFenceLineFragments(this.pendingFenceLineFragment, text) ? "" : "\n";
+		const merged = `${this.pendingFenceLineFragment}${separator}${text}`;
+		this.pendingFenceLineFragment = null;
+		return merged;
+	}
+	flushPendingFenceLineFragment() {
+		if (!this.pendingFenceLineFragment) return;
+		this.pushFenceTextLine(this.pendingFenceLineFragment);
+		this.pendingFenceLineFragment = null;
+	}
+	flushPendingHeaderAsText() {
+		if (!this.pendingHeaderLine) return;
+		this.pushTextLine(this.pendingHeaderLine);
+		this.pendingHeaderLine = null;
+		this.pendingHeaderCells = [];
+	}
+	clearPendingTableHeader() {
+		this.pendingHeaderLine = null;
+		this.pendingHeaderCells = [];
+	}
+	consumePendingRowPrefix(text) {
+		if (!this.pendingRowFragment) return text;
+		const separator = this.pendingRowFragment.trimEnd().endsWith("|") && text && !/^[\s|]/.test(text) ? " " : "";
+		const merged = `${this.pendingRowFragment}${separator}${text}`;
+		this.pendingRowFragment = null;
+		return merged;
+	}
+	flushPendingRowFragment(chunks, limit) {
+		if (!this.pendingRowFragment) return;
+		const fragment = this.pendingRowFragment;
+		this.pendingRowFragment = null;
+		pushBaseChunks(chunks, this.activeTable ? renderTableRowAsFields(this.activeTable.cells, splitPartialTableCells(fragment)) : renderMalformedPipeLineAsText(fragment), limit, this.baseChunker);
+	}
+	flushTable(chunks) {
+		if (this.tableLines.length === 0) return;
+		chunks.push(this.tableLines.join("\n"));
+		this.tableLines = [];
+	}
+	dropHeaderOnlyTableChunk() {
+		if (this.activeTable && this.tableLines.length === 2 && this.tableLines[0] === this.activeTable.header && this.tableLines[1] === this.activeTable.separator) this.tableLines = [];
+	}
+	endTable(chunks) {
+		this.flushTable(chunks);
+		this.activeTable = null;
+	}
+};
+function isTableRowLine(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("|") && trimmed.endsWith("|") && splitTableCells(trimmed).length >= 2;
+}
+function resolveQQBotMarkdownChunkLimit(limit) {
+	return Math.min(limit, QQBOT_MARKDOWN_SAFE_CHUNK_BYTE_LIMIT);
+}
+function pushBaseChunks(chunks, text, byteLimit, baseChunker) {
+	for (const chunk of baseChunker(text, byteLimit)) {
+		if (!chunk) continue;
+		if (utf8ByteLength(chunk) <= byteLimit) {
+			chunks.push(chunk);
+			continue;
+		}
+		chunks.push(...splitByUtf8ByteLimit(chunk, byteLimit));
+	}
+}
+function splitByUtf8ByteLimit(text, byteLimit) {
+	if (!text) return [];
+	const chunks = [];
+	let current = "";
+	let currentBytes = 0;
+	for (const char of text) {
+		const charBytes = utf8ByteLength(char);
+		if (current && currentBytes + charBytes > byteLimit) {
+			chunks.push(current);
+			current = "";
+			currentBytes = 0;
+		}
+		current += char;
+		currentBytes += charBytes;
+	}
+	if (current) chunks.push(current);
+	return chunks;
+}
+function utf8ByteLength(text) {
+	return Buffer.byteLength(text, "utf8");
+}
+function isIncompleteTableRowFragment(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("|") && !trimmed.endsWith("|") && splitPartialTableCells(trimmed).length >= 2;
+}
+function isShortTableRowLine(line, table) {
+	if (!isTableRowLine(line) || isTableSeparatorLine(line)) return false;
+	return splitTableCells(line).length < table.cells.length;
+}
+function isTableSeparatorLine(line) {
+	if (!isTableRowLine(line)) return false;
+	const cells = splitTableCells(line);
+	return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()));
+}
+function splitTableCells(line) {
+	return line.trim().slice(1, -1).split("|").map((cell) => cell.trim());
+}
+function splitPartialTableCells(line) {
+	return line.trim().replace(/^\|/, "").split("|").map((cell) => cell.trim()).filter((cell) => cell.length > 0);
+}
+function mergeRowFragments(pending, next) {
+	return pending ? `${pending}${next}` : next;
+}
+function mergeFenceLineFragments(pending, next) {
+	return pending ? `${pending}${next}` : next;
+}
+function shouldJoinFenceLineFragments(pending, next) {
+	if (!next || next.startsWith("\n")) return true;
+	const trimmedPending = pending.trimEnd();
+	const trimmedNext = next.trimStart();
+	if (!trimmedPending || !trimmedNext) return true;
+	if (/\d\.$/.test(trimmedPending) && /^\d/.test(trimmedNext)) return true;
+	if (/[.([{:,+\-*/%=&|^<>\\]$/.test(trimmedPending)) return true;
+	return hasUnclosedQuote(trimmedPending) || hasUnclosedDelimiter(trimmedPending);
+}
+function hasUnclosedQuote(line) {
+	let single = false;
+	let double = false;
+	let escaped = false;
+	for (const char of line) {
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (char === "'" && !double) {
+			single = !single;
+			continue;
+		}
+		if (char === "\"" && !single) double = !double;
+	}
+	return single || double;
+}
+function hasUnclosedDelimiter(line) {
+	const stack = [];
+	const pairs = {
+		"(": ")",
+		"[": "]",
+		"{": "}"
+	};
+	const closers = new Set(Object.values(pairs));
+	for (const char of line) {
+		if (pairs[char]) {
+			stack.push(pairs[char]);
+			continue;
+		}
+		if (closers.has(char)) {
+			if (stack.at(-1) === char) stack.pop();
+		}
+	}
+	return stack.length > 0;
+}
+function renderMalformedPipeLineAsText(line) {
+	return splitPartialTableCells(line).join(" ");
+}
+function renderTableRowAsFields(headers, cells) {
+	return cells.map((cell, index) => {
+		const header = headers[index]?.trim();
+		return header ? `${header}: ${cell}` : cell;
+	}).join("\n");
+}
+function pushFenceLineChunks(params) {
+	const { chunks, openLine, closeLine, bodyLines, limit, baseChunker } = params;
+	let currentLines = [];
+	const render = (lines) => [
+		openLine,
+		...lines,
+		closeLine
+	].join("\n");
+	const flushCurrent = () => {
+		if (currentLines.length === 0) return;
+		chunks.push(render(currentLines));
+		currentLines = [];
+	};
+	for (const line of bodyLines) {
+		const candidate = [...currentLines, line];
+		if (utf8ByteLength(render(candidate)) <= limit) {
+			currentLines = candidate;
+			continue;
+		}
+		flushCurrent();
+		const singleLineChunk = render([line]);
+		if (utf8ByteLength(singleLineChunk) <= limit) {
+			currentLines = [line];
+			continue;
+		}
+		pushBaseChunks(chunks, singleLineChunk, limit, baseChunker);
+	}
+	if (currentLines.length > 0 || bodyLines.length === 0) chunks.push(render(currentLines));
+}
+function parseFenceLine(line) {
+	const match = line.match(/^(\s*)(`{3,}|~{3,})/);
+	if (!match?.[2]) return null;
+	return {
+		openLine: line,
+		closeLine: `${match[1] ?? ""}${match[2]}`,
+		marker: match[2]
+	};
+}
+function isClosingFenceLine(line, fence) {
+	const markerChar = fence.marker[0] === "`" ? "`" : "~";
+	const match = line.match(/^(\s*)(`{3,}|~{3,})\s*$/);
+	return Boolean(match?.[2] && match[2][0] === markerChar && match[2].length >= fence.marker.length);
+}
+//#endregion
 //#region extensions/qqbot/src/group-policy.ts
 function resolveQQBotGroupToolPolicy(params) {
 	return resolveChannelGroupToolsPolicy({
@@ -667,12 +1066,12 @@ function resolveQQBotGroupToolPolicy(params) {
 //#region extensions/qqbot/src/channel.ts
 let gatewayModulePromise;
 function loadGatewayModule() {
-	gatewayModulePromise ??= import("./gateway-CElyH-CJ.js");
+	gatewayModulePromise ??= import("./gateway-CwDoxaZF.js");
 	return gatewayModulePromise;
 }
 let outboundMessagingModulePromise;
 function loadOutboundMessagingModule() {
-	outboundMessagingModulePromise ??= import("./outbound-C9wV892v.js").then((n) => n.t);
+	outboundMessagingModulePromise ??= import("./outbound-DN8kX1G3.js").then((n) => n.t);
 	return outboundMessagingModulePromise;
 }
 function createQQBotSendReceipt(params) {
@@ -822,7 +1221,7 @@ const qqbotPlugin = {
 	},
 	outbound: {
 		deliveryMode: "direct",
-		chunker: (text, limit) => getQQBotRuntime().channel.text.chunkMarkdownText(text, limit),
+		chunker: (text, limit) => chunkQQBotMarkdownText(text, limit, getQQBotRuntime().channel.text.chunkMarkdownText),
 		chunkerMode: "markdown",
 		textChunkLimit: 5e3,
 		sanitizeText: ({ text }) => sanitizeAssistantVisibleText(text),
@@ -950,4 +1349,4 @@ const qqbotPlugin = {
 	}
 };
 //#endregion
-export { authorizeQQBotApprovalAction as a, resolveQQBotExecApprovalConfig as c, buildExecApprovalText as d, buildPluginApprovalText as f, toGatewayAccount as i, shouldHandleQQBotExecApprovalRequest as l, resolveApprovalTarget as m, buildQQBotStateKey as n, isQQBotExecApprovalClientEnabled as o, parseApprovalButtonData as p, openQQBotSyncKeyedStore as r, matchesQQBotApprovalAccount as s, qqbotPlugin as t, buildApprovalKeyboard as u };
+export { toGatewayAccount as a, matchesQQBotApprovalAccount as c, buildApprovalKeyboard as d, buildExecApprovalText as f, resolveApprovalTarget as h, openQQBotSyncKeyedStore as i, resolveQQBotExecApprovalConfig as l, parseApprovalButtonData as m, createQQBotMarkdownChunker as n, authorizeQQBotApprovalAction as o, buildPluginApprovalText as p, buildQQBotStateKey as r, isQQBotExecApprovalClientEnabled as s, qqbotPlugin as t, shouldHandleQQBotExecApprovalRequest as u };

package/dist/{channel-entry-CfzBEypJ.js → channel-entry-D_eHXHMg.js}

@@ -1,7 +1,7 @@
 import { a as resolveQQBotAccount } from "./config-ZEfgeoL4.js";
 import { t as getFrameworkCommands } from "./slash-commands-impl-DVApdSop.js";
 import { t as registerQQBotTools } from "./tools-2d9t-N1b.js";
-import { h as sendDocument } from "./outbound-C9wV892v.js";
+import { h as sendDocument } from "./outbound-DN8kX1G3.js";
 //#region extensions/qqbot/src/bridge/commands/framework-context-adapter.ts
 /**
 * Default queue snapshot used for framework-registered commands.

package/dist/channel-entry-api.js

@@ -1,2 +1,2 @@
-import { t as registerQQBotFull } from "./channel-entry-CfzBEypJ.js";
+import { t as registerQQBotFull } from "./channel-entry-D_eHXHMg.js";
 export { registerQQBotFull };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as qqbotPlugin } from "./channel-M0rnT4bN.js";
+import { t as qqbotPlugin } from "./channel-91Y8ZcpJ.js";
 export { qqbotPlugin };

package/dist/{gateway-CElyH-CJ.js → gateway-CwDoxaZF.js}

@@ -1,14 +1,14 @@
 import { C as getNextMsgSeq, D as downloadFile, F as StreamInputMode, I as StreamInputState, M as getMaxUploadSize, P as StreamContentType, T as openLocalFile, a as createRawInputNotifyFn, b as stopBackgroundTokenRefresh, c as getMessageApi, d as initSender, f as onMessageSent, g as sendText, h as sendMedia, i as clearTokenCache, j as getImageMimeType, k as formatFileSize, l as getPluginUserAgent, m as sendInputNotify, n as acknowledgeInteraction, o as getAccessToken, p as registerAccount, r as buildDeliveryTarget, s as getGatewayUrl, t as accountToCreds, u as initApiConfig, x as withTokenRetry, y as startBackgroundTokenRefresh } from "./sender-DIMG7jHz.js";
 import { c as getPlatformAdapter, i as normalizeOptionalString$1, n as normalizeLowercaseStringOrEmpty$1, o as readStringField, s as sanitizeFileName, t as asOptionalObjectRecord } from "./string-normalize-R_0cKO7Q.js";
 import { c as setBridgeLogger, o as ensurePlatformAdapter } from "./config-schema-BFLNZ8Nf.js";
-import { a as authorizeQQBotApprovalAction, i as toGatewayAccount, n as buildQQBotStateKey, p as parseApprovalButtonData, r as openQQBotSyncKeyedStore } from "./channel-M0rnT4bN.js";
+import { a as toGatewayAccount, i as openQQBotSyncKeyedStore, m as parseApprovalButtonData, n as createQQBotMarkdownChunker, o as authorizeQQBotApprovalAction, r as buildQQBotStateKey } from "./channel-91Y8ZcpJ.js";
 import { d as resolveAccountBase } from "./config-ZEfgeoL4.js";
 import { a as formatErrorMessage, i as formatDuration, n as debugLog, r as debugWarn, t as debugError } from "./log-SDfMMBWe.js";
 import { n as getQQBotRuntimeForEngine, t as getQQBotRuntime } from "./runtime-B9UoQ5NI.js";
-import { a as getHomeDir, c as getQQBotMediaDir, d as isLocalPath, f as isWindows, i as checkSilkWasmAvailable, m as resolveQQBotPayloadLocalFilePath, o as getQQBotDataDir, p as normalizePath, s as getQQBotDataPath, u as getTempDir } from "./target-parser-BdCUmxK7.js";
+import { a as getHomeDir, c as getQQBotMediaDir, d as isLocalPath, f as isWindows, i as checkSilkWasmAvailable, o as getQQBotDataDir, p as normalizePath, s as getQQBotDataPath, u as getTempDir } from "./target-parser-BdCUmxK7.js";
 import { a as matchSlashCommand, i as initCommands, n as getFrameworkVersion, r as getPluginVersion } from "./slash-commands-impl-DVApdSop.js";
 import { n as runWithRequestContext } from "./request-context-Bm7PTBD1.js";
-import { D as setOutboundAudioPort, T as DEFAULT_MEDIA_SEND_ERROR, _ as sendVideoMsg, c as isCronReminderPayload, d as normalizeMediaTags, g as sendPhoto, h as sendDocument, l as isMediaPayload, o as decodeMediaPath, r as sendMedia$1, s as encodePayloadForCron, u as parseQQBotPayload, v as sendVoice, y as resolveUserFacingMediaError } from "./outbound-C9wV892v.js";
+import { E as DEFAULT_MEDIA_SEND_ERROR, O as setOutboundAudioPort, _ as sendVideoMsg, b as resolveUserFacingMediaError, c as isCronReminderPayload, d as normalizeMediaTags, g as sendPhoto, h as sendDocument, l as isMediaPayload, o as decodeMediaPath, r as sendMedia$1, s as encodePayloadForCron, u as parseQQBotPayload, v as sendVoice, y as resolveTrustedOutboundMediaPath } from "./outbound-DN8kX1G3.js";
 import { asBoolean, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { isImplicitSameChatApprovalAuthorization } from "openclaw/plugin-sdk/approval-auth-runtime";
 import * as fs$1 from "node:fs";
@@ -3997,7 +3997,7 @@ function formatMediaTypeLabel(mediaType) {
 	return mediaType[0].toUpperCase() + mediaType.slice(1);
 }
 function validateStructuredPayloadLocalPath(ctx, payloadPath, mediaType) {
-	const allowedPath = resolveQQBotPayloadLocalFilePath(payloadPath);
+	const allowedPath = resolveTrustedOutboundMediaPath(payloadPath);
 	if (allowedPath) return allowedPath;
 	ctx.log?.error(`Blocked ${mediaType} payload local path outside QQ Bot media storage`);
 	return null;
@@ -5870,6 +5870,7 @@ async function dispatchOutbound(inbound, deps) {
 			if (!hasResponse) reject(/* @__PURE__ */ new Error("Response timeout"));
 		}, responseTimeoutMs);
 	});
+	const markdownChunker = createQQBotMarkdownChunker((text, limit) => runtime.channel.text.chunkMarkdownText(text, limit));
 	const deliverDeps = {
 		mediaSender: {
 			sendPhoto: (target, imageUrl) => sendPhoto(target, imageUrl),
@@ -5878,7 +5879,30 @@ async function dispatchOutbound(inbound, deps) {
 			sendDocument: (target, filePath) => sendDocument(target, filePath),
 			sendMedia: (opts) => sendMedia$1(opts)
 		},
-		chunkText: (text, limit) => runtime.channel.text.chunkMarkdownText(text, limit)
+		chunkText: (text, limit) => markdownChunker.chunkText(text, limit)
+	};
+	const flushPendingMarkdownText = async () => {
+		const pendingChunks = markdownChunker.flushPendingText(TEXT_CHUNK_LIMIT);
+		if (pendingChunks.length === 0) return;
+		const passthroughDeps = {
+			...deliverDeps,
+			chunkText: (text) => [text]
+		};
+		for (const chunk of pendingChunks) {
+			await sendTextOnlyReply(chunk, {
+				type: event.type,
+				senderId: event.senderId,
+				messageId: event.messageId,
+				channelId: event.channelId,
+				groupOpenid: event.groupOpenid,
+				msgIdx: event.msgIdx
+			}, {
+				account,
+				qualifiedTarget,
+				log
+			}, sendWithRetry, () => void 0, passthroughDeps);
+			recordOutbound();
+		}
 	};
 	const replyDeps = { tts: {
 		textToSpeech: (params) => runtime.tts.textToSpeech(params),
@@ -6140,6 +6164,7 @@ async function dispatchOutbound(inbound, deps) {
 			toolFallbackSent = true;
 			await sendToolFallback();
 		}
+		await flushPendingMarkdownText();
 		if (streamingController && !streamingController.isTerminalPhase) try {
 			streamingController.markFullyComplete();
 			await streamingController.onIdle();

package/dist/{handler-runtime-BZCDG_mN.js → handler-runtime-BzeYyTXb.js}

@@ -1,6 +1,6 @@
 import { c as getMessageApi, t as accountToCreds } from "./sender-DIMG7jHz.js";
 import { o as ensurePlatformAdapter, s as getBridgeLogger } from "./config-schema-BFLNZ8Nf.js";
-import { c as resolveQQBotExecApprovalConfig, d as buildExecApprovalText, f as buildPluginApprovalText, l as shouldHandleQQBotExecApprovalRequest, m as resolveApprovalTarget, o as isQQBotExecApprovalClientEnabled, s as matchesQQBotApprovalAccount, u as buildApprovalKeyboard } from "./channel-M0rnT4bN.js";
+import { c as matchesQQBotApprovalAccount, d as buildApprovalKeyboard, f as buildExecApprovalText, h as resolveApprovalTarget, l as resolveQQBotExecApprovalConfig, p as buildPluginApprovalText, s as isQQBotExecApprovalClientEnabled, u as shouldHandleQQBotExecApprovalRequest } from "./channel-91Y8ZcpJ.js";
 import { a as resolveQQBotAccount } from "./config-ZEfgeoL4.js";
 import { resolveApprovalRequestSessionConversation } from "openclaw/plugin-sdk/approval-native-runtime";
 import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";

package/dist/{outbound-C9wV892v.js → outbound-DN8kX1G3.js}

@@ -5,6 +5,7 @@ import { c as getQQBotMediaDir, d as isLocalPath, m as resolveQQBotPayloadLocalF
 import { pathExistsSync, resolveLocalPathFromRootsSync } from "openclaw/plugin-sdk/security-runtime";
 import path from "node:path";
 import { getFileExtension } from "openclaw/plugin-sdk/media-mime";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/sandbox";
 //#region extensions/qqbot/src/engine/messaging/outbound-audio-port.ts
 let outboundAudioPort = null;
 /**
@@ -193,6 +194,47 @@ function buildFileTooLargeResult(fileType, fileSize) {
 	};
 }
 //#endregion
+//#region extensions/qqbot/src/engine/messaging/trusted-media-path.ts
+let cachedTrustedTmpRoot;
+function trustedOpenClawTmpRoot() {
+	if (cachedTrustedTmpRoot === void 0) try {
+		cachedTrustedTmpRoot = resolvePreferredOpenClawTmpDir();
+	} catch {
+		return null;
+	}
+	return cachedTrustedTmpRoot;
+}
+/**
+* Resolve a local outbound media path against every trusted root, returning the
+* canonical path or null when it sits outside all of them.
+*
+* QQBot is the only channel that root-sandboxes outbound local files, and the
+* same check runs at three sites (`resolveOutboundMediaPath`, the voice send
+* re-check, and structured-payload validation), so they must all agree or a file
+* accepted at one gate is rejected at the next. Beyond the QQ Bot media storage
+* roots, this also trusts OpenClaw's permission-hardened temp root, where
+* framework scratch media is written (e.g. cron auto-TTS voice files). Core
+* already treats that temp root as a sanctioned media root (`buildMediaLocalRoots`);
+* without it here, auto-routed sends are dropped and cron delivery silently loses
+* the message.
+*
+* `allowMissing` lets callers accept a not-yet-flushed temp file (e.g. TTS still
+* writing) under the temp root; existence is then enforced later by the voice
+* send re-check before upload.
+*/
+function resolveTrustedOutboundMediaPath(p, options = {}) {
+	const storageRootPath = resolveQQBotPayloadLocalFilePath(p);
+	if (storageRootPath) return storageRootPath;
+	const tmpRoot = trustedOpenClawTmpRoot();
+	if (!tmpRoot) return null;
+	return resolveLocalPathFromRootsSync({
+		filePath: p,
+		roots: [tmpRoot],
+		label: "OpenClaw temp media root",
+		allowMissing: options.allowMissing === true
+	})?.path ?? null;
+}
+//#endregion
 //#region extensions/qqbot/src/engine/messaging/outbound-media-send.ts
 /**
 * Low-level outbound media sends (photo, voice, video, document) and path resolution.
@@ -252,7 +294,7 @@ function resolveOutboundMediaPath(rawPath, mediaKind, options = {}) {
 		ok: true,
 		mediaPath: normalizedPath
 	};
-	const allowedPath = resolveQQBotPayloadLocalFilePath(normalizedPath);
+	const allowedPath = resolveTrustedOutboundMediaPath(normalizedPath, { allowMissing: options.allowMissingLocalPath });
 	if (allowedPath) return {
 		ok: true,
 		mediaPath: allowedPath
@@ -462,7 +504,7 @@ async function sendVoiceFromLocal(ctx, mediaPath, directUploadFormats, transcode
 		error: "Voice generate failed"
 	};
 	if (fileSize > getMaxUploadSize(3)) return buildFileTooLargeResult(3, fileSize);
-	const safeMediaPath = resolveQQBotPayloadLocalFilePath(mediaPath);
+	const safeMediaPath = resolveTrustedOutboundMediaPath(mediaPath);
 	if (!safeMediaPath) {
 		debugWarn(`sendVoice: blocked local voice path outside QQ Bot media storage`);
 		return {
@@ -1368,4 +1410,4 @@ async function sendCronMessage(account, to, message) {
 	});
 }
 //#endregion
-export { getMessageReplyStats as C, setOutboundAudioPort as D, OUTBOUND_ERROR_CODES as E, getMessageReplyConfig as S, DEFAULT_MEDIA_SEND_ERROR as T, sendVideoMsg as _, sendText as a, MESSAGE_REPLY_LIMIT as b, isCronReminderPayload as c, normalizeMediaTags as d, buildMediaTarget as f, sendPhoto as g, sendDocument as h, sendProactiveMessage as i, isMediaPayload as l, resolveOutboundMediaPath as m, sendCronMessage as n, decodeMediaPath as o, parseTarget as p, sendMedia as r, encodePayloadForCron as s, outbound_exports as t, parseQQBotPayload as u, sendVoice as v, recordMessageReply as w, checkMessageReplyLimit as x, resolveUserFacingMediaError as y };
+export { getMessageReplyConfig as C, OUTBOUND_ERROR_CODES as D, DEFAULT_MEDIA_SEND_ERROR as E, setOutboundAudioPort as O, checkMessageReplyLimit as S, recordMessageReply as T, sendVideoMsg as _, sendText as a, resolveUserFacingMediaError as b, isCronReminderPayload as c, normalizeMediaTags as d, buildMediaTarget as f, sendPhoto as g, sendDocument as h, sendProactiveMessage as i, isMediaPayload as l, resolveOutboundMediaPath as m, sendCronMessage as n, decodeMediaPath as o, parseTarget as p, sendMedia as r, encodePayloadForCron as s, outbound_exports as t, parseQQBotPayload as u, sendVoice as v, getMessageReplyStats as w, MESSAGE_REPLY_LIMIT as x, resolveTrustedOutboundMediaPath as y };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/qqbot",
-  "version": "2026.6.8",
+  "version": "2026.6.9-beta.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/qqbot",
-      "version": "2026.6.8",
+      "version": "2026.6.9-beta.1",
       "dependencies": {
         "@tencent-connect/qqbot-connector": "1.1.0",
         "mpg123-decoder": "1.0.3",
@@ -15,7 +15,7 @@
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.6.8"
+        "openclaw": ">=2026.6.9-beta.1"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/qqbot",
-  "version": "2026.6.8",
+  "version": "2026.6.9-beta.1",
   "private": false,
   "description": "OpenClaw QQ Bot channel plugin for group and direct-message workflows.",
   "repository": {
@@ -16,7 +16,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.6.8"
+    "openclaw": ">=2026.6.9-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -45,10 +45,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.6.8"
+      "pluginApi": ">=2026.6.9-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.6.8"
+      "openclawVersion": "2026.6.9-beta.1"
     },
     "release": {
       "publishToClawHub": true,