cdp-edge 1.2.2 → 1.3.0

package/server-edge-tracker/modules/intelligence.ts

@@ -0,0 +1,589 @@
+/**
+ * CDP Edge — Intelligence Agent + Customer Match
+ * runIntelligenceAgent, customer match Meta/Google, health checks
+ */
+
+import { sha256 } from './utils.js';
+import { getHealthMetrics, generateDailyReport, logIntelligence } from './db.js';
+import { sendCallMeBot } from './dispatch/whatsapp.js';
+import { autoDecideAbWinner } from './ml/ltv.js';
+import { analyzeMatchQuality, alertMatchQuality, purgeOldMatchQualityLogs } from './ml/matchquality.js';
+import { trainLogisticRegression, extractFeatures, saveWeights, LTV_WEIGHTS_KV_KEY } from './ml/logistic.js';
+import { computeRoasFeedback, sendRoasAlert } from './ml/roas.js';
+import { runNurtureQueue } from './nurture.js';
+import { Env } from '../types.js';
+
+// ── Tipos ───────────────────────────────────────────────────────────────────────
+export interface ApiVersionCheck {
+  platform: string;
+  current: string;
+  expected: string;
+  status: 'ok' | 'warning';
+}
+
+export interface ErrorRateAlert {
+  platform: string;
+  errorRate: number;
+  status: 'ok' | 'warning' | 'critical';
+}
+
+export interface LtvTrainResult {
+  trained?: boolean;
+  skipped?: string;
+  samples?: number;
+  accuracy?: number;
+  positiveRate?: number;
+  error?: string;
+}
+
+export interface IntelligenceAgentResult {
+  versionResults: ApiVersionCheck[];
+  errorAlerts: ErrorRateAlert[];
+  ltvTrainResult: LtvTrainResult;
+  abResult?: {
+    decided: boolean;
+    test_id?: number;
+    winner_name?: string;
+    improvement?: number;
+  };
+  mqAnalysis?: {
+    total?: number;
+    composite_score?: number;
+    email_rate?: number;
+    fbp_rate?: number;
+    alerts?: any[];
+  };
+  cmResult?: {
+    sent?: number;
+    received?: number;
+    skipped?: string;
+    error?: string;
+  };
+  roasResult?: {
+    campaigns: number;
+    total_revenue: number;
+    best_campaign: string | null;
+    skipped?: string;
+  };
+  nurtureResult?: {
+    processed: number;
+    sent: number;
+    failed: number;
+  };
+  lookalikeResult?: {
+    sent: number;
+    seed_type: string;
+    skipped?: string;
+  };
+}
+
+export interface CustomerMatchResult {
+  sent?: number;
+  received?: number;
+  num_received?: number;
+  skipped?: string;
+  error?: string;
+}
+
+export interface GoogleCustomerMatchExport {
+  hashed_email: string;
+  hashed_phone: string;
+  first_name: string;
+  last_name: string;
+}
+
+// ── Versões esperadas das APIs ────────────────────────────────────────────────
+const EXPECTED_API_VERSIONS: Record<string, string> = {
+  meta:      'v22.0',
+  ga4:       'latest',
+  tiktok:    'v1.3',
+  pinterest: 'v5',
+  reddit:    'v2.0',
+};
+
+const ALERT_THRESHOLDS = {
+  errorRateCritical: 0.20,
+  errorRateWarning:  0.10,
+};
+
+// ── Alerta via CallMeBot ──────────────────────────────────────────────────────
+export async function sendIntelligenceAlert(
+  env: Env,
+  severity: 'critical' | 'warning' | 'info',
+  title: string,
+  details: string
+): Promise<void> {
+  const icon  = severity === 'critical' ? '🚨' : severity === 'warning' ? '⚠️' : 'ℹ️';
+  const texto = `${icon} CDP Edge — ${title}\n\n${details}\n\n${new Date().toLocaleString('pt-BR', { timeZone: 'America/Sao_Paulo' })}`;
+  return sendCallMeBot(env, texto);
+}
+
+// ── Check de versões de API ───────────────────────────────────────────────────
+export async function checkApiVersionsIntelligence(
+  env: Env,
+  runType: string
+): Promise<ApiVersionCheck[]> {
+  const results: ApiVersionCheck[] = [];
+
+  for (const [platform, expected] of Object.entries(EXPECTED_API_VERSIONS)) {
+    const currentMap: Record<string, string> = { meta: 'v22.0', tiktok: 'v1.3', ga4: 'latest', pinterest: 'v5', reddit: 'v2.0' };
+    const current    = currentMap[platform] || 'unknown';
+    const isOk       = current === expected || expected === 'latest';
+    const status     = isOk ? 'ok' : 'warning';
+
+    if (env.DB) {
+      await logIntelligence(env.DB, runType, platform, 'api_version', status, current, expected,
+        isOk ? `${platform} ${current} — versão correta` : `${platform} ${current} desatualizado, esperado ${expected}`
+      );
+    }
+
+    results.push({ platform, current, expected, status });
+  }
+
+  return results;
+}
+
+// ── Auditoria de taxa de erro ─────────────────────────────────────────────────
+export async function auditErrorRates(
+  env: Env,
+  runType: string
+): Promise<ErrorRateAlert[]> {
+  if (!env.DB) return [];
+  const alerts: ErrorRateAlert[] = [];
+
+  for (const platform of ['meta', 'ga4', 'tiktok']) {
+    const metrics   = await getHealthMetrics(env.DB, platform, 24);
+    const errorRate = metrics.events_sent > 0 ? metrics.events_failed / metrics.events_sent : 0;
+
+    let status: 'ok' | 'warning' | 'critical' = 'ok';
+    if (errorRate >= ALERT_THRESHOLDS.errorRateCritical) status = 'critical';
+    else if (errorRate >= ALERT_THRESHOLDS.errorRateWarning) status = 'warning';
+
+    const message   = `${platform}: ${metrics.events_sent} eventos, ${metrics.events_failed} falhas (${(errorRate * 100).toFixed(1)}%)`;
+    let alertSent: boolean | undefined = false;
+    if (status !== 'ok') {
+      await sendIntelligenceAlert(env, status, `Taxa de Erro Alta — ${platform.toUpperCase()}`,
+        `📊 ${message}\n🎯 Taxa: ${(errorRate * 100).toFixed(1)}% (limite: ${ALERT_THRESHOLDS.errorRateWarning * 100}%)`);
+      alertSent = true;
+    }
+
+    if (env.DB) {
+      await logIntelligence(env.DB, runType, platform, 'error_rate', status,
+        `${(errorRate * 100).toFixed(1)}%`, `${ALERT_THRESHOLDS.errorRateWarning * 100}%`, message, alertSent
+      );
+    }
+
+    if (status !== 'ok') alerts.push({ platform, errorRate, status });
+  }
+
+  return alerts;
+}
+
+// ── Treinar modelo LTV (regressão logística com dados reais do D1) ────────────
+export async function trainLtvModel(env: Env): Promise<LtvTrainResult> {
+  if (!env.DB) return { skipped: 'DB não disponível' };
+
+  try {
+    // Busca leads com informação de conversão (compra confirmada)
+    const rows = await env.DB.prepare(`
+      SELECT
+        l.utm_source,
+        l.utm_medium,
+        l.engagement_score,
+        l.intention_level,
+        CAST(julianday('now') - julianday(l.created_at) AS INTEGER) AS days_since_lead,
+        CASE WHEN l.email IS NOT NULL AND l.email != '' THEN 1 ELSE 0 END AS has_email,
+        CASE WHEN l.phone IS NOT NULL AND l.phone != '' THEN 1 ELSE 0 END AS has_phone,
+        CASE WHEN (l.country = 'br' OR l.country = 'BR' OR l.country IS NULL) THEN 1 ELSE 0 END AS is_br,
+        CAST(strftime('%H', l.created_at) AS INTEGER) AS hour,
+        CASE WHEN EXISTS (
+          SELECT 1 FROM events e
+          WHERE e.user_id = l.user_id
+            AND e.event_name IN ('Purchase', 'purchase', 'PURCHASE')
+            AND e.created_at > l.created_at
+        ) THEN 1 ELSE 0 END AS label
+      FROM leads l
+      WHERE l.created_at >= datetime('now', '-90 days')
+      LIMIT 5000
+    `).all();
+
+    const dataset = (rows.results || []).map((row: any) => ({
+      features: extractFeatures(row),
+      label:    row.label || 0,
+    }));
+
+    const model = trainLogisticRegression(dataset);
+
+    if (!model) {
+      console.log('[LTV Train] Dados insuficientes para treinar modelo');
+      return { skipped: 'dados insuficientes', samples: dataset.length };
+    }
+
+    await saveWeights(env.DB, model);
+
+    // Invalidar cache KV para que próximas requests carreguem o modelo novo
+    if (env.GEO_CACHE) {
+      env.GEO_CACHE.delete(LTV_WEIGHTS_KV_KEY).catch(() => {});
+    }
+
+    console.log(`[LTV Train] Modelo treinado: ${dataset.length} samples, accuracy=${(model.accuracy * 100).toFixed(1)}%, positive_rate=${(model.positiveRate * 100).toFixed(1)}%`);
+    return { trained: true, samples: dataset.length, accuracy: model.accuracy, positiveRate: model.positiveRate };
+
+  } catch (err: any) {
+    console.error('[LTV Train] Erro:', err?.message || String(err));
+    return { error: err?.message || String(err) };
+  }
+}
+
+// ── Runner principal do Intelligence Agent ────────────────────────────────────
+export async function runIntelligenceAgent(
+  env: Env,
+  runType: string
+): Promise<IntelligenceAgentResult> {
+  console.log(`[Intelligence Agent] Iniciando ${runType}`);
+
+  // 1. Check de versões
+  const versionResults = await checkApiVersionsIntelligence(env, runType);
+  console.log(`[Intelligence Agent] Versões verificadas: ${versionResults.length} plataformas`);
+
+  // 2. Relatório diário
+  if (env.DB) {
+    const reports = await generateDailyReport(env.DB);
+    console.log(`[Intelligence Agent] Relatórios gerados: ${reports.length}`);
+  }
+
+  // 3. Auditoria de taxas de erro
+  const errorAlerts = await auditErrorRates(env, runType);
+  if (errorAlerts.length > 0) {
+    console.warn(`[Intelligence Agent] ${errorAlerts.length} alertas de taxa de erro enviados`);
+  }
+
+  // 4. Treinar modelo LTV (toda semana)
+  const ltvTrainResult = await trainLtvModel(env);
+  if (ltvTrainResult.trained) {
+    console.log(`[Intelligence Agent] LTV model treinado: accuracy=${(ltvTrainResult.accuracy! * 100).toFixed(1)}%`);
+    if (env.DB) {
+      await logIntelligence(env.DB, runType, 'ltv', 'model_training', 'ok',
+        `accuracy=${(ltvTrainResult.accuracy! * 100).toFixed(1)}%`, null,
+        `Modelo LTV re-treinado com ${ltvTrainResult.samples} amostras`
+      ).catch(() => {});
+    }
+  } else {
+    console.log(`[Intelligence Agent] LTV model: ${ltvTrainResult.skipped || ltvTrainResult.error || 'sem dados'}`);
+  }
+
+  // 5. Auto-decisão de winner no A/B LTV Test
+  let abResult: IntelligenceAgentResult['abResult'] = undefined;
+  try {
+    const abRes = await autoDecideAbWinner(env);
+    if (abRes?.decided) {
+      abResult = {
+        decided: abRes.decided,
+        test_id: abRes.test_id,
+        winner_name: abRes.winner_name,
+        improvement: abRes.improvement ? parseFloat(abRes.improvement) : undefined,
+      };
+      console.log(`[Intelligence Agent] A/B LTV winner auto-decidido: test_id=${abResult.test_id}, winner=${abResult.winner_name}`);
+
+      await sendIntelligenceAlert(env, 'info',
+        `A/B LTV Test — Winner Declarado Automaticamente`,
+        `🏆 Vencedor: ${abResult.winner_name}\n📈 Melhoria: +${abResult.improvement?.toFixed(1) ?? '?'}pp vs controle\n🆔 Test ID: ${abResult.test_id}\n\n✅ Prompt vencedor ativado automaticamente`
+      );
+
+      if (env.DB) {
+        await logIntelligence(env.DB, runType, 'ltv', 'ab_auto_winner', 'ok',
+          abResult.winner_name, null,
+          `A/B winner auto-decidido: test ${abResult.test_id}, melhoria ${abResult.improvement?.toFixed(1)}pp`
+        ).catch(() => {});
+      }
+    }
+  } catch (err: any) {
+    console.error('[Intelligence Agent] A/B auto-decide error:', err?.message || String(err));
+  }
+
+  // 6. Match Quality — análise + alertas
+  let mqAnalysis: IntelligenceAgentResult['mqAnalysis'] = undefined;
+  try {
+    const mqRes = await analyzeMatchQuality(env);
+    if (mqRes) {
+      mqAnalysis = mqRes;
+      console.log(`[Intelligence Agent] Match Quality: score=${mqAnalysis.composite_score ?? 0}%, alerts=${mqAnalysis.alerts?.length ?? 0}`);
+      await alertMatchQuality(env, mqRes);
+
+      if (env.DB && mqAnalysis.total && mqAnalysis.total > 0) {
+        await logIntelligence(env.DB, runType, 'meta', 'match_quality', (mqAnalysis.alerts && mqAnalysis.alerts.length > 0) ? 'warning' : 'ok',
+          `${mqAnalysis.composite_score ?? 0}%`, '45%',
+          `Match quality 2h: email=${mqAnalysis.email_rate ?? 0}%, fbp=${mqAnalysis.fbp_rate ?? 0}%, score=${mqAnalysis.composite_score ?? 0}%`
+        ).catch(() => {});
+      }
+    }
+  } catch (err: any) {
+    console.error('[Intelligence Agent] Match quality analysis error:', err?.message || String(err));
+  }
+
+  // 7. Auditoria mensal adicional
+  if (runType === 'monthly_audit') {
+    if (env.DB) {
+      try {
+        const ltvStats = await env.DB.prepare(`
+          SELECT predicted_ltv_class, COUNT(*) as count
+          FROM user_profiles
+          WHERE predicted_ltv_class IS NOT NULL AND updated_at > datetime('now', '-30 days')
+          GROUP BY predicted_ltv_class
+        `).all();
+
+        const summary = ltvStats.results?.map((r: any) => `${r.predicted_ltv_class}: ${r.count}`).join(', ') || 'sem dados';
+        await logIntelligence(env.DB, runType, 'all', 'ltv_distribution', 'ok', summary, null,
+          `Distribuição LTV últimos 30 dias: ${summary}`);
+        console.log(`[Intelligence Agent] LTV distribution: ${summary}`);
+      } catch (err: any) {
+        console.error('LTV audit error:', err?.message || String(err));
+      }
+
+      // Purge de logs antigos de match quality (> 30 dias)
+      if (env.DB) {
+        await purgeOldMatchQualityLogs(env.DB);
+        console.log('[Intelligence Agent] Match quality logs antigos purgados');
+      }
+    }
+  }
+
+  // 8. Customer Match sync semanal (high_intent → Meta Audience)
+  const cmResult = await syncMetaCustomAudience(env);
+  console.log(`[Intelligence Agent] Customer Match Meta: sent=${cmResult?.sent ?? 0}, received=${cmResult?.received ?? 0}`);
+
+  // 9. ROAS Feedback Loop — cruza leads com compras reais por campanha
+  let roasResult: IntelligenceAgentResult['roasResult'] = undefined;
+  try {
+    const report = await computeRoasFeedback(env, 30);
+    if (report) {
+      roasResult = {
+        campaigns:     report.campaigns.length,
+        total_revenue: report.total_revenue,
+        best_campaign: report.best_campaign,
+      };
+      await sendRoasAlert(env, report);
+      console.log(`[Intelligence Agent] ROAS: ${report.campaigns.length} campanhas, R$${report.total_revenue} receita`);
+    } else {
+      roasResult = { campaigns: 0, total_revenue: 0, best_campaign: null, skipped: 'sem dados suficientes' };
+    }
+  } catch (err: any) {
+    console.error('[Intelligence Agent] ROAS error:', err?.message || String(err));
+  }
+
+  // 10. Nurture Queue — processa mensagens agendadas (D+1, D+3, D+7)
+  let nurtureResult: IntelligenceAgentResult['nurtureResult'] = undefined;
+  try {
+    const nr = await runNurtureQueue(env);
+    nurtureResult = { processed: nr.processed, sent: nr.sent, failed: nr.failed };
+    console.log(`[Intelligence Agent] Nurture: ${nr.sent}/${nr.processed} mensagens enviadas`);
+  } catch (err: any) {
+    console.error('[Intelligence Agent] Nurture error:', err?.message || String(err));
+  }
+
+  // 11. Lookalike Dinâmico — compradores confirmados → Meta Audience seed
+  let lookalikeResult: IntelligenceAgentResult['lookalikeResult'] = undefined;
+  try {
+    const lr = await syncMetaLookalikeSeed(env);
+    lookalikeResult = lr;
+    console.log(`[Intelligence Agent] Lookalike seed: sent=${lr.sent}, type=${lr.seed_type}`);
+  } catch (err: any) {
+    console.error('[Intelligence Agent] Lookalike error:', err?.message || String(err));
+  }
+
+  console.log(`[Intelligence Agent] ${runType} concluído — LTV, A/B, match quality, customer match, ROAS, nurture, lookalike`);
+
+  return {
+    versionResults,
+    errorAlerts,
+    ltvTrainResult,
+    abResult,
+    mqAnalysis,
+    cmResult,
+    roasResult,
+    nurtureResult,
+    lookalikeResult,
+  };
+}
+
+// ── syncMetaCustomAudience — D1 → Meta Custom Audiences ─────────────────────
+export async function syncMetaCustomAudience(env: Env): Promise<CustomerMatchResult> {
+  if (!env.META_ACCESS_TOKEN || !env.META_AD_ACCOUNT_ID || !env.META_AUDIENCE_ID) {
+    console.log('[CustomerMatch] Meta: secrets não configurados — pulando sync');
+    return { skipped: 'META_AD_ACCOUNT_ID ou META_AUDIENCE_ID não configurados' };
+  }
+  if (!env.DB) return { skipped: 'DB não disponível' };
+
+  try {
+    const profiles = await env.DB.prepare(`
+      SELECT email, phone FROM user_profiles
+      WHERE cohort_label IN ('high_intent', 'buyer_lookalike')
+        AND updated_at > datetime('now', '-30 days')
+        AND email IS NOT NULL
+      LIMIT 10000
+    `).all();
+
+    if (!profiles.results || profiles.results.length === 0) {
+      console.log('[CustomerMatch] Meta: nenhum perfil elegível');
+      return { sent: 0 };
+    }
+
+    const data = await Promise.all(
+      profiles.results.map(async (p: any) => [
+        p.email ? await sha256(p.email) : '',
+        p.phone ? await sha256(p.phone) : '',
+      ])
+    );
+
+    const body = { payload: { schema: ['EMAIL_SHA256', 'PHONE_SHA256'], data } };
+    const endpoint = `https://graph.facebook.com/v22.0/${env.META_AUDIENCE_ID}/users`;
+
+    const res = await fetch(endpoint, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ ...body, access_token: env.META_ACCESS_TOKEN }),
+    });
+
+    const result = await res.json() as any;
+
+    if (!res.ok) {
+      console.error('[CustomerMatch] Meta erro:', res.status, result.error?.message || 'unknown');
+      return { error: result.error?.message, sent: 0 };
+    }
+
+    console.log(`[CustomerMatch] Meta: ${profiles.results.length} perfis sincronizados`);
+    return { sent: profiles.results.length, num_received: result.num_received, received: result.num_received };
+
+  } catch (err: any) {
+    console.error('[CustomerMatch] Meta fetch error:', err?.message || String(err));
+    return { error: err?.message || String(err), sent: 0 };
+  }
+}
+
+// ── syncMetaLookalikeSeed — compradores confirmados → Meta Audience (Fase 7) ──
+// Seed de Lookalike mais preciso: usa quem REALMENTE comprou (Purchase event)
+// em vez de quem só teve intenção (cohort_label = high_intent).
+// Separado do syncMetaCustomAudience para não misturar seeds de qualidade diferente.
+
+export async function syncMetaLookalikeSeed(env: Env): Promise<{
+  sent: number;
+  seed_type: string;
+  skipped?: string;
+}> {
+  if (!env.META_ACCESS_TOKEN || !env.META_AUDIENCE_ID) {
+    return { sent: 0, seed_type: 'buyer_confirmed', skipped: 'META secrets não configurados' };
+  }
+  if (!env.DB) return { sent: 0, seed_type: 'buyer_confirmed', skipped: 'DB não disponível' };
+
+  try {
+    // Busca perfis de compradores confirmados (Purchase event nos últimos 60 dias)
+    const confirmed = await env.DB.prepare(`
+      SELECT DISTINCT up.email, up.phone, up.first_name, up.last_name
+      FROM user_profiles up
+      JOIN leads l ON l.user_id = up.user_id
+      WHERE l.event_name IN ('Purchase','purchase')
+        AND l.created_at >= datetime('now', '-60 days')
+        AND up.email IS NOT NULL
+      UNION
+      SELECT DISTINCT up.email, up.phone, up.first_name, up.last_name
+      FROM user_profiles up
+      JOIN quiz_sessions qs ON qs.user_id = up.user_id
+      WHERE qs.qualification = 'comprador'
+        AND qs.created_at >= datetime('now', '-30 days')
+        AND up.email IS NOT NULL
+      LIMIT 10000
+    `).all();
+
+    if (!confirmed.results?.length) {
+      return { sent: 0, seed_type: 'buyer_confirmed', skipped: 'nenhum comprador confirmado no período' };
+    }
+
+    const data = await Promise.all(
+      confirmed.results.map(async (p: any) => [
+        p.email ? await sha256(p.email) : '',
+        p.phone ? await sha256(p.phone) : '',
+      ])
+    );
+
+    const body = { payload: { schema: ['EMAIL_SHA256', 'PHONE_SHA256'], data } };
+    const endpoint = `https://graph.facebook.com/v22.0/${env.META_AUDIENCE_ID}/users`;
+
+    const res = await fetch(endpoint, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ ...body, access_token: env.META_ACCESS_TOKEN }),
+    });
+
+    const result = await res.json() as any;
+
+    // Persiste histórico do seed
+    if (env.DB) {
+      await env.DB.prepare(`
+        INSERT INTO lookalike_seeds (audience_id, seed_type, profiles_sent, profiles_received, period_days)
+        VALUES (?, 'buyer_confirmed', ?, ?, 60)
+      `).bind(
+        env.META_AUDIENCE_ID,
+        confirmed.results.length,
+        result.num_received ?? null,
+      ).run().catch(() => {});
+    }
+
+    if (!res.ok) {
+      console.error('[Lookalike] Meta erro:', result.error?.message);
+      return { sent: 0, seed_type: 'buyer_confirmed', skipped: result.error?.message };
+    }
+
+    // Atualiza cohort_label dos compradores para buyer_confirmed
+    await env.DB.prepare(`
+      UPDATE user_profiles
+      SET cohort_label = 'buyer_confirmed', updated_at = datetime('now')
+      WHERE user_id IN (
+        SELECT DISTINCT user_id FROM leads
+        WHERE event_name IN ('Purchase','purchase')
+          AND created_at >= datetime('now', '-60 days')
+      )
+    `).run().catch(() => {});
+
+    console.log(`[Lookalike] ${confirmed.results.length} compradores confirmados enviados ao Meta`);
+    return { sent: confirmed.results.length, seed_type: 'buyer_confirmed' };
+
+  } catch (err: any) {
+    console.error('[Lookalike] syncMetaLookalikeSeed error:', err?.message || String(err));
+    return { sent: 0, seed_type: 'buyer_confirmed', skipped: err?.message };
+  }
+}
+
+// ── buildGoogleCustomerMatchExport — gera JSON para Google Ads Customer Match ─
+export async function buildGoogleCustomerMatchExport(env: Env): Promise<GoogleCustomerMatchExport[]> {
+  if (!env.DB) return [];
+
+  const profiles = await env.DB.prepare(`
+    SELECT email, phone, first_name, last_name FROM user_profiles
+    WHERE cohort_label IN ('high_intent', 'buyer_lookalike')
+      AND updated_at > datetime('now', '-30 days')
+      AND email IS NOT NULL
+    LIMIT 10000
+  `).all();
+
+  if (!profiles.results?.length) return [];
+
+  const results: GoogleCustomerMatchExport[] = [];
+  for (const p of profiles.results) {
+    const email = p.email as string | null | undefined;
+    const phone = p.phone as string | null | undefined;
+    const firstName = p.first_name as string | undefined;
+    const lastName = p.last_name as string | undefined;
+
+    const hashed_email = email ? await sha256(email) : '';
+    const hashed_phone = phone ? await sha256(phone) : '';
+    if (hashed_email || hashed_phone) {
+      results.push({
+        hashed_email: hashed_email || '',
+        hashed_phone: hashed_phone || '',
+        first_name: firstName || '',
+        last_name: lastName || '',
+      });
+    }
+  }
+  return results;
+}