agentic-api 2.0.314 → 2.0.585

package/dist/src/{execute.js → execute/legacy.js}

@@ -1,94 +1,72 @@
 "use strict";
+/**
+ * Legacy Implementation - Chat Completions API (beta.chat.completions)
+ *
+ * ⚠️ Cette implémentation utilise openai.beta.chat.completions.stream (ancienne API)
+ * Pour les nouveaux projets, Responses API (responses.ts) est recommandée.
+ *
+ * Code optimisé depuis execute.ts original avec les améliorations suivantes:
+ * - OPTIM: Helpers centralisés (accumulateUsageTokens, stepsToActions)
+ * - BUG FIX: executionResultMerge fusionne actions correctement (corrigé dans types.ts)
+ * - BUG FIX: moreThinkin supprimé (obsolète, reasoning_effort fait le job)
+ * - BUG FIX: Suppression de la boucle do...while(moreThinkin)
+ * - BUG FIX: Suppression de la ligne reasoning_effort dupliquée (ligne 425 originale)
+ *
+ * TODO [Optimisation future]: Remplacer la boucle for séquentielle par batchProcessToolCalls
+ * pour exploiter pleinement parallel_tool_calls et réduire la latence
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DummyWritable = void 0;
-exports.modelConfig = modelConfig;
-exports.sendFeedback = sendFeedback;
 exports.readCompletionsStream = readCompletionsStream;
 exports.executeAgentSet = executeAgentSet;
 exports.executeAgent = executeAgent;
 exports.executeQuery = executeQuery;
-const types_1 = require("./types");
-const utils_1 = require("./utils");
-const stategraph_1 = require("./stategraph");
-const pricing_llm_1 = require("./pricing.llm");
-exports.DummyWritable = {
-    write: () => { }
-};
-function modelConfig(model, custom) {
-    const defaultOptions = Object.assign({
-        stream_options: { "include_usage": true },
-    }, custom || {});
-    // Get mapping based on provider
-    const mapping = (0, pricing_llm_1.LLM)((0, utils_1.openaiInstance)());
-    const options = Object.assign(mapping[model], defaultOptions);
-    return options;
-}
-function sendFeedback(params) {
-    const { agent, stdout, description, usage, state, verbose } = params;
-    const feedback = {
-        agent,
-        description,
-        usage,
-        state
-    };
-    // if(verbose) {
-    //   console.log('--- DBG sendFeedback:',agent, description || '--', state);
-    // }
-    //
-    // send agent state and description
-    stdout.write(`\n<step>${JSON.stringify(feedback)}</step>\n`);
-}
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const stategraph_1 = require("../stategraph");
+const pricing_llm_1 = require("../pricing.llm");
+//
+// Import des utilitaires partagés et helpers optimisés
+const shared_1 = require("./shared");
+const modelconfig_1 = require("./modelconfig");
+const helpers_1 = require("./helpers");
 async function readCompletionsStream(params) {
     const openai = (0, utils_1.openaiInstance)();
-    //
-    // set default context here
-    const { stateGraph, discussion, agentConfig, agents, discussionRootAgent, stdout, final, session, verbose } = params;
-    const model = modelConfig(agentConfig.model).model;
+    const { stateGraph, discussion, agentConfig, agents, discussionRootAgent, stdout, final, context, verbose } = params;
+    const model = (0, modelconfig_1.modelConfig)(agentConfig.model).model;
     const accumulatedFunctionCall = final.choices[0]?.message.tool_calls || [];
     const content = final.choices[0]?.message.content;
-    let thinking = false;
     let localResult = (0, types_1.enrichExecutionResult)({
         runId: `${discussionRootAgent}-${Date.now()}`,
         startQuery: '',
         actions: [],
         lastMessage: '',
         usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
-        moreThinkin: false,
-    });
-    // Accumulate cost in the discussion usage
-    (0, pricing_llm_1.accumulateCost)(discussion.usage, model, final.usage);
-    stateGraph.updateTokens(discussionRootAgent, {
-        prompt: final.usage?.prompt_tokens || 0,
-        completion: final.usage?.completion_tokens || 0,
-        total: final.usage?.total_tokens || 0,
-        cost: 0 // Cost already accumulated directly in discussion.usage
     });
-    // Store state (implementation can be added later if needed)
-    // discussion.state = final.id;
+    //
+    // OPTIM: Utiliser helper centralisé pour l'accumulation
+    (0, helpers_1.accumulateUsageTokens)(stateGraph, discussion, discussionRootAgent, model, final.usage);
     if (content) {
         if (verbose)
-            console.log("✅ Agent (1): 🌶️🌶️🌶️  save content:", content?.length);
+            console.log("✅ Agent (1): save content:", content?.length);
         stateGraph.push(discussionRootAgent, { role: "assistant", content });
     }
+    //
     // Si le modèle décide d'appeler une fonction (par exemple "transferAgents")
     for (const functionCall of accumulatedFunctionCall) {
         const args = JSON.parse(functionCall?.function?.arguments || '{}');
         if (args.justification) {
-            sendFeedback({
+            (0, shared_1.sendFeedback)({
                 agent: agentConfig.name,
                 stdout,
                 description: args.justification,
                 usage: discussion.usage,
-                state: '', // State will be set later if needed,
+                state: '',
                 verbose
             });
         }
         // Créer une référence mutable pour handleTransferCall
         const currentAgentRef = { name: agentConfig.name };
-        const functionCallResult = await (0, utils_1.handleTransferCall)(discussion, currentAgentRef, agents, functionCall, session);
-        // result can be 
-        // {content, usage}  {did_transfer}
-        thinking = functionCallResult.thinking;
+        const functionCallResult = await (0, utils_1.handleTransferCall)(discussion, currentAgentRef, agents, functionCall, context);
         if (functionCallResult.usage) {
             stateGraph.updateTokens(discussionRootAgent, {
                 prompt: functionCallResult.usage.prompt || 0,
@@ -103,19 +81,17 @@ async function readCompletionsStream(params) {
             // Mise à jour du message système avec les nouvelles instructions du nouvel agent courant
             const transferredAgent = agents.find(a => a.name === currentAgentRef.name) || agentConfig;
             const instructions = transferredAgent.instructions;
-            const enrichedInstructions = (await params.enrichWithMemory?.("system", transferredAgent, session)) || '';
+            const enrichedInstructions = (await params.enrichWithMemory?.("system", transferredAgent, context)) || '';
             // ✅ Set préserve le trail existant via updateSystemMessage()
             stateGraph.set(discussionRootAgent, instructions + '\n' + enrichedInstructions);
-            //
-            // Display only explicit content to stdout (usually empty for silent transfers)
-            if (functionCallResult.content) {
-                stdout.write(functionCallResult.content + "\n");
-            }
+            stateGraph.push(discussionRootAgent, {
+                role: "assistant",
+                content: functionCallResult.content,
+                name: functionCallResult.name
+            });
         }
-        //
-        // other function call have a result
-        else if (functionCallResult.content) {
-            // console.log("✅ Agent tool response:",agentConfig.name,'::',functionCall.function.name, ' with content',functionCallResult.content);
+        else {
+            // other function call have a result
             stateGraph.push(discussionRootAgent, {
                 role: "assistant",
                 content: functionCallResult.content,
@@ -125,135 +101,103 @@ async function readCompletionsStream(params) {
         //
         // send user feedback (if not already sent via addStep for transfer)
         if (functionCallResult.feedback && !functionCallResult.did_transfer) {
-            sendFeedback({
+            (0, shared_1.sendFeedback)({
                 agent: agentConfig.name,
                 stdout,
                 description: functionCallResult.feedback,
                 usage: discussion.usage,
-                state: '', // State tracking can be added later if needed
+                state: '',
                 verbose
             });
         }
         // Réactualisation de la liste des outils pour le nouvel agent courant
         const currentAgent = agents.find(a => a.name === currentAgentRef.name) || agentConfig;
         const tools = currentAgent?.tools || [];
-        const followUpOptions = Object.assign({}, modelConfig(currentAgent.model));
+        const followUpOptions = Object.assign({}, (0, modelconfig_1.modelConfig)(currentAgent.model));
         followUpOptions.messages = discussion.messages;
         if (tools.length > 0) {
             followUpOptions.tools = tools;
             followUpOptions.tool_choice = "auto";
         }
-        // console.log("✅ DEBUG followUpOptions (tools):",currentAgentRef.name,'\n',JSON.stringify(followUpOptions,null,2));
-        // console.log("✅ DEBUG followUpOptions (tools):",currentAgentRef.name,tools.length, tools[0]?.function?.parameters?.properties?.destination_agent);
-        // console.log("✅ DEBUG followUpOptions (system):",discussion.messages[0]?.content);
-        // if(!functionCallResult.did_transfer) {
-        //   followUpOptions.tool_choice = "none";
-        // }
-        // Poursuite de la conversation avec le contexte mis à jour
+        //
+        // Legacy: utiliser beta.chat.completions.stream (ancienne API)
+        // NOTE: Cette API est en beta, Responses API est recommandée pour les nouveaux projets
         const followUpStream = await openai.beta.chat.completions.stream(followUpOptions);
         for await (const chunk of followUpStream) {
-            //process.stdout.write(chunk.choices[0]?.delta?.content || "");
             const delta = chunk.choices[0]?.delta;
             if (delta?.content) {
                 stdout.write(delta?.content);
             }
         }
-        const final = await followUpStream.finalChatCompletion();
+        const followUpFinal = await followUpStream.finalChatCompletion();
         //
         // ✅ addStep APRÈS la réponse de l'agent (pour avoir le trail complet au prochain tour)
-        if (functionCallResult.feedback) {
+        if (functionCallResult.name) {
             stateGraph.addStep(discussionRootAgent, {
                 tool: functionCallResult.name,
                 context: functionCallResult.context || '',
-                reason: functionCallResult.feedback,
+                reason: args.justification || '',
                 id: functionCallResult.id
             });
         }
-        // console.log("✅ DEBUG followUpOptions (OUT content):",final.choices[0]?.message.content);
-        // console.log("✅ DEBUG followUpOptions (OUT tool_calls):",final.choices[0]?.message.tool_calls);
         //
         // when called a function, agent must continue the conversation
-        // if(verbose) console.log("✅ Agent ( followUp - OUT):",currentAgent.name, 'with tool_calls ',!!(final.choices[0]?.message.tool_calls),' and content:' ,!!(final.choices[0]?.message.content));
-        if (final.choices[0]?.message.tool_calls) {
+        if (followUpFinal.choices[0]?.message.tool_calls) {
             const partial = await readCompletionsStream({
                 stateGraph,
                 discussion,
                 agentConfig: currentAgent,
                 agents,
-                discussionRootAgent, // ✅ Renommé de agentName pour clarté
+                discussionRootAgent,
                 stdout,
-                final,
-                session,
+                final: followUpFinal,
+                context,
                 verbose,
                 enrichWithMemory: params.enrichWithMemory
             });
             localResult = (0, types_1.executionResultMerge)(localResult, partial);
-            // ✅ Convertir steps en actions avant de retourner
-            localResult.actions = stateGraph.steps(discussionRootAgent).map(step => ({
-                action: step.tool,
-                content: step.context,
-                feedback: step.reason
-            }));
+            // ✅ OPTIM: Utiliser helper centralisé
+            localResult.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
             return localResult;
         }
-        // Accumulate final cost
-        stateGraph.updateTokens(discussionRootAgent, {
-            prompt: final.usage?.prompt_tokens || 0,
-            completion: final.usage?.completion_tokens || 0,
-            total: final.usage?.total_tokens || 0,
-            cost: 0 // Cost calculation handled internally
-        });
+        //
+        // OPTIM: Utiliser helper centralisé pour l'accumulation
+        (0, helpers_1.accumulateUsageTokens)(stateGraph, discussion, discussionRootAgent, model, followUpFinal.usage);
         //
         // send the cost
-        sendFeedback({
+        (0, shared_1.sendFeedback)({
             agent: currentAgent.name,
             stdout,
             description: '',
             usage: discussion.usage,
-            state: final.id || '',
+            state: followUpFinal.id || '',
             verbose
         });
-        const content = final.choices[0]?.message.content;
+        const followUpContent = followUpFinal.choices[0]?.message.content;
         //
         // capture new memory with the last message
-        await params.enrichWithMemory?.("assistant", currentAgent, session);
-        // if(verbose) console.log("✅ Agent (OUT):",currentAgent.name, 'with content length',!!content);
-        if (content) {
-            stateGraph.push(discussionRootAgent, { role: "assistant", content });
-        }
-        if (content?.includes('<continue>')) {
-            localResult.moreThinkin = true;
+        await params.enrichWithMemory?.("assistant", currentAgent, context);
+        if (followUpContent) {
+            stateGraph.push(discussionRootAgent, { role: "assistant", content: followUpContent });
         }
     }
     //
-    // ✅ Convertir steps en actions une seule fois avant de retourner
-    const allSteps = stateGraph.steps(discussionRootAgent);
-    localResult.actions = allSteps.map(step => ({
-        action: step.tool,
-        content: step.context,
-        feedback: step.reason
-    }));
+    // ✅ OPTIM: Utiliser helper centralisé
+    localResult.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
     return localResult;
 }
 /**
  * Executes a set of agents to process a user query
  *
- * This function initializes the agent memory, processes the user query through the appropriate
- * agent, and handles any agent transfers or tool calls that occur during execution.
- *
- * @param {AgentConfig[]} agentSet - Array of agent configurations
- * @param {AgenticContext} session - {memory, user, ...}  - Session object to store/read conversation state
- * @param {ExecuteAgentSetParams} params - Execution parameters
- * @returns {Promise<void>}
+ * OPTIMIZED: Sans boucle do...while(moreThinkin), reasoning_effort fait le job
  */
 async function executeAgentSet(agentSet, context, params) {
     const { query, verbose } = params;
     const openai = (0, utils_1.openaiInstance)();
     const agents = (0, utils_1.injectTransferTools)(agentSet);
     // 🔑 CLÉ DE DISCUSSION: Agent racine qui sert de point d'entrée
-    // Cette clé reste FIXE même après des transferts, permettant de garder l'historique unifié
     const discussionRootAgent = params.home || agents[0].name;
-    // 🎯 Récupération du StateGraph depuis le context (qui contient session, user, credential, etc.)
+    // 🎯 Récupération du StateGraph depuis le context
     const stateGraph = (0, stategraph_1.sessionStateGraphGet)(context);
     // 📍 Créer ou restaurer la discussion pour cet agent racine
     const discussion = stateGraph.createOrRestore(discussionRootAgent);
@@ -272,101 +216,74 @@ async function executeAgentSet(agentSet, context, params) {
     let enrichedQuery = query;
     if (!discussion.messages.length) {
         discussion.usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
-        //
-        // add the initial agent to his memory as System
-        // Handle two-shot prompting: if instructions is an array, use the first part as a system message
         const enrichedInstructions = await params.enrichWithMemory?.("system", currentAgentConfig, context);
         const instructions = currentAgentConfig.instructions + '\n' + enrichedInstructions;
         stateGraph.set(discussionRootAgent, instructions);
     }
     else {
-        // enrich the user query with memory as User
         enrichedQuery = (await params.enrichWithMemory?.("user", currentAgentConfig, context)) || query;
     }
-    // Append the user's query to the session-specific messages
-    // input: `${getMemoryString(relevantMemories)}\n${input}`,
     stateGraph.push(discussionRootAgent, { role: "user", content: enrichedQuery });
-    // Les outils (définition des fonctions) disponibles par l'agent courant
     const tools = currentAgentConfig.tools;
-    // console.log('--- DBG toolLogic (1)',currentAgentConfig, currentAgentConfig?.toolLogic);
     if (verbose) {
-        console.log('--- DBG current agent', currentAgentConfig.name, 'memory len:', discussion.messages.length);
+        console.log('--- DBG current agent', currentAgentConfig.name, `deep-thinking:${params.thinking}`, 'memory len:', discussion.messages.length);
     }
-    // let shots = 1;
     let result = (0, types_1.enrichExecutionResult)({
         runId: `${discussionRootAgent}-${Date.now()}`,
         startQuery: query,
         actions: [],
         lastMessage: '',
         usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
-        moreThinkin: false,
     });
-    do {
-        const model = modelConfig(currentAgentConfig.model);
-        const options = Object.assign({}, model);
-        options.messages = discussion.messages;
-        if (tools.length > 0) {
-            options.tools = tools;
-            options.tool_choice = "auto";
-        }
-        const stream = await openai.beta.chat.completions.stream(options);
-        // const intialinfo = [
-        //   "Analyse",
-        //   "Analyse en cours…",
-        //   "Hummm"
-        // ];
-        // const randomIndex = Math.floor(Math.random() * intialinfo.length);
-        // //
-        // // initial feedback
-        // sendFeedback({
-        //   agent:memory.currentAgent.name,
-        //   stdout:params.stdout,
-        //   description:intialinfo[randomIndex],
-        //   usage:memory.usage,
-        //   state:memory.state!
-        // })    
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta;
-            if (delta?.content) {
-                params.stdout.write(delta?.content);
-            }
+    //
+    // ✅ BUG FIX: Plus de boucle do...while(moreThinkin) - reasoning_effort fait le job
+    const intialinfo = ["Analyse", "Analyse en cours…", "Réflexion"];
+    const randomIndex = Math.floor(Math.random() * intialinfo.length);
+    (0, shared_1.sendFeedback)({
+        agent: currentAgentConfig.name,
+        stdout: params.stdout,
+        description: intialinfo[randomIndex],
+        usage: result.usage,
+        state: discussion.id
+    });
+    //
+    // ✅ BUG FIX: modelConfig gère reasoning_effort, pas de duplication (ligne 425 originale supprimée)
+    const model = (0, modelconfig_1.modelConfig)(currentAgentConfig.model, { thinking: params.thinking });
+    const options = Object.assign({}, model);
+    options.messages = discussion.messages;
+    if (tools.length > 0) {
+        options.tools = tools;
+        options.tool_choice = "auto";
+        options.parallel_tool_calls = true;
+    }
+    const stream = await openai.beta.chat.completions.stream(options);
+    for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+            params.stdout.write(delta?.content);
         }
-        const final = await stream.finalChatCompletion();
-        const partial = await readCompletionsStream({
-            stateGraph,
-            discussion,
-            agentConfig: currentAgentConfig,
-            agents,
-            discussionRootAgent, // ✅ CLÉ de discussion
-            stdout: params.stdout,
-            session: context,
-            final,
-            verbose,
-            enrichWithMemory: params.enrichWithMemory,
-        });
-        result = (0, types_1.executionResultMerge)(result, partial);
-        result.actions = stateGraph.steps(discussionRootAgent).map(step => ({
-            action: step.tool,
-            content: step.context,
-            feedback: step.reason
-        }));
-        // 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(currentAgent.instructions && shots < currentAgent.instructions.length)){
-        //   const instructions = currentAgent.instructions[shots];
-        //   memory.messages.push({ role: "user", content: instructions });
-        //   thinking = true;
-        //   shots++;
-        // }
-        if (result.moreThinkin)
-            console.log("🌶️🌶️🌶️ restart thinking:");
-    } while (result.moreThinkin);
-    // 💾 Auto-save du StateGraph à la fin (context contient session, user, credential, etc.)
+    }
+    const final = await stream.finalChatCompletion();
+    const partial = await readCompletionsStream({
+        stateGraph,
+        discussion,
+        agentConfig: currentAgentConfig,
+        agents,
+        discussionRootAgent,
+        stdout: params.stdout,
+        context,
+        final,
+        verbose,
+        enrichWithMemory: params.enrichWithMemory,
+    });
+    result = (0, types_1.executionResultMerge)(result, partial);
+    //
+    // ✅ OPTIM: Utiliser helper centralisé
+    result.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
+    // 💾 Auto-save du StateGraph à la fin
     (0, stategraph_1.sessionStateGraphSet)(context, stateGraph);
