avantgate 1.0.0 → 1.1.0

package/dist/index.js

@@ -22,6 +22,9 @@ var index_exports = {};
 __export(index_exports, {
   AvantGateControlLayer: () => AvantGateControlLayer,
   DEFAULT_MODEL_PRICES: () => DEFAULT_MODEL_PRICES,
+  PromptBuilder: () => PromptBuilder,
+  PromptRegistry: () => PromptRegistry,
+  PromptTemplate: () => PromptTemplate,
   ZenLLMControlLayer: () => AvantGateControlLayer,
   calculateCostUSD: () => calculateCostUSD,
   createAvantGate: () => createAvantGate,
@@ -84,8 +87,11 @@ function calculateCostUSD(model, promptTokens, completionTokens, cacheHitTokens
 // src/sanitizer.ts
 var EMAIL_REGEX = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b/g;
 var PHONE_FR_REGEX = /\b(?:(?:\+|00)33|0)\s*[1-9](?:[\s.-]*\d{2}){4}\b/g;
-var NIR_SSN_REGEX = /\b[12]\s*\d{2}\s*\d{2}\s*\d{2}\s*\d{3}\s*\d{3}(?:\s*\d{2})?\b/g;
-var IBAN_REGEX = /\b[A-Z]{2}\d{2}[A-Z0-9]{4}\d{7}([A-Z0-9]?){0,16}\b/g;
+var NIR_SSN_REGEX = /\b[12]\s*\d{2}\s*(?:0[1-9]|1[0-2]|[2-9]\d)\s*(?:0[1-9]|[1-8]\d|9[0-8]|2[ABab])\s*(?!000)\d{3}\s*(?!000)\d{3}(?:\s*\d{2})?\b/g;
+var SPI_LABELLED_REGEX = /(?:(?:num[ée]ro\s+fiscal|spi|n[°o]\s*fiscal|d[ée]clarant(?: fiscal)?)\s*[:=]?\s*)\b(\d{2}(?:[\s.-]?\d{2}){5}[\s.-]?\d|\d{13})\b/gi;
+var SPI_FORMATTED_REGEX = /\b[0-3]\d(?:\s+\d{2}){5}\s+\d\b/g;
+var IBAN_REGEX = /\b[A-Z]{2}\s*[0-9]{2}(?:[\s\r\n.-]*[A-Z0-9]){11,30}\b/g;
+var BIC_LABELLED_REGEX = /(?:(?:bic|swift)\s*[:=]?\s*)\b([A-Z]{4}[A-Z]{2}[A-Z0-9]{2}(?:[A-Z0-9]{3})?)\b/gi;
 function sanitizePII(input) {
   let count = 0;
   let result = input;
@@ -97,13 +103,36 @@ function sanitizePII(input) {
     count++;
     return "[REDACTED_PHONE]";
   });
-  result = result.replace(NIR_SSN_REGEX, () => {
+  result = result.replace(IBAN_REGEX, (match) => {
+    const cleanChars = match.replace(/[\s\r\n.-]/g, "");
+    if (cleanChars.length >= 15 && cleanChars.length <= 34) {
+      count++;
+      return "[REDACTED_IBAN]";
+    }
+    return match;
+  });
+  result = result.replace(BIC_LABELLED_REGEX, (_, bicCode) => {
     count++;
-    return "[REDACTED_NIR]";
+    return `[REDACTED_BIC: ${bicCode.slice(0, 4)}****]`;
   });
-  result = result.replace(IBAN_REGEX, () => {
+  result = result.replace(SPI_LABELLED_REGEX, (fullMatch, digits) => {
     count++;
-    return "[REDACTED_IBAN]";
+    return fullMatch.replace(digits, "[REDACTED_SPI]");
+  });
+  result = result.replace(NIR_SSN_REGEX, (match) => {
+    const rawDigits = match.replace(/\s+/g, "");
+    if (rawDigits.length === 13 || rawDigits.length === 15) {
+      count++;
+      return "[REDACTED_NIR]";
+    }
+    return match;
+  });
+  result = result.replace(SPI_FORMATTED_REGEX, (match) => {
+    if (!match.includes("[REDACTED")) {
+      count++;
+      return "[REDACTED_SPI]";
+    }
+    return match;
   });
   return { text: result, maskedCount: count };
 }
@@ -138,6 +167,469 @@ function validateUserInput(input, options) {
   return { valid: true };
 }
 
+// src/finance/strategies/french-pcg.strategy.ts
+var FrenchPCGStrategy = class {
+  jurisdictionCode = "FR";
+  standard = "PCG";
+  defaultCurrency = "EUR";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^\(\s*(.+?)\s*\)$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK](?:€|eur)?\b/i.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK](?:€|eur)?\b/gi, "").trim();
+    } else if (/[mM](?:€|eur)?\b/i.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM](?:€|eur)?\b/gi, "").trim();
+    }
+    str = str.replace(/[€$£]/g, "").replace(/\s+/g, "").replace(/\u00A0/g, "").trim();
+    str = str.replace(",", ".");
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalValue = parsed * multiplier;
+    return isNegative ? -Math.abs(finalValue) : finalValue;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)\(\s*([0-9][0-9\s.,]*(?:k€|k|keur|m€|m|meur|€)?)\s*\)/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*\(\s*([0-9][0-9\s.,]*(?:k€|k|keur|m€|m|meur|€)?)\s*\)\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?[0-9][0-9\s.,]*(?:k€|k|keur|m€|m|meur|€))\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?(?:[0-9]{1,3}(?:\s+[0-9]{3})+(?:,[0-9]+)?|[0-9]+,[0-9]+))\s*"/g,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(text) {
+    const lower = text.toLowerCase();
+    const frPatterns = [
+      /\bcerfa\b/i,
+      /\bliasse\s+fiscale\b/i,
+      /\bbilan\s+(actif|passif)\b/i,
+      /\bcompte\s+de\s+r[ée]sultat\b/i,
+      /\bplan\s+comptable\s+g[ée]n[ée]ral\b/i,
+      /\bpcg\b/i,
+      /\bsiren\b/i,
+      /\bsiret\b/i,
+      /\b[0-9\s.,]+(?:k€|m€)\b/i,
+      /\beur\b/i,
+      /€/
+    ];
+    return frPatterns.some((pattern) => pattern.test(lower));
+  }
+};
+
+// src/finance/strategies/us-gaap.strategy.ts
+var UsGAAPStrategy = class {
+  jurisdictionCode = "US";
+  standard = "US_GAAP";
+  defaultCurrency = "USD";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^[(\[]\s*(.+?)\s*[)\]]$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK]\b/.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK]\b/g, "").trim();
+    } else if (/[mM]\b/.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM]\b/g, "").trim();
+    } else if (/[bB]\b/.test(str)) {
+      multiplier = 1e9;
+      str = str.replace(/[bB]\b/g, "").trim();
+    }
+    str = str.replace(/[$]/g, "").replace(/\busd\b/gi, "").replace(/,/g, "").replace(/\s+/g, "").trim();
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalVal = parsed * multiplier;
+    return isNegative ? -Math.abs(finalVal) : finalVal;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)[(\[]\s*([0-9][0-9,.]*(?:k|m|b|\$)?)\s*[)\]]/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*[(\[]\s*([0-9][0-9,.]*(?:k|m|b|\$)?)\s*[)\]]\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?\$?\s*[0-9][0-9,.]*\s*(?:k|m|b|\$)?)\s*"/gi,
+      (_, prefix, amountStr) => {
+        if (!amountStr.includes("$") && !/[kmb]/i.test(amountStr)) {
+          return `${prefix}"${amountStr}"`;
+        }
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(text) {
+    const lower = text.toLowerCase();
+    const usPatterns = [
+      /\b10-[kq]\b/i,
+      /\bsec\s+filing\b/i,
+      /\bus[\s_-]?gaap\b/i,
+      /\bbalance\s+sheet\b/i,
+      /\bincome\s+statement\b/i,
+      /\bstatement\s+of\s+cash\s+flows\b/i,
+      /\$|usd/i
+    ];
+    return usPatterns.some((pattern) => pattern.test(lower));
+  }
+};
+
+// src/finance/strategies/uk-ifrs.strategy.ts
+var UkIFRSStrategy = class {
+  jurisdictionCode = "UK";
+  standard = "IFRS";
+  defaultCurrency = "GBP";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^\(\s*(.+?)\s*\)$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK]\b/.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK]\b/g, "").trim();
+    } else if (/[mM]\b/.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM]\b/g, "").trim();
+    }
+    str = str.replace(/[£]/g, "").replace(/\bgbp\b/gi, "").replace(/,/g, "").replace(/\s+/g, "").trim();
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalVal = parsed * multiplier;
+    return isNegative ? -Math.abs(finalVal) : finalVal;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)\(\s*([0-9][0-9,.]*(?:k|m|£)?)\s*\)/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*\(\s*([0-9][0-9,.]*(?:k|m|£)?)\s*\)\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?£\s*[0-9][0-9,.]*\s*(?:k|m)?)\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(text) {
+    const lower = text.toLowerCase();
+    const ukPatterns = [
+      /\bcompanies\s+house\b/i,
+      /\bfrs\s*102\b/i,
+      /\bhmrc\b/i,
+      /\bprofit\s+and\s+loss\b/i,
+      /£|\bgbp\b/i
+    ];
+    return ukPatterns.some((pattern) => pattern.test(lower));
+  }
+};
+
+// src/finance/strategies/swiss-co.strategy.ts
+var SwissCOStrategy = class {
+  jurisdictionCode = "CH";
+  standard = "SWISS_CO";
+  defaultCurrency = "CHF";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^\(\s*(.+?)\s*\)$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK]\b/.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK]\b/g, "").trim();
+    } else if (/[mM]\b/.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM]\b/g, "").trim();
+    }
+    str = str.replace(/\bchf\b/gi, "").replace(/['’]/g, "").replace(/\s+/g, "").trim();
+    str = str.replace(",", ".");
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalVal = parsed * multiplier;
+    return isNegative ? -Math.abs(finalVal) : finalVal;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)\(\s*([0-9][0-9'’.,\s]*(?:k|m|chf)?)\s*\)/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*\(\s*([0-9][0-9'’.,\s]*(?:k|m|chf)?)\s*\)\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?[0-9][0-9'’.,\s]*(?:k|m|chf))\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(text) {
+    const lower = text.toLowerCase();
+    const chPatterns = [
+      /\bcode\s+des\s+obligations\b/i,
+      /\bart\.?\s*725\b/i,
+      /\bche-[0-9]{3}\.[0-9]{3}\.[0-9]{3}\b/i,
+      /\bchf\b/i,
+      /\b[0-9]{1,3}(?:'[0-9]{3})+\b/
+    ];
+    return chPatterns.some((pattern) => pattern.test(lower));
+  }
+};
+
+// src/finance/strategies/international.strategy.ts
+var InternationalAccountingStrategy = class {
+  jurisdictionCode = "INTERNATIONAL";
+  standard = "OTHER";
+  defaultCurrency = "EUR";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^[(\[]\s*(.+?)\s*[)\]]$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK]\b/.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK]\b/g, "").trim();
+    } else if (/[mM]\b/.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM]\b/g, "").trim();
+    }
+    str = str.replace(/[€$£]/g, "").replace(/\b(?:eur|usd|gbp|chf)\b/gi, "").trim();
+    if (str.includes(",") && str.includes(".")) {
+      if (str.lastIndexOf(",") > str.lastIndexOf(".")) {
+        str = str.replace(/\./g, "").replace(",", ".");
+      } else {
+        str = str.replace(/,/g, "");
+      }
+    } else if (str.includes(",")) {
+      if (/,\d{1,2}$/.test(str)) {
+        str = str.replace(",", ".");
+      } else {
+        str = str.replace(",", "");
+      }
+    }
+    str = str.replace(/\s+/g, "");
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalVal = parsed * multiplier;
+    return isNegative ? -Math.abs(finalVal) : finalVal;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)[(\[]\s*([0-9][0-9,.\s]*(?:k|m|€|\$|£)?)\s*[)\]]/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*[(\[]\s*([0-9][0-9,.\s]*(?:k|m|€|\$|£)?)\s*[)\]]\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(_text) {
+    return true;
+  }
+};
+
+// src/finance/factory.ts
+var AccountingFactory = class {
+  static strategies = /* @__PURE__ */ new Map();
+  static detectionOrder = [];
+  static {
+    this.initDefaults();
+  }
+  static initDefaults() {
+    const fr = new FrenchPCGStrategy();
+    const us = new UsGAAPStrategy();
+    const uk = new UkIFRSStrategy();
+    const ch = new SwissCOStrategy();
+    const intl = new InternationalAccountingStrategy();
+    this.registerStrategy(ch);
+    this.registerStrategy(uk);
+    this.registerStrategy(us);
+    this.registerStrategy(fr);
+    this.registerStrategy(intl);
+  }
+  static registerStrategy(strategy) {
+    this.strategies.set(strategy.jurisdictionCode, strategy);
+    this.detectionOrder = [
+      strategy,
+      ...this.detectionOrder.filter((s) => s.jurisdictionCode !== strategy.jurisdictionCode)
+    ];
+  }
+  static getStrategy(code) {
+    if (!code) {
+      return this.strategies.get("FR") || new FrenchPCGStrategy();
+    }
+    const strategy = this.strategies.get(code);
+    if (!strategy) {
+      return this.strategies.get("FR") || new FrenchPCGStrategy();
+    }
+    return strategy;
+  }
+  static detectStrategy(documentText) {
+    for (const strategy of this.detectionOrder) {
+      if (strategy.jurisdictionCode !== "INTERNATIONAL" && strategy.detect(documentText)) {
+        return strategy;
+      }
+    }
+    return this.getStrategy("FR");
+  }
+  static resetDefaults() {
+    this.strategies.clear();
+    this.detectionOrder = [];
+    this.initDefaults();
+  }
+};
+
+// src/finance/normalizer.ts
+function cleanFinancialJSON(rawText, options) {
+  if (!rawText) {
+    return "";
+  }
+  const jsonBlock = extractAndCleanJSON(rawText);
+  const strategy = options?.jurisdiction ? AccountingFactory.getStrategy(options.jurisdiction) : options?.autoDetect !== false ? AccountingFactory.detectStrategy(rawText) : AccountingFactory.getStrategy("FR");
+  return strategy.cleanJSON(jsonBlock);
+}
+
 // src/response-validator.ts
 function extractAndCleanJSON(rawText) {
   let cleaned = rawText.trim();
@@ -164,12 +656,17 @@ function extractAndCleanJSON(rawText) {
   }
   return cleaned;
 }
