6. Le Pipe (Cortex Moteur)

Le pipe_engine.py (v192.15) est l'unité centrale de traitement d'ECHO. Open WebUI le voit comme un modèle GenAI standard, mais il agit en réalité comme un orchestrateur de contexte : il reconstruit l'historique bit-perfect depuis SQLite, pilote la boucle d'outils de l'Arsenal, gère l'authentification et l'inférence via deux backends (AI Studio et API Antigravity), puis scelle chaque tour dans les Ombres Riches. Il orchestre également la politique modèle centralisée — propagée de ses UserValves vers tous les outils via __metadata__ et le fallback SQLite echo_settings.

Fiche d'identité technique

La Suture Bit-Perfect — prepare_context()

La Suture est l'algorithme central du Pipe. Elle reconstruit le tableau de contents (historique au format Gemini) à partir des Ombres SQLite, garantissant une fidélité absolue quelle que soit la manipulation effectuée par Open WebUI sur l'historique affiché.

Hiérarchie de restauration

Pour chaque message de l'historique, le Pipe applique cette cascade :

1. Lecture de l'Ombre SQLite : get_message_shadow(message_id, updated_at). Le Verrou de Version compare updated_at stocké vs. updated_at fourni par le middleware. Si les timestamps concordent, l'Ombre est validée.
2. Restauration ThoughtSignature : get_signature_by_id(message_id) récupère l'Ancre Gemini 3+ scellée au tour précédent. Elle est réinjectée dans le part correspondant (p["thoughtSignature"] = sig) pour que le modèle retrouve son état de réflexion sans relire ses pensées en texte brut.
3. Cold Recovery (fallback) : si l'Ombre est absente ou invalidée par le Verrou de Version (Ghost Message), le Pipe reconstruit le message depuis le texte brut fourni par le middleware. Les pièces jointes binaires du tour concerné sont perdues, mais la continuité conversationnelle est préservée.

Intégration du Draft (message courant)

Pour le message utilisateur courant (jamais encore scellé), le Pipe récupère le Draft sémantique préparé par le Filtre (metadata._echo_user_parts_draft) et le fusionne avec le texte brut pour construire les parts envoyées à Gemini. C'est ici que les placeholders ##MODEL_ID##, ##MODEL_ORIGIN## et ##ECHO_VERSION## sont résolus par _resolve_placeholders().

Routage Cognitif Dynamique

En mode AUTO, le Pipe adapte le modèle d'inférence à la complexité estimée de la tâche et à l'état du contexte. Ce routage s'appuie sur deux variables : le taux de remplissage de la fenêtre contextuelle et la nature de la requête (évaluée au premier appel à MODEL_LITE).

L'outil new_cognitive_level

Injecté dynamiquement dans les outils disponibles de chaque modèle, cet outil permet au modèle actif de déclarer qu'il ne peut pas traiter la tâche correctement à son niveau cognitif courant. Le Pipe intercepte cet appel, récupère le Plan de Transfert rédigé par le modèle sortant (document Markdown structurant le contexte et les objectifs pour son successeur), puis re-route la requête vers le modèle cible sans redémarrer la boucle complète. L'outil est bidirectionnel : il permet une escalade (LITE → FLASH → PRO) comme une redescente (PRO → FLASH → LITE) selon la charge de la tâche courante.

Cascade Descendante Technique (v192.11)

Indépendamment de l'escalade cognitive volontaire, le Pipe gère les erreurs d'indisponibilité API (429, 503) par une cascade descendante automatique : PRO → FLASH → LITE. Cette cascade est distincte du mécanisme new_cognitive_level et s'active uniquement en mode AUTO ou AUTO_PRO.

Politique Modèle Centralisée — Pipe → Outils

La UserValve MODEL_SELECTION du Pipe définit la politique d'utilisation des modèles pour tous les outils de l'Arsenal. OWUI ne propageant pas les __metadata__ personnalisés du Pipe vers les outils, deux mécanismes parallèles assurent la propagation :

Gestion des Pensées (Chain-of-Thought)

Lorsque includeThoughts: true est envoyé dans le thinkingConfig (via echo_protocol.build_ca_generation_config()), l'API Gemini retourne des parts avec thought: true. StreamProcessor.process() les intercepte et les isole du flux principal.

Isolation et affichage

