adaptive-memory-multi-model-router 1.9.2 → 1.9.4

package/dist/integrations/index.js

@@ -24,6 +24,7 @@ const GmailIntegration = require('./gmail.js').GmailIntegration;
 const DiscordIntegration = require('./discord.js').DiscordIntegration;
 const AirtableIntegration = require('./airtable.js').AirtableIntegration;
 const GoogleCalendarIntegration = require('./google-calendar.js').GoogleCalendarIntegration;
+const WhatsAppIntegration = require('./whatsapp.js').WhatsAppIntegration;
 
 /**
  * Factory to create integrations
@@ -40,6 +41,7 @@ function createIntegration(type, config) {
     case 'discord': return new DiscordIntegration(config.webhookUrl);
     case 'airtable': return new AirtableIntegration(config.apiKey, config.baseId);
     case 'google-calendar': return new GoogleCalendarIntegration(config.credentials);
+    case 'whatsapp': return new WhatsAppIntegration(config.phoneNumberId, config.accessToken);
     default: throw new Error(`Unknown integration type: ${type}`);
   }
 }
@@ -56,6 +58,7 @@ module.exports = {
   DiscordIntegration,
   AirtableIntegration,
   GoogleCalendarIntegration,
+  WhatsAppIntegration,
   // Factory
   createIntegration
 };

package/examples/whatsapp-telegram-bridge-demo.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+/**
+ * WhatsApp ↔ Telegram Bridge Demo
+ * 
+ * This demo shows how the bridge works without requiring real credentials.
+ * It uses mock implementations to demonstrate the flow.
+ */
+
+// Mock implementations for demo
+class MockWhatsAppIntegration {
+  constructor(phoneNumberId, accessToken) {
+    this.phoneNumberId = phoneNumberId;
+    this.accessToken = accessToken;
+    console.log(`📱 WhatsApp Integration initialized (Phone: ${phoneNumberId})`);
+  }
+
+  async sendMessage(to, body) {
+    console.log(`   📤 WhatsApp → ${to}: "${body.substring(0, 50)}..."`);
+    return { 
+      messaging_product: 'whatsapp',
+      contacts: [{ input: to, wa_id: to }],
+      messages: [{ id: `wamid.${Date.now()}` }]
+    };
+  }
+
+  async getMessages() {
+    return { messages: [] };
+  }
+}
+
+class MockTelegramIntegration {
+  constructor(botToken) {
+    this.botToken = botToken;
+    this.messageId = 1000;
+    console.log(`💬 Telegram Integration initialized (Bot: ${botToken.substring(0, 10)}...)`);
+  }
+
+  async sendMessage(chatId, text) {
+    this.messageId++;
+    console.log(`   📤 Telegram → Chat ${chatId}:`);
+    console.log(`      ${text.substring(0, 100)}...`);
+    return { 
+      message_id: this.messageId,
+      chat: { id: chatId },
+      text: text
+    };
+  }
+
+  async getUpdates() {
+    return { result: [] };
+  }
+}
+
+// Import A3M Router
+const { createA3MRouter } = require('../dist/index.js');
+
+/**
+ * WhatsApp → Telegram Bridge Demo
+ */
+class WhatsAppTelegramBridgeDemo {
+  constructor() {
+    this.whatsapp = new MockWhatsAppIntegration('1234567890', 'mock_token');
+    this.telegram = new MockTelegramIntegration('mock_bot_token_12345');
+    this.telegramChatId = '987654321';
+    
+    // A3M Router for intelligent routing
+    this.router = createA3MRouter();
+    
+    // Message tracking
+    this.pendingReplies = new Map();
+    this.demoMode = true;
+  }
+
+  async handleWhatsAppMessage(whatsappMessage) {
+    console.log('\n📩 STEP 1: Received WhatsApp Message');
+    console.log('─────────────────────────────────────────────────────────────');
+    
+    const entry = whatsappMessage.entry?.[0];
+    const change = entry?.changes?.[0];
+    const value = change?.value;
+    const message = value?.messages?.[0];
+    
+    if (!message) {
+      console.log('❌ No message in payload');
+      return;
+    }
+
+    const from = message.from;
+    const text = message.text?.body || '';
+    const messageId = message.id;
+
+    console.log(`   From: ${from}`);
+    console.log(`   Text: "${text}"`);
+    console.log(`   Message ID: ${messageId}`);
+
+    // Route the message
+    console.log('\n🔀 STEP 2: Route Message via A3M Router');
+    console.log('─────────────────────────────────────────────────────────────');
+    
+    const route = this.router.route(text);
+    console.log(`   Primary Model: ${route.primary_model}`);
+    console.log(`   Fallbacks: ${route.fallback_models.slice(0, 2).join(', ')}`);
+    console.log(`   Estimated Cost: $${route.estimated_cost.toFixed(6)}`);
+    console.log(`   Reasoning: ${route.reasoning}`);
+
+    // Forward to Telegram
+    console.log('\n📤 STEP 3: Forward to Telegram Bot');
+    console.log('─────────────────────────────────────────────────────────────');
+    
+    const telegramResult = await this.forwardToTelegram(from, text, route);
+    
+    this.pendingReplies.set(telegramResult.messageId, {
+      whatsappUser: from,
+      originalText: text,
+      timestamp: Date.now(),
+    });
+
+    console.log(`   Telegram Message ID: ${telegramResult.messageId}`);
+    console.log(`   Status: ✅ Forwarded successfully`);
+
+    // Simulate Telegram bot reply
+    console.log('\n📩 STEP 4: Telegram Bot Processes & Replies');
+    console.log('─────────────────────────────────────────────────────────────');
+    
+    await this.simulateTelegramReply(telegramResult.messageId, text);
+
+    return telegramResult;
+  }
+
+  async forwardToTelegram(whatsappUser, text, route) {
+    const formattedMessage = `
+🔄 <b>WhatsApp Bridge</b>
+📱 <b>From:</b> ${whatsappUser}
+🤖 <b>Route:</b> ${route.primary_model}
+💰 <b>Est. Cost:</b> $${route.estimated_cost.toFixed(6)}
+
+💬 <b>Message:</b>
+${text}
+
+<i>Reply to this message to respond back to WhatsApp user</i>
+    `.trim();
+
+    const result = await this.telegram.sendMessage(this.telegramChatId, formattedMessage);
+
+    return {
+      messageId: result.message_id,
+      chatId: this.telegramChatId,
+    };
+  }
+
+  async simulateTelegramReply(originalMessageId, originalText) {
+    // Simulate bot processing time
+    console.log('   🤖 Bot is processing...');
+    await new Promise(r => setTimeout(r, 1000));
+
+    // Generate contextual reply
+    let reply;
+    if (originalText.toLowerCase().includes('order')) {
+      reply = `I've checked your order. It will be shipped tomorrow! 📦`;
+    } else if (originalText.toLowerCase().includes('help')) {
+      reply = `I'm here to help! What do you need assistance with? 🤝`;
+    } else if (originalText.toLowerCase().includes('price')) {
+      reply = `Let me check the pricing for you. One moment please... 💰`;
+    } else {
+      reply = `Thanks for your message! Our team will get back to you shortly. ⏰`;
+    }
+
+    console.log(`   Bot Reply: "${reply}"`);
+
+    // Handle the reply
+    await this.handleTelegramReply({
+      message: {
+        message_id: Date.now(),
+        reply_to_message: { message_id: originalMessageId },
+        text: reply,
+        chat: { id: this.telegramChatId }
+      }
+    });
+  }
+
+  async handleTelegramReply(telegramUpdate) {
+    console.log('\n📤 STEP 5: Send Reply Back to WhatsApp');
+    console.log('─────────────────────────────────────────────────────────────');
+    
+    const message = telegramUpdate.message;
+    const replyToMessage = message.reply_to_message;
+    const originalMessageId = replyToMessage.message_id;
+    
+    const pending = this.pendingReplies.get(originalMessageId);
+    if (!pending) {
+      console.log('❌ No pending reply found');
+      return;
+    }
+
+    const replyText = message.text;
+    console.log(`   Original WhatsApp User: ${pending.whatsappUser}`);
+    console.log(`   Reply Text: "${replyText}"`);
+
+    // Send back to WhatsApp
+    await this.whatsapp.sendMessage(pending.whatsappUser, replyText);
+
+    this.pendingReplies.delete(originalMessageId);
+    
+    console.log('   Status: ✅ Reply sent successfully');
+  }
+}
+
+// Demo scenarios
+const DEMO_MESSAGES = [
+  {
+    description: 'Customer asking about order',
+    payload: {
+      entry: [{
+        changes: [{
+          value: {
+            messages: [{
+              from: '+1234567890',
+              id: 'wamid.demo1',
+              text: { body: 'Hello, I need help with my order #12345' },
+              timestamp: Date.now().toString(),
+            }],
+          },
+        }],
+      }],
+    },
+  },
+  {
+    description: 'Customer asking for pricing',
+    payload: {
+      entry: [{
+        changes: [{
+          value: {
+            messages: [{
+              from: '+9876543210',
+              id: 'wamid.demo2',
+              text: { body: 'What is the price for your premium plan?' },
+              timestamp: Date.now().toString(),
+            }],
+          },
+        }],
+      }],
+    },
+  },
+  {
+    description: 'General inquiry',
+    payload: {
+      entry: [{
+        changes: [{
+          value: {
+            messages: [{
+              from: '+5555555555',
+              id: 'wamid.demo3',
+              text: { body: 'Hi there, I have a question about your services' },
+              timestamp: Date.now().toString(),
+            }],
+          },
+        }],
+      }],
+    },
+  },
+];
+
+// Run demo
+async function main() {
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('📱 WhatsApp ↔ Telegram Bridge Demo');
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('');
+  console.log('This demo shows how to use a Telegram bot to process');
+  console.log('WhatsApp messages and send replies back.');
+  console.log('');
+
+  const bridge = new WhatsAppTelegramBridgeDemo();
+
+  for (const scenario of DEMO_MESSAGES) {
+    console.log('\n═══════════════════════════════════════════════════════════════');
+    console.log(`📝 Scenario: ${scenario.description}`);
+    console.log('═══════════════════════════════════════════════════════════════');
+    
+    await bridge.handleWhatsAppMessage(scenario.payload);
+    
+    // Wait between scenarios
+    await new Promise(r => setTimeout(r, 1500));
+  }
+
+  console.log('\n═══════════════════════════════════════════════════════════════');
+  console.log('✅ Demo Complete!');
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('');
+  console.log('To use in production:');
+  console.log('  1. Get WhatsApp Business API credentials');
+  console.log('  2. Create Telegram bot via @BotFather');
+  console.log('  3. Set up webhooks for both platforms');
+  console.log('  4. Use whatsapp-telegram-bridge.js with real credentials');
+  console.log('');
+  console.log('Documentation:');
+  console.log('  - WhatsApp: https://business.whatsapp.com/products/business-platform');
+  console.log('  - Telegram: https://core.telegram.org/bots/api');
+  console.log('');
+}
+
+main().catch(console.error);

