@xgjktech/xg_cwork_im 1.19.41 → 1.19.43

package/dist/src/dispatch-mentioned-reply.js

@@ -0,0 +1,822 @@
+/**
+ * @ 触发的单轮回复：WebSocket BEGIN、OpenClaw dispatchReplyWithBufferedBlockDispatcher、HTTP deliver、RUN_USAGE、FINISHED。
+ */
+import { isImSingleChat, resolveSendMessageReply } from "./inbound-chat-type.js";
+import { buildTerminalSendFn, InboundTerminalController, } from "./inbound-terminal-delivery.js";
+import { formatConfirmedUpstreamErrorForIm } from "./user-facing-errors.js";
+import { shouldOmitDuplicateFileCaption, shouldSuppressDuplicateTextDeliver, stripMediaDirectiveLines, stripModelUsageFooter, } from "./deliver-text.js";
+import { shouldSuppressFallbackNoticeForIm } from "./per-message-fallback-notice.js";
+import { resolveThinkingWsDisplayUpdate, THINKING_WS_SUMMARY_HINT, ThinkingWsBuffer, WS_THINKING_DISPLAY_MAX, } from "./thinking-ws-progress.js";
+import { resolveItemEventGuard } from "./item-event-guard.js";
+import { clearPendingPerMessageModel, setPendingPerMessageModel, splitModelRef, } from "./per-message-model-pending.js";
+import { IM_BLOCK_STREAMING_COALESCE_DEFAULT, isDeliverPartialSnapshotEnabled, isDeliverSegmentBufferEnabled, isInboundBlockStreamingEnabled, resolveBlockStreamingReplyOptions, resolveDispatchOpenClawCfg, } from "./channel-config.js";
+import { sendReplyDeliverBlock, sendTextMessage } from "./send-service.js";
+import { isDeliverPayloadSendable, snapshotSupersedesBufferText, TurnDeliverBuffer } from "./turn-deliver-buffer.js";
+import { buildRunUsageFromSessionEntry, hasReportableUsage, toImStreamRunUsageData } from "./run-usage.js";
+import { readSessionUsageFields } from "./run-usage-session.js";
+import { hasActiveSubagents, deferFinished } from "./subagent-monitor.js";
+import { registerPlanWsClientAndSnapshot } from "./plan-stat-event.js";
+import { setSessionImContext } from "./session-im-context.js";
+import { completeActiveRound, registerActiveRound, } from "./active-round-registry.js";
+import { resolveNasVolumeDispatchConfig } from "./nas-volumes.js";
+/** WS `displayText` 过长封顶（避免网关/客户端溢出） */
+const WS_DISPLAY_TEXT_MAX = 200;
+/** 进度 `summary` 封顶（与网关约定一致） */
+const WS_PROGRESS_SUMMARY_MAX = 200;
+/** 流式正文预览（onPartialReply 快照）经 WS 展示的封顶长度 */
+const WS_REPLY_PREVIEW_MAX = 2000;
+/** 流式正文预览 WS 推送最小间隔（节流，避免 ~13 次/秒刷屏） */
+const WS_REPLY_PREVIEW_MIN_INTERVAL_MS = 500;
+/** 流式正文预览的 WS summary 标记（客户端据此更新同一输出位；定稿 HTTP 后清草稿） */
+const WS_REPLY_PREVIEW_SUMMARY = "reply_preview";
+function clipWsDisplayText(text, max = WS_DISPLAY_TEXT_MAX) {
+    const t = text.trim();
+    if (!t)
+        return "";
+    if (t.length <= max)
+        return t;
+    return `${t.slice(0, Math.max(0, max - 1))}…`;
+}
+function clipWsProgressSummary(text, max = WS_PROGRESS_SUMMARY_MAX) {
+    const t = text.trim().replace(/\r\n/g, "\n").replace(/\n+/g, " ");
+    if (!t)
+        return "";
+    if (t.length <= max)
+        return t;
+    return `${t.slice(0, Math.max(0, max - 1))}…`;
+}
+/** 流式 BEGIN → dispatch → 可选 RUN_USAGE → 必发 FINISHED；首包超时仅日志（不对 IM 发超时话术） */
+export async function dispatchMentionedReply(args) {
+    const { accountId, rt, cfg, config, log, logPrefix, route, inboundCtx, params, currentIdentity, streamClient, agentWorkspaceDir, nasVolumes, modelOverride, thinkingLevelOverride, autoRouteMeta, inboundTrigger, isStopControl = false } = args;
+    const terminal = new InboundTerminalController({
+        messageId: params.msgId,
+        groupId: params.groupId,
+        sessionKey: route.sessionKey,
+        trigger: inboundTrigger ?? "user",
+        log,
+        logPrefix,
+    });
+    const replyMetaForSend = resolveSendMessageReply(params);
+    const terminalSend = buildTerminalSendFn({
+        isSingleChat: isImSingleChat(params),
+        replyMeta: replyMetaForSend,
+        sendText: async (text, reply) => {
+            await sendTextMessage(config, currentIdentity.token, params.groupId, text, reply ? [reply.targetUserId] : [], log, undefined, reply);
+        },
+    });
+    log.info(`${logPrefix} [dispatch] Dispatching to OpenClaw AI, sessionKey=${route.sessionKey}`);
+    if (modelOverride) {
+        log.info(`${logPrefix} [model] per-message override requested: ${modelOverride}`);
+    }
+    if (autoRouteMeta) {
+        log.info(`${logPrefix} [route] dispatch version=${autoRouteMeta.version} tier=${autoRouteMeta.tier} ` +
+            `reason=${autoRouteMeta.reason} requestedModel=${modelOverride ?? "(none)"} ` +
+            `requestedThinking=${thinkingLevelOverride ?? "(default)"}`);
+    }
+    let isFirstReply = true;
+    let subagentNotificationSent = false;
+    const dispatchStart = Date.now();
+    const replyAnchorId = params.msgId.trim();
+    const progressGroupId = params.groupId;
+    const toolNameStack = [];
+    const notifyStreamProgress = async (event, displayText, summary, displayMax = WS_DISPLAY_TEXT_MAX) => {
+        if (isStopControl)
+            return;
+        const msg = clipWsDisplayText(displayText, displayMax);
+        const sum = summary?.trim() ? clipWsProgressSummary(summary) : undefined;
+        if (!progressGroupId.trim() || !replyAnchorId || !msg)
+            return;
+        try {
+            await streamClient.streamProgress({
+                groupId: progressGroupId,
+                replyToMsgId: replyAnchorId,
+                event,
+                displayText: msg,
+                ...(sum ? { summary: sum } : {}),
+            });
+        }
+        catch (e) {
+            log.warn(`${logPrefix} [stream] ${event} notify failed: ${String(e)}`);
+        }
+    };
+    const thinkingWsBuffer = new ThinkingWsBuffer();
+    let lastThinkingWsDisplay = "";
+    const flushThinkingWsOnce = async (reason) => {
+        const text = thinkingWsBuffer.take();
+        if (!text)
+            return;
+        const { displayText, changed } = resolveThinkingWsDisplayUpdate(lastThinkingWsDisplay, text);
+        if (!changed)
+            return;
+        lastThinkingWsDisplay = displayText;
+        await notifyStreamProgress("RUN_EVENT", displayText, THINKING_WS_SUMMARY_HINT, WS_THINKING_DISPLAY_MAX);
+        log.info(`${logPrefix} [stream] Thinking WS once (${reason}) len=${displayText.length}`);
+    };
+    let hasFirstReply = false;
+    let agentRunStarted = false;
+    let dispatchInFlight = false;
+    const firstReplyTimeoutMs = config.firstReplyTimeoutMs ?? 30 * 60_000;
+    const resolveFirstReplyTimeoutCause = () => {
+        if (!agentRunStarted)
+            return "never_started";
+        if (dispatchInFlight)
+            return "in_progress";
+        return "ended_without_http_reply";
+    };
+    const timeoutLabel = `${logPrefix} [stream] First reply timeout after ${firstReplyTimeoutMs}ms`;
+    const firstReplyTimeout = setTimeout(() => {
+        if (hasFirstReply)
+            return;
+        const timeoutCause = resolveFirstReplyTimeoutCause();
+        terminal.markTimeoutFired();
+        log.warn(`${timeoutLabel} cause=${timeoutCause} agentRunStarted=${agentRunStarted} ` +
+            `dispatchInFlight=${dispatchInFlight} (no IM timeout notice; channel timer ≠ OpenClaw terminal)`);
+    }, firstReplyTimeoutMs);
+    let deliverInvokeCount = 0;
+    let deliverCallCount = 0;
+    let deliverSkippedCount = 0;
+    let lastDeliveredText = "";
+    let lastDeliveredHadMedia = false;
+    let agentRunId;
+    let dispatchError = undefined;
+    let lastDeliverError = undefined;
+    let dispatchResult;
+    const blockStreamingEnabled = isInboundBlockStreamingEnabled(config);
+    const segmentBufferEnabled = blockStreamingEnabled && isDeliverSegmentBufferEnabled(config);
+    const segmentBuffer = segmentBufferEnabled ? new TurnDeliverBuffer() : undefined;
+    let hasBufferedSendable = false;
+    let flushSegmentBuffer = async () => { };
+    // —— onPartialReply 全量快照：当前 tool 区间内正文的权威来源 ——
+    // text 是「当前 assistant 消息」的完整快照（非增量）；tool 边界 / 轮末 flush 时用它覆盖
+    // deliver 拼接文本，消除段缓冲对「覆盖 vs 追加」的启发式猜测（CO2）。
+    const partialSnapshotEnabled = segmentBufferEnabled && isDeliverPartialSnapshotEnabled(config);
+    let segmentSnapshotText = "";
+    let segmentSnapshotHadPartial = false;
+    // WS 正文预览节流状态
+    let lastReplyPreviewAt = 0;
+    let lastReplyPreviewText = "";
+    // 观测统计（保留少量，便于线上核对）
+    let partialReplyCount = 0;
+    let partialReplyMaxTextLen = 0;
+    let partialReplyFirstAt = 0;
+    const resetSegmentSnapshot = () => {
+        segmentSnapshotText = "";
+        segmentSnapshotHadPartial = false;
+        lastReplyPreviewText = "";
+    };
+    const emitReplyPreviewWs = async (snapshot, force) => {
+        const text = snapshot.trim();
+        if (!text)
+            return;
+        const now = Date.now();
+        if (!force && now - lastReplyPreviewAt < WS_REPLY_PREVIEW_MIN_INTERVAL_MS)
+            return;
+        const clipped = clipWsDisplayText(text, WS_REPLY_PREVIEW_MAX);
+        if (clipped === lastReplyPreviewText)
+            return;
+        lastReplyPreviewAt = now;
+        lastReplyPreviewText = clipped;
+        await notifyStreamProgress("RUN_EVENT", clipped, WS_REPLY_PREVIEW_SUMMARY, WS_REPLY_PREVIEW_MAX);
+    };
+    const postHttpDeliver = async (args) => {
+        const { payloadForSend, textPart, sendLabel, invokeNum, hasMedia, omitDuplicateFileCaption } = args;
+        deliverCallCount++;
+        if (isFirstReply) {
+            const ttfr = Date.now() - dispatchStart;
+            log.info(`${logPrefix} [deliver] First response block received from AI (TTFB: ${ttfr}ms)`);
+            isFirstReply = false;
+        }
+        const reply = resolveSendMessageReply(params);
+        const atIds = reply ? [reply.targetUserId] : [];
+        if (!hasFirstReply) {
+            clearTimeout(firstReplyTimeout);
+        }
+        await sendReplyDeliverBlock(config, currentIdentity.token, params.groupId, payloadForSend, atIds, log, undefined, reply, agentWorkspaceDir);
+        if (!hasFirstReply) {
+            hasFirstReply = true;
+        }
+        terminal.markBusinessReplySent();
+        if (hasMedia) {
+            lastDeliveredHadMedia = true;
+            if (!omitDuplicateFileCaption) {
+                lastDeliveredText = textPart || "[media]";
+            }
+        }
+        else {
+            lastDeliveredText = textPart;
+            lastDeliveredHadMedia = false;
+        }
+        const preview = textPart.length > 80 ? `${textPart.slice(0, 80)}...` : textPart || "[media]";
+        log.info(`${logPrefix} [send] ${sendLabel} sent via HTTP: groupId=${params.groupId} ` +
+            `invoke=#${invokeNum} preview="${preview}"`);
+    };
+    let activeRound;
+    try {
+        if (!isStopControl) {
+            setSessionImContext(route.sessionKey, {
+                groupId: params.groupId,
+                replyToMsgId: params.msgId,
+                agentId: config.agentId || "main",
+            });
+            await streamClient.start({
+                groupId: params.groupId,
+                replyToMsgId: params.msgId,
+            });
+            activeRound = registerActiveRound({
+                accountId,
+                groupId: params.groupId,
+                agentId: config.agentId || "main",
+                sessionKey: route.sessionKey,
+                replyToMsgId: params.msgId,
+                streamClient,
+            });
+            registerPlanWsClientAndSnapshot(params.groupId, streamClient, params.msgId);
+        }
+        if (modelOverride) {
+            const parsed = splitModelRef(modelOverride);
+            if (parsed) {
+                setPendingPerMessageModel(route.sessionKey, modelOverride);
+            }
+            else {
+                log.warn(`${logPrefix} [model] invalid per-message model ref, ignoring: ${modelOverride}`);
+            }
+        }
+        const baseDispatchCfg = resolveDispatchOpenClawCfg(cfg, config);
+        let nasDispatch;
+        try {
+            nasDispatch = resolveNasVolumeDispatchConfig({
+                cfg: baseDispatchCfg,
+                config,
+                agentId: route.agentId,
+                sessionKey: route.sessionKey,
+                volumes: nasVolumes,
+            });
+        }
+        catch (error) {
+            // NAS 是可选增强信息。任何非法声明或运行时挂载校验失败都不得阻断原消息。
+            log.warn(`${logPrefix} [nas-volumes] invalid mount ignored: ${String(error)}`);
+            try {
+                // 若本会话此前已有有效声明，继续复用它；否则完全退回原 dispatch 配置。
+                nasDispatch = resolveNasVolumeDispatchConfig({
+                    cfg: baseDispatchCfg,
+                    config,
+                    agentId: route.agentId,
+                    sessionKey: route.sessionKey,
+                });
+            }
+            catch (cachedError) {
+                log.warn(`${logPrefix} [nas-volumes] cached mount unavailable, continuing without NAS: ${String(cachedError)}`);
+                nasDispatch = { cfg: baseDispatchCfg, reused: false };
+            }
+        }
+        const dispatchCfg = nasDispatch.cfg;
+        if (nasDispatch.specHash) {
+            log.info(`${logPrefix} [nas-volumes] session=${route.sessionKey} volumes=${nasVolumes?.length ?? "cached"} ` +
+                `spec=${nasDispatch.specHash.slice(0, 12)} reused=${nasDispatch.reused}`);
+        }
+        if (blockStreamingEnabled && baseDispatchCfg !== cfg) {
+            log.info(`${logPrefix} [dispatch] IM blockStreamingCoalesce override ` +
+                `(minChars=${IM_BLOCK_STREAMING_COALESCE_DEFAULT.minChars} idleMs=${IM_BLOCK_STREAMING_COALESCE_DEFAULT.idleMs}) ` +
+                `— agents.defaults coalesce will not delay tool-before HTTP`);
+        }
+        if (blockStreamingEnabled) {
+            log.info(`${logPrefix} [dispatch] blockStreaming=on (assistant text before tools → HTTP; tool progress → WS)`);
+        }
+        if (segmentBufferEnabled) {
+            log.info(`${logPrefix} [dispatch] deliverSegmentBuffer=on (segment buffer → flush on tool start / dispatch end)`);
+        }
+        flushSegmentBuffer = async (kind) => {
+            if (!segmentBuffer)
+                return;
+            const result = segmentBuffer.takeForFlush(kind);
+            // 本段快照（onPartialReply 全量）；仅在启用且确有回调时作为正文权威来源。
+            const snapshot = partialSnapshotEnabled && segmentSnapshotHadPartial ? segmentSnapshotText.trim() : "";
+            const sendLabel = kind === "interim"
+                ? "Interim block"
+                : deliverCallCount === 0
+                    ? "First reply"
+                    : "Final block";
+            if (result.status === "empty") {
+                // buffer 无内容但有快照（纯文本、无 deliver 文本块）→ 直接发快照。
+                if (snapshot) {
+                    if (shouldSuppressDuplicateTextDeliver({
+                        textPart: snapshot,
+                        hasMedia: false,
+                        lastDeliveredText,
+                        lastDeliveredHadMedia,
+                    })) {
+                        log.info(`${logPrefix} [deliver-buffer] flush_${kind} snapshot_only skipped ` +
+                            `(normalized same as last HTTP, len=${snapshot.length})`);
+                        resetSegmentSnapshot();
+                    }
+                    else {
+                        log.info(`${logPrefix} [deliver-buffer] flush_${kind} snapshot_only textLen=${snapshot.length}`);
+                        resetSegmentSnapshot();
+                        await postHttpDeliver({
+                            payloadForSend: { text: snapshot },
+                            textPart: snapshot,
+                            sendLabel,
+                            invokeNum: deliverInvokeCount,
+                            hasMedia: false,
+                            omitDuplicateFileCaption: false,
+                        });
+                    }
+                }
+                return;
+            }
+            if (result.status === "skipped_duplicate") {
+                log.info(`${logPrefix} [deliver-buffer] flush_${kind} skipped (same as previous HTTP, comparable match)`);
+                resetSegmentSnapshot();
+                return;
+            }
+            let { payload: payloadForSend, textPart } = result.entry;
+            const { hasMedia } = result.entry;
+            // 快照覆盖正文：仅当快照包含缓冲文本（归一化后为超集）时才覆盖，避免竞态截断；
+            // 媒体/附件等元数据仍沿用 deliver 的 payload。
+            if (snapshot && snapshot !== textPart) {
+                if (snapshotSupersedesBufferText(snapshot, textPart)) {
+                    log.info(`${logPrefix} [deliver-buffer] flush_${kind} snapshot_override ` +
+                        `bufferLen=${textPart.length} → snapshotLen=${snapshot.length}`);
+                    payloadForSend = {
+                        ...payloadForSend,
+                        text: snapshot,
+                        ...(payloadForSend.markdown != null ? { markdown: snapshot } : {}),
+                    };
+                    textPart = snapshot;
+                }
+                else {
+                    log.warn(`${logPrefix} [deliver-buffer] flush_${kind} snapshot_skip (not superset; keep buffer) ` +
+                        `bufferLen=${textPart.length} snapshotLen=${snapshot.length}`);
+                }
+            }
+            log.info(`${logPrefix} [deliver-buffer] flush_${kind} textLen=${textPart.length} hasMedia=${hasMedia}`);
+            resetSegmentSnapshot();
+            await postHttpDeliver({
+                payloadForSend,
+                textPart,
+                sendLabel,
+                invokeNum: deliverInvokeCount,
+                hasMedia,
+                omitDuplicateFileCaption: false,
+            });
+        };
+        dispatchInFlight = true;
+        dispatchResult = await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: inboundCtx,
+            cfg: dispatchCfg,
+            replyOptions: {
+                ...resolveBlockStreamingReplyOptions(config),
+                sourceReplyDeliveryMode: "automatic",
+                suppressDefaultToolProgressMessages: true,
+                ...(modelOverride ? { modelOverride } : {}),
+                ...(thinkingLevelOverride ? { thinkingLevelOverride } : {}),
+                onAgentRunStart: (runId) => {
+                    agentRunStarted = true;
+                    agentRunId = runId.trim() || undefined;
+                    terminal.setRunId(runId);
+                    log.info(`${logPrefix} [dispatch] agent run started runId=${runId}`);
+                },
+                onModelSelected: (m) => {
+                    // failover 候选启动时会多次触发；终态模型以 session store 为准（RUN_USAGE）
+                    log.info(`${logPrefix} [model] run candidate provider=${m.provider} model=${m.model}`);
+                },
+                onPartialReply: async (payload) => {
+                    if (!partialSnapshotEnabled)
+                        return;
+                    const text = typeof payload.text === "string" ? payload.text : "";
+                    if (!text)
+                        return;
+                    partialReplyCount++;
+                    if (text.length > partialReplyMaxTextLen)
+                        partialReplyMaxTextLen = text.length;
+                    const now = Date.now();
+                    if (partialReplyFirstAt === 0) {
+                        partialReplyFirstAt = now;
+                        log.info(`${logPrefix} [partial] FIRST +${now - dispatchStart}ms textLen=${text.length}`);
+                    }
+                    // text 是当前 assistant 消息的全量快照（非增量）：直接作为本段正文权威来源。
+                    segmentSnapshotText = text;
+                    segmentSnapshotHadPartial = true;
+                    // 节流推送 WS 正文预览，供前端尽早覆盖显示同一输出位（HTTP 定稿前）。
+                    await emitReplyPreviewWs(text, false);
+                },
+                onReasoningStream: async (payload) => {
+                    const text = typeof payload.text === "string" ? payload.text : "";
+                    if (!text.trim())
+                        return;
+                    thinkingWsBuffer.noteStream(text);
+                },
+                onReasoningEnd: async () => {
+                    await flushThinkingWsOnce("reasoning_end");
+                },
+                onToolStart: async (p) => {
+                    const name = typeof p.name === "string" && p.name.trim().length > 0 ? p.name.trim() : "tool";
+                    const rawPhase = typeof p.phase === "string" ? p.phase.toLowerCase() : "";
+                    console.log(`[xg_cwork_im] ${logPrefix} [onToolStart] name="${name}" phase="${rawPhase}" argsKeys=${p.args ? Object.keys(p.args).join(",") : "none"}`);
+                    if (rawPhase === "update" || rawPhase === "delta" || rawPhase === "progress") {
+                        return;
+                    }
+                    if (rawPhase === "end" || rawPhase === "fail" || rawPhase === "error") {
+                        return;
+                    }
+                    if (!rawPhase || rawPhase === "start") {
+                        try {
+                            await flushSegmentBuffer("interim");
+                        }
+                        catch (interimErr) {
+                            lastDeliverError = interimErr;
+                            log.error(`${logPrefix} [deliver-buffer] flush_interim failed: ${String(interimErr)}`);
+                        }
+                        await flushThinkingWsOnce("before_tool");
+                        toolNameStack.push(name);
+                        if (name.includes("sessions_spawn") && !subagentNotificationSent) {
+                            subagentNotificationSent = true;
+                            try {
+                                await sendTextMessage(config, currentIdentity.token, params.groupId, "已将任务分配给子助手处理，稍后会把结果发给您。");
+                                console.log(`[xg_cwork_im] ${logPrefix} [subagent] sent notification from onToolStart`);
+                            }
+                            catch (sendErr) {
+                                console.warn(`[xg_cwork_im] ${logPrefix} [subagent] onToolStart send failed: ${String(sendErr)}`);
+                            }
+                        }
+                    }
+                    // WS TOOL_PHASE 已移至全局 before_tool_call hook
+                },
+                onToolResult: async (payload) => {
+                    const toolName = toolNameStack.length > 0 ? toolNameStack.pop() : "tool";
+                    // WS TOOL_PHASE 已移至全局 after_tool_call hook
+                },
+                onItemEvent: async (p) => {
+                    // 工具生命周期已由 onToolStart/onToolResult 覆盖；Reasoning 已由
+                    // onReasoningStream/onReasoningEnd 覆盖（start/end 各触发一次）。二者
+                    // 均不再进入 RUN_EVENT 兜底，避免内部诊断标识 `unmapped:*` 展示给用户。
+                    const guard = resolveItemEventGuard(p);
+                    if (guard.suppress)
+                        return;
+                    const text = (typeof p.progressText === "string" && p.progressText.trim()) ||
+                        (typeof p.summary === "string" && p.summary.trim()) ||
+                        (typeof p.title === "string" && p.title.trim()) ||
+                        (typeof p.meta === "string" && p.meta.trim()) ||
+                        "";
+                    if (!text)
+                        return;
+                    // 未识别事件只记录日志，不发送给最终用户
+                    log.debug?.(`${logPrefix} [stream] ignored unmapped onItemEvent ` +
+                        `kind=${guard.kind || "unknown"} title=${guard.title || "unknown"}`);
+                },
+                onPlanUpdate: async (p) => {
+                    const title = typeof p.title === "string" ? p.title.trim() : "";
+                    if (title.length > 0) {
+                        await notifyStreamProgress("PLAN_UPDATE", clipWsDisplayText(`正在更新计划：${title}`, 160), typeof p.explanation === "string" && p.explanation.trim()
+                            ? clipWsProgressSummary(p.explanation.trim())
+                            : undefined);
+                    }
+                    else if (typeof p.explanation === "string" && p.explanation.trim().length > 0) {
+                        await notifyStreamProgress("PLAN_UPDATE", clipWsDisplayText(`计划更新：${p.explanation.trim()}`, 160));
+                    }
+                    else {
+                        await notifyStreamProgress("PLAN_UPDATE", "正在更新执行计划…");
+                    }
+                },
+                onCompactionStart: async () => {
+                    terminal.noteCompactionWsEvent("start");
+                    await notifyStreamProgress("RUN_EVENT", "正在整理上下文…");
+                },
+                onCompactionEnd: async () => {
+                    terminal.noteCompactionWsEvent("end");
+                    await notifyStreamProgress("RUN_EVENT", "上下文整理完成");
+                },
+                onApprovalEvent: async (p) => {
+                    const raw = typeof p.title === "string" && p.title.trim().length > 0
+                        ? p.title.trim()
+                        : typeof p.message === "string" && p.message.trim().length > 0
+                            ? p.message.trim()
+                            : "审批状态更新";
+                    await notifyStreamProgress("RUN_EVENT", clipWsDisplayText(raw, 160));
+                },
+                onCommandOutput: async (p) => {
+                    const ph = typeof p.phase === "string" ? p.phase.toLowerCase() : "";
+                    if (ph === "delta" || ph === "stream" || ph === "progress")
+                        return;
+                    const st = typeof p.status === "string" ? p.status.toLowerCase() : "";
+                    const terminalPhase = ["completed", "complete", "done", "end", "failed", "fail", "error"].includes(ph);
+                    const terminalStatus = ["completed", "failed", "error", "done"].includes(st);
+                    const hasExit = p.exitCode != null;
+                    if (!terminalPhase && !terminalStatus && !hasExit)
+                        return;
+                    const outRaw = typeof p.output === "string" ? p.output.trim() : "";
+                    const outSum = outRaw ? clipWsProgressSummary(outRaw) : undefined;
+                    if (ph === "failed" || ph === "fail" || ph === "error" || st === "failed" || st === "error") {
+                        await notifyStreamProgress("RUN_EVENT", "计划有变，正在调整策略", outSum); //命令执行失败
+                        return;
+                    }
+                    if (hasExit && p.exitCode !== 0) {
+                        await notifyStreamProgress("RUN_EVENT", `命令已结束（退出码 ${p.exitCode}）`, outSum);
+                        return;
+                    }
+                    await notifyStreamProgress("RUN_EVENT", "命令已执行完毕", outSum);
+                },
+                onPatchSummary: async (_p) => {
+                    await notifyStreamProgress("RUN_EVENT", "已记录文件变更摘要");
+                },
+            },
+            dispatcherOptions: {
+                responsePrefix: "",
+                onSkip: (payload, meta) => {
+                    deliverSkippedCount++;
+                    terminal.noteNormalizerSkip(meta.reason);
+                    log.info(`${logPrefix} [deliver] Payload skipped by normalizer kind=${meta.kind} reason=${meta.reason}`);
+                },
+                onError: (err, meta) => {
+                    lastDeliverError = err;
+                    log.error(`${logPrefix} [deliver] Dispatcher caught unhandled error kind=${meta.kind}: ${String(err)}`);
+                },
+                deliver: async (payload, info) => {
+                    try {
+                        deliverInvokeCount++;
+                        const textPayload = payload.markdown || payload.text || "";
+                        const trimmedForSend = textPayload.trim();
+                        const textPart = stripMediaDirectiveLines(trimmedForSend);
+                        const hasMedia = Boolean(payload.mediaUrl?.trim()) ||
+                            Boolean(payload.mediaUrls?.some((u) => typeof u === "string" && u.trim()));
+                        const textPreview = textPart.length > 160
+                            ? `${textPart.slice(0, 80)}…${textPart.slice(-80)}`
+                            : textPart;
+                        log.info(`${logPrefix} [deliver] invoke #${deliverInvokeCount} isThinking=${payload.isThinking ?? false} ` +
+                            `textLen=${textPart.length} hasMedia=${hasMedia} mediaUrl=${Boolean(payload.mediaUrl?.trim())} ` +
+                            `kind=${info?.kind ?? "none"} ` +
+                            `preview=${JSON.stringify(textPreview || "(empty)")}`);
+                        if (!hasMedia && !stripModelUsageFooter(textPart).trim()) {
+                            deliverSkippedCount++;
+                            log.info(`${logPrefix} [deliver] skip: model usage footer only (rawLen=${trimmedForSend.length})`);
+                            return;
+                        }
+                        if (payload.isError === true) {
+                            const errRaw = textPart || "(empty)";
+                            terminal.noteRuntimeErrorFromPayload(errRaw);
+                            const userText = formatConfirmedUpstreamErrorForIm(errRaw);
+                            if (!userText) {
+                                deliverSkippedCount++;
+                                log.info(`${logPrefix} [deliver] isError payload empty after format; skipped HTTP`);
+                                return;
+                            }
+                            // 上游已 deliver 的错误：HTTP 发出（白名单人话或原文），不再等到终态换插件空话
+                            const errorPayload = {
+                                ...payload,
+                                text: userText,
+                                markdown: userText,
+                                isError: true,
+                            };
+                            log.info(`${logPrefix} [deliver] isError → HTTP (confirmed map or passthrough) ` +
+                                `len=${userText.length}`);
+                            await postHttpDeliver({
+                                payloadForSend: errorPayload,
+                                textPart: userText,
+                                sendLabel: deliverInvokeCount === 1 ? "First reply (error)" : "Error payload",
+                                invokeNum: deliverInvokeCount,
+                                hasMedia: false,
+                                omitDuplicateFileCaption: false,
+                            });
+                            return;
+                        }
+                        if (payload.isCompactionNotice === true) {
+                            deliverSkippedCount++;
+                            terminal.noteCompactionNotice(textPart || "Compacting context...");
+                            log.info(`${logPrefix} [deliver] Compaction notice suppressed from HTTP (WS progress only): ` +
+                                `${JSON.stringify((textPart || "").slice(0, 80))}`);
+                            return;
+                        }
+                        if (payload.isReasoning === true) {
+                            deliverSkippedCount++;
+                            if (textPart)
+                                thinkingWsBuffer.noteStream(textPart);
+                            await flushThinkingWsOnce("deliver_reasoning");
+                            log.info(`${logPrefix} [deliver] Thinking block → single WS RUN_EVENT (len=${textPart.length})`);
+                            return;
+                        }
+                        if (shouldSuppressFallbackNoticeForIm({
+                            isFallbackNotice: payload.isFallbackNotice === true,
+                            deliverModelFallbackNotice: config.deliverModelFallbackNotice,
+                            requestedModelRaw: modelOverride,
+                            noticeText: textPart,
+                        })) {
+                            deliverSkippedCount++;
+                            const reason = config.deliverModelFallbackNotice === true
+                                ? "spurious per-message fallback notice"
+                                : "model fallback notice disabled for IM (deliverModelFallbackNotice)";
+                            log.info(`${logPrefix} [model] Suppressing fallback notice (${reason}): ` +
+                                `${JSON.stringify(textPart.slice(0, 120))}`);
+                            return;
+                        }
+                        if (!segmentBufferEnabled &&
+                            shouldSuppressDuplicateTextDeliver({
+                                textPart,
+                                hasMedia,
+                                lastDeliveredText,
+                                lastDeliveredHadMedia,
+                            })) {
+                            deliverSkippedCount++;
+                            log.info(`${logPrefix} [deliver] Suppressed duplicate text-only deliver ` +
+                                `(normalized same as previous, rawLen=${textPart.length})`);
+                            return;
+                        }
+                        let omitDuplicateFileCaption = false;
+                        if (!segmentBufferEnabled) {
+                            omitDuplicateFileCaption = shouldOmitDuplicateFileCaption({
+                                textPart,
+                                hasMedia,
+                                lastDeliveredText,
+                                lastDeliveredHadMedia,
+                            });
+                            if (omitDuplicateFileCaption) {
+                                log.info(`${logPrefix} [deliver] Omitting duplicate file caption ` +
+                                    `(normalized same as previous text, rawLen=${textPart.length})`);
+                            }
+                        }
+                        if (!isDeliverPayloadSendable({
+                            textPart,
+                            hasMedia,
+                            isThinking: payload.isThinking,
+                        })) {
+                            deliverSkippedCount++;
+                            log.info(`${logPrefix} [deliver] Payload has no sendable content, skipping` +
+                                ` (isThinking=${payload.isThinking ?? false} hasMedia=${hasMedia})`);
+                            return;
+                        }
+                        let payloadForSend = textPart !== trimmedForSend
+                            ? {
+                                ...payload,
+                                ...(payload.markdown != null
+                                    ? { markdown: textPart }
+                                    : { text: textPart }),
+                            }
+                            : payload;
+                        if (omitDuplicateFileCaption) {
+                            payloadForSend = { ...payloadForSend, text: "", markdown: "" };
+                        }
+                        if (segmentBufferEnabled && segmentBuffer) {
+                            if (info?.kind === "final" && segmentBuffer.hasContent()) {
+                                segmentBuffer.clear();
+                                log.info(`${logPrefix} [deliver] final block replaces buffer (intermediates discarded, textLen=${textPart.length})`);
+                            }
+                            if (shouldSuppressDuplicateTextDeliver({ textPart, hasMedia, lastDeliveredText, lastDeliveredHadMedia })) {
+                                deliverSkippedCount++;
+                                log.info(`${logPrefix} [deliver-buffer] skip: same as last HTTP delivered ` +
+                                    `(normalized match, textLen=${textPart.length})`);
+                                return;
+                            }
+                            segmentBuffer.write({ payload: payloadForSend, textPart, rawTextPart: textPayload, hasMedia });
+                            if (!hasBufferedSendable) {
+                                hasBufferedSendable = true;
+                                clearTimeout(firstReplyTimeout);
+                            }
+                            log.info(`${logPrefix} [deliver-buffer] write invoke=#${deliverInvokeCount} ` +
+                                `textLen=${textPart.length} hasMedia=${hasMedia}`);
+                            return;
+                        }
+                        const sendLabel = deliverInvokeCount === 1
+                            ? "First reply"
+                            : blockStreamingEnabled
+                                ? "Interim block"
+                                : "Additional reply";
+                        await postHttpDeliver({
+                            payloadForSend,
+                            textPart,
+                            sendLabel,
+                            invokeNum: deliverInvokeCount,
+                            hasMedia,
+                            omitDuplicateFileCaption,
+                        });
+                    }
+                    catch (err) {
+                        log.error(`${logPrefix} [deliver] Reply deliver failed: ${String(err)}`);
+                        throw err;
+                    }
+                },
+            },
+        });
+        dispatchInFlight = false;
+        const bufStats = segmentBuffer?.getStats();
+        log.info(`${logPrefix} [dispatch] Dispatch completed for sessionKey=${route.sessionKey}` +
+            ` (invoke=${deliverInvokeCount} delivered=${deliverCallCount} skipped=${deliverSkippedCount}` +
+            (bufStats
+                ? ` buffer_writes=${bufStats.writeCount}` +
+                    ` revision_overwrite=${bufStats.revisionOverwriteCount}` +
+                    ` segment_append=${bufStats.segmentAppendCount}` +
+                    ` flush_interim=${bufStats.flushInterimCount}` +
+                    ` flush_final=${bufStats.flushFinalCount}` +
+                    ` flush_dup_skip=${bufStats.skippedDuplicateFlushCount}`
+                : "") +
+            `)`);
+        if (partialSnapshotEnabled) {
+            log.info(`${logPrefix} [partial] SUMMARY count=${partialReplyCount} ` +
+                `maxTextLen=${partialReplyMaxTextLen} ` +
+                `firstAt=${partialReplyFirstAt ? partialReplyFirstAt - dispatchStart : -1}ms ` +
+                `(count=0 → 该配置下未回调 partial，flush 回退到 deliver 段缓冲)`);
+        }
+        if (deliverInvokeCount === 0) {
+            log.warn(`${logPrefix} [dispatch] OpenClaw never invoked channel deliver() for this turn — ` +
+                `this plugin will not POST /im/message/send; IM「收到消息」若存在，多半来自占位/END 或其它通道，而非本插件 HTTP 合并`);
+        }
+        else if (deliverCallCount === 0 && !segmentBuffer?.hasContent()) {
+            log.warn(`${logPrefix} [dispatch] deliver() invoked ${deliverInvokeCount} time(s) but none had sendable text/media — ` +
+                `check model output (thinking-only / empty blocks) or OpenClaw normalizer`);
+        }
+    }
+    catch (dispatchErr) {
+        dispatchError = dispatchErr;
+        log.error(`${logPrefix} [dispatch] Dispatch failed (invoke=${deliverInvokeCount} delivered=${deliverCallCount} skipped=${deliverSkippedCount}): ${String(dispatchErr)}`);
+    }
+    finally {
+        dispatchInFlight = false;
+        clearPendingPerMessageModel(route.sessionKey);
+        try {
+            await flushSegmentBuffer("final");
+        }
+        catch (flushErr) {
+            lastDeliverError = flushErr;
+            log.error(`${logPrefix} [deliver-buffer] flush_final failed: ${String(flushErr)}`);
+        }
+        clearTimeout(firstReplyTimeout);
+        const terminalState = await terminal.finalizeAndDeliver({
+            sendFn: terminalSend,
+            dispatchThrew: dispatchError !== undefined,
+            dispatchError,
+            lastDeliverError,
+            beforeAgentRunBlocked: dispatchResult?.beforeAgentRunBlocked === true,
+            deliverInvokeCount,
+            deliverCallCount,
+        });
+        const endReason = terminalState === "success" ||
+            hasFirstReply ||
+            terminal.wasTerminalDelivered() ||
+            terminal.didTimeoutFire() ||
+            subagentNotificationSent
+            ? "stop"
+            : "no_reply";
+        // `/stop` 仅借用 OpenClaw dispatch 触发 fast-abort；原轮次的 suspended/aborted
+        // 由 account-connection 在 dispatch 返回后串行收口，控制消息自身不产生 WS 事件。
+        if (isStopControl)
+            return;
+        // 当前业务轮次已被并发 `/stop` 接管时，收口事件由 interrupt-round 负责。
+        if (activeRound?.interrupted) {
+            log.info(`${logPrefix} [stream] round interrupted; skip late RUN_USAGE/FINISHED`);
+            return;
+        }
+        try {
+            const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
+                agentId: config.agentId || "main",
+            });
+            const sessionFields = readSessionUsageFields({
+                storePath,
+                sessionKey: route.sessionKey,
+            });
+            const usage = buildRunUsageFromSessionEntry(sessionFields, {
+                runId: agentRunId ?? terminal.getRunId(),
+            });
+            if (hasReportableUsage(usage) && usage) {
+                await streamClient.streamUsage(toImStreamRunUsageData(usage, {
+                    groupId: params.groupId,
+                    replyToMsgId: params.msgId,
+                }));
+            }
+            else {
+                log.info(`${logPrefix} [stream] RUN_USAGE skipped (session store has no model/token; ` +
+                    `sessionKey=${route.sessionKey} deliver_call=${deliverCallCount})`);
+            }
+        }
+        catch (usageErr) {
+            log.warn(`${logPrefix} [stream] RUN_USAGE failed: ${String(usageErr)}`);
+        }
+        // ✅ 检查是否有活跃的 subagent，如果有则延迟 FINISHED
+        if (activeRound &&
+            hasActiveSubagents(activeRound.roundKey, activeRound.generation)) {
+            log.info(`${logPrefix} [stream] FINISHED deferred: has active subagents, ` +
+                `will be sent by monitor when all complete. reason=${endReason} ` +
+                `terminal_state=${terminalState} deliver_invoke=${deliverInvokeCount}`);
+            // 记录延迟的 FINISHED，由 subagent-monitor 在所有完成后发送
+            deferFinished(activeRound.roundKey, activeRound.generation, endReason);
+        }
+        else {
+            // 没有活跃 subagent，正常发送 FINISHED
+            try {
+                await streamClient.end(endReason, {
+                    groupId: params.groupId,
+                    replyToMsgId: params.msgId,
+                });
+                log.info(`${logPrefix} [stream] FINISHED sent: reason=${endReason} terminal_state=${terminalState} ` +
+                    `has_first_reply=${hasFirstReply} deliver_invoke=${deliverInvokeCount} ` +
+                    `deliver_call=${deliverCallCount} skipped=${deliverSkippedCount}`);
+            }
+            catch (endErr) {
+                log.error(`${logPrefix} [stream] FINISHED failed: ${String(endErr)}`);
+            }
+            finally {
+                if (activeRound) {
+                    completeActiveRound(activeRound.roundKey, activeRound.generation);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=dispatch-mentioned-reply.js.map