clawgram 2.13.0 → 2.14.0

package/dist/channel.js

@@ -1305,7 +1305,11 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 };
             },
             extractToolSend: ({ args }) => (0, tool_send_1.extractToolSend)(args, "sendMessage"),
-            handleAction: async ({ action, params, cfg, accountId, dryRun, toolContext }) => {
+            handleAction: async ({ action, params, cfg, accountId, dryRun: dryRunFlag, toolContext }) => {
+                // Core passes the flag beside `params`; callers write it inside.
+                // Both count, because a rehearsal flag that is silently ignored puts
+                // a real message in a real chat — twice, so far (2.13.1).
+                const dryRun = (0, helpers_1.resolveDryRun)(dryRunFlag, params);
                 // `read` is what OpenClaw core dispatches (`openclaw message read`,
                 // MCP `messages_read`). `list` is accepted as a synonym so a caller that
                 // guessed the other obvious name is not silently refused.
@@ -1830,10 +1834,15 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                         accountId: resolvedAccountId,
                     });
                 }
+                // Whom to greet is decided by the message this turn is answering, not
+                // by whoever spoke last. An agent replying to a request rarely passes
+                // `replyToId`, and until 2026-08-10 that fell through to the most
+                // recent sender: in an interleaved chat the owner's report went out
+                // addressed to a colleague who had asked something else entirely.
                 const groupReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
                     accountId: resolvedAccountId,
                     chatId: to,
-                    replyToId,
+                    replyToId: replyToId ?? currentMessageId,
                 });
                 const requestedText = (0, helpers_1.readMessageText)(params).replaceAll("\\n", "\n");
                 // `NO_REPLY` is OpenClaw's "say nothing" sentinel. The inbound pipeline
@@ -1892,6 +1901,17 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                         currentMessageId,
                     });
                 }
