openclaw-channel-dmwork 0.6.1 → 0.6.2-dev.84da5e15

package/dist/src/inbound.js

@@ -1,4 +1,4 @@
-import { sendMessage, editMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers, getGroupMd, sendMediaMessage, inferContentType, ensureTextCharset, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS, fetchUserInfo } from "./api-fetch.js";
+import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers, getGroupMd, sendMediaMessage, inferContentType, ensureTextCharset, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS, fetchUserInfo } from "./api-fetch.js";
 import { ChannelType, MessageType } from "./types.js";
 import { getDmworkRuntime } from "./runtime.js";
 import { DEFAULT_HISTORY_PROMPT_TEMPLATE } from "./config-schema.js";
@@ -8,6 +8,9 @@ import { createWriteStream } from "node:fs";
 import { mkdir, unlink, readdir, stat } from "node:fs/promises";
 import { join, basename } from "node:path";
 import { randomUUID } from "node:crypto";
+// Pending inbound context for before_prompt_build hook injection.
+// handleInboundMessage writes here; the hook reads and clears per sessionKey.
+export const pendingInboundContext = new Map();
 // Defensive imports — these may not exist in older OpenClaw versions
 // History context managed manually for cross-SDK compatibility
 let clearHistoryEntriesIfEnabled;
@@ -1203,11 +1206,13 @@ export async function handleInboundMessage(params) {
         storePath,
         sessionKey: route.sessionKey,
     });
-    // Inject member list for group messages to help LLM learn @[uid:name] format
+    // memberListPrefix and historyPrefix are injected via before_prompt_build hook
+    // (not persisted to session history). Only quotePrefix stays in Body.
     const memberListPrefix = isGroup ? buildMemberListPrefix(uidToNameMap) : "";
