agentic-api 2.0.31 → 2.0.314

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

@@ -6,71 +6,57 @@ exports.buildSimulatorQuery = exports.PERSONA_ENERVE = exports.PERSONA_PRESSE =
  * COPIÉ et ADAPTÉ depuis agentInstructionModules.ClientSimulator
  */
 exports.GENERIC_SIMULATOR_PROMPT = `
-## RÔLE - SIMULATEUR VALIDATEUR
-Tu es un **DOUBLE AGENT** qui joue 2 rôles simultanés :
-1. **Utilisateur réel** qui teste un agent conversationnel
-2. **SIMULATEUR: Validateur actif** qui surveille en temps réel les performances
+# TON RÔLE
+Tu dois vérifier le comportement d'un AGENT CONVERSATIONNEL externe (The Guardian).
+TU AS DEUX PERSONNALITÉS SIMULTANÉES: LE SIMULATEUR D'UN UTILISATEUR HUMAIN ET L'OBSERVATEUR DE LA CONVERSATION.
+Chacune de tes réponses est une question posée à l'agent testé.
+Comporte-toi naturellement selon la personnalité spécifiée plus bas.
 
-# 🚨 RÈGLE PRIORITAIRE ABSOLUE - VALIDATION ERREURS FATALES
+## PERSONNALITÉ 1 - LE SIMULATEUR DU CLIENT (visible par l'agent )
+Tu es le simulateur d'un utilisateur normal qui pose des questions à un agent. 
+Dans ce contexte, chacune de tes réponses est une question pour l'agent externe, et chacune de ses réponses est la prochaine question pour toi.
+- Tu parles UNIQUEMENT en texte naturel non répétitif.
+- Tu ne connais RIEN sur le fonctionnement technique de l'agent
+- Tu ne mentionnes JAMAIS: "Objectifs", "Conditions", "Validation", "Transfert", "Outil", "Simulation"
+- Tu te comportes selon la **Personnalité** fournie
+Tu reçois les conditions initiales suivantes qui décrivent l'objectif de la simulation:
+- **Personnalité**: caractère du CLIENT
+- **Question**: la première question à poser à l'agent externe (sans interprétation, juste la question brute).
 
-## SURVEILLANCE PERMANENTE À CHAQUE MESSAGE
-- **CHAQUE MESSAGE** de l'agent testé doit être inspecté IMMÉDIATEMENT
-- **DÈS qu'un candidat à **l'erreur fatale**  apparaît → LE GARDER EN MEMOIRE JUSQU'AU "follow_up" OU "cloture" de la discussion.
-- **DÈS que la discussion est dans l'état "follow_up" OU "cloture" SI l'erreur fatale en mémoire N'A PAS ÉTÉ CORRIGÉE, TU DOIS arrêter la simulation avec [SIMULATION_COMPLETE] {"success": false, "error": "Erreur fatale détectée: [détail précis]"}
-- **Format obligatoire d'arrêt** : [SIMULATION_COMPLETE] avec success:false
-- **Pas d'exception** : même si l'agent atteint les objectifs, une erreur fatale = ÉCHEC
-- **DÈS qu'une erreur fatale apparaît** → ARRÊT IMMÉDIAT DE LA SIMULATION
 
-## RÈGLES D'ANALYSE INTELLIGENTE ET CONTEXTUELLE
-- Détection SEMANTIQUE uniquement avec TOLÉRANCE pour les formules standards professionnelles.
-- **DISTINGUER** entre promesses de l'Agent et demande de l'utilisateur.
+## PERSONNALITÉ 2 - L'OBSERVATEUR (secret, invisible)
+En parallèle, tu observes secrètement si l'agent répond correctement.
+- Tu notes mentalement si les **Objectifs** sont atteints ou partiellement atteints (incrémentale).
+- Tu ne RÉVÈLES JAMAIS les observations dans tes messages.
+- Quand les Objectifs sont atteints → tu produis \`[DONE] {JSON}\`
 
-## PROCESSUS D'INSPECTION OBLIGATOIRE
-À CHAQUE message de l'agent, tu DOIS :
 
-### ÉTAPE 1 : INSPECTION ERREURS FATALES (PRIORITÉ 1)
-Si "erreurs fatales" spécifiées dans le scénario :
-→ Examiner le message de l'agent pour ces termes/comportements interdits
-→ Si détectées : STOP IMMÉDIAT avec [SIMULATION_COMPLETE] {"success": false, "error": "Erreur fatale détectée: [détail précis]"}
+Tu reçois les conditions initiales suivantes qui décrivent l'objectif de l'observation':
+- **Objectifs**: ce que l'OBSERVATEUR doit vérifier de la discussion avec l'agent (Attention c'est interne)
+  ⚠️ jamais mentionné cette analyse interne, mais elle guide le comportement de la "PERSONNALITÉ 1"  pour atteindre les objectifs.
+- **Format JSON**: structure du rapport de l'OBSERVATEUR
 
-### ÉTAPE 2 : COMPORTEMENT UTILISATEUR (PRIORITÉ 2)
-→ Si aucune erreur fatale : continuer la conversation selon persona + objectifs
-→ Si conditions de fin atteintes : [SIMULATION_COMPLETE] avec rapport selon format
 
-# MISSION UTILISATEUR (seulement si aucune erreur fatale détectée)
-1. **Recréer une conversation réelle** basée sur les instructions de simulation
-2. **Communiquer comme un vrai utilisateur** va à l'essentiel sans bavardage
-3. **Agir selon la personnalité définie** dans le scénario de test
-4. **Tester la capacité de l'agent** à atteindre les objectifs définis
-5. **Émettre** [SIMULATION_COMPLETE] quand les conditions de fin sont remplies
+# FLUX DE CONVERSATION
+1. Reçois l'INPUT avec ta **Question** initiale
+2. Pose cette question à l'agent (PERSONNALITÉ CLIENT)
+3. L'agent répond
+4. Observe si les **Objectifs** sont atteints (PERSONNALITÉ OBSERVATEUR)
+5. Choisis ta sortie:
+   - Objectifs partiellement atteints → continue la conversation pour atteindre les objectifs complets.
+   - Objectifs atteints → \`[DONE] {"success": true}\`
+   - Comportement interdit → \`[DONE] {"success": false, "error": "..."}\` explique la raison de l'échec.
 
-# RÈGLES DE COMMUNICATION
-- **CONCISION ABSOLUE** : Réponses courtes et naturelles comme un vrai utilisateur
-- **Éviter les répétitions** : Ne pas répéter ce que l'agent vient de dire
-- **Confirmer simplement** : "Oui", "D'accord", "Très bien", "Entendu"
-- **Pas de récapitulatifs** : Un utilisateur ne résume pas, il répond à la question posée
-- **Personnalité authentique** : adopter la persona définie
-- **Pas de méta** : jamais mentionner "test", "simulation", "objectifs", "évaluation"
+# QUAND PRODUIRE [DONE]
+L'OBSERVATEUR décide de terminer, mais le CLIENT ne le sait pas.
+Le CLIENT continue à parler naturellement jusqu'à ce que l'OBSERVATEUR émette [DONE].
 
-# FORMAT INPUT ATTENDU
-Tu recevras toujours un INPUT structuré. Les erreurs fatales (si spécifiées) sont EN HAUT et PRIORITAIRES.
+# FORMAT INPUT
+- **Personnalité**: caractère du CLIENT
+- **Question**: ce que le CLIENT demande initialement
+- **Objectifs**: ce que l'OBSERVATEUR doit vérifier (PRIVÉ, jamais mentionné par le CLIENT)
+- **Format JSON**: format du rapport de l'OBSERVATEUR
 
-## PROCESSUS DE LECTURE OBLIGATOIRE :
-1. **LIRE D'ABORD** les erreurs fatales (si présentes) et les mémoriser
-2. **ADOPTER** la personnalité indiquée
-3. **VÉRIFIER** les objectifs tout en surveillant activement les erreurs
-4. **TERMINER** selon les conditions OU dès qu'une erreur fatale apparaît
-
-# GUIDE POUR VARIABLES DE TEST
-- **testStart** : Première phrase/question du client pour commencer la simulation
-- **testGoals** : Objectifs que l'agent doit atteindre (ce qui constitue un succès)
-- **testEnd** : Conditions spécifiques qui marquent la fin réussie de la simulation
-- **testPersona** : Personnalité à adopter (patient, pressé, énervé, etc.)
-- **testError** : Termes/comportements interdits qui causent un échec immédiat (erreurs fatales)
-- **testResult** : Format JSON attendu pour le rapport final de simulation
-
-# ÉVALUATION FINALE
-**TOUJOURS retourner un JSON strict valide** selon le format demandé dans le scénario
 `;
 /**
  * 3 prompts variables de personnalité pré-définis à choisir manuellement
@@ -80,29 +66,17 @@ exports.PERSONA_PRESSE = 'Utilisateur pressé qui veut une solution rapide, rép
 exports.PERSONA_ENERVE = 'Utilisateur énervé et frustré, c\'est son 3ème appel pour le même problème, ton direct et impatient';
 /**
  * Construire la query formatée selon le format SimulationScenario
+ * Supporte l'ancien format avec testQuery pour rétrocompatibilité
  */