-function validateWithZod(rawText, schema) {
-  const jsonString = extractAndCleanJSON(rawText);
+function validateWithZod(rawText, schema, options) {
+  let jsonString = extractAndCleanJSON(rawText);
+  if (options?.normalizer) {
+    jsonString = options.normalizer(jsonString);
+  } else if (options?.financialNormalizer) {
+    jsonString = cleanFinancialJSON(jsonString, { jurisdiction: options.jurisdiction });
+  }
   let parsed;
   try {
     parsed = JSON.parse(jsonString);
-  } catch (error) {
+  } catch (_error) {
     const sanitized = jsonString.replace(/,\s*([}\]])/g, "$1").replace(/'/g, '"');
     parsed = JSON.parse(sanitized);
   }
@@ -248,14 +745,15 @@ var AvantGateControlLayer = class {
       attempts: 1
     };
   }
-  async executeProviderPipeline(messages, query, temperature) {
+  async executeProviderPipeline(messages, query, temperature, modelOverride) {
     const chain = this.getProviderChain();
     let lastError;
     for (let index = 0; index < chain.length; index++) {
       const providerConfig = chain[index];
+      const targetModel = index === 0 && modelOverride ? modelOverride : providerConfig.model;
       try {
         const response = await providerConfig.client.complete({
-          model: providerConfig.model,
+          model: targetModel,
           messages,
           temperature: temperature ?? 0.2
         });
@@ -263,7 +761,7 @@ var AvantGateControlLayer = class {
         return {
           responseText: response.text,
           usage,
-          modelUsed: providerConfig.model,
+          modelUsed: targetModel,
           failoverOccurred: index > 0,
           attempts: index + 1
         };
@@ -331,7 +829,13 @@ var AvantGateControlLayer = class {
       temperature: options.temperature ?? 0.1,
       providerOverride: options.providerOverride
     });
-    const parsedData = validateWithZod(rawResult.text, options.schema);
+    const isFinancial = Boolean(
+      this.config.features?.finance?.enableFrenchAccounting || this.config.features?.finance
+    );
+    const parsedData = validateWithZod(rawResult.text, options.schema, {
+      financialNormalizer: isFinancial,
+      jurisdiction: this.config.features?.finance?.jurisdiction
+    });
     return {
       data: parsedData,
       rawText: rawResult.text,
@@ -341,15 +845,427 @@ var AvantGateControlLayer = class {
       failoverOccurred: rawResult.failoverOccurred
     };
   }
+  /**
+   * Méthode unifiée de premier niveau pour l'extraction structurée sans code boilerplate.
+   * Gère le failover multi-fournisseurs, les retries, la validation Zod et la normalisation financière.
+   */
+  async generateStructuredOutput(options) {
+    const maxRetries = options.maxRetries ?? this.config.retryOptions?.maxRetries ?? 2;
+    const modelToUse = options.model ?? this.config.primary.model;
+    const processedMessages = options.messages.map((msg) => {
+      if (msg.role === "user") {
+        return { ...msg, content: this.applySecurityGuards(msg.content) };
+      }
+      return msg;
+    });
+    let lastError;
+    let accumulatedPromptTokens = 0;
+    let accumulatedCompletionTokens = 0;
+    let failoverOccurred = false;
+    let modelUsed = modelToUse;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        let responseText = "";
+        let attemptPromptTokens = 0;
+        let attemptCompletionTokens = 0;
+        if (options.providerOverride) {
+          const res = await options.providerOverride.complete({
+            model: modelToUse,
+            messages: processedMessages,
+            temperature: options.temperature ?? 0.1
+          });
+          responseText = res.text;
+          const usage = this.resolveTokens(res.usage, JSON.stringify(processedMessages), responseText);
+          attemptPromptTokens = usage.promptTokens;
+          attemptCompletionTokens = usage.completionTokens;
+          modelUsed = modelToUse;
+        } else if (this.getProviderChain().length === 0) {
+          const sim = this.executeSimulation(JSON.stringify(processedMessages));
+          responseText = sim.text;
+          attemptPromptTokens = sim.tokens.prompt;
+          attemptCompletionTokens = sim.tokens.completion;
+        } else {
+          const output = await this.executeProviderPipeline(
+            processedMessages,
+            JSON.stringify(processedMessages),
+            options.temperature ?? 0.1,
+            options.model
+          );
+          responseText = output.responseText;
+          attemptPromptTokens = output.usage.promptTokens;
+          attemptCompletionTokens = output.usage.completionTokens;
+          modelUsed = output.modelUsed;
+          failoverOccurred = output.failoverOccurred;
+        }
+        accumulatedPromptTokens += attemptPromptTokens;
+        accumulatedCompletionTokens += attemptCompletionTokens;
+        const isFinancial = options.financialNormalizer ?? Boolean(
+          this.config.features?.finance?.enableFrenchAccounting || this.config.features?.finance
+        );
+        const parsedData = validateWithZod(responseText, options.schema, {
+          financialNormalizer: isFinancial,
+          jurisdiction: this.config.features?.finance?.jurisdiction
+        });
+        const totalTokens = accumulatedPromptTokens + accumulatedCompletionTokens;
+        const costUSD = calculateCostUSD(modelUsed, accumulatedPromptTokens, accumulatedCompletionTokens);
+        const result = {
+          data: parsedData,
+          rawText: responseText,
+          tokens: {
+            prompt: accumulatedPromptTokens,
+            completion: accumulatedCompletionTokens,
+            total: totalTokens
+          },
+          costUSD,
+          modelUsed,
+          failoverOccurred
+        };
+        await this.notifyAuditSink({
+          text: responseText,
+          tokens: result.tokens,
+          costUSD: result.costUSD,
+          modelUsed: result.modelUsed,
+          failoverOccurred: result.failoverOccurred,
+          attempts: attempt + 1
+        });
+        return result;
+      } catch (err) {
+        lastError = err;
+        if (attempt < maxRetries) {
+          const delay = (this.config.retryOptions?.initialDelayMs ?? 200) * Math.pow(this.config.retryOptions?.backoffFactor ?? 1.5, attempt);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
 };
 function createLLMControlLayer(config) {
   return new AvantGateControlLayer(config);
 }
 var createAvantGate = createLLMControlLayer;
+
+// src/prompts/prompt-template.ts
+var DEFAULT_JAILBREAK_PATTERNS = [
+  /ignore\s+(all\s+)?(previous|prior)\s+(instructions|rules)/i,
+  /disregard\s+(all\s+)?(previous|prior)\s+(instructions|rules)/i,
+  /system\s+override/i,
+  /you\s+are\s+now\s+(unrestricted|DAN|jailbroken)/i,
+  /<\s*\|\s*im_start\s*\|>/i,
+  /\[SYSTEM_PROMPT\]/i
+];
+var PromptTemplate = class {
+  id;
+  version;
+  label;
+  description;
+  template;
+  inputSchema;
+  blockPatterns;
+  antiInjectionEnabled;
+  customSanitizer;
+  constructor(options) {
+    this.id = options.id;
+    this.version = options.version;
+    this.label = options.label || "production";
+    this.description = options.description;
+    this.template = options.template;
+    this.inputSchema = options.inputSchema;
+    this.antiInjectionEnabled = options.antiInjection?.enabled !== false;
+    this.blockPatterns = options.antiInjection?.blockPatterns || DEFAULT_JAILBREAK_PATTERNS;
+    this.customSanitizer = options.antiInjection?.sanitizer;
+  }
+  validateUserInput(variables) {
+    const threats = [];
+    if (this.inputSchema) {
+      const parsed = this.inputSchema.safeParse(variables);
+      if (!parsed.success) {
+        return {
+          isValid: false,
+          threats: parsed.error.issues.map(
+            (issue) => `${issue.path.join(".")}: ${issue.message}`
+          )
+        };
+      }
+    }
+    if (this.antiInjectionEnabled) {
+      for (const [key, val] of Object.entries(variables)) {
+        if (typeof val === "string") {
+          for (const pattern of this.blockPatterns) {
+            if (pattern.test(val)) {
+              threats.push(
+                `Potential prompt injection in variable "${key}" matching pattern ${pattern}`
+              );
+            }
+          }
+        }
+      }
+    }
+    return { isValid: threats.length === 0, threats };
+  }
+  format(variables) {
+    const check = this.validateUserInput(variables);
+    if (!check.isValid) {
+      throw new Error(
+        `[PromptTemplate:${this.id}] Validation failed: ${check.threats.join(", ")}`
+      );
+    }
+    const interpolated = this.template.replace(/\{\{\s*([\w.-]+)\s*\}\}/g, (_, key) => {
+      let value = variables[key];
+      if (value === void 0 || value === null) {
+        return "";
+      }
+      let stringValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+      if (this.customSanitizer) {
+        stringValue = this.customSanitizer(stringValue);
+      }
+      return stringValue;
+    });
+    return interpolated.split("\n").filter((line, index, arr) => line.trim() !== "" || index > 0 && arr[index - 1].trim() !== "").join("\n");
+  }
+};
+
+// src/prompts/prompt-builder.ts
+var import_zod = require("zod");
+var PromptBuilder = class {
+  personaSlot = "";
+  rulesSlot = [];
+  retryHintSlot = "";
+  fewShotSlot = [];
+  pinnedFactsSlot = "";
+  contextSlot = "";
+  userPayloadSlot = "";
+  schemaContractText = "";
+  constructor(templateOrId) {
+    if (templateOrId instanceof PromptTemplate) {
+      this.personaSlot = templateOrId.template;
+    } else if (typeof templateOrId === "string") {
+      this.personaSlot = templateOrId.trim();
+    }
+  }
+  withPersona(persona) {
+    this.personaSlot = persona.trim();
+    return this;
+  }
+  withRules(rules) {
+    if (Array.isArray(rules)) {
+      this.rulesSlot.push(...rules.map((rule) => rule.trim()).filter(Boolean));
+    } else if (rules) {
+      this.rulesSlot.push(rules.trim());
+    }
+    return this;
+  }
+  withRetryHint(hint) {
+    this.retryHintSlot = hint.trim();
+    return this;
+  }
+  withFewShot(examples) {
+    this.fewShotSlot = examples;
+    return this;
+  }
+  withPinnedFacts(facts) {
+    if (!facts) return this;
+    if (typeof facts === "string") {
+      this.pinnedFactsSlot = facts.trim();
+      return this;
+    }
+    this.pinnedFactsSlot = Object.entries(facts).filter(([, val]) => val !== void 0 && val !== null && val !== "").map(([key, val]) => `\u2022 ${key} : ${Array.isArray(val) ? val.join(", ") : String(val)}`).join("\n");
+    return this;
+  }
+  withContext(context) {
+    this.contextSlot = context.trim();
+    return this;
+  }
+  withUserPayload(payload) {
+    this.userPayloadSlot = payload.trim();
+    return this;
+  }
+  schemaContract(schema, options) {
+    let shapeDescription = "JSON Object";
+    if (schema instanceof import_zod.z.ZodObject) {
+      shapeDescription = JSON.stringify(Object.keys(schema.shape));
+    }
+    this.schemaContractText = [
+      `[DIRECTIVE DE CONTRAT DE SORTIE JSON STRICT]`,
+      `Tu DOIS renvoyer UNIQUEMENT un objet JSON valide, sans balises markdown (\`\`\`json), sans texte avant ou apr\xE8s.`,
+      `Champs obligatoires et types attendus :`,
+      options?.schemaName ? `Sch\xE9ma : ${options.schemaName}` : "",
+      shapeDescription
+    ].filter(Boolean).join("\n");
+    return this;
+  }
+  assembleMessages(pinnedFacts, context, userPayload) {
+    const messages = [];
+    let system0 = this.personaSlot || "Tu es un assistant expert.";
+    if (this.schemaContractText) {
+      system0 += `
+
+${this.schemaContractText}`;
+    }
+    messages.push({ role: "system", content: system0 });
+    const dynamicParts = [];
+    if (this.rulesSlot.length > 0) {
+      dynamicParts.push(
+        `[R\xC8GLES ET CONSIGNES M\xC9TIER]
+${this.rulesSlot.map((rule, idx) => `${idx + 1}. ${rule}`).join("\n")}`
+      );
+    }
+    if (this.retryHintSlot) {
+      dynamicParts.push(`[INSTRUCTION DE CORRECTION / RETRY]
+${this.retryHintSlot}`);
+    }
+    if (dynamicParts.length > 0) {
+      messages.push({ role: "system", content: dynamicParts.join("\n\n") });
+    }
+    if (this.fewShotSlot.length > 0) {
+      const examplesContent = this.fewShotSlot.map(
+        (ex, idx) => `[Exemple ${idx + 1}]
+Question: ${ex.question}
+R\xE9ponse attendue: ${ex.answer}`
+      ).join("\n\n");
+      messages.push({ role: "system", content: `[EXEMPLES DE R\xC9F\xC9RENCE]
+${examplesContent}` });
+    }
+    const userParts = [];
+    if (pinnedFacts) {
+      userParts.push(`[FAITS STRUCTUR\xC9S]
+${pinnedFacts}`);
+    }
+    if (context) {
+      userParts.push(`[CONTEXTE DOCUMENTAIRE]
+${context}`);
+    }
+    if (userPayload) {
+      const labelNeeded = Boolean(pinnedFacts || context);
+      userParts.push(labelNeeded ? `[DONN\xC9ES \xC0 ANALYSER]
+${userPayload}` : userPayload);
+    }
+    messages.push({ role: "user", content: userParts.join("\n\n") });
+    return messages;
+  }
+  toMessages() {
+    return this.assembleMessages(this.pinnedFactsSlot, this.contextSlot, this.userPayloadSlot);
+  }
+  build(budget) {
+    if (!budget) {
+      const messages2 = this.toMessages();
+      const promptText2 = messages2.map((msg) => `${msg.role.toUpperCase()}:
+${msg.content}`).join("\n\n");
+      return {
+        messages: messages2,
+        promptText: promptText2,
+        allocatedTokens: Math.ceil(promptText2.length / 4),
+        isTruncated: false
+      };
+    }
+    budget.reset();
+    let isTruncated = false;
+    let truncatedSlot;
+    let system0 = this.personaSlot || "Tu es un assistant expert.";
+    if (this.schemaContractText) {
+      system0 += `
+
+${this.schemaContractText}`;
+    }
+    budget.forceReserve("persona", system0);
+    if (this.rulesSlot.length > 0 || this.retryHintSlot) {
+      const rulesText = this.rulesSlot.map((rule, idx) => `${idx + 1}. ${rule}`).join("\n");
+      budget.forceReserve("rules", `${rulesText}
+${this.retryHintSlot}`);
+    }
+    let payloadToUse = this.userPayloadSlot;
+    let factsToUse = this.pinnedFactsSlot;
+    let contextToUse = this.contextSlot;
+    if (payloadToUse) {
+      const payloadCost = budget.count(payloadToUse);
+      if (payloadCost > budget.remaining()) {
+        const charLimit = Math.max(100, budget.remaining() * 4);
+        payloadToUse = payloadToUse.slice(0, charLimit);
+        isTruncated = true;
+        truncatedSlot = "user";
+      }
+      budget.reserve("user", payloadToUse);
+    }
+    if (factsToUse) {
+      const factsCost = budget.count(factsToUse);
+      if (factsCost > budget.remaining()) {
+        const charLimit = Math.max(50, budget.remaining() * 4);
+        factsToUse = factsToUse.slice(0, charLimit);
+        isTruncated = true;
+        truncatedSlot = "pinnedFacts";
+      }
+      budget.reserve("pinnedFacts", factsToUse);
+    }
+    if (contextToUse) {
+      const contextCost = budget.count(contextToUse);
+      if (contextCost > budget.remaining()) {
+        const charLimit = Math.max(0, budget.remaining() * 4);
+        contextToUse = contextToUse.slice(0, charLimit);
+        isTruncated = true;
+        truncatedSlot = "context";
+      }
+      budget.reserve("context", contextToUse);
+    }
+    const messages = this.assembleMessages(factsToUse, contextToUse, payloadToUse);
+    const promptText = messages.map((msg) => `${msg.role.toUpperCase()}:
+${msg.content}`).join("\n\n");
+    return {
+      messages,
+      promptText,
+      allocatedTokens: budget.getAllocated(),
+      isTruncated,
+      truncatedSlot
+    };
+  }
+};
+
+// src/prompts/prompt-registry.ts
+var PromptRegistry = class {
+  static registry = /* @__PURE__ */ new Map();
+  static register(templateOrOptions) {
+    const template = templateOrOptions instanceof PromptTemplate ? templateOrOptions : new PromptTemplate(templateOrOptions);
+    const existing = this.registry.get(template.id) || [];
+    const filtered = existing.filter((item) => item.version !== template.version);
+    filtered.push(template);
+    filtered.sort((a, b) => b.version - a.version);
+    this.registry.set(template.id, filtered);
+  }
+  static get(id, options) {
+    const templates = this.registry.get(id);
+    if (!templates || templates.length === 0) {
+      throw new Error(`[PromptRegistry] No prompt template registered with id: "${id}"`);
+    }
+    if (options?.version !== void 0) {
+      const match = templates.find((item) => item.version === options.version);
+      if (!match) {
+        throw new Error(
+          `[PromptRegistry] Template "${id}" with version ${options.version} not found`
+        );
+      }
+      return match;
+    }
+    if (options?.label) {
+      const match = templates.find((item) => item.label === options.label);
+      if (match) {
+        return match;
+      }
+    }
+    return templates[0];
+  }
+  static has(id) {
+    return this.registry.has(id);
+  }
+  static clear() {
+    this.registry.clear();
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AvantGateControlLayer,
   DEFAULT_MODEL_PRICES,
+  PromptBuilder,
+  PromptRegistry,
+  PromptTemplate,
   ZenLLMControlLayer,
   calculateCostUSD,
   createAvantGate,