inbound calls

Author: mesut

apps/agent/src/expressive_agent.py

@@ -411,7 +411,6 @@ async def tts_node(self, text: AsyncIterable[str], model_settings: ModelSettings
         params = {}
         if voice_instruction:
             params = self._map_instruction_to_params(voice_instruction)
-            logger.info(f"Voice instruction: '{voice_instruction}' -> TTS params: {params}")
 
         # Create inference.TTS with extra_kwargs for this utterance
         tts_kwargs = dict(self._tts_config)

apps/backend/.env.example

@@ -14,6 +14,12 @@ LIVEKIT_API_SECRET=your_api_secret
 # Default: "aylin-agent" for production, "aylin-dev-agent" for development
 # AGENT_NAME=aylin-dev-agent
 
+# LiveKit SIP Endpoint for inbound calls (WITHOUT sip: prefix)
+# Find this in your LiveKit Cloud project settings under "SIP URI"
+# Format: your-project-id.sip.livekit.cloud
+# Example: 3bfg1girhxh.sip.livekit.cloud
+LIVEKIT_SIP_ENDPOINT=3bfg1girhxh.sip.livekit.cloud
+
 # Database Configuration
 DATABASE_URL=postgresql://aylin_user:aylin_password@localhost:5432/aylin
 DATABASE_HOST=localhost

apps/backend/.env.production

@@ -36,3 +36,9 @@ AZURE_STORAGE_CONNECTION_STRING=DefaultEndpointsProtocol=https;EndpointSuffix=co
 
 AGENT_NAME=aylin-agent
 
+
+# LiveKit SIP Endpoint for inbound calls (WITHOUT sip: prefix)
+# Find this in your LiveKit Cloud project settings under "SIP URI"
+# Format: your-project-id.sip.livekit.cloud
+# Example: 3bfg1girhxh.sip.livekit.cloud
+LIVEKIT_SIP_ENDPOINT=3bfg1girhxh.sip.livekit.cloud

apps/backend/migrations/V18__add_inbound_settings.sql

@@ -0,0 +1,4 @@
+ALTER TABLE phone_numbers
+    ADD COLUMN inbound_agent_id UUID REFERENCES agents(id) ON DELETE SET NULL,
+    ADD COLUMN livekit_dispatch_rule_id VARCHAR(255),
+    ADD COLUMN fallback_number VARCHAR(20);

apps/backend/src/routes/phone-numbers.ts

@@ -12,7 +12,8 @@ router.use(authenticateToken);
 // Helper to separate sensitive configuration from response data
 const sanitizePhoneNumber = (pn: any) => {
   if (!pn) return null;
-  const { configuration, provider, livekit_outbound_trunk_id, livekit_inbound_trunk_id, ...safeData } = pn;
+  // Keep inbound_agent_id and fallback_number, but hide internal LiveKit IDs and config
+  const { configuration, provider, livekit_outbound_trunk_id, livekit_inbound_trunk_id, livekit_dispatch_rule_id, ...safeData } = pn;
   return safeData;
 };
 
@@ -327,6 +328,122 @@ router.put('/:id', async (req: Request, res: Response) => {
   }
 });
 
