adaptive-memory-multi-model-router 2.14.49 → 2.14.52

package/examples/ensemble.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * ensemble.js — Query multiple providers in parallel and merge results.
+ *
+ * A3M's signature capability: parallel multi-LLM execution with voting.
+ * Unlike every other router (which does sequential fallback A -> B -> C),
+ * A3M queries all selected providers simultaneously and compares responses.
+ *
+ * Usage:
+ *   node examples/ensemble.js
+ *   QUERY="What is the capital of France?" PROVIDERS="openai,groq,anthropic" node examples/ensemble.js
+ */
+
+const { routeQuery, getAvailableProviders } = require('../dist/index.js');
+
+const query = process.env.QUERY || 'Explain the concept of recursion with a real-world analogy';
+const providerList = (process.env.PROVIDERS || 'openai,groq,gemini')
+  .split(',')
+  .map(s => s.trim());
+
+/**
+ * Simulate calling each provider. In production, replace with real API calls.
+ * A3M Router selects the model — you call its API endpoint.
+ */
+async function callProvider(provider, model, prompt) {
+  const apiKey = process.env[provider.toUpperCase() + '_API_KEY'];
+
+  if (!apiKey) {
+    return {
+      provider,
+      model,
+      text: `[SKIP — set ${provider.toUpperCase()}_API_KEY]`,
+      cost: 0,
+      latency: 0,
+      skipped: true,
+    };
+  }
+
+  const start = Date.now();
+
+  // Each provider has a different base URL and format
+  const endpoints = {
+    openai:     { url: 'https://api.openai.com/v1/chat/completions',           model: model || 'gpt-4o-mini' },
+    groq:       { url: 'https://api.groq.com/openai/v1/chat/completions',       model: model || 'llama-3.3-70b-versatile' },
+    gemini:     { url: 'https://generativelanguage.googleapis.com/v1beta/openai/chat/completions', model: model || 'gemini-2.0-flash' },
+    anthropic:  { url: 'https://api.anthropic.com/v1/messages',                 model: model || 'claude-3-5-haiku-latest' },
+  };
+
+  const ep = endpoints[provider];
+  if (!ep) {
+    return { provider, model, text: `[UNSUPPORTED PROVIDER: ${provider}]`, cost: 0, latency: 0, skipped: true };
+  }
+
+  const headers = { 'Content-Type': 'application/json' };
+  if (provider === 'anthropic') {
+    headers['x-api-key'] = apiKey;
+    headers['anthropic-version'] = '2023-06-01';
+  } else {
+    headers['Authorization'] = `Bearer ${apiKey}`;
+  }
+
+  const body = provider === 'anthropic'
+    ? { model: ep.model, max_tokens: 512, messages: [{ role: 'user', content: prompt }] }
+    : { model: ep.model, messages: [{ role: 'user', content: prompt }], max_tokens: 512 };
+
+  try {
+    const res = await fetch(ep.url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const errText = await res.text().catch(() => '');
+      return { provider, model: ep.model, text: `[ERROR ${res.status}: ${errText}]`, cost: 0, latency: Date.now() - start, skipped: true };
+    }
+
+    const data = await res.json();
+    const text = provider === 'anthropic'
+      ? data.content?.[0]?.text || JSON.stringify(data)
+      : data.choices?.[0]?.message?.content || JSON.stringify(data);
+
+    return {
+      provider,
+      model: ep.model,
+      text: text.trim(),
+      latency: Date.now() - start,
+      skipped: false,
+      usage: data.usage,
+    };
+  } catch (err) {
+    return { provider, model: ep.model, text: `[FETCH ERROR: ${err.message}]`, cost: 0, latency: Date.now() - start, skipped: true };
+  }
+}
+
+/**
+ * Simple text voting: find common key phrases across responses.
+ */
+function voteOnResults(results) {
+  const answered = results.filter(r => !r.skipped);
+  if (answered.length === 0) return { winner: null, consensus: false, details: 'No providers returned results' };
+
+  const texts = answered.map(r => r.text.toLowerCase());
+  const wordSets = texts.map(t => new Set(t.split(/\s+/).filter(w => w.length > 3)));
+  const intersection = wordSets.reduce((a, b) => new Set([...a].filter(x => b.has(x))));
+
+  const consensusScore = intersection.size > 5 ? 0.85 : 0.3;
+  return {
+    winner: answered[0],
+    consensus: consensusScore > 0.5,
+    consensusScore,
+    sharedTerms: [...intersection].slice(0, 10),
+    totalAnswered: answered.length,
+    totalSkipped: results.length - answered.length,
+  };
+}
+
+async function main() {
+  console.log('A3M Router — Parallel Ensemble');
+  console.log('=' .repeat(50));
+  console.log('Query:', query);
+  console.log('Providers:', providerList.join(', '));
+  console.log('');
+
+  // Get route decisions from A3M for insight
+  console.log('-- A3M Route Recommendations --');
+  for (const provider of providerList) {
+    const decision = routeQuery(query);
+    console.log(`  ${provider}: ${decision.primary_model} (conf: ${(decision.confidence * 100).toFixed(0)}%, $${decision.estimated_cost.toFixed(6)})`);
+  }
+  console.log('');
+
+  // Execute all providers in parallel
+  console.log('-- Parallel Execution --');
+  const promises = providerList.map(provider => callProvider(provider, null, query));
+  const results = await Promise.all(promises);
+
+  for (const r of results) {
+    const icon = r.skipped ? '  [SKIP]' : '  [OK]  ';
+    console.log(`${icon} ${r.provider.padEnd(12)} ${r.model}`);
+    console.log(`       latency: ${r.latency}ms`);
+    if (!r.skipped) {
+      const preview = r.text.slice(0, 120).replace(/\n/g, ' ');
+      console.log(`       response: ${preview}...`);
+    }
+    console.log('');
+  }
+
+  // Vote on results
+  const vote = voteOnResults(results);
+  console.log('-- Consensus Vote --');
+  console.log('  Consensus:', vote.consensus ? 'YES' : 'NO');
+  console.log('  Score:', vote.consensusScore.toFixed(2));
+  console.log('  Answered:', vote.totalAnswered, '/', vote.totalSkipped + vote.totalAnswered);
+  if (vote.sharedTerms?.length) {
+    console.log('  Shared key terms:', vote.sharedTerms.join(', '));
+  }
+}
+
+main().catch(console.error);

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);