use anyhow::Result;
use rsipstack::dialog::{authenticate::Credential, invitation::InviteOption};
use serde::{Deserialize, Serialize};
use serde_with::skip_serializing_none;
use std::collections::HashMap;
use crate::{
media::{
agc::AGCOption, ambiance::AmbianceOption, monitor::MonitorOption,
recorder::RecorderOption, track::media_pass::MediaPassOption, vad::VADOption,
},
synthesis::SynthesisOption,
transcription::TranscriptionOption,
};
pub mod app;
pub mod call;
pub mod callrecord;
pub mod config;
pub mod event;
pub mod handler;
pub mod locator;
pub mod main_builder;
pub mod media;
pub mod net_tool;
#[cfg(feature = "offline")]
pub mod offline;
pub mod playbook;
pub mod runtime;
pub mod sip_util;
pub mod sipflow;
pub mod synthesis;
pub mod transcription;
pub mod useragent;
#[derive(Deserialize, Serialize, Default, Clone)]
#[serde(default)]
pub struct SipOption {
pub username: Option<String>,
#[serde(skip_serializing)]
pub password: Option<String>,
pub realm: Option<String>,
pub contact: Option<String>,
pub headers: Option<HashMap<String, String>>,
pub hangup_headers: Option<HashMap<String, String>>,
pub extract_headers: Option<Vec<String>>,
pub enable_srtp: Option<bool>,
}
impl std::fmt::Debug for SipOption {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SipOption")
.field("username", &self.username)
.field("password", &self.password.as_ref().map(|_| "***"))
.field("realm", &self.realm)
.field("contact", &self.contact)
.field("headers", &self.headers)
.field("hangup_headers", &self.hangup_headers)
.field("extract_headers", &self.extract_headers)
.field("enable_srtp", &self.enable_srtp)
.finish()
}
}
#[skip_serializing_none]
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct CallOption {
pub denoise: Option<bool>,
pub agc: Option<AGCOption>,
pub offer: Option<String>,
pub callee: Option<String>,
pub caller: Option<String>,
pub recorder: Option<RecorderOption>,
pub vad: Option<VADOption>,
pub asr: Option<TranscriptionOption>,
pub tts: Option<SynthesisOption>,
pub media_pass: Option<MediaPassOption>,
pub handshake_timeout: Option<u64>,
pub enable_ipv6: Option<bool>,
pub inactivity_timeout: Option<u64>, pub rtp_timeout: Option<u64>,
pub jitter_buffer: Option<bool>,
pub sip: Option<SipOption>,
pub extra: Option<HashMap<String, String>>,
pub codec: Option<String>, pub ambiance: Option<AmbianceOption>,
pub eou: Option<EouOption>,
pub realtime: Option<RealtimeOption>,
pub subscribe: Option<bool>,
pub monitor: Option<MonitorOption>,
pub enable_ice_lite: Option<bool>,
pub ringback_detection: Option<RingbackDetectionOption>,
}
impl Default for CallOption {
fn default() -> Self {
Self {
denoise: None,
agc: None,
offer: None,
callee: None,
caller: None,
recorder: None,
asr: None,
vad: None,
tts: None,
media_pass: None,
handshake_timeout: None,
inactivity_timeout: Some(50), rtp_timeout: None,
jitter_buffer: None,
enable_ipv6: None,
sip: None,
extra: None,
codec: None,
ambiance: None,
eou: None,
realtime: None,
subscribe: None,
monitor: None,
enable_ice_lite: None,
ringback_detection: None,
}
}
}
impl CallOption {
pub fn check_default(&mut self) {
if let Some(tts) = &mut self.tts {
tts.check_default();
}
if let Some(asr) = &mut self.asr {
asr.check_default();
}
if let Some(realtime) = &mut self.realtime {
realtime.check_default();
}
}
pub fn build_invite_option(&self) -> Result<InviteOption> {
let mut invite_option = InviteOption::default();
if let Some(offer) = &self.offer {
invite_option.offer = Some(offer.clone().into());
}
if let Some(callee) = &self.callee {
invite_option.callee = callee.clone().try_into()?;
}
let caller_uri = if let Some(caller) = &self.caller {
crate::sip_util::ensure_sip_scheme(caller.clone())
} else if let Some(username) = self.sip.as_ref().and_then(|sip| sip.username.as_ref()) {
let domain = self
.sip
.as_ref()
.and_then(|sip| sip.realm.as_ref())
.map(|s| s.as_str())
.unwrap_or("127.0.0.1");
format!("sip:{}@{}", username, domain)
} else {
"sip:active-call@127.0.0.1".to_string()
};
invite_option.caller = caller_uri.try_into()?;
if let Some(sip) = &self.sip {
invite_option.credential = Some(Credential {
username: sip.username.clone().unwrap_or_default(),
auth_username: None,
password: sip.password.clone().unwrap_or_default(),
realm: sip.realm.clone(),
});
invite_option.headers = sip
.headers
.as_ref()
.map(crate::sip_util::sip_headers_from_map);
sip.contact.as_ref().map(|c| match c.clone().try_into() {
Ok(u) => {
invite_option.contact = u;
}
Err(_) => {}
});
}
Ok(invite_option)
}
}
#[skip_serializing_none]
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ReferOption {
pub denoise: Option<bool>,
pub agc: Option<AGCOption>,
pub timeout: Option<u32>,
pub moh: Option<String>,
pub vad: Option<VADOption>,
pub asr: Option<TranscriptionOption>,
pub auto_hangup: Option<bool>,
pub sip: Option<SipOption>,
pub call_id: Option<String>,
pub pause_parent_asr: Option<bool>,
pub forward_dtmf: Option<bool>,
pub extra_headers: Option<HashMap<String, String>>,
pub inactivity_timeout: Option<u64>,
}
#[skip_serializing_none]
#[derive(Clone, Debug, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct EouOption {
pub r#type: Option<String>,
pub endpoint: Option<String>,
#[serde(alias = "apiKey")]
pub secret_key: Option<String>,
pub secret_id: Option<String>,
pub timeout: Option<u32>,
pub extra: Option<HashMap<String, String>>,
}
#[skip_serializing_none]
#[derive(Clone, Debug, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct RingbackDetectionOption {
pub enabled: Option<bool>,
pub model_weights_path: Option<String>,
pub min_buffer_secs: Option<f32>,
pub detection_interval_secs: Option<f32>,
pub confidence_threshold: Option<f32>,
pub on_state_change_only: Option<bool>,
pub sliding_window_size: Option<usize>,
pub final_confidence_threshold: Option<f32>,
pub inference_threads: Option<usize>,
}
#[derive(Debug, Clone, Serialize, Hash, Eq, PartialEq)]
pub enum RealtimeType {
#[serde(rename = "openai")]
OpenAI,
#[serde(rename = "azure")]
Azure,
Other(String),
}
impl<'de> Deserialize<'de> for RealtimeType {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
match value.as_str() {
"openai" => Ok(RealtimeType::OpenAI),
"azure" => Ok(RealtimeType::Azure),
_ => Ok(RealtimeType::Other(value)),
}
}
}
#[skip_serializing_none]
#[derive(Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct RealtimeOption {
pub provider: Option<RealtimeType>,
pub model: Option<String>,
#[serde(alias = "apiKey")]
pub secret_key: Option<String>,
pub secret_id: Option<String>,
pub endpoint: Option<String>,
pub turn_detection: Option<serde_json::Value>,
pub tools: Option<Vec<serde_json::Value>>,
pub extra: Option<HashMap<String, String>>,
}
impl std::fmt::Debug for RealtimeOption {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RealtimeOption")
.field("provider", &self.provider)
.field("model", &self.model)
.field("secret_key", &self.secret_key.as_ref().map(|_| "***"))
.field("secret_id", &self.secret_id)
.field("endpoint", &self.endpoint)
.field("turn_detection", &self.turn_detection)
.field("tools", &self.tools)
.field("extra", &self.extra)
.finish()
}
}
impl RealtimeOption {
pub fn check_default(&mut self) {
if self.secret_key.is_none() {
self.secret_key = std::env::var("OPENAI_API_KEY").ok();
}
}
}
pub type Spawner = fn(
std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>,
) -> tokio::task::JoinHandle<()>;
static EXTERNAL_SPAWNER: std::sync::OnceLock<Spawner> = std::sync::OnceLock::new();
pub fn set_spawner(spawner: Spawner) -> Result<(), Spawner> {
EXTERNAL_SPAWNER.set(spawner)
}
pub fn spawn<F>(future: F) -> tokio::task::JoinHandle<()>
where
F: std::future::Future<Output = ()> + Send + 'static,
{
if let Some(spawner) = EXTERNAL_SPAWNER.get() {
spawner(Box::pin(future))
} else {
tokio::spawn(future)
}
}
#[cfg(test)]
mod rtp_timeout_tests {
use super::CallOption;
use crate::call::Command;
#[test]
fn rtp_timeout_is_optional_and_shared_by_invite_and_accept() {
assert_eq!(CallOption::default().rtp_timeout, None);
assert!(
serde_json::to_value(CallOption::default())
.unwrap()
.get("rtpTimeout")
.is_none()
);
for command in ["invite", "accept"] {
for (option, expected) in [
(serde_json::json!({}), None),
(serde_json::json!({"rtpTimeout": null}), None),
(serde_json::json!({"rtpTimeout": 0}), Some(0)),
(serde_json::json!({"rtpTimeout": 30}), Some(30)),
] {
let parsed: Command = serde_json::from_value(serde_json::json!({
"command": command, "option": option,
}))
.unwrap();
match parsed {
Command::Invite { option } | Command::Accept { option } => {
assert_eq!(option.rtp_timeout, expected);
}
_ => unreachable!(),
}
}
}
}
}
#[cfg(test)]
mod jitter_buffer_option_tests {
use crate::call::Command;
#[test]
fn jitter_buffer_is_set_per_call_by_invite_and_accept() {
for command in ["invite", "accept"] {
for (option, expected) in [
(serde_json::json!({}), None),
(serde_json::json!({"jitterBuffer": true}), Some(true)),
(serde_json::json!({"jitterBuffer": false}), Some(false)),
] {
let parsed: Command = serde_json::from_value(serde_json::json!({
"command": command, "option": option,
}))
.unwrap();
match parsed {
Command::Invite { option } | Command::Accept { option } => {
assert_eq!(option.jitter_buffer, expected);
}
_ => unreachable!(),
}
}
}
}
}