elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/agents/agents.service.ts

@@ -0,0 +1,733 @@
+import {
+  Injectable,
+  Inject,
+  Logger,
+  NotFoundException,
+  BadRequestException,
+} from '@nestjs/common';
+import type Redis from 'ioredis';
+import { PrismaService } from '../database/prisma.service';
+import { ElevenLabsService } from '../integrations/elevenlabs/elevenlabs.service';
+import { REDIS_CLIENT } from '../redis/redis.module';
+import { CreateAgentDto, UpdateAgentDto } from './dto';
+
+@Injectable()
+export class AgentsService {
+  private readonly logger = new Logger(AgentsService.name);
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly elevenlabs: ElevenLabsService,
+    @Inject(REDIS_CLIENT) private readonly redis: Redis,
+  ) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST                                                               */
+  /* ------------------------------------------------------------------ */
+
+  async findAllGlobal() {
+    return this.prisma.agent.findMany({
+      orderBy: { agent_created_at: 'desc' },
+      include: {
+        tenant: { select: { tenant_id: true, tenant_name: true } },
+        clinic: { select: { clinic_id: true, clinic_name: true } },
+        clinic_assignments: {
+          include: { clinic: { select: { clinic_id: true, clinic_name: true } } },
+        },
+        _count: { select: { phone_numbers: true, calls: true } },
+      },
+    });
+  }
+
+  /** Raw lookup — returns just the agent row for tenant resolution. */
+  async findByIdRaw(agentId: string) {
+    return this.prisma.agent.findUnique({
+      where: { agent_id: agentId },
+      select: { agent_id: true, agent_tenant_id: true },
+    });
+  }
+
+  async findAll(tenantId: string, clinicId?: string) {
+    const where: any = { agent_tenant_id: tenantId };
+
+    // If clinicId given, return agents for that clinic + tenant-level (clinicId = null)
+    if (clinicId) {
+      where.AND = [
+        { agent_tenant_id: tenantId },
+        {
+          OR: [
+            { agent_clinic_id: clinicId },
+            { agent_clinic_id: null },
+          ],
+        },
+      ];
+      delete where.agent_tenant_id;
+    }
+
+    return this.prisma.agent.findMany({
+      where,
+      orderBy: { agent_created_at: 'desc' },
+      include: {
+        clinic: {
+          select: {
+            clinic_id: true,
+            clinic_name: true,
+          },
+        },
+        clinic_assignments: {
+          include: {
+            clinic: { select: { clinic_id: true, clinic_name: true } },
+          },
+        },
+        _count: {
+          select: {
+            phone_numbers: true,
+            calls: true,
+          },
+        },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  SINGLE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async findById(agentId: string, tenantId: string | null) {
+    const agent = await this.prisma.agent.findFirst({
+      where: {
+        agent_id: agentId,
+        ...(tenantId ? { agent_tenant_id: tenantId } : {}),
+      },
+      include: {
+        clinic: {
+          select: {
+            clinic_id: true,
+            clinic_name: true,
+          },
+        },
+        _count: {
+          select: {
+            phone_numbers: true,
+            calls: true,
+          },
+        },
+      },
+    });
+
+    if (!agent) {
+      throw new NotFoundException('Agent not found');
+    }
+
+    return agent;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND BY ELEVENLABS ID (webhook lookup, no tenant scoping)          */
+  /* ------------------------------------------------------------------ */
+
+  async findByElevenlabsId(elevenlabsId: string) {
+    const agent = await this.prisma.agent.findFirst({
+      where: { agent_elevenlabs_id: elevenlabsId },
+      include: {
+        tenant: true,
+        clinic: true,
+      },
+    });
+
+    if (!agent) {
+      throw new NotFoundException(
+        `Agent with ElevenLabs ID "${elevenlabsId}" not found`,
+      );
+    }
+
+    return agent;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CREATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async create(tenantId: string | null, dto: CreateAgentDto) {
+    return this.prisma.agent.create({
+      data: {
+        agent_tenant_id: tenantId ?? undefined,
+        agent_name: dto.name,
+        agent_elevenlabs_id: dto.elevenlabsId ?? '',
+        ...(dto.clinicId !== undefined && { agent_clinic_id: dto.clinicId }),
+        ...(dto.description !== undefined && { agent_description: dto.description }),
+        ...(dto.voiceId !== undefined && { agent_voice_id: dto.voiceId }),
+        ...(dto.language !== undefined && { agent_language: dto.language }),
+        ...(dto.greeting !== undefined && { agent_greeting: dto.greeting }),
+        ...(dto.systemPrompt !== undefined && { agent_system_prompt: dto.systemPrompt }),
+        ...(dto.aiProvider !== undefined && { agent_ai_provider: dto.aiProvider }),
+        ...(dto.aiModel !== undefined && { agent_ai_model: dto.aiModel }),
+        ...(dto.postCallStrategy !== undefined && { agent_post_call_strategy: dto.postCallStrategy }),
+        ...(dto.postCallWaNotify !== undefined && { agent_post_call_wa_notify: dto.postCallWaNotify }),
+        ...(dto.postCallSmsNotify !== undefined && { agent_post_call_sms_notify: dto.postCallSmsNotify }),
+        ...(dto.summaryPrompt !== undefined && { agent_summary_prompt: dto.summaryPrompt }),
+        ...(dto.waMessageTemplate !== undefined && { agent_wa_message_template: dto.waMessageTemplate }),
+      },
+      include: {
+        clinic: {
+          select: {
+            clinic_id: true,
+            clinic_name: true,
+          },
+        },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CLINIC ASSIGNMENTS                                                 */
+  /* ------------------------------------------------------------------ */
+
+  async getClinicAssignments(agentId: string) {
+    return this.prisma.agentClinicAssignment.findMany({
+      where: { aca_agent_id: agentId },
+      include: {
+        clinic: {
+          select: { clinic_id: true, clinic_name: true },
+        },
+      },
+      orderBy: { aca_created_at: 'asc' },
+    });
+  }
+
+  async assignClinics(agentId: string, clinicIds: string[]) {
+    // Upsert — skip existing assignments
+    const existing = await this.prisma.agentClinicAssignment.findMany({
+      where: { aca_agent_id: agentId },
+      select: { aca_clinic_id: true },
+    });
+    const existingIds = new Set(existing.map((a) => a.aca_clinic_id));
+    const newIds = clinicIds.filter((id) => !existingIds.has(id));
+
+    if (newIds.length > 0) {
+      await this.prisma.agentClinicAssignment.createMany({
+        data: newIds.map((clinicId) => ({
+          aca_agent_id: agentId,
+          aca_clinic_id: clinicId,
+        })),
+      });
+    }
+
+    return this.getClinicAssignments(agentId);
+  }
+
+  async unassignClinic(agentId: string, clinicId: string) {
+    await this.prisma.agentClinicAssignment.deleteMany({
+      where: { aca_agent_id: agentId, aca_clinic_id: clinicId },
+    });
+    return { success: true };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async update(agentId: string, tenantId: string | null, dto: UpdateAgentDto) {
+    await this.findById(agentId, tenantId);
+
+    const data = this.mapDtoToPrisma(dto);
+
+    if (Object.keys(data).length === 0) {
+      throw new BadRequestException('No fields to update');
+    }
+
+    const result = await this.prisma.agent.update({
+      where: { agent_id: agentId },
+      data,
+      include: {
+        clinic: {
+          select: {
+            clinic_id: true,
+            clinic_name: true,
+          },
+        },
+        _count: {
+          select: {
+            phone_numbers: true,
+            calls: true,
+          },
+        },
+      },
+    });
+
+    await this.invalidateCache(tenantId);
+    if (dto.tenantId && dto.tenantId !== tenantId) {
+      await this.invalidateCache(dto.tenantId);
+    }
+    return result;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  TOGGLE ACTIVE                                                      */
+  /* ------------------------------------------------------------------ */
+
+  async toggleActive(agentId: string, tenantId: string | null) {
+    const agent = await this.findById(agentId, tenantId);
+
+    const result = await this.prisma.agent.update({
+      where: { agent_id: agentId },
+      data: { agent_is_active: !agent.agent_is_active },
+      include: {
+        clinic: {
+          select: {
+            clinic_id: true,
+            clinic_name: true,
+          },
+        },
+      },
+    });
+
+    await this.invalidateCache(tenantId);
+    return result;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  PROMPT MANAGEMENT                                                  */
+  /* ------------------------------------------------------------------ */
+
+  /** Update system prompt with versioning. */
+  async updatePrompt(
+    agentId: string,
+    tenantId: string | null,
+    prompt: string,
+    changeNote: string,
+    changedBy: string,
+  ) {
+    const agent = await this.findById(agentId, tenantId);
+
+    // Get next version number
+    const lastVersion = await this.prisma.agentPromptVersion.findFirst({
+      where: { pv_agent_id: agentId },
+      orderBy: { pv_version: 'desc' },
+      select: { pv_version: true },
+    });
+    const nextVersion = (lastVersion?.pv_version ?? 0) + 1;
+
+    // Save version + update agent in transaction
+    const [version, updated] = await this.prisma.$transaction([
+      this.prisma.agentPromptVersion.create({
+        data: {
+          pv_agent_id: agentId,
+          pv_version: nextVersion,
+          pv_prompt: prompt,
+          pv_change_note: changeNote,
+          pv_changed_by: changedBy,
+        },
+      }),
+      this.prisma.agent.update({
+        where: { agent_id: agentId },
+        data: { agent_system_prompt: prompt },
+      }),
+    ]);
+
+    this.logger.log(`Prompt updated for agent ${agent.agent_name} → v${nextVersion} by ${changedBy}`);
+    await this.invalidateCache(tenantId);
+
+    return { version: nextVersion, agent: updated };
+  }
+
+  /** Get prompt version history for an agent. */
+  async getPromptHistory(agentId: string, tenantId: string | null) {
+    await this.findById(agentId, tenantId); // verify access
+
+    return this.prisma.agentPromptVersion.findMany({
+      where: { pv_agent_id: agentId },
+      orderBy: { pv_version: 'desc' },
+      include: {
+        changed_by: {
+          select: { user_id: true, user_first_name: true, user_last_name: true },
+        },
+      },
+    });
+  }
+
+  /** Rollback to a specific prompt version. */
+  async rollbackPrompt(
+    agentId: string,
+    tenantId: string | null,
+    version: number,
+    changedBy: string,
+  ) {
+    await this.findById(agentId, tenantId);
+
+    const targetVersion = await this.prisma.agentPromptVersion.findFirst({
+      where: { pv_agent_id: agentId, pv_version: version },
+    });
+    if (!targetVersion) throw new NotFoundException(`Version ${version} not found`);
+
+    return this.updatePrompt(
+      agentId,
+      tenantId,
+      targetVersion.pv_prompt,
+      `Rollback to v${version}`,
+      changedBy,
+    );
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  ELEVENLABS SYNC                                                    */
+  /* ------------------------------------------------------------------ */
+
+  /** Create an ElevenLabs agent from our agent config. */
+  async createOnElevenLabs(agentId: string, tenantId: string | null) {
+    const agent = await this.findById(agentId, tenantId);
+
+    const result = await this.elevenlabs.createAgent({
+      name: agent.agent_name,
+      conversation_config: {
+        agent: {
+          prompt: { prompt: agent.agent_system_prompt },
+          first_message: agent.agent_greeting || undefined,
+          language: agent.agent_language,
+        },
+      },
+    });
+
+    // Save ElevenLabs ID back
+    await this.prisma.agent.update({
+      where: { agent_id: agentId },
+      data: {
+        agent_elevenlabs_id: result.agent_id,
+        agent_el_synced_at: new Date(),
+        agent_el_sync_error: null,
+      },
+    });
+
+    this.logger.log(`Created ElevenLabs agent ${result.agent_id} for ${agent.agent_name}`);
+    return { elevenlabsAgentId: result.agent_id };
+  }
+
+  /** Push current agent config to ElevenLabs. */
+  async syncToElevenLabs(agentId: string, tenantId: string | null) {
+    const agent = await this.findById(agentId, tenantId);
+
+    if (!agent.agent_elevenlabs_id) {
+      throw new BadRequestException('Agent has no ElevenLabs ID. Create on ElevenLabs first.');
+    }
+
+    try {
+      await this.elevenlabs.updateAgent(agent.agent_elevenlabs_id, {
+        name: agent.agent_name,
+        conversation_config: {
+          agent: {
+            prompt: { prompt: agent.agent_system_prompt },
+            first_message: agent.agent_greeting || undefined,
+            language: agent.agent_language,
+          },
+        },
+      });
+
+      await this.prisma.agent.update({
+        where: { agent_id: agentId },
+        data: { agent_el_synced_at: new Date(), agent_el_sync_error: null },
+      });
+
+      this.logger.log(`Synced agent ${agent.agent_name} to ElevenLabs`);
+      return { success: true };
+    } catch (err: any) {
+      await this.prisma.agent.update({
+        where: { agent_id: agentId },
+        data: { agent_el_sync_error: err.message },
+      });
+      throw err;
+    }
+  }
+
+  /** Pull agent config from ElevenLabs into our DB. */
+  async syncFromElevenLabs(agentId: string, tenantId: string | null, changedBy: string) {
+    const agent = await this.findById(agentId, tenantId);
+
+    if (!agent.agent_elevenlabs_id) {
+      throw new BadRequestException('Agent has no ElevenLabs ID');
+    }
+
+    let elAgent: any;
+    try {
+      elAgent = await this.elevenlabs.getAgent(agent.agent_elevenlabs_id);
+    } catch (err: any) {
+      await this.prisma.agent.update({
+        where: { agent_id: agentId },
+        data: { agent_el_sync_error: err.message },
+      });
+      throw new BadRequestException(`ElevenLabs sync failed: ${err.message}`);
+    }
+
+    const config = elAgent.conversation_config?.agent ?? {};
+    const prompt = config.prompt?.prompt ?? '';
+    const greeting = config.first_message ?? '';
+    const language = config.language ?? 'tr';
+    const name = elAgent.name ?? '';
+    const voiceId = elAgent.conversation_config?.tts?.voice_id ?? '';
+
+    // Update agent fields
+    const updates: Record<string, any> = {
+      agent_greeting: greeting,
+      agent_language: language,
+      agent_el_synced_at: new Date(),
+      agent_el_sync_error: null,
+    };
+    if (name && name !== agent.agent_name) updates.agent_name = name;
+    if (voiceId) updates.agent_voice_id = voiceId;
+
+    await this.prisma.agent.update({
+      where: { agent_id: agentId },
+      data: updates,
+    });
+
+    // Track prompt change
+    let promptChanged = false;
+    if (prompt && prompt !== agent.agent_system_prompt) {
+      await this.updatePrompt(agentId, tenantId, prompt, 'Synced from ElevenLabs', changedBy);
+      promptChanged = true;
+    }
+
+    return {
+      success: true,
+      synced: {
+        name: name !== agent.agent_name,
+        greeting: greeting !== agent.agent_greeting,
+        language: language !== agent.agent_language,
+        prompt: promptChanged,
+        voiceId: !!voiceId,
+      },
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  ELEVENLABS IMPORT / MATCH                                          */
+  /* ------------------------------------------------------------------ */
+
+  /** List ElevenLabs agents (single page) with match status against our DB. */
+  async listElevenLabsAgents(tenantId: string | null, cursor?: string) {
+    const [elPage, dbAgents] = await Promise.all([
+      this.elevenlabs.listAgents(cursor),
+      this.prisma.agent.findMany({
+        where: tenantId ? { agent_tenant_id: tenantId } : {},
+        select: { agent_id: true, agent_elevenlabs_id: true, agent_name: true },
+      }),
+    ]);
+
+    const linkedElIds = new Set(dbAgents.map((a) => a.agent_elevenlabs_id).filter(Boolean));
+
+    return {
+      agents: elPage.agents.map((el: any) => ({
+        elevenlabsId: el.agent_id,
+        name: el.name,
+        language: el.conversation_config?.agent?.language,
+        hasPrompt: !!el.conversation_config?.agent?.prompt?.prompt,
+        linked: linkedElIds.has(el.agent_id),
+        linkedAgentId: dbAgents.find((a) => a.agent_elevenlabs_id === el.agent_id)?.agent_id ?? null,
+        linkedAgentName: dbAgents.find((a) => a.agent_elevenlabs_id === el.agent_id)?.agent_name ?? null,
+      })),
+      has_more: elPage.has_more,
+      next_cursor: elPage.next_cursor,
+    };
+  }
+
+  /** Import an ElevenLabs agent into our system. */
+  async importFromElevenLabs(
+    tenantId: string | null,
+    elevenlabsId: string,
+    clinicId: string | null,
+    changedBy: string,
+  ) {
+    const existing = await this.prisma.agent.findFirst({
+      where: { agent_elevenlabs_id: elevenlabsId },
+    });
+    if (existing) {
+      throw new BadRequestException(`Already linked to agent "${existing.agent_name}"`);
+    }
+
+    // Fetch from ElevenLabs
+    const elAgent = await this.elevenlabs.getAgent(elevenlabsId);
+    const agentConfig = elAgent.conversation_config?.agent ?? {};
+    const prompt = agentConfig.prompt?.prompt ?? '';
+    const greeting = agentConfig.first_message ?? '';
+    const language = agentConfig.language ?? 'tr';
+    const name = elAgent.name ?? 'Imported Agent';
+
+    // Create in our DB
+    const agent = await this.prisma.agent.create({
+      data: {
+        agent_tenant_id: tenantId ?? undefined,
+        agent_clinic_id: clinicId,
+        agent_elevenlabs_id: elevenlabsId,
+        agent_name: name,
+        agent_system_prompt: prompt,
+        agent_greeting: greeting,
+        agent_language: language,
+        agent_ai_provider: 'elevenlabs',
+        agent_el_synced_at: new Date(),
+      },
+    });
+
+    // Save initial prompt version
+    if (prompt) {
+      await this.prisma.agentPromptVersion.create({
+        data: {
+          pv_agent_id: agent.agent_id,
+          pv_version: 1,
+          pv_prompt: prompt,
+          pv_change_note: `Imported from ElevenLabs (${elevenlabsId})`,
+          pv_changed_by: changedBy,
+        },
+      });
+    }
+
+    this.logger.log(`Imported ElevenLabs agent ${elevenlabsId} as "${name}"`);
+    return agent;
+  }
+
+  /** Link an existing DB agent to an ElevenLabs agent. */
+  async linkToElevenLabs(
+    agentId: string,
+    tenantId: string | null,
+    elevenlabsId: string,
+  ) {
+    const agent = await this.findById(agentId, tenantId);
+
+    if (agent.agent_elevenlabs_id && agent.agent_elevenlabs_id !== elevenlabsId) {
+      throw new BadRequestException(`Agent already linked to ElevenLabs ID ${agent.agent_elevenlabs_id}`);
+    }
+
+    return this.prisma.agent.update({
+      where: { agent_id: agentId },
+      data: {
+        agent_elevenlabs_id: elevenlabsId,
+        agent_el_synced_at: new Date(),
+        agent_el_sync_error: null,
+      },
+    });
+  }
+
+  /** Unlink an agent from ElevenLabs (doesn't delete the EL agent). */
+  async unlinkFromElevenLabs(agentId: string, tenantId: string | null) {
+    await this.findById(agentId, tenantId);
+
+    return this.prisma.agent.update({
+      where: { agent_id: agentId },
+      data: {
+        agent_elevenlabs_id: '',
+        agent_el_synced_at: null,
+        agent_el_sync_error: null,
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  TENANT ASSIGNMENT                                                  */
+  /* ------------------------------------------------------------------ */
+
+  async assignTenant(agentId: string, tenantId: string) {
+    const agent = await this.prisma.agent.findUnique({
+      where: { agent_id: agentId },
+    });
+    if (!agent) throw new NotFoundException('Agent not found');
+    if (agent.agent_tenant_id) {
+      throw new BadRequestException('Agent already has a tenant');
+    }
+
+    const result = await this.prisma.agent.update({
+      where: { agent_id: agentId },
+      data: { agent_tenant_id: tenantId },
+      include: {
+        tenant: { select: { tenant_id: true, tenant_name: true } },
+        clinic: { select: { clinic_id: true, clinic_name: true } },
+      },
+    });
+
+    await this.invalidateCache(tenantId);
+    return result;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  HELPERS                                                            */
+  /* ------------------------------------------------------------------ */
+
+  /* ------------------------------------------------------------------ */
+  /*  PROVIDER OPTIONS                                                   */
+  /* ------------------------------------------------------------------ */
+
+  getProviderOptions() {
+    return [
+      {
+        id: 'elevenlabs',
+        name: 'ElevenLabs',
+        description: 'Voice + text AI via WebSocket (requires ElevenLabs agent ID)',
+        mode: 'voice',
+        models: [],
+        requiresExternalId: true,
+      },
+      {
+        id: 'anthropic',
+        name: 'Anthropic (Claude)',
+        description: 'Text-based AI agent via API',
+        mode: 'text',
+        models: [
+          { id: 'claude-sonnet-4-20250514', name: 'Claude Sonnet 4', tier: 'standard', contextWindow: 200000 },
+          { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', tier: 'fast', contextWindow: 200000 },
+          { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', tier: 'premium', contextWindow: 1000000 },
+        ],
+        requiresExternalId: false,
+      },
+      {
+        id: 'openai',
+        name: 'OpenAI (GPT)',
+        description: 'Text-based AI agent via API',
+        mode: 'text',
+        models: [
+          { id: 'gpt-4o', name: 'GPT-4o', tier: 'standard', contextWindow: 128000 },
+          { id: 'gpt-4o-mini', name: 'GPT-4o Mini', tier: 'fast', contextWindow: 128000 },
+          { id: 'gpt-4.1', name: 'GPT-4.1', tier: 'premium', contextWindow: 1000000 },
+          { id: 'o3-mini', name: 'o3-mini', tier: 'reasoning', contextWindow: 200000 },
+        ],
+        requiresExternalId: false,
+      },
+    ];
+  }
+
+  /** Invalidate agent config cache for a tenant. */
+  private async invalidateCache(tenantId: string | null): Promise<void> {
+    if (!tenantId) return;
+    const keys = await this.redis.keys(`agent_config:${tenantId}:*`);
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+  }
+
+  private mapDtoToPrisma(dto: UpdateAgentDto): Record<string, any> {
+    const map: Record<string, any> = {};
+
+    if (dto.tenantId !== undefined) map.agent_tenant_id = dto.tenantId;
+    if (dto.name !== undefined) map.agent_name = dto.name;
+    if (dto.elevenlabsId !== undefined) map.agent_elevenlabs_id = dto.elevenlabsId;
+    if (dto.clinicId !== undefined) map.agent_clinic_id = dto.clinicId;
+    if (dto.description !== undefined) map.agent_description = dto.description;
+    if (dto.voiceId !== undefined) map.agent_voice_id = dto.voiceId;
+    if (dto.language !== undefined) map.agent_language = dto.language;
+    if (dto.greeting !== undefined) map.agent_greeting = dto.greeting;
+    if (dto.systemPrompt !== undefined) map.agent_system_prompt = dto.systemPrompt;
+    if (dto.aiProvider !== undefined) map.agent_ai_provider = dto.aiProvider;
+    if (dto.aiModel !== undefined) map.agent_ai_model = dto.aiModel;
+    if (dto.postCallStrategy !== undefined) map.agent_post_call_strategy = dto.postCallStrategy;
+    if (dto.postCallWaNotify !== undefined) map.agent_post_call_wa_notify = dto.postCallWaNotify;
+    if (dto.postCallSmsNotify !== undefined) map.agent_post_call_sms_notify = dto.postCallSmsNotify;
+    if (dto.summaryPrompt !== undefined) map.agent_summary_prompt = dto.summaryPrompt;
+    if (dto.waMessageTemplate !== undefined) map.agent_wa_message_template = dto.waMessageTemplate;
+    if (dto.temperature !== undefined) map.agent_temperature = dto.temperature;
+    if (dto.maxTokens !== undefined) map.agent_max_tokens = dto.maxTokens;
+    if (dto.enabledTools !== undefined) map.agent_enabled_tools = dto.enabledTools;
+    if (dto.tags !== undefined) map.agent_tags = dto.tags;
+    if (dto.channels !== undefined) map.agent_channels = dto.channels;
+    if (dto.status !== undefined) map.agent_status = dto.status;
+    if (dto.metadata !== undefined) map.agent_metadata = dto.metadata;
+    if (dto.isActive !== undefined) map.agent_is_active = dto.isActive;
+
+    return map;
+  }
+}