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
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.
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)
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. |
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
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 |
Il convient de distinguer l'implémentation actuelle de sa version initiale :
is_per_turn_swap = True).is_per_turn_swap = False, server.py:11466) à la demande de Raphaël.HYBRID_VEILLE_TIMEOUT_S = 15) :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 :
HYBRID_VEILLE_TIMEOUT_S) :