Init commit

app/__init__.py

@@ -0,0 +1 @@
+"""Active-Call Application Package"""

app/backend_client.py

@@ -0,0 +1,211 @@
+"""Backend API client for assistant config and history persistence."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+from loguru import logger
+
+from app.config import settings
+
+
+async def fetch_assistant_config(assistant_id: str) -> Optional[Dict[str, Any]]:
+    """Fetch assistant config payload from backend API.
+
+    Expected response shape:
+    {
+      "assistant": {...},
+      "voice": {...} | null
+    }
+    """
+    if not settings.backend_url:
+        logger.warning("BACKEND_URL not set; skipping assistant config fetch")
+        return None
+
+    url = f"{settings.backend_url.rstrip('/')}/api/assistants/{assistant_id}/config"
+    timeout = aiohttp.ClientTimeout(total=settings.backend_timeout_sec)
+
+    try:
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.get(url) as resp:
+                if resp.status == 404:
+                    logger.warning(f"Assistant config not found: {assistant_id}")
+                    return None
+                resp.raise_for_status()
+                payload = await resp.json()
+                if not isinstance(payload, dict):
+                    logger.warning("Assistant config payload is not a dict; ignoring")
+                    return None
+                return payload
+    except Exception as exc:
+        logger.warning(f"Failed to fetch assistant config ({assistant_id}): {exc}")
+        return None
+
+
+def _backend_base_url() -> Optional[str]:
+    if not settings.backend_url:
+        return None
+    return settings.backend_url.rstrip("/")
+
+
+def _timeout() -> aiohttp.ClientTimeout:
+    return aiohttp.ClientTimeout(total=settings.backend_timeout_sec)
+
+
+async def create_history_call_record(
+    *,
+    user_id: int,
+    assistant_id: Optional[str],
+    source: str = "debug",
+) -> Optional[str]:
+    """Create a call record via backend history API and return call_id."""
+    base_url = _backend_base_url()
+    if not base_url:
+        return None
+
+    url = f"{base_url}/api/history"
+    payload: Dict[str, Any] = {
+        "user_id": user_id,
+        "assistant_id": assistant_id,
+        "source": source,
+        "status": "connected",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=_timeout()) as session:
+            async with session.post(url, json=payload) as resp:
+                resp.raise_for_status()
+                data = await resp.json()
+                call_id = str((data or {}).get("id") or "")
+                return call_id or None
+    except Exception as exc:
+        logger.warning(f"Failed to create history call record: {exc}")
+        return None
+
+
+async def add_history_transcript(
+    *,
+    call_id: str,
+    turn_index: int,
+    speaker: str,
+    content: str,
+    start_ms: int,
+    end_ms: int,
+    confidence: Optional[float] = None,
+    duration_ms: Optional[int] = None,
+) -> bool:
+    """Append a transcript segment to backend history."""
+    base_url = _backend_base_url()
+    if not base_url or not call_id:
+        return False
+
+    url = f"{base_url}/api/history/{call_id}/transcripts"
+    payload: Dict[str, Any] = {
+        "turn_index": turn_index,
+        "speaker": speaker,
+        "content": content,
+        "confidence": confidence,
+        "start_ms": start_ms,
+        "end_ms": end_ms,
+        "duration_ms": duration_ms,
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=_timeout()) as session:
+            async with session.post(url, json=payload) as resp:
+                resp.raise_for_status()
+                return True
+    except Exception as exc:
+        logger.warning(f"Failed to append history transcript (call_id={call_id}, turn={turn_index}): {exc}")
+        return False
+
+
+async def finalize_history_call_record(
+    *,
+    call_id: str,
+    status: str,
+    duration_seconds: int,
+) -> bool:
+    """Finalize a call record with status and duration."""
+    base_url = _backend_base_url()
+    if not base_url or not call_id:
+        return False
+
+    url = f"{base_url}/api/history/{call_id}"
+    payload: Dict[str, Any] = {
+        "status": status,
+        "duration_seconds": duration_seconds,
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=_timeout()) as session:
+            async with session.put(url, json=payload) as resp:
+                resp.raise_for_status()
+                return True
+    except Exception as exc:
+        logger.warning(f"Failed to finalize history call record ({call_id}): {exc}")
+        return False
+
+
+async def search_knowledge_context(
+    *,
+    kb_id: str,
+    query: str,
+    n_results: int = 5,
+) -> List[Dict[str, Any]]:
+    """Search backend knowledge base and return retrieval results."""
+    base_url = _backend_base_url()
+    if not base_url:
+        return []
+    if not kb_id or not query.strip():
+        return []
+    try:
+        safe_n_results = max(1, int(n_results))
+    except (TypeError, ValueError):
+        safe_n_results = 5
+
+    url = f"{base_url}/api/knowledge/search"
+    payload: Dict[str, Any] = {
+        "kb_id": kb_id,
+        "query": query,
+        "nResults": safe_n_results,
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=_timeout()) as session:
+            async with session.post(url, json=payload) as resp:
+                if resp.status == 404:
+                    logger.warning(f"Knowledge base not found for retrieval: {kb_id}")
+                    return []
+                resp.raise_for_status()
+                data = await resp.json()
+                if not isinstance(data, dict):
+                    return []
+                results = data.get("results", [])
+                if not isinstance(results, list):
+                    return []
+                return [r for r in results if isinstance(r, dict)]
+    except Exception as exc:
+        logger.warning(f"Knowledge search failed (kb_id={kb_id}): {exc}")
+        return []
+
+
+async def fetch_tool_resource(tool_id: str) -> Optional[Dict[str, Any]]:
+    """Fetch tool resource configuration from backend API."""
+    base_url = _backend_base_url()
+    if not base_url or not tool_id:
+        return None
+
+    url = f"{base_url}/api/tools/resources/{tool_id}"
+    try:
+        async with aiohttp.ClientSession(timeout=_timeout()) as session:
+            async with session.get(url) as resp:
+                if resp.status == 404:
+                    return None
+                resp.raise_for_status()
+                data = await resp.json()
+                return data if isinstance(data, dict) else None
+    except Exception as exc:
+        logger.warning(f"Failed to fetch tool resource ({tool_id}): {exc}")
+        return None

app/config.py

@@ -0,0 +1,154 @@
+"""Configuration management using Pydantic settings."""
+
+from typing import List, Optional
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+import json
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore"
+    )
+
+    # Server Configuration
+    host: str = Field(default="0.0.0.0", description="Server host address")
+    port: int = Field(default=8000, description="Server port")
+    external_ip: Optional[str] = Field(default=None, description="External IP for NAT traversal")
+
+    # Audio Configuration
+    sample_rate: int = Field(default=16000, description="Audio sample rate in Hz")
+    chunk_size_ms: int = Field(default=20, description="Audio chunk duration in milliseconds")
+    default_codec: str = Field(default="pcm", description="Default audio codec")
+    max_audio_buffer_seconds: int = Field(
+        default=30,
+        description="Maximum buffered user audio duration kept in memory for current turn"
+    )
+
+    # VAD Configuration
+    vad_type: str = Field(default="silero", description="VAD algorithm type")
+    vad_model_path: str = Field(default="data/vad/silero_vad.onnx", description="Path to VAD model")
+    vad_threshold: float = Field(default=0.5, description="VAD detection threshold")
+    vad_min_speech_duration_ms: int = Field(default=100, description="Minimum speech duration in milliseconds")
+    vad_eou_threshold_ms: int = Field(default=800, description="End of utterance (silence) threshold in milliseconds")
+
+    # OpenAI / LLM Configuration
+    openai_api_key: Optional[str] = Field(default=None, description="OpenAI API key")
+    openai_api_url: Optional[str] = Field(default=None, description="OpenAI API base URL (for Azure/compatible)")
+    llm_model: str = Field(default="gpt-4o-mini", description="LLM model name")
+    llm_temperature: float = Field(default=0.7, description="LLM temperature for response generation")
+    
+    # TTS Configuration
+    tts_provider: str = Field(
+        default="openai_compatible",
+        description="TTS provider (edge, openai_compatible; siliconflow alias supported)"
+    )
+    tts_voice: str = Field(default="anna", description="TTS voice name")
+    tts_speed: float = Field(default=1.0, description="TTS speech speed multiplier")
+    
+    # SiliconFlow Configuration
+    siliconflow_api_key: Optional[str] = Field(default=None, description="SiliconFlow API key")
+    siliconflow_tts_model: str = Field(default="FunAudioLLM/CosyVoice2-0.5B", description="SiliconFlow TTS model")
+    
+    # ASR Configuration
+    asr_provider: str = Field(
+        default="openai_compatible",
+        description="ASR provider (openai_compatible, buffered; siliconflow alias supported)"
+    )
+    siliconflow_asr_model: str = Field(default="FunAudioLLM/SenseVoiceSmall", description="SiliconFlow ASR model")
+    asr_interim_interval_ms: int = Field(default=500, description="Interval for interim ASR results in ms")
+    asr_min_audio_ms: int = Field(default=300, description="Minimum audio duration before first ASR result")
+    asr_start_min_speech_ms: int = Field(
+        default=160,
+        description="Minimum continuous speech duration before ASR capture starts"
+    )
+    asr_pre_speech_ms: int = Field(
+        default=240,
+        description="Audio context (ms) prepended before detected speech to avoid clipping first phoneme"
+    )
+    asr_final_tail_ms: int = Field(
+        default=120,
+        description="Silence tail (ms) appended before final ASR decode to protect utterance ending"
+    )
+    
+    # Duplex Pipeline Configuration
+    duplex_enabled: bool = Field(default=True, description="Enable duplex voice pipeline")
+    duplex_greeting: Optional[str] = Field(default=None, description="Optional greeting message")
+    duplex_system_prompt: Optional[str] = Field(
+        default="You are a helpful, friendly voice assistant. Keep your responses concise and conversational.",
+        description="System prompt for LLM"
+    )
+    
+    # Barge-in (interruption) Configuration
+    barge_in_min_duration_ms: int = Field(
+        default=200, 
+        description="Minimum speech duration (ms) required to trigger barge-in. Lower=more sensitive."
+    )
+    barge_in_silence_tolerance_ms: int = Field(
+        default=60,
+        description="How much silence (ms) is tolerated during potential barge-in before reset"
+    )
+
+    # Logging
+    log_level: str = Field(default="INFO", description="Logging level")
+    log_format: str = Field(default="json", description="Log format (json or text)")
+
+    # CORS
+    cors_origins: str = Field(
+        default='["http://localhost:3000", "http://localhost:8080"]',
+        description="CORS allowed origins"
+    )
+
+    # ICE Servers (WebRTC)
+    ice_servers: str = Field(
+        default='[{"urls": "stun:stun.l.google.com:19302"}]',
+        description="ICE servers configuration"
+    )
+
+    # WebSocket heartbeat and inactivity
+    inactivity_timeout_sec: int = Field(default=60, description="Close connection after no message from client (seconds)")
+    heartbeat_interval_sec: int = Field(default=50, description="Send heartBeat event to client every N seconds")
+    ws_protocol_version: str = Field(default="v1", description="Public WS protocol version")
+    ws_api_key: Optional[str] = Field(default=None, description="Optional API key required for WS hello auth")
+    ws_require_auth: bool = Field(default=False, description="Require auth in hello message even when ws_api_key is not set")
+
+    # Backend bridge configuration (for call/transcript persistence)
+    backend_url: Optional[str] = Field(default=None, description="Backend API base URL (e.g. http://localhost:8787)")
+    backend_timeout_sec: int = Field(default=10, description="Backend API request timeout in seconds")
+    history_default_user_id: int = Field(default=1, description="Fallback user_id for history records")
+
+    @property
+    def chunk_size_bytes(self) -> int:
+        """Calculate chunk size in bytes based on sample rate and duration."""
+        # 16-bit (2 bytes) per sample, mono channel
+        return int(self.sample_rate * 2 * (self.chunk_size_ms / 1000.0))
+
+    @property
+    def cors_origins_list(self) -> List[str]:
+        """Parse CORS origins from JSON string."""
+        try:
+            return json.loads(self.cors_origins)
+        except json.JSONDecodeError:
+            return ["http://localhost:3000", "http://localhost:8080"]
+
+    @property
+    def ice_servers_list(self) -> List[dict]:
+        """Parse ICE servers from JSON string."""
+        try:
+            return json.loads(self.ice_servers)
+        except json.JSONDecodeError:
+            return [{"urls": "stun:stun.l.google.com:19302"}]
+
+
+# Global settings instance
+settings = Settings()
+
+
+def get_settings() -> Settings:
+    """Get application settings instance."""
+    return settings

app/main.py

@@ -0,0 +1,396 @@
+"""FastAPI application with WebSocket and WebRTC endpoints."""
+
+import asyncio
+import json
+import time
+import uuid
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, FileResponse
+from loguru import logger
+
+# Try to import aiortc (optional for WebRTC functionality)
+try:
+    from aiortc import RTCPeerConnection, RTCSessionDescription
+    AIORTC_AVAILABLE = True
+except ImportError:
+    AIORTC_AVAILABLE = False
+    logger.warning("aiortc not available - WebRTC endpoint will be disabled")
+
+from app.config import settings
+from core.transports import SocketTransport, WebRtcTransport, BaseTransport
+from core.session import Session
+from processors.tracks import Resampled16kTrack
+from core.events import get_event_bus, reset_event_bus
+from models.ws_v1 import ev
+
+# Check interval for heartbeat/timeout (seconds)
+_HEARTBEAT_CHECK_INTERVAL_SEC = 5
+
+
+async def heartbeat_and_timeout_task(
+    transport: BaseTransport,
+    session: Session,
+    session_id: str,
+    last_received_at: List[float],
+    last_heartbeat_at: List[float],
+    inactivity_timeout_sec: int,
+    heartbeat_interval_sec: int,
+) -> None:
+    """
+    Background task: send heartBeat every ~heartbeat_interval_sec and close
+    connection if no message from client for inactivity_timeout_sec.
+    """
+    while True:
+        await asyncio.sleep(_HEARTBEAT_CHECK_INTERVAL_SEC)
+        if transport.is_closed:
+            break
+        now = time.monotonic()
+        if now - last_received_at[0] > inactivity_timeout_sec:
+            logger.info(f"Session {session_id}: {inactivity_timeout_sec}s no message, closing")
+            await session.cleanup()
+            break
+        if now - last_heartbeat_at[0] >= heartbeat_interval_sec:
+            try:
+                await transport.send_event({
+                    **ev("heartbeat"),
+                })
+                last_heartbeat_at[0] = now
+            except Exception as e:
+                logger.debug(f"Session {session_id}: heartbeat send failed: {e}")
+                break
+
+
+# Initialize FastAPI
+app = FastAPI(title="Python Active-Call", version="0.1.0")
+_WEB_CLIENT_PATH = Path(__file__).resolve().parent.parent / "examples" / "web_client.html"
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins_list,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Active sessions storage
+active_sessions: Dict[str, Session] = {}
+
+# Configure logging
+logger.remove()
+logger.add(
+    "./logs/active_call_{time}.log",
+    rotation="1 day",
+    retention="7 days",
+    level=settings.log_level,
+    format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}"
+)
+logger.add(
+    lambda msg: print(msg, end=""),
+    level=settings.log_level,
+    format="{time:HH:mm:ss} | {level: <8} | {message}"
+)
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {"status": "healthy", "sessions": len(active_sessions)}
+
+
+@app.get("/")
+async def web_client_root():
+    """Serve the web client."""
+    if not _WEB_CLIENT_PATH.exists():
+        raise HTTPException(status_code=404, detail="Web client not found")
+    return FileResponse(_WEB_CLIENT_PATH)
+
+
+@app.get("/client")
+async def web_client_alias():
+    """Alias for the web client."""
+    if not _WEB_CLIENT_PATH.exists():
+        raise HTTPException(status_code=404, detail="Web client not found")
+    return FileResponse(_WEB_CLIENT_PATH)
+
+
+
+
+@app.get("/iceservers")
+async def get_ice_servers():
+    """Get ICE servers configuration for WebRTC."""
+    return settings.ice_servers_list
+
+
+@app.get("/call/lists")
+async def list_calls():
+    """List all active calls."""
+    return {
+        "calls": [
+            {
+                "id": session_id,
+                "state": session.state,
+                "created_at": session.created_at
+            }
+            for session_id, session in active_sessions.items()
+        ]
+    }
+
+
+@app.post("/call/kill/{session_id}")
+async def kill_call(session_id: str):
+    """Kill a specific active call."""
+    if session_id not in active_sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = active_sessions[session_id]
+    await session.cleanup()
+    del active_sessions[session_id]
+
+    return True
+
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """
+    WebSocket endpoint for raw audio streaming.
+
+    Accepts mixed text/binary frames:
+    - Text frames: JSON commands
+    - Binary frames: PCM audio data (16kHz, 16-bit, mono)
+    """
+    await websocket.accept()
+    session_id = str(uuid.uuid4())
+
+    # Create transport and session
+    transport = SocketTransport(websocket)
+    session = Session(session_id, transport)
+    active_sessions[session_id] = session
+
+    logger.info(f"WebSocket connection established: {session_id}")
+
+    last_received_at: List[float] = [time.monotonic()]
+    last_heartbeat_at: List[float] = [0.0]
+    hb_task = asyncio.create_task(
+        heartbeat_and_timeout_task(
+            transport,
+            session,
+            session_id,
+            last_received_at,
+            last_heartbeat_at,
+            settings.inactivity_timeout_sec,
+            settings.heartbeat_interval_sec,
+        )
+    )
+
+    try:
+        # Receive loop
+        while True:
+            message = await websocket.receive()
+            message_type = message.get("type")
+
+            if message_type == "websocket.disconnect":
+                logger.info(f"WebSocket disconnected: {session_id}")
+                break
+
+            last_received_at[0] = time.monotonic()
+
+            # Handle binary audio data
+            if "bytes" in message:
+                await session.handle_audio(message["bytes"])
+
+            # Handle text commands
+            elif "text" in message:
+                await session.handle_text(message["text"])
+
+    except WebSocketDisconnect:
+        logger.info(f"WebSocket disconnected: {session_id}")
+
+    except Exception as e:
+        logger.error(f"WebSocket error: {e}", exc_info=True)
+
+    finally:
+        hb_task.cancel()
+        try:
+            await hb_task
+        except asyncio.CancelledError:
+            pass
+        # Cleanup session
+        if session_id in active_sessions:
+            await session.cleanup()
+            del active_sessions[session_id]
+
+        logger.info(f"Session {session_id} removed")
+
+
+@app.websocket("/webrtc")
+async def webrtc_endpoint(websocket: WebSocket):
+    """
+    WebRTC endpoint for WebRTC audio streaming.
+
+    Uses WebSocket for signaling (SDP exchange) and WebRTC for media transport.
+    """
+    # Check if aiortc is available
+    if not AIORTC_AVAILABLE:
+        await websocket.close(code=1011, reason="WebRTC not available - aiortc/av not installed")
+        logger.warning("WebRTC connection attempted but aiortc is not available")
+        return
+    await websocket.accept()
+    session_id = str(uuid.uuid4())
+
+    # Create WebRTC peer connection
+    pc = RTCPeerConnection()
+
+    # Create transport and session
+    transport = WebRtcTransport(websocket, pc)
+    session = Session(session_id, transport)
+    active_sessions[session_id] = session
+
+    logger.info(f"WebRTC connection established: {session_id}")
+
+    last_received_at: List[float] = [time.monotonic()]
+    last_heartbeat_at: List[float] = [0.0]
+    hb_task = asyncio.create_task(
+        heartbeat_and_timeout_task(
+            transport,
+            session,
+            session_id,
+            last_received_at,
+            last_heartbeat_at,
+            settings.inactivity_timeout_sec,
+            settings.heartbeat_interval_sec,
+        )
+    )
+
+    # Track handler for incoming audio
+    @pc.on("track")
+    def on_track(track):
+        logger.info(f"Track received: {track.kind}")
+
+        if track.kind == "audio":
+            # Wrap track with resampler
+            wrapped_track = Resampled16kTrack(track)
+
+            # Create task to pull audio from track
+            async def pull_audio():
+                try:
+                    while True:
+                        frame = await wrapped_track.recv()
+                        # Convert frame to bytes
+                        pcm_bytes = frame.to_ndarray().tobytes()
+                        # Feed to session
+                        await session.handle_audio(pcm_bytes)
+                except Exception as e:
+                    logger.error(f"Error pulling audio from track: {e}")
+
+            asyncio.create_task(pull_audio())
+
+    @pc.on("connectionstatechange")
+    async def on_connectionstatechange():
+        logger.info(f"Connection state: {pc.connectionState}")
+        if pc.connectionState == "failed" or pc.connectionState == "closed":
+            await session.cleanup()
+
+    try:
+        # Signaling loop
+        while True:
+            message = await websocket.receive()
+
+            if "text" not in message:
+                continue
+
+            last_received_at[0] = time.monotonic()
+            data = json.loads(message["text"])
+
+            # Handle SDP offer/answer
+            if "sdp" in data and "type" in data:
+                logger.info(f"Received SDP {data['type']}")
+
+                # Set remote description
+                offer = RTCSessionDescription(sdp=data["sdp"], type=data["type"])
+                await pc.setRemoteDescription(offer)
+
+                # Create and set local description
+                if data["type"] == "offer":
+                    answer = await pc.createAnswer()
+                    await pc.setLocalDescription(answer)
+
+                    # Send answer back
+                    await websocket.send_text(json.dumps({
+                        "event": "answer",
+                        "trackId": session_id,
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                        "sdp": pc.localDescription.sdp
+                    }))
+
+                    logger.info(f"Sent SDP answer")
+
+            else:
+                # Handle other commands
+                await session.handle_text(message["text"])
+
+    except WebSocketDisconnect:
+        logger.info(f"WebRTC WebSocket disconnected: {session_id}")
+
+    except Exception as e:
+        logger.error(f"WebRTC error: {e}", exc_info=True)
+
+    finally:
+        hb_task.cancel()
+        try:
+            await hb_task
+        except asyncio.CancelledError:
+            pass
+        # Cleanup
+        await pc.close()
+        if session_id in active_sessions:
+            await session.cleanup()
+            del active_sessions[session_id]
+
+        logger.info(f"WebRTC session {session_id} removed")
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Run on application startup."""
+    logger.info("Starting Python Active-Call server")
+    logger.info(f"Server: {settings.host}:{settings.port}")
+    logger.info(f"Sample rate: {settings.sample_rate} Hz")
+    logger.info(f"VAD model: {settings.vad_model_path}")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Run on application shutdown."""
+    logger.info("Shutting down Python Active-Call server")
+
+    # Cleanup all sessions
+    for session_id, session in active_sessions.items():
+        await session.cleanup()
+
+    # Close event bus
+    event_bus = get_event_bus()
+    await event_bus.close()
+    reset_event_bus()
+
+    logger.info("Server shutdown complete")
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    # Create logs directory
+    import os
+    os.makedirs("logs", exist_ok=True)
+
+    # Run server
+    uvicorn.run(
+        "app.main:app",
+        host=settings.host,
+        port=settings.port,
+        reload=True,
+        log_level=settings.log_level.lower()
+    )