-    // finalize result (usage accumulated via discussion.usage once here)
+    // finalize result
     result.lastMessage = discussion.messages?.[discussion.messages.length - 1]?.content || '';
-    // Ensure usage reflects the aggregated discussion usage (prompt/completion/total)
     if (discussion?.usage) {
         result.usage = {
             prompt: discussion.usage.prompt || 0,
@@ -388,14 +305,13 @@ async function executeAgent(agentSet, params) {
     if (!agent.instructions) {
         throw new Error(`Agent ${agent.name} has no instructions`);
     }
-    // Simple message array without memory manager - but preserve conversation
     const messages = [
         { role: "system", content: agent.instructions },
         { role: "user", content: query }
     ];
     let usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
     let state = '';
-    let maxIterations = 10; // Prevent infinite loops
+    let maxIterations = 10;
     let iterations = 0;
     if (verbose) {
         console.log('--- DBG executeAgent:', agent.name);
@@ -405,10 +321,9 @@ async function executeAgent(agentSet, params) {
         console.log('--- DBG executeAgent-system:', agent.instructions);
         console.log('--- DBG executeAgent-user:', query);
     }
-    // Execute the agent with tool call handling loop
     while (iterations < maxIterations) {
         iterations++;
-        const options = Object.assign({}, modelConfig(agent.model));
+        const options = Object.assign({}, (0, modelconfig_1.modelConfig)(agent.model));
         options.messages = messages;
         const tools = agent.tools || [];
         if (tools.length > 0) {
@@ -419,7 +334,6 @@ async function executeAgent(agentSet, params) {
             console.log('--- DBG executeAgent:', agent.name, 'iterations:', iterations, '\n', messages.length, '\n---', messages[messages.length - 1]?.content);
         }
         const stream = await openai.beta.chat.completions.stream(options);
-        // Stream the response
         for await (const chunk of stream) {
             const delta = chunk.choices[0]?.delta;
             if (delta?.content) {
@@ -427,37 +341,30 @@ async function executeAgent(agentSet, params) {
             }
         }
         const final = await stream.finalChatCompletion();
-        // Update usage and state
-        const model = modelConfig(agent.model).model;
+        const model = (0, modelconfig_1.modelConfig)(agent.model).model;
         (0, pricing_llm_1.accumulateCost)(usage, model, final.usage);
         state = final.id;
-        // Add assistant response to messages
         const content = final.choices[0]?.message.content;
         if (content) {
             messages.push({ role: "assistant", content });
         }
-        // Handle tool calls if any
         const toolCalls = final.choices[0]?.message.tool_calls;
         let hasToolCalls = false;
         if (toolCalls && toolCalls.length > 0) {
             hasToolCalls = true;
-            // First, update the assistant message with tool_calls
             const lastAssistant = messages[messages.length - 1];
             if (lastAssistant && lastAssistant.role === 'assistant') {
                 lastAssistant.tool_calls = toolCalls;
             }
             else {
-                // If no assistant message, add one with tool calls
                 messages.push({
                     role: "assistant",
                     content: content || null,
                     tool_calls: toolCalls
                 });
             }
-            // Then execute tools and add tool responses
             for (const toolCall of toolCalls) {
                 const args = JSON.parse(toolCall.function.arguments || '{}');
-                // Execute tool if it exists in agent's toolLogic
                 if (agent.toolLogic && agent.toolLogic[toolCall.function.name]) {
                     try {
                         const result = await agent.toolLogic[toolCall.function.name](args, { state });
@@ -477,7 +384,6 @@ async function executeAgent(agentSet, params) {
                 }
             }
         }
-        // If no tool calls, we're done
         if (!hasToolCalls) {
             break;
         }
@@ -491,20 +397,14 @@ async function executeAgent(agentSet, params) {
 }
 /**
  * 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
  */
 async function executeQuery(params) {
-    const { query, verbose } = params;
-    // Get OpenAI/Grok instance
+    const { query, verbose, model: modelName, instructions } = params;
+    if (!modelName) {
+        throw new Error('executeQuery requires "model" parameter');
+    }
     const openai = (0, utils_1.openaiInstance)();
-    // Use default model configuration if no home agent specified
-    const modelName = params.model || params.home || "LOW-fast";
-    const model = modelConfig(modelName);
+    const model = (0, modelconfig_1.modelConfig)(modelName);
     const more = {};
     if (params.json) {
         more.response_format = { type: "json_object" };
@@ -515,21 +415,21 @@ async function executeQuery(params) {
     if (verbose) {
         console.log('--- DBG query:', modelName, `${query?.substring(0, 100)}...`);
     }
-    // Simple message array - no system prompt, just the user query
     const messages = params.messages || [];
+    // Ajouter le système prompt si fourni
+    if (instructions) {
+        messages.unshift({ role: "system", content: instructions });
+    }
     messages.push({ role: "user", content: query });
     let usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
     let state = '';
     try {
-        // Create completion options
         const options = Object.assign({}, model, more);
         options.messages = messages;
         if (verbose) {
             console.log('--- DBG executeQuery options:', JSON.stringify(options, null, 2));
         }
-        // Execute the query
         const stream = await openai.beta.chat.completions.stream(options);
-        // Stream the response
         for await (const chunk of stream) {
             const delta = chunk.choices[0]?.delta;
             if (delta?.content && params.stdout) {
@@ -537,10 +437,8 @@ async function executeQuery(params) {
             }
         }
         const final = await stream.finalChatCompletion();
-        // Update usage and state
         (0, pricing_llm_1.accumulateCost)(usage, model.model, final.usage);
         state = final.id || '';
-        // Get the response content
         const content = final.choices[0]?.message.content || '';
         if (verbose) {
             console.log('--- DBG executeQuery completed, usage:', usage);

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

@@ -0,0 +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
+ * entre les deux APIs.
+ *
+ * @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)
+ *
+ * @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?: {
+    provider?: LLMProvider;
+    thinking?: boolean;
+    [key: string]: any;
+}, forResponses?: boolean): AgentModel;