Les pensées sont extraites par split_thought_process(text) (echo_utils.py), encapsulées dans les balises <think>…</think> et envoyées en amont du texte final dans le flux SSE. Open WebUI les affiche dans une section repliable. Elles ne polluent jamais le texte de la réponse.

L'Ancre (ThoughtSignature)

ECHO ne réinjecte jamais le texte brut des pensées dans l'historique des tours suivants. À la place, la thoughtSignature est scellée dans cognitive_signatures (SQLite) et réinjectée au tour suivant (p["thoughtSignature"] = sig).

La ThoughtSignature est un impératif de l'API Gemini 3+ : à la fin de chaque génération, l'API retourne systématiquement ce blob opaque dont la structure est entièrement interne à Google. Sa fonction : permettre au modèle de retrouver la continuité de sa réflexion entre les tours sans retranscrire ses raisonnements en texte brut.

Transport HTTP/2 et Headers Stealth

EchoGeminiClient utilise httpx avec l'option http2=True (dépendance h2 obligatoire). Pour les requêtes vers l'API Antigravity, les en-têtes de requête reproduisent ceux d'un IDE réel grâce à get_stealth_headers() :

User-Agent: antigravity/2.1.0 (language_server; os_type=Windows; os_version=10.0.26100; arch=x64)
x-goog-api-client: antigravity/2.1.0
Authorization: Bearer {oauth_token}
Content-Type: application/json

Bridge _TOOLS_CACHE — Partage des Callables Outils

OWUI injecte le dictionnaire __tools__ (contenant les callables Python réels des outils associés au modèle) dans le Pipe, mais ne le propage pas aux tool callables (chaque outil reçoit un __metadata__ indépendant). Cette contrainte architecturale empêche delegate_to_subagent d'accéder aux callables des autres outils pour les exécuter au nom du sous-agent.

Trois formes de __tools__ gérées

Clés injectées dans __metadata__ par ce mécanisme :

• _echo_tools_dict — dict brut OWUI (peut être vide)
• _echo_body_tools — specs format OpenAI pour tous les outils disponibles

Phase de Scellement

Une fois la génération terminée et le stream SSE clos, le Pipe scelle le tour en quatre opérations atomiques :

1. Shadow Sealing : save_message_shadow(parts_finale, updated_at) — enregistre la structure complète des parts envoyées et reçues dans message_shadows.
2. Cognitive Sealing : save_signature_by_id(message_id, thoughtSignature) — ancre la signature dans cognitive_signatures.
3. Tool Journal : save_cognitive_data(cumulative_hash, tool_io) — journalise les appels et sorties d'outils dans tool_journal.
4. Suture Index : index_suture(cumulative_hash, parent_hash) — met à jour la chaîne Merkle de la conversation.

HUD Quota — intégration dans le Pipe

À chaque fin de tour, le Pipe collecte les métriques de quota et les injecte dans la Context Gauge. Le pipeline précis, extrait du code source :

# 1. Résolution de l'ID modèle AGY (cloudcode-pa interne)
ca_id = get_ca_model_id(target_model)
# ex : MODEL_FLASH → "gemini-3-flash-agent"

# 2. Lecture du quota depuis identity.db (EchoAuth.get_model_quota)
model_quota = await echo_auth.get_model_quota(ca_id)
# Retourne le quotaInfo spécifique ou {} si modèle inconnu

# 3. Extraction des champs
quota_fraction = model_quota.get("remainingFraction", 1.0)
quota_reset    = model_quota.get("resetTime", "N/A")   # → formaté "HH:MM (Xmin)"
quota_rpd_rem  = model_quota.get("requestsPerDayRemaining", "N/A")
quota_rpd_lim  = model_quota.get("requestsPerDayLimit", "N/A")
quota_rpm_rem  = model_quota.get("requestsPerMinuteRemaining", "N/A")
quota_rpm_lim  = model_quota.get("requestsPerMinuteLimit", "N/A")

# 4. Rafraîchissement asynchrone non-bloquant (cooldown 10 min)
asyncio.ensure_future(refresh_quota_if_needed())

# 5. Injection HUD
await EchoUI.deploy_context_gauge(events, ..., quota_model=ca_id,
    quota_rpd_rem=quota_rpd_rem, quota_rpd_lim=quota_rpd_lim, ...)