minor fixes probably should've been in other branch fahh

Author: AnkushMalaker

backends/advanced/src/advanced_omi_backend/chat_service.py

@@ -21,6 +21,13 @@
 from advanced_omi_backend.database import get_database
 from advanced_omi_backend.llm_client import get_llm_client
 from advanced_omi_backend.model_registry import get_models_registry
+from advanced_omi_backend.observability.otel_setup import (
+    get_tracer,
+    is_otel_enabled,
+    set_otel_session,
+    set_trace_io,
+)
+from advanced_omi_backend.prompt_registry import get_prompt_registry
 from advanced_omi_backend.services.memory import get_memory_service
 from advanced_omi_backend.services.memory.base import MemoryEntry
 from advanced_omi_backend.services.obsidian_service import (
@@ -164,8 +171,6 @@ async def _get_system_prompt(self) -> str:
 
         # Fallback to prompt registry
         try:
-            from advanced_omi_backend.prompt_registry import get_prompt_registry
-
             registry = get_prompt_registry()
             prompt = await registry.get_prompt("chat.system")
             logger.info("Using chat system prompt from prompt registry")
@@ -426,13 +431,6 @@ async def generate_response_stream(
         include_obsidian_memory: bool = False,
     ) -> AsyncGenerator[Dict, None]:
         """Generate streaming response with memory context."""
-        from advanced_omi_backend.observability.otel_setup import (
-            get_tracer,
-            is_otel_enabled,
-            set_otel_session,
-            set_trace_io,
-        )
-
         set_otel_session(session_id)
 
         tracer = get_tracer() if is_otel_enabled() else None

backends/advanced/src/advanced_omi_backend/speaker_recognition_client.py

@@ -15,13 +15,22 @@
 import json
 import logging
 import os
+import traceback
+import uuid
+import wave
 from pathlib import Path
 from typing import Dict, List, Optional
 
 import aiohttp
 from aiohttp import ClientConnectorError
 
+from advanced_omi_backend.config import get_diarization_settings
 from advanced_omi_backend.model_registry import get_models_registry
+from advanced_omi_backend.models.conversation import Conversation
+from advanced_omi_backend.utils.audio_chunk_utils import reconstruct_audio_segment
+from advanced_omi_backend.utils.audio_extraction import extract_audio_for_results
+from advanced_omi_backend.utils.audio_utils import pcm_to_wav_bytes
+from advanced_omi_backend.utils.segment_utils import is_non_speech
 
 logger = logging.getLogger(__name__)
 
@@ -76,12 +85,23 @@ def __init__(self, service_url: Optional[str] = None):
             )
             return
 
-        # Enabled - determine URL (priority: param > config > env var)
+        # Enabled - determine URL (priority: param > config > env var > minidisc)
         self.service_url = (
             service_url
             or speaker_config.get("service_url")
             or os.getenv("SPEAKER_SERVICE_URL")
         )
+
+        if not self.service_url:
+            try:
+                from discovery import CHRONICLE_SPEAKER, resolve_service_url
+
+                self.service_url = resolve_service_url(
+                    None, CHRONICLE_SPEAKER, default=None
+                )
+            except ImportError:
+                pass
+
         self.enabled = bool(self.service_url)
 
         if self.enabled:
