agentic-api 2.0.491 → 2.0.592

package/dist/src/agents/simulator.dashboard.js

@@ -0,0 +1,344 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulatorDashboard = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const readline_1 = require("readline");
+const path_1 = __importDefault(require("path"));
+const simulator_1 = require("./simulator");
+// ============================================================================
+// CLASS: SimulatorDashboard
+// ============================================================================
+class SimulatorDashboard {
+    constructor(config) {
+        this.config = config;
+        this.simulator = null;
+        this.abortController = null;
+        this._currentOutputPath = null;
+        this._currentInputPath = null;
+        this.status = this.createInitialStatus();
+    }
+    /**
+     * Chemin du fichier output actuel (ou du dernier run)
+     */
+    get currentOutputPath() {
+        return this._currentOutputPath;
+    }
+    /**
+     * Chemin du fichier input actuel (ou du dernier run)
+     */
+    get currentInputPath() {
+        return this._currentInputPath;
+    }
+    createInitialStatus() {
+        return {
+            isRunning: false,
+            sessionId: null,
+            currentTest: 0,
+            totalTests: 0,
+            passed: 0,
+            failed: 0,
+            errors: 0,
+            startTime: null,
+            lastUpdate: null
+        };
+    }
+    /**
+     * Obtenir le status actuel (pour le contrôleur backend)
+     */
+    getStatus() {
+        return { ...this.status };
+    }
+    /**
+     * Vérifier si une exécution est en cours
+     */
+    isRunning() {
+        return this.status.isRunning;
+    }
+    /**
+     * Annuler l'exécution en cours
+     */
+    abort() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    /**
+     * Charger un fichier JSON d'entrée
+     */
+    async loadInputFile(filePath) {
+        const content = await (0, promises_1.readFile)(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    /**
+     * Générer le chemin du fichier output basé sur le fichier input
+     * Exemple: tests/my-tests.json → tests/results.my-tests.jsonl
+     */
+    createOutputPath(inputPath) {
+        const dir = path_1.default.dirname(inputPath);
+        const basename = path_1.default.basename(inputPath, path_1.default.extname(inputPath));
+        return path_1.default.join(dir, `results.${basename}.jsonl`);
+    }
+    /**
+     * Charger les résultats JSONL existants (en cours ou terminés)
+     * Supporte le streaming partiel (fichier en cours d'écriture)
+     *
+     * @param inputPath - Chemin du fichier JSON d'entrée (génère automatiquement le output path)
+     * @returns Les lignes parsées ou null si le fichier n'existe pas
+     */
+    async loadResults(inputPath) {
+        // Déterminer le chemin du fichier output
+        let outputPath = null;
+        if (inputPath) {
+            outputPath = this.createOutputPath(inputPath);
+        }
+        else if (this._currentInputPath) {
+            outputPath = this.createOutputPath(this._currentInputPath);
+        }
+        else if (this._currentOutputPath) {
+            outputPath = this._currentOutputPath;
+        }
+        if (!outputPath || !(0, fs_1.existsSync)(outputPath)) {
+            return null;
+        }
+        return new Promise((resolve, reject) => {
+            const lines = [];
+            const stream = (0, fs_1.createReadStream)(outputPath, { encoding: 'utf-8' });
+            const rl = (0, readline_1.createInterface)({ input: stream, crlfDelay: Infinity });
+            rl.on('line', (line) => {
+                if (line.trim()) {
+                    try {
+                        lines.push(JSON.parse(line));
+                    }
+                    catch (e) {
+                        // Ignorer les lignes mal formées (fichier en cours d'écriture)
+                    }
+                }
+            });
+            rl.on('close', () => resolve(lines));
+            rl.on('error', reject);
+        });
+    }
+    /**
+     * Obtenir le résumé des résultats (dernière ligne type='end')
+     * @param inputPath - Chemin du fichier JSON d'entrée
+     */
+    async getResultsSummary(inputPath) {
+        const results = await this.loadResults(inputPath);
+        if (!results)
+            return null;
+        const endLine = results.find(r => r.type === 'end');
+        return endLine?.summary || null;
+    }
+    /**
+     * Vérifier si les résultats sont complets (contient une ligne 'end')
+     * @param inputPath - Chemin du fichier JSON d'entrée
+     */
+    async isResultsComplete(inputPath) {
+        const results = await this.loadResults(inputPath);
+        if (!results)
+            return false;
+        return results.some(r => r.type === 'end');
+    }
+    /**
+     * Exécuter les tests et écrire les résultats en JSONL
+     *
+     * @param input - Données d'entrée (ou chemin vers fichier JSON)
+     * @param outputPath - Chemin du fichier JSONL de sortie
+     * @param onLine - Callback optionnel pour chaque ligne JSONL (streaming)
+     */
+    async run(input, outputPath, onLine) {
+        // Stocker et charger l'input si c'est un chemin
+        const isInputFile = typeof input === 'string';
+        this._currentInputPath = isInputFile ? input : null;
+        const data = isInputFile
+            ? await this.loadInputFile(input)
+            : input;
+        // Générer automatiquement le outputPath si input est un fichier
+        const resolvedOutputPath = outputPath ?? (isInputFile ? this.createOutputPath(input) : undefined);
+        this._currentOutputPath = resolvedOutputPath || null;
+        // Initialiser le status
+        const sessionId = `session-${Date.now()}`;
+        this.status = {
+            isRunning: true,
+            sessionId,
+            currentTest: 0,
+            totalTests: data.tests.length,
+            passed: 0,
+            failed: 0,
+            errors: 0,
+            startTime: new Date(),
+            lastUpdate: new Date()
+        };
+        // Créer le simulateur avec config mergée
+        const mergedConfig = {
+            ...this.config,
+            ...data.config
+        };
+        this.simulator = new simulator_1.AgentSimulator(mergedConfig);
+        // Créer l'AbortController
+        this.abortController = new AbortController();
+        // Ouvrir le fichier de sortie si spécifié
+        let writeStream = null;
+        if (resolvedOutputPath) {
+            writeStream = (0, fs_1.createWriteStream)(resolvedOutputPath, { encoding: 'utf-8' });
+        }
+        const results = [];
+        const startTime = Date.now();
+        // Helper pour écrire une ligne
+        const writeLine = (line) => {
+            results.push(line);
+            const jsonLine = JSON.stringify(line) + '\n';
+            if (writeStream) {
+                writeStream.write(jsonLine);
+            }
+            if (onLine) {
+                onLine(line);
+            }
+        };
+        try {
+            // Écrire la ligne de début
+            writeLine({
+                type: 'start',
+                timestamp: new Date().toISOString(),
+                sessionId,
+                totalTests: data.tests.length
+            });
+            // Exécuter chaque test
+            for (let i = 0; i < data.tests.length; i++) {
+                // Vérifier si annulé
+                if (this.abortController.signal.aborted) {
+                    break;
+                }
+                const testCase = data.tests[i];
+                const testId = testCase.id || `test-${i}`;
+                const testStartTime = Date.now();
+                // Mettre à jour le status
+                this.status.currentTest = i + 1;
+                this.status.lastUpdate = new Date();
+                try {
+                    // Exécuter le test
+                    const result = await this.simulator.testCase(testCase.scenario, testCase.case);
+                    // Déterminer le status
+                    const status = result.success ? 'completed' : 'failed';
+                    // Mettre à jour les compteurs
+                    if (result.success) {
+                        this.status.passed++;
+                    }
+                    else {
+                        this.status.failed++;
+                    }
+                    // Écrire le résultat
+                    writeLine({
+                        type: 'result',
+                        timestamp: new Date().toISOString(),
+                        testId,
+                        testIndex: i,
+                        name: testCase.name || testId,
+                        description: testCase.scenario.description || testCase.scenario.goals,
+                        query: testCase.case.query,
+                        status,
+                        success: result.success,
+                        message: result.message,
+                        error: result.error || undefined,
+                        exchangeCount: result.exchangeCount,
+                        messages: result.messages,
+                        duration: Date.now() - testStartTime
+                    });
+                }
+                catch (error) {
+                    // Erreur d'exécution
+                    this.status.errors++;
+                    writeLine({
+                        type: 'error',
+                        timestamp: new Date().toISOString(),
+                        testId,
+                        testIndex: i,
+                        name: testCase.name || testId,
+                        description: testCase.scenario.description || testCase.scenario.goals,
+                        query: testCase.case.query,
+                        status: 'error',
+                        success: false,
+                        error: error.message || String(error),
+                        duration: Date.now() - testStartTime
+                    });
+                }
+            }
+            // Écrire la ligne de fin
+            writeLine({
+                type: 'end',
+                timestamp: new Date().toISOString(),
+                sessionId,
+                summary: {
+                    total: data.tests.length,
+                    passed: this.status.passed,
+                    failed: this.status.failed,
+                    errors: this.status.errors,
+                    totalDuration: Date.now() - startTime
+                }
+            });
+        }
+        finally {
+            // Fermer le stream et attendre la fin de l'écriture
+            if (writeStream) {
+                await new Promise((resolve, reject) => {
+                    writeStream.end(() => resolve());
+                    writeStream.on('error', reject);
+                });
+            }
+            // Reset le status
+            this.status.isRunning = false;
+            this.status.lastUpdate = new Date();
+            this.simulator = null;
+            this.abortController = null;
+        }
+        return results;
+    }
+    /**
+     * Exécuter avec callback de streaming (pour SSE/WebSocket)
+     */
+    async runWithStream(input, onLine) {
+        return this.run(input, undefined, onLine);
+    }
+    /**
+     * Créer un fichier JSON d'exemple pour les tests
+     */
+    static createExampleInput() {
+        return {
+            name: "Example Test Suite",
+            description: "Exemple de suite de tests pour le simulator",
+            tests: [
+                {
+                    id: "test-greeting",
+                    name: "Test de salutation",
+                    scenario: {
+                        goals: "L'agent doit répondre poliment à la salutation",
+                        persona: "Utilisateur poli et patient"
+                    },
+                    case: {
+                        query: "Bonjour, comment allez-vous?"
+                        // maxExchanges: 1 par défaut
+                        // expectedTools: {} par défaut
+                    }
+                },
+                {
+                    id: "test-transfer",
+                    name: "Test de transfert",
+                    scenario: {
+                        goals: "L'agent doit transférer vers l'agent spécialisé",
+                        persona: "Utilisateur avec une demande spécifique"
+                    },
+                    case: {
+                        query: "J'ai besoin d'aide spécialisée",
+                        maxExchanges: 3,
+                        expectedTools: { 'transferAgents': { gte: 1 } }
+                    }
+                }
+            ]
+        };
+    }
+}
+exports.SimulatorDashboard = SimulatorDashboard;

package/dist/src/agents/simulator.js

@@ -7,7 +7,63 @@ class AgentSimulator {
         this.config = config;
         this.executor = new simulator_executor_1.AgentExecutor(config);
     }
+    // ============================================================================
+    // NOUVELLE API : testCase(scenario, case)
+    // ============================================================================
     /**
+     * Exécuter un cas de test avec scénario et paramètres séparés
+     *
+     * @param scenario - Contexte stable (goals, persona, result)
+     * @param testCase - Paramètres du test (query, maxExchanges, model, expectedTools)
+     * @returns SimulationResult
+     *
+     * @example
+     * ```typescript
+     * const scenario = {
+     *   goals: 'Obtenir le nombre secret 1942',
+     *   persona: PERSONA_PATIENT,
+     *   result: '{"success": boolean, "error": string}'
+     * };
+     *
+     * const result = await simulator.testCase(scenario, {
+     *   query: 'À quel nombre penses-tu?',
+     *   maxExchanges: 3,  // défaut: 1 (oneshot)
+     *   expectedTools: { 'transferAgents': { equal: 1 } }  // défaut: {}
+     * });
+     * ```
+     */
+    async testCase(scenario, testCase) {
+        // Appliquer les défauts
+        const resolvedCase = {
+            query: testCase.query,
+            maxExchanges: testCase.maxExchanges ?? 1, // Défaut: 1 (oneshot)
+            expectedTools: testCase.expectedTools ?? {}, // Défaut: pas de validation
+            model: testCase.model,
+            onMessage: testCase.onMessage
+        };
+        // TODO: Support model override (Phase 2)
+        // if (resolvedCase.model) {
+        //   this.overrideModel(resolvedCase.model);
+        // }
+        // Convertir TestScenario vers SimulationScenario et déléguer
+        return this.executeSimulation({
+            scenario: {
+                goals: scenario.goals,
+                persona: scenario.persona,
+                result: scenario.result || '{"success": boolean, "explain": string, "error": string}'
+            },
+            query: resolvedCase.query,
+            maxExchanges: resolvedCase.maxExchanges,
+            expectedTool: resolvedCase.expectedTools,
+            onMessage: resolvedCase.onMessage
+        });
+    }
+    // ============================================================================
+    // ANCIENNE API : executeSimulation(options) - deprecated
+    // ============================================================================
+    /**
+     * @deprecated Utiliser testCase(scenario, case) à la place
+     *
      * Exécuter la simulation complète
      *
      * Architecture :

package/dist/src/agents/simulator.types.d.ts

@@ -9,6 +9,38 @@ export interface SimulatorConfig {
     mockCacheInitializer?: (sessionId: string) => Promise<void>;
     ragConfig?: RAGManagerConfig;
 }
+/**
+ * Scénario de test - Contexte stable entre les tests
+ * Définit la personnalité du simulateur et les objectifs de validation
+ */
+export interface TestScenario {
+    description?: string;
+    goals: string;
+    persona: string;
+    result?: string;
+}
+/**
+ * Contrainte de validation pour un outil
+ */
+export interface ToolConstraint {
+    equal?: number;
+    gte?: number;
+    lte?: number;
+}
+/**
+ * Cas de test spécifique - Varie pour chaque test
+ * Définit la query et les attentes de validation
+ */
+export interface TestCaseInput {
+    query: string;
+    maxExchanges?: number;
+    model?: string;
+    expectedTools?: Record<string, ToolConstraint>;
+    onMessage?: (message: AgentMessage) => void;
+}
+/**
+ * @deprecated Utiliser TestScenario à la place
+ */
 export interface SimulationScenario {
     goals?: string;
     persona?: string;
@@ -20,15 +52,14 @@ export interface SimulationScenario {
     testQuery?: string;
     testResult?: string;
 }
+/**
+ * @deprecated Utiliser testCase(scenario, case) à la place de executeSimulation(options)
+ */
 export interface SimulationOptions {
     scenario: SimulationScenario;
     query?: string;
     maxExchanges: number;
-    expectedTool?: Record<string, {
-        equal?: number;
-        gte?: number;
-        lte?: number;
-    }>;
+    expectedTool?: Record<string, ToolConstraint>;
     onMessage?: (message: AgentMessage) => void;
 }
 export interface SimulationResult {
@@ -51,7 +82,8 @@ export interface ExecutionContext {
     exchangeCount: number;
     lastExecution: ExecutionResult;
 }
-export interface TestScenario {
+/** @deprecated Utiliser TestScenario avec l'API testCase() */
+export interface PRSolverScenario {
     ticketId: string;
     ticketMarkdown: string;
     clientType: 'locataire' | 'proprietaire';

package/dist/src/agents/simulator.utils.d.ts

@@ -1,4 +1,4 @@
-import { SimulationScenario } from './simulator.types';
+import { SimulationScenario, TestScenario } from './simulator.types';
 import { PERSONA_PATIENT, PERSONA_PRESSE, PERSONA_ENERVE } from './simulator.prompts';
 /**
  * Charger un ticket depuis le filesystem (comme agent-vs-agent.ts)
@@ -22,4 +22,25 @@ custom?: Partial<SimulationScenario>): {
  * Supporte l'ancien format (testGoals, testEnd, etc.) pour rétrocompatibilité
  */
 export declare function buildGenericScenario(scenario: SimulationScenario): SimulationScenario;
+/**
+ * Créer un TestScenario pour la nouvelle API testCase()
+ *
+ * @example
+ * ```typescript
+ * const scenario = createTestScenario({
+ *   goals: 'Obtenir le nombre secret 1942',
+ *   persona: PERSONA_PATIENT
+ * });
+ *
+ * const result = await simulator.testCase(scenario, {
+ *   query: 'À quel nombre penses-tu?'
+ * });
+ * ```
+ */
+export declare function createTestScenario(options: {
+    description?: string;
+    goals: string;
+    persona: string;
+    result?: string;
+}): TestScenario;
 export { PERSONA_PATIENT, PERSONA_PRESSE, PERSONA_ENERVE };

package/dist/src/agents/simulator.utils.js

@@ -37,6 +37,7 @@ exports.PERSONA_ENERVE = exports.PERSONA_PRESSE = exports.PERSONA_PATIENT = void
 exports.loadScenario = loadScenario;
 exports.buildScenarioFromTicket = buildScenarioFromTicket;
 exports.buildGenericScenario = buildGenericScenario;
+exports.createTestScenario = createTestScenario;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const simulator_prompts_1 = require("./simulator.prompts");
@@ -105,3 +106,29 @@ function buildGenericScenario(scenario) {
         result: scenario.result || '{"success": boolean, "error": string, "description": string}'
     };
 }
+// ============================================================================
+// NOUVELLE API : createTestScenario (pour testCase)
+// ============================================================================
+/**
+ * Créer un TestScenario pour la nouvelle API testCase()
+ *
+ * @example
+ * ```typescript
+ * const scenario = createTestScenario({
+ *   goals: 'Obtenir le nombre secret 1942',
+ *   persona: PERSONA_PATIENT
+ * });
+ *
+ * const result = await simulator.testCase(scenario, {
+ *   query: 'À quel nombre penses-tu?'
+ * });
+ * ```
+ */
+function createTestScenario(options) {
+    return {
+        description: options.description,
+        goals: options.goals,
+        persona: options.persona,
+        result: options.result || '{"success": boolean, "explain": string, "error": string}'
+    };
+}

package/dist/src/execute/helpers.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.accumulateUsageTokens = accumulateUsageTokens;
 exports.stepsToActions = stepsToActions;
 exports.batchProcessToolCalls = batchProcessToolCalls;
-const pricing_llm_1 = require("../pricing.llm");
+const pricing_1 = require("../llm/pricing");
 const utils_1 = require("../utils");
 /**
  * OPTIM: Accumule l'usage des tokens et met à jour stateGraph + discussion.usage
@@ -18,7 +18,7 @@ const utils_1 = require("../utils");
  * @param usage - Usage retourné par l'API (prompt_tokens, completion_tokens, total_tokens)
  */
 function accumulateUsageTokens(stateGraph, discussion, agentName, model, usage) {
-    (0, pricing_llm_1.accumulateCost)(discussion.usage, model, usage);
+    (0, pricing_1.accumulateCost)(discussion.usage, model, usage);
     stateGraph.updateTokens(agentName, {
         prompt: usage?.prompt_tokens || 0,
         completion: usage?.completion_tokens || 0,

package/dist/src/execute/modelconfig.d.ts

@@ -1,19 +1,29 @@
 import { AgentModel } from '../types';
+import { LLMProvider } from '../llm';
 /**
  * Configuration des modèles pour Chat Completions (legacy) et Responses API
  *
  * Gère la configuration des modèles avec migration automatique des paramètres
- * selon le provider (OpenAI, xAI) et l'API utilisée (legacy ou Responses)
+ * entre les deux APIs.
  *
- * @param model - Alias du modèle (LOW-fast, MEDIUM-fast, HIGH-fast, HIGH-medium, etc.)
- * @param custom - Options custom
- * @param custom.thinking - Si true, active reasoning_effort élevé (via LLM mapping)
- * @param forResponses - Si true, retourne format Responses API avec mappings:
- *   - reasoning_effort → reasoning: { effort }
- *   - verbosity → text.verbosity
- * @returns Configuration du modèle
+ * @param model - Alias du modèle (ex: "LOW", "MEDIUM", "HIGH", "EMBEDDING-small", "VISION")
+ * @param custom - Options personnalisées (provider, thinking, temperature, etc.)
+ * @param custom.provider - Provider à utiliser ('openai' | 'xai'), default: LLM_PROVIDER env
+ * @param custom.thinking - Active le mode raisonnement (reasoning_effort: high)
+ * @param forResponses - Si true, adapte pour l'API Responses (sinon Chat Completions)
  *
- * NOTE: Pour GPT-5, temperature est toujours fixée à 1
- * NOTE: reasoning_effort est géré automatiquement par LLM() selon le provider
+ * @example
+ * // Modèle par défaut
+ * const config = modelConfig("MEDIUM");
+ *
+ * // Forcer OpenAI pour embeddings
+ * const config = modelConfig("EMBEDDING-small", { provider: 'openai' });
+ *
+ * // Vision avec xAI
+ * const config = modelConfig("VISION", { provider: 'xai' });
  */
-export declare function modelConfig(model: string, custom?: any, forResponses?: boolean): AgentModel;
+export declare function modelConfig(model: string, custom?: {
+    provider?: LLMProvider;
+    thinking?: boolean;
+    [key: string]: any;
+}, forResponses?: boolean): AgentModel;

package/dist/src/execute/modelconfig.js

@@ -1,27 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.modelConfig = modelConfig;
-const utils_1 = require("../utils");
-const pricing_llm_1 = require("../pricing.llm");
+const llm_1 = require("../llm");
+const pricing_1 = require("../llm/pricing");
 /**
  * Configuration des modèles pour Chat Completions (legacy) et Responses API
  *
  * Gère la configuration des modèles avec migration automatique des paramètres
- * selon le provider (OpenAI, xAI) et l'API utilisée (legacy ou Responses)
+ * entre les deux APIs.
  *
- * @param model - Alias du modèle (LOW-fast, MEDIUM-fast, HIGH-fast, HIGH-medium, etc.)
- * @param custom - Options custom
- * @param custom.thinking - Si true, active reasoning_effort élevé (via LLM mapping)
- * @param forResponses - Si true, retourne format Responses API avec mappings:
- *   - reasoning_effort → reasoning: { effort }
- *   - verbosity → text.verbosity
- * @returns Configuration du modèle
+ * @param model - Alias du modèle (ex: "LOW", "MEDIUM", "HIGH", "EMBEDDING-small", "VISION")
+ * @param custom - Options personnalisées (provider, thinking, temperature, etc.)
+ * @param custom.provider - Provider à utiliser ('openai' | 'xai'), default: LLM_PROVIDER env
+ * @param custom.thinking - Active le mode raisonnement (reasoning_effort: high)
+ * @param forResponses - Si true, adapte pour l'API Responses (sinon Chat Completions)
  *
- * NOTE: Pour GPT-5, temperature est toujours fixée à 1
- * NOTE: reasoning_effort est géré automatiquement par LLM() selon le provider
+ * @example
+ * // Modèle par défaut
+ * const config = modelConfig("MEDIUM");
+ *
+ * // Forcer OpenAI pour embeddings
+ * const config = modelConfig("EMBEDDING-small", { provider: 'openai' });
+ *
+ * // Vision avec xAI
+ * const config = modelConfig("VISION", { provider: 'xai' });
  */
 function modelConfig(model, custom, forResponses = false) {
+    //
+    // Extraire et supprimer les paramètres spéciaux
+    const provider = custom?.provider || (0, llm_1.getDefaultProvider)();
     const thinking = custom?.thinking || false;
+    delete custom?.provider;
     delete custom?.thinking;
     const defaultOptions = Object.assign({
         stream_options: { "include_usage": true },
@@ -29,7 +38,14 @@ function modelConfig(model, custom, forResponses = false) {
     //
     // Get mapping based on provider (OpenAI vs xAI)
     // LLM() applique automatiquement reasoning_effort si thinking=true
-    const mapping = (0, pricing_llm_1.LLM)((0, utils_1.openaiInstance)(), thinking);
+    const mapping = (0, pricing_1.LLM)(provider, thinking);
+    //
+    // Vérifier que le modèle existe pour ce provider
+    if (!mapping[model]) {
+        const availableModels = Object.keys(mapping).join(', ');
+        throw new Error(`Model "${model}" not available for provider "${provider}". ` +
+            `Available models: ${availableModels}`);
+    }
     const options = Object.assign({}, mapping[model], defaultOptions);
     //
     // Pour Responses API : mapper vers la nouvelle structure et filtrer les paramètres incompatibles