+                // The turn has now spoken for itself. Recorded for every send into the
+                // chat this turn came from — with or without an explicit replyToId —
+                // so that core delivering the turn's final text a few seconds later
+                // can be recognised as an echo of this same answer.
+                if (currentMessageId !== null && currentMessageId !== undefined) {
+                    (0, group_visible_reply_guard_1.rememberTurnSend)({
+                        accountId: resolvedAccountId,
+                        chatId: to,
+                        currentMessageId,
+                    });
+                }
                 actionLog.info("clawgram handleAction send completed", {
                     accountId: resolvedAccountId,
                     to,
@@ -1965,6 +1985,28 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 if (!gram) {
                     throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
                 }
+                // The agent already answered this message with its own `send`, and this
+                // is core delivering the same turn's final text. Two messages for one
+                // answer is how 2026-08-10 read in a work chat: every request reported
+                // twice, in slightly different words, seconds apart.
+                //
+                // Core's own convention is that an agent which has sent a message
+                // returns NO_REPLY; this catches the turns that forget. The window is
+                // seconds wide, so a result the assistant comes back with later is
+                // still delivered.
+                if (ctx.replyToId !== null && ctx.replyToId !== undefined && (0, group_visible_reply_guard_1.hadTurnSendJustNow)({
+                    accountId: ctx.accountId,
+                    chatId: (0, helpers_1.normalizeOutboundTarget)(ctx.to),
+                    currentMessageId: ctx.replyToId,
+                })) {
+                    actionLog.warn("clawgram suppressing echo of a turn that already sent", {
+                        accountId: ctx.accountId,
+                        rawTo: ctx.to,
+                        replyToId: ctx.replyToId,
+                        textLength: ctx.text.length,
+                    });
+                    return { skipped: "duplicate" };
+                }
                 const groupReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
                     accountId: ctx.accountId,
                     chatId: ctx.to,

package/dist/group-reply-address.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rememberGroupReplyAddress = rememberGroupReplyAddress;
 exports.consumeGroupReplyAddress = consumeGroupReplyAddress;
+exports.resetGroupReplyAddresses = resetGroupReplyAddresses;
 exports.buildGroupReplyAddress = buildGroupReplyAddress;
 const helpers_1 = require("./helpers");
 const groupReplyAddresses = new Map();
 const GROUP_REPLY_ADDRESS_TTL_MS = 10 * 60 * 1000;
-const GROUP_REPLY_LATEST_ID = "__latest__";
 function normalizeGroupReplyTarget(rawTarget) {
     if (typeof rawTarget !== "string") {
         return String(rawTarget ?? "").trim();
@@ -33,23 +33,20 @@ function rememberGroupReplyAddress(input) {
         address: input.address,
         expiresAt: Date.now() + GROUP_REPLY_ADDRESS_TTL_MS,
     });
-    const latestKey = buildGroupReplyAddressKey({
-        ...input,
-        replyToId: GROUP_REPLY_LATEST_ID,
-    });
-    if (latestKey) {
-        groupReplyAddresses.set(latestKey, {
-            address: input.address,
-            expiresAt: Date.now() + GROUP_REPLY_ADDRESS_TTL_MS,
-        });
-    }
 }
+/**
+ * The address remembered for one specific incoming message.
+ *
+ * There used to be a `__latest__` entry as well, so that a send carrying no
+ * `replyToId` still greeted somebody. In a chat where requests interleave that
+ * "somebody" is whoever spoke last, which on 2026-08-10 put the owner's report
+ * out as "@colleague, готово": the colleague read a result they had not asked
+ * for, and the owner's own request looked unanswered. Recency is not an answer
+ * to "who am I replying to", so the fallback is gone — callers pass the message
+ * the turn is actually answering, and no message means no greeting.
+ */
 function consumeGroupReplyAddress(input) {
-    const latestKey = buildGroupReplyAddressKey({
-        ...input,
-        replyToId: GROUP_REPLY_LATEST_ID,
-    });
-    const key = buildGroupReplyAddressKey(input) ?? latestKey;
+    const key = buildGroupReplyAddressKey(input);
     if (!key) {
         return undefined;
     }
@@ -58,14 +55,15 @@ function consumeGroupReplyAddress(input) {
         return undefined;
     }
     groupReplyAddresses.delete(key);
-    if (latestKey) {
-        groupReplyAddresses.delete(latestKey);
-    }
     if (stored.expiresAt < Date.now()) {
         return undefined;
     }
     return stored.address;
 }
+/** Test seam: the map is module state, and suites must not leak into each other. */
+function resetGroupReplyAddresses() {
+    groupReplyAddresses.clear();
+}
 function buildGroupReplyAddress(input) {
     const username = input.senderUsername?.replace(/^@/, "").trim();
     if (username) {

package/dist/group-visible-reply-guard.js

@@ -2,9 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasRecentVisibleGroupReply = hasRecentVisibleGroupReply;
 exports.rememberVisibleGroupReply = rememberVisibleGroupReply;
+exports.rememberTurnSend = rememberTurnSend;
+exports.hadTurnSendJustNow = hadTurnSendJustNow;
+exports.resetVisibleGroupReplies = resetVisibleGroupReplies;
 const helpers_1 = require("./helpers");
+/** When each visible reply went out, keyed by account + chat + incoming message. */
 const recentVisibleGroupReplies = new Map();
 const GROUP_VISIBLE_REPLY_TTL_MS = 10 * 60 * 1000;
+/**
+ * How long after the agent's own send core's delivery of the same turn's final
+ * text still counts as an echo rather than as something new.
+ *
+ * Measured on the live incident: `handleAction send` at 12:39:02, core's
+ * delivery at 12:39:09 — seven seconds, twice in a row. Work that produces
+ * genuinely new information takes far longer, and the window has to stay well
+ * under that: dropping a real result is worse than letting a duplicate through.
+ */
+const GROUP_TURN_ECHO_WINDOW_MS = 20 * 1000;
 function buildVisibleGroupReplyKey(input) {
     const chatId = (0, helpers_1.normalizeOutboundTarget)(String(input.chatId ?? "").trim());
     const currentMessageId = input.currentMessageId === null || input.currentMessageId === undefined
@@ -39,10 +53,59 @@ function hasRecentVisibleGroupReply(input) {
     }
     return true;
 }
-function rememberVisibleGroupReply(input) {
+function rememberVisibleGroupReply(input, sentAt = Date.now()) {
     const key = buildVisibleGroupReplyKey(input);
     if (!key) {
         return;
     }
-    recentVisibleGroupReplies.set(key, Date.now() + GROUP_VISIBLE_REPLY_TTL_MS);
+    recentVisibleGroupReplies.set(key, sentAt + GROUP_VISIBLE_REPLY_TTL_MS);
+}
+/**
+ * When a turn last spoke for itself, keyed the same way.
+ *
+ * Kept apart from `recentVisibleGroupReplies` on purpose: that map drives a
+ * ten-minute suppression of repeated sends, and widening what feeds it would
+ * quietly make that rule stricter. This one answers a different question —
+ * did core just echo the turn that has only now finished.
+ */
+const lastTurnSends = new Map();
+/** Records that the agent itself put a message in the chat during this turn. */
+function rememberTurnSend(input, sentAt = Date.now()) {
+    const key = buildVisibleGroupReplyKey(input);
+    if (!key) {
+        return;
+    }
+    lastTurnSends.set(key, sentAt);
+}
+/**
+ * True when this turn already put a visible message in this chat moments ago.
+ *
+ * The case it exists for: the agent answers by calling `send`, then returns
+ * text as well, and core delivers that text as a second message. Both are the
+ * same answer — on 2026-08-10 every request in a work chat was reported twice,
+ * and the reader had to work out that the two messages were one event.
+ *
+ * Bounded by `GROUP_TURN_ECHO_WINDOW_MS` rather than by the ten-minute TTL:
+ * beyond a few seconds the assistant is coming back with something new, and
+ * dropping that would lose a real result.
+ */
+function hadTurnSendJustNow(input, now = Date.now()) {
+    const key = buildVisibleGroupReplyKey(input);
+    if (!key) {
+        return false;
+    }
+    const sentAt = lastTurnSends.get(key);
+    if (sentAt === undefined) {
+        return false;
+    }
+    if (now - sentAt > GROUP_TURN_ECHO_WINDOW_MS) {
+        lastTurnSends.delete(key);
+        return false;
+    }
+    return true;
+}
+/** Test seam: module state must not leak between suites. */
+function resetVisibleGroupReplies() {
+    recentVisibleGroupReplies.clear();
+    lastTurnSends.clear();
 }

package/dist/helpers.js

@@ -38,6 +38,7 @@ exports.resolveSenderProfileWithTimeout = resolveSenderProfileWithTimeout;
 exports.normalizeParseMode = normalizeParseMode;
 exports.resolveReplyParseMode = resolveReplyParseMode;
 exports.resolveOutboundParseMode = resolveOutboundParseMode;
+exports.resolveDryRun = resolveDryRun;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const core_1 = require("openclaw/plugin-sdk/core");
@@ -578,6 +579,25 @@ function resolveReplyParseMode(cfg, accountId) {
     const account = channel?.accounts?.[accountId] ?? channel;
     return normalizeParseMode(account?.replyParseMode);
 }
+/**
+ * Whether this call is a rehearsal, from either position the flag can arrive.
+ *
+ * Core passes `dryRun` as a sibling of `params`. Callers put it inside
+ * `params`, next to `to` and `text`, because that is where every other
+ * parameter lives — and there it used to be read by nobody: the flag vanished
+ * and the send happened for real.
+ *
+ * That is the worst possible failure mode for a safety flag, and it has cost
+ * two irreversible messages in a work chat (2026-08-08, note 0066; and
+ * 2026-08-10 at 02:49 UTC, a bare "ping" the agent then could not delete,
+ * because this channel has no delete action). Either position now counts, and
+ * a disagreement resolves toward **not** sending: a caller who wrote
+ * "dry run" anywhere meant it somewhere.
+ */
+function resolveDryRun(dryRun, params) {
+    const fromParams = params?.dryRun;
+    return dryRun === true || dryRun === "true" || fromParams === true || fromParams === "true";
+}
 /**
  * Parse mode for the `send` action (2.13.0).
  *

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "clawgram",
   "name": "Clawgram",
   "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawgram",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
   "main": "./dist/index.js",
   "scripts": {