elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/admin/ai-chat-session.service.ts

@@ -0,0 +1,454 @@
+import {
+  Injectable,
+  Logger,
+  NotFoundException,
+  ForbiddenException,
+  BadRequestException,
+} from '@nestjs/common';
+import WebSocket from 'ws';
+import { PrismaService } from '../database/prisma.service';
+import { AIService } from '../integrations/ai/ai.service';
+import { ElevenLabsService } from '../integrations/elevenlabs/elevenlabs.service';
+import { ToolRegistryService } from '../tools/tool-registry.service';
+import type { AIMessage } from '../integrations/ai/ai.interface';
+import type { ToolContext } from '../tools/tool.interfaces';
+import type { AcmRole } from '@prisma/client';
+
+interface ELConnection {
+  ws: WebSocket;
+  conversationId: string | null;
+  ready: Promise<void>;
+}
+
+@Injectable()
+export class AiChatSessionService {
+  private readonly logger = new Logger(AiChatSessionService.name);
+  /** Active ElevenLabs WS connections keyed by session ID */
+  private readonly elConnections = new Map<string, ELConnection>();
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly aiService: AIService,
+    private readonly elevenlabs: ElevenLabsService,
+    private readonly toolRegistry: ToolRegistryService,
+  ) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  CRUD                                                               */
+  /* ------------------------------------------------------------------ */
+
+  async createSession(userId: string, dto: {
+    title?: string;
+    provider?: string;
+    tenantId?: string;
+    clinicId?: string;
+    agentId?: string;
+    systemPrompt?: string;
+    enableTools?: boolean;
+    channel?: string;
+  }) {
+    return this.prisma.adminChatSession.create({
+      data: {
+        acs_user_id: userId,
+        acs_title: dto.title || '',
+        acs_provider: dto.provider || 'anthropic',
+        acs_tenant_id: dto.tenantId || null,
+        acs_clinic_id: dto.clinicId || null,
+        acs_agent_id: dto.agentId || null,
+        acs_system_prompt: dto.systemPrompt || '',
+        acs_enable_tools: dto.enableTools ?? false,
+        acs_channel: dto.channel || 'whatsapp',
+      },
+    });
+  }
+
+  async listSessions(userId: string) {
+    return this.prisma.adminChatSession.findMany({
+      where: { acs_user_id: userId },
+      orderBy: { acs_updated_at: 'desc' },
+      select: {
+        acs_id: true,
+        acs_title: true,
+        acs_provider: true,
+        acs_tenant_id: true,
+        acs_agent_id: true,
+        acs_message_count: true,
+        acs_last_message_at: true,
+        acs_enable_tools: true,
+        acs_created_at: true,
+        acs_updated_at: true,
+      },
+    });
+  }
+
+  async getSession(sessionId: string, userId: string) {
+    const session = await this.prisma.adminChatSession.findUnique({
+      where: { acs_id: sessionId },
+      include: {
+        messages: { orderBy: { acm_created_at: 'asc' } },
+      },
+    });
+    if (!session) throw new NotFoundException('Session not found');
+    if (session.acs_user_id !== userId) throw new ForbiddenException();
+    return session;
+  }
+
+  async updateSession(sessionId: string, userId: string, dto: {
+    title?: string;
+    provider?: string;
+    systemPrompt?: string;
+    enableTools?: boolean;
+  }) {
+    const session = await this.prisma.adminChatSession.findUnique({
+      where: { acs_id: sessionId },
+      select: { acs_user_id: true },
+    });
+    if (!session) throw new NotFoundException('Session not found');
+    if (session.acs_user_id !== userId) throw new ForbiddenException();
+
+    const data: Record<string, any> = {};
+    if (dto.title !== undefined) data.acs_title = dto.title;
+    if (dto.provider !== undefined) data.acs_provider = dto.provider;
+    if (dto.systemPrompt !== undefined) data.acs_system_prompt = dto.systemPrompt;
+    if (dto.enableTools !== undefined) data.acs_enable_tools = dto.enableTools;
+
+    return this.prisma.adminChatSession.update({
+      where: { acs_id: sessionId },
+      data,
+    });
+  }
+
+  async deleteSession(sessionId: string, userId: string) {
+    const session = await this.prisma.adminChatSession.findUnique({
+      where: { acs_id: sessionId },
+      select: { acs_user_id: true },
+    });
+    if (!session) throw new NotFoundException('Session not found');
+    if (session.acs_user_id !== userId) throw new ForbiddenException();
+
+    // Close EL WS if active
+    this.closeELConnection(sessionId);
+
+    await this.prisma.adminChatSession.delete({
+      where: { acs_id: sessionId },
+    });
+    return { success: true };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CONVERSE — routes to text AI or ElevenLabs based on provider       */
+  /* ------------------------------------------------------------------ */
+
+  async converse(sessionId: string, userId: string, content: string) {
+    const session = await this.getSession(sessionId, userId);
+
+    // Persist user message
+    await this.prisma.adminChatMessage.create({
+      data: { acm_session_id: sessionId, acm_role: 'user', acm_content: content },
+    });
+
+    // Auto-title from first message
+    if (!session.acs_title && session.messages.length === 0) {
+      const title = content.length > 60 ? content.substring(0, 57) + '...' : content;
+      await this.prisma.adminChatSession.update({
+        where: { acs_id: sessionId },
+        data: { acs_title: title },
+      });
+    }
+
+    // Route by provider
+    if (session.acs_provider === 'elevenlabs') {
+      return this.converseElevenLabs(sessionId, session, content);
+    }
+    return this.converseTextAI(sessionId, session, content);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  TEXT AI (Anthropic / OpenAI)                                        */
+  /* ------------------------------------------------------------------ */
+
+  private async converseTextAI(
+    sessionId: string,
+    session: Awaited<ReturnType<typeof this.getSession>>,
+    content: string,
+  ) {
+    // Build conversation history
+    const messages: AIMessage[] = session.messages.map((m) => ({
+      role: m.acm_role as AIMessage['role'],
+      content: m.acm_content,
+      ...(m.acm_role === 'tool_result' && (m.acm_metadata as any)?.toolCallId
+        ? { toolCallId: (m.acm_metadata as any).toolCallId }
+        : {}),
+    }));
+    messages.push({ role: 'user', content });
+
+    // Resolve tools
+    let features: string[] = [];
+    if (session.acs_tenant_id) {
+      const tenant = await this.prisma.tenant.findUnique({
+        where: { tenant_id: session.acs_tenant_id },
+        select: { tenant_enabled_features: true },
+      });
+      features = (tenant?.tenant_enabled_features as string[]) ?? [];
+    }
+
+    const channel = session.acs_channel || 'whatsapp';
+    const tools = session.acs_enable_tools
+      ? this.toolRegistry.getAITools(features, channel)
+      : undefined;
+
+    const toolCtx: ToolContext = {
+      tenantId: session.acs_tenant_id || '',
+      clinicId: session.acs_clinic_id || null,
+      patientPhone: 'test-playground',
+      patientName: 'Test User',
+      channel: channel as any,
+      channelMetadata: {},
+    };
+    const onToolCall = session.acs_enable_tools
+      ? this.toolRegistry.createToolCallHandler(toolCtx)
+      : undefined;
+
+    const start = Date.now();
+    const response = await this.aiService.converse({
+      providerName: session.acs_provider,
+      systemPrompt: session.acs_system_prompt || 'You are a helpful assistant.',
+      messages,
+      tools,
+      onToolCall,
+      maxTokens: 4096,
+    });
+    const durationMs = Date.now() - start;
+
+    // Persist assistant messages
+    const newMessages: { role: AcmRole; content: string; metadata: any }[] = [];
+
+    if (response.toolCalls?.length) {
+      for (const tc of response.toolCalls) {
+        newMessages.push({
+          role: 'tool_result',
+          content: `${tc.name}(${JSON.stringify(tc.arguments)})`,
+          metadata: { toolCallId: tc.id, toolName: tc.name, arguments: tc.arguments },
+        });
+      }
+    }
+
+    if (response.text) {
+      newMessages.push({
+        role: 'assistant',
+        content: response.text,
+        metadata: { usage: response.usage, durationMs, stopReason: response.stopReason },
+      });
+    } else if (newMessages.length === 0) {
+      newMessages.push({
+        role: 'assistant',
+        content: `[${response.stopReason}]`,
+        metadata: { usage: response.usage, durationMs, stopReason: response.stopReason },
+      });
+    }
+
+    await this.persistAndUpdateCounters(sessionId, newMessages);
+
+    return {
+      text: response.text,
+      toolCalls: response.toolCalls,
+      stopReason: response.stopReason,
+      usage: response.usage,
+      durationMs,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  ELEVENLABS (WebSocket text-only)                                   */
+  /* ------------------------------------------------------------------ */
+
+  private async converseElevenLabs(
+    sessionId: string,
+    session: Awaited<ReturnType<typeof this.getSession>>,
+    content: string,
+  ) {
+    // Resolve the ElevenLabs agent ID
+    let elAgentId: string | undefined;
+    if (session.acs_agent_id) {
+      const agent = await this.prisma.agent.findUnique({
+        where: { agent_id: session.acs_agent_id },
+        select: { agent_elevenlabs_id: true },
+      });
+      elAgentId = agent?.agent_elevenlabs_id || undefined;
+    }
+    if (!elAgentId) {
+      throw new BadRequestException(
+        'ElevenLabs provider requires an agent with an ElevenLabs ID',
+      );
+    }
+
+    const conn = await this.getOrCreateELConnection(sessionId, elAgentId);
+    await conn.ready;
+
+    const start = Date.now();
+
+    // Send user message and wait for agent response
+    const responseText = await new Promise<string>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        conn.ws.removeListener('message', handler);
+        reject(new Error('ElevenLabs response timeout (30s)'));
+      }, 30_000);
+      let collected = '';
+      let debounce: ReturnType<typeof setTimeout> | null = null;
+
+      const handler = (raw: WebSocket.Data) => {
+        let msg: any;
+        try { msg = JSON.parse(raw.toString()); } catch { return; }
+
+        if (msg.type === 'ping') {
+          conn.ws.send(JSON.stringify({ type: 'pong' }));
+          return;
+        }
+        if (msg.type === 'audio') return; // ignore audio chunks
+
+        // Collect agent text — nested under agent_response_event.agent_response
+        if (msg.type === 'agent_response') {
+          const text = (msg.agent_response_event?.agent_response ?? '').trim();
+          if (text) collected = text;
+        }
+
+        // agent_response_correction replaces the previous response
+        if (msg.type === 'agent_response_correction') {
+          const text = (msg.agent_response_correction_event?.agent_response ?? '').trim();
+          if (text) collected = text;
+        }
+
+        // When we have text, debounce to collect all chunks then resolve
+        if (collected) {
+          if (debounce) clearTimeout(debounce);
+          debounce = setTimeout(() => {
+            clearTimeout(timeout);
+            conn.ws.removeListener('message', handler);
+            resolve(collected);
+          }, 1500);
+        }
+      };
+
+      conn.ws.on('message', handler);
+      conn.ws.send(JSON.stringify({ type: 'user_message', text: content }));
+    });
+
+    const durationMs = Date.now() - start;
+
+    // Persist
+    await this.persistAndUpdateCounters(sessionId, [{
+      role: 'assistant',
+      content: responseText,
+      metadata: { durationMs, provider: 'elevenlabs', conversationId: conn.conversationId },
+    }]);
+
+    return {
+      text: responseText,
+      toolCalls: [],
+      stopReason: 'end_turn',
+      usage: { inputTokens: 0, outputTokens: 0 },
+      durationMs,
+    };
+  }
+
+  private async getOrCreateELConnection(sessionId: string, elAgentId: string): Promise<ELConnection> {
+    const existing = this.elConnections.get(sessionId);
+    if (existing && existing.ws.readyState === WebSocket.OPEN) {
+      return existing;
+    }
+
+    // Clean up stale
+    this.closeELConnection(sessionId);
+
+    const { signed_url } = await this.elevenlabs.getSignedUrl(elAgentId);
+    const ws = new WebSocket(`${signed_url}&textOnly=true`);
+
+    let readyResolve: () => void;
+    let readyReject: (err: Error) => void;
+    const ready = new Promise<void>((resolve, reject) => {
+      readyResolve = resolve;
+      readyReject = reject;
+    });
+
+    const conn: ELConnection = { ws, conversationId: null, ready };
+    this.elConnections.set(sessionId, conn);
+
+    ws.on('open', () => {
+      ws.send(JSON.stringify({
+        type: 'conversation_initiation_client_data',
+        conversation_config_override: {},
+        dynamic_variables: {
+          current_date: new Date().toISOString().split('T')[0],
+        },
+      }));
+    });
+
+    ws.on('message', (raw) => {
+      let msg: any;
+      try { msg = JSON.parse(raw.toString()); } catch { return; }
+
+      if (msg.type === 'conversation_initiation_metadata') {
+        conn.conversationId = msg.conversation_id;
+        readyResolve!();
+      }
+
+      if (msg.type === 'ping') {
+        ws.send(JSON.stringify({ type: 'pong', event_id: msg.ping_event?.event_id }));
+      }
+    });
+
+    ws.on('close', () => {
+      this.elConnections.delete(sessionId);
+    });
+
+    ws.on('error', (err) => {
+      this.logger.error(`EL WS error for session ${sessionId}: ${err.message}`);
+      readyReject!(err);
+      this.elConnections.delete(sessionId);
+    });
+
+    // Timeout
+    setTimeout(() => readyReject!(new Error('EL WS ready timeout (15s)')), 15_000);
+
+    return conn;
+  }
+
+  private closeELConnection(sessionId: string) {
+    const conn = this.elConnections.get(sessionId);
+    if (!conn) return;
+    try {
+      if (conn.ws.readyState === WebSocket.OPEN || conn.ws.readyState === WebSocket.CONNECTING) {
+        conn.ws.close(1000, 'session_ended');
+      }
+    } catch { /* ignore */ }
+    this.elConnections.delete(sessionId);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  HELPERS                                                            */
+  /* ------------------------------------------------------------------ */
+
+  private async persistAndUpdateCounters(
+    sessionId: string,
+    newMessages: { role: AcmRole; content: string; metadata: any }[],
+  ) {
+    if (newMessages.length > 0) {
+      await this.prisma.adminChatMessage.createMany({
+        data: newMessages.map((m) => ({
+          acm_session_id: sessionId,
+          acm_role: m.role,
+          acm_content: m.content,
+          acm_metadata: m.metadata,
+        })),
+      });
+    }
+
+    await this.prisma.adminChatSession.update({
+      where: { acs_id: sessionId },
+      data: {
+        acs_message_count: { increment: 1 + newMessages.length },
+        acs_last_message_at: new Date(),
+      },
+    });
+  }
+}