-    const finalBody = (memberListPrefix || historyPrefix || quotePrefix)
-        ? (memberListPrefix + historyPrefix + quotePrefix + rawBody)
-        : rawBody;
+    if (historyPrefix || memberListPrefix) {
+        pendingInboundContext.set(route.sessionKey, { historyPrefix, memberListPrefix });
+    }
+    const finalBody = quotePrefix ? (quotePrefix + rawBody) : rawBody;
     const body = core.channel.reply.formatAgentEnvelope({
         channel: "DMWork",
         from: fromLabel,
@@ -1216,10 +1221,8 @@ export async function handleInboundMessage(params) {
         envelope: envelopeOptions,
         body: finalBody,
     });
-    // Inject GROUP.md as GroupSystemPrompt for group messages
-    const groupSystemPrompt = isGroup && groupMdCache && message.channel_id
-        ? groupMdCache.get(extractParentGroupNo(message.channel_id))?.content
-        : undefined;
+    // GROUP.md injection is handled exclusively by the before_prompt_build hook
+    // (see index.ts → getGroupMdForPrompt) — no longer set here to avoid duplication.
     // Resolve sender display name — async fallback for DM users not in cache
     let senderName = resolveSenderName(message.from_uid, uidToNameMap);
     if (!senderName && !isGroup) {
@@ -1245,9 +1248,10 @@ export async function handleInboundMessage(params) {
     }
     const ctxPayload = core.channel.reply.finalizeInboundContext({
         Body: body,
-        BodyForAgent: body, // ← 关键！AI 实际读取的是这个字段！
+        BodyForAgent: body,
         RawBody: rawBody,
         CommandBody: rawBody,
+        CommandAuthorized: true,
         MediaUrl: isFileMessage ? undefined : inboundMediaUrl,
         MediaUrls: (() => {
             // Only pass current message's local media path (no remote history URLs)
@@ -1268,7 +1272,7 @@ export async function handleInboundMessage(params) {
         MessageSid: String(message.message_id),
         Timestamp: message.timestamp ? message.timestamp * 1000 : undefined,
         GroupSubject: isGroup ? message.channel_id : undefined,
-        GroupSystemPrompt: groupSystemPrompt,
+        GroupSystemPrompt: undefined,
         Provider: "dmwork",
         Surface: "dmwork",
         OriginatingChannel: "dmwork",
@@ -1300,21 +1304,126 @@ export async function handleInboundMessage(params) {
     const typingInterval = setInterval(() => {
         sendTyping({ apiUrl, botToken, channelId: replyChannelId, channelType: replyChannelType }).catch(() => { });
     }, 5000);
-    // Draft-edit dedup: tracks the first sent message so subsequent delivers edit it.
-    // draftMessage is scoped to this handleInboundMessage invocation; deliver is called
-    // sequentially by dispatchReplyWithBufferedBlockDispatcher, so no concurrency issue.
-    let draftMessage = null;
+    // Buffer text across streaming deliver calls; only send once after dispatcher finishes.
+    // Media is sent immediately (no edit problem); text is buffered (each call overwrites).
+    const deliverBuffer = {
+        lastText: null,
+        textSent: false,
+    };
+    const sentMediaUrls = new Set();
+    // --- Shared helper: resolve mentions and send text ---
+    const resolveAndSendText = async (content) => {
+        let replyMentionUids = [];
+        let replyMentionEntities = [];
+        let finalContent = content;
+        if (isGroup) {
+            const structuredMentions = parseStructuredMentions(content);
+            if (structuredMentions.length > 0) {
+                // v2 path: LLM used @[uid:name] format
+                const validUids = new Set(uidToNameMap.keys());
+                const converted = convertStructuredMentions(content, structuredMentions, validUids);
+                finalContent = converted.content;
+                replyMentionEntities = [...converted.entities];
+                // Mixed scenario: check for remaining @name in converted content
+                const remaining = buildEntitiesFromFallback(finalContent, memberMap);
+                const existingOffsets = new Set(replyMentionEntities.map((e) => e.offset));
+                for (const rm of remaining.entities) {
+                    if (!existingOffsets.has(rm.offset)) {
+                        replyMentionEntities.push(rm);
+                    }
+                }
+                log?.debug?.(`dmwork: [REPLY] structured mentions: ${structuredMentions.length}, fallback: ${remaining.entities.length}`);
+            }
+            else {
+                // v1 fallback path: LLM used @name format
+                const contentMentions = extractMentionMatches(content);
+                const unresolvedNames = [];
+                const resolveMention = (name) => {
+                    const uid = findUidByName(name, memberMap);
+                    let newContent = finalContent;
+                    if (uid) {
+                        return { uid, newContent };
+                    }
+                    else if (/^[a-f0-9]{32}$/i.test(name)) {
+                        const displayName = uidToNameMap.get(name);
+                        if (displayName) {
+                            newContent = newContent.replace(`@${name}`, `@${displayName}`);
+                            return { uid: name, newContent };
+                        }
+                        return { uid: name, newContent };
+                    }
+                    else if (/^[a-zA-Z0-9_]+$/.test(name)) {
+                        const displayName = uidToNameMap.get(name);
+                        if (displayName) {
+                            newContent = newContent.replace(`@${name}`, `@${displayName}`);
+                            return { uid: name, newContent };
+                        }
+                        return { uid: name, newContent };
+                    }
+                    return { uid: null, newContent };
+                };
+                const resolvedUids = [];
+                for (const mention of contentMentions) {
+                    const name = mention.slice(1);
+                    const result = resolveMention(name);
+                    finalContent = result.newContent;
+                    resolvedUids.push(result.uid);
+                    if (!result.uid) {
+                        unresolvedNames.push({ name, index: resolvedUids.length - 1 });
+                    }
+                }
+                if (unresolvedNames.length > 0) {
+                    log?.info?.(`dmwork: [REPLY] ${unresolvedNames.length} unresolved names, force refreshing cache...`);
+                    const refreshed = await refreshGroupMemberCache({ sessionId: memberCacheGroupNo, memberMap, uidToNameMap, groupCacheTimestamps, apiUrl: account.config.apiUrl, botToken: account.config.botToken ?? "", forceRefresh: true, log });
+                    if (refreshed) {
+                        for (const { name, index } of unresolvedNames) {
+                            const uid = findUidByName(name, memberMap);
+                            if (uid) {
+                                resolvedUids[index] = uid;
+                            }
+                        }
+                    }
+                }
+                replyMentionUids = resolvedUids.filter((uid) => uid !== null);
+                const fallbackResult = buildEntitiesFromFallback(finalContent, memberMap);
+                replyMentionEntities = fallbackResult.entities;
+            }
+            // Sort entities by offset and rebuild uids from sorted entities
+            if (replyMentionEntities.length > 0) {
+                replyMentionEntities.sort((a, b) => a.offset - b.offset);
+                replyMentionUids = replyMentionEntities.map((e) => e.uid);
+            }
+        }
+        // Detect @all/@所有人 in final content
+        const hasAtAll = /(?:^|(?<=\s))@(?:all|所有人)(?=\s|[^\w]|$)/i.test(finalContent);
+        await sendMessage({
+            apiUrl: account.config.apiUrl,
+            botToken: account.config.botToken ?? "",
+            channelId: replyChannelId,
+            channelType: replyChannelType,
+            content: finalContent,
+            ...(replyMentionUids.length > 0 ? { mentionUids: replyMentionUids } : {}),
+            ...(replyMentionEntities.length > 0 ? { mentionEntities: replyMentionEntities } : {}),
+            mentionAll: hasAtAll || undefined,
+        });
+        statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+    };
     try {
         await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
             ctx: ctxPayload,
             cfg: config,
             replyOptions: {},
             dispatcherOptions: {
-                deliver: async (payload) => {
-                    // Resolve outbound media URLs
+                deliver: async (payload, info) => {
+                    // Skip reasoning blocks
+                    if (payload.isReasoning)
+                        return;
+                    const kind = info?.kind ?? "final";
+                    // --- Media: send immediately (no edit/forward issue) with dedup ---
                     const outboundMediaUrls = resolveOutboundMediaUrls(payload);
-                    // Upload and send each media file
                     for (const mediaUrl of outboundMediaUrls) {
+                        if (sentMediaUrls.has(mediaUrl))
+                            continue;
                         try {
                             await uploadAndSendMedia({
                                 mediaUrl,
@@ -1324,12 +1433,13 @@ export async function handleInboundMessage(params) {
                                 channelType: replyChannelType,
                                 log,
                             });
+                            sentMediaUrls.add(mediaUrl);
                         }
                         catch (err) {
                             log?.error?.(`dmwork: media send failed for ${mediaUrl}: ${String(err)}`);
                         }
                     }
-                    // If there are no media URLs, fall through to text logic; if there are, only send text if caption exists
+                    // --- Text handling based on kind ---
                     const content = payload.text?.trim() ?? "";
                     if (!content && outboundMediaUrls.length > 0) {
                         statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
@@ -1337,146 +1447,22 @@ export async function handleInboundMessage(params) {
                     }
                     if (!content)
                         return;
-                    // Build mentionUids + entities from @mentions in content
-                    // Supports both @[uid:name] (v2 structured) and @name (v1 fallback)
-                    let replyMentionUids = [];
-                    let replyMentionEntities = [];
-                    let finalContent = content;
-                    if (isGroup) {
-                        const structuredMentions = parseStructuredMentions(content);
-                        if (structuredMentions.length > 0) {
-                            // v2 path: LLM used @[uid:name] format
-                            const validUids = new Set(uidToNameMap.keys());
-                            const converted = convertStructuredMentions(content, structuredMentions, validUids);
-                            finalContent = converted.content;
-                            replyMentionEntities = [...converted.entities];
-                            // Mixed scenario: check for remaining @name in converted content
-                            const remaining = buildEntitiesFromFallback(finalContent, memberMap);
-                            const existingOffsets = new Set(replyMentionEntities.map((e) => e.offset));
-                            for (const rm of remaining.entities) {
-                                if (!existingOffsets.has(rm.offset)) {
-                                    replyMentionEntities.push(rm);
-                                }
-                            }
-                            log?.debug?.(`dmwork: [REPLY] structured mentions: ${structuredMentions.length}, fallback: ${remaining.entities.length}`);
-                        }
-                        else {
-                            // v1 fallback path: LLM used @name format
-                            // Keep existing resolveMention logic for hex uid / uid-format handling
-                            const contentMentions = extractMentionMatches(content);
-                            let unresolvedNames = [];
-                            const resolveMention = (name) => {
-                                let uid = findUidByName(name, memberMap);
-                                let newContent = finalContent;
-                                if (uid) {
-                                    return { uid, newContent };
-                                }
-                                else if (/^[a-f0-9]{32}$/i.test(name)) {
-                                    const displayName = uidToNameMap.get(name);
-                                    if (displayName) {
-                                        newContent = newContent.replace(`@${name}`, `@${displayName}`);
-                                        return { uid: name, newContent };
-                                    }
-                                    return { uid: name, newContent };
-                                }
-                                else if (/^[a-zA-Z0-9_]+$/.test(name)) {
-                                    const displayName = uidToNameMap.get(name);
-                                    if (displayName) {
-                                        newContent = newContent.replace(`@${name}`, `@${displayName}`);
-                                        return { uid: name, newContent };
-                                    }
-                                    return { uid: name, newContent };
-                                }
-                                return { uid: null, newContent };
-                            };
-                            const resolvedUids = [];
-                            for (const mention of contentMentions) {
-                                const name = mention.slice(1);
-                                const result = resolveMention(name);
-                                finalContent = result.newContent;
-                                resolvedUids.push(result.uid);
-                                if (!result.uid) {
-                                    unresolvedNames.push({ name, index: resolvedUids.length - 1 });
-                                }
-                            }
-                            if (unresolvedNames.length > 0) {
-                                log?.info?.(`dmwork: [REPLY] ${unresolvedNames.length} unresolved names, force refreshing cache...`);
-                                const refreshed = await refreshGroupMemberCache({ sessionId: memberCacheGroupNo, memberMap, uidToNameMap, groupCacheTimestamps, apiUrl: account.config.apiUrl, botToken: account.config.botToken ?? "", forceRefresh: true, log });
-                                if (refreshed) {
-                                    for (const { name, index } of unresolvedNames) {
-                                        const uid = findUidByName(name, memberMap);
-                                        if (uid) {
-                                            resolvedUids[index] = uid;
-                                        }
-                                    }
-                                }
-                            }
-                            replyMentionUids = resolvedUids.filter((uid) => uid !== null);
-                            // Build entities from fallback for the final content
-                            const fallbackResult = buildEntitiesFromFallback(finalContent, memberMap);
-                            replyMentionEntities = fallbackResult.entities;
-                        }
-                        // Sort entities by offset and rebuild uids from sorted entities
-                        if (replyMentionEntities.length > 0) {
-                            replyMentionEntities.sort((a, b) => a.offset - b.offset);
-                            replyMentionUids = replyMentionEntities.map((e) => e.uid);
-                        }
-                    }
-                    // Detect @all/@所有人 in final content
-                    const hasAtAll = /(?:^|(?<=\s))@(?:all|所有人)(?=\s|[^\w]|$)/i.test(finalContent);
-                    // Draft-edit dedup: subsequent delivers edit the first message.
-                    // Note: editMessage API only updates content_edit text; mention metadata
-                    // (mentionUids/mentionEntities/mentionAll) cannot be updated via edit.
-                    // This is acceptable because the first sendMessage already carries the
-                    // correct mention info, and subsequent edits only update the text body.
-                    if (draftMessage) {
-                        try {
-                            const contentEdit = JSON.stringify({ type: 1, content: finalContent });
-                            log?.debug?.(`dmwork: [draft-edit] editMessage attempt id=${draftMessage.messageId} seq=${draftMessage.messageSeq}`);
-                            await editMessage({
-                                apiUrl: account.config.apiUrl,
-                                botToken: account.config.botToken ?? "",
-                                messageId: draftMessage.messageId,
-                                messageSeq: draftMessage.messageSeq,
-                                channelId: replyChannelId,
-                                channelType: replyChannelType,
-                                contentEdit,
-                            });
-                            log?.debug?.(`dmwork: [draft-edit] editMessage success`);
-                            statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
-                            return;
-                        }
-                        catch (editErr) {
-                            log?.warn?.(`dmwork: [draft-edit] editMessage failed: ${String(editErr)}, falling back to sendMessage`);
-                            draftMessage = null;
-                        }
-                    }
-                    const sendResult = await sendMessage({
-                        apiUrl: account.config.apiUrl,
-                        botToken: account.config.botToken ?? "",
-                        channelId: replyChannelId,
-                        channelType: replyChannelType,
-                        content: finalContent,
-                        ...(replyMentionUids.length > 0 ? { mentionUids: replyMentionUids } : {}),
-                        ...(replyMentionEntities.length > 0 ? { mentionEntities: replyMentionEntities } : {}),
-                        mentionAll: hasAtAll || undefined,
-                    });
-                    // Save draft for subsequent edit-dedup
-                    if (sendResult?.message_id != null && sendResult?.message_seq != null) {
-                        draftMessage = {
-                            messageId: String(sendResult.message_id),
-                            messageSeq: sendResult.message_seq,
-                        };
-                        log?.debug?.(`dmwork: [draft-edit] sendMessage OK, draft set: id=${draftMessage.messageId} seq=${draftMessage.messageSeq}`);
-                    }
-                    else {
-                        log?.debug?.(`dmwork: [draft-edit] sendMessage returned no id/seq, draft-edit disabled`);
+                    if (kind === "tool") {
+                        // Verbose tool call output: send immediately
+                        await resolveAndSendText(content);
+                        log?.info?.(`dmwork: [deliver] tool text sent (${content.length} chars)`);
+                        return;
                     }
-                    statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+                    // kind === "block" / "final" / anything else: buffer, send only once after dispatcher finishes
+                    deliverBuffer.lastText = content;
+                    log?.debug?.(`dmwork: [deliver-buffer] ${kind} text buffered (${content.length} chars)`);
                 },
                 onError: async (err, info) => {
                     clearInterval(typingInterval);
                     log?.error?.(`dmwork ${info.kind} reply failed: ${String(err)}`);
+                    // Prevent finally block from sending stale buffered text after error
+                    deliverBuffer.lastText = null;
+                    deliverBuffer.textSent = true;
                     try {
                         await sendMessage({
                             apiUrl,
@@ -1494,7 +1480,20 @@ export async function handleInboundMessage(params) {
         });
     }
     finally {
+        // --- Final send: deliver buffered text if only blocks arrived (no final/tool) ---
+        if (deliverBuffer.lastText && !deliverBuffer.textSent) {
+            deliverBuffer.textSent = true;
+            try {
+                await resolveAndSendText(deliverBuffer.lastText);
+                log?.info?.(`dmwork: [deliver-buffer] fallback text sent (${deliverBuffer.lastText.length} chars)`);
+            }
+            catch (finalSendErr) {
+                log?.error?.(`dmwork: [deliver-buffer] final text send failed: ${String(finalSendErr)}`);
+            }
+        }
         clearInterval(typingInterval);
+        // Safety net: clean up pending inbound context in case the hook didn't fire
+        pendingInboundContext.delete(route.sessionKey);
     }
 }
 //# sourceMappingURL=inbound.js.map