@conversionpros/aiva 1.0.0

package/router-v2/escalation-bridge.js

@@ -0,0 +1,540 @@
+// ── Escalation Bridge - Silent Handoff to Main Agent ─────
+// Per-category timeouts, two-strike retry, contact never knows.
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { getStmts, getSetting } = require('./db');
+const { sendMessage, sendEscalationTimeout } = require('./outbound-sender');
+const { savePreference } = require('./learning-loop');
+
+// Read gateway auth for AIVA channel delivery
+let _gatewayToken = null;
+function getGatewayToken() {
+  if (_gatewayToken) return _gatewayToken;
+  try {
+    const configPath = path.join(process.env.HOME || '/Users/brandonburgan', '.openclaw', 'openclaw.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    _gatewayToken = config.hooks?.token || config.gateway?.auth?.password || '';
+  } catch { _gatewayToken = ''; }
+  return _gatewayToken;
+}
+
+/**
+ * Send an escalation to the main agent via the AIVA channel plugin.
+ * This injects a system message into the main session via the gateway webhook.
+ */
+async function sendToMainAgent(text, interactive = null) {
+  // 1. Send to gateway (for the agent session)
+  const token = getGatewayToken();
+  const payload = {
+    userId: 'system',
+    displayName: 'AIVA Router',
+    text: `[System Message] Router Escalation:\n\n${text}`,
+    messageId: `esc-${Date.now()}`,
+    timestamp: new Date().toISOString(),
+    media: [],
+    metadata: { source: 'router-v2-escalation' },
+  };
+  let gatewayOk = false;
+  try {
+    const resp = await fetch('http://localhost:18789/aiva', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => '');
+      log('Gateway delivery failed', { status: resp.status, body: body.substring(0, 200) });
+    } else {
+      gatewayOk = true;
+    }
+  } catch (err) {
+    log('Gateway delivery error', { error: err.message });
+  }
+
+  // 2. Send directly to AIVA app chat (so Brandon sees it with interactive buttons)
+  let appOk = false;
+  try {
+    const appPayload = { userId: 'brandon', text, interactive, escalationId: interactive?.escalationMeta?.escalationId || null };
+    const appResp = await fetch('http://localhost:3847/api/chat/aiva-reply', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-aiva-internal': 'true',
+      },
+      body: JSON.stringify(appPayload),
+      signal: AbortSignal.timeout(5000),
+    });
+    if (appResp.ok) {
+      appOk = true;
+      log('Escalation delivered to AIVA app chat');
+    } else {
+      log('AIVA app chat delivery failed', { status: appResp.status });
+    }
+  } catch (err) {
+    log('AIVA app chat delivery error', { error: err.message });
+  }
+
+  return gatewayOk || appOk;
+}
+
+// Per-category timeout in minutes
+const CATEGORY_TIMEOUTS = {
+  lead: 5,
+  'qualified-lead': 5,
+  client: 10,
+  team: 10,
+  unknown: 15,
+  friend: 20,
+  family: 30,
+};
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [ESCALATION] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [ESCALATION] ${msg}`);
+}
+
+function generateEscalationId() {
+  return `esc_${crypto.randomBytes(8).toString('hex')}`;
+}
+
+/**
+ * Escalate a message to the main OpenClaw agent.
+ * @param {Object} options
+ * @param {Object} options.contact - Contact record
+ * @param {string} options.triggerMessage - What the contact said
+ * @param {Array} options.conversationHistory - Recent messages
+ * @param {Object} [options.contactContext] - Additional context
+ * @param {boolean} [options.isClientSupport=false] - Client support escalation
+ * @param {boolean} [options.isRetry=false] - Is this a retry after timeout
+ * @returns {Promise<string>} Escalation ID
+ */
+// Scope mapping for escalation types
+const ESCALATION_TYPE_SCOPES = {
+  scheduling: ['calendar.book', 'calendar.view'],
+  task: ['tasks.create'],
+  reminder: ['reminders.create'],
+  messaging: ['messages.send'],
+  file_sharing: ['files.send'],
+};
+
+function detectEscalationType(text) {
+  if (/schedul|call|meet|appointment|book|calendar|availab/i.test(text)) return 'scheduling';
+  if (/remind|task|todo|follow.?up/i.test(text)) return 'task';
+  if (/send.*file|attach|document|upload/i.test(text)) return 'file_sharing';
+  if (/send.*message|text.*someone|forward/i.test(text)) return 'messaging';
+  return 'general';
+}
+
+// Build contextual interactive options based on what triggered the escalation
+function buildEscalationOptions(contact, triggerMessage, escalationType) {
+  // Determine the denied scopes to grant if "allow future" is selected
+  // Always detect from the trigger message - the escalationType from the validator
+  // describes WHY it was caught (e.g. "sending messages to others"), not WHAT the contact wants
+  const resolvedType = detectEscalationType(triggerMessage);
+  const scopesToGrant = ESCALATION_TYPE_SCOPES[resolvedType] || [];
+
+  // Scheduling-related escalations
+  if (resolvedType === 'scheduling') {
+    return {
+      escalationMeta: { phone: contact.phone, type: resolvedType, scopes: scopesToGrant },
+      questions: [{
+        id: 'escalation_action',
+        text: `${contact.name}: "${triggerMessage}"`,
+        options: [
+          'Yes, add a reminder and allow future requests like this',
+          'Yes, add a reminder, but keep requiring escalation',
+          'Politely decline',
+          'Ignore future requests like this from this contact',
+        ],
+        actions: [
+          { type: 'approve_and_grant', scopes: scopesToGrant, reply: true },
+          { type: 'approve_one_time', scopes: [], reply: true },
+          { type: 'decline', scopes: [], reply: true },
+          { type: 'ignore', scopes: [], reply: false },
+        ],
+        multiSelect: false,
+        allowOther: true,
+      }],
+    };
+  }
+
+  // Task/reminder-related
+  if (resolvedType === 'task' || resolvedType === 'reminder') {
+    return {
+      escalationMeta: { phone: contact.phone, type: resolvedType, scopes: scopesToGrant },
+      questions: [{
+        id: 'escalation_action',
+        text: `${contact.name}: "${triggerMessage}"`,
+        options: [
+          'Yes, handle it and allow future requests like this',
+          'Yes, handle it, but keep requiring escalation',
+          'Politely decline',
+          'Ignore future requests like this from this contact',
+        ],
+        actions: [
+          { type: 'approve_and_grant', scopes: scopesToGrant, reply: true },
+          { type: 'approve_one_time', scopes: [], reply: true },
+          { type: 'decline', scopes: [], reply: true },
+          { type: 'ignore', scopes: [], reply: false },
+        ],
+        multiSelect: false,
+        allowOther: true,
+      }],
+    };
+  }
+
+  // File/message sharing
+  if (resolvedType === 'messaging' || resolvedType === 'file_sharing') {
+    return {
+      escalationMeta: { phone: contact.phone, type: resolvedType, scopes: scopesToGrant },
+      questions: [{
+        id: 'escalation_action',
+        text: `${contact.name}: "${triggerMessage}"`,
+        options: [
+          'Yes, handle it and enable this capability for them',
+          'Yes, handle it one-time only',
+          'Politely decline',
+          'Ignore future requests like this from this contact',
+        ],
+        actions: [
+          { type: 'approve_and_grant', scopes: scopesToGrant, reply: true },
+          { type: 'approve_one_time', scopes: [], reply: true },
+          { type: 'decline', scopes: [], reply: true },
+          { type: 'ignore', scopes: [], reply: false },
+        ],
+        multiSelect: false,
+        allowOther: true,
+      }],
+    };
+  }
+
+  // Default / general escalation
+  return {
+    escalationMeta: { phone: contact.phone, type: 'general', scopes: [] },
+    questions: [{
+      id: 'escalation_action',
+      text: `${contact.name}: "${triggerMessage}"`,
+      options: [
+        'Draft a reply for me to approve',
+        'I\'ll handle it personally',
+        'Politely decline',
+        'Ignore',
+      ],
+      actions: [
+        { type: 'approve_one_time', scopes: [], reply: true },
+        { type: 'handle_personally', scopes: [], reply: false },
+        { type: 'decline', scopes: [], reply: true },
+        { type: 'ignore', scopes: [], reply: false },
+      ],
+      multiSelect: false,
+      allowOther: true,
+    }],
+  };
+}
+
+async function escalate({
+  contact,
+  triggerMessage,
+  conversationHistory = [],
+  contactContext = {},
+  isClientSupport = false,
+  isRetry = false,
+  escalationType = null,
+}) {
+  const stmts = getStmts();
+  const escalationId = generateEscalationId();
+  const timeoutMin = CATEGORY_TIMEOUTS[contact.category] || 15;
+  const timeoutAt = new Date(Date.now() + timeoutMin * 60000).toISOString().replace('T', ' ').split('.')[0];
+
+  // Build escalation payload
+  const payload = {
+    escalationId,
+    phone: contact.phone,
+    contactName: contact.name,
+    category: contact.category,
+    channel: contact.source || 'imessage',
+    triggerMessage,
+    conversationHistory: conversationHistory.slice(-20).map(m => ({
+      role: m.sent_by === 'contact' ? 'contact' : 'aiva',
+      text: m.text,
+      at: m.created_at,
+    })),
+    contactContext: {
+      relationship: contactContext.relationship || '',
+      lastTopic: contactContext.last_topic || '',
+      pendingItems: JSON.parse(contactContext.pending_items || '[]'),
+      conversationSummary: contactContext.conversation_summary || '',
+    },
+    isClientSupport,
+    isRetry,
+    prepend: `You are responding on behalf of AIVA to a contact who doesn't know they've been escalated. Respond naturally as AIVA. If you are not 90% or more confident in the answer, ask your user for the answer. Do not guess. The user's response will be saved as a preference for future use so the router can handle this type of question autonomously next time.`,
+    preferenceHint: triggerMessage.substring(0, 200),
+  };
+
+  // Store escalation
+  stmts.insertEscalation.run(
+    escalationId,
+    contact.phone,
+    triggerMessage,
+    JSON.stringify(payload),
+    isClientSupport ? 1 : 0,
+    timeoutAt,
+  );
+
+  // Update conversation state
+  stmts.upsertState.run(contact.phone, 'escalated', JSON.stringify({ escalationId }), timeoutAt);
+
+  // Send to main agent via AIVA channel plugin
+  const escalationText = `📨 Router Escalation - ${contact.name} (${contact.phone}, ${contact.category})
+
+They said: "${triggerMessage}"
+Reason: ${isClientSupport ? 'Client support request' : 'Requires human judgment'}
+Escalation ID: ${escalationId}
+Timeout: ${timeoutMin} minutes`;
+  const initialInteractive = buildEscalationOptions(contact, triggerMessage, escalationType);
+  if (initialInteractive.escalationMeta) {
+    initialInteractive.escalationMeta.escalationId = escalationId;
+  }
+  const sent = await sendToMainAgent(escalationText, initialInteractive);
+  if (sent) {
+    log('Escalation sent via AIVA channel', { escalationId, phone: contact.phone, timeout: `${timeoutMin}min`, isRetry });
+  } else {
+    log('Failed to send escalation via AIVA channel', { escalationId });
+    // Fall through - timeout handler will retry
+  }
+
+  // Send SMS notification to the owner
+  try {
+    const ownerPhone = getSetting('masterPhone');
+    if (ownerPhone) {
+      const smsText = `AIVA Escalation: ${contact.name} (${contact.category}) says "${triggerMessage}" - check your AIVA app to respond.`;
+      await sendMessage({
+        phone: ownerPhone,
+        text: smsText,
+        channel: 'imessage',
+        sentBy: 'system',
+        stateAtTime: 'escalation-sms',
+        skipSanitize: true,
+      });
+      log('Escalation SMS sent to owner', { ownerPhone });
+    }
+  } catch (err) {
+    log('Escalation SMS failed', { error: err.message });
+  }
+
+  return escalationId;
+}
+
+/**
+ * Handle an escalation reply from the main agent.
+ * @param {Object} reply
+ * @param {string} reply.escalationId
+ * @param {string} reply.response - Response text to send to contact
+ * @param {Object} [reply.saveAsPreference] - Preference to save
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+async function handleReply(reply) {
+  const stmts = getStmts();
+  const escalation = stmts.getEscalation.get(reply.escalationId);
+
+  if (!escalation) {
+    log('Escalation not found', { escalationId: reply.escalationId });
+    return { success: false, error: 'escalation_not_found' };
+  }
+
+  if (escalation.status !== 'pending') {
+    log('Escalation already resolved', { escalationId: reply.escalationId, status: escalation.status });
+    return { success: false, error: 'already_resolved' };
+  }
+
+  // Resolve escalation
+  stmts.resolveEscalation.run(reply.response, reply.escalationId);
+
+  // Reset conversation state to active
+  stmts.upsertState.run(escalation.phone, 'active', '{}', null);
+
+  // Send response to contact - rewrite Brandon's intent into AIVA's voice
+  const context = JSON.parse(escalation.context_sent || '{}');
+  const channel = context.channel || 'imessage';
+  const contactName = context.contactName || escalation.phone;
+
+  // Grab recent conversation history for context
+  const recentMessages = stmts.getRecentMessages ? stmts.getRecentMessages.all(escalation.phone, 10) : [];
+  const historyBlock = recentMessages.map(m => 
+    `${m.direction === 'inbound' ? contactName : 'AIVA'}: ${m.text}`
+  ).join('\n');
+
+  // Rewrite the response in AIVA's voice using Sonnet
+  let finalResponse = reply.response;
+  try {
+    const { callSonnet } = require('./utils/ai');
+    const rewriteResult = await callSonnet({
+      messages: [
+        { role: 'system', content: `You are AIVA, Brandon's AI assistant. You're texting ${contactName}. Rewrite Brandon's intent as a brief iMessage from you (AIVA). The contact thinks they're talking to you, not Brandon.
+
+RULES:
+- Output ONLY the final text message. Nothing else.
+- No thinking, no preamble, no "Sure!" or "Got it" before the message.
+- One to two sentences max.
+- No markdown, no em dashes, no bullet points, no emojis.
+- Casual, natural, like a real person texting.
+
+Conversation context:
+${historyBlock}
+
+${contactName} asked: "${escalation.trigger_message}"` },
+        { role: 'user', content: `Brandon's intent: ${reply.response}` }
+      ],
+      maxTokens: 200,
+      temperature: 0.7,
+    });
+    if (rewriteResult.content) {
+      finalResponse = rewriteResult.content;
+      log('Rewritten escalation reply', { original: reply.response, rewritten: finalResponse });
+    }
+  } catch (err) {
+    // Fail-open: if rewrite fails, send Brandon's original text
+    log('Rewrite failed, sending original', { error: err.message });
+  }
+
+  const sendResult = await sendMessage({
+    phone: escalation.phone,
+    text: finalResponse,
+    channel,
+    sentBy: 'aiva',
+    stateAtTime: 'escalation-reply',
+  });
+
+  // Save preference if provided
+  if (reply.saveAsPreference && reply.saveAsPreference.answer) {
+    savePreference({
+      scope: reply.saveAsPreference.scope || 'global',
+      questionPattern: reply.saveAsPreference.questionPattern || context.preferenceHint || '',
+      answer: reply.saveAsPreference.answer,
+      source: reply.saveAsPreference.source || 'main_agent',
+      confidence: reply.saveAsPreference.confidence,
+      escalationId: reply.escalationId,
+      phone: escalation.phone,
+      originalQuestion: escalation.trigger_message,
+    });
+  }
+
+  log('Escalation resolved', { escalationId: reply.escalationId, sent: sendResult.sent });
+  return { success: true };
+}
+
+/**
+ * Check for timed-out escalations and handle retries / notifications.
+ * Should be called periodically (e.g. every minute).
+ */
+async function processTimeouts() {
+  const stmts = getStmts();
+  const timedOut = stmts.getTimedOutEscalations.all();
+
+  for (const esc of timedOut) {
+    const context = JSON.parse(esc.context_sent || '{}');
+
+    if (esc.strike_count === 0) {
+      // First timeout - retry
+      log('First timeout - retrying', { escalationId: esc.escalation_id, phone: esc.phone });
+      stmts.incrementStrike.run(esc.escalation_id);
+
+      // Extend timeout
+      const category = context.category || 'unknown';
+      const timeoutMin = CATEGORY_TIMEOUTS[category] || 15;
+      const newTimeout = new Date(Date.now() + timeoutMin * 60000).toISOString().replace('T', ' ').split('.')[0];
+      const db = require('./db').getDb();
+      db.prepare("UPDATE escalations SET timeout_at = ? WHERE escalation_id = ?").run(newTimeout, esc.escalation_id);
+
+      // Re-send escalation event
+      const retryText = `⏰ Escalation Retry - ${context.contactName || esc.phone} (${esc.phone}) is still waiting.
+
+Original message: "${esc.trigger_message}"
+Escalation ID: ${esc.escalation_id}`;
+      const retryInteractive = {
+        questions: [{
+          id: 'escalation_action',
+          text: `${context.contactName || esc.phone} is still waiting. Original: "${esc.trigger_message}" - What do you want to do?`,
+          options: ['Draft a reply for me to approve', "I'll handle it personally - pause the router for this contact", 'Ignore - no response needed', 'Block this contact'],
+          multiSelect: false,
+          allowOther: true,
+        }],
+      };
+      const retrySent = await sendToMainAgent(retryText, retryInteractive);
+      if (!retrySent) {
+        log('Retry escalation delivery failed', { escalationId: esc.escalation_id });
+      }
+    } else {
+      // Second timeout - notify Brandon and fail
+      log('Second timeout - notifying Brandon', { escalationId: esc.escalation_id, phone: esc.phone });
+      stmts.failEscalation.run(esc.escalation_id);
+      stmts.upsertState.run(esc.phone, 'idle', '{}', null);
+
+      await sendEscalationTimeout(
+        context.contactName || esc.phone,
+        esc.phone,
+        esc.trigger_message || '',
+      );
+    }
+  }
+}
+
+/**
+ * Append a new message to a pending escalation (contact sent follow-up while waiting).
+ * @param {string} phone
+ * @param {string} newMessage
+ */
+async function appendToEscalation(phone, newMessage) {
+  const stmts = getStmts();
+  const active = stmts.getActiveEscalation.get(phone);
+  if (!active) return;
+
+  const context = JSON.parse(active.context_sent || '{}');
+  if (!context.conversationHistory) context.conversationHistory = [];
+  context.conversationHistory.push({
+    role: 'contact',
+    text: newMessage,
+    at: new Date().toISOString(),
+  });
+  context.triggerMessage = `${context.triggerMessage}\n[Follow-up]: ${newMessage}`;
+
+  const db = require('./db').getDb();
+  db.prepare("UPDATE escalations SET context_sent = ?, trigger_message = ? WHERE escalation_id = ?")
+    .run(JSON.stringify(context), context.triggerMessage, active.escalation_id);
+
+  // Re-notify the main agent with updated context
+  try {
+    const updateText = `UPDATE: ${phone} sent a follow-up while waiting for escalation ${active.escalation_id}: "${newMessage}"`;
+    await sendToMainAgent(updateText);
+  } catch (err) {
+    log('Failed to re-notify agent on append', { escalationId: active.escalation_id, error: err.message });
+  }
+
+  log('Appended to escalation', { escalationId: active.escalation_id, phone });
+}
+
+/**
+ * Check if there's an active escalation for a phone number.
+ * @param {string} phone
+ * @returns {Object|null}
+ */
+function getActiveEscalation(phone) {
+  return getStmts().getActiveEscalation.get(phone) || null;
+}
+
+module.exports = {
+  escalate,
+  handleReply,
+  processTimeouts,
+  appendToEscalation,
+  getActiveEscalation,
+  CATEGORY_TIMEOUTS,
+};