@jeik/dingtalk-connector 0.8.27 → 0.8.28

package/dist/{message-handler-DQZiKx3i.mjs → message-handler-B1usz1wb.mjs}

@@ -1,14 +1,15 @@
 import { a as resolveDingtalkAccount } from "./accounts-BAzdqkAV.mjs";
-import { r as CHANNEL_ID, t as getDingtalkRuntime } from "./runtime-DzZo6Gvk.mjs";
+import { r as CHANNEL_ID, t as getDingtalkRuntime } from "./runtime-A6G7WAWn.mjs";
 import { n as createLoggerFromConfig } from "./logger-mZ9OSbmD.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import { i as getOapiAccessToken } from "./utils-CIfI_3Jh.mjs";
-import { S as finalClean, _ as FINAL_TAG, a as sendTextMessage, b as estimateTokens, d as finishAICard, g as unregisterActiveCard, h as streamAICard, i as sendProactive, m as registerActiveCard, p as isQpsLimitError, r as sendMessage, t as sendMarkdownMessage, u as createAICardForTarget, v as PROCESS_TAG, x as extractFinal, y as displayClean } from "./messaging-WleKf54h.mjs";
+import { S as finalClean, _ as FINAL_TAG, a as sendTextMessage, b as estimateTokens, d as finishAICard, g as unregisterActiveCard, h as streamAICard, i as sendProactive, m as registerActiveCard, p as isQpsLimitError, r as sendMessage, t as sendMarkdownMessage, u as createAICardForTarget, v as PROCESS_TAG, x as extractFinal, y as displayClean } from "./messaging-DVS3UKOp.mjs";
 import { a as QUEUE_BUSY_ACK_PHRASES, n as normalizeSlashCommand, t as buildSessionContext } from "./session-DJ4jYqPv.mjs";
 import { c as formatSenderRoles, f as getUserProfile, h as recallEmotionReply, l as getAccessToken, o as formatHiredDateShanghai, r as addEmotionReply, s as formatSenderDisplayLabel, t as DINGTALK_API, u as getOapiAccessToken$1 } from "./utils-legacy-DQ3HeGHh.mjs";
-import "./chunk-upload-BBQgGtcZ.mjs";
-import { a as toLocalPath, i as VIDEO_MARKER_PATTERN, o as uploadMediaToDingTalk, r as FILE_MARKER_PATTERN, t as AUDIO_MARKER_PATTERN } from "./common-DE0gd0Jg.mjs";
-import { n as lookupCardContent, t as collectCardLookupIds } from "./card-content-cache-CYUzCaQJ.mjs";
+import { r as trackBackgroundWork } from "./background-work-Cxb4b-91.mjs";
+import "./chunk-upload-BE71drPg.mjs";
+import { a as toLocalPath, i as VIDEO_MARKER_PATTERN, o as uploadMediaToDingTalk, r as FILE_MARKER_PATTERN, t as AUDIO_MARKER_PATTERN } from "./common-BZiVgd3A.mjs";
+import { n as lookupCardContent, t as collectCardLookupIds } from "./card-content-cache-bDQFz2u8.mjs";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "node:os";
@@ -261,10 +262,36 @@ function createDingtalkReplyDispatcher(params) {
 		accountId
 	});
 	const log = createLoggerFromConfig(account.config, `DingTalk:${accountId}`);
-	let currentCardTarget = null;
+	let currentCardTarget = preCreatedCard ?? null;
 	let accumulatedText = "";
 	const deliveredFinalTexts = /* @__PURE__ */ new Set();
 	let sessionClosed = false;