+// Configure inbound settings (assign agent, create inbound trunk + dispatch rule)
+router.put('/:id/inbound', async (req: Request, res: Response) => {
+  const { id } = req.params;
+  const { agentId, fallbackNumber } = req.body;
+  const userId = (req as any).user.id;
+
+  try {
+    // Fetch the phone number
+    const phoneResult = await pool.query(
+      'SELECT * FROM phone_numbers WHERE id = $1 AND user_id = $2',
+      [id, userId]
+    );
+
+    if (phoneResult.rows.length === 0) {
+      return res.status(404).json({ error: 'Phone number not found' });
+    }
+
+    const phoneNumber = phoneResult.rows[0];
+    const livekitService = new LiveKitSipConfigService();
+
+    // Determine agent name from environment
+    const isProduction = process.env.NODE_ENV === 'production';
+    const agentName = process.env.AGENT_NAME || (isProduction ? 'aylin-agent' : 'aylin-dev-agent');
+
+    // If agentId is null/empty, remove inbound settings
+    if (!agentId) {
+      // Clean up existing LiveKit resources
+      if (phoneNumber.livekit_dispatch_rule_id) {
+        await livekitService.deleteDispatchRule(phoneNumber.livekit_dispatch_rule_id);
+      }
+      if (phoneNumber.livekit_inbound_trunk_id) {
+        await livekitService.deleteTrunk(phoneNumber.livekit_inbound_trunk_id);
+      }
+
+      const result = await pool.query(
+        `UPDATE phone_numbers
+         SET inbound_agent_id = NULL,
+             livekit_inbound_trunk_id = NULL,
+             livekit_dispatch_rule_id = NULL,
+             fallback_number = NULL
+         WHERE id = $1 AND user_id = $2
+         RETURNING *`,
+        [id, userId]
+      );
+
+      console.log(`Inbound settings removed for phone number ${phoneNumber.phone_number}`);
+      return res.json(sanitizePhoneNumber(result.rows[0]));
+    }
+
+    // Verify agent exists
+    const agentResult = await pool.query('SELECT id FROM agents WHERE id = $1', [agentId]);
+    if (agentResult.rows.length === 0) {
+      return res.status(404).json({ error: 'Agent not found' });
+    }
+
+    // Clean up old inbound resources if they exist
+    if (phoneNumber.livekit_dispatch_rule_id) {
+      await livekitService.deleteDispatchRule(phoneNumber.livekit_dispatch_rule_id);
+    }
+    if (phoneNumber.livekit_inbound_trunk_id) {
+      await livekitService.deleteTrunk(phoneNumber.livekit_inbound_trunk_id);
+    }
+
+    // Create new inbound trunk
+    console.log(`Creating inbound trunk for ${phoneNumber.phone_number}...`);
+    const inboundTrunk = await livekitService.createInboundTrunk({
+      phoneNumber: phoneNumber.phone_number,
+      name: `Inbound-${phoneNumber.phone_number.replace(/[^\w]/g, '')}`,
+    });
+
+    // Create dispatch rule linking to the agent
+    console.log(`Creating dispatch rule for agent ${agentId}...`);
+    const dispatchRule = await livekitService.createInboundDispatchRule({
+      inboundTrunkId: inboundTrunk.inboundTrunkId,
+      agentName,
+      agentId,
+    });
+
+    // Update database
+    const result = await pool.query(
+      `UPDATE phone_numbers
+       SET inbound_agent_id = $1,
+           livekit_inbound_trunk_id = $2,
+           livekit_dispatch_rule_id = $3,
+           fallback_number = $4
+       WHERE id = $5 AND user_id = $6
+       RETURNING *`,
+      [agentId, inboundTrunk.inboundTrunkId, dispatchRule.dispatchRuleId, fallbackNumber || null, id, userId]
+    );
+
+    console.log(`Inbound settings configured for ${phoneNumber.phone_number}`);
+    console.log(`   Inbound Trunk: ${inboundTrunk.inboundTrunkId}`);
+    console.log(`   Dispatch Rule: ${dispatchRule.dispatchRuleId}`);
+    console.log(`   Agent: ${agentId}`);
+
+    const updatedPhone = result.rows[0];
+    console.log('Database result:', {
+      inbound_agent_id: updatedPhone.inbound_agent_id,
+      livekit_inbound_trunk_id: updatedPhone.livekit_inbound_trunk_id,
+      livekit_dispatch_rule_id: updatedPhone.livekit_dispatch_rule_id,
+      fallback_number: updatedPhone.fallback_number,
+    });
+
+    const sanitized = sanitizePhoneNumber(updatedPhone);
+    console.log('Sanitized response:', {
+      inbound_agent_id: sanitized.inbound_agent_id,
+      fallback_number: sanitized.fallback_number,
+    });
+
+    res.json(sanitized);
+  } catch (error: any) {
+    console.error('Error configuring inbound settings:', error);
+    res.status(500).json({ error: 'Failed to configure inbound settings', message: error.message });
+  }
+});
+
 router.delete('/:id', async (req: Request, res: Response) => {
   const { id } = req.params;
   const userId = (req as any).user.id;
@@ -346,23 +463,32 @@ router.delete('/:id', async (req: Request, res: Response) => {
     const config = phoneNumber.configuration;
 
     // Cleanup external resources if they exist
-    if (config) {
-      try {
-        // 1. Delete LiveKit trunk
-        if (phoneNumber.livekit_outbound_trunk_id) {
-          const livekitService = new LiveKitSipConfigService();
-          await livekitService.deleteTrunk(phoneNumber.livekit_outbound_trunk_id);
-        }
+    try {
+      const livekitService = new LiveKitSipConfigService();
 
-        // 2. Delete Twilio trunk
-        if (config.twilioTrunkSid && config.accountSid && config.authToken) {
-          const twilioService = new TwilioSipTrunkService(config.accountSid, config.authToken);
-          await twilioService.deleteSipTrunk(config.twilioTrunkSid);
-        }
-      } catch (cleanupError) {
-        console.error('Error cleaning up external resources:', cleanupError);
-        // Continue with deletion even if cleanup fails
+      // 1. Delete inbound dispatch rule
+      if (phoneNumber.livekit_dispatch_rule_id) {
+        await livekitService.deleteDispatchRule(phoneNumber.livekit_dispatch_rule_id);
+      }
+
+      // 2. Delete inbound trunk
+      if (phoneNumber.livekit_inbound_trunk_id) {
+        await livekitService.deleteTrunk(phoneNumber.livekit_inbound_trunk_id);
+      }
+
+      // 3. Delete outbound trunk
+      if (phoneNumber.livekit_outbound_trunk_id) {
+        await livekitService.deleteTrunk(phoneNumber.livekit_outbound_trunk_id);
+      }
+
+      // 4. Delete Twilio trunk
+      if (config && config.twilioTrunkSid && config.accountSid && config.authToken) {
+        const twilioService = new TwilioSipTrunkService(config.accountSid, config.authToken);
+        await twilioService.deleteSipTrunk(config.twilioTrunkSid);
       }
+    } catch (cleanupError) {
+      console.error('Error cleaning up external resources:', cleanupError);
+      // Continue with deletion even if cleanup fails
     }
 
     // Delete from database

apps/backend/src/services/livekitSipConfigService.ts

@@ -1,4 +1,5 @@
 import { SipClient } from 'livekit-server-sdk';
+import { RoomConfiguration, RoomAgentDispatch } from '@livekit/protocol';
 import { ElasticTrunkResult } from './twilioSipTrunkService';
 
 interface CreateTwilioTrunkParams {
@@ -110,6 +111,81 @@ export class LiveKitSipConfigService {
     }
   }
 
+  async createInboundTrunk(params: {
+    phoneNumber: string;
+    name?: string;
+  }) {
+    const { phoneNumber, name } = params;
+    const safePhoneNumber = phoneNumber.replace(/[^\w]/g, '');
+
+    try {
+      console.log(`Creating LiveKit SIP Inbound Trunk for ${phoneNumber}`);
+
+      const trunk = await this.sipClient.createSipInboundTrunk(
+        name || `Inbound-${safePhoneNumber}`,
+        [phoneNumber],
+        {
+          krispEnabled: true,
+        }
+      );
+
+      console.log(`LiveKit Inbound Trunk created: ${trunk.sipTrunkId}`);
+      return { inboundTrunkId: trunk.sipTrunkId };
+    } catch (error) {
+      console.error('Error creating LiveKit SIP Inbound Trunk:', error);
+      throw error;
+    }
+  }
+
+  async createInboundDispatchRule(params: {
+    inboundTrunkId: string;
+    agentName: string;
+    agentId: string;
+  }) {
+    const { inboundTrunkId, agentName, agentId } = params;
+
+    try {
+      console.log(`Creating SIP dispatch rule for trunk ${inboundTrunkId}, agent ${agentId}`);
+
+      const dispatchRule = await this.sipClient.createSipDispatchRule(
+        {
+          type: 'individual',
+          roomPrefix: 'inbound-',
+        },
+        {
+          name: `Inbound-dispatch-${agentId}`,
+          trunkIds: [inboundTrunkId],
+          roomConfig: new RoomConfiguration({
+            agents: [
+              new RoomAgentDispatch({
+                agentName: agentName,
+                metadata: JSON.stringify({
+                  agentId,
+                  conversationType: 'inbound',
+                }),
+              }),
+            ],
+          }),
+        }
+      );
+
+      console.log(`SIP dispatch rule created: ${dispatchRule.sipDispatchRuleId}`);
+      return { dispatchRuleId: dispatchRule.sipDispatchRuleId };
+    } catch (error) {
+      console.error('Error creating SIP dispatch rule:', error);
+      throw error;
+    }
+  }
+
+  async deleteDispatchRule(dispatchRuleId: string) {
+    try {
+      await this.sipClient.deleteSipDispatchRule(dispatchRuleId);
+      console.log(`SIP dispatch rule deleted: ${dispatchRuleId}`);
+    } catch (error) {
+      console.error('Error deleting SIP dispatch rule:', error);
+    }
+  }
+
   async createSipOutboundCall(params: {
     trunkId: string;
     roomName: string;

apps/backend/src/services/twilioSipTrunkService.ts

@@ -56,7 +56,15 @@ export class TwilioSipTrunkService {
 
       const phoneNumberResource = phoneNumbers[0];
 
-      // Check if already assigned to a trunk
+      // Update phone number to route voice calls via SIP trunk
+      console.log(`📞 Configuring phone number to use SIP trunk for voice...`);
+      await client.incomingPhoneNumbers(phoneNumberResource.sid).update({
+        trunkSid: trunk.sid,
+        voiceUrl: '', // Clear voice URL to use trunk routing
+      });
+      console.log(`✅ Phone number configured to route calls via trunk`);
+
+      // Verify phone number is assigned to trunk
       const existingPhoneNumbers = await client.trunking.v1
         .trunks(trunk.sid)
         .phoneNumbers.list();
@@ -65,15 +73,11 @@ export class TwilioSipTrunkService {
         (pn: any) => pn.sid === phoneNumberResource.sid
       );
 
-      if (!alreadyAssigned) {
-        await client.trunking.v1
-          .trunks(trunk.sid)
-          .phoneNumbers.create({
-            phoneNumberSid: phoneNumberResource.sid,
-          });
+      if (alreadyAssigned) {
         console.log(`✅ Phone number assigned to trunk`);
       } else {
-        console.log(`✅ Phone number already assigned to trunk`);
+        // This should not happen if the update above succeeded
+        console.warn(`⚠️ Phone number not found in trunk after assignment`);
       }
 
       // Step 2: Create SIP Credentials for this trunk
@@ -108,7 +112,32 @@ export class TwilioSipTrunkService {
 
       console.log(`✅ Credential list associated with trunk`);
 
+      // Step 3: Configure Origination (inbound calls from Twilio to LiveKit)
+      console.log(`\n📞 Configuring Origination URL for inbound calls...`);
+
+      // Get LiveKit SIP endpoint from environment
+      const livekitSipEndpoint = process.env.LIVEKIT_SIP_ENDPOINT;
+      const originationUri = `sip:${livekitSipEndpoint}`;
+
+      try {
+        // Create Origination URL
+        await client.trunking.v1
+          .trunks(trunk.sid)
+          .originationUrls.create({
+            friendlyName: 'LiveKit Inbound',
+            sipUrl: originationUri,
+            priority: 10,
+            weight: 10,
+            enabled: true,
+          });
+        console.log(`✅ Origination URL configured: ${originationUri}`);
+      } catch (originationError: any) {
+        console.error(`⚠️ Failed to configure Origination:`, originationError.message);
+        // Continue anyway - trunk is created, user can configure manually
+      }
+
       console.log(`\n✅ Twilio Elastic SIP Trunk fully configured!`);
+      console.log(`   ⚡ Outbound calls: ${domainName}`);
 
       return {
         trunkSid: trunk.sid,

apps/frontend/src/api/client.ts

@@ -78,6 +78,11 @@ export const phoneNumbersApi = {
     return response.data;
   },
 
+  updateInbound: async (id: string, data: { agentId: string | null; fallbackNumber?: string }) => {
+    const response = await client.put(`/phone-numbers/${id}/inbound`, data);
+    return response.data;
+  },
+
   delete: async (id: string) => {
     await client.delete(`/phone-numbers/${id}`);
   }