whatsapp-pi 1.0.60 → 1.0.61

package/package.json

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

package/src/services/whatsapp.service.ts

@@ -185,11 +185,27 @@ export class WhatsAppService {
         return value;
     }
 
-    private normalizeRecipientJid(jid: string): string {
-        if (jid.includes('@')) return jid;
-        const digits = jid.startsWith('+') ? jid.slice(1) : jid;
-        return `${digits}@s.whatsapp.net`;
-    }
+    private normalizeRecipientJid(jid: string): string {
+        if (jid.includes('@')) return jid;
+        const digits = jid.startsWith('+') ? jid.slice(1) : jid;
+        return `${digits}@s.whatsapp.net`;
+    }
+
+    public resolveOutboundRecipientJid(recipient: string): string {
+        if (SessionManager.isGroupJid(recipient)) {
+            return recipient;
+        }
+
+        const senderNumber = this.normalizeContactNumber(recipient.split('@')[0]);
+        const allowedContact = this.sessionManager.getAllowedContact(recipient)
+            ?? this.sessionManager.getAllowedContact(senderNumber);
+
+        if (allowedContact?.sendNumber) {
+            return this.normalizeRecipientJid(allowedContact.sendNumber);
+        }
+
+        return this.normalizeRecipientJid(recipient);
+    }
 
     private normalizeJidForComparison(jid: string): string {
         const [localPart, domain = ''] = jid.split('@');
@@ -653,27 +669,29 @@ export class WhatsAppService {
         }
     }
 
-    async sendMessage(jid: string, text: string) {
-        // Ensure we show the typing indicator before sending
-        await this.sendPresence(jid, 'composing');
-
-        const result = await this.messageSender.send({
-            recipientJid: jid,
-            text: text
-        });
-
-        // After sending, we can stop the typing indicator
-        await this.sendPresence(jid, 'paused');
-
-        if (!result.success) {
-            console.error(t('service.whatsapp.failedSendMessage', { jid, error: result.error ?? t('message.sender.unknownError') }));
-        }
-
-        return result;
-    }
-
-    async sendMenuMessage(jid: string, text: string) {
-        const normalizedJid = this.normalizeRecipientJid(jid);
+    async sendMessage(jid: string, text: string) {
+        const recipientJid = this.resolveOutboundRecipientJid(jid);
+
+        // Ensure we show the typing indicator before sending
+        await this.sendPresence(recipientJid, 'composing');
+
+        const result = await this.messageSender.send({
+            recipientJid,
+            text: text
+        });
+
+        // After sending, we can stop the typing indicator
+        await this.sendPresence(recipientJid, 'paused');
+
+        if (!result.success) {
+            console.error(t('service.whatsapp.failedSendMessage', { jid: recipientJid, error: result.error ?? t('message.sender.unknownError') }));
+        }
+
+        return result;
+    }
+
+    async sendMenuMessage(jid: string, text: string) {
+        const normalizedJid = this.resolveOutboundRecipientJid(jid);
         const socket = this.getActiveSocket();
 
         if (!socket) {

package/src/ui/message-reply.view.ts

@@ -41,13 +41,21 @@ const buildReplyWidget = (selectedMessage: SelectedMessageContext): string[] =>
     ];
 };
 
-const buildReplyTitle = (selectedMessage: SelectedMessageContext): string => {
+const buildReplyTitle = (selectedMessage: SelectedMessageContext): string => {
     const sender = selectedMessage.senderName
         ? `${selectedMessage.senderName} (${selectedMessage.senderNumber})`
         : selectedMessage.senderNumber;
 
-    return truncateToWidth(`${t('message.reply.title')} ${sender}`, 120);
-};
+    return truncateToWidth(`${t('message.reply.title')} ${sender}`, 120);
+};
+
+const toRecentSenderNumber = (recipientJid: string): string => {
+    if (recipientJid.endsWith('@g.us')) {
+        return recipientJid;
+    }
+
+    return `+${recipientJid.split('@')[0]}`;
+};
 
 export async function showMessageReplyView(
     ctx: MessageReplyContext,
@@ -70,24 +78,27 @@ export async function showMessageReplyView(
                 continue;
             }
 
-            const draft: ReplyDraft = {
-                text,
-                targetMessageId: props.selectedMessage.messageId,
-                targetConversation: props.selectedMessage.senderNumber
-            };
-
-            const result: ReplySendResult = await props.whatsappService.sendMenuMessage(
-                props.selectedMessage.senderNumber,
-                draft.text
-            );
-
-            if (result.success) {
-                await props.recentsService.recordMessage({
-                    messageId: result.messageId ?? `${Date.now()}`,
-                    senderNumber: props.selectedMessage.senderNumber,
-                    senderName: props.selectedMessage.senderName,
-                    text: draft.text,
-                    direction: 'outgoing',
+            const draft: ReplyDraft = {
+                text,
+                targetMessageId: props.selectedMessage.messageId,
+                targetConversation: props.selectedMessage.senderNumber
+            };
+            const recipientJid = props.whatsappService.resolveOutboundRecipientJid(
+                props.selectedMessage.senderNumber
+            );
+
+            const result: ReplySendResult = await props.whatsappService.sendMenuMessage(
+                recipientJid,
+                draft.text
+            );
+
+            if (result.success) {
+                await props.recentsService.recordMessage({
+                    messageId: result.messageId ?? `${Date.now()}`,
+                    senderNumber: toRecentSenderNumber(recipientJid),
+                    senderName: props.selectedMessage.senderName,
+                    text: draft.text,
+                    direction: 'outgoing',
                     timestamp: Date.now()
                 });
                 ctx.ui.notify(t('message.reply.sent', { preview: buildPreview(props.selectedMessage.text) }), 'info');

package/whatsapp-pi.ts

@@ -205,8 +205,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;
+    // 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) => {
@@ -318,16 +326,15 @@ export default function (pi: ExtensionAPI) {
                 formattedMessage
             ].join('\n'));
 
-            const result = await whatsappService.sendMessage(resolvedJid, 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 = resolvedJid;
-                const isGroupJid = resolvedJid.endsWith('@g.us');
-                const senderNumber = isGroupJid ? resolvedJid : `+${resolvedJid.split('@')[0]}`;
-                await recentsService.recordMessage({
-                    messageId: result.messageId!,
-                    senderNumber,
+                toolSentToJid = outboundJid;
+                await recentsService.recordMessage({
+                    messageId: result.messageId!,
+                    senderNumber: toRecentSenderNumber(outboundJid),
                     text: params.message,
                     direction: 'outgoing',
                     timestamp: Date.now()
@@ -378,10 +385,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(lastJid, 'composing');
-        }
+        const lastJid = whatsappService.getLastRemoteJid();
+        if (lastJid) {
+            await whatsappService.sendPresence(whatsappService.resolveOutboundRecipientJid(lastJid), 'composing');
+        }
     });
 
     pi.on("message_end", async (event, ctx) => {
@@ -389,23 +396,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");
-
-            // Skip if send_wa_message tool already sent a reply to this JID
-            if (toolSentToJid === lastJid) {
-                toolSentToJid = null;
-                return;
-            }
-
-            if (lastJid && text) {
-                try {
-                    const result = await whatsappService.sendMessage(lastJid, text);
-                    if (result.success) {
-                        await recentsService.recordMessage({
-                            messageId: result.messageId ?? `${Date.now()}`,
-                            senderNumber: `+${lastJid.split('@')[0]}`,
+        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()