Plugin UI v2 & other fixes

backends/advanced/docker-compose-test.yml

@@ -59,6 +59,7 @@ services:
       # Wait for audio queue to drain before timing out (test mode)
       - WAIT_FOR_AUDIO_QUEUE_DRAIN=true
       # Mock speaker recognition for tests (avoids resource-intensive ML service)
+      # To test with REAL speaker recognition: set to 'false' and start extras/speaker-recognition service
       - USE_MOCK_SPEAKER_CLIENT=true
     depends_on:
       qdrant-test:
@@ -137,7 +138,7 @@ services:
       context: ../../extras/speaker-recognition
       dockerfile: Dockerfile
       args:
-        PYTORCH_CUDA_VERSION: cpu
+        PYTORCH_CUDA_VERSION: cu12.6
     image: speaker-recognition-test:latest
     ports:
       - "8086:8085"  # Avoid conflict with dev speaker service on 8085
@@ -164,6 +165,32 @@ services:
     profiles:
       - speaker  # Optional service - only start when explicitly enabled
 
+  mock-streaming-stt:
+    build:
+      context: ../..
+      dockerfile: tests/Dockerfile.mock-streaming-stt
+    ports:
+      - "9999:9999"
+    healthcheck:
+      test: ["CMD", "python", "-c", "import socket; s=socket.socket(); s.connect(('localhost',9999)); s.close()"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    restart: unless-stopped
+
+  mock-llm:
+    build:
+      context: ../..
+      dockerfile: tests/Dockerfile.mock-llm
+    ports:
+      - "11435:11435"
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:11435/health').read()"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    restart: unless-stopped
+
   workers-test:
     build:
       context: .
@@ -212,6 +239,7 @@ services:
       # Wait for audio queue to drain before timing out (test mode)
       - WAIT_FOR_AUDIO_QUEUE_DRAIN=true
       # Mock speaker recognition for tests (avoids resource-intensive ML service)
+      # To test with REAL speaker recognition: set to 'false' and start extras/speaker-recognition service
       - USE_MOCK_SPEAKER_CLIENT=true
     depends_on:
       chronicle-backend-test:

backends/advanced/src/advanced_omi_backend/app_factory.py

@@ -42,6 +42,52 @@
 application_logger = logging.getLogger("audio_processing")
 
 
+async def initialize_openmemory_user() -> None:
+    """Initialize and register OpenMemory user if using OpenMemory MCP provider.
+
+    This function:
+    - Checks if OpenMemory MCP is configured as the memory provider
+    - Registers the configured user with OpenMemory server
+    - Creates a test memory and deletes it to trigger user creation
+    - Logs success or warning if OpenMemory is not reachable
+    """
+    from advanced_omi_backend.services.memory.config import build_memory_config_from_env, MemoryProvider
+
+    memory_provider_config = build_memory_config_from_env()
+
+    if memory_provider_config.memory_provider != MemoryProvider.OPENMEMORY_MCP:
+        return
+
+    try:
+        from advanced_omi_backend.services.memory.providers.mcp_client import MCPClient
+
+        # Get configured user_id and server_url
+        openmemory_config = memory_provider_config.openmemory_config
+        user_id = openmemory_config.get("user_id", "openmemory") if openmemory_config else "openmemory"
+        server_url = openmemory_config.get("server_url", "http://host.docker.internal:8765") if openmemory_config else "http://host.docker.internal:8765"
+        client_name = openmemory_config.get("client_name", "chronicle") if openmemory_config else "chronicle"
+
+        application_logger.info(f"Registering OpenMemory user: {user_id} at {server_url}")
+
+        # Make a lightweight registration call (create and delete dummy memory)
+        async with MCPClient(server_url=server_url, client_name=client_name, user_id=user_id) as client:
+            # Test connection first
+            is_connected = await client.test_connection()
+            if is_connected:
+                # Create and immediately delete a dummy memory to trigger user creation
+                memory_ids = await client.add_memories("Chronicle initialization - user registration test")
+                if memory_ids:
+                    # Delete the test memory
+                    await client.delete_memory(memory_ids[0])
+                application_logger.info(f"✅ Registered OpenMemory user: {user_id}")
+            else:
+                application_logger.warning(f"⚠️  OpenMemory MCP not reachable at {server_url}")
+                application_logger.info("User will be auto-created on first memory operation")
+    except Exception as e:
+        application_logger.warning(f"⚠️  Could not register OpenMemory user: {e}")
+        application_logger.info("User will be auto-created on first memory operation")
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Manage application lifespan events."""
@@ -126,6 +172,9 @@ async def lifespan(app: FastAPI):
     # Memory service will be lazily initialized when first used
     application_logger.info("Memory service will be initialized on first use (lazy loading)")
 
+    # Register OpenMemory user if using openmemory_mcp provider
+    await initialize_openmemory_user()
+
     # SystemTracker is used for monitoring and debugging
     application_logger.info("Using SystemTracker for monitoring and debugging")
 

backends/advanced/src/advanced_omi_backend/clients/audio_stream_client.py

@@ -123,6 +123,7 @@ async def send_audio_start(
         sample_rate: int = OMI_SAMPLE_RATE,
         sample_width: int = OMI_SAMPLE_WIDTH,
         channels: int = OMI_CHANNELS,
+        always_persist: bool = False,
     ) -> None:
         """Send Wyoming audio-start event.
 
@@ -131,6 +132,7 @@ async def send_audio_start(
             sample_rate: Audio sample rate in Hz (default: 16000)
             sample_width: Bytes per sample (default: 2 for 16-bit)
             channels: Number of audio channels (default: 1)
+            always_persist: Save audio even if transcription fails (default: False)
 
         Note:
             The mode is inside the "data" dict, matching _handle_audio_session_start
@@ -146,11 +148,15 @@ async def send_audio_start(
                 "width": sample_width,
                 "channels": channels,
                 "mode": recording_mode,
+                "always_persist": always_persist,
             },
             "payload_length": None,
         }
+        print(f"🔵 CLIENT: Sending audio-start message: {header}")
+        logger.info(f"🔵 CLIENT: Sending audio-start message: {header}")
         await self.ws.send(json.dumps(header) + "\n")
-        logger.info(f"Sent audio-start with mode={recording_mode}")
+        print(f"✅ CLIENT: Sent audio-start with mode={recording_mode}, always_persist={always_persist}")
+        logger.info(f"✅ CLIENT: Sent audio-start with mode={recording_mode}, always_persist={always_persist}")
 
     async def send_audio_chunk_wyoming(
         self,
@@ -232,6 +238,7 @@ async def stream_wav_file(
         use_wyoming: bool = True,
         recording_mode: str = "streaming",
         realtime_factor: float = 0.1,
+        always_persist: bool = False,
     ) -> int:
         """Stream a WAV file in chunks, simulating real-time audio.
 
@@ -241,6 +248,7 @@ async def stream_wav_file(
             use_wyoming: If True, use Wyoming protocol; if False, send raw binary
             recording_mode: "streaming" or "batch"
             realtime_factor: Fraction of real-time to simulate (0.1 = 10x speed)
+            always_persist: Save audio even if transcription fails (default: False)
 
         Returns:
             Number of chunks sent
@@ -268,6 +276,7 @@ async def stream_wav_file(
                 sample_rate=sample_rate,
                 sample_width=sample_width,
                 channels=channels,
+                always_persist=always_persist,
             )
 
             # Reset counters
@@ -335,6 +344,7 @@ def stream_audio_file(
     device_name: str = "robot-test",
     recording_mode: str = "streaming",
     use_wyoming: bool = True,
+    always_persist: bool = False,
 ) -> int:
     """Synchronous wrapper for streaming audio file.
 
@@ -348,6 +358,7 @@ def stream_audio_file(
         device_name: Device name for client identification
         recording_mode: "streaming" or "batch"
         use_wyoming: If True, use Wyoming protocol
+        always_persist: Save audio even if transcription fails (default: False)
 
     Returns:
         Number of chunks sent
@@ -359,6 +370,7 @@ async def _run() -> int:
                 wav_path,
                 use_wyoming=use_wyoming,
                 recording_mode=recording_mode,
+                always_persist=always_persist,
             )
 
     return asyncio.run(_run())
@@ -407,6 +419,7 @@ def start_stream(
         token: str,
         device_name: str = "robot-test",
         recording_mode: str = "streaming",
+        always_persist: bool = False,
     ) -> str:
         """Start a new audio stream (non-blocking).
 
@@ -415,6 +428,7 @@ def start_stream(
             token: JWT token
             device_name: Device name for client ID
             recording_mode: "streaming" or "batch"
+            always_persist: Save audio even if transcription fails (default: False)
 
         Returns:
             stream_id: Unique ID for this stream session
@@ -440,14 +454,16 @@ def run_loop():
         # Connect and send audio-start
         async def _connect_and_start():
             try:
+                logger.info(f"🔵 CLIENT: Stream {stream_id} connecting for {device_name}...")
                 await client.connect()
                 session.connected = True
-                await client.send_audio_start(recording_mode=recording_mode)
+                logger.info(f"✅ CLIENT: Stream {stream_id} connected, sending audio-start...")
+                await client.send_audio_start(recording_mode=recording_mode, always_persist=always_persist)
                 session.audio_started = True
-                logger.info(f"Stream {stream_id} started for {device_name}")
+                logger.info(f"✅ CLIENT: Stream {stream_id} started for {device_name}")
             except Exception as e:
                 session.error = str(e)
-                logger.error(f"Stream {stream_id} failed to start: {e}")
+                logger.error(f"❌ CLIENT: Stream {stream_id} failed to start: {e}")
 
         future = asyncio.run_coroutine_threadsafe(_connect_and_start(), loop)
         future.result(timeout=10)  # Wait for connection

backends/advanced/src/advanced_omi_backend/config.py

@@ -176,4 +176,56 @@ def get_audio_storage_settings() -> dict:
         Dict with audio_base_path, audio_chunks_path
     """
     cfg = get_backend_config('audio_storage')
-    return OmegaConf.to_container(cfg, resolve=True)
+    return OmegaConf.to_container(cfg, resolve=True)
+
+
+# ============================================================================
+# Miscellaneous Settings (OmegaConf-based)
+# ============================================================================
+
+def get_misc_settings() -> dict:
+    """
+    Get miscellaneous configuration settings using OmegaConf.
+
+    Returns:
+        Dict with always_persist_enabled and use_provider_segments
+    """
+    # Get audio settings for always_persist_enabled
+    audio_cfg = get_backend_config('audio')
+    audio_settings = OmegaConf.to_container(audio_cfg, resolve=True) if audio_cfg else {}
+
+    # Get transcription settings for use_provider_segments
+    transcription_cfg = get_backend_config('transcription')
+    transcription_settings = OmegaConf.to_container(transcription_cfg, resolve=True) if transcription_cfg else {}
+
+    return {
+        'always_persist_enabled': audio_settings.get('always_persist_enabled', False),
+        'use_provider_segments': transcription_settings.get('use_provider_segments', False)
+    }
+
+
+def save_misc_settings(settings: dict) -> bool:
+    """
+    Save miscellaneous settings to config.yml using OmegaConf.
+
+    Args:
+        settings: Dict with always_persist_enabled and/or use_provider_segments
+
+    Returns:
+        True if saved successfully, False otherwise
+    """
+    success = True
+
+    # Save audio settings if always_persist_enabled is provided
+    if 'always_persist_enabled' in settings:
+        audio_settings = {'always_persist_enabled': settings['always_persist_enabled']}
+        if not save_config_section('backend.audio', audio_settings):
+            success = False
+
+    # Save transcription settings if use_provider_segments is provided
+    if 'use_provider_segments' in settings:
+        transcription_settings = {'use_provider_segments': settings['use_provider_segments']}
+        if not save_config_section('backend.transcription', transcription_settings):
+            success = False
+
+    return success

backends/advanced/src/advanced_omi_backend/controllers/conversation_controller.py

@@ -118,6 +118,8 @@ async def get_conversation(conversation_id: str, user: User):
             "deleted": conversation.deleted,
             "deletion_reason": conversation.deletion_reason,
             "deleted_at": conversation.deleted_at.isoformat() if conversation.deleted_at else None,
+            "processing_status": conversation.processing_status,
+            "always_persist": conversation.always_persist,
             "end_reason": conversation.end_reason.value if conversation.end_reason else None,
             "completed_at": conversation.completed_at.isoformat() if conversation.completed_at else None,
             "title": conversation.title,
@@ -133,6 +135,8 @@ async def get_conversation(conversation_id: str, user: User):
             "active_memory_version": conversation.active_memory_version,
             "transcript_version_count": conversation.transcript_version_count,
             "memory_version_count": conversation.memory_version_count,
+            "active_transcript_version_number": conversation.active_transcript_version_number,
+            "active_memory_version_number": conversation.active_memory_version_number,
         }
 
         return {"conversation": response}
@@ -182,6 +186,8 @@ async def get_conversations(user: User, include_deleted: bool = False):
                 "deleted": conv.deleted,
                 "deletion_reason": conv.deletion_reason,
                 "deleted_at": conv.deleted_at.isoformat() if conv.deleted_at else None,
+                "processing_status": conv.processing_status,
+                "always_persist": conv.always_persist,
                 "title": conv.title,
                 "summary": conv.summary,
                 "detailed_summary": conv.detailed_summary,
@@ -193,6 +199,8 @@ async def get_conversations(user: User, include_deleted: bool = False):
                 "memory_count": conv.memory_count,
                 "transcript_version_count": conv.transcript_version_count,
                 "memory_version_count": conv.memory_version_count,
+                "active_transcript_version_number": conv.active_transcript_version_number,
+                "active_memory_version_number": conv.active_memory_version_number,
             })
 
         return {"conversations": conversations}

backends/advanced/src/advanced_omi_backend/controllers/queue_controller.py

@@ -342,7 +342,9 @@ def start_streaming_jobs(
     Returns:
         Dict with job IDs: {'speech_detection': job_id, 'audio_persistence': job_id}
 
-    Note: user_email is fetched from the database when needed.
+    Note:
+        - user_email is fetched from the database when needed.
+        - always_persist setting is read from global config by the audio persistence job.
     """
     from advanced_omi_backend.workers.transcription_jobs import stream_speech_detection_job
     from advanced_omi_backend.workers.audio_jobs import audio_streaming_persistence_job
@@ -381,6 +383,7 @@ def start_streaming_jobs(
     # Enqueue audio persistence job on dedicated audio queue
     # NOTE: This job handles file rotation for multiple conversations automatically
     # Runs for entire session, not tied to individual conversations
+    # The job reads always_persist_enabled from global config internally
     audio_job = audio_queue.enqueue(
         audio_streaming_persistence_job,
         session_id,