Update: Professional React landing page

.gitignore

@@ -18,6 +18,7 @@ __pycache__/
 
 # production
 /build
+/dist
 
 # misc
 .DS_Store

README.md

@@ -15,8 +15,8 @@ Real-time voice AI with transcription, vision, and intelligent conversation usin
 ## Features
 
 - **Dual Operation Modes**
-  - **WebRTC Mode** (`bot.py`) - Browser-based voice AI with real-time metrics dashboard
-  - **Robot Mode** (`tars_bot.py`) - Connect to Raspberry Pi TARS robot via WebRTC and gRPC
+  - **WebRTC Mode** (`src/bot.py`) - Browser-based voice AI with real-time metrics dashboard
+  - **Robot Mode** (`src/tars_bot.py`) - Connect to Raspberry Pi TARS robot via WebRTC and gRPC
 - **Real-time Transcription** - Speechmatics or Deepgram with smart turn detection
 - **Dual TTS Options** - Qwen3-TTS (local, free, voice cloning) or ElevenLabs (cloud)
 - **LLM Integration** - Any model via DeepInfra
@@ -32,9 +32,9 @@ Real-time voice AI with transcription, vision, and intelligent conversation usin
 
 ```
 tars-conversation-app/
-├── bot.py                      # WebRTC mode - Browser voice AI
-├── tars_bot.py                 # Robot mode - Raspberry Pi hardware
-├── pipecat_service.py          # FastAPI backend (WebRTC signaling)
+├── src/bot.py                      # WebRTC mode - Browser voice AI
+├── src/tars_bot.py                 # Robot mode - Raspberry Pi hardware
+├── src/pipecat_service.py          # FastAPI backend (WebRTC signaling)
 ├── config.py                   # Configuration management
 ├── config.ini                  # User configuration file
 ├── requirements.txt            # Python dependencies
@@ -62,14 +62,14 @@ tars-conversation-app/
 
 ## Operation Modes
 
-### WebRTC Mode (`bot.py`)
+### WebRTC Mode (`src/bot.py`)
 - **Use case**: Browser-based voice AI conversations
 - **Transport**: SmallWebRTC (browser ↔ Pipecat)
 - **Features**: Full pipeline with STT, LLM, TTS, Memory
 - **UI**: Gradio dashboard for metrics and transcription
 - **Best for**: Development, testing, remote conversations
 
-### Robot Mode (`tars_bot.py`)
+### Robot Mode (`src/tars_bot.py`)
 - **Use case**: Physical TARS robot on Raspberry Pi
 - **Transport**: aiortc (RPi ↔ Pipecat) + gRPC (commands)
 - **Features**: Same pipeline + robot control (eyes, gestures, movement)
@@ -159,7 +159,7 @@ type = hybrid  # SQLite-based hybrid search (vector + BM25)
 
 **Terminal 1: Python backend**
 ```bash
-python pipecat_service.py
+python src/pipecat_service.py
 ```
 
 **Terminal 2: Gradio UI (optional)**
@@ -197,7 +197,7 @@ Deployment detection:
 
 Run:
 ```bash
