agentic-api 2.0.31 → 2.0.314

package/dist/src/stategraph/stategraph.js

@@ -30,6 +30,7 @@ class AgentStateGraph {
                 description: description,
                 messages: [],
                 usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
+                trailSteps: [], // ✅ Chaque discussion a son propre trail
                 createdAt: new Date(),
                 updatedAt: new Date(),
                 startAgent: agentName
@@ -56,7 +57,7 @@ class AgentStateGraph {
     /**
      * Écrase le message system de la discussion avec un nouvel agent
      * Le message system est toujours messages[0] avec role: "system"
-     * @param agentName Nom de l'agent
+     * @param agentName Nom de l'agent (clé de discussion, reste fixe)
      * @param content Nouveau contenu du message system
      */
     set(agentName, content) {
@@ -64,8 +65,8 @@ class AgentStateGraph {
         const systemMessage = {
             id: (0, crypto_1.randomUUID)(),
             role: 'system',
-            content,
-            agent: agentName,
+            content: content,
+            agent: agentName, // Tag avec la clé de discussion
             timestamp: new Date()
         };
         // Écraser ou créer le message system (toujours en position 0)
@@ -73,8 +74,69 @@ class AgentStateGraph {
             discussion.messages.push(systemMessage);
         }
         else {
-            discussion.messages[0] = systemMessage;
+            discussion.messages[0].content = content;
+            discussion.messages[0].agent = systemMessage.agent;
+            discussion.messages[0].timestamp = new Date();
+        }
+        this.updateSystemMessage(discussion);
+        discussion.updatedAt = new Date();
+    }
+    /**
+     * Ajoute une étape au CONTEXT TRAIL et met à jour le message system
+     * @param agentName Nom de l'agent
+     * @param step Étape à ajouter au trail
+     */
+    addStep(agentName, step) {
+        const discussion = this.discussions.find(d => d.startAgent === agentName);
+        if (!discussion)
+            return;
+        discussion.trailSteps.push(step);
+        this.updateSystemMessage(discussion);
+    }
+    /**
+     * Retourne tous les steps du CONTEXT TRAIL pour une discussion
+     * @param agentName Nom de l'agent
+     * @returns Liste des steps enregistrés pour cette discussion
+     */
+    steps(agentName) {
+        const discussion = this.discussions.find(d => d.startAgent === agentName);
+        // console.log(`🔍 steps: ${agentName} has ${discussion?.trailSteps.length} steps`);
+        return discussion ? [...discussion.trailSteps] : [];
+    }
+    /**
+     * Formate le CONTEXT TRAIL d'une discussion pour injection dans system instructions
+     * @param discussion Discussion à formater
+     * @returns Trail formaté ou message par défaut
+     */
+    formatTrailPrompt(discussion) {
+        if (discussion.trailSteps.length === 0) {
+            return '(No actions yet)';
+        }
+        return discussion.trailSteps.map(s => {
+            const idPart = s.id ? ` [id: ${s.id}]` : '';
+            return `- ${s.tool}: ${s.context} "${s.reason}"${idPart}`;
+        }).join('\n');
+    }
+    /**
+     * Met à jour le message system avec le nouveau trail via regexp
+     * @param agentName Nom de l'agent
+     */
+    updateSystemMessage(discussion) {
+        const systemMessage = discussion.messages.find((m) => m.role === 'system');
+        if (!systemMessage)
+            return;
+        const trail = this.formatTrailPrompt(discussion);
+        const trailBlock = `<context-trail>\n${trail}\n</context-trail>`;
+        const hasTag = systemMessage.content.includes('<context-trail>');
+        // Remplacement via regexp du tag <context-trail>
+        if (hasTag) {
+            systemMessage.content = systemMessage.content.replace(/<context-trail>[\s\S]*?<\/context-trail>/, trailBlock);
+        }
+        else {
+            // Ajouter le tag si absent
+            systemMessage.content += `\n\n${trailBlock}`;
         }
+        systemMessage.timestamp = new Date();
         discussion.updatedAt = new Date();
     }
     /**
@@ -107,9 +169,9 @@ class AgentStateGraph {
             }
             return content;
         };
-        // Filtrer les messages pour le client - exclure system et tool
+        // Filtrer les messages pour le client - exclure system, tool et messages avec name
         const clientMessages = discussion.messages
-            .filter(msg => msg.role !== 'system' && !msg.name)
+            .filter(msg => msg.role !== 'system' && msg.role !== 'tool' && !msg.name)
             .map(msg => ({
             id: msg.id,
             role: msg.role,
@@ -162,6 +224,7 @@ class AgentStateGraph {
             discussion.messages = [];
         }
         // Réinitialiser l'usage
+        discussion.trailSteps = [];
         discussion.usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
         discussion.updatedAt = new Date();
     }
@@ -211,6 +274,29 @@ class AgentStateGraph {
         }
         return agentName;
     }
+    /**
+     * Charge une discussion en remplaçant l'existante ou en créant une nouvelle
+     * Recherche par id en priorité, sinon par startAgent
+     * @param discussion Discussion à charger
+     */
+    load(discussion) {
+        // Chercher discussion existante par id OU par startAgent
+        const index = this.discussions.findIndex(d => d.id === discussion.id || d.startAgent === discussion.startAgent);
+        if (index >= 0) {
+            // Remplacer l'existante
+            this.discussions[index] = {
+                ...discussion,
+                updatedAt: new Date()
+            };
+        }
+        else {
+            // Créer nouvelle
+            this.discussions.push({
+                ...discussion,
+                updatedAt: new Date()
+            });
+        }
+    }
     /**
      * Sérialise le StateGraph en JSON
      * @returns Représentation JSON
@@ -230,6 +316,7 @@ class AgentStateGraph {
                 ...d,
                 createdAt: new Date(d.createdAt),
                 updatedAt: new Date(d.updatedAt),
+                trailSteps: d.trailSteps || [], // ✅ Rétrocompatibilité : initialiser vide si absent
                 messages: d.messages.map((m) => ({
                     ...m,
                     timestamp: new Date(m.timestamp)

package/dist/src/stategraph/stategraph.storage.js

@@ -71,6 +71,10 @@ function sessionStateGraphSet(context, stateGraph) {
         const compressed = (0, zlib_1.gzipSync)(Buffer.from(jsonData, 'utf8'));
         // Stocker en base64 dans la session
         session[SESSION_STATEGRAPH_KEY] = compressed.toString('base64');
+        // Force express-session à marquer la session comme modifiée
+        if (typeof session.touch === 'function') {
+            session.touch();
+        }
         // Logging pour debug (taille avant/après compression)
         if (process.env.NODE_ENV === 'development') {
             const originalSize = Buffer.byteLength(jsonData, 'utf8');

package/dist/src/stategraph/types.d.ts

@@ -33,6 +33,20 @@ export interface TokenUsage {
     /** Coût estimé en USD (optionnel) */
     cost?: number;
 }
+/**
+ * Step du CONTEXT TRAIL - trace une action significative
+ * Utilisé pour maintenir une mémoire de travail des actions effectuées par les outils
+ */
+export interface StepTrail {
+    /** Nom de l'outil (ex: "transferAgents", "database") */
+    tool: string;
+    /** Contexte de l'action (ex: "orientation → guess-word") */
+    context: string;
+    /** Justification/raison de l'action */
+    reason: string;
+    /** ID optionnel pour détection de boucles */
+    id?: string;
+}
 /**
  * Discussion d'agent - thread de messages pour un agent spécifique
  * Remplace l'ancienne AgenticMemorySession
@@ -48,6 +62,8 @@ export interface AgentDiscussion {
     messages: AgentMessage[];
     /** Usage des tokens pour cette discussion */
     usage: TokenUsage;
+    /** CONTEXT TRAIL - steps des actions significatives */
+    trailSteps: StepTrail[];
     /** Date de création */
     createdAt: Date;
     /** Date de dernière mise à jour */
@@ -104,6 +120,12 @@ export interface AgentStateGraph {
      * @returns true si le message a été supprimé, false s'il n'a pas été trouvé
      */
     deleteMessage(agentName: string, messageId: string): boolean;
+    /**
+     * Charge une discussion en remplaçant l'existante ou en créant une nouvelle
+     * Cherche par id OU par startAgent
+     * @param discussion Discussion à charger
+     */
+    load(discussion: AgentDiscussion): void;
 }
 /**
  * Vue client d'une discussion (filtrée)

package/dist/src/types.d.ts

@@ -33,6 +33,7 @@ export interface AgentModel {
     temperature: null;
     maxTokens: number;
     topP?: number;
+    stream?: boolean;
     parallel_tool_calls: boolean;
     frequencyPenalty?: number;
     presencePenalty?: number;
@@ -47,7 +48,8 @@ export interface AgentModel {
 }
 export interface AgentConfig {
     name: string;
-    model: AgentModel;
+    groupName?: string;
+    model: string;
     human?: boolean;
     publicDescription: string;
     instructions: string;
@@ -65,8 +67,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>;

package/dist/src/types.js

@@ -42,7 +42,7 @@ 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 || [])],
+        actions: [],
         lastMessage: a.lastMessage || '',
         usage: {
             prompt: (a.usage?.prompt || 0) + (b.usage?.prompt || 0),

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,
+        home: 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,32 @@
 "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');
+    }
+    const options = {
+        apiKey: process.env[envKey],
+        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 +51,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 +85,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 +112,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 +137,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 }) => ({
@@ -194,18 +180,25 @@ 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é.`,
                 did_transfer: false,
                 name: functionCallParams.function.name
             };
@@ -244,62 +237,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);
-}