from livekit.api import LiveKitAPI, CreateSIPParticipantRequest

async def place_outbound_call(
  phone_number: str,
  trunk_id: str,
  room_name: str,
):
  api = LiveKitAPI()

  request = CreateSIPParticipantRequest(
      sip_trunk_id=trunk_id,
      sip_call_to=phone_number,
      room_name=room_name,
      participant_identity=f"caller-{phone_number}",
      participant_name=phone_number,
  )

  participant = await api.sip.create_sip_participant(request)
  return participant

import { LiveKitAPI, CreateSIPParticipantRequest } from "@livekit/server-sdk";

async function placeOutboundCall(
phoneNumber: string,
trunkId: string,
roomName: string,
) {
const api = new LiveKitAPI();

const request: CreateSIPParticipantRequest = {
  sipTrunkId: trunkId,
  sipCallTo: phoneNumber,
  roomName,
  participantIdentity: `caller-${phoneNumber}`,
  participantName: phoneNumber,
};

const participant = await api.sip.createSipParticipant(request);
return participant;
}

import asyncio
from datetime import datetime, time
from dataclasses import dataclass, field

@dataclass
class CallRecord:
  phone_number: str
  name: str
  campaign_id: str
  status: str = "pending"  # pending, calling, completed, failed, retry
  attempts: int = 0
  max_attempts: int = 3
  last_attempt: datetime | None = None
  outcome: str | None = None  # answered, voicemail, no_answer, busy

@dataclass
class Campaign:
  campaign_id: str
  name: str
  trunk_id: str
  call_list: list[CallRecord] = field(default_factory=list)
  calls_per_minute: int = 10
  start_time: time = time(9, 0)   # 9:00 AM
  end_time: time = time(20, 0)    # 8:00 PM
  active: bool = True

class CampaignManager:
  def __init__(self):
      self.campaigns: dict[str, Campaign] = {}
      self.active_calls: int = 0

  def is_within_calling_hours(self, campaign: Campaign) -> bool:
      now = datetime.now().time()
      return campaign.start_time <= now <= campaign.end_time

  def get_next_call(self, campaign: Campaign) -> CallRecord | None:
      for record in campaign.call_list:
          if record.status == "pending" or (
              record.status == "retry"
              and record.attempts < record.max_attempts
          ):
              return record
      return None

  async def run_campaign(self, campaign_id: str):
      campaign = self.campaigns[campaign_id]
      interval = 60.0 / campaign.calls_per_minute

      while campaign.active:
          if not self.is_within_calling_hours(campaign):
              await asyncio.sleep(60)
              continue

          record = self.get_next_call(campaign)
          if record is None:
              break  # All calls completed or exhausted retries

          record.status = "calling"
          record.attempts += 1
          record.last_attempt = datetime.now()

          try:
              await place_outbound_call(
                  record.phone_number,
                  campaign.trunk_id,
                  f"campaign-{campaign_id}-{record.phone_number}",
              )
              record.status = "completed"
          except Exception:
              record.status = "retry" if record.attempts < record.max_attempts else "failed"

          await asyncio.sleep(interval)

import asyncio
from collections import deque
from datetime import datetime

class OutboundRateLimiter:
  def __init__(self, max_concurrent: int = 20, max_per_minute: int = 10):
      self.max_concurrent = max_concurrent
      self.max_per_minute = max_per_minute
      self.active_calls = 0
      self.call_timestamps: deque[datetime] = deque()
      self._lock = asyncio.Lock()

  async def acquire(self) -> bool:
      async with self._lock:
          now = datetime.now()

          # Remove timestamps older than 60 seconds
          while self.call_timestamps and (now - self.call_timestamps[0]).seconds >= 60:
              self.call_timestamps.popleft()

          if self.active_calls >= self.max_concurrent:
              return False
          if len(self.call_timestamps) >= self.max_per_minute:
              return False

          self.active_calls += 1
          self.call_timestamps.append(now)
          return True

  async def release(self):
      async with self._lock:
          self.active_calls = max(0, self.active_calls - 1)