pipcode 0.0.0-stage → 2.1.0

package/src/core/doctrine.js

@@ -0,0 +1,39 @@
+// src/core/doctrine.js — loadDoctrine : fetch + vérif Ed25519 de core_rules (tier lite, hors quota Pro).
+// Cache RAM TTL 5 h (cache-ttl.js), jamais sur disque. Fail-Fast : signature invalide ou contenu vide → Error.
+import { fetchSignedSkill } from "./doctrine-fetch.js";
+import { verifySignature } from "./crypto.js";
+import { freshCache, isCacheFresh } from "./cache-ttl.js";
+
+/** @type {DoctrineCache | null} */
+let doctrineCache = null;
+
+// Charge la doctrine core_rules (vérifiée Ed25519). Cache RAM TTL 5 h.
+/** @param {PlugConfig} cfg @returns {Promise<string>} */
+export async function loadDoctrine(cfg) {
+  if (isCacheFresh(doctrineCache)) return doctrineCache.content;
+  const payload = await fetchSignedSkill("core_rules", "lite", cfg);
+  if (!verifySignature(payload.data, payload.sig)) {
+    throw new Error(
+      "Signature Ed25519 de la doctrine (core_rules) INVALIDE — payload rejeté. " +
+      "Cause probable : l'ancre de confiance client (PLUGCTO_TRUSTED_PUBLIC_X) ne " +
+      "correspond pas à la clé privée du Worker déployé. Exécuter `npx pipcode setup` " +
+      "pour mettre le client à jour."
+    );
+  }
+  let parsed;
+  try {
+    parsed = /** @type {SkillPayloadContent} */ (JSON.parse(payload.data));
+  } catch {
+    throw new Error("Doctrine (core_rules) : payload signé valide mais données illisibles.");
+  }
+  const content = typeof parsed.content === "string" ? parsed.content : "";
+  if (!content.trim()) throw new Error("Doctrine (core_rules) vide.");
+  doctrineCache = freshCache(content);
+  return content;
+}
+
+// Test-only : réinitialise le cache core_rules.
+export function resetDoctrineCache() {
+  doctrineCache = null;
+}
+// MODULE_COMPLETE

package/src/core/dual-stream-parser.js