-python tars_bot.py
+python src/tars_bot.py
 ```
 
 ## Gradio Dashboard
@@ -268,7 +268,7 @@ See [docs/DEVELOPING_APPS.md](docs/DEVELOPING_APPS.md) for comprehensive guide o
 ### Adding Tools
 1. Create function in `src/tools/`
 2. Create schema with `create_*_schema()`
-3. Register in `bot.py` or `tars_bot.py`
+3. Register in `src/bot.py` or `src/tars_bot.py`
 4. LLM can now call your tool
 
 ### Modifying UI
@@ -287,7 +287,7 @@ Removes virtual environment and optionally data/config files.
 ## Troubleshooting
 
 ### No metrics in Gradio UI
-- Ensure bot is running (`bot.py` or `tars_bot.py`)
+- Ensure bot is running (`src/bot.py` or `src/tars_bot.py`)
 - Check WebRTC client is connected
 - Verify at least one conversation turn completed
 

assets/index-BGP_uT2P.css

@@ -0,0 +1 @@
+*,:before,:after{box-sizing:border-box;border-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,[type=button],[type=reset],[type=submit]{-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]{display:none}:root{--background: 0 0% 100%;--foreground: 0 0% 9%;--card: 0 0% 100%;--card-foreground: 0 0% 9%;--popover: 0 0% 100%;--popover-foreground: 0 0% 9%;--primary: 0 0% 9%;--primary-foreground: 0 0% 98%;--secondary: 0 0% 96.1%;--secondary-foreground: 0 0% 9%;--muted: 0 0% 96.1%;--muted-foreground: 0 0% 45.1%;--accent: 0 0% 96.1%;--accent-foreground: 0 0% 9%;--destructive: 0 84.2% 60.2%;--destructive-foreground: 0 0% 98%;--border: 0 0% 89.8%;--input: 0 0% 89.8%;--ring: 0 0% 9%;--radius: .5rem}*{border-color:hsl(var(--border))}body{background-color:hsl(var(--background));color:hsl(var(--foreground))}*,:before,:after{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: }::backdrop{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: }.container{width:100%;margin-right:auto;margin-left:auto;padding-right:2rem;padding-left:2rem}@media(min-width:1400px){.container{max-width:1400px}}.sticky{position:sticky}.top-0{top:0}.z-50{z-index:50}.mx-auto{margin-left:auto;margin-right:auto}.mb-12{margin-bottom:3rem}.mb-2{margin-bottom:.5rem}.mb-4{margin-bottom:1rem}.flex{display:flex}.inline-flex{display:inline-flex}.grid{display:grid}.h-10{height:2.5rem}.h-11{height:2.75rem}.h-12{height:3rem}.h-3{height:.75rem}.h-4{height:1rem}.h-6{height:1.5rem}.h-8{height:2rem}.h-9{height:2.25rem}.min-h-screen{min-height:100vh}.w-10{width:2.5rem}.w-12{width:3rem}.w-3{width:.75rem}.w-4{width:1rem}.w-6{width:1.5rem}.w-8{width:2rem}.w-full{width:100%}.max-w-3xl{max-width:48rem}.max-w-5xl{max-width:64rem}.max-w-6xl{max-width:72rem}.max-w-md{max-width:28rem}.flex-1{flex:1 1 0%}.flex-shrink-0{flex-shrink:0}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-center{align-items:center}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1{gap:.25rem}.gap-12{gap:3rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-4{gap:1rem}.gap-6{gap:1.5rem}.gap-8{gap:2rem}.space-y-1>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.25rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.25rem * var(--tw-space-y-reverse))}.space-y-1\.5>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.375rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.375rem * var(--tw-space-y-reverse))}.space-y-4>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1rem * var(--tw-space-y-reverse))}.space-y-6>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.5rem * var(--tw-space-y-reverse))}.whitespace-nowrap{white-space:nowrap}.rounded{border-radius:.25rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:var(--radius)}.rounded-md{border-radius:calc(var(--radius) - 2px)}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-t{border-top-width:1px}.border-input{border-color:hsl(var(--input))}.border-transparent{border-color:transparent}.bg-background{background-color:hsl(var(--background))}.bg-black{--tw-bg-opacity: 1;background-color:rgb(0 0 0 / var(--tw-bg-opacity))}.bg-card{background-color:hsl(var(--card))}.bg-destructive{background-color:hsl(var(--destructive))}.bg-gray-50{--tw-bg-opacity: 1;background-color:rgb(249 250 251 / var(--tw-bg-opacity))}.bg-primary{background-color:0 0% 9%}.bg-secondary{background-color:hsl(var(--secondary))}.bg-white{--tw-bg-opacity: 1;background-color:rgb(255 255 255 / var(--tw-bg-opacity))}.p-4{padding:1rem}.p-6{padding:1.5rem}.px-2{padding-left:.5rem;padding-right:.5rem}.px-2\.5{padding-left:.625rem;padding-right:.625rem}.px-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.px-8{padding-left:2rem;padding-right:2rem}.py-0{padding-top:0;padding-bottom:0}.py-0\.5{padding-top:.125rem;padding-bottom:.125rem}.py-1{padding-top:.25rem;padding-bottom:.25rem}.py-16{padding-top:4rem;padding-bottom:4rem}.py-2{padding-top:.5rem;padding-bottom:.5rem}.py-4{padding-top:1rem;padding-bottom:1rem}.py-8{padding-top:2rem;padding-bottom:2rem}.pt-0{padding-top:0}.text-center{text-align:center}.text-2xl{font-size:1.5rem;line-height:2rem}.text-3xl{font-size:1.875rem;line-height:2.25rem}.text-5xl{font-size:3rem;line-height:1}.text-lg{font-size:1.125rem;line-height:1.75rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xl{font-size:1.25rem;line-height:1.75rem}.text-xs{font-size:.75rem;line-height:1rem}.font-bold{font-weight:700}.font-medium{font-weight:500}.font-semibold{font-weight:600}.leading-none{line-height:1}.tracking-tight{letter-spacing:-.025em}.text-black{--tw-text-opacity: 1;color:rgb(0 0 0 / var(--tw-text-opacity))}.text-card-foreground{color:hsl(var(--card-foreground))}.text-destructive-foreground{color:hsl(var(--destructive-foreground))}.text-foreground{color:hsl(var(--foreground))}.text-muted-foreground{color:hsl(var(--muted-foreground))}.text-primary{color:0 0% 9%}.text-primary-foreground{color:0 0% 98%}.text-secondary-foreground{color:hsl(var(--secondary-foreground))}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity))}.underline-offset-4{text-underline-offset:4px}.shadow{--tw-shadow: 0 1px 3px 0 rgb(0 0 0 / .1), 0 1px 2px -1px rgb(0 0 0 / .1);--tw-shadow-colored: 0 1px 3px 0 var(--tw-shadow-color), 0 1px 2px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-lg{--tw-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--tw-shadow-colored: 0 10px 15px -3px var(--tw-shadow-color), 0 4px 6px -4px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-sm{--tw-shadow: 0 1px 2px 0 rgb(0 0 0 / .05);--tw-shadow-colored: 0 1px 2px 0 var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.outline{outline-style:solid}.ring-offset-background{--tw-ring-offset-color: hsl(var(--background))}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-shadow{transition-property:box-shadow;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.hover\:bg-accent:hover{background-color:hsl(var(--accent))}.hover\:bg-destructive\/80:hover{background-color:hsl(var(--destructive) / .8)}.hover\:bg-destructive\/90:hover{background-color:hsl(var(--destructive) / .9)}.hover\:bg-secondary\/80:hover{background-color:hsl(var(--secondary) / .8)}.hover\:text-accent-foreground:hover{color:hsl(var(--accent-foreground))}.hover\:underline:hover{text-decoration-line:underline}.hover\:shadow-lg:hover{--tw-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--tw-shadow-colored: 0 10px 15px -3px var(--tw-shadow-color), 0 4px 6px -4px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.focus\:ring-2:focus{--tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);--tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow, 0 0 #0000)}.focus\:ring-ring:focus{--tw-ring-color: hsl(var(--ring))}.focus\:ring-offset-2:focus{--tw-ring-offset-width: 2px}.focus-visible\:outline-none:focus-visible{outline:2px solid transparent;outline-offset:2px}.focus-visible\:ring-2:focus-visible{--tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);--tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow, 0 0 #0000)}.focus-visible\:ring-ring:focus-visible{--tw-ring-color: hsl(var(--ring))}.focus-visible\:ring-offset-2:focus-visible{--tw-ring-offset-width: 2px}.disabled\:pointer-events-none:disabled{pointer-events:none}.disabled\:opacity-50:disabled{opacity:.5}@media(min-width:768px){.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}}@media(min-width:1024px){.lg\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}}.\[\&_svg\]\:pointer-events-none svg{pointer-events:none}.\[\&_svg\]\:size-4 svg{width:1rem;height:1rem}.\[\&_svg\]\:shrink-0 svg{flex-shrink:0}

index.html

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="description" content="Real-time conversational AI with transcription, vision, and intelligent conversation for TARS robot" />
     <title>TARS Conversation App - Real-time AI Voice Assistant</title>
-    <script type="module" crossorigin src="/assets/index-Dyqch0TE.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C9-qqRmx.css">
+    <script type="module" crossorigin src="/assets/index-BdlkdtJU.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BGP_uT2P.css">
   </head>
   <body>
     <div id="root"></div>

scripts/install.sh

@@ -89,11 +89,11 @@ if [ "$CONFIG_CREATED" = true ] || [ "$ENV_CREATED" = true ]; then
     [ "$ENV_CREATED" = true ] && echo "   - Add API keys to: $APP_DIR/.env.local"
     [ "$CONFIG_CREATED" = true ] && echo "   - Configure settings: $APP_DIR/config.ini"
     echo "2. Activate environment: source $APP_DIR/venv/bin/activate"
-    echo "3. Run the app: python $APP_DIR/tars_bot.py"
+    echo "3. Run the app: python $APP_DIR/src/tars_bot.py"
 else
     echo "1. Activate environment: source $APP_DIR/venv/bin/activate"
-    echo "2. Run the app: python $APP_DIR/tars_bot.py"
+    echo "2. Run the app: python $APP_DIR/src/tars_bot.py"
 fi
 echo
-echo "For browser mode: python $APP_DIR/bot.py"
+echo "For browser mode: python $APP_DIR/src/bot.py"
 echo "For dashboard: python $APP_DIR/ui/app.py"

scripts/start_robot_mode.sh

@@ -58,8 +58,8 @@ if [ -d ".venv" ]; then
 fi
 
 # Check if tars_bot.py exists
-if [ ! -f "tars_bot.py" ]; then
-    echo "❌ Error: tars_bot.py not found"
+if [ ! -f "src/tars_bot.py" ]; then
+    echo "❌ Error: src/tars_bot.py not found"
     exit 1
 fi
 
@@ -84,5 +84,5 @@ else
     echo "⚠️  Note: Audio bridge integration is in progress"
     echo "   See IMPLEMENTATION_SUMMARY.md for current status"
     echo ""
-    python tars_bot.py
+    python src/tars_bot.py
 fi

scripts/uninstall.sh

@@ -10,9 +10,9 @@ echo
 
 # Stop running processes
 echo "Stopping running processes..."
-pkill -f "python.*tars_bot.py" || true
-pkill -f "python.*bot.py" || true
-pkill -f "python.*pipecat_service.py" || true
+pkill -f "python.*src/tars_bot.py" || true
+pkill -f "python.*src/bot.py" || true
+pkill -f "python.*src/pipecat_service.py" || true
 pkill -f "python.*ui/app.py" || true
 sleep 1
 echo "Processes stopped"

src/bot.py

@@ -0,0 +1,606 @@
+"""Bot pipeline setup and execution."""
+
+import sys
+from pathlib import Path
+
+# Add src directory to Python path for imports
+src_dir = Path(__file__).parent
+sys.path.insert(0, str(src_dir))
+
+import asyncio
+import json
+import os
+import logging
+import uuid
+import httpx
+
+from pipecat.adapters.schemas.tools_schema import ToolsSchema
+from pipecat.frames.frames import (
+    LLMRunFrame,
+    TranscriptionFrame,
+    InterimTranscriptionFrame,
+    Frame,
+    TranscriptionMessage,
+    TranslationFrame,
+    UserImageRawFrame,
+    UserAudioRawFrame,
+    UserImageRequestFrame,
+)
+from pipecat.processors.frame_processor import FrameProcessor, FrameDirection
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineTask, PipelineParams
+from pipecat.processors.aggregators.llm_context import LLMContext
+from pipecat.processors.aggregators.llm_response_universal import (
+    LLMContextAggregatorPair,
+    LLMUserAggregatorParams
+)
+from pipecat.observers.turn_tracking_observer import TurnTrackingObserver
+from pipecat.observers.loggers.user_bot_latency_log_observer import UserBotLatencyLogObserver
+from pipecat.services.moondream.vision import MoondreamService
+from pipecat.services.openai.llm import OpenAILLMService
+from pipecat.services.llm_service import FunctionCallParams
+from services.memory_hybrid import HybridMemoryService
+from pipecat.transcriptions.language import Language
+from pipecat.transports.base_transport import TransportParams
+from pipecat.transports.smallwebrtc.transport import SmallWebRTCTransport
+
+from loguru import logger
+
+from config import (
+    SPEECHMATICS_API_KEY,
+    DEEPGRAM_API_KEY,
+    ELEVENLABS_API_KEY,
+    ELEVENLABS_VOICE_ID,
+    DEEPINFRA_API_KEY,
+    DEEPINFRA_BASE_URL,
+    MEM0_API_KEY,
+    get_fresh_config,
+)
+from services.factories import create_stt_service, create_tts_service
+from processors import (
+    SilenceFilter,
+    InputAudioFilter,
+    InterventionGating,
+    VisualObserver,
+    EmotionalStateMonitor,
+)
+from observers import (
+    MetricsObserver,
+    TranscriptionObserver,
+    AssistantResponseObserver,
+    TTSStateObserver,
+    VisionObserver,
+    DebugObserver,
+    DisplayEventsObserver,
+)
+from character.prompts import (
+    load_persona_ini,
+    load_tars_json,
+    build_tars_system_prompt,
+    get_introduction_instruction,
+)
+from tools import (
+    fetch_user_image,
+    adjust_persona_parameter,
+    execute_movement,
+    capture_camera_view,
+    create_fetch_image_schema,
+    create_adjust_persona_schema,
+    create_identity_schema,
+    create_movement_schema,
+    create_camera_capture_schema,
+    get_persona_storage,
+    get_crossword_hint,
+    create_crossword_hint_schema,
+)
+from shared_state import metrics_store
+
+
+# ============================================================================
+# CUSTOM FRAME PROCESSORS
+# ============================================================================
+
+class IdentityUnifier(FrameProcessor):
+    """
+    Applies 'guest_ID' ONLY to specific user input frames.
+    Leaves other frames untouched.
+    """
+    # Define the frame types that should have user_id set
+    TARGET_FRAME_TYPES = (
+        TranscriptionFrame,
+        TranscriptionMessage,
+        TranslationFrame,
+        InterimTranscriptionFrame,
+        UserImageRawFrame,
+        UserAudioRawFrame,
+        UserImageRequestFrame,
+    )
+
+    def __init__(self, target_user_id):
+        super().__init__()
+        self.target_user_id = target_user_id
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        # 1. Handle internal state
+        await super().process_frame(frame, direction)
+
+        # 2. Only modify specific frame types
+        if isinstance(frame, self.TARGET_FRAME_TYPES):
+            try:
+                frame.user_id = self.target_user_id
+            except Exception:
+                pass
+
+        # 3. Push downstream
+        await self.push_frame(frame, direction)
+
+
+# ============================================================================
+# HELPER FUNCTIONS
+# ============================================================================
+
+async def _cleanup_services(service_refs: dict):
+    if service_refs.get("stt"):
+        try:
+            await service_refs["stt"].close()
+            logger.info("✓ STT service cleaned up")
+        except Exception:
+            pass
+    if service_refs.get("tts"):
+        try:
+            await service_refs["tts"].close()
+            logger.info("✓ TTS service cleaned up")
+        except Exception:
+            pass
+
+
+# ============================================================================
+# MAIN BOT PIPELINE
+# ============================================================================
+
+async def run_bot(webrtc_connection):
+    """Initialize and run the TARS bot pipeline."""
+    logger.info("Starting bot pipeline for WebRTC connection...")
+
+    # Load fresh configuration for this connection (allows runtime config updates)
+    runtime_config = get_fresh_config()
+    DEEPINFRA_MODEL = runtime_config['DEEPINFRA_MODEL']
+    DEEPINFRA_GATING_MODEL = runtime_config['DEEPINFRA_GATING_MODEL']
+    STT_PROVIDER = runtime_config['STT_PROVIDER']
+    TTS_PROVIDER = runtime_config['TTS_PROVIDER']
+    QWEN3_TTS_MODEL = runtime_config['QWEN3_TTS_MODEL']
+    QWEN3_TTS_DEVICE = runtime_config['QWEN3_TTS_DEVICE']
+    QWEN3_TTS_REF_AUDIO = runtime_config['QWEN3_TTS_REF_AUDIO']
+    EMOTIONAL_MONITORING_ENABLED = runtime_config['EMOTIONAL_MONITORING_ENABLED']
+    EMOTIONAL_SAMPLING_INTERVAL = runtime_config['EMOTIONAL_SAMPLING_INTERVAL']
+    EMOTIONAL_INTERVENTION_THRESHOLD = runtime_config['EMOTIONAL_INTERVENTION_THRESHOLD']
+    TARS_DISPLAY_URL = runtime_config['TARS_DISPLAY_URL']
+    TARS_DISPLAY_ENABLED = runtime_config['TARS_DISPLAY_ENABLED']
+
+    logger.info(f"📋 Runtime config loaded - STT: {STT_PROVIDER}, LLM: {DEEPINFRA_MODEL}, TTS: {TTS_PROVIDER}, Emotional: {EMOTIONAL_MONITORING_ENABLED}")
+
+    # Session initialization
+    session_id = str(uuid.uuid4())[:8]
+    client_id = f"guest_{session_id}"
+    client_state = {"client_id": client_id}
+    logger.info(f"Session started: {client_id}")
+
+    service_refs = {"stt": None, "tts": None}
+
+    try:
+        # ====================================================================
+        # TRANSPORT INITIALIZATION
+        # ====================================================================
+        # Note: STT providers handle their own turn detection:
+        # - Speechmatics: SMART_TURN mode
+        # - Deepgram: endpointing parameter (300ms silence detection)
+        # - Deepgram Flux: built-in turn detection with ExternalUserTurnStrategies (deprecated)
+
+        logger.info(f"Initializing transport with {STT_PROVIDER} turn detection...")
+
+        transport_params = TransportParams(
+            audio_in_enabled=True,
+            audio_out_enabled=True,
+            video_in_enabled=False,
+            video_out_enabled=False,
+            video_out_is_live=False,
+        )
+
+        pipecat_transport = SmallWebRTCTransport(
+            webrtc_connection=webrtc_connection,
+            params=transport_params,
+        )
+
+        logger.info("✓ Transport initialized")
+
+        # ====================================================================
+        # SPEECH-TO-TEXT SERVICE
+        # ====================================================================
+
+        logger.info(f"Initializing {STT_PROVIDER} STT...")
+        stt = None
+        try:
+            stt = create_stt_service(
+                provider=STT_PROVIDER,
+                speechmatics_api_key=SPEECHMATICS_API_KEY,
+                deepgram_api_key=DEEPGRAM_API_KEY,
+                language=Language.EN,
+                enable_diarization=False,
+            )
+            service_refs["stt"] = stt
+
+            # Log additional info for Deepgram
+            if STT_PROVIDER == "deepgram":
+                logger.info("✓ Deepgram: 300ms endpointing for turn detection")
+                logger.info("✓ Deepgram: VAD events enabled for speech detection")
+
+        except Exception as e:
+            logger.error(f"Failed to initialize {STT_PROVIDER} STT: {e}", exc_info=True)
+            return
+
+        # ====================================================================
+        # TEXT-TO-SPEECH SERVICE
+        # ====================================================================
+
+        try:
+            tts = create_tts_service(
+                provider=TTS_PROVIDER,
+                elevenlabs_api_key=ELEVENLABS_API_KEY,
+                elevenlabs_voice_id=ELEVENLABS_VOICE_ID,
+                qwen_model=QWEN3_TTS_MODEL,
+                qwen_device=QWEN3_TTS_DEVICE,
+                qwen_ref_audio=QWEN3_TTS_REF_AUDIO,
+            )
+            service_refs["tts"] = tts
+        except Exception as e:
+            logger.error(f"Failed to initialize TTS service: {e}", exc_info=True)
+            return
+
+        # ====================================================================
+        # LLM SERVICE & TOOLS
+        # ====================================================================
+
+        logger.info("Initializing LLM via DeepInfra...")
+        llm = None
+        try:
+            llm = OpenAILLMService(
+                api_key=DEEPINFRA_API_KEY,
+                base_url=DEEPINFRA_BASE_URL,
+                model=DEEPINFRA_MODEL 
+            )
+            
+            character_dir = os.path.join(os.path.dirname(__file__), "character")
+            persona_params = load_persona_ini(os.path.join(character_dir, "persona.ini"))
+            tars_data = load_tars_json(os.path.join(character_dir, "TARS.json"))
+            system_prompt = build_tars_system_prompt(persona_params, tars_data)
+
+            # Create tool schemas (these return FunctionSchema objects)
+            fetch_image_tool = create_fetch_image_schema()
+            persona_tool = create_adjust_persona_schema()
+            identity_tool = create_identity_schema()
+            crossword_hint_tool = create_crossword_hint_schema()
+            movement_tool = create_movement_schema()
+            camera_capture_tool = create_camera_capture_schema()
+
+            # Pass FunctionSchema objects directly to standard_tools
+            tools = ToolsSchema(
+                standard_tools=[
+                    fetch_image_tool,
+                    persona_tool,
+                    identity_tool,
+                    crossword_hint_tool,
+                    movement_tool,
+                    camera_capture_tool,
+                ]
+            )
+            messages = [system_prompt]
+            context = LLMContext(messages, tools)
+
+            llm.register_function("fetch_user_image", fetch_user_image)
+            llm.register_function("adjust_persona_parameter", adjust_persona_parameter)
+            llm.register_function("get_crossword_hint", get_crossword_hint)
+            llm.register_function("execute_movement", execute_movement)
+            llm.register_function("capture_camera_view", capture_camera_view)
+
+            pipeline_unifier = IdentityUnifier(client_id)
+            async def wrapped_set_identity(params: FunctionCallParams):
+                name = params.arguments["name"]
+                logger.info(f"👤 Identity discovered: {name}")
+
+                old_id = client_state["client_id"]
+                new_id = f"user_{name.lower().replace(' ', '_')}"
+
+                if old_id != new_id:
+                    logger.info(f"🔄 Switching User ID: {old_id} -> {new_id}")
+                    client_state["client_id"] = new_id
+
+                    # Update the pipeline unifier to use new identity
+                    pipeline_unifier.target_user_id = new_id
+                    logger.info(f"✓ Updated pipeline unifier with new ID: {new_id}")
+
+                    # Update memory service with new user_id
+                    if memory_service:
+                        memory_service.user_id = new_id
+                        logger.info(f"✓ Updated memory service user_id to: {new_id}")
+
+                    # Notify frontend of identity change
+                    try:
+                        if webrtc_connection and webrtc_connection.is_connected():
+                            webrtc_connection.send_app_message({
+                                "type": "identity_update",
+                                "old_id": old_id,
+                                "new_id": new_id,
+                                "name": name
+                            })
+                            logger.info(f"📤 Sent identity update to frontend: {new_id}")
+                    except Exception as e:
+                        logger.warning(f"Failed to send identity update to frontend: {e}")
+
+                await params.result_callback(f"Identity updated to {name}.")
+
+            llm.register_function("set_user_identity", wrapped_set_identity)
+            logger.info(f"✓ LLM initialized with model: {DEEPINFRA_MODEL}")
+
+        except Exception as e:
+            logger.error(f"Failed to initialize LLM: {e}", exc_info=True)
+            return
+
+        # ====================================================================
+        # VISION & GATING SERVICES
+        # ====================================================================
+
+        logger.info("Initializing Moondream vision service...")
+        moondream = None
+        try:
+            moondream = MoondreamService(model="vikhyatk/moondream2", revision="2025-01-09")
+            logger.info("✓ Moondream vision service initialized")
+        except Exception as e:
+            logger.error(f"Failed to initialize Moondream: {e}")
+            return
+
+        # ====================================================================
+        # TARS DISPLAY - Note: Display control via gRPC in robot mode only
+        # ====================================================================
+
+        logger.info("TARS Display features available in robot mode (tars_bot.py)")
+        tars_client = None
+
+        logger.info("Initializing Visual Observer...")
+        visual_observer = VisualObserver(
+            vision_client=moondream,
+            enable_face_detection=True,
+            tars_client=tars_client
+        )
+        logger.info("✓ Visual Observer initialized")
+
+        logger.info("Initializing Emotional State Monitor...")
+        emotional_monitor = EmotionalStateMonitor(
+            vision_client=moondream,
+            model="vikhyatk/moondream2",
+            sampling_interval=EMOTIONAL_SAMPLING_INTERVAL,
+            intervention_threshold=EMOTIONAL_INTERVENTION_THRESHOLD,
+            enabled=EMOTIONAL_MONITORING_ENABLED,
+            auto_intervene=False,  # Let gating layer handle intervention decisions
+        )
+        logger.info(f"✓ Emotional State Monitor initialized (enabled: {EMOTIONAL_MONITORING_ENABLED})")
+        logger.info(f"   Mode: Integrated with gating layer for smarter decisions")
+
+        logger.info("Initializing Gating Layer...")
+        gating_layer = InterventionGating(
+            api_key=DEEPINFRA_API_KEY,
+            base_url=DEEPINFRA_BASE_URL,
+            model=DEEPINFRA_GATING_MODEL,
+            visual_observer=visual_observer,
+            emotional_monitor=emotional_monitor
+        )
+        logger.info(f"✓ Gating Layer initialized with emotional state integration")
+
+        # ====================================================================
+        # MEMORY SERVICE
+        # ====================================================================
+
+        # Memory service: Hybrid search combining vector similarity (70%) and BM25 keyword matching (30%)
+        # Optimized for voice AI with <50ms latency target
+        logger.info("Initializing hybrid memory service...")
+        memory_service = None
+        try:
+            memory_service = HybridMemoryService(
+                user_id=client_id,
+                db_path="./memory_data/memory.sqlite",
+                search_limit=3,
+                search_timeout_ms=100,  # Hybrid search needs ~60-80ms, allow buffer
+                vector_weight=0.7,      # 70% semantic similarity
+                bm25_weight=0.3,        # 30% keyword matching
+                system_prompt_prefix="From our conversations:\n",
+            )
+            logger.info(f"✓ Hybrid memory service initialized for {client_id}")
+        except Exception as e:
+            logger.error(f"Failed to initialize hybrid memory service: {e}")
+            logger.info("  Continuing without memory service...")
+            memory_service = None  # Continue without memory if it fails
+
+        # ====================================================================
+        # CONTEXT AGGREGATOR & PERSONA STORAGE
+        # ====================================================================
+
+        # Configure user turn aggregation
+        # STT services (Speechmatics, Deepgram) handle turn detection internally
+        user_params = LLMUserAggregatorParams(
+            user_turn_stop_timeout=1.5
+        )
+
+        context_aggregator = LLMContextAggregatorPair(
+            context,
+            user_params=user_params
+        )
+
+        
+        persona_storage = get_persona_storage()
+        persona_storage["persona_params"] = persona_params
+        persona_storage["tars_data"] = tars_data
+        persona_storage["context_aggregator"] = context_aggregator
+
+        # ====================================================================
+        # LOGGING PROCESSORS
+        # ====================================================================
+
+        transcription_observer = TranscriptionObserver(
+            webrtc_connection=webrtc_connection,
+            client_state=client_state
+        )
+        assistant_observer = AssistantResponseObserver(webrtc_connection=webrtc_connection)
+        tts_state_observer = TTSStateObserver(webrtc_connection=webrtc_connection)
+        vision_observer = VisionObserver(webrtc_connection=webrtc_connection)
+        display_events_observer = DisplayEventsObserver(tars_client=tars_client)
+
+        # Create MetricsObserver (non-intrusive monitoring outside pipeline)
+        metrics_observer = MetricsObserver(
+            webrtc_connection=webrtc_connection,
+            stt_service=stt
+        )
+
+        # Turn tracking observer (for debugging turn detection)
+        turn_observer = TurnTrackingObserver()
+
+        @turn_observer.event_handler("on_turn_started")
+        async def on_turn_started(*args, **kwargs):
+            turn_number = args[1] if len(args) > 1 else kwargs.get('turn_number', 0)
+            logger.info(f"🗣️  [TurnObserver] Turn STARTED: {turn_number}")
+            # Notify metrics observer of new turn
+            metrics_observer.start_turn(turn_number)
+
+        @turn_observer.event_handler("on_turn_ended")
+        async def on_turn_ended(*args, **kwargs):
+            turn_number = args[1] if len(args) > 1 else kwargs.get('turn_number', 0)
+            logger.info(f"🗣️  [TurnObserver] Turn ENDED: {turn_number}")
+
+        # ====================================================================
+        # PIPELINE ASSEMBLY
+        # ====================================================================
+
+        logger.info("Creating audio/video pipeline...")
+
+        pipeline = Pipeline([
+            pipecat_transport.input(),
+            # emotional_monitor,  # Real-time emotional state monitoring
+            stt,
+            pipeline_unifier,
+            context_aggregator.user(),
+            memory_service,  # Hybrid memory (70% vector + 30% BM25) for automatic recall/storage
+            # gating_layer,  # AI decision system (with emotional state integration)
+            llm,
+            SilenceFilter(),
+            tts,
+            pipecat_transport.output(),
+            context_aggregator.assistant(),
+        ])
+
+        # ====================================================================
+        # EVENT HANDLERS
+        # ====================================================================
+
+        task_ref = {"task": None}
+
+        @pipecat_transport.event_handler("on_client_connected")
+        async def on_client_connected(transport, client):
+            logger.info("Pipecat Client connected")
+            try:
+                if webrtc_connection.is_connected():
+                    webrtc_connection.send_app_message({"type": "system", "message": "Connection established"})
+
+                    # Send service configuration info with provider and model details
+                    llm_display = DEEPINFRA_MODEL.split('/')[-1] if '/' in DEEPINFRA_MODEL else DEEPINFRA_MODEL
+
+                    if TTS_PROVIDER == "elevenlabs":
+                        tts_display = "ElevenLabs: eleven_flash_v2_5"
+                    else:
+                        tts_model = QWEN3_TTS_MODEL.split('/')[-1] if '/' in QWEN3_TTS_MODEL else QWEN3_TTS_MODEL
+                        tts_display = f"Qwen3-TTS: {tts_model}"
+
+                    # Format STT provider name for display
+                    stt_display = {
+                        "speechmatics": "Speechmatics",
+                        "deepgram": "Deepgram Nova-2"
+                    }.get(STT_PROVIDER, STT_PROVIDER.capitalize())
+
+                    service_info = {
+                        "stt": stt_display,
+                        "memory": "Hybrid Search (SQLite)",
+                        "llm": f"DeepInfra: {llm_display}",
+                        "tts": tts_display
+                    }
+
+                    # Store in shared state for Gradio UI
+                    metrics_store.set_service_info(service_info)
+
+                    # Send via WebRTC
+                    webrtc_connection.send_app_message({
+                        "type": "service_info",
+                        **service_info
+                    })
+                    logger.info(f"📊 Sent service info to frontend: STT={stt_display}, LLM={llm_display}, TTS={tts_display}")
+            except Exception as e:
+                logger.error(f"❌ Error sending service info: {e}")
+
+            if task_ref["task"]:
+                verbosity = persona_params.get("verbosity", 10) if persona_params else 10
+                intro_instruction = get_introduction_instruction(client_state['client_id'], verbosity)
+                
+                if context and hasattr(context, "messages"):
+                     context.messages.append(intro_instruction)
+
+                logger.info("Waiting for pipeline to warm up...")
+                await asyncio.sleep(2.0)
+                
+                logger.info("Queueing initial LLM greeting...")
+                await task_ref["task"].queue_frames([LLMRunFrame()])
+
+        @pipecat_transport.event_handler("on_client_disconnected")
+        async def on_client_disconnected(transport, client):
+            logger.info("Pipecat Client disconnected")
+            if task_ref["task"]:
+                await task_ref["task"].cancel()
+            await _cleanup_services(service_refs)
+
+        # ====================================================================
+        # PIPELINE EXECUTION
+        # ====================================================================
+
+        # Enable built-in Pipecat metrics for latency tracking
+        user_bot_latency_observer = UserBotLatencyLogObserver()
+
+        task = PipelineTask(
+            pipeline,
+            params=PipelineParams(
+                enable_metrics=True,              # Enable performance metrics (TTFB, latency)
+                enable_usage_metrics=True,        # Enable LLM/TTS usage metrics
+                report_only_initial_ttfb=False,   # Report all TTFB measurements
+            ),
+            observers=[
+                turn_observer,
+                metrics_observer,
+                transcription_observer,
+                assistant_observer,
+                tts_state_observer,
+                vision_observer,
+                display_events_observer,          # Send events to TARS display
+                user_bot_latency_observer,        # Measures total user→bot response time
+            ],  # Non-intrusive monitoring
+        )
+        task_ref["task"] = task
+        runner = PipelineRunner(handle_sigint=False)
+
+        logger.info("Starting pipeline runner...")
+        
+        try:
+            await runner.run(task)
+        except Exception:
+            raise
+        finally:
+            await _cleanup_services(service_refs)
+
+    except Exception as e:
+        logger.error(f"Error in bot pipeline: {e}", exc_info=True)
+    finally:
+        await _cleanup_services(service_refs)

src/pipecat_service.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""
+Pipecat.ai service for real-time transcription and TTS using SmallWebRTC
+Communicates directly with browser via WebRTC
+"""
+
+# Fix SSL certificate issues FIRST - before any SSL-using imports
+import os
+import sys
+from pathlib import Path
+
+# Add src/ to Python path
+# Add src directory to Python path for imports
+src_dir = Path(__file__).parent
+sys.path.insert(0, str(src_dir))
+
+try:
+    import certifi
+    cert_file = certifi.where()
+    os.environ['SSL_CERT_FILE'] = cert_file
+    os.environ['REQUESTS_CA_BUNDLE'] = cert_file
+    os.environ['CURL_CA_BUNDLE'] = cert_file
+except ImportError:
+    pass  # certifi not available, will use system certs
+
+import ssl
+from contextlib import asynccontextmanager
+
+# Configure SSL to use certifi certificates for Python's ssl module
+# For development: disable SSL verification completely to avoid certificate issues
+# This MUST happen before any libraries that use SSL are imported
+try:
+    import certifi
+    cert_file = certifi.where()
+    # Set environment variables for libraries that respect them
+    os.environ['SSL_CERT_FILE'] = cert_file
+    os.environ['REQUESTS_CA_BUNDLE'] = cert_file
+    os.environ['CURL_CA_BUNDLE'] = cert_file
+
+    # For Python's ssl module: use unverified context for development
+    # This bypasses SSL certificate verification to avoid connection issues
+    ssl._create_default_https_context = ssl._create_unverified_context
+except ImportError:
+    # If certifi not available, use unverified (development only)
+    ssl._create_default_https_context = ssl._create_unverified_context
+except Exception as e:
+    # If anything fails, use unverified context
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+import argparse
+import logging
+from fastapi import BackgroundTasks, FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from loguru import logger
+from pipecat.transports.smallwebrtc.request_handler import (
+    SmallWebRTCPatchRequest,
+    SmallWebRTCRequest,
+    SmallWebRTCRequestHandler,
+)
+
+from bot import run_bot
+from config import (
+    PIPECAT_HOST,
+    PIPECAT_PORT,
+    SPEECHMATICS_API_KEY,
+    DEEPGRAM_API_KEY,
+    ELEVENLABS_API_KEY,
+    DEEPINFRA_API_KEY,
+    STT_PROVIDER,
+    TTS_PROVIDER,  # Only used for startup validation
+    get_fresh_config,
+)
+
+# Remove default loguru handler and set up custom logging
+logger.remove(0)
+
+# Configure standard logging
+logging.basicConfig(level=logging.INFO)
+standard_logger = logging.getLogger(__name__)
+
+# Reduce noise from websockets library - only log warnings and above
+websockets_logger = logging.getLogger('websockets')
+websockets_logger.setLevel(logging.WARNING)
+
+# Log SSL certificate configuration
+try:
+    import certifi
+    logger.info(f"SSL Configuration: Using certificates from {certifi.where()}")
+    logger.info(f"SSL_CERT_FILE env: {os.environ.get('SSL_CERT_FILE', 'not set')}")
+except:
+    logger.warning("certifi not available - SSL verification disabled for development")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Handle app lifespan events."""
+    logger.info(f"Starting Pipecat service on http://{PIPECAT_HOST}:{PIPECAT_PORT}...")
+    logger.info(f"STT Provider: {STT_PROVIDER}")
+    logger.info(f"TTS Provider: {TTS_PROVIDER}")
+
+    # Check required API keys based on STT and TTS providers
+    missing_keys = []
+    if STT_PROVIDER == "speechmatics" and not SPEECHMATICS_API_KEY:
+        missing_keys.append("SPEECHMATICS_API_KEY")
+    if STT_PROVIDER == "deepgram" and not DEEPGRAM_API_KEY:
+        missing_keys.append("DEEPGRAM_API_KEY")
+    if not DEEPINFRA_API_KEY:
+        missing_keys.append("DEEPINFRA_API_KEY")
+    if TTS_PROVIDER == "elevenlabs" and not ELEVENLABS_API_KEY:
+        missing_keys.append("ELEVENLABS_API_KEY")
+
+    if missing_keys:
+        logger.error(f"ERROR: Missing required API keys: {', '.join(missing_keys)}")
+        sys.exit(1)
+
+    yield  # Run app
+
+    # Cleanup
+    await small_webrtc_handler.close()
+    logger.info("Shutting down...")
+
+
+app = FastAPI(lifespan=lifespan)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with specific origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize the SmallWebRTC request handler
+small_webrtc_handler: SmallWebRTCRequestHandler = SmallWebRTCRequestHandler()
+
+@app.post("/api/offer")
+async def offer(request: SmallWebRTCRequest, background_tasks: BackgroundTasks):
+    """Handle WebRTC offer requests via SmallWebRTCRequestHandler."""
+    logger.debug(f"Received WebRTC offer request")
+
+    # Prepare runner arguments with the callback to run your bot
+    async def webrtc_connection_callback(connection):
+        background_tasks.add_task(run_bot, connection)
+
+    # Delegate handling to SmallWebRTCRequestHandler
+    answer = await small_webrtc_handler.handle_web_request(
+        request=request,
+        webrtc_connection_callback=webrtc_connection_callback,
+    )
+    return answer
+
+
+@app.patch("/api/offer")
+async def ice_candidate(request: SmallWebRTCPatchRequest):
+    """Handle ICE candidate patch requests."""
+    logger.debug(f"Received ICE candidate patch request")
+    await small_webrtc_handler.handle_patch_request(request)
+    return {"status": "success"}
+
+
+@app.get("/api/status")
+async def status():
+    """Health check endpoint with fresh config values."""
+    # Get current config from config.ini
+    current_config = get_fresh_config()
+    current_stt = current_config['STT_PROVIDER']
+    current_tts = current_config['TTS_PROVIDER']
+    current_model = current_config['DEEPINFRA_MODEL']
+
+    return {
+        "status": "ok",
+        "stt_provider": current_stt,
+        "tts_provider": current_tts,
+        "llm_model": current_model,
+        "speechmatics_configured": bool(SPEECHMATICS_API_KEY) if current_stt == "speechmatics" else None,
+        "deepgram_configured": bool(DEEPGRAM_API_KEY) if current_stt == "deepgram" else None,
+        "elevenlabs_configured": bool(ELEVENLABS_API_KEY) if current_tts == "elevenlabs" else None,
+        "deepinfra_configured": bool(DEEPINFRA_API_KEY),
+        "qwen3_tts_configured": True if current_tts == "qwen3" else None,
+    }
+
+
+@app.get("/api/config")
+async def get_config():
+    """Get current configuration from config.ini."""
+    import configparser
+    from pathlib import Path
+
+    config = configparser.ConfigParser()
+    config_path = Path("config.ini")
+
+    if not config_path.exists():
+        return {"error": "config.ini not found"}
+
+    config.read(config_path)
+
+    return {
+        "llm": {
+            "model": config.get("LLM", "model", fallback="Qwen/Qwen3-235B-A22B-Instruct-2507")
+        },
+        "stt": {
+            "provider": config.get("STT", "provider", fallback="speechmatics")
+        },
+        "tts": {
+            "provider": config.get("TTS", "provider", fallback="qwen3"),
+            "qwen3_model": config.get("TTS", "qwen3_model", fallback="Qwen/Qwen3-TTS-12Hz-0.6B-Base"),
+            "qwen3_device": config.get("TTS", "qwen3_device", fallback="mps"),
+            "qwen3_ref_audio": config.get("TTS", "qwen3_ref_audio", fallback="tars-clean-compressed.mp3"),
+        }
+    }
+
+
+@app.post("/api/config")
+async def update_config(request: dict):
+    """Update configuration in config.ini."""
+    import configparser
+    from pathlib import Path
+
+    config = configparser.ConfigParser()
+    config_path = Path("config.ini")
+
+    if not config_path.exists():
+        return {"error": "config.ini not found"}
+
+    config.read(config_path)
+
+    # Update LLM config
+    if "llm_model" in request:
+        if not config.has_section("LLM"):
+            config.add_section("LLM")
+        config.set("LLM", "model", request["llm_model"])
+
+    # Update STT config
+    if "stt_provider" in request:
+        if not config.has_section("STT"):
+            config.add_section("STT")
+        config.set("STT", "provider", request["stt_provider"])
+
+    # Update TTS config
+    if "tts_provider" in request:
+        if not config.has_section("TTS"):
+            config.add_section("TTS")
+        config.set("TTS", "provider", request["tts_provider"])
+
+    # Write back to file
+    with open(config_path, "w") as f:
+        config.write(f)
+
+    return {
+        "success": True,
+        "message": "Configuration updated. Please restart the service for changes to take effect.",
+        "restart_required": True
+    }
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="WebRTC Pipecat service")
+    parser.add_argument(
+        "--host", default=PIPECAT_HOST, help=f"Host for HTTP server (default: {PIPECAT_HOST})"
+    )
+    parser.add_argument(
+        "--port", type=int, default=PIPECAT_PORT, help=f"Port for HTTP server (default: {PIPECAT_PORT})"
+    )
+    parser.add_argument("--verbose", "-v", action="count")
+    args = parser.parse_args()
+
+    if args.verbose:
+        logger.add(sys.stderr, level="TRACE")
+    else:
+        logger.add(sys.stderr, level="INFO")
+
+    import uvicorn
+    uvicorn.run(app, host=args.host, port=args.port)

src/tars_bot.py

@@ -0,0 +1,457 @@
+"""
+TARS Bot - Robot Mode
+
+Pipecat pipeline that connects to Raspberry Pi TARS robot via WebRTC.
+Uses aiortc client for bidirectional audio and DataChannel for state sync.
+
+Architecture:
+- RPi WebRTC Server (aiortc) ← MacBook WebRTC Client (aiortc)
+- Audio: RPi mic → Pipeline → RPi speaker
+- State: DataChannel for real-time sync
+- Commands: gRPC for robot control
+"""
+
+import sys
+from pathlib import Path
+
+# Add src/ to Python path
+# Add src directory to Python path for imports
+src_dir = Path(__file__).parent
+sys.path.insert(0, str(src_dir))
+
+import asyncio
+import os
+import uuid
+from loguru import logger
+
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineTask, PipelineParams
+from pipecat.processors.aggregators.llm_context import LLMContext
+from pipecat.processors.aggregators.llm_response_universal import (
+    LLMContextAggregatorPair,
+    LLMUserAggregatorParams
+)
+from pipecat.services.openai.llm import OpenAILLMService
+from pipecat.adapters.schemas.tools_schema import ToolsSchema
+from pipecat.transcriptions.language import Language
+from pipecat.frames.frames import LLMRunFrame
+
+from config import (
+    DEEPGRAM_API_KEY,
+    SPEECHMATICS_API_KEY,
+    ELEVENLABS_API_KEY,
+    ELEVENLABS_VOICE_ID,
+    DEEPINFRA_API_KEY,
+    DEEPINFRA_BASE_URL,
+    RPI_URL,
+    RPI_GRPC,
+    AUTO_CONNECT,
+    RECONNECT_DELAY,
+    MAX_RECONNECT_ATTEMPTS,
+    get_fresh_config,
+    detect_deployment_mode,
+    get_robot_grpc_address,
+)
+
+from transport import AiortcRPiClient, AudioBridge, StateSync
+from transport.audio_bridge import RPiAudioInputTrack, RPiAudioOutputTrack
+from services.factories import create_stt_service, create_tts_service
+from services import tars_robot
+from services.update_checker import TarsUpdateChecker, CLIENT_VERSION
+from processors import SilenceFilter
+from observers import StateObserver
+from character.prompts import (
+    load_persona_ini,
+    load_tars_json,
+    build_tars_system_prompt,
+    get_introduction_instruction,
+)
+from tools import (
+    fetch_user_image,
+    adjust_persona_parameter,
+    execute_movement,
+    capture_camera_view,
+    create_fetch_image_schema,
+    create_adjust_persona_schema,
+    create_identity_schema,
+    create_movement_schema,
+    create_camera_capture_schema,
+    get_persona_storage,
+    set_emotion,
+    do_gesture,
+    create_emotion_schema,
+    create_gesture_schema,
+    set_rate_limiter,
+    ExpressionRateLimiter,
+)
+
+
+async def run_robot_bot():
+    """Run TARS bot in robot mode (connected to RPi via aiortc)."""
+    logger.info("=" * 80)
+    logger.info("🤖 Starting TARS in Robot Mode")
+    logger.info("=" * 80)
+
+    # Load fresh configuration
+    runtime_config = get_fresh_config()
+    DEEPINFRA_MODEL = runtime_config['DEEPINFRA_MODEL']
+    STT_PROVIDER = runtime_config['STT_PROVIDER']
+    TTS_PROVIDER = runtime_config['TTS_PROVIDER']
+    QWEN3_TTS_MODEL = runtime_config['QWEN3_TTS_MODEL']
+    QWEN3_TTS_DEVICE = runtime_config['QWEN3_TTS_DEVICE']
+    QWEN3_TTS_REF_AUDIO = runtime_config['QWEN3_TTS_REF_AUDIO']
+    TARS_DISPLAY_URL = runtime_config['TARS_DISPLAY_URL']
+    TARS_DISPLAY_ENABLED = runtime_config['TARS_DISPLAY_ENABLED']
+
+    # Detect deployment mode
+    deployment_mode = detect_deployment_mode()
+    robot_grpc_address = get_robot_grpc_address()
+
+    logger.info(f"📋 Configuration:")
+    logger.info(f"   Client: v{CLIENT_VERSION}")
+    logger.info(f"   Deployment: {deployment_mode}")
+    logger.info(f"   STT: {STT_PROVIDER}")
+    logger.info(f"   LLM: {DEEPINFRA_MODEL}")
+    logger.info(f"   TTS: {TTS_PROVIDER}")
+    logger.info(f"   RPi HTTP: {RPI_URL}")
+    logger.info(f"   RPi gRPC: {robot_grpc_address}")
+    logger.info(f"   Display: {TARS_DISPLAY_URL} ({'enabled' if TARS_DISPLAY_ENABLED else 'disabled'})")
+
+    # Session initialization
+    session_id = str(uuid.uuid4())[:8]
+    client_id = f"guest_{session_id}"
+    client_state = {"client_id": client_id}
+    logger.info(f"📱 Session: {client_id}")
+
+    service_refs = {"stt": None, "tts": None, "robot_client": None, "aiortc_client": None}
+
+    try:
+        # ====================================================================
+        # WEBRTC CONNECTION TO RPI
+        # ====================================================================
+
+        logger.info("🔌 Initializing WebRTC client...")
+        aiortc_client = AiortcRPiClient(
+            rpi_url=RPI_URL,
+            auto_reconnect=True,
+            reconnect_delay=RECONNECT_DELAY,
+            max_reconnect_attempts=MAX_RECONNECT_ATTEMPTS,
+        )
+        service_refs["aiortc_client"] = aiortc_client
+
+        # State sync via DataChannel
+        state_sync = StateSync()
+
+        # Set up callbacks
+        @aiortc_client.on_connected
+        async def on_connected():
+            logger.info("✓ WebRTC connected to RPi")
+            state_sync.set_send_callback(aiortc_client.send_data_channel_message)
+
+        @aiortc_client.on_disconnected
+        async def on_disconnected():
+            logger.warning("⚠️  WebRTC disconnected from RPi")
+
+        @aiortc_client.on_data_channel_message
+        def on_data_message(message: str):
+            state_sync.handle_message(message)
+
+        # Register DataChannel message handlers
+        state_sync.on_battery_update(lambda level, charging:
+            logger.debug(f"🔋 Battery: {level}% ({'charging' if charging else 'discharging'})"))
+
+        state_sync.on_movement_status(lambda moving, movement:
+            logger.debug(f"🚶 Movement: {movement} ({'active' if moving else 'idle'})"))
+
+        # Connect to RPi
+        if AUTO_CONNECT:
+            logger.info("🔄 Connecting to RPi...")
+            connected = await aiortc_client.connect()
+            if not connected:
+                logger.error("❌ Failed to connect to RPi. Exiting.")
+                return
+        else:
+            logger.info("⏸️  Auto-connect disabled. Waiting for manual connection.")
+            return
+
+        # Wait for audio track from RPi
+        logger.info("⏳ Waiting for audio track from RPi...")
+        timeout = 10
+        start_time = asyncio.get_event_loop().time()
+        while not aiortc_client.get_audio_track() and (asyncio.get_event_loop().time() - start_time) < timeout:
+            await asyncio.sleep(0.1)
+
+        audio_track_from_rpi = aiortc_client.get_audio_track()
+        if not audio_track_from_rpi:
+            logger.error("❌ No audio track received from RPi. Exiting.")
+            return
+
+        logger.info("✓ Received audio track from RPi")
+
+        # ====================================================================
+        # AUDIO BRIDGE SETUP
+        # ====================================================================
+
+        logger.info("🎧 Setting up audio bridge...")
+
+        # Create audio input track (RPi mic → Pipecat)
+        rpi_input = RPiAudioInputTrack(
+            aiortc_track=audio_track_from_rpi,
+            sample_rate=16000  # RPi mic sample rate
+        )
+
+        # Create audio output track (Pipecat TTS → RPi speaker)
+        rpi_output = RPiAudioOutputTrack(
+            sample_rate=24000  # TTS output sample rate
+        )
+
+        # Add output track to WebRTC connection
+        aiortc_client.add_audio_track(rpi_output)
+
+        # Create audio bridge processor
+        audio_bridge = AudioBridge(
+            rpi_input_track=rpi_input,
+            rpi_output_track=rpi_output
+        )
+
+        logger.info("✓ Audio bridge ready")
+
+        # ====================================================================
+        # SPEECH-TO-TEXT SERVICE
+        # ====================================================================
+
+        logger.info(f"🎤 Initializing {STT_PROVIDER} STT...")
+        stt = create_stt_service(
+            provider=STT_PROVIDER,
+            speechmatics_api_key=SPEECHMATICS_API_KEY,
+            deepgram_api_key=DEEPGRAM_API_KEY,
+            language=Language.EN,
+            enable_diarization=False,
+        )
+        service_refs["stt"] = stt
+        logger.info(f"✓ STT initialized")
+
+        # ====================================================================
+        # TEXT-TO-SPEECH SERVICE
+        # ====================================================================
+
+        logger.info(f"🔊 Initializing {TTS_PROVIDER} TTS...")
+        tts = create_tts_service(
+            provider=TTS_PROVIDER,
+            elevenlabs_api_key=ELEVENLABS_API_KEY,
+            elevenlabs_voice_id=ELEVENLABS_VOICE_ID,
+            qwen_model=QWEN3_TTS_MODEL,
+            qwen_device=QWEN3_TTS_DEVICE,
+            qwen_ref_audio=QWEN3_TTS_REF_AUDIO,
+        )
+        service_refs["tts"] = tts
+        logger.info(f"✓ TTS initialized")
+
+        # ====================================================================
+        # LLM SERVICE & TOOLS
+        # ====================================================================
+
+        logger.info("🧠 Initializing LLM...")
+        llm = OpenAILLMService(
+            api_key=DEEPINFRA_API_KEY,
+            base_url=DEEPINFRA_BASE_URL,
+            model=DEEPINFRA_MODEL
+        )
+
+        # Load character
+        character_dir = os.path.join(os.path.dirname(__file__), "character")
+        persona_params = load_persona_ini(os.path.join(character_dir, "persona.ini"))
+        tars_data = load_tars_json(os.path.join(character_dir, "TARS.json"))
+        system_prompt = build_tars_system_prompt(persona_params, tars_data)
+
+        # Initialize expression rate limiter
+        rate_limiter = ExpressionRateLimiter(
+            min_emotion_interval=5.0,
+            min_gesture_interval=30.0,
+            max_gestures_per_session=3
+        )
+        set_rate_limiter(rate_limiter)
+
+        # Create tool schemas
+        tools = ToolsSchema(
+            standard_tools=[
+                create_fetch_image_schema(),
+                create_adjust_persona_schema(),
+                create_identity_schema(),
+                create_movement_schema(),
+                create_camera_capture_schema(),
+                create_emotion_schema(),
+                create_gesture_schema(),
+            ]
+        )
+
+        messages = [system_prompt]
+        context = LLMContext(messages, tools)
+
+        # Register tool functions
+        llm.register_function("fetch_user_image", fetch_user_image)
+        llm.register_function("adjust_persona_parameter", adjust_persona_parameter)
+        llm.register_function("execute_movement", execute_movement)
+        llm.register_function("capture_camera_view", capture_camera_view)
+        llm.register_function("set_emotion", set_emotion)
+        llm.register_function("do_gesture", do_gesture)
+
+        logger.info(f"✓ LLM initialized with {DEEPINFRA_MODEL}")
+
+        # ====================================================================
+        # TARS ROBOT CLIENT (gRPC commands)
+        # ====================================================================
+
+        logger.info("🤖 Initializing TARS Robot Client (gRPC)...")
+        robot_client = None
+        if TARS_DISPLAY_ENABLED:
+            try:
+                robot_client = tars_robot.get_robot_client(address=robot_grpc_address)
+                service_refs["robot_client"] = robot_client
+                if robot_client and tars_robot.is_robot_available():
+                    logger.info(f"✓ TARS Robot Client connected via gRPC at {robot_grpc_address}")
+                    tars_robot.set_eye_state("idle")
+
+                    # Check daemon version
+                    logger.info("Checking TARS daemon version...")
+                    update_checker = TarsUpdateChecker(robot_client)
+                    await update_checker.check_on_connect()
+                else:
+                    logger.warning("⚠️ TARS Robot not available")
+            except Exception as e:
+                logger.warning(f"⚠️ Could not initialize TARS Robot: {e}")
+        else:
+            logger.info("ℹ️  TARS Robot control disabled")
+
+        # ====================================================================
+        # CONTEXT AGGREGATOR
+        # ====================================================================
+
+        user_params = LLMUserAggregatorParams(
+            user_turn_stop_timeout=1.5
+        )
+
+        context_aggregator = LLMContextAggregatorPair(
+            context,
+            user_params=user_params
+        )
+
+        persona_storage = get_persona_storage()
+        persona_storage["persona_params"] = persona_params
+        persona_storage["tars_data"] = tars_data
+        persona_storage["context_aggregator"] = context_aggregator
+
+        # ====================================================================
+        # OBSERVERS
+        # ====================================================================
+
+        state_observer = StateObserver(state_sync=state_sync)
+
+        # ====================================================================
+        # PIPELINE ASSEMBLY
+        # ====================================================================
+
+        logger.info("🔧 Building pipeline...")
+
+        pipeline = Pipeline([
+            stt,
+            context_aggregator.user(),
+            llm,
+            SilenceFilter(),
+            tts,
+            audio_bridge,  # Captures TTS output and sends to RPi speaker
+            context_aggregator.assistant(),
+        ])
+
+        # ====================================================================
+        # AUDIO INPUT FEEDING
+        # ====================================================================
+
+        # Task reference for audio feeding
+        task_ref = {"task": None, "audio_task": None}
+
+        async def feed_rpi_audio():
+            """Feed audio frames from RPi mic into the pipeline."""
+            logger.info("🎤 Starting audio input from RPi...")
+            try:
+                async for audio_frame in rpi_input.start():
+                    if task_ref.get("task"):
+                        await task_ref["task"].queue_frames([audio_frame])
+            except Exception as e:
+                logger.error(f"❌ Audio input error: {e}", exc_info=True)
+            finally:
+                logger.info("🎤 Audio input stopped")
+
+        # ====================================================================
+        # PIPELINE EXECUTION
+        # ====================================================================
+
+        task = PipelineTask(
+            pipeline,
+            params=PipelineParams(
+                enable_metrics=True,
+                enable_usage_metrics=True,
+                report_only_initial_ttfb=False,
+            ),
+            observers=[state_observer],
+        )
+
+        task_ref["task"] = task
+        runner = PipelineRunner(handle_sigint=True)
+
+        logger.info("▶️  Starting pipeline...")
+        logger.info("=" * 80)
+
+        # Start audio input feeding task
+        audio_task = asyncio.create_task(feed_rpi_audio())
+        task_ref["audio_task"] = audio_task
+
+        # Send initial greeting
+        await asyncio.sleep(2.0)
+        intro_instruction = get_introduction_instruction(client_id, persona_params.get("verbosity", 10))
+        if context and hasattr(context, "messages"):
+            context.messages.append(intro_instruction)
+        await task.queue_frames([LLMRunFrame()])
+
+        # Run pipeline
+        try:
+            await runner.run(task)
+        finally:
+            # Cancel audio feeding task
+            if task_ref.get("audio_task"):
+                task_ref["audio_task"].cancel()
+                try:
+                    await task_ref["audio_task"]
+                except asyncio.CancelledError:
+                    pass
+
+    except KeyboardInterrupt:
+        logger.info("🛑 Interrupted by user")
+    except Exception as e:
+        logger.error(f"❌ Error in robot bot: {e}", exc_info=True)
+    finally:
+        # Cleanup
+        logger.info("🧹 Cleaning up...")
+        if service_refs.get("aiortc_client"):
+            await service_refs["aiortc_client"].disconnect()
+        if service_refs.get("stt"):
+            try:
+                await service_refs["stt"].close()
+            except:
+                pass
+        if service_refs.get("tts"):
+            try:
+                await service_refs["tts"].close()
+            except:
+                pass
+        if service_refs.get("robot_client"):
+            try:
+                tars_robot.close_robot_client()
+            except:
+                pass
+        logger.info("✓ Cleanup complete")
+
+
+if __name__ == "__main__":
+    asyncio.run(run_robot_bot())

ui/README.md

@@ -39,7 +39,7 @@ Then open http://localhost:7861
 
 Terminal 1:
 ```bash