package/nestjs/src/admin/ai-test.controller.ts

@@ -0,0 +1,191 @@
+import {
+  Controller,
+  Post,
+  Get,
+  Patch,
+  Delete,
+  Body,
+  Param,
+  Query,
+  UseGuards,
+  BadRequestException,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { AIService } from '../integrations/ai/ai.service';
+import { ToolRegistryService } from '../tools/tool-registry.service';
+import { PrismaService } from '../database/prisma.service';
+import { AiChatSessionService } from './ai-chat-session.service';
+import { JwtAuthGuard, SuperadminGuard } from '../common/guards';
+import { CurrentUser } from '../common/decorators';
+import type { JwtPayload } from '../common/interfaces/jwt-payload.interface';
+import type { AIMessage } from '../integrations/ai/ai.interface';
+import type { ToolContext } from '../tools/tool.interfaces';
+
+@ApiTags('Admin — AI Test')
+@Controller('admin/ai-test')
+@UseGuards(JwtAuthGuard, SuperadminGuard)
+@ApiBearerAuth()
+export class AITestController {
+  constructor(
+    private readonly aiService: AIService,
+    private readonly toolRegistry: ToolRegistryService,
+    private readonly prisma: PrismaService,
+    private readonly chatSessions: AiChatSessionService,
+  ) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  METADATA                                                           */
+  /* ------------------------------------------------------------------ */
+
+  @Get('providers')
+  @ApiOperation({ summary: 'List available AI providers' })
+  getProviders() {
+    return ['openai', 'anthropic'].map((name) => {
+      try {
+        const provider = this.aiService.getProvider(name);
+        return { name: provider.name, available: true };
+      } catch {
+        return { name, available: false };
+      }
+    });
+  }
+
+  @Get('tools')
+  @ApiOperation({ summary: 'List all registered tools' })
+  getTools(@Query('features') features?: string) {
+    const featureList = features
+      ? features.split(',')
+      : ['google_calendar', 'operator_workflow', 'voice_transcription', 'appointment_validation'];
+    return this.toolRegistry.getAITools(featureList, 'whatsapp');
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  TEST ENDPOINTS                                                     */
+  /* ------------------------------------------------------------------ */
+
+  @Post('generate')
+  @ApiOperation({ summary: 'Test single-turn text generation' })
+  async testGenerate(
+    @Body() body: { provider: string; prompt: string; systemPrompt?: string },
+  ) {
+    if (!body.prompt) throw new BadRequestException('prompt required');
+
+    const start = Date.now();
+    const provider = this.aiService.getProvider(body.provider);
+    const result = await provider.generateText({
+      prompt: body.prompt,
+      systemPrompt: body.systemPrompt,
+      maxTokens: 1024,
+    });
+
+    return { provider: provider.name, result, durationMs: Date.now() - start };
+  }
+
+  @Post('converse')
+  @ApiOperation({ summary: 'Test multi-turn conversation with tools' })
+  async testConverse(
+    @Body() body: {
+      provider: string;
+      systemPrompt: string;
+      messages: AIMessage[];
+      enableTools?: boolean;
+      tenantId?: string;
+      clinicId?: string;
+      channel?: string;
+    },
+  ) {
+    if (!body.messages?.length) throw new BadRequestException('messages required');
+
+    // Resolve tenant features for tool filtering
+    let features: string[] = [];
+    if (body.tenantId) {
+      const tenant = await this.prisma.tenant.findUnique({
+        where: { tenant_id: body.tenantId },
+        select: { tenant_enabled_features: true },
+      });
+      features = (tenant?.tenant_enabled_features as string[]) ?? [];
+    }
+
+    const channel = body.channel || 'whatsapp';
+    const tools = body.enableTools
+      ? this.toolRegistry.getAITools(features, channel)
+      : undefined;
+
+    // Build tool context for execution
+    const toolCtx: ToolContext = {
+      tenantId: body.tenantId || '',
+      clinicId: body.clinicId || null,
+      patientPhone: 'test-playground',
+      patientName: 'Test User',
+      channel: channel as any,
+      channelMetadata: {},
+    };
+    const onToolCall = body.enableTools
+      ? this.toolRegistry.createToolCallHandler(toolCtx)
+      : undefined;
+
+    const start = Date.now();
+    const response = await this.aiService.converse({
+      providerName: body.provider,
+      systemPrompt: body.systemPrompt || 'You are a helpful assistant.',
+      messages: body.messages,
+      tools,
+      onToolCall,
+      maxTokens: 4096,
+    });
+
+    return {
+      provider: body.provider,
+      text: response.text,
+      toolCalls: response.toolCalls,
+      stopReason: response.stopReason,
+      usage: response.usage,
+      durationMs: Date.now() - start,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CHAT SESSIONS (persistent)                                         */
+  /* ------------------------------------------------------------------ */
+
+  @Post('sessions')
+  @ApiOperation({ summary: 'Create a new chat session' })
+  async createSession(@CurrentUser() user: JwtPayload, @Body() dto: any) {
+    return this.chatSessions.createSession(user.sub, dto);
+  }
+
+  @Get('sessions')
+  @ApiOperation({ summary: 'List chat sessions for current user' })
+  async listSessions(@CurrentUser() user: JwtPayload) {
+    return this.chatSessions.listSessions(user.sub);
+  }
+
+  @Get('sessions/:id')
+  @ApiOperation({ summary: 'Get session with messages' })
+  async getSession(@Param('id') id: string, @CurrentUser() user: JwtPayload) {
+    return this.chatSessions.getSession(id, user.sub);
+  }
+
+  @Patch('sessions/:id')
+  @ApiOperation({ summary: 'Update session config/title' })
+  async updateSession(@Param('id') id: string, @CurrentUser() user: JwtPayload, @Body() dto: any) {
+    return this.chatSessions.updateSession(id, user.sub, dto);
+  }
+
+  @Delete('sessions/:id')
+  @ApiOperation({ summary: 'Delete a session' })
+  async deleteSession(@Param('id') id: string, @CurrentUser() user: JwtPayload) {
+    return this.chatSessions.deleteSession(id, user.sub);
+  }
+
+  @Post('sessions/:id/converse')
+  @ApiOperation({ summary: 'Send message in session + get AI response (persisted)' })
+  async sessionConverse(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+    @Body() body: { content: string },
+  ) {
+    if (!body.content?.trim()) throw new BadRequestException('content required');
+    return this.chatSessions.converse(id, user.sub, body.content.trim());
+  }
+}