@@ -0,0 +1,55 @@
+// src/core/dual-stream-parser.js — Parser de flux à DEUX ÉTATS : THINKING (raisonnement : champ dédié ou <think>…</think>) et PAYLOAD
+// (réponse). Le raisonnement ne touche JAMAIS le tampon de la réponse : il sert à la télémétrie (ligne de statut), pas au JSON extrait.
+// Balises coupées entre deux morceaux gérées ; « </think> » seul (modèle dont l'ouverture est dans son gabarit) accepté ; non fermé = fin en THINKING.
+
+export const THINKING = "THINKING";
+export const PAYLOAD = "PAYLOAD";
+const OPENS = ["<think>", "<thinking>"];
+const CLOSES = ["</think>", "</thinking>"];
+
+/** @param {string} s @param {string[]} tags @returns {{ at: number, len: number } | null} première balise rencontrée */
+function firstTag(s, tags) {
+  /** @type {{ at: number, len: number } | null} */ let best = null;
+  for (const t of tags) { const at = s.indexOf(t); if (at !== -1 && (!best || at < best.at)) best = { at, len: t.length }; }
+  return best;
+}
+
+/** Longueur de la fin de `s` qui pourrait être le début d'une des balises (à garder pour le prochain morceau). @param {string} s @param {string[]} tags @returns {number} */
+function heldTail(s, tags) {
+  for (let n = Math.min(s.length, 11); n > 0; n--) if (tags.some((t) => t.startsWith(s.slice(-n)) && t !== s.slice(-n))) return n;
+  return 0;
+}
+
+export class DualStreamTokenParser {
+  constructor() { this.state = PAYLOAD; this.thinking = ""; this.payload = ""; this.held = ""; this.inTag = false; }
+
+  /** Jetons de raisonnement d'un champ dédié (reasoning_content / thinking). @param {string} text */
+  reason(text) { if (text) { this.thinking += text; this.state = THINKING; } }
+
+  /** Jetons de contenu : texte de réponse, éventuellement entrecoupé de balises de raisonnement. @param {string} text */
+  content(text) {
+    let rest = this.held + text; this.held = "";
+    while (rest) {
+      const tag = firstTag(rest, this.inTag ? CLOSES : [...OPENS, ...CLOSES]);
+      if (!tag) { const keep = heldTail(rest, this.inTag ? CLOSES : [...OPENS, ...CLOSES]); this.#put(rest.slice(0, rest.length - keep)); this.held = rest.slice(rest.length - keep); return; }
+      const closing = CLOSES.some((c) => rest.startsWith(c, tag.at));
+      if (closing && !this.inTag) { this.thinking += this.payload + rest.slice(0, tag.at); this.payload = ""; } else this.#put(rest.slice(0, tag.at));
+      this.inTag = !closing; this.state = closing ? PAYLOAD : THINKING;
+      rest = rest.slice(tag.at + tag.len);
+    }
+  }
+
+  /** @param {string} s */
+  #put(s) { if (this.inTag) { this.thinking += s; return; } this.payload += s; if (s.trim()) this.state = PAYLOAD; }
+
+  /** Fin du flux : le reste retenu est versé là où le parser se trouve. @returns {{ thinking: string, payload: string, state: string }} */
+  end() { this.#put(this.held); this.held = ""; return { thinking: this.thinking, payload: this.payload, state: this.inTag ? THINKING : this.state }; }
+}
+
+/** Texte complet → réponse SANS raisonnement. @param {string} text @returns {string} */
+export function stripReasoning(text) {
+  const p = new DualStreamTokenParser();
+  p.content(String(text ?? ""));
+  return p.end().payload.trim();
+}
+// MODULE_COMPLETE

package/src/core/exports.js

@@ -0,0 +1,28 @@
+// src/core/exports.js — Surface publique du domaine core : agrégation des
+// re-exports consommés par les tests via le hub index.js.
+export { readProviderConfig } from "./llm-config.js";
+export { extractLLMText } from "./llm-extract.js";
+export { callLLM } from "./llm-call.js";
+export { RATE_LIMIT_MESSAGE, isRateLimit, friendlyError } from "./llm-errors.js";
+export { warmupCache } from "./llm-warmup.js";
+export { PROVIDER_DEFAULTS } from "./llm-providers.js";
+export { patchMaxTokens, ANALYSIS_MAX_TOKENS } from "./constants.js";
+export { verifySessionToken } from "./session.js";
+export { ensureSession, requestSession, purgeSessionCache } from "./session-net.js";
+export { ensureTrialSession, requestTrialSession, purgeTrialCache } from "./trial-session.js";
+export { resolveTrialOrLite } from "./trial-resolve.js";
+export { resolveSessionResilient } from "./session-resilient.js";
+export { purgeLicenseKey } from "./purge-key.js";
+export { isCacheFresh, DOCTRINE_TTL_MS } from "./cache-ttl.js";
+export { machineFp } from "./identity.js";
+export { verifySignature, resolveTrustAnchor } from "./crypto.js";
+export { normalizeText, scanForLeak, extractFingerprints } from "./dlp.js";
+export { isValidToolName } from "./manifest.js";
+export { loadConfig } from "./config.js";
+export { resolveTier, isWithinTrial, maybeTrialExpiredNotice } from "./tier.js";
+export { loadDoctrine } from "./doctrine.js";
+export { loadAllDoctrine } from "./doctrine-all.js";
+export { __resetDoctrineCachesForTest } from "./doctrine-caches.js";
+export { fetchSignedSkill } from "./doctrine-fetch.js";
+export { buildMasterPrompt } from "./master-prompt.js";
+// MODULE_COMPLETE

package/src/core/google-route.js

@@ -0,0 +1,17 @@
+// src/core/google-route.js — Tout appel vers Google (generativelanguage.googleapis.com) passe par l'API REST NATIVE : adaptateur « gemini », route
+// /v1beta/models/<id>:generateContent, clé dans l'en-tête x-goog-api-key (jamais Authorization: Bearer, que le service natif refuse en 401).
+// Une configuration qui pointe encore vers l'adresse « compatible OpenAI » (/v1beta/openai) ou vers /v1 est ramenée à la route native /v1beta.
+
+export const GOOGLE_HOST = "generativelanguage.googleapis.com";
+export const GOOGLE_NATIVE_BASE = `https://${GOOGLE_HOST}/v1beta`;
+
+/** @param {string} base @returns {boolean} */
+export function isGoogleBase(base) {
+  try { return new URL(String(base)).hostname === GOOGLE_HOST; } catch { return false; } // adresse illisible : pas Google
+}
+
+/** @param {string} provider @param {string} base @returns {{ provider: string, base: string }} */
+export function routeGoogle(provider, base) {
+  return isGoogleBase(base) ? { provider: "gemini", base: GOOGLE_NATIVE_BASE } : { provider, base };
+}
+// MODULE_COMPLETE

package/src/core/identity.js

@@ -0,0 +1,23 @@
+// src/core/identity.js — Empreinte machine stable (anti-rotation IP de l'essai, B1).
+// Calculée depuis des identifiants OS stables (hostname, utilisateur, platform, arch) :
+// survit aux changements d'IP (VPN/DHCP) et redémarrages, diffère par machine/compte.
+// Hashée SHA-256 (anonyme : aucune donnée OS lisible n'est envoyée). Côté serveur,
+// l'essai Pro est bindé à cette empreinte (et non à l'IP). Cache vie-du-process.
+
+import os from "node:os";
+import crypto from "node:crypto";
+
+/** @type {string | null} */
+let _machineFpCache = null;
+
+// Empreinte machine SHA-256 (base64url). Stable par machine/compte, anonyme.
+/** @returns {string} */
+export function machineFp() {
+  if (_machineFpCache) return _machineFpCache;
+  let username = "";
+  try { username = (os.userInfo && os.userInfo().username) || ""; } catch { username = ""; }
+  const parts = [os.hostname() || "", username, os.platform() || "", os.arch() || ""];
+  _machineFpCache = crypto.createHash("sha256").update(parts.join("|")).digest("base64url");
+  return _machineFpCache;
+}
+// MODULE_COMPLETE

package/src/core/lang.js

@@ -0,0 +1,19 @@
+// src/core/lang.js — Consigne de LANGUE injectée dans les prompts qui produisent du texte lu par l'utilisateur (chat,
+// extraction de mission, analyse). La langue vient de l'extension (PLUGCTO_LANG = langue d'affichage de VS Code) ;
+// valeur absente ou hors forme BCP 47 → aucune consigne (jamais de texte construit à partir d'une entrée non validée).
+// Les prompts à format machine (diff, décomposition JSON, verdict) n'en reçoivent pas.
+
+const LANG_RE = /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,3}$/;
+
+/** @param {NodeJS.ProcessEnv} [env] @returns {string} */
+export function languageDirective(env = process.env) {
+  const code = String(env.PLUGCTO_LANG || "").trim();
+  return LANG_RE.test(code) ? `Formule l'intégralité de tes réponses et analyses dans la langue du système (${code}).` : "";
+}
+
+/** Prompt système + consigne de langue (préfixe stable par langue : le cache de prompt reste valide). @param {string} systemPrompt @param {NodeJS.ProcessEnv} [env] @returns {string} */
+export function withLanguage(systemPrompt, env = process.env) {
+  const d = languageDirective(env);
+  return d ? `${systemPrompt}\n\n${d}` : systemPrompt;
+}
+// MODULE_COMPLETE

package/src/core/leak-guard.js

@@ -0,0 +1,40 @@
+// src/core/leak-guard.js — Garde anti-fuite : une ligne de réponse qui recopie 8 mots consécutifs d'un texte CONFIDENTIEL (règles, doctrine, protocole servis
+// par le serveur) est remplacée par une mention neutre, AVANT affichage (flux compris : sortie ligne par ligne). Complète la consigne de confidentialité
+// du prompt : une paraphrase passe, une récitation non. Pur ; sans secret (liste vide) → aucun effet, aucune mise en tampon.
+
+const SPAN = 8;
+export const REDACTED = "[Contenu interne PipCode non détaillé.]";
+
+/** @param {string} s @returns {string[]} */
+const words = (s) => s.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").split(" ").filter(Boolean);
+
+export class LeakGuard {
+  /** @param {string[]} secrets textes confidentiels transmis au modèle */
+  constructor(secrets) {
+    /** @type {Set<string>} */ this.known = new Set();
+    for (const text of secrets) { const w = words(text); for (let i = 0; i + SPAN <= w.length; i++) this.known.add(w.slice(i, i + SPAN).join(" ")); }
+    this.buf = "";
+  }
+
+  /** @param {string} line @returns {string} */
+  #line(line) {
+    const w = words(line);
+    for (let i = 0; i + SPAN <= w.length; i++) if (this.known.has(w.slice(i, i + SPAN).join(" "))) return REDACTED;
+    return line;
+  }
+
+  /** Texte complet (réponse finale, raisonnement compris). @param {string} text @returns {string} */
+  sanitize(text) { return this.known.size ? text.split("\n").map((l) => this.#line(l)).join("\n") : text; }
+
+  /** Flux : ne rend que des lignes COMPLÈTES, contrôlées. @param {string} chunk @returns {string} */
+  push(chunk) {
+    if (!this.known.size) return chunk;
+    const parts = (this.buf + chunk).split("\n");
+    this.buf = parts.pop() ?? "";
+    return parts.map((l) => this.#line(l) + "\n").join("");
+  }
+
+  /** Fin du flux : dernière ligne incomplète contrôlée. @returns {string} */
+  end() { const rest = this.buf; this.buf = ""; return rest ? this.#line(rest) : ""; }
+}
+// MODULE_COMPLETE

package/src/core/llm-builder-anthropic.js

@@ -0,0 +1,26 @@
+// src/core/llm-builder-anthropic.js — Builder de requête Anthropic (messages +
+// cache_control ephemeral sur le préfixe stable). Scission de llm-request.js.
+
+/** @param {import("./llm-request.js").LLMParams} p @returns {{ url: string, init: RequestInit }} */
+export function buildAnthropicStyle(p) {
+  const systemBlocks = [{ type: "text", text: p.systemPrompt, cache_control: { type: "ephemeral" } }];
+  const userContent = p.stablePrefix
+    ? [{ type: "text", text: p.stablePrefix, cache_control: { type: "ephemeral" } }, { type: "text", text: p.userText }]
+    : p.userText;
+  return {
+    url: `${p.base}/messages`,
+    init: {
+      method: "POST",
+      signal: p.signal,
+      headers: { "Content-Type": "application/json", "x-api-key": p.key, "anthropic-version": "2023-06-01" },
+      body: JSON.stringify({
+        model: p.model,
+        max_tokens: p.budget,
+        ...(p.stream ? { stream: true } : {}),
+        system: systemBlocks,
+        messages: [{ role: "user", content: userContent }],
+      }),
+    },
+  };
+}
+// MODULE_COMPLETE

package/src/core/llm-builder-gemini.js

@@ -0,0 +1,22 @@
+// src/core/llm-builder-gemini.js — Builder de requête Gemini (generateContent).
+// Scission de llm-request.js (audit hebdo) : un builder par famille de provider.
+import { isReasoningModel } from "./reasoning-models.js";
+import { sanitizeGeminiModelId } from "./model-id.js";
+
+/** @param {import("./llm-request.js").LLMParams} p @returns {{ url: string, init: RequestInit }} */
+export function buildGeminiStyle(p) {
+  return {
+    url: `${p.base.replace(/\/+$/, "")}/models/${encodeURIComponent(sanitizeGeminiModelId(p.model))}${p.stream ? ":streamGenerateContent?alt=sse" : ":generateContent"}`, // « : » LITTÉRAL (encodé en %3A = 404) ; le segment /models/ est celui de la route, le préfixe de l'identifiant est retiré
+    init: {
+      method: "POST",
+      signal: p.signal,
+      headers: { "Content-Type": "application/json", "x-goog-api-key": p.key },
+      body: JSON.stringify({
+        system_instruction: { parts: [{ text: p.systemPrompt }] },
+        contents: [{ role: "user", parts: [{ text: p.stablePrefix ? p.stablePrefix + "\n" + p.userText : p.userText }] }],
+        generationConfig: p.unbounded || isReasoningModel(p.model) ? {} : { maxOutputTokens: p.budget }, // Gemini 2.5/3 : la réflexion compte dans la limite → aucune limite
+      }),
+    },
+  };
+}
+// MODULE_COMPLETE

package/src/core/llm-builder-openai.js

@@ -0,0 +1,26 @@
+// src/core/llm-builder-openai.js — Builder de requête OpenAI/Zhipu (chat/completions).
+// Scission de llm-request.js (audit hebdo) : un builder par famille de provider.
+
+import { isReasoningModel } from "./reasoning-models.js";
+
+/** @param {import("./llm-request.js").LLMParams} p @returns {{ url: string, init: RequestInit }} */
+export function buildOpenAIStyle(p) {
+  return {
+    url: `${p.base}/chat/completions`,
+    init: {
+      method: "POST",
+      signal: p.signal,
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${p.key}` },
+      body: JSON.stringify({
+        model: p.model,
+        ...(p.unbounded || isReasoningModel(p.model) ? {} : { max_tokens: p.budget }), // modèle à raisonnement : AUCUNE limite (il s'arrête seul sur son jeton de fin)
+        ...(p.stream ? { stream: true, stream_options: { include_usage: true } } : {}), // flux SSE (+ usage réel dans le dernier morceau)
+        messages: [
+          { role: "system", content: p.systemPrompt },
+          { role: "user", content: p.stablePrefix ? p.stablePrefix + "\n" + p.userText : p.userText },
+        ],
+      }),
+    },
+  };
+}
+// MODULE_COMPLETE

package/src/core/llm-call.js

@@ -0,0 +1,53 @@
+// src/core/llm-call.js — callLLM : adaptateur d'API unifié (OpenAI/Anthropic/Gemini/Zhipu).
+// Budget max_tokens dynamique (Token Saver), timeout AbortController, Error enrichie (status/provider).
+import { DEFAULT_MAX_TOKENS } from "./constants.js";
+import { providerLabel, timeoutFor } from "./llm-label.js";
+import { ipv4Loopback } from "../net/loopback.js";
+import { exchangeUnbounded } from "./llm-unbounded.js";
+import { retryOn429 } from "./llm-retry-429.js";
+import { sanitizeModelId } from "./model-id.js";
+import { emitProgress } from "./progress-emit.js";
+import { isRunAborted, linkAbort, RunAbortedError } from "./abort-signal.js";
+import { stripReasoning } from "./dual-stream-parser.js";
+
+// Appelle un provider compatible OpenAI/Anthropic/Gemini/Zhipu. Retourne le texte généré ou jette.
+/** @param {CallLLMArgs} { provider, key, model, base, systemPrompt, userText, cachePrefix, maxTokens } @returns {Promise<string>} */
+export async function callLLM({ provider, key, model: rawModel, base: rawBase, systemPrompt, userText, cachePrefix, maxTokens, showThinking, onDelta }) {
+  const base = ipv4Loopback(String(rawBase || "")); // localhost → 127.0.0.1 (IPv4 strict)
+  const model = sanitizeModelId(base, rawModel); // dernier point avant toute requête : « models/x » → « x » chez Google
+  if (provider && key && base && !model) {
+    throw new Error(`Aucun modèle configuré pour ${provider} : choisissez un modèle dans les réglages de PipCode (aucune requête envoyée).`);
+  }
+  if (!provider || !key || !model || !base) {
+    throw new Error("Configuration provider incomplète (provider/key/model/base).");
+  }
+  const requested = (Number.isFinite(maxTokens) && (/** @type {number} */ (maxTokens)) > 0)
+    ? Math.min(DEFAULT_MAX_TOKENS, Math.round(/** @type {number} */ (maxTokens)))
+    : DEFAULT_MAX_TOKENS;
+  const budget = requested; // modèle à raisonnement : cette valeur n'est PAS envoyée (unbounded)
+  const stablePrefix = cachePrefix ? String(cachePrefix) : "";
+  if (isRunAborted()) throw new RunAbortedError(); // arrêt déjà demandé : aucune requête ne part
+  const controller = new AbortController();
+  linkAbort(controller); // « Stop » de l'interface : la requête en cours est annulée
+  const timeoutMs = timeoutFor(base);
+  const label = providerLabel(provider, base);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    emitProgress({ k: "tick" }); // signe de vie : l'interface sait que le moteur travaille (délai d'inactivité)
+    const text = await retryOn429(() => exchangeUnbounded({ provider, key, model, base, budget, systemPrompt, userText, stablePrefix, signal: controller.signal, label, showThinking, onDelta })); // 429 : 3 essais, délai exponentiel
+    emitProgress({ k: "tick" });
+    return showThinking ? text : stripReasoning(text); // le raisonnement n'entre jamais dans un texte analysé (JSON, diff, verdict)
+  } catch (err) {
+    const e0 = /** @type {EnrichedError} */ (err);
+    if (isRunAborted()) throw new RunAbortedError(); // arrêt voulu : ni « délai dépassé » ni panne
+    if (e0 && e0.name === "AbortError") {
+      const e = /** @type {EnrichedError} */ (new Error(`Délai dépassé (${Math.round(timeoutMs / 1000)} s) : ${label} n'a pas répondu (modèle ${model}).`));
+      e.provider = provider;
+      throw e;
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+// MODULE_COMPLETE

package/src/core/llm-config-secondary.js

@@ -0,0 +1,28 @@
+// src/core/llm-config-secondary.js — readSecondaryProvider : provider cloud
+// SECONDAIRE optionnel (bascule BYOK conditionnelle du routage hybride). Même
+// schéma que le primaire, préfixe PLUGCTO_PROVIDER_SECONDARY. Zéro secret en dur.
+
+import { PROVIDER_DEFAULTS, isValidProvider } from "./llm-providers.js";
+import { ipv4Loopback } from "../net/loopback.js";
+
+// Retourne { secondary } = { provider, key, model, base, smartModel, fastModel }
+// ou { secondary: null } si absent/incomplet. Accepte un env explicite (tests).
+/** @param {Record<string, string | undefined>} [env] @returns {{ secondary: ProviderPrimary | null }} */
+export function readSecondaryProvider(env = process.env) {
+  const provider = (env.PLUGCTO_PROVIDER_SECONDARY || "").toLowerCase();
+  if (!isValidProvider(provider)) return { secondary: null };
+  const key = env.PLUGCTO_PROVIDER_SECONDARY_KEY || "";
+  if (!key) return { secondary: null };
+  const d = PROVIDER_DEFAULTS[provider];
+  const base = ipv4Loopback(env.PLUGCTO_PROVIDER_SECONDARY_BASE || d.base);
+  const mainModel = (env.PLUGCTO_PROVIDER_SECONDARY_MODEL || "").trim(); // exact, jamais de modèle par défaut
+  const fast = (env.PLUGCTO_PROVIDER_SECONDARY_FAST_MODEL || "").trim() || mainModel;
+  return {
+    secondary: {
+      provider: /** @type {ProviderName} */ (provider),
+      key, base,
+      model: mainModel, smartModel: mainModel, fastModel: fast,
+    },
+  };
+}
+// MODULE_COMPLETE

package/src/core/llm-config.js

@@ -0,0 +1,32 @@
+// src/core/llm-config.js — readProviderConfig : lit la config provider depuis l'env (single-key strict).
+// API_KEY alias de PLUGCTO_PROVIDER_PRIMARY_KEY. Fallback OLLAMA_HOST normalisé /v1.
+import { PROVIDER_DEFAULTS, isValidProvider, normalizeOllamaBase } from "./llm-providers.js";
+import { ipv4Loopback } from "../net/loopback.js";
+
+// Retourne { primary } = { provider, key, model, base, smartModel, fastModel } ou null si incomplet.
+// Accepte un env explicite (tests) ; défaut = process.env. smart_model = modèle principal, fast = variante légère.
+/** @param {Record<string, string | undefined>} [env] @returns {{ primary: ProviderPrimary | null }} */
+export function readProviderConfig(env = process.env) {
+  const provider = (env.PLUGCTO_PROVIDER_PRIMARY || "").toLowerCase();
+  if (!isValidProvider(provider)) return { primary: null };
+  const key = env.PLUGCTO_PROVIDER_PRIMARY_KEY || env.API_KEY || "";
+  if (!key) return { primary: null };
+  const d = PROVIDER_DEFAULTS[provider];
+  const explicitBase = env.PLUGCTO_PROVIDER_PRIMARY_BASE;
+  const base = ipv4Loopback(explicitBase
+    || (provider === "openai" && env.OLLAMA_HOST ? normalizeOllamaBase(env.OLLAMA_HOST) : d.base)); // OLLAMA_HOST ne concerne QUE l'adaptateur openai ; localhost → 127.0.0.1
+  const mainModel = (env.PLUGCTO_PROVIDER_PRIMARY_MODEL || "").trim(); // exact, jamais de modèle par défaut (vide : erreur explicite à l'appel)
+  const smartModel = (env.PLUGCTO_SMART_MODEL || "").trim() || mainModel;
+  const fastModel = (env.PLUGCTO_FAST_MODEL || "").trim() || smartModel;
+  return {
+    primary: {
+      provider: /** @type {ProviderName} */ (provider),
+      key,
+      base,
+      model: smartModel,
+      smartModel,
+      fastModel,
+    },
+  };
+}
+// MODULE_COMPLETE

package/src/core/llm-errors.js

@@ -0,0 +1,25 @@
+// src/core/llm-errors.js — Erreurs LLM user-friendly (Complexity Hiding) :
+// message unique, clair et rassurant pour le HTTP 429 (quota du fournisseur —
+// clé utilisée simultanément par plusieurs outils). Zéro jargon, zéro stack
+// trace, zéro objet d'erreur JSON. Générique : TOUS les providers passent par
+// parseLLMResponse (llm-extract.js), point d'étranglement unique.
+
+/** Message utilisateur affiché en cas de refus de quota HTTP 429. */
+export const RATE_LIMIT_MESSAGE =
+  "⏳ Limite de requêtes atteinte par votre fournisseur (trop d'IA sollicitées en même temps). Veuillez patienter quelques secondes.";
+
+/** Vrai si l'erreur (enrichie par parseLLMResponse) est un refus de quota 429. */
+/** @param {unknown} e @returns {boolean} */
+export function isRateLimit(e) {
+  if (!e || typeof e !== "object") return false;
+  return (/** @type {{ status?: unknown }} */ (e)).status === 429;
+}
+
+/** Message à montrer à l'utilisateur : friendly si 429, sinon message nettoyé. */
+/** @param {unknown} e @returns {string} */
+export function friendlyError(e) {
+  if (isRateLimit(e)) return RATE_LIMIT_MESSAGE;
+  if (e && typeof e === "object") return String((/** @type {{ message?: unknown }} */ (e)).message || "Erreur inconnue.");
+  return "Erreur inconnue.";
+}
+// MODULE_COMPLETE

package/src/core/llm-exchange.js

@@ -0,0 +1,27 @@
+// src/core/llm-exchange.js — UN échange avec le fournisseur : Ollama → API native en streaming (llm-ollama) ; autre serveur local →
+// transport IPv4 keepAlive ; cloud → fetch. Le texte généré est retourné, l'usage réel relevé. Erreurs nommées au bon fournisseur.
+
+import { isLocalBase } from "./llm-label.js";
+import { localFetch } from "../net/local-fetch.js";
+import { buildLLMRequest } from "./llm-request.js";
+import { parseLLMResponse } from "./llm-extract.js";
+import { recordUsage } from "./usage-meter.js";
+import { exchangeOllama } from "./llm-ollama.js";
+import { isOllamaBase, isOllamaCloudBase } from "./ollama.js";
+import { routeGoogle } from "./google-route.js";
+import { exchangeStream } from "./llm-stream.js";
+
+/** @param {{ provider: string, key: string, model: string, base: string, budget: number, unbounded?: boolean, systemPrompt: string, userText: string, stablePrefix: string, signal: AbortSignal, label: string, showThinking?: boolean, onDelta?: (text: string) => void }} input @returns {Promise<string>} */
+export async function exchange(input) {
+  const p = { ...input, ...routeGoogle(input.provider, input.base) }; // Google : toujours l'API REST native (gemini, /v1beta, x-goog-api-key)
+  if (isOllamaBase(p.base)) return exchangeOllama(p);
+  if (isOllamaCloudBase(p.base)) return exchangeOllama({ ...p, cloud: true }); // service distinct : clé API, API native HTTPS
+  if (p.onDelta) return exchangeStream(/** @type {Parameters<typeof exchangeStream>[0]} */ (p)); // affichage jeton par jeton (chat)
+  const { url, init } = buildLLMRequest(p.provider, p);
+  const res = /** @type {Response} */ (/** @type {unknown} */ (await (isLocalBase(p.base) ? localFetch : fetch)(url, init)));
+  const body = await res.text();
+  const text = parseLLMResponse(p.provider, p.model, res, body, p.label, url); // url : route exacte citée dans les erreurs
+  recordUsage(p.provider, p.model, p.base, body); // usage RÉEL rapporté par l'API (réponse réussie seulement)
+  return text;
+}
+// MODULE_COMPLETE

package/src/core/llm-extract.js

@@ -0,0 +1,52 @@
+// src/core/llm-extract.js — extraction du texte réponse LLM + parsing HTTP (status/erreur/vide).
+// Schémas hétérogènes : OpenAI/Zhipu (choices), Anthropic (content blocks), Gemini (candidates).
+// HTTP 429 (quota provider) → message user-friendly unique (llm-errors.js), zéro jargon.
+import { RATE_LIMIT_MESSAGE } from "./llm-errors.js";
+import { cutWhileThinking, thinkingBudgetError } from "./reasoning-cut.js";
+
+// Extrait le texte selon le schéma du provider.
+/** @param {string} provider @param {LLMResponse | null} j @returns {string} */
+export function extractLLMText(provider, j) {
+  if (!j) return "";
+  if (provider === "openai" || provider === "zhipu") {
+    return j.choices?.[0]?.message?.content ?? "";
+  }
+  if (provider === "anthropic") {
+    const blocks = Array.isArray(j.content) ? j.content : [];
+    return blocks.filter((b) => b && b.type === "text").map((b) => b.text).join("\n");
+  }
+  if (provider === "gemini") {
+    const parts = j.candidates?.[0]?.content?.parts; // Gemini 2.5 : plusieurs parties possibles, celles de « réflexion » exclues
+    return Array.isArray(parts) ? parts.filter((x) => x && !x.thought && typeof x.text === "string").map((x) => x.text).join("") : "";
+  }
+  return "";
+}
+
+// Parse la réponse HTTP : jette une Error enrichie (status/provider) si !ok ou vide.
+/** @param {string} provider @param {string} model @param {Response} res @param {string} bodyText @param {string} [label] fournisseur réellement appelé (adresse), pour les messages @returns {string} */
+export function parseLLMResponse(provider, model, res, bodyText, label = provider, url = "") {
+  let parsed = null;
+  try { parsed = /** @type {LLMResponse | LLMErrorResponse | null} */ (JSON.parse(bodyText)); } catch { /* corps non-JSON : parsed reste null */ }
+  if (!res.ok) {
+    // Quota provider (429) : message clair et rassurant, JAMAIS le JSON brut du
+    // fournisseur ni un code HTTP (Complexity Hiding) — générique, tout provider.
+    if (res.status === 429) {
+      const rl = /** @type {EnrichedError} */ (new Error(RATE_LIMIT_MESSAGE));
+      rl.status = res.status;
+      rl.provider = provider;
+      throw rl;
+    }
+    const apiMsg = parsed && (/** @type {LLMErrorResponse} */ (parsed).error?.message || /** @type {LLMErrorResponse} */ (parsed).message);
+    const route = url ? ` — URL : ${String(url).split("?")[0]}` : ""; // route exacte appelée (sans paramètres : jamais de clé dans un message)
+    const err = /** @type {EnrichedError} */ (new Error(`${apiMsg || `HTTP ${res.status} de ${label} (modèle ${model})`}${route}`));
+    err.status = res.status;
+    err.provider = provider;
+    throw err;
+  }
+  const txt = extractLLMText(provider, /** @type {LLMResponse | null} */ (parsed));
+  if (typeof txt !== "string" || !txt.trim()) {
+    throw cutWhileThinking(parsed) ? thinkingBudgetError(`${label}, modèle ${model}`) : new Error(`Réponse vide de ${label} (modèle ${model}).`);
+  }
+  return txt;
+}
+// MODULE_COMPLETE

package/src/core/llm-label.js

@@ -0,0 +1,33 @@
+// src/core/llm-label.js — Libellé HONNÊTE du fournisseur dans les messages d'erreur (l'adaptateur « openai » sert aussi Ollama,
+// Gemini, OpenRouter… : afficher « openai » trompait) + délai adapté (modèle local = chargement à froid long). Pur.
+
+import { LLM_TIMEOUT_MS, LLM_LOCAL_TOTAL_MS } from "./constants.js";
+
+/** @type {Array<[RegExp, string]>} */
+const KNOWN = [[/(^|\.)openrouter\.ai$/, "OpenRouter"], [/(^|\.)generativelanguage\.googleapis\.com$/, "Google Gemini"], [/(^|\.)api\.openai\.com$/, "OpenAI"],
+  [/(^|\.)anthropic\.com$/, "Anthropic"], [/(^|\.)groq\.com$/, "Groq"], [/(^|\.)bigmodel\.cn$/, "Zhipu"], [/^(www\.)?ollama\.com$/, "Ollama Cloud"]];
+const LOOPBACK = /^(localhost|127\.\d+\.\d+\.\d+|\[?::1\]?|0\.0\.0\.0)$/;
+
+/** @param {string} base @returns {URL | null} */
+function parse(base) {
+  try { return new URL(base); } catch { return null; } // adresse illisible : libellé de repli
+}
+
+/** Serveur local (boucle locale) : Ollama, LM Studio… @param {string} base @returns {boolean} */
+export function isLocalBase(base) {
+  const u = parse(base);
+  return !!u && LOOPBACK.test(u.hostname);
+}
+
+/** « Ollama (localhost:11434) », « Google Gemini », « OpenRouter »… selon l'ADRESSE réellement appelée. @param {string} provider @param {string} base @returns {string} */
+export function providerLabel(provider, base) {
+  const u = parse(base);
+  if (!u) return provider;
+  if (LOOPBACK.test(u.hostname)) return u.port === "11434" ? `Ollama (${u.host})` : `serveur local (${u.host})`;
+  const known = KNOWN.find(([re]) => re.test(u.hostname));
+  return known ? known[1] : u.host;
+}
+
+/** Délai d'attente : long pour un modèle local (chargement à froid), standard pour le cloud. @param {string} base @returns {number} */
+export const timeoutFor = (base) => (isLocalBase(base) || providerLabel("", base) === "Ollama Cloud" ? LLM_LOCAL_TOTAL_MS : LLM_TIMEOUT_MS); // génération en streaming : durée totale longue
+// MODULE_COMPLETE

package/src/core/llm-ollama-request.js

@@ -0,0 +1,32 @@
+// src/core/llm-ollama-request.js — Requête native Ollama /api/chat (streaming). Modèle à RAISONNEMENT (ou rejeu sans limite) : AUCUNE limite de
+// sortie envoyée (pas de num_predict) — le modèle s'arrête seul sur son jeton de fin. Les autres gardent le budget demandé ; seul le chat LOCAL
+// conserve un plafond de latence (2048). Pour un modèle local, CTX_RESERVE DIMENSIONNE la fenêtre (num_ctx), il n'est jamais envoyé comme limite.
+import { numCtxFor, ollamaRoot } from "./ollama.js";
+import { isReasoningModel } from "./reasoning-models.js";
+
+const LOCAL_CHAT_CAP = 2048;
+const CTX_RESERVE = 16384;
+
+/** @param {{ model: string, unbounded?: boolean }} p @returns {boolean} */
+export const unboundedFor = (p) => p.unbounded === true || isReasoningModel(p.model);
+
+/** @param {{ model: string, unbounded?: boolean, budget: number, cloud?: boolean, showThinking?: boolean, systemPrompt: string }} p @param {string} user @returns {{ num_ctx?: number, num_predict?: number }} */
+function optionsFor(p, user) {
+  const predict = unboundedFor(p) ? undefined : p.cloud || !p.showThinking ? p.budget : Math.min(p.budget, LOCAL_CHAT_CAP);
+  /** @type {{ num_predict?: number }} */ const limit = {};
+  if (predict !== undefined) limit.num_predict = predict; // absent = aucune limite
+  return p.cloud ? limit : { num_ctx: numCtxFor(p.systemPrompt.length + user.length, predict ?? CTX_RESERVE), ...limit };
+}
+
+/** @param {{ base: string, key?: string, cloud?: boolean, showThinking?: boolean, unbounded?: boolean, model: string, budget: number, systemPrompt: string, userText: string, stablePrefix: string, signal: AbortSignal }} p */
+export function buildOllamaRequest(p) {
+  const user = p.stablePrefix ? `${p.stablePrefix}\n${p.userText}` : p.userText;
+  return {
+    url: `${ollamaRoot(p.base)}/api/chat`,
+    init: {
+      method: "POST", signal: p.signal, headers: { "Content-Type": "application/json", ...(p.cloud && p.key ? { Authorization: `Bearer ${p.key}` } : {}) },
+      body: JSON.stringify({ model: p.model, stream: true, messages: [{ role: "system", content: p.systemPrompt }, { role: "user", content: user }], options: optionsFor(p, user) }),
+    },
+  };
+}
+// MODULE_COMPLETE