@@ -157,8 +177,6 @@ async def diarize_identify_match(
             return {"segments": []}
 
         # Fetch conversation to get audio duration for timeout calculation
-        from advanced_omi_backend.models.conversation import Conversation
-
         conversation = await Conversation.find_one(
             Conversation.conversation_id == conversation_id
         )
@@ -173,8 +191,6 @@ async def diarize_identify_match(
             )
 
             # Read diarization source from config system
-            from advanced_omi_backend.config import get_diarization_settings
-
             config = get_diarization_settings()
             diarization_source = config.get("diarization_source", "pyannote")
 
@@ -432,18 +448,11 @@ async def identify_provider_segments(
         if not self.enabled:
             return {"segments": []}
 
-        from advanced_omi_backend.config import get_diarization_settings
-        from advanced_omi_backend.utils.audio_chunk_utils import (
-            reconstruct_audio_segment,
-        )
-
         config = get_diarization_settings()
         similarity_threshold = config.get("similarity_threshold", 0.45)
 
         MAX_SAMPLES_PER_LABEL = 3
 
-        from advanced_omi_backend.utils.segment_utils import is_non_speech
-
         def _is_non_speech(seg: Dict) -> bool:
             return is_non_speech(
                 seg.get("text", ""),
@@ -633,10 +642,6 @@ async def _identify_per_segment(
         Returns:
             Dict with 'segments' list matching diarize_identify_match() format
         """
-        from advanced_omi_backend.utils.audio_chunk_utils import (
-            reconstruct_audio_segment,
-        )
-
         logger.info(
             f"🎤 Per-segment identification: {len(speech_segments)} speech segments "
             f"(min_duration={min_segment_duration}s)"
@@ -849,8 +854,6 @@ async def diarize_and_identify(
                 )
 
                 # Get current diarization settings from config
-                from advanced_omi_backend.config import get_diarization_settings
-
                 diarization_settings = get_diarization_settings()
 
                 # Add all diarization parameters for the diarize-and-identify endpoint
@@ -947,8 +950,6 @@ async def diarize_and_identify(
             logger.error(
                 f"🎤 [DIARIZE] ❌ Error during speaker diarization and identification: {e}"
             )
-            import traceback
-
             logger.debug(traceback.format_exc())
             return {"error": "unknown_error", "message": str(e), "segments": []}
 
@@ -979,8 +980,6 @@ async def identify_speakers(
             logger.info(f"Identifying {len(unique_speakers)} speakers in {audio_path}")
 
             # Get audio duration for timeout calculation
-            import wave
-
             try:
                 with wave.open(audio_path, "rb") as wav_file:
                     frame_count = wav_file.getnframes()
@@ -1007,8 +1006,6 @@ async def identify_speakers(
                         content_type="audio/wav",
                     )
                     # Get current diarization settings
-                    from advanced_omi_backend.config import get_diarization_settings
-
                     _diarization_settings = get_diarization_settings()
 
                     # Add all diarization parameters for the diarize-and-identify endpoint
@@ -1239,8 +1236,6 @@ async def enroll_new_speaker(
             return {"error": "speaker_recognition_disabled"}
 
         try:
-            import uuid
-
             # Generate speaker ID: user_{user_id}_speaker_{random_hex}
             speaker_id = f"user_{user_id}_speaker_{uuid.uuid4().hex[:12]}"
 
@@ -1356,10 +1351,6 @@ async def check_if_enrolled_speaker_present(
             - enrolled_present: True if enrolled speaker detected, False otherwise
             - speaker_result: Full speaker recognition result dict with segments
         """
-        from advanced_omi_backend.utils.audio_extraction import (
-            extract_audio_for_results,
-        )
-
         logger.info(
             f"🎤 [SPEAKER CHECK] Starting speaker check for session {session_id}"
         )
@@ -1407,7 +1398,6 @@ async def check_if_enrolled_speaker_present(
         )
 
         # Convert PCM to WAV in memory (no disk I/O!)
-        from advanced_omi_backend.utils.audio_utils import pcm_to_wav_bytes
 
         logger.info(f"🎤 [SPEAKER CHECK] Converting PCM to WAV in memory...")
         wav_data = pcm_to_wav_bytes(

services.py

@@ -40,36 +40,55 @@ def load_config_yml():
         "compose_file": "docker-compose.yml",
         "description": "LangFuse Observability & Prompt Management",
         "ports": ["3002"],
+        "health_endpoints": [
+            ("langfuse", None, "3002", "/api/public/health"),
+        ],
     },
     "backend": {
         "path": "backends/advanced",
         "compose_file": "docker-compose.yml",
         "description": "Advanced Backend + WebUI",
         "ports": ["8000", "5173"],
+        "health_endpoints": [
+            ("backend", "BACKEND_PUBLIC_PORT", "8000", "/readiness"),
+        ],
     },
     "speaker-recognition": {
         "path": "extras/speaker-recognition",
         "compose_file": "docker-compose.yml",
         "description": "Speaker Recognition Service",
         "ports": ["8085", "5174/8444"],
+        "health_endpoints": [
+            ("speaker", "SPEAKER_SERVICE_PORT", "8085", "/health"),
+        ],
     },
     "asr-services": {
         "path": "extras/asr-services",
         "compose_file": "docker-compose.yml",
         "description": "Parakeet ASR Service",
         "ports": ["8767"],
+        "health_endpoints": [
+            ("asr", "ASR_PORT", "8767", "/health"),
+        ],
     },
     "openmemory-mcp": {
         "path": "extras/openmemory-mcp",
         "compose_file": "docker-compose.yml",
         "description": "OpenMemory MCP Server",
         "ports": ["8765"],
+        "health_endpoints": [
+            ("openmemory", None, "8765", "/docs"),
+        ],
     },
     "llm-services": {
         "path": "extras/llm-services",
         "compose_file": "docker-compose.yml",
         "description": "Local LLM via llama.cpp (chat + embeddings)",
         "ports": ["8083", "8082"],
+        "health_endpoints": [
+            ("chat", "LLM_PORT", "8083", "/health"),
+            ("embeddings", "EMBED_PORT", "8082", "/health"),
+        ],
     },
 }
 
@@ -162,6 +181,54 @@ def check_service_configured(service_name):
         return (service_path / ".env").exists()
 
 
+def check_service_health(service_name):
+    """Check runtime health of a service by hitting its health endpoints.
+
+    Returns (status, detail) where status is one of:
+        "healthy"  — all endpoints responding with < 400
+        "partial"  — some endpoints down (detail says which)
+        "unhealthy" — responding but returning errors
+        "stopped"  — not reachable at all
+    """
+    import requests
+
+    service = SERVICES[service_name]
+    endpoints = service.get("health_endpoints", [])
+    if not endpoints:
+        return ("stopped", "no endpoints defined")
+
+    env_path = Path(service["path"]) / ".env"
+    env_values = dotenv_values(env_path) if env_path.exists() else {}
+
+    results = []  # list of (label, ok: bool)
+    any_unhealthy = False
+
+    for label, port_env, default_port, path in endpoints:
+        port = env_values.get(port_env, default_port) if port_env else default_port
+        url = f"http://localhost:{port}{path}"
+        try:
+            resp = requests.get(url, timeout=2)
+            if resp.status_code < 400:
+                results.append((label, True))
+            else:
+                results.append((label, False))
+                any_unhealthy = True
+        except (requests.ConnectionError, requests.Timeout):
+            results.append((label, False))
+
+    up = [r for r in results if r[1]]
+    down = [r for r in results if not r[1]]
+
+    if len(up) == len(results):
+        return ("healthy", "")
+    if len(down) == len(results):
+        if any_unhealthy:
+            return ("unhealthy", "")
+        return ("stopped", "")
+    down_labels = ", ".join(r[0] for r in down)
+    return ("partial", f"{down_labels} down")
+
+
 def run_compose_command(service_name, command, build=False, force_recreate=False):
     """Run docker compose command for a service"""
     service = SERVICES[service_name]
@@ -605,13 +672,28 @@ def show_status():
     table = Table()
     table.add_column("Service", style="cyan")
     table.add_column("Configured", justify="center")
+    table.add_column("Running", justify="center")
     table.add_column("Description", style="dim")
     table.add_column("Ports", style="green")
 
     for service_name, service_info in SERVICES.items():
         configured = "✅" if check_service_configured(service_name) else "❌"
         ports = ", ".join(service_info["ports"])
-        table.add_row(service_name, configured, service_info["description"], ports)
+
+        # Check runtime health
+        status, detail = check_service_health(service_name)
+        if status == "healthy":
+            running = "[green]✅ healthy[/green]"
+        elif status == "partial":
+            running = f"[yellow]⚠ partial[/yellow] [dim]({detail})[/dim]"
+        elif status == "unhealthy":
+            running = "[red]⚠ unhealthy[/red]"
+        else:
+            running = "[dim]— stopped[/dim]"
+
+        table.add_row(
+            service_name, configured, running, service_info["description"], ports
+        )
 
     console.print(table)
 

setup-requirements.txt

@@ -5,3 +5,4 @@ requests>=2.31.0
 pyyaml>=6.0.0
 ruamel-yaml>=0.18.0
 omegaconf>=2.3.0
+minidisc-python>=0.1.0