package/examples/whatsapp-telegram-bridge.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+/**
+ * WhatsApp ↔ Telegram Bridge Example
+ * 
+ * This example shows how to use a Telegram bot to process
+ * WhatsApp messages and send replies back.
+ * 
+ * Prerequisites:
+ * 1. WhatsApp Business API credentials (phoneNumberId, accessToken)
+ * 2. Telegram Bot Token (from @BotFather)
+ * 3. Webhook endpoint to receive WhatsApp messages
+ * 
+ * Usage:
+ *   node whatsapp-telegram-bridge.js
+ */
+
+const { 
+  createIntegration,
+  WhatsAppIntegration,
+  TelegramIntegration,
+  createA3MRouter 
+} = require('../dist/index.js');
+
+// Configuration
+const CONFIG = {
+  whatsapp: {
+    phoneNumberId: process.env.WHATSAPP_PHONE_NUMBER_ID,
+    accessToken: process.env.WHATSAPP_ACCESS_TOKEN,
+  },
+  telegram: {
+    botToken: process.env.TELEGRAM_BOT_TOKEN,
+    // The chat ID where your bot will process messages
+    // This could be your personal chat with the bot
+    chatId: process.env.TELEGRAM_CHAT_ID,
+  },
+};
+
+// Validate config
+function validateConfig() {
+  const missing = [];
+  if (!CONFIG.whatsapp.phoneNumberId) missing.push('WHATSAPP_PHONE_NUMBER_ID');
+  if (!CONFIG.whatsapp.accessToken) missing.push('WHATSAPP_ACCESS_TOKEN');
+  if (!CONFIG.telegram.botToken) missing.push('TELEGRAM_BOT_TOKEN');
+  if (!CONFIG.telegram.chatId) missing.push('TELEGRAM_CHAT_ID');
+  
+  if (missing.length > 0) {
+    console.error('❌ Missing environment variables:');
+    missing.forEach(v => console.error(`   - ${v}`));
+    console.error('\nSet these variables and try again.');
+    process.exit(1);
+  }
+}
+
+/**
+ * WhatsApp → Telegram Bridge
+ * 
+ * Flow:
+ * 1. Receive message from WhatsApp (via webhook)
+ * 2. Forward message to Telegram bot
+ * 3. Get reply from Telegram (bot processes it)
+ * 4. Send reply back to WhatsApp user
+ */
+class WhatsAppTelegramBridge {
+  constructor(config) {
+    this.whatsapp = new WhatsAppIntegration(
+      config.whatsapp.phoneNumberId,
+      config.whatsapp.accessToken
+    );
+    this.telegram = new TelegramIntegration(config.telegram.botToken);
+    this.telegramChatId = config.telegram.chatId;
+    
+    // A3M Router for intelligent routing
+    this.router = createA3MRouter();
+    
+    // Message tracking
+    this.pendingReplies = new Map(); // messageId -> { whatsappUser, timestamp }
+  }
+
+  /**
+   * Handle incoming WhatsApp message
+   * @param {Object} whatsappMessage - WhatsApp webhook payload
+   */
+  async handleWhatsAppMessage(whatsappMessage) {
+    try {
+      // Extract message details
+      const entry = whatsappMessage.entry?.[0];
+      const change = entry?.changes?.[0];
+      const value = change?.value;
+      const message = value?.messages?.[0];
+      
+      if (!message) {
+        console.log('No message in webhook payload');
+        return;
+      }
+
+      const from = message.from; // WhatsApp user phone number
+      const text = message.text?.body || '';
+      const messageId = message.id;
+
+      console.log(`📩 WhatsApp message from ${from}: "${text.substring(0, 50)}..."`);
+
+      // Route the message to get best processing strategy
+      const route = this.router.route(text);
+      console.log(`🔀 Routed to: ${route.primary_model} (${route.reasoning})`);
+
+      // Forward to Telegram bot with context
+      const telegramMessage = await this.forwardToTelegram(from, text, route);
+      
+      // Track pending reply
+      this.pendingReplies.set(telegramMessage.messageId, {
+        whatsappUser: from,
+        originalText: text,
+        timestamp: Date.now(),
+      });
+
+      console.log(`📤 Forwarded to Telegram (message ID: ${telegramMessage.messageId})`);
+
+    } catch (error) {
+      console.error('❌ Error handling WhatsApp message:', error.message);
+    }
+  }
+
+  /**
+   * Forward WhatsApp message to Telegram
+   */
+  async forwardToTelegram(whatsappUser, text, route) {
+    // Format message for Telegram bot
+    const formattedMessage = `
+🔄 <b>WhatsApp Bridge</b>
+📱 <b>From:</b> ${whatsappUser}
+🤖 <b>Route:</b> ${route.primary_model}
+
+💬 <b>Message:</b>
+${text}
+
+<i>Reply to this message to respond back to WhatsApp user</i>
+    `.trim();
+
+    // Send to Telegram
+    const result = await this.telegram.sendMessage(
+      this.telegramChatId,
+      formattedMessage
+    );
+
+    return {
+      messageId: result.message_id || `msg_${Date.now()}`,
+      chatId: this.telegramChatId,
+    };
+  }
+
+  /**
+   * Handle Telegram reply
+   * @param {Object} telegramUpdate - Telegram webhook/update payload
+   */
+  async handleTelegramReply(telegramUpdate) {
+    try {
+      const message = telegramUpdate.message || telegramUpdate.callback_query?.message;
+      if (!message) return;
+
+      const replyToMessage = message.reply_to_message;
+      if (!replyToMessage) {
+        console.log('Not a reply message, ignoring');
+        return;
+      }
+
+      // Extract original message ID from reply
+      const originalMessageId = replyToMessage.message_id;
+      const pending = this.pendingReplies.get(originalMessageId);
+
+      if (!pending) {
+        console.log('No pending WhatsApp reply found for this message');
+        return;
+      }
+
+      const replyText = message.text || message.caption || '';
+      console.log(`📩 Telegram reply: "${replyText.substring(0, 50)}..."`);
+
+      // Send reply back to WhatsApp
+      await this.sendWhatsAppReply(pending.whatsappUser, replyText);
+
+      // Clean up pending reply
+      this.pendingReplies.delete(originalMessageId);
+
+    } catch (error) {
+      console.error('❌ Error handling Telegram reply:', error.message);
+    }
+  }
+
+  /**
+   * Send reply back to WhatsApp user
+   */
+  async sendWhatsAppReply(to, text) {
+    const result = await this.whatsapp.sendMessage(to, text);
+    console.log(`📤 Sent WhatsApp reply to ${to}: "${text.substring(0, 50)}..."`);
+    return result;
+  }
+
+  /**
+   * Clean up old pending replies (older than 1 hour)
+   */
+  cleanupPendingReplies() {
+    const now = Date.now();
+    const oneHour = 60 * 60 * 1000;
+    
+    for (const [messageId, pending] of this.pendingReplies) {
+      if (now - pending.timestamp > oneHour) {
+        this.pendingReplies.delete(messageId);
+        console.log(`🧹 Cleaned up expired pending reply: ${messageId}`);
+      }
+    }
+  }
+
+  /**
+   * Start cleanup interval
+   */
+  startCleanup() {
+    setInterval(() => this.cleanupPendingReplies(), 5 * 60 * 1000); // Every 5 minutes
+  }
+}
+
+// Example usage
+async function main() {
+  validateConfig();
+
+  console.log('🚀 Starting WhatsApp ↔ Telegram Bridge\n');
+
+  const bridge = new WhatsAppTelegramBridge(CONFIG);
+  bridge.startCleanup();
+
+  console.log('✅ Bridge initialized');
+  console.log(`   WhatsApp Phone Number ID: ${CONFIG.whatsapp.phoneNumberId}`);
+  console.log(`   Telegram Chat ID: ${CONFIG.telegram.chatId}`);
+  console.log('');
+
+  // Example: Simulate receiving a WhatsApp message
+  console.log('📋 Example: Simulating WhatsApp webhook payload\n');
+  
+  const exampleWhatsAppMessage = {
+    entry: [{
+      changes: [{
+        value: {
+          messages: [{
+            from: '1234567890',
+            id: 'wamid.example123',
+            text: { body: 'Hello, I need help with my order #12345' },
+            timestamp: Date.now().toString(),
+          }],
+        },
+      }],
+    }],
+  };
+
+  await bridge.handleWhatsAppMessage(exampleWhatsAppMessage);
+
+  console.log('\n📋 To use this in production:');
+  console.log('   1. Set up WhatsApp Business API webhook');
+  console.log('   2. Set up Telegram bot webhook');
+  console.log('   3. Route webhooks to handleWhatsAppMessage() and handleTelegramReply()');
+  console.log('');
+  console.log('📖 See: https://developers.facebook.com/docs/whatsapp/cloud-api/guides/set-up-webhooks');
+  console.log('📖 See: https://core.telegram.org/bots/webhooks');
+}
+
+// Run if executed directly
+if (require.main === module) {
+  main().catch(console.error);
+}
+
+module.exports = { WhatsAppTelegramBridge };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adaptive-memory-multi-model-router",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "shortName": "A3M Router",
   "displayName": "A3M Router - Adaptive Memory Multi-Model Router",
   "description": "A3M Router - Adaptive Memory Multi-Model Router with learned routing (RouteLLM), prefix caching (RadixAttention), speculative decoding (Medusa), TokenJuice-style compression. 14 LLM providers, 10 integrations, Python bindings. 20x more adaptable for ML/AI developers.",