agentic-api 2.0.31 → 2.0.491

package/dist/src/types.d.ts

@@ -9,12 +9,20 @@ export interface ToolParameterProperty {
     required?: string[];
     additionalProperties?: boolean;
     items?: ToolParameterProperty;
+    minLength?: number;
+    maxLength?: number;
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    default?: any;
+    [key: string]: any;
 }
 export interface ToolParameters {
     type: string;
     properties: Record<string, ToolParameterProperty>;
     required?: string[];
     additionalProperties?: boolean;
+    [key: string]: any;
 }
 export interface Tool {
     type: "function";
@@ -25,6 +33,17 @@ export interface Tool {
         strict: boolean;
     };
 }
+export type ToolContractOutput<T> = {
+    status: "ok" | "success" | "empty" | "error" | "transfer_required" | "multiple_results";
+    items?: T[];
+    meta?: Record<string, any>;
+    control?: {
+        next_hint?: string;
+        can_retry: boolean;
+        error_code?: string;
+        transfer_message?: string;
+    };
+};
 export interface AgentModelMapping {
     [key: string]: string;
 }
@@ -33,21 +52,37 @@ export interface AgentModel {
     temperature: null;
     maxTokens: number;
     topP?: number;
+    stream?: boolean;
     parallel_tool_calls: boolean;
-    frequencyPenalty?: number;
-    presencePenalty?: number;
     stop?: string[] | string;
     tool_choice?: "auto" | "none" | "required";
     /**
      * Timeout in milliseconds for a query.
-     * If not specified, the default  (10 minutes).
+     * If not specified, the default (10 minutes).
      * https://platform.openai.com/docs/guides/flex-processing#api-request-timeouts
      */
     timeout?: number;
+    verbosity?: string;
+    reasoning_effort?: string;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    text?: {
+        verbosity?: string;
+        format?: {
+            type: string;
+            name?: string;
+            schema?: any;
+            strict?: boolean;
+        };
+    };
+    reasoning?: {
+        effort: string;
+    };
 }
 export interface AgentConfig {
     name: string;
-    model: AgentModel;
+    groupName?: string;
+    model: string;
     human?: boolean;
     publicDescription: string;
     instructions: string;
@@ -65,8 +100,8 @@ export interface AgentConfig {
 export interface UserNano {
     id: string;
     isAnonymous?: boolean;
-    role: string;
     uid?: string;
+    [key: string]: any;
 }
 export type AgenticCache = {
     get: <T>(key: string) => Promise<T | null>;
@@ -83,6 +118,7 @@ export interface AgenticContext {
     session: any;
     [key: string]: any;
     currentAgent?: AgentConfig;
+    discussionRootAgent?: string;
 }
 export type AllAgentConfigsType = Record<string, AgentConfig[]>;
 export interface Usage {
@@ -128,7 +164,8 @@ export interface ExecutionAction {
  * - `lastMessage`: The final assistant message content after execution.
  * - `usage`: Token usage/cost snapshot for the whole execution.
  * - `error`: Optional error message if something went wrong (non-fatal).
- * - `moreThinkin`: When true, caller should continue the execution loop (retro-compat flag).
+ *
+ * NOTE: `moreThinkin` was removed (obsolete) - reasoning_effort in modelConfig handles this natively
  */
 export interface ExecutionResult {
     runId: string;
@@ -138,7 +175,6 @@ export interface ExecutionResult {
     lastMessage: string;
     usage: Usage;
     error?: string;
-    moreThinkin: boolean;
     /**
      * Human-readable summary formatter. Optional to preserve backward compatibility.
      */
@@ -150,10 +186,11 @@ export interface ExecutionResult {
  * Merge strategy:
  * - `runId`: preserved from the primary accumulator `a`.
  * - `actions`: appended in order (a.actions then b.actions).
- * - `lastMessage`: preserved from `a` unless set elsewhere later in the workflow.
+ * - `lastMessage`: prioritize more recent (b) over older (a).
  * - `usage`: summed field-by-field to accumulate totals across steps.
  * - `error`: keep the latest non-undefined error (prefer `b`).
- * - `moreThinkin`: true if either `a` or `b` requests continued thinking.
+ *
+ * NOTE: moreThinkin removed (obsolete) - always returns false
  */
 export declare function enrichExecutionResult(result: ExecutionResult): ExecutionResult;
 export declare function executionResultMerge(a: ExecutionResult, b: ExecutionResult): ExecutionResult;

package/dist/src/types.js

@@ -8,10 +8,11 @@ exports.executionResultMerge = executionResultMerge;
  * Merge strategy:
  * - `runId`: preserved from the primary accumulator `a`.
  * - `actions`: appended in order (a.actions then b.actions).
- * - `lastMessage`: preserved from `a` unless set elsewhere later in the workflow.
+ * - `lastMessage`: prioritize more recent (b) over older (a).
  * - `usage`: summed field-by-field to accumulate totals across steps.
  * - `error`: keep the latest non-undefined error (prefer `b`).
- * - `moreThinkin`: true if either `a` or `b` requests continued thinking.
+ *
+ * NOTE: moreThinkin removed (obsolete) - always returns false
  */
 function enrichExecutionResult(result) {
     const formatAction = (action, index) => {
@@ -29,7 +30,7 @@ function enrichExecutionResult(result) {
         if (result.error) {
             lines.push(`error: ${result.error}`);
         }
-        lines.push(`moreThinkin: ${Boolean(result.moreThinkin)}`);
+        // moreThinkin removed (obsolete) - reasoning_effort fait le job
         const actions = result.actions || [];
         lines.push(`actions (${actions.length}):`);
         actions.forEach((a, i) => lines.push(`  - ${formatAction(a, i)}`));
@@ -42,16 +43,16 @@ function executionResultMerge(a, b) {
     const merged = {
         runId: a.runId && a.runId.length > 0 ? a.runId : b.runId,
         startQuery: a.startQuery || b.startQuery || '',
-        actions: [...(a.actions || []), ...(b.actions || [])],
-        lastMessage: a.lastMessage || '',
+        actions: [...(a.actions || []), ...(b.actions || [])], // ✅ BUG FIX: Fusionner les actions
+        lastMessage: b.lastMessage || a.lastMessage || '', // ✅ BUG FIX: Prioriser le plus récent (b)
         usage: {
             prompt: (a.usage?.prompt || 0) + (b.usage?.prompt || 0),
             completion: (a.usage?.completion || 0) + (b.usage?.completion || 0),
             total: (a.usage?.total || 0) + (b.usage?.total || 0),
             cost: (a.usage?.cost || 0) + (b.usage?.cost || 0),
         },
-        error: b.error ?? a.error,
-        moreThinkin: Boolean(a.moreThinkin || b.moreThinkin),
+        error: b.error ?? a.error
+        // moreThinkin removed (obsolete) - reasoning_effort fait le job
     };
     return enrichExecutionResult(merged);
 }

package/dist/src/usecase.d.ts

@@ -1,4 +1,13 @@
-export declare function callGPTToExtractUserQueries(inputsection: string, file: string): Promise<{
-    json: any;
+import { UsecaseExtractionOptions } from "./prompts";
+/**
+ * Extrait les use cases d'une section de document en utilisant un LLM via executeQuery
+ *
+ * @param inputsection - Le contenu de la section à analyser
+ * @param file - Le nom du fichier source
+ * @param options - Options d'extraction (optionnel)
+ * @returns Promise avec le JSON des queries et le coût
+ */
+export declare function llmExtractUserQueries(inputsection: string, file: string, options?: UsecaseExtractionOptions): Promise<{
+    json: string;
     cost: number;
 }>;

package/dist/src/usecase.js

@@ -1,44 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callGPTToExtractUserQueries = callGPTToExtractUserQueries;
-const princing_openai_1 = require("./princing.openai");
+exports.llmExtractUserQueries = llmExtractUserQueries;
 const prompts_1 = require("./prompts");
-const utils_1 = require("./utils");
-async function callGPTToExtractUserQueries(inputsection, file) {
-    const openai = (0, utils_1.openaiInstance)();
+const execute_1 = require("./execute");
+/**
+ * Extrait les use cases d'une section de document en utilisant un LLM via executeQuery
+ *
+ * @param inputsection - Le contenu de la section à analyser
+ * @param file - Le nom du fichier source
+ * @param options - Options d'extraction (optionnel)
+ * @returns Promise avec le JSON des queries et le coût
+ */
+async function llmExtractUserQueries(inputsection, file, options = { model: "LOW-fast" }) {
     // Format: YYYY-MM-DD
     const today = new Date().toISOString().substring(0, 10);
-    // Créer le prompt pour décrire la tâche au LLM
-    const messages = [
-        {
-            role: "system",
-            content: (0, prompts_1.usecaseExtractionPrompt)(file)
-        },
-        {
-            role: "user",
-            content: `Nous sommes le ${today}.\nVoici le document à analyser :\n${inputsection}`
-        }
-    ];
-    // WARNING: o3-mini is buggy with "Marche à suivre nouveau bail.pdf"
-    //const model = "o3-mini";// "gpt-4o-mini";
-    const model = "gpt-5-mini";
-    const response = await openai.chat.completions.create({
-        model: model,
-        reasoning_effort: "low",
-        verbosity: "low",
-        messages,
-        //reasoning_effort:"low",
-        response_format: { type: "json_object" }
-    });
+    // Construire le prompt complet en combinant système et utilisateur
+    const systemPrompt = (0, prompts_1.usecaseExtractionPrompt)(file);
+    const userContent = `Nous sommes le ${today}.\nVoici le document à analyser :\n${inputsection}`;
+    // Combiner les prompts pour executeQuery (qui prend un seul message utilisateur)
+    const query = `${systemPrompt}\n\n---\n\n${userContent}`;
+    //
+    // Utiliser executeQuery pour exécuter la requête
     // response_format: { type: "json_object" }
-    const cost = (0, princing_openai_1.calculateCost)(model, response.usage);
-    // Récupérer la réponse markdown
-    const json = response.choices[0].message.content;
+    const result = await (0, execute_1.executeQuery)({
+        query,
+        model: options.model,
+        stdout: execute_1.DummyWritable,
+        verbose: false,
+        json: true
+    });
+    const json = result.content;
+    const cost = result.usage.cost;
     console.log(`Markdown 💰 cost: ${cost}`);
-    //
-    // add a regex to extract the markdown content between <thinking></thinking> tags
-    // const thinking = markdown.match(/<thinking>[\s\S]*?<\/thinking>/)?.[0];
-    // const markdownWithoutThinking = markdown.replace(/<thinking>[\s\S]*?<\/thinking>/g, '');
-    // return markdownWithoutThinking;
     return { json, cost };
 }

package/dist/src/utils.d.ts

@@ -1,6 +1,13 @@
 import { ParsedFunctionToolCall } from "openai/resources/beta/chat/completions";
 import { AgentConfig, AgenticContext } from "./types";
-export declare const openaiInstance: (openai?: any) => any;
+import OpenAI from "openai";
+/**
+ * global openai instance
+ */
+declare global {
+    var _openaiInstance_: OpenAI | undefined;
+}
+export declare const openaiInstance: (envKey?: string, baseUrl?: string) => OpenAI;
 /**
  * Converts a string to a URL-friendly slug
  * @param text The text to convert to a slug
@@ -8,27 +15,34 @@ export declare const openaiInstance: (openai?: any) => any;
  * @returns A URL-friendly slug
  */
 export declare const toSlug: (text: string, whitespace?: string) => string;
+/**
+ * Contrat standard JSON pour le transfert (handoff) entre agents.
+ *
+ * Ce contrat décrit le format attendu lors d'un transfert via l'outil "transferAgents".
+ * Il doit être inclut dans la documentation de l'outil pour garantir l'interopérabilité.
+ *
+ * Exemple de contrat (format JSON) :
+ *
+ * ```json
+ * {
+ *   "subject_id": "sha1(intention_normalisee_id|bien|acteur)", // Identifiant unique du sujet
+ *   "intention": "<string>", // Intention normalisée de la demande
+ *   "decision_preliminaire": "S1|S2|S3", // Décision préliminaire prise (catégorisation)
+ *   "meme_sujet_bons_ouverts": "string", // Identifiants ou liens vers dossiers ouverts liés au même sujet
+ *   "urgency": "standard|prioritaire|urgent", // Niveau d'urgence de la demande
+ *   "mood": "<string>", // État émotionnel détecté ou exprimé
+ *   "next_action": "<string>", // Prochaine action préconisée ou à effectuer
+ *   "multiple_subjects": "string" // Autres sujets/discussions associés (optionnel)
+ * }
+ * ```
+ *
+ * À intégrer dans la définition des outils de transfert pour chaque agent métier impliqué dans un handoff.
+ */
 /**
  * This defines and adds "transferAgents" tool dynamically based on the specified downstreamAgents on each agent.
+ * https://github.com/openai/openai-realtime-agents/blob/without-agents-sdk/src/app/agentConfigs/utils.ts
  */
 export declare function injectTransferTools(agentDefs: AgentConfig[]): AgentConfig[];
 export declare function handleTransferCall(discussion: any, currentAgentRef: {
     name: string;
 }, agents: AgentConfig[], functionCallParams: ParsedFunctionToolCall, context: AgenticContext): Promise<any>;
-/**
- * Calls the system review agent to analyze a prompt
- *
- * This function sends a prompt to the system review agent and returns its analysis.
- * The system review agent evaluates prompts based on various criteria like clarity,
- * identity, scope, decision logic, etc.
- *
- * @param {string} prompt - The prompt text to be analyzed by the system review agent
- * @param {Object} params - Parameters for the API call
- * @param {Object} params.openai - The OpenAI client instance
- * @param {Object} params.defaultOptions - Default options to be merged with agent model options
- * @returns {Promise<string>} The analysis response from the system review agent
- */
-export declare function callForSystemReview(prompt: string, params: any): Promise<{
-    content: any;
-    cost: number;
-}>;

package/dist/src/utils.js

@@ -1,21 +1,34 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toSlug = exports.openaiInstance = void 0;
 exports.injectTransferTools = injectTransferTools;
 exports.handleTransferCall = handleTransferCall;
-exports.callForSystemReview = callForSystemReview;
 const prompts_1 = require("./prompts");
-const system_1 = require("./agents/system");
-const princing_openai_1 = require("./princing.openai");
-let _openaiInstance;
-const openaiInstance = function (openai) {
-    if (openai) {
-        _openaiInstance = openai;
+const openai_1 = __importDefault(require("openai"));
+const openaiInstance = function (envKey, baseUrl) {
+    if (globalThis._openaiInstance_) {
+        return globalThis._openaiInstance_;
+    }
+    if (!envKey) {
+        throw new Error('AI API key is missing');
+    }
+    // 
+    // use multiple fallback if envKey is not set
+    const options = {
+        apiKey: process.env[envKey] || envKey || process.env.API_LLM_KEY || process.env.OPENAI_API_KEY,
+        timeout: 60000 * 15
+    };
+    if (baseUrl) {
+        options.baseURL = baseUrl;
     }
-    if (!_openaiInstance) {
+    globalThis._openaiInstance_ = new openai_1.default(options);
+    if (!globalThis._openaiInstance_) {
         throw new Error('OpenAI instance has not been initialized');
     }
-    return _openaiInstance;
+    return globalThis._openaiInstance_;
 };
 exports.openaiInstance = openaiInstance;
 /**
@@ -40,8 +53,32 @@ const toSlug = (text, whitespace = '-') => {
         .replace(new RegExp(`^\\${whitespace}+|\\${whitespace}+$`, 'g'), ''); // Trim whitespace char (escape for regex)
 };
 exports.toSlug = toSlug;
+/**
+ * Contrat standard JSON pour le transfert (handoff) entre agents.
+ *
+ * Ce contrat décrit le format attendu lors d'un transfert via l'outil "transferAgents".
+ * Il doit être inclut dans la documentation de l'outil pour garantir l'interopérabilité.
+ *
+ * Exemple de contrat (format JSON) :
+ *
+ * ```json
+ * {
+ *   "subject_id": "sha1(intention_normalisee_id|bien|acteur)", // Identifiant unique du sujet
+ *   "intention": "<string>", // Intention normalisée de la demande
+ *   "decision_preliminaire": "S1|S2|S3", // Décision préliminaire prise (catégorisation)
+ *   "meme_sujet_bons_ouverts": "string", // Identifiants ou liens vers dossiers ouverts liés au même sujet
+ *   "urgency": "standard|prioritaire|urgent", // Niveau d'urgence de la demande
+ *   "mood": "<string>", // État émotionnel détecté ou exprimé
+ *   "next_action": "<string>", // Prochaine action préconisée ou à effectuer
+ *   "multiple_subjects": "string" // Autres sujets/discussions associés (optionnel)
+ * }
+ * ```
+ *
+ * À intégrer dans la définition des outils de transfert pour chaque agent métier impliqué dans un handoff.
+ */
 /**
  * This defines and adds "transferAgents" tool dynamically based on the specified downstreamAgents on each agent.
+ * https://github.com/openai/openai-realtime-agents/blob/without-agents-sdk/src/app/agentConfigs/utils.ts
  */
 function injectTransferTools(agentDefs) {
     // Iterate over each agent definition
@@ -50,67 +87,18 @@ function injectTransferTools(agentDefs) {
             return;
         }
         const downstreamAgents = agentDef.downstreamAgents || [];
-        //
-        // Add the think tool if maxSteps is set
-        // https://www.aihero.dev/implementing-anthropics-think-tool-in-typescript
-        if (agentDef.maxSteps && agentDef.maxSteps > 0) {
-            const description = `
-Use the tool as a helper to think about something with a plan of multiple steps.
-It will not obtain new information or change the database, but just append the thought to the log.
-Use it when complex reasoning or some cache memory is needed.
-To avoid infinite thinking, the tool is limited to ${agentDef.maxSteps} calls.
-
-It takes two arguments:
-- thought (str): A thought to think about.
-- step (int): The incremented step number that constrains the global thinking with a limitation of ${agentDef.maxSteps} calls.
-`;
-            const think = {
-                type: "function",
-                function: {
-                    name: "thinking",
-                    description,
-                    strict: true,
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            justification: {
-                                type: "string",
-                                description: "The reasoning why this thinking is needed.",
-                            },
-                            thought: {
-                                type: "string",
-                                description: "A thought to think about.",
-                            },
-                            step: {
-                                type: "number",
-                                description: "The incremented step number that constrains the global thinking.",
-                            },
-                        },
-                        required: ["justification", "thought", "step"],
-                        additionalProperties: false,
-                    },
-                }
-            };
-            // Ensure the agent has a tools array
-            if (!agentDef.tools) {
-                agentDef.tools = [];
-            }
-            console.log('--- DBG addTools', agentDef.name, 'with think step', agentDef.maxSteps);
-            // Add the newly created tool to the current agent's tools
-            agentDef.tools.push(think);
-        }
         // Only proceed if there are downstream agents
         if (downstreamAgents.length > 0) {
             // Build a list of downstream agents and their descriptions for the prompt
             const availableAgentsList = downstreamAgents
-                .map((dAgent) => `- ${dAgent.name}: ${dAgent.publicDescription ?? "No description"} ${dAgent.human ? '(human agent, less specialized)' : ''}`)
+                .map((dAgent) => `- ${dAgent.name}: ${dAgent.publicDescription ?? "No description"} ${dAgent.human ? '(⚠️ root agent for orientation)' : ''}`)
                 .join("\n");
             // Create the transfer_agent tool specific to this agent
             const transferAgentTool = {
                 type: "function",
                 function: {
                     name: "transferAgents",
-                    description: `${prompts_1.transferAgentPrompt.replace('__AGENT_NAME__', agentDef.name)}
+                    description: `${prompts_1.transferAgentPromptStructured.replace('__AGENT_NAME__', agentDef.name)}
 ${availableAgentsList}
           `,
                     parameters: {
@@ -126,7 +114,7 @@ ${availableAgentsList}
                             },
                             destination_agent: {
                                 type: "string",
-                                description: "The more specialized destination_agent that should handle the user’s intended request.",
+                                description: "The more specialized destination_agent that should handle the user's intended request.",
                                 enum: downstreamAgents.map((dAgent) => dAgent.name),
                             },
                             confidence: {
@@ -151,7 +139,7 @@ ${availableAgentsList}
             }
             // Add the newly created tool to the current agent's tools
             agentDef.tools.push(transferAgentTool);
-            // console.log('--- DBG injectTransferTools',agentDef.name,'with new transfer',JSON.stringify(transferAgentTool.function.parameters,null,2 ));
+            // console.log('--- DBG injectTransferTools',agentDef.name,transferAgentTool.function.description);
         }
         // so .stringify doesn't break with circular dependencies
         agentDef.downstreamAgents = agentDef.downstreamAgents?.map(({ name, publicDescription, human }) => ({
@@ -166,6 +154,14 @@ ${availableAgentsList}
 //
 // Fonction pour gérer un appel de fonction retourné par OpenAI
 // le contexte est un objet qui contient des informations supplémentaires de session
+//
+// TODO [Phase 2 - openai-agents-js]: 
+// Cette logique de handleTransferCall sera remplacée par le handoff natif
+// de openai-agents-js (https://openai.github.io/openai-agents-js/)
+// qui gère les transferts via policies et router intégrés.
+// Les concepts de downstreamAgents et confidence seront mappés 
+// vers les primitives de l'Agent SDK (swarm.run, handoff strategies).
+// Le stateGraph restera compatible car il utilise AgentMessage générique.
 async function handleTransferCall(discussion, currentAgentRef, agents, functionCallParams, context) {
     const currentAgentName = currentAgentRef.name;
     const args = JSON.parse(functionCallParams?.function?.arguments || '{}');
@@ -194,18 +190,26 @@ async function handleTransferCall(discussion, currentAgentRef, agents, functionC
         if (destinationAgent) {
             //console.log(`🤖 Agent "${destinationAgent.name}" en préparation`);
             currentAgentRef.name = destinationAgent.name;
+            //
+            // Generate ID for CONTEXT TRAIL (loop detection)
+            const transferId = (0, exports.toSlug)(args.rationale_for_transfer);
             return {
-                feedback: args.rationale_for_transfer,
+                name: functionCallParams.function.name, // ← tool pour addStep
+                feedback: args.rationale_for_transfer, // ← reason pour addStep
+                context: `${currentAgentName} → ${destinationAgentName}`, // ← context pour addStep
+                id: transferId, // ← ID optionnel pour addStep
                 destination_agent: destinationAgentName,
                 source_agent: currentAgentName,
-                did_transfer: true,
-                name: functionCallParams.function.name
+                content: '', // ✅ Transfert silencieux
+                did_transfer: true
             };
         }
         else {
-            console.log("❌ Agent non trouvé !");
+            console.log(`❌L'agent destination "${destinationAgentName}" n'a pas été trouvé.`);
             return {
-                feedback: "L'agent destination n'a pas été trouvé.",
+                feedback: `❌ L'agent destination "${destinationAgentName}" n'a pas été trouvé.`,
+                content: `❌L'agent destination "${destinationAgentName}" n'a pas été trouvé.`,
+                context: `❌L'agent destination "${destinationAgentName}" n'a pas été trouvé.`,
                 did_transfer: false,
                 name: functionCallParams.function.name
             };
@@ -226,11 +230,24 @@ async function handleTransferCall(discussion, currentAgentRef, agents, functionC
     // ⚠️ ALWAYS inject context in tool logic, ALWAYS!
     const agent = agents.find(a => a.name === currentAgentRef.name);
     if (agent?.toolLogic && agent.toolLogic[functionCallParams.function.name]) {
-        const { content, usage } = await agent.toolLogic[functionCallParams.function.name](args, context);
+        const rawResult = await agent.toolLogic[functionCallParams.function.name](args, context);
+        //
+        // ✅ Le tool peut retourner { content, context, id, usage? } OU ToolContractOutput
+        // - Si content existe → utiliser le texte formaté
+        // - Sinon → préserver rawResult pour sérialisation (ToolContractOutput)
+        // - context: identifiant sémantique unique pour le trail (ex: "intention_123", "daily-events")
+        // - id: slug unique pour détection de boucles (généralement dérivé du context)
+        // Si le tool ne fournit pas context/id, on utilise le nom du tool comme fallback
+        const toolContext = rawResult.context || 'Null';
+        const toolId = rawResult.id || args.justification || JSON.stringify(args);
         return {
-            content,
+            content: rawResult.content, // ✅ Peut être undefined pour ToolContractOutput
             name: functionCallParams.function.name,
-            usage
+            context: toolContext,
+            id: toolId,
+            usage: rawResult.usage,
+            feedback: rawResult.feedback,
+            rawResult: rawResult // ✅ Préserver le résultat brut pour sérialisation
         };
     }
     else {
@@ -244,62 +261,3 @@ async function handleTransferCall(discussion, currentAgentRef, agents, functionC
         };
     }
 }
-/**
- * Calls the system review agent to analyze a prompt
- *
- * This function sends a prompt to the system review agent and returns its analysis.
- * The system review agent evaluates prompts based on various criteria like clarity,
- * identity, scope, decision logic, etc.
- *
- * @param {string} prompt - The prompt text to be analyzed by the system review agent
- * @param {Object} params - Parameters for the API call
- * @param {Object} params.openai - The OpenAI client instance
- * @param {Object} params.defaultOptions - Default options to be merged with agent model options
- * @returns {Promise<string>} The analysis response from the system review agent
- */
-async function callForSystemReview(prompt, params) {
-    const { openai, defaultOptions } = params;
-    const agent = system_1.system;
-    const options = Object.assign({}, agent.model, defaultOptions || {});
-    const jsonOptions = `
-- L'option JSON a été activée, tu dois respecter le format brut suivant \`
-{
-  directives: [
-    {"directive": "...","criteria": [{"criterion": "...","score": "...","comment": "..."}]},
-    ...
-  ]
-}
-\``;
-    //
-    // add the initial agent to his memory
-    // Handle two-shot prompting: if instructions is an array, use the first part as a system message
-    const instructions = agent.instructions;
-    options.messages = [
-        { role: "system", content: instructions }
-    ];
-    if (options.response_format?.type == "json_object") {
-        options.messages.push({ role: "user", content: jsonOptions });
-    }
-    options.messages.push({ role: "user", content: `tu dois analyser toutes les directives:\n ${prompt}` });
-    let thinking = 1;
-    //
-    // loop until the agent has finished thinking
-    do {
-        const response = await openai.chat.completions.create(options);
-        const cost = (0, princing_openai_1.calculateCost)(options.model, response.usage);
-        if (options.response_format?.type == "json_object") {
-            const content = JSON.parse(response.choices[0].message.content || '{}');
-            return { content, cost };
-        }
-        // Handle two-shot prompting: if instructions is an array, send the second part as a user message
-        // This allows for more complex agent behavior by providing additional context or instructions
-        // after the initial response, similar to chain-of-thought prompting
-        if (!Array.isArray(agent.instructions) || thinking >= agent.instructions.length) {
-            const content = response.choices[0].message.content;
-            return { content, cost };
-        }
-        const instructions = agent.instructions[thinking];
-        options.messages.push({ role: "user", content: instructions });
-        thinking++;
-    } while (true);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-api",
-  "version": "2.0.31",
+  "version": "2.0.491",
   "description": "API pour l'orchestration d'agents intelligents avec séquences et escalades automatiques",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -10,7 +10,13 @@
   "scripts": {
     "prebuild": "npm version patch --no-git-tag-version",
     "build": "tsc",
-    "test": "jest",
+    "test": "jest --silent",
+    "test:quiet": "jest --testPathIgnorePatterns=agent* --silent tests",
+    "test:verbose": "jest --testPathIgnorePatterns=agent* --verbose tests",
+    "test:simulator": "jest --testNamePattern=simulator.* --silent tests",
+    "test:simulator:quiet": "jest --testNamePattern=simulator.* --silent tests",
+    "test:merge-recovery": "jest --testPathPattern=merge-recovery --verbose",
+    "test:merge-recovery:single": "jest --testPathPattern=merge-recovery --testNamePattern=corrupted-index-from-previous-pr --verbose",
     "lint": "eslint 'src/**/*.ts'",
     "prepublishOnly": "npm run build",
     "extract:pdf": "texttopdf ",
@@ -21,12 +27,13 @@
   },
   "dependencies": {
     "@mozilla/readability": "^0.6.0",
+    "async-mutex": "^0.5.0",
     "dotenv": "^16.4.7",
     "hnswlib-node": "^3.0.0",
     "jsdom": "^26.0.0",
     "minisearch": "^7.1.0",
     "natural": "^8.1.0",
-    "openai": "^4.102.0",
+    "openai": "^5.23.2",
     "simple-git": "^3.27.0",
     "stopwords-fr": "^0.3.0"
   },