clawgram 2.10.0 → 2.11.0

package/dist/channel.js

@@ -101,6 +101,9 @@ async function reactToSilentMentionForAccount(params) {
             // method that needs its receiver.
             complete: (args) => llm.complete(args),
             sendReaction: (args) => gram.sendReaction(args),
+            allowedReactions: gram.getAllowedReactions
+                ? () => gram.getAllowedReactions(params.chatId)
+                : undefined,
             onDecision: (info) => actionLog.info("clawgram silent-mention reaction", {
                 accountId: params.accountId,
                 ...info,

package/dist/gramjs-client.js

@@ -360,6 +360,46 @@ class GramJsClientManager {
         })().catch(() => undefined);
         return { entity, full };
     }
+    /**
+     * Which reactions a chat permits, or `undefined` when it permits all.
+     *
+     * Telegram models this three ways on the full chat: absent or
+     * `ChatReactionsAll` means everything, `ChatReactionsSome` carries the
+     * allowed list, and `ChatReactionsNone` means reactions are switched off —
+     * reported here as an empty list, which callers must read as "react with
+     * nothing", not as "no restriction".
+     *
+     * Custom emoji entries are dropped: they need a Premium account to send.
+     */
+    async getAllowedReactions(target) {
+        const resolved = await this.resolvePeer(target);
+        const entity = await this.client.getEntity(resolved.peer);
+        const full = await (async () => {
+            switch (entity?.className) {
+                case "Channel":
+                    return (await this.client.invoke(new telegram_1.Api.channels.GetFullChannel({
+                        channel: entity,
+                    }))).fullChat;
+                case "Chat":
+                    return (await this.client.invoke(new telegram_1.Api.messages.GetFullChat({
+                        chatId: entity.id,
+                    }))).fullChat;
+                default:
+                    return undefined;
+            }
+        })();
+        const available = full?.availableReactions;
+        switch (available?.className) {
+            case "ChatReactionsNone":
+                return [];
+            case "ChatReactionsSome":
+                return (available.reactions ?? [])
+                    .map((reaction) => reaction?.emoticon)
+                    .filter((emoticon) => typeof emoticon === "string");
+            default:
+                return undefined;
+        }
+    }
     /**
      * Adds or clears this account's reaction on a message.
      *

package/dist/silent-reaction.js

@@ -20,17 +20,32 @@
  * tested without Telegram or a model.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_REACTIONS = void 0;
 exports.buildEmojiSystemPrompt = buildEmojiSystemPrompt;
+exports.canonicalizeReactionEmoji = canonicalizeReactionEmoji;
 exports.parseEmojiChoice = parseEmojiChoice;
 exports.shouldReactToSilentTurn = shouldReactToSilentTurn;
 exports.reactToSilentMention = reactToSilentMention;
-function buildEmojiSystemPrompt(appetite) {
+function buildEmojiSystemPrompt(appetite, allowed) {
+    const choices = allowed === undefined || allowed.length === 0 ? exports.TELEGRAM_REACTIONS : allowed;
     const shared = [
         "You pick a single emoji reaction for a chat message.",
         "The assistant was mentioned in this message but decided it needs no written reply.",
         "Answer with exactly one emoji and nothing else, or the word NONE if no reaction fits.",
-        "Match the mood of the message: a joke gets something amused, praise something warm,",
-        "bad news something sympathetic, an achievement something celebratory.",
+        // The set is not decoration: Telegram refuses anything outside it, and an
+        // answer outside it is discarded, so offering the choices up front is the
+        // difference between a reaction and silence.
+        `Choose ONLY from this set, copied exactly: ${choices.join(" ")}`,
+        // Fixed answers the owner asked for by name. They come before the mood
+        // rule because the model's own instinct here was wrong in a specific way:
+        // it answered 👍 to being praised, which reads as approving of the praise
+        // rather than being touched by it.
+        "Three situations have a fixed answer. Use it, and do not substitute a similar emoji:",
+        `- the assistant is praised or thanked, or someone speaks well of it → ❤ (never \u{1F44D} here)`,
+        `- the assistant is asked or told to do something → \u{1FAE1}, or \u{1F44C} for a small routine request`,
+        `- the message is about producing something written — a text, a reply, a document, a draft → ✍`,
+        "Otherwise match the mood: a joke gets something amused, bad news something",
+        "sympathetic, an achievement something celebratory.",
         "Answer NONE when the message is conflictual, heavy, or discusses a person's",
         "performance — a reaction there reads as a verdict on someone.",
     ];
@@ -45,14 +60,50 @@ function buildEmojiSystemPrompt(appetite) {
         ].join("\n");
 }
 /**
- * Turns a model answer into an emoji, or nothing.
+ * The emoji Telegram accepts as reactions, in the exact form it expects.
  *
- * Deliberately strict. A wrong emoji is a visible act on someone else's
- * message, and Telegram rejects emoji outside the chat's allowed set anyway —
- * so anything that does not look like a bare emoji is treated as "no
- * reaction" rather than sent hopefully.
+ * Reactions are not "any emoji". Telegram keeps a fixed set, and several of
+ * its members carry **no** variation selector — `❤` is U+2764 alone, and so
+ * are `⚡`, `✍`, `🕊`, `☃`. Sending the U+FE0F-decorated form of any of them
+ * fails, which is exactly what happened on the first live attempt:
+ *
+ *   RPCError: 400: REACTION_INVALID (caused by messages.SendReaction)
+ *
+ * The list is written with explicit escapes for those five, because the
+ * difference is invisible in an editor and a stray U+FE0F would break them
+ * again silently.
+ */
+exports.TELEGRAM_REACTIONS = [
+    "👍", "👎", "❤", "🔥", "🥰", "👏", "😁", "🤔", "🤯", "😱",
+    "🤬", "😢", "🎉", "🤩", "🤮", "💩", "🙏", "👌", "\u{1F54A}", "🤡",
+    "🥱", "🥴", "😍", "🐳", "🌚", "🌭", "💯", "🤣", "⚡", "🍌",
+    "🏆", "💔", "🤨", "😐", "🍓", "🍾", "💋", "😈", "😴", "😭",
+    "🤓", "👻", "👀", "🎃", "🙈", "😇", "😨", "🤝", "✍", "🤗",
+    "🫡", "🎅", "🎄", "☃", "💅", "🤪", "🗿", "🆒", "💘", "🙉",
+    "🦄", "😘", "💊", "🙊", "😎", "👾", "🤷", "😡",
+];
+/**
+ * Strips the decorations a model adds that Telegram will not accept.
+ *
+ * U+FE0F is the big one — models emit `❤️` and `⚡️` by habit, and the reaction
+ * set wants them bare. Skin-tone modifiers are dropped for the same reason:
+ * `👍🏽` is not a member of the set, `👍` is.
+ */
+function canonicalizeReactionEmoji(value) {
+    return value.replace(/️/g, "").replace(/[\u{1F3FB}-\u{1F3FF}]/gu, "");
+}
+/**
+ * Turns a model answer into an emoji Telegram will actually take, or nothing.
+ *
+ * Deliberately strict, and strict in the one way that matters: the result is
+ * matched against the reaction set rather than merely "looks like an emoji".
+ * The first live attempt proved the difference — the model picked a perfectly
+ * sensible emoji, the parser passed it, and Telegram refused it.
+ *
+ * `allowed` narrows the set further for chats that restrict which reactions
+ * they permit; omit it when the chat allows all of them.
  */
-function parseEmojiChoice(raw) {
+function parseEmojiChoice(raw, allowed) {
     if (typeof raw !== "string") {
         return undefined;
     }
@@ -65,12 +116,14 @@ function parseEmojiChoice(raw) {
     if (/\s/.test(cleaned) || cleaned.length > 8) {
         return undefined;
     }
-    // Latin letters and digits mean words like "NONE", "ok" or "1" slipped
-    // through; an emoji has none of them.
-    if (/[A-Za-z0-9]/.test(cleaned)) {
-        return undefined;
-    }
-    return cleaned;
+    const candidate = canonicalizeReactionEmoji(cleaned);
+    // `undefined` is "the chat does not restrict reactions"; an empty list is
+    // `ChatReactionsNone` — reactions switched off — and must permit nothing.
+    // Collapsing the two would react in a chat that forbids reacting.
+    const permitted = allowed === undefined
+        ? exports.TELEGRAM_REACTIONS
+        : allowed.map(canonicalizeReactionEmoji);
+    return permitted.includes(candidate) ? candidate : undefined;
 }
 /**
  * Whether a silent turn deserves a reaction attempt at all.
@@ -111,14 +164,32 @@ async function reactToSilentMention(params) {
     if (!Number.isInteger(messageId) || messageId <= 0) {
         return undefined;
     }
+    // A chat that restricts reactions would reject anything outside its own set,
+    // so the restriction has to reach the model rather than be discovered by a
+    // rejected send. Not knowing is not the same as being forbidden: a failure
+    // here falls back to the full Telegram set.
+    const allowed = await (params.deps.allowedReactions?.() ?? Promise.resolve(undefined))
+        .catch(() => undefined);
+    // Reactions switched off for the whole chat: nothing to pick from, and no
+    // reason to spend a model call finding that out.
+    if (allowed !== undefined && allowed.length === 0) {
+        params.deps.onDecision?.({ messageId, appetite, chose: "none", allowedCount: 0 });
+        return undefined;
+    }
     const answer = await params.deps.complete({
         messages: [{ role: "user", content: String(params.messageText ?? "").slice(0, MAX_JUDGED_CHARS) }],
-        systemPrompt: buildEmojiSystemPrompt(appetite),
+        systemPrompt: buildEmojiSystemPrompt(appetite, allowed),
         maxTokens: 8,
         purpose: "clawgram: emoji reaction for a silent mention",
     });
-    const emoji = parseEmojiChoice(answer?.text);
-    params.deps.onDecision?.({ messageId, appetite, chose: emoji ? "emoji" : "none" });
+    const emoji = parseEmojiChoice(answer?.text, allowed);
+    params.deps.onDecision?.({
+        messageId,
+        appetite,
+        chose: emoji ? "emoji" : "none",
+        emoji,
+        allowedCount: allowed?.length,
+    });
     if (!emoji) {
         return undefined;
     }

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.10.0",
+  "version": "2.11.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

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