+	/**
+	* 群聊 fail-before-reply 时 OpenClaw 会把用户可见文案收成 NO_REPLY（静默），
+	* 但 payload 仍带 rawError/isError。normalize 会在 deliver 前丢掉整包，
+	* 导致 closeStreaming 空文本 → answerCard 误定格「思考完成」。
+	* 用 onSkip 捕获后写入此处，供 closeStreaming 定稿错误卡。
+	*/
+	let pendingErrorText = null;
+	if (preCreatedCard && !isDirect) registerActiveCard(conversationId, preCreatedCard);
+	if (preCreatedCard) log.info(`[DingTalk] 启动即挂接即时建卡 currentCardTarget=${preCreatedCard.cardInstanceId} isDirect=${isDirect}`);
+	/** 从 isError/rawError payload 提取中文错误文案（含被静默丢弃的群聊失败） */
+	const captureErrorFromPayload = (payload, source) => {
+		const p = payload;
+		if (!p) return null;
+		const raw = readPayloadRawError(p);
+		const text = typeof p.text === "string" ? p.text.trim() : "";
+		const looksSilent = !text || /^NO_REPLY$/i.test(text) || text.split(/\s+/).every((t) => /^NO_REPLY$/i.test(t));
+		let errorText = null;
+		if (raw) errorText = matchModelErrorText(raw, { includeCatchAll: true });
+		if (!errorText && p.isError && text && !looksSilent) errorText = matchModelErrorText(text, { includeCatchAll: true }) ?? text;
+		if (!errorText && (raw || p.isError)) errorText = MODEL_ERROR_GENERIC;
+		if (!errorText) return null;
+		pendingErrorText = errorText;
+		if (!accumulatedText.trim() || looksSilent) accumulatedText = errorText;
+		log.info(`[DingTalk][errorCapture] source=${source} len=${errorText.length} preview=${errorText.slice(0, 60)}`);
+		return errorText;
+	};
 	let asyncModeFullResponse = "";
 	let currentToolLine = "";
 	/**
@@ -415,10 +442,11 @@ function createDingtalkReplyDispatcher(params) {
 				}
 			}
 		};
-		streamWriteChain = streamWriteChain.then(() => runWrite(force)).catch((e) => {
+		const writePromise = streamWriteChain.then(() => runWrite(force));
+		streamWriteChain = writePromise.catch((e) => {
 			log.warn(`[DingTalk][stream] 队列任务失败（不中断后续）：${e?.message || e}`);
 		});
-		return streamWriteChain;
+		return writePromise;
 	};
 	/** 定稿前：取消尾随定时器，强制推送全文并等待队列排空 */
 	const flushCardStream = async (content, card) => {
@@ -559,8 +587,13 @@ function createDingtalkReplyDispatcher(params) {
 			clearTrailingFlush();
 			await streamWriteChain;
 			let finalText = finalClean(pickFinalText());
+			if (!finalText.trim() && pendingErrorText) {
+				finalText = pendingErrorText;
+				log.info(`[DingTalk][closeStreaming] 使用 pendingErrorText 定稿（群聊静默失败恢复），len=${finalText.length}`);
+			}
 			const hadRealAnswer = finalText.trim().length > 0;
-			log.info(`[DingTalk][closeStreaming] 最终答案来源=${finalMarkedText !== null ? "marker[-final-]" : lastAnswerText ? "非reasoning/累积取长" : "accumulatedText兜底"}，长度=${finalText.length}，lastAnswerLen=${lastAnswerText.length}，accLen=${accumulatedText.length}`);
+			const isErrorFinal = Boolean(pendingErrorText);
+			log.info(`[DingTalk][closeStreaming] 最终答案来源=${finalMarkedText !== null ? "marker[-final-]" : isErrorFinal ? "pendingErrorText" : lastAnswerText ? "非reasoning/累积取长" : "accumulatedText兜底"}，长度=${finalText.length}，lastAnswerLen=${lastAnswerText.length}，accLen=${accumulatedText.length}，isErrorFinal=${isErrorFinal}`);
 			if (!finalText.trim()) {
 				finalText = "✅ 任务执行完成（无文本输出）";
 				log.info(`[DingTalk][closeStreaming] 累积文本为空，使用默认提示文案`);
@@ -602,7 +635,7 @@ function createDingtalkReplyDispatcher(params) {
 					}
 				} else log.info(`[DingTalk][closeStreaming] 养成系统：onCommandOutput 监听到 ${productsToProcess.size} 个 dws 产品: ${[...productsToProcess].join(", ")}`);
 				if (productsToProcess.size > 0) {
-					const { GamificationEngine } = await import("./game-xiyou-CAT0ilSj.mjs");
+					const { GamificationEngine } = await import("./game-xiyou-uwsv23AC.mjs");
 					const engine = GamificationEngine.getInstanceForUser(senderId);
 					if (engine.isEnabled()) {
 						const primaryProduct = [...productsToProcess][0];
@@ -632,7 +665,15 @@ function createDingtalkReplyDispatcher(params) {
 				const answerTplId = (account.config?.answerCardTemplateId)?.trim() || "d246b7f5-1783-4e9b-bb46-bef52d63050e.schema";
 				const answerActToken = Number(account.config?.answerActToken) || 500;
 				const answerTokens = estimateTokens(finalText);
-				if (!hadRealAnswer) {
+				if (isErrorFinal) {
+					log.info(`[DingTalk][closeStreaming] answerCard 模式：错误定稿原卡（len=${finalText.length}），不建答案卡、不定格思考完成`);
+					try {
+						await flushCardStream(finalText, cardSnapshot);
+					} catch (e) {
+						log.warn(`[DingTalk][closeStreaming] 错误终稿 flush 失败（继续 FINISH）：${e?.message || e}`);
+					}
+					await finishAICard(cardSnapshot, finalText, account.config, log, void 0, void 0, conversationId);
+				} else if (!hadRealAnswer) {
 					log.info(`[DingTalk][closeStreaming] answerCard 模式：无真实答案，仅定格原卡思考完成（不建答案卡）`);
 					await finalizeOriginalToDone();
 				} else if (answerTokens <= answerActToken) {
@@ -686,14 +727,66 @@ function createDingtalkReplyDispatcher(params) {
 			accumulatedText = "";
 		}
 	};
+	/**
+	* 统一错误定稿：模型/dispatch 异常时把中文提示写到 AI Card 并 FINISHED。
+	* 供 dispatcher onError 与 message-handler catch（同步 throw）共用。
+	* 不依赖 OpenClaw 返回的 replyOptions.onError（SDK 根本不导出该字段）。
+	*/
+	const finalizeDispatchError = async (error, kind = "invoke") => {
+		const errorMsg = String(error);
+		log.error(`[DingTalk][finalizeDispatchError] kind=${kind} failed: ${errorMsg}`);
+		await startStreaming();
+		const errorText = matchModelErrorText(errorMsg, { includeCatchAll: true }) ?? "⚠️ 模型请求异常，请稍后重试";
+		log.warn(`[DingTalk][finalizeDispatchError] 错误提示: ${errorText.slice(0, 80)}`);
+		pendingErrorText = errorText;
+		accumulatedText = errorText;
+		if (!currentCardTarget && !sessionClosed) if (preCreatedCard) try {
+			currentCardTarget = preCreatedCard;
+			if (!isDirect) registerActiveCard(conversationId, preCreatedCard);
+			log.info(`[DingTalk][finalizeDispatchError] 复用即时建卡显示错误（cardInstanceId=${preCreatedCard.cardInstanceId}）`);
+		} catch (cardErr) {
+			log.warn(`[DingTalk][finalizeDispatchError] 复用即时建卡失败：${cardErr.message}，降级发送普通消息`);
+			try {
+				await sendMessage(account.config, sessionWebhook, accumulatedText, {
+					useMarkdown: false,
+					log: params.runtime.log
+				});
+			} catch (sendErr) {
+				log.error(`[DingTalk][finalizeDispatchError] 降级发送普通消息失败：${sendErr.message}`);
+			}
+		}
+		else {
+			log.warn(`[DingTalk][finalizeDispatchError] 无可用 AI Card，降级发送普通消息`);
+			try {
+				await sendMessage(account.config, sessionWebhook, accumulatedText, {
+					useMarkdown: false,
+					log: params.runtime.log
+				});
+			} catch (sendErr) {
+				log.error(`[DingTalk][finalizeDispatchError] 降级发送普通消息失败：${sendErr.message}`);
+			}
+		}
+		await closeStreaming();
+	};
 	const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
 		...prefixOptions,
 		humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
+		onSkip: (payload, info) => {
+			const raw = readPayloadRawError(payload);
+			const isErr = Boolean(payload?.isError);
+			if (!raw && !isErr) {
+				log.info(`[DingTalk][onSkip] kind=${info?.kind} reason=${info?.reason} 非错误静默（NO_REPLY/empty），跳过错误捕获`);
+				return;
+			}
+			log.warn(`[DingTalk][onSkip] kind=${info?.kind} reason=${info?.reason} isError=${isErr} rawLen=${raw.length}（群聊静默失败常见）`);
+			captureErrorFromPayload(payload, `onSkip:${info?.kind ?? "?"}:${info?.reason ?? "?"}`);
+		},
 		onReplyStart: () => {
 			log.info(`[DingTalk][onReplyStart] 开始回复，流式 enabled=${streamingEnabled}`);
 			deliveredFinalTexts.clear();
 			finalMarkedText = null;
 			lastAnswerText = "";
+			pendingErrorText = null;
 			processMarkerLogged = false;
 			finalMarkerLogged = false;
 			markerSystemActive = false;
@@ -710,6 +803,7 @@ function createDingtalkReplyDispatcher(params) {
 			let text = payload.text ?? "";
 			const rawError = readPayloadRawError(payload);
 			if (rawError) {
+				captureErrorFromPayload(payload, `deliver:${info?.kind ?? "?"}`);
 				const matchedErrorText = matchModelErrorText(rawError, { includeCatchAll: true });
 				if (matchedErrorText) {
 					log.warn(`[DingTalk][deliver] 检测到上游 rawError，替换为中文提示（raw=${rawError.slice(0, 120)}）`);
@@ -720,14 +814,22 @@ function createDingtalkReplyDispatcher(params) {
 			observeReply(payload.text, payload);
 			await startStreaming();
 			if (isNonAnswerPayload(payload)) {
+				const isModelErrorFinal = Boolean(payload.isError) && info?.kind === "final" && Boolean(text.trim());
+				if (isModelErrorFinal) {
+					accumulatedText = text;
+					log.info(`[DingTalk][deliver] 将上游异常 final 文本存入 accumulatedText（len=${text.length}），防止 onIdle 覆盖`);
+				} else if (payload.isError && !accumulatedText.trim() && text.trim()) {
+					accumulatedText = text;
+					log.info(`[DingTalk][deliver] 将上游异常 payload 文本存入 accumulatedText（len=${text.length}），防止 onIdle 覆盖`);
+				}
 				if (streamingEnabled && currentCardTarget && !asyncMode && finalMarkedText === null) try {
-					await enqueueCardStream(displayClean(text));
+					await enqueueCardStream(displayClean(text), { force: isModelErrorFinal });
 				} catch (e) {
 					if (!isQpsLimitError(e)) log.warn(`[DingTalk][deliver] 状态/错误 payload 写卡失败：${e?.message || e}`);
 				}
-				if (payload.isError && !accumulatedText.trim() && text.trim()) {
-					accumulatedText = text;
-					log.info(`[DingTalk][deliver] 将上游异常 payload 文本存入 accumulatedText（len=${text.length}），防止 onIdle 覆盖`);
+				if (isModelErrorFinal) {
+					log.info(`[DingTalk][deliver] 上游 isError final，主动 closeStreaming 定稿错误卡`);
+					await closeStreaming();
 				}
 				log.info(`[DingTalk][deliver] 非答案 payload（isError=${payload.isError},isStatusNotice=${payload.isStatusNotice}），仅展示不计入最终答案`);
 				return;
@@ -838,40 +940,9 @@ function createDingtalkReplyDispatcher(params) {
 			}
 		},
 		onError: async (error, info) => {
-			const errorMsg = String(error);
-			log.error(`[DingTalk][onError] ${info.kind} reply failed: ${errorMsg}`);
-			params.runtime.error?.(`dingtalk[${account.accountId}] ${info.kind} reply failed: ${errorMsg}`);
-			await startStreaming();
-			const errorText = matchModelErrorText(errorMsg, { includeCatchAll: true }) ?? "⚠️ 模型请求异常，请稍后重试";
-			log.warn(`[DingTalk][onError] 错误提示: ${errorText.slice(0, 80)}`);
-			if (!accumulatedText.trim()) accumulatedText = errorText;
-			if (!currentCardTarget && !sessionClosed) if (preCreatedCard) try {
-				currentCardTarget = preCreatedCard;
-				if (!isDirect) registerActiveCard(conversationId, preCreatedCard);
-				log.info(`[DingTalk][onError] 复用即时建卡显示错误（cardInstanceId=${preCreatedCard.cardInstanceId}）`);
-			} catch (cardErr) {
-				log.warn(`[DingTalk][onError] 复用即时建卡失败：${cardErr.message}，降级发送普通消息`);
-				try {
-					await sendMessage(account.config, sessionWebhook, accumulatedText, {
-						useMarkdown: false,
-						log: params.runtime.log
-					});
-				} catch (sendErr) {
-					log.error(`[DingTalk][onError] 降级发送普通消息失败：${sendErr.message}`);
-				}
-			}
-			else {
-				log.warn(`[DingTalk][onError] 卡片已关闭且无即时建卡，降级发送普通消息`);
-				try {
-					await sendMessage(account.config, sessionWebhook, accumulatedText, {
-						useMarkdown: false,
-						log: params.runtime.log
-					});
-				} catch (sendErr) {
-					log.error(`[DingTalk][onError] 降级发送普通消息失败：${sendErr.message}`);
-				}
-			}
-			await closeStreaming();
+			log.error(`[DingTalk][onError] ${info.kind} reply failed: ${String(error)}`);
+			params.runtime.error?.(`dingtalk[${account.accountId}] ${info.kind} reply failed: ${String(error)}`);
+			await finalizeDispatchError(error, info.kind);
 			typingCallbacks.onIdle?.();
 		},
 		onIdle: async () => {
@@ -905,7 +976,7 @@ function createDingtalkReplyDispatcher(params) {
 					currentToolLine = "";
 					await startStreaming();
 					if (currentCardTarget) try {
-						const { FILE_MARKER_PATTERN, VIDEO_MARKER_PATTERN, AUDIO_MARKER_PATTERN } = await import("./common-B_A78n8u.mjs");
+						const { FILE_MARKER_PATTERN, VIDEO_MARKER_PATTERN, AUDIO_MARKER_PATTERN } = await import("./common-DgL28gCZ.mjs");
 						await enqueueCardStream(buildCardContent().replace(FILE_MARKER_PATTERN, "").replace(VIDEO_MARKER_PATTERN, "").replace(AUDIO_MARKER_PATTERN, "").trim(), { force: true });
 					} catch (err) {
 						if (!isQpsLimitError(err)) log.error(`[DingTalk][onPartialReply] final-marker 刷卡失败：${err.message}`);
@@ -918,7 +989,7 @@ function createDingtalkReplyDispatcher(params) {
 					if (payload.text?.trim()) hasModelStreamText = true;
 					currentToolLine = "";
 					try {
-						const { FILE_MARKER_PATTERN, VIDEO_MARKER_PATTERN, AUDIO_MARKER_PATTERN } = await import("./common-B_A78n8u.mjs");
+						const { FILE_MARKER_PATTERN, VIDEO_MARKER_PATTERN, AUDIO_MARKER_PATTERN } = await import("./common-DgL28gCZ.mjs");
 						await enqueueCardStream(buildCardContent().replace(FILE_MARKER_PATTERN, "").replace(VIDEO_MARKER_PATTERN, "").replace(AUDIO_MARKER_PATTERN, "").trim());
 					} catch (err) {
 						if (isQpsLimitError(err)) log.warn(`[DingTalk][onPartialReply] QPS 限流，已排队尾随重试 latestLen=${latestCardContent.length}`);
@@ -957,12 +1028,20 @@ function createDingtalkReplyDispatcher(params) {
 			}
 		},
 		markDispatchIdle,
-		getAsyncModeResponse: () => asyncModeFullResponse
+		getAsyncModeResponse: () => asyncModeFullResponse,
+		/** 同步 dispatch 异常时由 message-handler catch 调用，统一 finish 错误卡 */
+		finalizeDispatchError
 	};
 }
 //#endregion
 //#region src/core/message-handler.ts
 /**
+* 单条会话队列任务最长执行时间。
+* 503 重试 + 工具循环偶发挂死时，若不超时，后续同会话消息会永远堵在 previousTask 上，
+* 表现：连发多条「网关没反应 / 不贴表情」（表情在排队 ACK 或 dequeued 后才贴）。
+*/
+const SESSION_QUEUE_TASK_TIMEOUT_MS = 180 * 1e3;
+/**
 * 会话消息队列管理
 * 用于确保同一会话+agent的消息按顺序处理，避免并发冲突导致AI返回空响应
 * 队列键格式：{sessionId}:{agentId}
@@ -1926,7 +2005,7 @@ async function handleDingTalkMessageInternal(params) {
 	const rawText = content.text || "";
 	let userContent = normalizeSlashCommand(rawText) || (content.imageUrls.length > 0 ? "请描述这张图片" : "");
 	try {
-		const { GamificationEngine, isGamificationCommand } = await import("./game-xiyou-CAT0ilSj.mjs");
+		const { GamificationEngine, isGamificationCommand } = await import("./game-xiyou-uwsv23AC.mjs");
 		if (isGamificationCommand(rawText)) {
 			const engine = GamificationEngine.getInstanceForUser(senderId);
 			if (rawText.trim().startsWith("/西游") || engine.isEnabled()) {
@@ -2100,6 +2179,8 @@ async function handleDingTalkMessageInternal(params) {
 			log?.warn?.(`Failed to send acknowledgment: ${ackErr?.message || ackErr}`);
 		}
 	}
+	let earlyCard = params.preCreatedCard;
+	let finalizeDispatchError;
 	try {
 		const core = getDingtalkRuntime();
 		let finalContent = userContent;
@@ -2165,7 +2246,6 @@ async function handleDingTalkMessageInternal(params) {
 		});
 		const groupReplyModeForCard = config.groupReplyMode || "aicard";
 		const streamingEnabledForCard = !(!isDirect && (groupReplyModeForCard === "text" || groupReplyModeForCard === "markdown")) && config.streaming !== false;
-		let earlyCard = params.preCreatedCard;
 		if (!earlyCard && streamingEnabledForCard && !asyncMode) try {
 			earlyCard = await createAICardForTarget(config, isDirect ? {
 				type: "user",
@@ -2183,7 +2263,7 @@ async function handleDingTalkMessageInternal(params) {
 			log.warn(`[DingTalk][earlyCard] 即时建卡失败（降级延迟建卡）：${e?.message}`);
 			earlyCard = void 0;
 		}
-		const { dispatcher, replyOptions, markDispatchIdle, getAsyncModeResponse } = createDingtalkReplyDispatcher({
+		const { dispatcher, replyOptions, markDispatchIdle, getAsyncModeResponse, finalizeDispatchError: finalizeErr } = createDingtalkReplyDispatcher({
 			cfg,
 			agentId: matchedAgentId,
 			runtime,
@@ -2196,6 +2276,7 @@ async function handleDingTalkMessageInternal(params) {
 			asyncMode,
 			preCreatedCard: earlyCard
 		});
+		finalizeDispatchError = finalizeErr;
 		if (config.clientId) {
 			const botIdentityHint = `[DingTalk Bot Context] Current bot clientId: ${String(config.clientId)}. When executing \`dws chat message send-by-bot\`, always pass \`--client-id ${String(config.clientId)}\` to ensure messages are sent from the correct bot.`;
 			finalContent = finalContent ? `${finalContent}\n\n${botIdentityHint}` : botIdentityHint;
@@ -2265,28 +2346,42 @@ async function handleDingTalkMessageInternal(params) {
 		}
 	} catch (err) {
 		log?.error?.(`SDK dispatch 失败: ${err.message}`);
-		const errorText = matchModelErrorText(err.message, { includeCatchAll: true }) ?? `⚠️ 抱歉，处理请求时出错: ${err.message}`;
-		if (earlyCard) try {
-			await streamAICard(earlyCard, errorText, true, config, log);
-		} catch (cardErr) {
-			log?.error?.(`更新错误卡片失败: ${cardErr.message}`);
+		if (finalizeDispatchError) try {
+			log?.info?.(`[DingTalk] 统一错误定稿：调用 finalizeDispatchError 处理同步异常`);
+			await finalizeDispatchError(err, "invoke");
+		} catch (finalizeErr) {
+			log?.error?.(`[DingTalk] finalizeDispatchError 失败: ${finalizeErr?.message || finalizeErr}`);
 		}
-		else try {
-			const token = await getAccessToken(config);
-			const body = {
-				msgtype: "text",
-				text: { content: errorText }
-			};
-			if (!isDirect) body.at = {
-				atUserIds: [senderId],
-				isAtAll: false
-			};
-			await dingtalkHttp.post(sessionWebhook, body, { headers: {
-				"x-acs-dingtalk-access-token": token,
-				"Content-Type": "application/json"
-			} });
-		} catch (fallbackErr) {
-			log?.error?.(`错误消息发送也失败: ${fallbackErr.message}`);
+		else {
+			const errorText = matchModelErrorText(err.message, { includeCatchAll: true }) ?? `⚠️ 抱歉，处理请求时出错: ${err.message}`;
+			let cardSuccess = false;
+			if (earlyCard) try {
+				await finishAICard(earlyCard, errorText, config, log, void 0, void 0, data.conversationId);
+				cardSuccess = true;
+				log?.info?.(`[DingTalk] 极端兜底：finishAICard 错误卡成功`);
+			} catch (cardErr) {
+				log?.error?.(`更新错误卡片失败: ${cardErr.message}`);
+			}
+			if (!cardSuccess) {
+				log?.warn?.(`[DingTalk] 无可用错误定稿路径，走纯文本发送`);
+				try {
+					const token = await getAccessToken(config);
+					const body = {
+						msgtype: "text",
+						text: { content: errorText }
+					};
+					if (!isDirect) body.at = {
+						atUserIds: [senderId],
+						isAtAll: false
+					};
+					await dingtalkHttp.post(sessionWebhook, body, { headers: {
+						"x-acs-dingtalk-access-token": token,
+						"Content-Type": "application/json"
+					} });
+				} catch (fallbackErr) {
+					log?.error?.(`错误消息发送也失败: ${fallbackErr.message}`);
+				}
+			}
 		}
 	}
 	try {
@@ -2334,54 +2429,33 @@ async function handleDingTalkMessage(params) {
 	const queueKey = `${baseSessionId}:${matchedAgentId}`;
 	try {
 		sessionLastActivity.set(queueKey, Date.now());
-		const isQueueBusy = sessionQueues.has(queueKey);
 		const previousTask = sessionQueues.get(queueKey) || Promise.resolve();
-		let preCreatedCard;
-		if (isQueueBusy) {
-			const ackPhrases = QUEUE_BUSY_ACK_PHRASES;
-			const ackText = ackPhrases[Math.floor(Math.random() * ackPhrases.length)];
-			const groupReplyMode = config.groupReplyMode || "aicard";
-			if (!isDirect && (groupReplyMode === "text" || groupReplyMode === "markdown")) try {
-				await sendProactive(config, { openConversationId: data.conversationId }, ackText, {
-					msgType: "text",
-					useAICard: false,
-					fallbackToNormal: true
-				});
-				log?.info?.(`[队列] 队列繁忙，已发送普通文本 ACK（groupReplyMode=${groupReplyMode}）`);
-			} catch (ackErr) {
-				log?.warn?.(`[队列] 发送普通 ACK 失败: ${ackErr?.message || ackErr}`);
+		const isQueueBusy = sessionQueues.has(queueKey);
+		const cardHolder = {
+			card: void 0,
+			ackDone: !isQueueBusy
+		};
+		const currentTask = previousTask.then(async () => {
+			log?.info?.(`[队列] 开始处理消息，queueKey=${queueKey} wasBusy=${isQueueBusy} timeoutMs=${SESSION_QUEUE_TASK_TIMEOUT_MS}`);
+			if (isQueueBusy && !cardHolder.ackDone) {
+				const waitStart = Date.now();
+				while (!cardHolder.ackDone && Date.now() - waitStart < 2e3) await new Promise((r) => setTimeout(r, 50));
 			}
-			else {
-				const cardTarget = isDirect ? {
-					type: "user",
-					userId: senderId
-				} : {
-					type: "group",
-					openConversationId: data.conversationId
-				};
-				try {
-					const card = await createAICardForTarget(config, cardTarget, log);
-					if (card) {
-						await streamAICard(card, ackText, false, config, log);
-						preCreatedCard = card;
-						log?.info?.(`[队列] 队列繁忙，已创建排队 ACK Card，cardInstanceId=${card.cardInstanceId}`);
-					} else log?.warn?.(`[队列] 创建排队 ACK Card 失败（返回 null），跳过 ACK`);
-					addEmotionReply(config, data, log).catch((err) => {
-						log?.warn?.(`[队列] 贴排队表情失败: ${err.message}`);
-					});
-				} catch (ackErr) {
-					log?.warn?.(`[队列] 创建排队 ACK Card 异常: ${ackErr?.message || ackErr}`);
-				}
+			let timeoutId;
+			try {
+				await Promise.race([handleDingTalkMessageInternal({
+					...params,
+					preCreatedCard: cardHolder.card,
+					emotionAlreadyAdded: true
+				}), new Promise((_, reject) => {
+					timeoutId = setTimeout(() => {
+						reject(/* @__PURE__ */ new Error(`会话队列任务超时（${SESSION_QUEUE_TASK_TIMEOUT_MS}ms），释放队列以免堵死后续消息`));
+					}, SESSION_QUEUE_TASK_TIMEOUT_MS);
+				})]);
+				log?.info?.(`[队列] 消息处理完成，queueKey=${queueKey}`);
+			} finally {
+				if (timeoutId !== void 0) clearTimeout(timeoutId);
 			}
-		}
-		const currentTask = previousTask.then(async () => {
-			log?.info?.(`[队列] 开始处理消息，queueKey=${queueKey}`);
-			await handleDingTalkMessageInternal({
-				...params,
-				preCreatedCard,
-				emotionAlreadyAdded: isQueueBusy
-			});
-			log?.info?.(`[队列] 消息处理完成，queueKey=${queueKey}`);
 		}).catch((err) => {
 			log?.error?.(`[队列] 消息处理异常，queueKey=${queueKey}, error=${err.message}`);
 		}).finally(() => {
@@ -2391,9 +2465,51 @@ async function handleDingTalkMessage(params) {
 			}
 		});
 		sessionQueues.set(queueKey, currentTask);
+		trackBackgroundWork(currentTask, queueKey);
+		log?.info?.(`[队列] 已登记 queueKey=${queueKey} busy=${isQueueBusy} depth≈pending`);
+		addEmotionReply(config, data, log).catch((err) => {
+			log?.warn?.(`[队列] 即时贴表情失败: ${err?.message || err}`);
+		});
+		if (isQueueBusy) {
+			const ackPhrases = QUEUE_BUSY_ACK_PHRASES;
+			const ackText = ackPhrases[Math.floor(Math.random() * ackPhrases.length)];
+			const groupReplyMode = config.groupReplyMode || "aicard";
+			const skipAICard = !isDirect && (groupReplyMode === "text" || groupReplyMode === "markdown");
+			(async () => {
+				try {
+					if (skipAICard) {
+						await sendProactive(config, { openConversationId: data.conversationId }, ackText, {
+							msgType: "text",
+							useAICard: false,
+							fallbackToNormal: true
+						});
+						log?.info?.(`[队列] 队列繁忙，已发送普通文本 ACK（groupReplyMode=${groupReplyMode}）`);
+					} else {
+						const card = await createAICardForTarget(config, isDirect ? {
+							type: "user",
+							userId: senderId
+						} : {
+							type: "group",
+							openConversationId: data.conversationId
+						}, log);
+						if (card) {
+							await streamAICard(card, ackText, false, config, log);
+							cardHolder.card = card;
+							log?.info?.(`[队列] 队列繁忙，已创建排队 ACK Card，cardInstanceId=${card.cardInstanceId}`);
+						} else log?.warn?.(`[队列] 创建排队 ACK Card 失败（返回 null）`);
+					}
+				} catch (ackErr) {
+					log?.warn?.(`[队列] 繁忙 ACK 异常: ${ackErr?.message || ackErr}`);
+				} finally {
+					cardHolder.ackDone = true;
+				}
+			})();
+		}
 	} catch (err) {
 		log?.error?.(`[队列] 队列管理异常，直接处理: ${err.message}`);
-		handleDingTalkMessageInternal(params);
+		trackBackgroundWork(handleDingTalkMessageInternal(params).catch((e) => {
+			log?.error?.(`[队列] 直接处理也失败: ${e.message}`);
+		}), "queue-fallback");
 	}
 }
 //#endregion

package/dist/{messaging-WleKf54h.mjs → messaging-DVS3UKOp.mjs}

@@ -371,7 +371,7 @@ async function finishAICard(card, content, config, log, contentVar, skipInputing
 	const fixedContent = ensureTableBlankLines(cleanContent);
 	log?.info?.(`[DingTalk][AICard] 开始 finish（一次性定稿，无流式回放），最终内容长度=${fixedContent.length}`);
 	try {
-		const { rememberCardContent } = await import("./card-content-cache-Dwd8HICP.mjs");
+		const { rememberCardContent } = await import("./card-content-cache-c4Ls96eJ.mjs");
 		rememberCardContent({
 			text: fixedContent,
 			outTrackId: card.cardInstanceId,
@@ -429,8 +429,12 @@ async function finishAICard(card, content, config, log, contentVar, skipInputing
 				return;
 			} catch (retryErr) {
 				log?.error?.(`[DingTalk][AICard] FINISHED 重试失败：${retryErr.message}`);
+				throw retryErr;
 			}
-		} else log?.error?.(`[DingTalk][AICard] FINISHED 更新失败：${err.message}`);
+		} else {
+			log?.error?.(`[DingTalk][AICard] FINISHED 更新失败：${err.message}`);
+			throw err;
+		}
 	}
 }
 //#endregion

package/dist/{runtime-DzZo6Gvk.mjs → runtime-A6G7WAWn.mjs}

@@ -3,7 +3,7 @@ import { a as resolveDingtalkAccount, c as addWildcardAllowFrom, d as hasConfigu
 import { t as createLogger } from "./logger-mZ9OSbmD.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import "./utils-CIfI_3Jh.mjs";
-import { S as finalClean, f as getActiveCardForConversation, n as sendMediaToDingTalk, o as sendTextToDingTalk } from "./messaging-WleKf54h.mjs";
+import { S as finalClean, f as getActiveCardForConversation, n as sendMediaToDingTalk, o as sendTextToDingTalk } from "./messaging-DVS3UKOp.mjs";
 import { createRequire } from "node:module";
 import { z, z as z$1 } from "zod";
 //#region src/secret-input.ts
@@ -955,8 +955,8 @@ async function monitorDingtalkProvider(opts = {}) {
 	const log = createLogger(cfg.channels?.["dingtalk-connector"]?.debug ?? false);
 	const [accountsModule, monitorAccountModule, monitorSingleModule] = await Promise.all([
 		import("./accounts-BQptOmgB.mjs"),
-		import("./message-handler-DQZiKx3i.mjs"),
-		import("./connection-fc6B4z4G.mjs")
+		import("./message-handler-B1usz1wb.mjs"),
+		import("./connection-CZ7ZoN5_.mjs")
 	]);
 	const { resolveDingtalkAccount, listEnabledDingtalkAccounts } = accountsModule;
 	const { handleDingTalkMessage } = monitorAccountModule;

package/docs/RELEASE_NOTES_V0.8.28.md

@@ -0,0 +1,56 @@
+# Release Notes · v0.8.28
+
+**发布日期：** 2026-07-25  
+**npm：** `@jeik/dingtalk-connector@0.8.28`  
+**定位：** 基于官方 **0.8.24** 的社区增强正式版
+
+---
+
+## 一句话
+
+连接更稳、消息更少丢、模型出错时提示更清楚；官方 0.8.24 的长连接改进已吸收，社区图片/答案卡等增强继续保留。
+
+---
+
+## 基于官方 0.8.24 做了什么
+
+- 吸收官方对长连接的稳定性改进（少假死、少误重连）
+- 长任务处理期间连接更不容易被中途打断
+- 日志更干净，方便运维判断「是不是真坏了」
+
+未合入：官方给其他插件调用的「卡片开放接口」（对话主流程不需要）。
+
+---
+
+## 社区额外优化（效果）
+
+1. **真正能收消息才显示已连接** — 减少「显示在线、发了没反应」  
+2. **连发 / 错误后 / 刚回完再发** — 消息进网关的成功率明显提高  
+3. **上一条还在跑时再发** — 更容易马上看到排队提示和思考中表情  
+4. **模型 503、欠费、无可用线路等** — 更容易定格成中文错误说明，少卡转圈  
+5. **原有社区能力** — 大段答案独立卡片、图片全路径、中文错误映射等均保留  
+
+---
+
+## 安装
+
+```bash
+npx -y @jeik/dingtalk-connector@0.8.28 install --force
+openclaw gateway restart
+```
+
+或：
+
+```bash
+openclaw plugins install @jeik/dingtalk-connector@0.8.28 --force
+openclaw gateway restart
+```
+
+---
+
+## 建议验收
+
+1. 启动后日志出现「订阅已生效 / registered」类成功信息后再发消息  
+2. 正常对话：先「召唤大模型」再流式/答案卡  
+3. 故意用故障模型：应定格中文错误，而不是一直转圈  
+4. 任务进行中再发一条：应较快出现排队/处理中反馈  

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jeik/dingtalk-connector",
-  "version": "0.8.27",
-  "description": "OpenClaw DingTalk channel plugin (fork) | 钉钉 OpenClaw 渠道插件（fork 自官方，含标记/卡片渲染修复）",
+  "version": "0.8.28",
+  "description": "OpenClaw DingTalk channel plugin (community) | 钉钉 OpenClaw 社区增强版（基于官方 0.8.24，长连接与消息体验增强）",
   "type": "module",
   "exports": {
     ".": {