elevenlabs-webhook-nodejs 1.0.0

package/src/services/whatsapp.service.ts

@@ -0,0 +1,245 @@
+import twilio from 'twilio';
+import config from '../config';
+import logger from '../utils/logger';
+import WhatsAppRecipient, { IWhatsAppRecipient, IRecipientFilters } from '../models/WhatsAppRecipient';
+import { loadAgentPrompts } from './ai/base.ai';
+import { ISummary } from '../models/Summary';
+import { ITranscription } from '../models/Transcription';
+import { NotificationResult, TemplateVariables } from '../types';
+
+const TEMPLATE_SID = 'HX47645724f174e91c4d90b25ee10fe612';
+
+class WhatsAppService {
+  private client: twilio.Twilio | null = null;
+  private fromNumber: string = '';
+  public isReady: boolean = false;
+
+  async initialize(): Promise<void> {
+    try {
+      this.client = twilio(config.twilio.accountSid, config.twilio.authToken);
+      this.fromNumber = `whatsapp:${config.twilio.whatsappNumber}`;
+      this.isReady = true;
+      logger.info('Twilio WhatsApp client initialized', {
+        fromNumber: config.twilio.whatsappNumber
+      });
+    } catch (error) {
+      logger.error('Failed to initialize Twilio client', { error: (error as Error).message });
+      throw error;
+    }
+  }
+
+  async sendMessage(phoneNumber: string, contentVariables: TemplateVariables): Promise<{ sid: string; status: string }> {
+    if (!this.isReady || !this.client) {
+      throw new Error('WhatsApp client not ready');
+    }
+
+    try {
+      const toNumber = this.normalizePhoneNumber(phoneNumber);
+
+      logger.info('Sending WhatsApp with template', {
+        to: toNumber,
+        contentSid: TEMPLATE_SID,
+        contentVariables
+      });
+
+      const result = await this.client.messages.create({
+        from: this.fromNumber,
+        to: toNumber,
+        contentSid: TEMPLATE_SID,
+        contentVariables: JSON.stringify(contentVariables)
+      });
+
+      logger.info('WhatsApp message sent via Twilio', {
+        to: toNumber,
+        messageSid: result.sid,
+        status: result.status
+      });
+
+      return { sid: result.sid, status: result.status };
+    } catch (error) {
+      logger.error('Failed to send WhatsApp message', {
+        phoneNumber,
+        error: (error as Error).message
+      });
+      throw error;
+    }
+  }
+
+  private normalizePhoneNumber(phoneNumber: string): string {
+    let normalized = phoneNumber.replace('@c.us', '');
+    if (!normalized.startsWith('+')) {
+      normalized = '+' + normalized;
+    }
+    return `whatsapp:${normalized}`;
+  }
+
+  async sendSummaryToRecipients(summary: ISummary, transcription: ITranscription): Promise<NotificationResult[]> {
+    const recipients = await WhatsAppRecipient.find({ is_active: true });
+    const results: NotificationResult[] = [];
+
+    for (const recipient of recipients) {
+      if (!this.matchesFilters(recipient.filters, transcription)) {
+        continue;
+      }
+
+      const contentVariables = this.buildTemplateVariables(summary, transcription);
+
+      try {
+        const result = await this.sendMessage(recipient.whatsapp_id, contentVariables);
+
+        results.push({
+          recipient_id: recipient.whatsapp_id,
+          recipient_name: recipient.name,
+          recipient_type: recipient.type,
+          sent_at: new Date(),
+          message_sid: result.sid
+        });
+
+        await WhatsAppRecipient.updateOne(
+          { _id: recipient._id },
+          {
+            $inc: { total_notifications_sent: 1 },
+            $set: { last_notification_at: new Date() }
+          }
+        );
+      } catch (error) {
+        results.push({
+          recipient_id: recipient.whatsapp_id,
+          recipient_name: recipient.name,
+          recipient_type: recipient.type,
+          error: (error as Error).message
+        });
+      }
+    }
+
+    return results;
+  }
+
+  private matchesFilters(filters: IRecipientFilters | undefined, transcription: ITranscription): boolean {
+    if (!filters) return true;
+
+    if (filters.agent_ids && filters.agent_ids.length > 0) {
+      if (!filters.agent_ids.includes(transcription.agent_id)) {
+        return false;
+      }
+    }
+
+    if (filters.min_call_duration) {
+      const metadata = transcription.metadata as Record<string, unknown> | undefined;
+      const callDuration = metadata?.call_duration_secs as number | undefined;
+      if (callDuration !== undefined && callDuration < filters.min_call_duration) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  buildTemplateVariables(summary: ISummary, transcription: ITranscription): TemplateVariables {
+    const metadata = transcription.metadata as Record<string, unknown> | undefined;
+    const phoneCall = metadata?.phone_call as Record<string, unknown> | undefined;
+    const callerNumber = String(phoneCall?.external_number || 'Bilinmiyor').substring(0, 100);
+
+    const promptsConfig = loadAgentPrompts();
+    const agentConfig = transcription.agent_id ? promptsConfig.agents[transcription.agent_id] : null;
+    const headerPrefix = (agentConfig?.messageTemplate?.headerPrefix) ||
+      (promptsConfig.default?.messageTemplate?.headerPrefix) || '';
+
+    let callSummary = String(summary.summary_text || 'Özet oluşturulamadı')
+      .substring(0, 1000)
+      .replace(/[\r\n]+/g, ' ')
+      .trim();
+
+    if (headerPrefix) {
+      callSummary = `${headerPrefix} ${callSummary}`;
+    }
+
+    return {
+      caller_number: callerNumber,
+      call_summary: callSummary
+    };
+  }
+
+  async sendSummaryToAllRecipients(
+    agentId: string,
+    contentVariables: TemplateVariables
+  ): Promise<NotificationResult[]> {
+    const recipients = await WhatsAppRecipient.find({ is_active: true });
+    const results: NotificationResult[] = [];
+
+    for (const recipient of recipients) {
+      // Check agent filter
+      if (recipient.filters?.agent_ids?.length && !recipient.filters.agent_ids.includes(agentId)) {
+        continue;
+      }
+
+      try {
+        const result = await this.sendMessage(recipient.whatsapp_id, contentVariables);
+        results.push({
+          recipient_id: recipient.whatsapp_id,
+          recipient_name: recipient.name,
+          recipient_type: recipient.type,
+          sent_at: new Date(),
+          message_sid: result.sid
+        });
+
+        await WhatsAppRecipient.updateOne(
+          { _id: recipient._id },
+          {
+            $inc: { total_notifications_sent: 1 },
+            $set: { last_notification_at: new Date() }
+          }
+        );
+      } catch (error) {
+        results.push({
+          recipient_id: recipient.whatsapp_id,
+          recipient_name: recipient.name,
+          recipient_type: recipient.type,
+          error: (error as Error).message
+        });
+      }
+    }
+
+    return results;
+  }
+
+  async sendToNumbers(
+    phoneNumbers: string[],
+    contentVariables: TemplateVariables
+  ): Promise<NotificationResult[]> {
+    const results: NotificationResult[] = [];
+
+    for (const number of phoneNumbers) {
+      try {
+        const result = await this.sendMessage(number, contentVariables);
+        results.push({
+          recipient_id: number,
+          recipient_name: number,
+          recipient_type: 'contact',
+          sent_at: new Date(),
+          message_sid: result.sid
+        });
+      } catch (error) {
+        results.push({
+          recipient_id: number,
+          recipient_name: number,
+          recipient_type: 'contact',
+          error: (error as Error).message
+        });
+      }
+    }
+
+    return results;
+  }
+
+  getStatus(): { isReady: boolean; provider: string; fromNumber: string } {
+    return {
+      isReady: this.isReady,
+      provider: 'twilio',
+      fromNumber: config.twilio.whatsappNumber
+    };
+  }
+}
+
+const whatsappService = new WhatsAppService();
+export default whatsappService;

package/src/templates/index.ts

@@ -0,0 +1,71 @@
+import { IAgentConfig, IPostCallProcessing, AgentTemplate, AgentDirection } from '../modules/agents/agent.model';
+import { ISurvey } from '../modules/surveys/survey.model';
+import { receptionistTemplate } from './receptionist';
+import { surveyTemplate } from './survey';
+
+// --- Template-specific data types ---
+
+export interface ReceptionistTemplateData {
+  business_name: string;
+  business_hours?: { day: string; open: string; close: string }[];
+  transfer_number?: string;
+  faq_entries?: { question: string; answer: string }[];
+  services?: string[];
+}
+
+export interface SurveyTemplateData {
+  intro_script: string;
+  outro_script: string;
+  default_survey_id?: string;
+}
+
+export interface CustomTemplateData {
+  custom_prompt: string;
+}
+
+// --- Template definition interface ---
+
+export interface AgentTemplateDefinition<T = Record<string, unknown>> {
+  name: string;
+  direction: AgentDirection;
+  defaultPostCallProcessing: IPostCallProcessing;
+  buildPrompt(config: IAgentConfig & { template_data: T }, survey?: ISurvey): string;
+}
+
+// --- Registry ---
+
+const templates: Record<string, AgentTemplateDefinition<any>> = {
+  receptionist: receptionistTemplate,
+  survey: surveyTemplate
+};
+
+export function getTemplate(name: AgentTemplate): AgentTemplateDefinition | undefined {
+  return templates[name];
+}
+
+export function listTemplates(): { name: string; direction: AgentDirection; defaultPostCallProcessing: IPostCallProcessing }[] {
+  return Object.values(templates).map(t => ({
+    name: t.name,
+    direction: t.direction,
+    defaultPostCallProcessing: t.defaultPostCallProcessing
+  }));
+}
+
+export function buildPrompt(
+  agentTemplate: AgentTemplate,
+  config: IAgentConfig,
+  survey?: ISurvey
+): string {
+  const template = templates[agentTemplate];
+
+  if (!template) {
+    // custom template: use raw custom_prompt from template_data
+    const customData = config.template_data as unknown as CustomTemplateData;
+    if (customData.custom_prompt) {
+      return customData.custom_prompt;
+    }
+    throw new Error(`Unknown agent template: ${agentTemplate}`);
+  }
+
+  return template.buildPrompt(config as any, survey);
+}

package/src/templates/receptionist.ts

@@ -0,0 +1,44 @@
+import { AgentTemplateDefinition, ReceptionistTemplateData } from './index';
+
+export const receptionistTemplate: AgentTemplateDefinition<ReceptionistTemplateData> = {
+  name: 'receptionist',
+  direction: 'inbound',
+
+  defaultPostCallProcessing: {
+    strategy: 'summarize',
+    llm_provider: 'openai',
+    whatsapp_notify: true,
+    notification_template: 'call_summary',
+    summary_prompt: '',
+    system_message: '',
+    whatsapp_message_template: ''
+  },
+
+  buildPrompt(config) {
+    const data = config.template_data;
+
+    const hoursText = data.business_hours
+      ?.map(h => `${h.day}: ${h.open} - ${h.close}`)
+      .join('\n') || 'Belirtilmedi';
+
+    const faqText = data.faq_entries
+      ?.map(f => `S: ${f.question}\nC: ${f.answer}`)
+      .join('\n\n') || '';
+
+    const servicesText = data.services?.join(', ') || '';
+
+    const transferText = data.transfer_number
+      ? `Kendi yetkinizin disinda bir talep gelirse, aramayi su numaraya yonlendirin: ${data.transfer_number}`
+      : '';
+
+    return [
+      `Sen ${data.business_name} adli isletmenin telefon resepsiyonistisin.`,
+      config.greeting ? `Karsilama: ${config.greeting}` : '',
+      '',
+      `Calisma saatleri:\n${hoursText}`,
+      servicesText ? `\nSunulan hizmetler: ${servicesText}` : '',
+      faqText ? `\nSik Sorulan Sorular:\n${faqText}` : '',
+      transferText ? `\n${transferText}` : ''
+    ].filter(Boolean).join('\n');
+  }
+};

package/src/templates/survey.ts

@@ -0,0 +1,44 @@
+import { AgentTemplateDefinition, SurveyTemplateData } from './index';
+import { ISurvey } from '../modules/surveys/survey.model';
+
+export const surveyTemplate: AgentTemplateDefinition<SurveyTemplateData> = {
+  name: 'survey',
+  direction: 'outbound',
+
+  defaultPostCallProcessing: {
+    strategy: 'extract_survey',
+    llm_provider: 'openai',
+    whatsapp_notify: true,
+    notification_template: 'survey_progress',
+    summary_prompt: '',
+    system_message: '',
+    whatsapp_message_template: ''
+  },
+
+  buildPrompt(config, survey?: ISurvey) {
+    const data = config.template_data;
+
+    const questionsText = survey?.questions
+      .map(q => {
+        let line = `${q.id}: ${q.text} (tip: ${q.type}`;
+        if (q.options?.length) {
+          line += `, secenekler: ${q.options.join(' / ')}`;
+        }
+        line += ')';
+        if (q.branch_logic) {
+          line += ` [Eger ${q.branch_logic.condition} → ${q.branch_logic.go_to} sorusuna gec]`;
+        }
+        return line;
+      })
+      .join('\n') || '';
+
+    return [
+      data.intro_script,
+      '',
+      'Bir anket yapiyorsun. Asagidaki sorulari sirasiyla sor, dal mantigi kurallarina uy:',
+      questionsText,
+      '',
+      `Gorusme bittiginde: ${data.outro_script}`
+    ].join('\n');
+  }
+};

package/src/types/index.ts

@@ -0,0 +1,218 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+
+// --- Config types ---
+
+export interface ServerConfig {
+  port: number;
+  env: string;
+}
+
+export interface MongoDBConfig {
+  uri: string;
+}
+
+export interface ElevenLabsConfig {
+  apiKey: string;
+  webhookSecret: string;
+  defaultProfileAgentId: string;
+}
+
+export interface AIProviderConfig {
+  apiKey: string;
+  model: string;
+}
+
+export interface AIConfig {
+  provider: 'openai' | 'gemini';
+  summaryLanguage: string;
+  summaryMaxTokens: number;
+  openai: AIProviderConfig;
+  gemini: AIProviderConfig;
+}
+
+export interface UnipileConfig {
+  apiKey: string;
+  dsn: string;
+  webhookSecret: string;
+}
+
+export interface TwilioConfig {
+  accountSid: string;
+  authToken: string;
+  whatsappNumber: string;
+}
+
+export interface JWTConfig {
+  accessSecret: string;
+  refreshSecret: string;
+  accessExpiry: string;
+  refreshExpiry: string;
+}
+
+export interface AdminConfig {
+  password: string;
+}
+
+export interface LoggingConfig {
+  level: string;
+}
+
+export interface GoogleCalendarConfig {
+  clientId: string;
+  clientSecret: string;
+  callbackUrl: string;
+  tokenEncryptionKey: string;
+  oauthStateSecret: string;
+  frontendUrl: string;
+}
+
+export interface NetGsmConfig {
+  username: string;
+  password: string;
+  msgheader: string;
+  apiUrl: string;
+}
+
+export interface AppConfig {
+  server: ServerConfig;
+  mongodb: MongoDBConfig;
+  elevenlabs: ElevenLabsConfig;
+  ai: AIConfig;
+  unipile: UnipileConfig;
+  baileys: UnipileConfig;
+  twilio: TwilioConfig;
+  jwt: JWTConfig;
+  admin: AdminConfig;
+  logging: LoggingConfig;
+  google: GoogleCalendarConfig;
+  netgsm: NetGsmConfig;
+}
+
+// --- ElevenLabs webhook payload types ---
+
+export interface TranscriptEntry {
+  role: string;
+  message: string;
+  time_in_call_secs?: number;
+  tool_calls?: unknown[];
+  tool_results?: unknown[];
+  interrupted?: boolean;
+  source_medium?: string;
+}
+
+export interface PhoneCallInfo {
+  external_number?: string;
+  [key: string]: unknown;
+}
+
+export interface CallMetadata {
+  start_time_unix_secs?: number;
+  call_duration_secs?: number;
+  cost?: number;
+  termination_reason?: string;
+  main_language?: string;
+  phone_call?: PhoneCallInfo;
+}
+
+export interface WebhookPayloadData {
+  conversation_id: string;
+  agent_id: string;
+  agent_name?: string;
+  user_id?: string;
+  status: string;
+  transcript: TranscriptEntry[];
+  metadata?: CallMetadata;
+  analysis?: Record<string, unknown>;
+}
+
+export interface ElevenLabsWebhookPayload {
+  type: string;
+  event_timestamp: number;
+  data: WebhookPayloadData;
+}
+
+// --- AI service types ---
+
+export interface AISummaryResult {
+  summary: string;
+  tokenUsage: {
+    prompt_tokens: number | null;
+    completion_tokens: number | null;
+    total_tokens: number | null;
+  };
+  model: string;
+}
+
+export interface AISummaryOptions {
+  language?: string;
+  agentId?: string;
+  maxTokens?: number;
+  summaryPrompt?: string;
+  systemMessage?: string;
+}
+
+// --- Agent prompts config ---
+
+export interface MessageTemplate {
+  headerPrefix: string;
+}
+
+export interface AgentPromptConfig {
+  name?: string;
+  summaryPrompt: string | null;
+  systemMessage: string | null;
+  messageTemplate: MessageTemplate;
+}
+
+export interface AgentPromptsConfig {
+  agents: Record<string, AgentPromptConfig>;
+  default: AgentPromptConfig;
+}
+
+// --- WhatsApp types ---
+
+export interface TemplateVariables {
+  caller_number: string;
+  call_summary: string;
+}
+
+export interface NotificationResult {
+  recipient_id: string;
+  recipient_name: string;
+  recipient_type: 'group' | 'contact';
+  sent_at?: Date;
+  message_sid?: string;
+  error?: string;
+}
+
+// --- JWT ---
+
+import { UserRole } from '../modules/auth/auth.model';
+import { Feature } from '../modules/tenants/tenant.model';
+
+export interface JWTAccessPayload {
+  id: string;
+  tenant_id: string;
+  role: UserRole;
+  enabled_features: Feature[];
+}
+
+export interface JWTRefreshPayload {
+  id: string;
+  type: 'refresh';
+}
+
+// --- Fastify augmentations ---
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    authenticate: (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+  }
+}
+
+declare module '@fastify/jwt' {
+  interface FastifyJWT {
+    payload: JWTAccessPayload;
+    user: JWTAccessPayload;
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,83 @@
+import winston from 'winston';
+import Transport from 'winston-transport';
+
+// Buffered MongoDB transport — writes logs in batches to avoid per-log DB overhead
+class MongoTransport extends Transport {
+  private buffer: Array<{ level: string; message: string; meta: Record<string, unknown>; service: string; timestamp: Date }> = [];
+  private flushInterval: ReturnType<typeof setInterval> | null = null;
+  private LogModel: typeof import('../modules/logs/log.model').default | null = null;
+  private ready = false;
+
+  constructor(opts?: Transport.TransportStreamOptions) {
+    super(opts);
+    // Lazy-load model to avoid circular deps and early mongoose access
+    this.flushInterval = setInterval(() => this.flush(), 5000);
+  }
+
+  private async getModel() {
+    if (!this.LogModel) {
+      const mod = await import('../modules/logs/log.model');
+      this.LogModel = mod.default;
+      this.ready = true;
+    }
+    return this.LogModel;
+  }
+
+  log(info: { level: string; message: string; timestamp?: string; service?: string; [key: string]: unknown }, callback: () => void): void {
+    const { level, message, timestamp, service, ...rest } = info;
+
+    this.buffer.push({
+      level,
+      message,
+      meta: rest as Record<string, unknown>,
+      service: (service as string) || 'elevenlabs-webhook',
+      timestamp: timestamp ? new Date(timestamp as string) : new Date(),
+    });
+
+    // Flush if buffer gets large
+    if (this.buffer.length >= 50) {
+      this.flush();
+    }
+
+    callback();
+  }
+
+  private async flush(): Promise<void> {
+    if (this.buffer.length === 0) return;
+
+    const batch = this.buffer.splice(0, this.buffer.length);
+
+    try {
+      const Model = await this.getModel();
+      await Model.insertMany(batch, { ordered: false });
+    } catch {
+      // Silently drop — can't log about logging failures
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.flushInterval) clearInterval(this.flushInterval);
+    await this.flush();
+  }
+}
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.errors({ stack: true }),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'elevenlabs-webhook' },
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.simple()
+      )
+    }),
+    new MongoTransport(),
+  ]
+});
+
+export default logger;