@newbase-clawchat/openclaw-clawchat 2026.5.12-2 → 2026.5.12-21

package/dist/src/outbound.js

@@ -1,19 +1,55 @@
+import { MessageSendError } from "./protocol-types.js";
 import { createAttachedChannelResultAdapter, } from "openclaw/plugin-sdk/channel-send-result";
 import { chunkMarkdownText } from "openclaw/plugin-sdk/reply-runtime";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
 import { CHANNEL_ID, resolveOpenclawClawlingAccount } from "./config.js";
 import { textToFragments } from "./message-mapper.js";
 import { uploadOutboundMedia } from "./media-runtime.js";
+import { isClawChatNoopResponseText } from "./profile-prompt.js";
 import { getOpenclawClawlingClient, getOpenclawClawlingRuntime, waitForOpenclawClawlingClient, } from "./runtime.js";
+import { clawChatDbPathForStateDir, getClawChatStore, } from "./storage.js";
 import { createAlignedWsQueue } from "./ws-alignment.js";
 import { formatWsLog } from "./ws-log.js";
 const alignedOutboundQueues = new WeakMap();
 const alignedOutboundContexts = new WeakMap();
-function getRawClientInternals(client) {
-    const raw = client;
-    if (!raw.opts?.transport || !raw.opts.traceIdFactory || !raw.on)
-        return null;
-    return raw;
+const alignedOutboundMessageErrorTrackers = new WeakMap();
+const alignedOutboundCloseHandlers = new WeakMap();
+const alignedOutboundStateHandlers = new WeakMap();
+function addAlignedOutboundCloseHandler(client, handler) {
+    const key = client;
+    let entry = alignedOutboundCloseHandlers.get(key);
+    if (!entry) {
+        const handlers = new Set();
+        const listener = (close) => {
+            for (const current of [...handlers])
+                current(close);
+        };
+        entry = { handlers, listener };
+        alignedOutboundCloseHandlers.set(key, entry);
+        client.on("close", listener);
+    }
+    entry.handlers.add(handler);
+    return () => {
+        entry?.handlers.delete(handler);
+    };
+}
+function addAlignedOutboundStateHandler(client, handler) {
+    const key = client;
+    let entry = alignedOutboundStateHandlers.get(key);
+    if (!entry) {
+        const handlers = new Set();
+        const listener = (state) => {
+            for (const current of [...handlers])
+                current(state);
+        };
+        entry = { handlers, listener };
+        alignedOutboundStateHandlers.set(key, entry);
+        client.on("state", listener);
+    }
+    entry.handlers.add(handler);
+    return () => {
+        entry?.handlers.delete(handler);
+    };
 }
 function getAlignedOutboundQueue(client, account, log) {
     const existing = alignedOutboundQueues.get(client);
@@ -32,25 +68,60 @@ function getAlignedOutboundQueue(client, account, log) {
     alignedOutboundQueues.set(client, queue);
     return queue;
 }
+function getAlignedMessageErrorTracker(client, account, log) {
+    const key = client;
+    const existing = alignedOutboundMessageErrorTrackers.get(key);
+    if (existing)
+        return existing;
+    const pending = new Set();
+    const listener = (env) => {
+        if (env.event !== "message.error")
+            return;
+        if (pending.has(env.trace_id)) {
+            client.markMessageErrorHandled?.(env.trace_id);
+            return;
+        }
+        if (client.hasPendingAckTrace?.(env.trace_id)) {
+            return;
+        }
+        const context = alignedOutboundContexts.get(key)?.() ?? {
+            attempt: 1,
+            reconnectCount: 0,
+            state: client.transportState === "open" ? "ready" : "reconnecting",
+        };
+        if (log?.info) {
+            log.info(formatWsLog({
+                event: "ack_unmatched",
+                accountId: account.accountId,
+                attempt: context.attempt,
+                reconnectCount: context.reconnectCount,
+                state: context.state,
+                action: "ignore",
+                fields: [
+                    ["trace_id", env.trace_id],
+                    ["chat_id", env.chat_id],
+                ],
+            }));
+            client.markMessageErrorHandled?.(env.trace_id);
+        }
+    };
+    client.on("raw", listener);
+    const tracker = { pending, listener };
+    alignedOutboundMessageErrorTrackers.set(key, tracker);
+    return tracker;
+}
 export function setAlignedOutboundLogContext(client, context) {
     alignedOutboundContexts.set(client, context);
 }
 export function flushAlignedOutboundQueue(client) {
-    const raw = getRawClientInternals(client);
-    if (!raw?.opts?.transport)
-        return;
     const queue = alignedOutboundQueues.get(client);
-    queue?.flush((wire) => raw.opts.transport.send(wire));
+    queue?.flush((wire) => client.sendWire(wire));
 }
 export function getAlignedOutboundQueueSize(client) {
     return alignedOutboundQueues.get(client)?.snapshot().length ?? 0;
 }
 async function sendAlignedAckableEnvelope(params) {
-    const raw = getRawClientInternals(params.client);
-    if (!raw?.opts?.transport || !raw.opts.traceIdFactory)
-        return null;
-    const transport = raw.opts.transport;
-    const traceId = raw.opts.traceIdFactory();
+    const traceId = params.client.nextTraceId();
     const env = {
         version: "2",
         event: params.eventName,
@@ -61,15 +132,45 @@ async function sendAlignedAckableEnvelope(params) {
     };
     const wire = JSON.stringify(env);
     const queue = getAlignedOutboundQueue(params.client, params.account, params.log);
+    const messageErrorTracker = getAlignedMessageErrorTracker(params.client, params.account, params.log);
+    const isReady = () => {
+        const state = params.client.state;
+        return params.client.transportState === "open" && (!state || state === "connected");
+    };
+    const isDisconnected = () => params.client.state === "disconnected";
     return await new Promise((resolve, reject) => {
+        let state = "queued";
         let timer;
+        let rawListenerRegistered = false;
+        let removeCloseListener;
+        let removeStateListener;
+        const clearAckTimer = () => {
+            if (!timer)
+                return;
+            clearTimeout(timer);
+            timer = undefined;
+        };
+        const removeRawListener = () => {
+            if (!rawListenerRegistered)
+                return;
+            params.client.off("raw", onRaw);
+            rawListenerRegistered = false;
+        };
         const cleanup = () => {
-            if (timer)
-                clearTimeout(timer);
-            if (raw.off)
-                raw.off("raw", onRaw);
-            else
-                raw.removeListener?.("raw", onRaw);
+            messageErrorTracker.pending.delete(traceId);
+            clearAckTimer();
+            removeRawListener();
+            removeCloseListener?.();
+            removeCloseListener = undefined;
+            removeStateListener?.();
+            removeStateListener = undefined;
+        };
+        const fail = (err) => {
+            if (state === "acked" || state === "failed")
+                return;
+            state = "failed";
+            cleanup();
+            reject(err);
         };
         const logAck = (event, action, fields) => {
             params.log?.info?.(formatWsLog({
@@ -78,7 +179,7 @@ async function sendAlignedAckableEnvelope(params) {
                 ...(alignedOutboundContexts.get(params.client)?.() ?? {
                     attempt: 1,
                     reconnectCount: 0,
-                    state: transport.state === "open" ? "ready" : "reconnecting",
+                    state: isReady() ? "ready" : "reconnecting",
                 }),
                 action,
                 fields: [
@@ -89,20 +190,40 @@ async function sendAlignedAckableEnvelope(params) {
                 ],
             }));
         };
-        const onRaw = (ack) => {
-            if (ack.event !== "message.ack" || ack.trace_id !== traceId)
+        function onRaw(ack) {
+            if (ack.trace_id !== traceId)
+                return;
+            if (ack.event === "message.error") {
+                if (state === "acked" || state === "failed")
+                    return;
+                const payload = ack.payload;
+                const code = typeof payload.code === "string" && payload.code ? payload.code : "unknown";
+                const message = typeof payload.message === "string" && payload.message ? payload.message : "message send failed";
+                fail(new MessageSendError(traceId, code, message, ack.chat_id));
                 return;
+            }
+            if (ack.event !== "message.ack")
+                return;
+            if (state === "acked" || state === "failed")
+                return;
+            state = "acked";
             cleanup();
             const payload = ack.payload;
             logAck("ack_received", "resolve", [["message_id", payload.message_id]]);
             resolve(ack);
-        };
+        }
         const startAckTimer = () => {
-            raw.on?.("raw", onRaw);
+            if (state === "acked" || state === "failed")
+                return;
+            state = "written_waiting_ack";
+            messageErrorTracker.pending.add(traceId);
+            clearAckTimer();
+            removeRawListener();
+            params.client.on("raw", onRaw);
+            rawListenerRegistered = true;
             timer = setTimeout(() => {
-                cleanup();
                 logAck("ack_timeout", "reject_no_reconnect", [["timeout_ms", params.account.ack.timeout]]);
-                reject(new Error(`ack timeout after ${params.account.ack.timeout}ms for trace_id=${traceId}`));
+                fail(new Error(`ack timeout after ${params.account.ack.timeout}ms for trace_id=${traceId}`));
             }, params.account.ack.timeout);
         };
         const item = {
@@ -111,18 +232,52 @@ async function sendAlignedAckableEnvelope(params) {
             chatId: params.chatId,
             wire,
             onWrite: startAckTimer,
+            onDrop: () => {
+                fail(new Error(`send queue full; dropped ${params.eventName} before write for trace_id=${traceId}`));
+            },
         };
-        if (transport.state !== "open") {
+        function isTerminalClose(close) {
+            return close?.code === 1000 || close?.reason === "client close" || close?.reason === "auth failed";
+        }
+        function onClose(close) {
+            if (state === "acked" || state === "failed")
+                return;
+            if (isTerminalClose(close)) {
+                const reason = typeof close?.reason === "string" && close.reason ? close.reason : "websocket closed";
+                queue.remove(item);
+                fail(new Error(`send cancelled because ${reason}`));
+                return;
+            }
+            if (state !== "written_waiting_ack")
+                return;
+            clearAckTimer();
+            removeRawListener();
+            state = "queued";
+            queue.enqueue(item);
+        }
+        function onState(next) {
+            if (state === "acked" || state === "failed" || next?.to !== "disconnected")
+                return;
+            queue.remove(item);
+            fail(new Error("send cancelled because client disconnected"));
+        }
+        removeCloseListener = addAlignedOutboundCloseHandler(params.client, onClose);
+        removeStateListener = addAlignedOutboundStateHandler(params.client, onState);
+        if (!isReady()) {
+            if (isDisconnected()) {
+                fail(new Error("send cancelled because client disconnected"));
+                return;
+            }
             queue.enqueue(item);
             return;
         }
         try {
             queue.enqueue(item);
-            queue.flush((queuedWire) => transport.send(queuedWire));
+            queue.flush((queuedWire) => params.client.sendWire(queuedWire));
         }
-        catch (err) {
-            cleanup();
-            reject(err);
+        catch {
+            // The queue keeps the failed frame at the head for reconnect retry, so
+            // keep this promise pending until the frame is written+acked, dropped, or timed out.
         }
     });
 }
@@ -179,23 +334,31 @@ export async function sendOpenclawClawlingText(params) {
     const text = (params.text ?? "").trim();
     const richFragments = params.richFragments ?? [];
     const mediaFragments = params.mediaFragments ?? [];
+    if (isClawChatNoopResponseText(text) &&
+        richFragments.length === 0 &&
+        mediaFragments.length === 0) {
+        params.log?.info?.(`[${params.account.accountId}] openclaw-clawchat outbound suppressed: silent response`);
+        return null;
+    }
     if (!text && richFragments.length === 0 && mediaFragments.length === 0) {
         params.log?.info?.(`[${params.account.accountId}] openclaw-clawchat outbound suppressed: empty text and no media`);
         return null;
     }
     const mentions = params.mentions ?? [];
     const textFragments = text ? textToFragments(text) : [];
-    // Cast at the SDK boundary: each MediaItem object is structurally compatible
-    // with one of the SDK's narrow Fragment members (ImageFragment / FileFragment /
+    // Each MediaItem object is structurally compatible
+    // with one of the local narrow Fragment members (ImageFragment / FileFragment /
     // AudioFragment / VideoFragment) based on its runtime `kind`. The wide local
     // shape lets us build a single uniform array without a per-kind switch.
     const fragments = [...textFragments, ...richFragments, ...mediaFragments];
     const useReply = Boolean(params.replyCtx);
+    const messageId = params.messageId;
     let ack;
     let mode;
     if (useReply && params.replyCtx) {
         mode = "reply";
         const payload = {
+            ...(messageId ? { message_id: messageId } : {}),
             message_mode: "normal",
             message: {
                 body: { fragments },
@@ -212,49 +375,37 @@ export async function sendOpenclawClawlingText(params) {
                 },
             },
         };
-        ack = (await sendAlignedAckableEnvelope({
+        ack = await sendAlignedAckableEnvelope({
             client: params.client,
             account: params.account,
             eventName: "message.reply",
             chatId: params.to.chatId,
             payload,
             ...(params.log ? { log: params.log } : {}),
-        })) ?? await params.client.replyMessage({
-            chat_id: params.to.chatId,
-            mode: "normal",
-            replyTo: {
-                msgId: params.replyCtx.replyToMessageId,
-                senderId: params.replyCtx.replyPreviewSenderId,
-                nickName: params.replyCtx.replyPreviewNickName,
-                fragments: [{ kind: "text", text: params.replyCtx.replyPreviewText }],
-            },
-            body: { fragments },
-            context: { mentions },
         });
     }
     else {
         mode = "send";
         const payload = {
+            ...(messageId ? { message_id: messageId } : {}),
             message_mode: "normal",
             message: {
                 body: { fragments },
                 context: { mentions, reply: null },
             },
         };
-        ack = (await sendAlignedAckableEnvelope({
+        ack = await sendAlignedAckableEnvelope({
             client: params.client,
             account: params.account,
             eventName: "message.send",
             chatId: params.to.chatId,
             payload,
             ...(params.log ? { log: params.log } : {}),
-        })) ?? await params.client.sendMessage({
-            chat_id: params.to.chatId,
-            mode: "normal",
-            body: { fragments },
-            context: { mentions, reply: null },
         });
     }
+    if (messageId && ack.payload.message_id !== messageId) {
+        throw new Error(`ack message_id mismatch: expected ${messageId} got ${ack.payload.message_id}`);
+    }
     params.log?.info?.(`[${params.account.accountId}] openclaw-clawchat outbound mode=${mode} msg=${ack.payload.message_id} text_len=${text.length} media=${mediaFragments.length} trace=${ack.trace_id}`);
     return {
         messageId: ack.payload.message_id,
@@ -281,11 +432,48 @@ export async function sendOpenclawClawlingMedia(params) {
         to: params.to,
         text: params.text ?? "",
         mediaFragments: params.mediaFragments,
+        ...(params.messageId ? { messageId: params.messageId } : {}),
         ...(params.replyCtx ? { replyCtx: params.replyCtx } : {}),
         ...(params.mentions ? { mentions: params.mentions } : {}),
         ...(params.log ? { log: params.log } : {}),
     });
 }
+function mintOutboundMessageId(account) {
+    return `${account.userId}-msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function resolveChannelOutboundStore() {
+    try {
+        const runtime = getOpenclawClawlingRuntime();
+        const stateDir = runtime.state?.resolveStateDir?.();
+        return getClawChatStore({
+            ...(stateDir ? { dbPath: clawChatDbPathForStateDir(stateDir) } : {}),
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function claimChannelOutbound(params) {
+    const store = resolveChannelOutboundStore();
+    if (!store)
+        return null;
+    try {
+        return store.claimMessageOnce({
+            platform: "openclaw",
+            accountId: params.account.accountId,
+            kind: "message",
+            direction: "outbound",
+            eventType: "message.send",
+            chatId: params.target.chatId,
+            messageId: params.messageId,
+            text: params.text,
+            raw: params.raw,
+        });
+    }
+    catch {
+        return null;
+    }
+}
 export const openclawClawlingOutbound = {
     deliveryMode: "direct",
     chunker: (text, limit) => chunkMarkdownText(text, limit),
@@ -297,15 +485,35 @@ export const openclawClawlingOutbound = {
             const account = resolveOpenclawClawlingAccount(cfg);
             const client = getOpenclawClawlingClient(account.accountId) ??
                 (await waitForOpenclawClawlingClient(account.accountId));
+            const target = parseOpenclawRecipient(to);
+            const messageId = mintOutboundMessageId(account);
+            const trimmedText = text.trim();
+            if (!trimmedText) {
+                throw new Error("openclaw-clawchat sendText requires non-empty text");
+            }
+            const claimed = claimChannelOutbound({
+                account,
+                target,
+                messageId,
+                text: trimmedText,
+                raw: { target, mode: "channel-sendText" },
+            });
+            if (claimed === false) {
+                throw new Error("openclaw-clawchat outbound duplicate claim; message not sent");
+            }
+            if (claimed === null) {
+                throw new Error("openclaw-clawchat outbound message claim failed");
+            }
             const result = await sendOpenclawClawlingText({
                 client,
                 account,
-                to: parseOpenclawRecipient(to),
+                to: target,
                 text,
+                messageId,
             });
             return {
                 to,
-                messageId: result?.messageId ?? `${account.userId}-${Date.now()}`,
+                messageId: result?.messageId ?? messageId,
             };
         },
         sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile }) => {
@@ -331,16 +539,33 @@ export const openclawClawlingOutbound = {
             if (mediaFragments.length === 0) {
                 throw new Error(`openclaw-clawchat failed to upload media: ${mediaUrl}`);
             }
+            const target = parseOpenclawRecipient(to);
+            const messageId = mintOutboundMessageId(account);
+            const claimText = (text ?? "").trim();
+            const claimed = claimChannelOutbound({
+                account,
+                target,
+                messageId,
+                text: claimText,
+                raw: { target, mode: "channel-sendMedia", mediaCount: mediaFragments.length },
+            });
+            if (claimed === false) {
+                throw new Error("openclaw-clawchat outbound duplicate claim; message not sent");
+            }
+            if (claimed === null) {
+                throw new Error("openclaw-clawchat outbound message claim failed");
+            }
             const result = await sendOpenclawClawlingMedia({
                 client,
                 account,
-                to: parseOpenclawRecipient(to),
+                to: target,
                 text,
                 mediaFragments,
+                messageId,
             });
             return {
                 to,
-                messageId: result?.messageId ?? `${account.userId}-${Date.now()}`,
+                messageId: result?.messageId ?? messageId,
             };
         },
     }),

package/dist/src/plugin-prompts.js

@@ -0,0 +1,76 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const REQUIRED_PROMPT_NAMES = ["platform"];
+const OPTIONAL_PROMPT_NAMES = ["user", "group"];
+function findDefaultPluginRoot() {
+    let current = path.dirname(fileURLToPath(import.meta.url));
+    const root = path.parse(current).root;
+    while (true) {
+        if (fs.existsSync(path.join(current, "prompts")) ||
+            fs.existsSync(path.join(current, "openclaw.plugin.json"))) {
+            return current;
+        }
+        if (current === root) {
+            return process.cwd();
+        }
+        current = path.dirname(current);
+    }
+}
+function readRequiredPrompt(root, name) {
+    const promptPath = path.join(root, "prompts", `${name}.md`);
+    let prompt = "";
+    try {
+        prompt = fs.readFileSync(promptPath, "utf8").trim();
+    }
+    catch (error) {
+        throw new Error(`missing or empty ClawChat prompt: ${name} at ${promptPath}`, {
+            cause: error,
+        });
+    }
+    if (prompt.length === 0) {
+        throw new Error(`missing or empty ClawChat prompt: ${name} at ${promptPath}`);
+    }
+    return prompt;
+}
+function readOptionalPrompt(root, name) {
+    const promptPath = path.join(root, "prompts", `${name}.md`);
+    if (!fs.existsSync(promptPath)) {
+        return "";
+    }
+    const prompt = fs.readFileSync(promptPath, "utf8").trim();
+    if (prompt.length === 0) {
+        throw new Error(`missing or empty ClawChat prompt: ${name} at ${promptPath}`);
+    }
+    return prompt;
+}
+export function loadClawChatPromptsFromRoot(root) {
+    const prompts = {
+        platform: "",
+        user: "",
+        group: "",
+    };
+    for (const name of REQUIRED_PROMPT_NAMES) {
+        prompts[name] = readRequiredPrompt(root, name);
+    }
+    for (const name of OPTIONAL_PROMPT_NAMES) {
+        prompts[name] = readOptionalPrompt(root, name);
+    }
+    return Object.freeze(prompts);
+}
+const CLAWCHAT_PROMPTS = loadClawChatPromptsFromRoot(findDefaultPluginRoot());
+export function getClawChatPlatformPrompt() {
+    return CLAWCHAT_PROMPTS.platform;
+}
+export function getClawChatUserPrompt() {
+    return CLAWCHAT_PROMPTS.user;
+}
+export function getClawChatGroupPrompt() {
+    return CLAWCHAT_PROMPTS.group;
+}
+export function getClawChatModePrompt(mode) {
+    if (mode === "group") {
+        return getClawChatGroupPrompt();
+    }
+    return getClawChatUserPrompt();
+}