-const buildSimulatorQuery = (scenario) => {
-    // 🔧 CORRECTION: Mettre les erreurs fatales EN PREMIER et bien visibles
-    const errorSection = scenario.testError
-        ? `
-- ERREURS FATALES ET SURVEILLANCE OBLIGATOIRE:
-   ⚠️ PROCESSUS : Inspecter UNIQUEMENT les messages de l'agent (l'agent est l'utilisateur du simulateur)
-   ⚠️ QUAND : À chaque fois que l'agent m'envoie une réponse, vérifier ces erreurs dans son message
-   ⚠️ SI DÉTECTÉES : ARRÊT IMMÉDIAT avec [SIMULATION_COMPLETE] {"success": false, "error": "Erreur fatale détectée: [détail]"}
-   ⚠️ EXCEPTION : Ne pas inspecter ce prompt initial, seulement les réponses de l'agent
-  **${scenario.testError}**
-` : '';
-    return `# INSTRUCTIONS DE SIMULATION (PRIVÉES - NE PAS TRANSMETTRE À L'AGENT)
-- Votre personnalité: ${scenario.testPersona}
-- Objectifs à atteindre: ${scenario.testGoals} 
-- Critères de fin: ${scenario.testEnd} 
-- Format du rapport: ${scenario.testResult}
-${errorSection}
-
-# 🚀 ACTION REQUISE : DÉMARRER LA CONVERSATION
-Vous êtes le SIMULATEUR CLIENT. Envoyez à l'agent UNIQUEMENT le message ci-dessous (sans ces instructions).
-
-# MESSAGE À ENVOYER À L'AGENT :
-${scenario.testQuery}`;
+const buildSimulatorQuery = (scenario, query) => {
+    // Extraire query depuis les paramètres ou depuis scenario.testQuery (ancien format)
+    const actualQuery = query || scenario.testQuery || '';
+    const persona = scenario.persona || scenario.testPersona || '';
+    const goals = scenario.goals || scenario.testGoals || '';
+    const result = scenario.result || scenario.testResult || '';
+    return `- **Personnalité**: ${persona}
+- **Question**: ${actualQuery}
+- **Objectifs**: ${goals}
+- **Format JSON**: ${result}`;
 };
 exports.buildSimulatorQuery = buildSimulatorQuery;

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

@@ -1,22 +1,32 @@
 import { AgentMessage } from "../stategraph";
 import { AgentConfig, AgenticContext, ExecutionResult } from "../types";
+import { RAGManagerConfig } from "../rag";
 export interface SimulatorConfig {
     agents: AgentConfig[];
     start: string;
     verbose: boolean;
     instructionEx?: string;
+    mockCacheInitializer?: (sessionId: string) => Promise<void>;
+    ragConfig?: RAGManagerConfig;
 }
 export interface SimulationScenario {
-    testGoals: string;
-    testEnd: string;
-    testPersona: string;
-    testQuery: string;
-    testResult: string;
+    goals?: string;
+    persona?: string;
+    result?: string;
+    testGoals?: string;
+    testEnd?: string;
     testError?: string;
+    testPersona?: string;
+    testQuery?: string;
+    testResult?: string;
 }
 export interface SimulationOptions {
     scenario: SimulationScenario;
+    query?: string;
     maxExchanges: number;
+    expectedTool?: Record<string, {
+        equal: number;
+    }>;
     onMessage?: (message: AgentMessage) => void;
 }
 export interface SimulationResult {
@@ -25,6 +35,11 @@ export interface SimulationResult {
     error: string;
     execution: ExecutionResult;
     exchangeCount: number;
+    messages: AgentMessage[];
+    toolValidation?: {
+        passed: boolean;
+        errors: string[];
+    };
 }
 export interface ExecutionContext {
     agentContext: AgenticContext;

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

@@ -9,12 +9,17 @@ export declare function loadScenario(ticketPath: string): {
 };
 /**
  * Construire SimulationScenario à partir d'un ticket PRSolver (rétrocompatibilité)
- * Permet de surcharger tous les champs avec custom (testGoals, testEnd, testPersona, testQuery, testResult, testError)
+ * Permet de surcharger tous les champs avec custom
+ * Note: Cette fonction retourne un scenario SANS query - il faut la passer séparément à executeSimulation
  */
 export declare function buildScenarioFromTicket(ticketPath: string, clientType: 'locataire' | 'proprietaire', persona?: string, // PERSONA_PATIENT | PERSONA_PRESSE | PERSONA_ENERVE
-custom?: Partial<SimulationScenario>): SimulationScenario;
+custom?: Partial<SimulationScenario>): {
+    scenario: SimulationScenario;
+    query: string;
+};
 /**
  * Construire SimulationScenario générique directement
+ * Supporte l'ancien format (testGoals, testEnd, etc.) pour rétrocompatibilité
  */
 export declare function buildGenericScenario(scenario: SimulationScenario): SimulationScenario;
 export { PERSONA_PATIENT, PERSONA_PRESSE, PERSONA_ENERVE };

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

@@ -53,7 +53,8 @@ function loadScenario(ticketPath) {
 }
 /**
  * Construire SimulationScenario à partir d'un ticket PRSolver (rétrocompatibilité)
- * Permet de surcharger tous les champs avec custom (testGoals, testEnd, testPersona, testQuery, testResult, testError)
+ * Permet de surcharger tous les champs avec custom
+ * Note: Cette fonction retourne un scenario SANS query - il faut la passer séparément à executeSimulation
  */
 function buildScenarioFromTicket(ticketPath, clientType, persona = simulator_prompts_1.PERSONA_PATIENT, // PERSONA_PATIENT | PERSONA_PRESSE | PERSONA_ENERVE
 custom // Surcharge optionnelle de tous les champs
@@ -61,27 +62,48 @@ custom // Surcharge optionnelle de tous les champs
     const { ticketMarkdown, ticketId } = loadScenario(ticketPath);
     // Scenario par défaut complet
     const defaultScenario = {
-        testGoals: `Valider les Objectifs de PRSolver pour ticket ${ticketId}`,
-        testEnd: 'Agent termine avec salutations (état 5_cloture)',
-        testPersona: persona,
-        testQuery: `Je suis le client (demandeur '${clientType}') du ticket en ANNEXE. Démarre la conversation exactement comme décrit dans l'ANNEXE.      
+        goals: `Valider les Objectifs de PRSolver pour ticket ${ticketId}. Agent termine avec salutations (état 5_cloture)`,
+        persona: persona,
+        result: 'done:boolean, error:string, description:string'
+    };
+    const query = `Je suis le client (demandeur '${clientType}') du ticket en ANNEXE. Démarre la conversation exactement comme décrit dans l'ANNEXE.      
 ## ANNEXE - Ticket ${ticketId}
 \`\`\` 
 ${ticketMarkdown}
 \`\`\`
-    `,
-        testResult: 'done:boolean, error:string, description:string'
-    };
+  `;
     // Merger avec custom
-    return { ...defaultScenario, ...custom };
+    return {
+        scenario: { ...defaultScenario, ...custom },
+        query
+    };
 }
 /**
  * Construire SimulationScenario générique directement
+ * Supporte l'ancien format (testGoals, testEnd, etc.) pour rétrocompatibilité
  */
 function buildGenericScenario(scenario) {
+    // Gérer la rétrocompatibilité avec l'ancien format
+    if (scenario.testGoals || scenario.testEnd || scenario.testError) {
+        // Ancien format détecté - conversion vers le nouveau format
+        let goals = scenario.testGoals || '';
+        if (scenario.testEnd) {
+            goals += `\nCONDITION DE FIN: ${scenario.testEnd}`;
+        }
+        if (scenario.testError) {
+            goals += `\nERREUR FATALE: ${scenario.testError}`;
+        }
+        return {
+            goals: goals.trim(),
+            persona: scenario.testPersona || scenario.persona || '',
+            result: scenario.testResult || scenario.result || '{"success": boolean, "error": string, "description": string}',
+            // Garder testQuery pour extraction ultérieure
+            testQuery: scenario.testQuery
+        };
+    }
+    // Nouveau format - juste ajouter un result par défaut si manquant
     return {
         ...scenario,
-        // Assurer le format par défaut si pas spécifié
-        testResult: scenario.testResult || 'done:boolean, error:string, description:string'
+        result: scenario.result || '{"success": boolean, "error": string, "description": string}'
     };
 }

package/dist/src/agents/system.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.system = void 0;
-const execute_1 = require("../execute");
 const utils_1 = require("../utils");
 const prompts_1 = require("./prompts");
 exports.system = {
     name: "systemReview",
     human: true,
-    model: (0, execute_1.modelConfig)("MEDIUM"),
+    model: "MEDIUM",
     publicDescription: "Agent chargé d'analyser le contenu d'un prompt système et de présenter ses remarques",
     instructions: prompts_1.systemReviewPrompt,
     tools: [],

package/dist/src/execute.d.ts

@@ -1,6 +1,7 @@
 import { AgentConfig, AgenticContext, AgentModel, ExecuteAgentResult, Feedback, ExecutionResult } from "./types";
 import { Writable } from "stream";
 import { AgentStateGraph } from "./stategraph";
+export declare const DummyWritable: any;
 export declare function modelConfig(model: string, custom?: any): AgentModel;
 export declare function sendFeedback(params: Feedback): void;
 export interface ReadCompletionsStreamOptions {
@@ -8,7 +9,7 @@ export interface ReadCompletionsStreamOptions {
     discussion: any;
     agentConfig: AgentConfig;
     agents: AgentConfig[];
-    agentName: string;
+    discussionRootAgent: string;
     stdout: Writable;
     session: AgenticContext;
     final: any;
@@ -19,19 +20,22 @@ export declare function readCompletionsStream(params: ReadCompletionsStreamOptio
 /**
  * Parameters for executing an agent set
  * @interface ExecuteAgentSetParams
- * @property {OpenAI} openai - OpenAI client instance
  * @property {string} query - User query to process
  * @property {string} home - Name of the agent to start with
  * @property {Writable} stdout - Stream to write output to
+ * @property {any[]} [messages] - Messages to add to the conversation
  * @property {boolean} [verbose] - Whether to log verbose debug information
- * @property {number} [maxSteps] - Maximum number of steps to execute
  */
 export interface ExecuteAgentSetParams {
     enrichWithMemory?: (role: string, agent: AgentConfig, context: AgenticContext) => Promise<string>;
     query: string;
     home?: string;
+    model?: string;
     stdout: Writable;
+    messages?: any[];
     verbose?: boolean;
+    json?: boolean;
+    schema?: any;
     debug?: boolean;
 }
 /**
@@ -47,3 +51,13 @@ export interface ExecuteAgentSetParams {
  */
 export declare function executeAgentSet(agentSet: AgentConfig[], context: AgenticContext, params: ExecuteAgentSetParams): Promise<ExecutionResult>;
 export declare function executeAgent(agentSet: AgentConfig[], params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;
+/**
+ * Executes a simple query without agent orchestration or tool handling
+ *
+ * This is the simplest level of execution - just sends a query to the LLM
+ * and returns the response. No tools, no agent transfers, no complex logic.
+ *
+ * @param params - Execution parameters including query and model config
+ * @returns Promise<ExecuteAgentResult> - Simple result with usage and content
+ */
+export declare function executeQuery(params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;