whatsapp-pi 1.0.61 → 1.0.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whatsapp-pi",
-  "version": "1.0.61",
+  "version": "1.0.62",
   "type": "module",
   "description": "WhatsApp integration extension for Pi",
   "main": "whatsapp-pi.ts",

package/src/i18n.ts

@@ -189,6 +189,11 @@ const fallback = {
     "incoming.media.contact": "[Contact]",
     "incoming.media.location": "[Location]",
     "incoming.media.unsupported": "[Unsupported Message Type: {typeName}]",
+    "incoming.media.reaction": "{emoji} Reacted to message",
+    "incoming.media.reactionRemoved": "Removed reaction",
+    "tool.sendReaction.label": "Send WhatsApp Reaction",
+    "tool.sendReaction.description": "React to a WhatsApp message with an emoji",
+    "tool.sendReaction.error.invalidEmoji": "Invalid emoji provided",
     "incoming.media.audioTranscribing": "[WhatsApp-Pi] Transcribing audio from {pushName}...",
     "incoming.media.audioTranscribed": "[Transcribed Audio]: {transcription}",
     "incoming.media.imageDownloading": "[WhatsApp-Pi] Downloading image from {pushName}...",
@@ -387,6 +392,11 @@ const translations: Record<Locale, Partial<Record<Key, string>>> = {
         "incoming.media.documentDownloading": "[WhatsApp-Pi] Baixando documento de {pushName}: {fileName}...",
         "incoming.media.documentSaved": "[WhatsApp-Pi] Documento salvo em {relativePath} ({size} bytes)",
         "incoming.media.documentReceived": "[Documento recebido: {fileName}]",
+        "incoming.media.reaction": "{emoji} Reagiu à mensagem",
+        "incoming.media.reactionRemoved": "Reação removida",
+        "tool.sendReaction.label": "Enviar Reação no WhatsApp",
+        "tool.sendReaction.description": "Reagir a uma mensagem do WhatsApp com um emoji",
+        "tool.sendReaction.error.invalidEmoji": "Emoji inválido",
         "incoming.media.documentMimeType": "Tipo MIME: {mimeType}",
         "incoming.media.documentSize": "Tamanho: {size}",
         "incoming.media.documentLocation": "Local: {relativePath}",
@@ -531,6 +541,11 @@ const translations: Record<Locale, Partial<Record<Key, string>>> = {
         "session.manager.failedSaveConfig": "Error al guardar config:",
         "session.manager.invalidNumber": "[SessionManager] Intento de añadir número inválido:",
         "session.manager.failedDeleteAuthState": "Error al eliminar el estado de autenticación:",
+        "incoming.media.reaction": "{emoji} Reaccionó al mensaje",
+        "incoming.media.reactionRemoved": "Reacción eliminada",
+        "tool.sendReaction.label": "Enviar Reacción en WhatsApp",
+        "tool.sendReaction.description": "Reaccionar a un mensaje de WhatsApp con un emoji",
+        "tool.sendReaction.error.invalidEmoji": "Emoji inválido",
     },
     fr: {
         "tool.label": "Envoyer un message WhatsApp",

package/src/services/incoming-message.resolver.ts

@@ -9,6 +9,7 @@ export type IncomingResolution =
     | { kind: 'contact'; text: string }
     | { kind: 'location'; text: string }
     | { kind: 'system'; text: string }
+    | { kind: 'reaction'; text: string; reactionMessage: any }
     | { kind: 'unsupported'; text: string };
 
 const protocolTypes: Record<number, keyof typeof protocolLabels> = {
@@ -146,5 +147,21 @@ export const extractIncomingText = (message: any): IncomingResolution => {
         return { kind: 'text', text: resolved.templateButtonReplyMessage.selectedDisplayText };
     }
 
+    if (resolved?.reactionMessage) {
+        const emoji = resolved.reactionMessage.text;
+        if (emoji) {
+            return {
+                kind: 'reaction',
+                text: t('incoming.media.reaction', { emoji }),
+                reactionMessage: resolved.reactionMessage
+            };
+        }
+        return {
+            kind: 'reaction',
+            text: t('incoming.media.reactionRemoved'),
+            reactionMessage: resolved.reactionMessage
+        };
+    }
+
     return { kind: 'unsupported', text: t('incoming.media.unsupported', { typeName }) };
 };

package/src/services/reaction.sender.ts

@@ -0,0 +1,65 @@
+import { t } from '../i18n.js';
+
+export interface SendReactionOptions {
+    jid: string;
+    messageId: string;
+    emoji: string;
+}
+
+export interface SendReactionResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+}
+
+// Socket interface that matches what we need from Baileys
+interface ReactionSocket {
+    sendMessage: (jid: string, content: { react: { text: string; key: { remoteJid: string; id: string; fromMe: boolean } } }) => Promise<{ key?: { id?: string | null } } | undefined>;
+}
+
+export class ReactionSender {
+    constructor(private socket: ReactionSocket | null) {}
+
+    async sendReaction(options: SendReactionOptions): Promise<SendReactionResult> {
+        if (!this.socket) {
+            return { success: false, error: t('service.whatsapp.notConnected') };
+        }
+
+        // Validate emoji (must be single emoji or empty string to remove)
+        if (!this.isValidEmoji(options.emoji)) {
+            return { success: false, error: t('tool.sendReaction.error.invalidEmoji') };
+        }
+
+        try {
+            const result = await this.socket.sendMessage(options.jid, {
+                react: {
+                    text: options.emoji,
+                    key: {
+                        remoteJid: options.jid,
+                        id: options.messageId,
+                        fromMe: false
+                    }
+                }
+            });
+
+            return {
+                success: true,
+                messageId: result?.key?.id ?? undefined
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+
+    private isValidEmoji(emoji: string): boolean {
+        // Allow empty string (removes reaction)
+        if (emoji === '') return true;
+        // Check if single emoji using Unicode emoji regex
+        // This matches single Unicode emojis including variation selectors
+        const emojiRegex = /^(\p{Emoji_Presentation}|\p{Emoji}\uFE0F)$/u;
+        return emojiRegex.test(emoji);
+    }
+}

package/whatsapp-pi.ts

@@ -8,6 +8,7 @@ import { AudioService } from './src/services/audio.service.js';
 import { extractIncomingText } from './src/services/incoming-message.resolver.js';
 import { IncomingMediaService } from './src/services/incoming-media.service.js';
 import { WhatsAppPiLogger } from './src/services/whatsapp-pi.logger.js';
+import { ReactionSender } from './src/services/reaction.sender.js';
 import { initI18n, t } from './src/i18n.js';
 
 const shutdownState = globalThis as typeof globalThis & {
@@ -205,16 +206,16 @@ export default function (pi: ExtensionAPI) {
         ctx.ui.notify('WhatsApp: Session reset via /new is now fully supported.', 'info');
     });
 
-    // Track whether send_wa_message tool already sent a reply this turn
-    let toolSentToJid: string | null = null;
-
-    const toRecentSenderNumber = (recipientJid: string): string => {
-        if (recipientJid.endsWith('@g.us')) {
-            return recipientJid;
-        }
-
-        return `+${recipientJid.split('@')[0]}`;
-    };
+    // Track whether send_wa_message tool already sent a reply this turn
+    let toolSentToJid: string | null = null;
+
+    const toRecentSenderNumber = (recipientJid: string): string => {
+        if (recipientJid.endsWith('@g.us')) {
+            return recipientJid;
+        }
+
+        return `+${recipientJid.split('@')[0]}`;
+    };
 
     // Handle incoming messages by injecting them as user prompts
     whatsappService.setMessageCallback(async (m) => {
@@ -326,15 +327,15 @@ export default function (pi: ExtensionAPI) {
                 formattedMessage
             ].join('\n'));
 
-            const outboundJid = whatsappService.resolveOutboundRecipientJid(resolvedJid);
-            const result = await whatsappService.sendMessage(outboundJid, params.message);
+            const outboundJid = whatsappService.resolveOutboundRecipientJid(resolvedJid);
+            const result = await whatsappService.sendMessage(outboundJid, params.message);
 
             if (result.success) {
                 // Mark that tool already sent to this JID — prevents message_end from re-sending
-                toolSentToJid = outboundJid;
-                await recentsService.recordMessage({
-                    messageId: result.messageId!,
-                    senderNumber: toRecentSenderNumber(outboundJid),
+                toolSentToJid = outboundJid;
+                await recentsService.recordMessage({
+                    messageId: result.messageId!,
+                    senderNumber: toRecentSenderNumber(outboundJid),
                     text: params.message,
                     direction: 'outgoing',
                     timestamp: Date.now()
@@ -362,6 +363,44 @@ export default function (pi: ExtensionAPI) {
         }
     });
 
+    // Register send_reaction tool (LLM-callable)
+    pi.registerTool({
+        name: "send_reaction",
+        label: t("tool.sendReaction.label"),
+        description: t("tool.sendReaction.description"),
+        promptSnippet: "send_reaction(jid, messageId, emoji) - React to a WhatsApp message with an emoji. The 'jid' is the chat JID (e.g. 5511999998888@s.whatsapp.net), 'messageId' is the ID of the message to react to, and 'emoji' is the emoji to react with (e.g., 👍, ❤️, 😂).",
+        parameters: Type.Object({
+            jid: Type.String({ description: "WhatsApp JID of the chat (e.g. 5511999998888@s.whatsapp.net or 120363012345@g.us)" }),
+            messageId: Type.String({ description: "ID of the message to react to" }),
+            emoji: Type.String({ description: "Emoji to react with (e.g., 👍, ❤️, 😂). Use empty string to remove reaction." })
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            // Get socket from WhatsApp service
+            const socket = whatsappService.getSocket();
+            if (!socket) {
+                return {
+                    isError: true,
+                    details: undefined,
+                    content: [{ type: "text" as const, text: JSON.stringify({ success: false, error: t("service.whatsapp.notConnected") }) }]
+                };
+            }
+
+            // Create sender with the socket
+            const sender = new ReactionSender(socket as any);
+            const result = await sender.sendReaction({
+                jid: params.jid,
+                messageId: params.messageId,
+                emoji: params.emoji
+            });
+
+            return {
+                isError: !result.success,
+                details: undefined,
+                content: [{ type: "text" as const, text: JSON.stringify({ success: result.success, messageId: result.messageId, error: result.error }) }]
+            };
+        }
+    });
+
     // Suppress automatic message_end reply when tool already sent
     // This is checked by the message_end handler below
 
@@ -385,10 +424,10 @@ export default function (pi: ExtensionAPI) {
     // Handle outgoing messages (Agent -> WhatsApp)
     pi.on("agent_start", async (_event, _ctx) => {
         if (sessionManager.getStatus() !== 'connected') return;
-        const lastJid = whatsappService.getLastRemoteJid();
-        if (lastJid) {
-            await whatsappService.sendPresence(whatsappService.resolveOutboundRecipientJid(lastJid), 'composing');
-        }
+        const lastJid = whatsappService.getLastRemoteJid();
+        if (lastJid) {
+            await whatsappService.sendPresence(whatsappService.resolveOutboundRecipientJid(lastJid), 'composing');
+        }
     });
 
     pi.on("message_end", async (event, ctx) => {
@@ -396,26 +435,26 @@ export default function (pi: ExtensionAPI) {
 
         const { message } = event;
         // Only reply if it's the assistant and we have a valid target
-        if (message.role === "assistant") {
-            const lastJid = whatsappService.getLastRemoteJid();
-            const text = message.content.filter(c => c.type === "text").map(c => c.text).join("\n");
-            const outboundJid = lastJid
-                ? whatsappService.resolveOutboundRecipientJid(lastJid)
-                : null;
-
-            // Skip if send_wa_message tool already sent a reply to this JID
-            if (toolSentToJid === outboundJid) {
-                toolSentToJid = null;
-                return;
-            }
-
-            if (outboundJid && text) {
-                try {
-                    const result = await whatsappService.sendMessage(outboundJid, text);
-                    if (result.success) {
-                        await recentsService.recordMessage({
-                            messageId: result.messageId ?? `${Date.now()}`,
-                            senderNumber: toRecentSenderNumber(outboundJid),
+        if (message.role === "assistant") {
+            const lastJid = whatsappService.getLastRemoteJid();
+            const text = message.content.filter(c => c.type === "text").map(c => c.text).join("\n");
+            const outboundJid = lastJid
+                ? whatsappService.resolveOutboundRecipientJid(lastJid)
+                : null;
+
+            // Skip if send_wa_message tool already sent a reply to this JID
+            if (toolSentToJid === outboundJid) {
+                toolSentToJid = null;
+                return;
+            }
+
+            if (outboundJid && text) {
+                try {
+                    const result = await whatsappService.sendMessage(outboundJid, text);
+                    if (result.success) {
+                        await recentsService.recordMessage({
+                            messageId: result.messageId ?? `${Date.now()}`,
+                            senderNumber: toRecentSenderNumber(outboundJid),
                             text,
                             direction: 'outgoing',
                             timestamp: Date.now()