⚡ Analyse Technique Approfondie : Temps de Réponse de la Première Phrase vs Phrases Suivantes en Mode Live Hybride

Date : 30 octobre 2026
Auteur : Antigravity / Jarvis Core Engine
Fichiers analysés :
- C:\ASSISTANT_IA\JARVIS_LIVE_VOICE\server.py (lignes 315–344, 11080–11115, 11440–11505, 11880–12075)
- C:\ASSISTANT_IA\JARVIS_LIVE_VOICE\public_jarvis\app.js
- C:\ASSISTANT_IA\artifacts\IMPLEMENTATION_MODE_LIVE_HYBRID_20261016.md
- C:\ASSISTANT_IA\artifacts\DIAGNOSTIC_ET_CORRECTIF_REPETITION_MODE_HYBRIDE_20261016.md
- C:\ASSISTANT_IA\artifacts\DIAGNOSTIC_MODES_HYBRIDE_ET_LIVE_TOUR_20261016.md
- C:\ASSISTANT_IA\JARVIS_LIVE_VOICE\live_session.log


1. Synthèse Exécutive & Constat Majeur

En mode Live Hybride (live_hybrid), l'écart de latence perçue entre la première phrase d'un échange et les phrases suivantes n'est pas un dysfonctionnement aléatoire : c'est la conséquence directe de l'architecture de veille et d'économie de flux implémentée pour concilier rapidité vocale et résilience réseau.

  1. Première phrase (Sortie de Veille / Cold Start) : ~2,5s à 4,2s de délai global
    Lorsque Jarvis est en veille (silence > 15s), la session WebSocket Gemini Live est physiquement fermée. La première phrase de Raphaël doit déclencher la détection VAD locale, établir la connexion WebSocket Google (handshake TLS, auth, instructions système, contexte persistant) et vider le pré-roll audio accumulé en rafale.
  2. Phrases suivantes (Flux Actif en Streaming / Warm State) : 0,15s à 0,45s de délai (quasi instantané)
    Tant que la conversation reste active (< 15s d'intervalle entre les prises de parole), le tunnel WebSocket Gemini Live reste ouvert en duplex intégral. L'audio micro est streamé en temps réel (1x) sans aucune mise en mémoire tampon. La VAD neuronale de Google opère au fil de l'eau pendant que Raphaël parle, permettant à Gemini de répondre dès le dernier mot prononcé.

2. Architecture du Mode Live Hybride : Deux Régimes Distincts

Le mode live_hybrid a été conçu pour éliminer les deux défauts symétriques des autres modes : - Le mode live continu : ultra-rapide mais maintient un flux montant ininterrompu à 256 kbit/s même pendant des heures de silence, consommant du quota et s'exposant aux coupures réseau 4G/Wi-Fi inopinées. - Le mode live_tour : accumule tout l'audio localement jusqu'au silence complet, injecte 0,9s de padding numérique forcé et envoie tout en bloc, causant une latence structurelle lourde de 5 à 8s.

Le mode Hybride sépare son fonctionnement en deux états opérationnels :

stateDiagram-v2
    [*] --> VEILLE : Inactivité > 15s ou démarrage
    state VEILLE {
        [*] --> EcouteVADLocale
        EcouteVADLocale : Micro ouvert localement
        EcouteVADLocale : Session Google FERMÉE (0 débit cloud)
        EcouteVADLocale : Buffer glissant pré-roll (max 3s)
    }

    VEILLE --> ACTIF : Phrase 1 détectée (RMS > 300)\n[Latence 2.5s - 4.2s]\n(Connexion Google + Envoi Pré-roll)

    state ACTIF {
        [*] --> StreamingContinu
        StreamingContinu : Session Google OUVERTE
        StreamingContinu : Audio streamé en temps réel (1x)
        StreamingContinu : VAD Google au fil de l'eau
        StreamingContinu : Latence phrases suivantes : 0.15s - 0.45s
    }

    ACTIF --> ACTIF : Phrases 2, 3, 4... (Silence < 15s)
    ACTIF --> VEILLE : Silence réel continu > 15s (HYBRID_VEILLE_TIMEOUT_S)

3. Décomposition Technique : Pourquoi la 1ère Phrase Met Plus de Temps

Lors de la première prise de parole, le système effectue en série une succession d'opérations bloquantes :

Étape Mécanisme dans le code Délai typique Impact sur la latence perçue
1. Détection VAD locale is_pcm_speech_active(pcm, min_rms=300.0) (server.py:12043) 50 à 150 ms Nécessite que l'énergie vocale dépasse le seuil RMS 300 sur 1-2 chunks de 100ms.
2. Négociation WebSocket Google await start_session(is_internal_reconnect=True) (server.py:12057) 1 800 à 2 400 ms Résolution DNS, handshake TLS, poignée de main WebSocket vers generativelanguage.googleapis.com.
3. Transfert Contexte & Repères Injection system_instruction + repère Guadeloupe UTC-4 + 10 derniers échanges SQLite Inclus dans le handshake Contexte de ~15k tokens envoyé à l'ouverture de session.
4. Envoi du Pré-roll en Rafale session.send_realtime_input(audio=pre_roll) (server.py:12064) 50 à 100 ms Les 1 à 3 secondes d'audio prononcées pendant que la session s'ouvrait partent d'un coup.
5. Dépilage du swap_pcm_buffer Lecture des trames accumulées pendant session_lock 100 à 200 ms Absorbe la parole de Raphaël sans trou noir.
6. VAD Google sur Bloc Rétroactif Traitement neuronal Google sur un flux compacté 400 à 800 ms Gemini doit ingérer l'ensemble de l'audio accumulé d'un coup pour situer la fin de phrase.
Total Première Phrase Chaîne séquentielle complète ~2,5s à 4,2s Délai incompressible de réveil à froid.

4. Décomposition Technique : Pourquoi les Phrases Suivantes Sont Quasi Instantanées

Dès que la session est en régime actif (hybrid_en_veille == False et time.time() - hybrid_last_speech_ts < 15s) :

sequenceDiagram
    participant R as Raphaël (Micro)
    participant J as Serveur Jarvis (server.py)
    participant G as Google Gemini Live (Session Ouverte)

    Note over R,G: Régime Actif (Phrases 2, 3, 4...) : Session déjà chaude
    R->>J: Parle en continu ("Et concernant le planning...")
    J->>G: Stream direct 1x (PCM 16kHz toutes les 100ms)
    Note over G: VAD neuronale Google calcule la fin au fil de l'eau
    R->>J: Dernier mot prononcé
    J->>G: Dernier chunk de parole
    Note over G: Détection immédiate (silence_duration_ms=900, start=HIGH, end=LOW)
    G->>J: 1er octet audio de réponse (Puck) [0.15s - 0.37s]
    J->>R: Restitution haut-parleur instantanée

5. Mesures Réelles Comparatives en Production

Données extraites des journaux réels de production (live_session.log et tests en direct sous Guadeloupe UTC-4) :

Métrique Première Phrase (Sortie de veille) Phrases Suivantes (Conversation active) Mode Live Pur (Continu) Mode Live Tour (Par bloc)
État Session Google Fermée (à établir) Déjà ouverte Déjà ouverte Maintenue
Temps d'établissement réseau 1,8s – 2,4s 0 ms 0 ms 0 ms
Pré-roll / Tamponnage 1,0s – 3,0s de burst 0 ms (flux temps réel) 0 ms 1,0s – 5,0s de bloc complet
Padding numérique artificiel 0 ms 0 ms 0 ms 900 ms de zéros
Latence 1er octet audio 2,5s à 4,2s 0,15s à 0,45s 0,12s à 0,35s 4,5s à 8,0s
Consommation bande passante 0 octet en veille 256 kbit/s pendant le dialogue 256 kbit/s permanent 24/7 0 en silence, rafale au tour

6. Historique & Évolution du Mode Hybride

Il convient de distinguer l'implémentation actuelle de sa version initiale :

  1. Version initiale (16/10/2026) :
  2. Le serveur appliquait un swap de session à chaque fin de tour (is_per_turn_swap = True).
  3. Conséquence : toutes les phrases subissaient le coût d'un renouvellement (~2,4s masqué pendant le silence), provoquant parfois des répétitions de fin de tour ou des collisions avec l'écho haut-parleur.
  4. Version définitive (18/10/2026 à aujourd'hui) :
  5. Le swap systématique à chaque tour a été supprimé (is_per_turn_swap = False, server.py:11466) à la demande de Raphaël.
  6. Introduction de la veille réelle à 15 secondes (HYBRID_VEILLE_TIMEOUT_S = 15) :
    • La session reste ouverte en continu pendant toute la discussion.
    • Elle ne se ferme réellement que lorsque Raphaël et Jarvis se taisent pendant plus de 15 secondes d'affilée.

7. Recommandations & Optimisations Possibles

Pour gommer ou atténuer ce delta de latence sur la première phrase sans perdre les bénéfices de la veille, trois leviers techniques sont envisageables :

  1. Ajuster la durée de veille (HYBRID_VEILLE_TIMEOUT_S) :
    Passer de 15s à 30s ou 45s. Une pause de 15s intervient fréquemment lors d'une réflexion naturelle ou d'une recherche. À 30-45s, les phrases de relance restent dans le régime chaud ultra-rapide (0,2s) sans multiplier les réveils à froid.
  2. Pré-connexion anticipée sur pré-VAD à seuil doux :
    Déclencher l'ouverture de la session dès un souffle ou un murmure (RMS > 180 au lieu de 300) en tâche de fond, pour que la session WebSocket soit déjà connectée au moment où la phrase audible démarre.
  3. Transmission en parallèle du pré-roll :
    Dès que le socket s'ouvre, pousser le pré-roll en streaming fragmenté plutôt qu'en un bloc massif, pour lisser l'ingestion par la VAD de Google.