-python bot.py
+python src/src/bot.py
 ```
 
 Terminal 2:
@@ -52,7 +52,7 @@ python ui/app.py
 The UI reads from `src/shared_state.py`, which is populated by observers in the Pipecat pipeline:
 
 ```
-bot.py (Pipecat Pipeline)
+src/bot.py (Pipecat Pipeline)
     ↓
 src/observers/ (metrics, transcription, assistant)
     ↓
@@ -123,7 +123,7 @@ python tests/gradio/test_gradio.py
 ## Troubleshooting
 
 ### No data showing
-- Ensure bot.py is running
+- Ensure src/bot.py is running
 - Check that WebRTC client is connected
 - Verify at least one conversation turn has completed
 
@@ -133,7 +133,7 @@ pip install gradio plotly
 ```
 
 ### Charts not updating
-- Check that observers are enabled in bot.py
+- Check that observers are enabled in src/bot.py
 - Verify shared_state.py is being imported correctly
 - Check console for errors
 

ui/app.py

@@ -337,13 +337,13 @@ with gr.Blocks(
             gr.Markdown("""
 **To connect to TARS:**
 
-1. Ensure bot pipeline is running: `python bot.py`
+1. Ensure bot pipeline is running: `python src/src/bot.py`
 2. Open WebRTC client in browser
 3. Pipeline will connect automatically
 
 **Endpoints:**
 - WebRTC Signaling: Handled by SmallWebRTC transport
-- Health Check: Check bot.py logs for status
+- Health Check: Check src/bot.py logs for status
 
 **Architecture:**
 - Pipecat pipeline with STT, LLM, TTS