waengine 2.3.9 → 2.4.4

package/FEATURES.md

@@ -1013,6 +1013,174 @@ const type = client.getMessageType(message)
 
 ---
 
+## 🎨 Console Renderer **NEU in v2.0.0!**
+
+### **Schöne Console-Ausgabe mit Custom Prefix und Farben**
+
+Verwandle deine Console in ein professionelles Dashboard mit automatischen Prefixes und Farben für alle Ausgaben!
+
+```javascript
+import { WhatsAppClient, render } from 'waengine';
+
+const client = new WhatsAppClient();
+
+// Prefix und Farben konfigurieren
+render.consolePrefix('MyBot');           // Prefix: [MyBot]
+render.consolePrefixColor('cyan');       // Prefix-Farbe
+render.consoleColor('green');            // Standard-Farbe
+render.consoleError('red');              // Fehler-Farbe
+render.consoleWarn('yellow');            // Warn-Farbe
+render.consoleInfo('blue');              // Info-Farbe
+
+// Jetzt haben ALLE Console-Ausgaben automatisch den Prefix!
+console.log('Bot gestartet!');           // [MyBot] Bot gestartet!
+console.error('Ein Fehler!');            // [MyBot] Ein Fehler! (rot)
+console.warn('Warnung!');                // [MyBot] Warnung! (gelb)
+console.info('Information');             // [MyBot] Information (blau)
+```
+
+### **Verfügbare Farben (30+ Farben)**
+
+**Basic Colors:**
+- `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`
+
+**Bright Colors:**
+- `brightRed`, `brightGreen`, `brightYellow`, `brightBlue`, `brightMagenta`, `brightCyan`, `brightWhite`
+
+**Background Colors:**
+- `bgBlack`, `bgRed`, `bgGreen`, `bgYellow`, `bgBlue`, `bgMagenta`, `bgCyan`, `bgWhite`
+
+**Bright Backgrounds:**
+- `bgBrightRed`, `bgBrightGreen`, `bgBrightYellow`, `bgBrightBlue`, `bgBrightMagenta`, `bgBrightCyan`, `bgBrightWhite`
+
+**Styles:**
+- `bold`, `dim`, `italic`, `underline`, `inverse`, `strikethrough`
+
+### **Direkte Print-Funktionen**
+```javascript
+// Direkt mit Farbe ausgeben (ohne Prefix)
+render.print('Wichtige Nachricht', 'red');
+render.print('Erfolg!', 'green');
+
+// Success Helper (grün mit ✓)
+render.success('Operation erfolgreich!');
+
+// Alle verfügbaren Farben anzeigen
+render.showColors();
+```
+
+### **Renderer Control**
+```javascript
+// Renderer aktivieren/deaktivieren
+render.enable();   // Aktivieren
+render.disable();  // Deaktivieren
+
+// Komplett zurücksetzen
+render.reset();    // Entfernt alle Patches
+```
+
+### **Praktische Anwendungen**
+```javascript
+// Bot mit schöner Console
+import { WhatsAppClient, render } from 'waengine';
+
+const client = new WhatsAppClient();
+
+// Setup
+render.consolePrefix('WABot');
+render.consolePrefixColor('brightCyan');
+render.consoleColor('white');
+render.consoleError('brightRed');
+render.consoleWarn('brightYellow');
+
+client.on('message', async (msg) => {
+    console.log(`Nachricht von ${msg.from}: ${msg.text}`);
+    // Output: [WABot] Nachricht von 123@s.whatsapp.net: Hello
+});
+
+client.on('error', (error) => {
+    console.error(`Fehler: ${error.message}`);
+    // Output: [WABot] Fehler: Connection lost (rot)
+});
+
+// Multi-Bot mit verschiedenen Farben
+const bot1 = new WhatsAppClient();
+render.consolePrefix('Bot1');
+render.consolePrefixColor('green');
+
+const bot2 = new WhatsAppClient();
+render.consolePrefix('Bot2');
+render.consolePrefixColor('blue');
+```
+
+### **Console Renderer Features**
+- ✅ **Auto-Prefix** - Automatischer Prefix vor JEDER Console-Ausgabe
+- ✅ **30+ Farben** - Basic, Bright, Background, Styles
+- ✅ **Separate Farben** - Unterschiedliche Farben für log/error/warn/info
+- ✅ **Prefix-Farbe** - Eigene Farbe für den Prefix
+- ✅ **Direct Print** - Direkte Ausgabe ohne Prefix
+- ✅ **Success Helper** - Grüne Success-Messages mit ✓
+- ✅ **Color Preview** - Alle Farben anzeigen
+- ✅ **Enable/Disable** - Renderer an/aus schalten
+- ✅ **Reset** - Komplett zurücksetzen
+- ✅ **Zero Config** - Funktioniert out-of-the-box
+
+### **Beispiel: Multi-Bot Dashboard**
+```javascript
+import { WhatsAppClient, render } from 'waengine';
+
+// Bot 1 - Grün
+render.consolePrefix('Support');
+render.consolePrefixColor('brightGreen');
+const supportBot = new WhatsAppClient();
+
+// Bot 2 - Blau  
+render.consolePrefix('Sales');
+render.consolePrefixColor('brightBlue');
+const salesBot = new WhatsAppClient();
+
+// Bot 3 - Magenta
+render.consolePrefix('Admin');
+render.consolePrefixColor('brightMagenta');
+const adminBot = new WhatsAppClient();
+
+// Jetzt hat jeder Bot seine eigene Farbe in der Console!
+// [Support] Nachricht empfangen... (grün)
+// [Sales] Kunde kontaktiert... (blau)
+// [Admin] Gruppe erstellt... (magenta)
+```
+
+---
+
+## 🗑️ MessageDel API - Nachrichten von anderen Usern löschen **NEU in v2.0.0!**
+
+### **Admin-Funktion zum Löschen von Nachrichten anderer User**
+
+Lösche Nachrichten von anderen Usern in Gruppen (erfordert Admin-Rechte)!
+
+```javascript
+// Nachricht von anderem User löschen
+const result = await msg.MessageDel(messageId, participantJid);
+
+if (result.success) {
+    console.log('✅ Nachricht gelöscht!');
+} else {
+    console.log(`❌ Fehler: ${result.reason}`);
+}
+```
+
+### **Return Object**
+```javascript
+{
+    success: boolean,           // true wenn erfolgreich
+    messageId: string,          // ID der gelöschten Nachricht
+    participant: string,        // JID des ursprünglichen Senders
+    wasFromBot: boolean,        // true wenn Bot-Nachricht
+    result: object,             // Baileys Result Object
+    reason: string,     
+
+---
+
 ## 💾 Storage System
 
 ### **Einfache Storage API**

package/README.md

@@ -100,7 +100,7 @@ client.on('truly_connected', (data) => {
 - **Button Messages** - Interactive buttons with callbacks
 - **List Messages** - Organized lists with sections
 - **Template Messages** - Reusable message templates
-- **Carousel Messages** - Swipeable card carousels with VIDEO support! 🎬
+- **Interactive Carousel** - REAL swipeable carousel in ONE message with VIDEO support! 🎬
 
 ### 👥 **Advanced Group Features**
 - **Group Settings** - Control who can send messages
@@ -216,10 +216,20 @@ client.setPrefix('!');
 // NEW: Ignore offline messages to prevent spam
 client.ignore.message.offline(true);
 
+// NEW: Control if bot ignores its own messages (default: true)
+client.ignore.message.FromMe(true);  // Bot ignores itself (prevents loops)
+// client.ignore.message.FromMe(false); // Bot reacts to own messages
+
 client.on('message', async (msg) => {
     if (msg.text === 'hello') {
         await msg.simulateTyping('Hello! How can I help?');
     }
+    
+    // Dynamically change FromMe ignore during runtime
+    if (msg.text === '/enable-echo') {
+        msg.ignore.FromMe(false); // Bot now reacts to own messages
+        await msg.reply('Echo mode enabled!');
+    }
 });
 
 await client.connect();
@@ -859,6 +869,111 @@ const type = client.getMessageType(message)
 
 ---
 
+## 🤖 FromMe Ignore API
+
+### **Control Bot Self-Interaction**
+
+By default, the bot ignores its own messages to prevent infinite loops. You can control this behavior:
+
+```javascript
+import { WhatsAppClient } from "waengine";
+
+const client = new WhatsAppClient();
+
+// ✅ Default: Bot ignores its own messages (prevents loops)
+client.ignore.message.FromMe(true);
+
+// ❌ Bot reacts to its own messages (use with caution!)
+client.ignore.message.FromMe(false);
+
+client.on('message', async (msg) => {
+    if (msg.text === '/menu') {
+        // With FromMe(true): Bot sends /menu but doesn't process it ✅
+        // With FromMe(false): Bot sends /menu and processes it again ❌ (loop!)
+        await msg.reply('📋 Menu: /help, /info, /status');
+    }
+});
+
+await client.connect();
+```
+
+### **Dynamic Control During Runtime**
+
+```javascript
+client.on('message', async (msg) => {
+    // Enable echo mode (bot reacts to own messages)
+    if (msg.text === '/echo-on') {
+        msg.ignore.FromMe(false);
+        await msg.reply('🔊 Echo mode enabled!');
+    }
+    
+    // Disable echo mode (bot ignores own messages)
+    if (msg.text === '/echo-off') {
+        msg.ignore.FromMe(true);
+        await msg.reply('🔇 Echo mode disabled!');
+    }
+    
+    // Check current status
+    if (msg.text === '/status') {
+        const status = client.ignoreFromMe ? 'ACTIVE ✅' : 'INACTIVE ❌';
+        await msg.reply(`FromMe Ignore: ${status}`);
+    }
+});
+```
+
+### **Use Cases**
+
+**Standard Bot (Recommended):**
+```javascript
+// Default behavior - bot ignores itself
+// No configuration needed!
+client.on('message', async (msg) => {
+    if (msg.text === '/menu') {
+        await msg.reply('Menu displayed!');
+        // ✅ No infinite loop
+    }
+});
+```
+
+**Echo Bot:**
+```javascript
+// Bot reacts to own messages
+client.ignore.message.FromMe(false);
+
+const processedIds = new Set();
+
+client.on('message', async (msg) => {
+    // Prevent infinite loops with message ID tracking
+    if (processedIds.has(msg.id)) return;
+    processedIds.add(msg.id);
+    
+    if (!msg.text.startsWith('/')) {
+        await msg.reply(`Echo: ${msg.text}`);
+    }
+});
+```
+
+**Self-Testing Bot:**
+```javascript
+// Bot tests its own commands
+client.ignore.message.FromMe(false);
+
+client.on('message', async (msg) => {
+    if (msg.text === '/test-all') {
+        // Bot sends and processes its own commands
+        await msg.reply('/help');
+        await msg.reply('/info');
+        await msg.reply('/status');
+    }
+});
+```
+
+⚠️ **Important:** When using `FromMe(false)`, always implement loop prevention mechanisms!
+
+📚 **Full Documentation:** See [FROMME-IGNORE-API.md](./FROMME-IGNORE-API.md)
+
+---
+
 ## 📚 Examples
 
 ### **EasyBot (Beginners)**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "2.3.9",
+  "version": "2.4.4",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with 860+ Working Features, Complete Baileys Integration & Production-Ready Stability",
   "main": "src/index.js",
   "type": "module",

package/src/advanced-features.js

@@ -235,75 +235,170 @@ export class AdvancedMessage {
         }
     }
 
-    async sendCarouselMessage(cards) {
+    async sendCarouselMessage(cards, options = {}) {
         try {
-            // WhatsApp Carousel mit Video & Image Support
-            const results = [];
+            const fs = await import('fs');
+            const { prepareWAMessageMedia, generateWAMessageFromContent } = await import('@whiskeysockets/baileys');
             
-            for (let i = 0; i < cards.length; i++) {
-                const card = cards[i];
-                
-                // Build card text
-                let cardText = `🎴 **${i + 1}/${cards.length}: ${card.title}**\n`;
-                if (card.subtitle) cardText += `${card.subtitle}\n\n`;
-                if (card.body) cardText += `${card.body}`;
-                if (card.footer) cardText += `\n\n_${card.footer}_`;
-                
-                // Add buttons as text
-                if (card.buttons && card.buttons.length > 0) {
-                    cardText += `\n\n**Options:**\n`;
-                    card.buttons.forEach((btn, btnIndex) => {
-                        cardText += `${btnIndex + 1}. ${btn.text || btn.title}\n`;
-                    });
-                }
+            // Default options
+            const carouselHeader = options.header || 'Carousel';
+            const carouselBody = options.body || 'Swipe to see all options';
+            
+            // Prepare all cards with media
+            const preparedCards = [];
+            
+            for (const [index, card] of cards.entries()) {
+                const carouselCard = {
+                    body: card.body || '',
+                    footer: card.footer || `${index + 1}/${cards.length}`,
+                    header: {
+                        title: card.title,
+                        subtitle: card.subtitle || '',
+                        hasMediaAttachment: false
+                    },
+                    nativeFlowMessage: {
+                        buttons: []
+                    }
+                };
                 
-                // Send with appropriate media type
-                let result;
+                // Prepare media if exists
                 if (card.video) {
-                    // Video card
-                    result = await this.socket.sendMessage(this.msg.from, {
-                        video: { url: card.video },
-                        caption: cardText,
-                        gifPlayback: card.gifPlayback || false
-                    });
+                    try {
+                        const videoBuffer = fs.readFileSync(card.video);
+                        const preparedMedia = await prepareWAMessageMedia(
+                            { video: videoBuffer },
+                            { upload: this.socket.waUploadToServer }
+                        );
+                        
+                        if (preparedMedia && preparedMedia.videoMessage) {
+                            carouselCard.header.hasMediaAttachment = true;
+                            carouselCard.header.videoMessage = preparedMedia.videoMessage;
+                        }
+                    } catch (mediaError) {
+                        console.error('⚠️ Video preparation failed:', mediaError.message);
+                        // Continue without video
+                    }
                 } else if (card.image) {
-                    // Image card
-                    result = await this.socket.sendMessage(this.msg.from, {
-                        image: { url: card.image },
-                        caption: cardText
-                    });
-                } else {
-                    // Text-only card
-                    result = await this.msg.reply(cardText);
+                    try {
+                        const imageBuffer = fs.readFileSync(card.image);
+                        const preparedMedia = await prepareWAMessageMedia(
+                            { image: imageBuffer },
+                            { upload: this.socket.waUploadToServer }
+                        );
+                        
+                        if (preparedMedia && preparedMedia.imageMessage) {
+                            carouselCard.header.hasMediaAttachment = true;
+                            carouselCard.header.imageMessage = preparedMedia.imageMessage;
+                        }
+                    } catch (mediaError) {
+                        console.error('⚠️ Image preparation failed:', mediaError.message);
+                        // Continue without image
+                    }
                 }
                 
-                results.push(result);
-                
-                // Small delay between cards
-                if (i < cards.length - 1) {
-                    await new Promise(resolve => setTimeout(resolve, 500));
+                // Add buttons
+                if (card.buttons && card.buttons.length > 0) {
+                    carouselCard.nativeFlowMessage.buttons = card.buttons.map(btn => ({
+                        name: 'quick_reply',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: btn.text || btn.title,
+                            id: btn.id || `btn_${index}`
+                        })
+                    }));
                 }
+                
+                preparedCards.push(carouselCard);
             }
             
-            return results;
+            // Create the carousel message structure
+            const message = generateWAMessageFromContent(
+                this.msg.from,
+                {
+                    viewOnceMessage: {
+                        message: {
+                            interactiveMessage: {
+                                header: {
+                                    title: carouselHeader,
+                                    hasMediaAttachment: false
+                                },
+                                body: {
+                                    text: carouselBody
+                                },
+                                carouselMessage: {
+                                    cards: preparedCards
+                                }
+                            }
+                        }
+                    }
+                },
+                { userJid: this.socket.user.id }
+            );
+            
+            return await this.socket.relayMessage(this.msg.from, message.message, {
+                messageId: message.key.id
+            });
+            
         } catch (error) {
-            console.error('❌ Carousel Message fehlgeschlagen:', error);
-            // Fallback: Sende Cards als Text
-            const results = [];
-            for (const card of cards) {
-                try {
-                    let cardText = `🎴 **${card.title}**\n`;
-                    if (card.subtitle) cardText += `${card.subtitle}\n\n`;
-                    cardText += card.body;
-                    if (card.footer) cardText += `\n\n_${card.footer}_`;
-                    
-                    const result = await this.msg.reply(cardText);
-                    results.push(result);
-                } catch (cardError) {
-                    console.error('❌ Card fehlgeschlagen:', cardError);
+            console.error('❌ Interactive Carousel fehlgeschlagen:', error);
+            
+            // Fallback: Send videos individually
+            try {
+                console.log('🔄 Fallback: Sending cards individually...');
+                const results = [];
+                const fs = await import('fs');
+                
+                for (const [index, card] of cards.entries()) {
+                    try {
+                        const caption = `${card.title}\n\n${card.body || ''}\n\n${card.footer || ''}`;
+                        
+                        if (card.video) {
+                            // Send as video using socket directly
+                            const videoBuffer = fs.readFileSync(card.video);
+                            await this.socket.sendMessage(this.msg.from, {
+                                video: videoBuffer,
+                                caption: caption,
+                                gifPlayback: card.gifPlayback || false
+                            });
+                        } else if (card.image) {
+                            // Send as image using socket directly
+                            const imageBuffer = fs.readFileSync(card.image);
+                            await this.socket.sendMessage(this.msg.from, {
+                                image: imageBuffer,
+                                caption: caption
+                            });
+                        } else {
+                            // Send as text
+                            await this.socket.sendMessage(this.msg.from, {
+                                text: caption
+                            });
+                        }
+                        results.push({ index, success: true });
+                        
+                        // Small delay between messages
+                        if (index < cards.length - 1) {
+                            await new Promise(resolve => setTimeout(resolve, 1000));
+                        }
+                    } catch (cardError) {
+                        console.error(`❌ Card ${index} fehlgeschlagen:`, cardError);
+                        results.push({ index, success: false, error: cardError.message });
+                    }
                 }
+                
+                console.log('✅ Fallback completed:', results);
+                return { type: 'fallback_individual', results };
+                
+            } catch (fallbackError) {
+                console.error('❌ Individual fallback fehlgeschlagen:', fallbackError);
+                
+                // Final fallback: Text list
+                const fallbackText = cards.map((card, i) => 
+                    `${i + 1}. **${card.title}**\n${card.body || ''}`
+                ).join('\n\n');
+                
+                return await this.socket.sendMessage(this.msg.from, {
+                    text: fallbackText
+                });
             }
-            return results;
         }
     }
 }

package/src/client.js

@@ -145,6 +145,9 @@ export class WhatsAppClient {
         this.ignoredMessagesCount = 0; // Counter für ignorierte Messages
         this.offlineMessageTimer = null; // Timer für finale Zusammenfassung
         
+        // FromMe Ignore System - NEUE GLOBALE API!
+        this.ignoreFromMe = true; // Standard: Bot ignoriert sich selbst
+        
         // Log wenn automatisch aktiviert
         if (this.ignoreOfflineMessages) {
             console.log('\n📵 Offline Message Ignore: AUTOMATISCH AKTIVIERT');
@@ -178,6 +181,11 @@ export class WhatsAppClient {
                     this.ignoreOfflineMessages = enabled;
                     console.log(`📵 Offline Message Ignore: ${enabled ? 'AKTIVIERT' : 'DEAKTIVIERT'}`);
                     return this;
+                },
+                FromMe: (enabled = true) => {
+                    this.ignoreFromMe = enabled;
+                    console.log(`🤖 FromMe Ignore: ${enabled ? 'AKTIVIERT (Bot ignoriert sich selbst)' : 'DEAKTIVIERT (Bot reagiert auf eigene Messages)'}`);
+                    return this;
                 }
             }
         };
@@ -373,7 +381,7 @@ export class WhatsAppClient {
             this.socket = makeWASocket({
                 version,
                 auth: state,
-                logger: pino({ level: this.options.logLevel }),
+                logger: pino({ level: 'silent' }), // Force silent to prevent session logs
                 browser: this.options.browser,
                 generateHighQualityLinkPreview: true,
                 syncFullHistory: true, // Wichtig für Message-Empfang
@@ -394,7 +402,7 @@ export class WhatsAppClient {
         } catch (versionError) {
             this.socket = makeWASocket({
                 auth: state,
-                logger: pino({ level: this.options.logLevel }),
+                logger: pino({ level: 'silent' }), // Force silent to prevent session logs
                 browser: this.options.browser,
                 generateHighQualityLinkPreview: true,
                 syncFullHistory: true, // Wichtig für Message-Empfang
@@ -993,7 +1001,12 @@ export class WhatsAppClient {
                 }
                 
                 // Bessere Message-Validierung
-                if (!msg.message || msg.key.fromMe) return;
+                if (!msg.message) return;
+                
+                // FromMe Ignore - DEINE NEUE FUNKTION!
+                if (this.ignoreFromMe && msg.key.fromMe) {
+                    return; // Bot ignoriert seine eigenen Messages
+                }
                 
                 // OFFLINE MESSAGE IGNORE - DEINE NEUE FUNKTION!
                 if (this.ignoreOfflineMessages && this.connectionStartTime) {

package/src/message.js

@@ -37,6 +37,15 @@ export class Message {
                 }
             }
         };
+        
+        // Ignore API - DEINE NEUE FUNKTION!
+        this.ignore = {
+            FromMe: (enabled = true) => {
+                this.client.ignoreFromMe = enabled;
+                console.log(`🤖 FromMe Ignore: ${enabled ? 'AKTIVIERT (Bot ignoriert sich selbst)' : 'DEAKTIVIERT (Bot reagiert auf eigene Messages)'}`);
+                return this;
+            }
+        };
 
         // ===== ADVANCED FEATURES INTEGRATION - NEU! =====
         this.advanced = new AdvancedMessage(this);

package/src/ui-components.js

@@ -6,88 +6,91 @@ export class UIComponents {
     // ===== CAROUSEL MESSAGES =====
     
     /**
-     * Send carousel message with multiple cards
-     * Supports: images, videos, and text-only cards
+     * Send REAL carousel message with swipeable cards in ONE message
+     * Uses WhatsApp Interactive Message API
      */
     async sendCarousel(chatId, cards, options = {}) {
         try {
-            // WhatsApp doesn't support native carousels, so we create a rich media alternative
-            let carouselText = `🎠 **${options.title || 'Carousel'}**\n\n`;
-            
-            cards.forEach((card, index) => {
-                carouselText += `**${index + 1}. ${card.title}**\n`;
-                if (card.subtitle) carouselText += `${card.subtitle}\n`;
-                if (card.body) carouselText += `${card.body}\n`;
-                if (card.price) carouselText += `💰 ${card.price}\n`;
-                
-                // Add buttons as text options
-                if (card.buttons && card.buttons.length > 0) {
-                    carouselText += `Options: `;
-                    card.buttons.forEach((btn, btnIndex) => {
-                        carouselText += `[${btnIndex + 1}] ${btn.title} `;
-                    });
-                    carouselText += `\n`;
+            // Build proper WhatsApp Interactive Carousel Message
+            const carouselMessage = {
+                interactiveMessage: {
+                    header: {
+                        title: options.title || 'Carousel',
+                        hasMediaAttachment: false
+                    },
+                    body: {
+                        text: options.body || 'Swipe to see all options'
+                    },
+                    footer: {
+                        text: options.footer || ''
+                    },
+                    carouselMessage: {
+                        cards: cards.map((card, index) => {
+                            const carouselCard = {
+                                body: {
+                                    text: card.body || card.description || ''
+                                },
+                                footer: {
+                                    text: card.footer || `${index + 1}/${cards.length}`
+                                },
+                                nativeFlowMessage: {
+                                    buttons: []
+                                }
+                            };
+                            
+                            // Add header with media
+                            if (card.video) {
+                                carouselCard.header = {
+                                    title: card.title,
+                                    subtitle: card.subtitle || '',
+                                    hasMediaAttachment: true,
+                                    videoMessage: {
+                                        url: card.video,
+                                        gifPlayback: card.gifPlayback || false
+                                    }
+                                };
+                            } else if (card.image) {
+                                carouselCard.header = {
+                                    title: card.title,
+                                    subtitle: card.subtitle || '',
+                                    hasMediaAttachment: true,
+                                    imageMessage: {
+                                        url: card.image
+                                    }
+                                };
+                            } else {
+                                carouselCard.header = {
+                                    title: card.title,
+                                    subtitle: card.subtitle || '',
+                                    hasMediaAttachment: false
+                                };
+                            }
+                            
+                            // Add buttons
+                            if (card.buttons && card.buttons.length > 0) {
+                                carouselCard.nativeFlowMessage.buttons = card.buttons.map(btn => ({
+                                    name: 'quick_reply',
+                                    buttonParamsJson: JSON.stringify({
+                                        display_text: btn.title || btn.text,
+                                        id: btn.id || `btn_${index}_${btn.title}`
+                                    })
+                                }));
+                            }
+                            
+                            return carouselCard;
+                        })
+                    }
                 }
-                
-                carouselText += `\n`;
-            });
-            
-            if (options.footer) {
-                carouselText += `\n_${options.footer}_`;
-            }
+            };
             
-            // Send each card with its media (image or video)
-            for (let i = 0; i < cards.length; i++) {
-                const card = cards[i];
-                
-                // Build card text
-                let cardText = `**${i + 1}/${cards.length}: ${card.title}**\n`;
-                if (card.subtitle) cardText += `${card.subtitle}\n`;
-                if (card.body) cardText += `${card.body}\n`;
-                if (card.price) cardText += `💰 ${card.price}\n`;
-                
-                if (card.buttons && card.buttons.length > 0) {
-                    cardText += `\nOptions: `;
-                    card.buttons.forEach((btn, btnIndex) => {
-                        cardText += `[${btnIndex + 1}] ${btn.title} `;
-                    });
-                }
-                
-                if (options.footer) {
-                    cardText += `\n\n_${options.footer}_`;
-                }
-                
-                // Send with appropriate media type
-                if (card.video) {
-                    // Video card
-                    await this.client.socket.sendMessage(chatId, {
-                        video: { url: card.video },
-                        caption: cardText,
-                        gifPlayback: card.gifPlayback || false
-                    });
-                } else if (card.image) {
-                    // Image card
-                    await this.client.socket.sendMessage(chatId, {
-                        image: { url: card.image },
-                        caption: cardText
-                    });
-                } else {
-                    // Text-only card
-                    await this.client.socket.sendMessage(chatId, { 
-                        text: cardText 
-                    });
-                }
-                
-                // Small delay between cards to prevent spam
-                if (i < cards.length - 1) {
-                    await new Promise(resolve => setTimeout(resolve, 500));
-                }
-            }
+            // Send the carousel
+            const result = await this.client.socket.sendMessage(chatId, carouselMessage);
             
             return { 
                 success: true, 
-                type: 'carousel', 
+                type: 'interactive_carousel', 
                 cards: cards.length,
+                messageId: result.key.id,
                 mediaTypes: {
                     videos: cards.filter(c => c.video).length,
                     images: cards.filter(c => c.image).length,
@@ -96,14 +99,80 @@ export class UIComponents {
             };
             
         } catch (error) {
-            console.error('❌ Carousel error:', error);
+            console.error('❌ Interactive Carousel failed, trying fallback:', error);
             
-            // Fallback to simple text
-            const fallbackText = `📋 **${options.title || 'Options'}**\n\n` +
-                cards.map((card, i) => `${i + 1}. ${card.title}`).join('\n');
-            
-            await this.client.socket.sendMessage(chatId, { text: fallbackText });
-            return { success: true, type: 'fallback', cards: cards.length };
+            // Fallback 1: Try native carousel format
+            try {
+                const nativeCarousel = {
+                    viewOnceMessage: {
+                        message: {
+                            messageContextInfo: {
+                                deviceListMetadata: {},
+                                deviceListMetadataVersion: 2
+                            },
+                            interactiveMessage: {
+                                nativeFlowMessage: {
+                                    buttons: cards.map((card, i) => ({
+                                        name: 'single_select',
+                                        buttonParamsJson: JSON.stringify({
+                                            title: card.title,
+                                            sections: [{
+                                                title: card.subtitle || '',
+                                                rows: [{
+                                                    title: card.title,
+                                                    description: card.body,
+                                                    id: `card_${i}`
+                                                }]
+                                            }]
+                                        })
+                                    }))
+                                }
+                            }
+                        }
+                    }
+                };
+                
+                const result = await this.client.socket.sendMessage(chatId, nativeCarousel);
+                return { success: true, type: 'native_carousel', cards: cards.length };
+                
+            } catch (nativeError) {
+                console.error('❌ Native carousel also failed, using list fallback:', nativeError);
+                
+                // Fallback 2: Use List Message (closest to carousel)
+                try {
+                    const listMessage = {
+                        text: options.title || 'Select an option',
+                        footer: options.footer || `${cards.length} options available`,
+                        title: options.title || 'Carousel',
+                        buttonText: 'View Options',
+                        sections: [{
+                            title: 'All Options',
+                            rows: cards.map((card, i) => ({
+                                title: card.title,
+                                description: card.body || card.subtitle || '',
+                                rowId: `carousel_${i}`
+                            }))
+                        }]
+                    };
+                    
+                    const result = await this.client.socket.sendMessage(chatId, listMessage);
+                    return { success: true, type: 'list_fallback', cards: cards.length };
+                    
+                } catch (listError) {
+                    console.error('❌ List fallback failed, using text:', listError);
+                    
+                    // Fallback 3: Simple text with emojis
+                    const fallbackText = `🎠 **${options.title || 'Carousel'}**\n\n` +
+                        cards.map((card, i) => 
+                            `${i + 1}️⃣ **${card.title}**\n` +
+                            `${card.subtitle ? `   ${card.subtitle}\n` : ''}` +
+                            `   ${card.body || ''}\n`
+                        ).join('\n');
+                    
+                    await this.client.socket.sendMessage(chatId, { text: fallbackText });
+                    return { success: true, type: 'text_fallback', cards: cards.length };
+                }
+            }
         }
     }