agentic-api 2.0.646 → 2.0.885

package/dist/src/execute/helpers.js

@@ -1,10 +1,62 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.accumulateUsageTokens = accumulateUsageTokens;
 exports.stepsToActions = stepsToActions;
+exports.handleSubAgentCall = handleSubAgentCall;
 exports.batchProcessToolCalls = batchProcessToolCalls;
+const stream_1 = require("stream");
 const pricing_1 = require("../llm/pricing");
+const subagent_1 = require("../agents/subagent");
 const utils_1 = require("../utils");
+const responses_1 = require("./responses");
+//
+// Stdout filtré pour les sub-agents : ne laisse passer que les <step> (sendFeedback)
+// et supprime le texte brut du LLM (qui ne doit pas être streamé au user final).
+// sendFeedback écrit toujours `\n<step>JSON</step>\n` en un seul write.
+function createFeedbackOnlyStdout(target) {
+    return new stream_1.Writable({
+        write(chunk, _enc, cb) {
+            const str = chunk.toString();
+            if (str.includes('<step>')) {
+                target.write(chunk);
+            }
+            cb();
+        }
+    });
+}
 /**
  * OPTIM: Accumule l'usage des tokens et met à jour stateGraph + discussion.usage
  *
@@ -45,10 +97,154 @@ function accumulateUsageTokens(stateGraph, discussion, agentName, model, usage)
 function stepsToActions(stateGraph, agentName) {
     return stateGraph.steps(agentName).map(step => ({
         action: step.tool,
-        content: step.context,
+        content: step.reason,
         feedback: step.reason
     }));
 }
+/**
+ * Gère l'exécution d'un sub-agent via la convention `subAgent<Name>`.
+ *
+ * Clé de session : `{parentDiscussionId}_{toolName}` (ex: `f3a9b1_subAgentPRMaster`).
+ * - Isole la session par (discussion parente × tool) → pas de fuite entre users/conversations.
+ * - useSession=true  → session persistante : le sub-agent accumule le contexte entre appels.
+ * - useSession=false → éphémère : clearDiscussion avant exec, repart d'un slate vide.
+ *
+ * Le sub-agent est cloné avec `name = sessionKey` pour que executeAgentSet utilise
+ * la bonne clé dans le stateGraph partagé sans écraser la discussion `<Name>` parente.
+ */
+function buildSubAgentFallbackResult(toolName, fallbackMessage, feedback, status = 'error') {
+    const result = {
+        status,
+        items: fallbackMessage ? [fallbackMessage] : [],
+        meta: {
+            resolved: [],
+            notFound: [],
+            knowledge_found: 'no'
+        },
+        control: {
+            can_retry: false
+        },
+        content: '',
+        name: toolName,
+        feedback
+    };
+    result.content = JSON.stringify({
+        status: result.status,
+        items: result.items,
+        meta: result.meta,
+        control: result.control
+    });
+    return result;
+}
+async function handleSubAgentCall(stateGraph, agents, functionCallParams, context) {
+    const toolName = functionCallParams.function.name; // ex: 'subAgentPRMaster'
+    const args = JSON.parse(functionCallParams?.function?.arguments || '{}');
+    const useSession = true;
+    //
+    // Composer la mission — supporte ancien triplet (subject/context/expected_result) et nouveau (query/context/goal)
+    const { subAgentComposeMission } = await Promise.resolve().then(() => __importStar(require('../agents/subagent')));
+    const mission = subAgentComposeMission(args);
+    //
+    // Rétro-compat : confidence seuil (ancien format)
+    if (args.confidence != null && args.confidence < 0.5) {
+        return buildSubAgentFallbackResult(toolName, `La délégation n'est pas nécessaire (confidence: ${args.confidence}), réponds directement.`, args.rationale_for_agent || args.query || '', 'empty');
+    }
+    //
+    // Rationale pour logging/feedback (ancien: rationale_for_agent, nouveau: query)
+    const rationale = args.rationale_for_agent || args.query || '';
+    //
+    // Convention subAgent<Name> → <Name> (ex: subAgentPRMaster → PRMaster)
+    const subAgentName = toolName.replace(/^subAgent([A-Z])/, (_, c) => c);
+    const subAgent = agents.find(a => a.name === subAgentName);
+    if (!subAgent) {
+        console.log(`❌ Sub-agent "${subAgentName}" introuvable.`);
+        return buildSubAgentFallbackResult(toolName, `❌ Sub-agent "${subAgentName}" introuvable.`, rationale);
+    }
+    //
+    // Clé de session scoped : {parentDiscussionId}_{toolName}
+    // - Isole la discussion du sub-agent par (user × conversation × tool)
+    // - context.discussionRootAgent est fixé avant batchProcessToolCalls (responses.ts)
+    // - Le save/restore ci-dessous garantit que l'UUID du root agent reste stable
+    //   même si executeAgentSet le mute en interne.
+    const discussionRootAgent = context.discussionRootAgent;
+    const parentDiscussion = stateGraph.createOrRestore(discussionRootAgent);
+    const sessionKey = `${parentDiscussion.id}_${toolName}`;
+    // useSession=false → éphémère : vider la discussion avant exec
+    if (!useSession) {
+        stateGraph.clearDiscussion(sessionKey);
+    }
+    const subDiscussion = stateGraph.createOrRestore(sessionKey);
+    //
+    // Clone l'agent avec name = sessionKey pour que executeAgentSet utilise
+    // la bonne clé dans le stateGraph partagé (pas de collision avec PRMaster).
+    // subAgents: [] — empêche la découverte récursive de subAgents dans l'exécution isolée.
+    // tools snapshot — isole les tools de l'original pour éviter toute propagation de mutation.
+    const isolatedAgent = {
+        ...subAgent,
+        name: sessionKey,
+        subAgents: [],
+        tools: [...(subAgent.tools || [])].filter(t => !t.function.name.startsWith('subAgent')),
+    };
+    //
+    // Save/restore : executeAgentSet mute context.discussionRootAgent = sessionKey.
+    // Sans restore, un 2e appel subAgent séquentiel lirait la valeur mutée et créerait
+    // une nouvelle discussion au lieu de réutiliser celle du root agent.
+    //
+    // feedbackOnlyStdout : ne streame que les <step> (sendFeedback) vers l'utilisateur.
+    // Le texte LLM du sub-agent est supprimé — seul le parent reformule la réponse finale.
+    const feedbackStdout = createFeedbackOnlyStdout(context.stdout);
+    const outputSchema = subAgent.outputSchema ?? subagent_1.SUBAGENT_OUTPUT_SCHEMA;
+    const subAgentStartMs = Date.now();
+    const savedDiscussionRootAgent = context.discussionRootAgent;
+    const result = await (0, responses_1.executeAgentSet)([isolatedAgent], context, {
+        query: mission,
+        home: sessionKey,
+        schema: outputSchema,
+        stdout: feedbackStdout,
+        verbose: true
+    });
+    context.discussionRootAgent = savedDiscussionRootAgent;
+    // console.log('🔍 SubAgentCall', result.lastMessage);
+    //
+    // Trace dans le context trail de la discussion parente
+    stateGraph.addStep(discussionRootAgent, {
+        tool: toolName,
+        reason: `${rationale} — ${mission}`
+    });
+    //
+    // Diagnostic subAgent : taille du résultat + temps d'exécution
+    const elapsedMs = Date.now() - subAgentStartMs;
+    const msgLength = result.lastMessage?.length || 0;
+    console.log(`🔀 SubAgent "${subAgentName}" prompt("${mission}") — message("${msgLength} chars"), ${elapsedMs}ms, usage: ${result.usage.prompt}:${result.usage.completion} tokens\n`, `🔀 SubAgent clé "${sessionKey}" (${subDiscussion.messages.length} msgs)\n`); // `🔀 SubAgent result: ${result.lastMessage}`
+    const rawContent = result.lastMessage || result.error || `❌ Sub-agent "${subAgentName}" n'a pas retourné de résultat.`;
+    const parsedOutput = (0, subagent_1.parseSubAgentOutputContent)(rawContent);
+    if (!parsedOutput) {
+        return buildSubAgentFallbackResult(toolName, rawContent, rationale);
+    }
+    const content = JSON.stringify(parsedOutput);
+    return {
+        ...parsedOutput,
+        //
+        // content = texte plain pour function_call_output (lu par batchProcessToolCalls)
+        content,
+        name: toolName,
+        feedback: rationale
+    };
+}
+/**
+ * Dispatch un tool call vers le bon handler (subAgent* ou toolLogic).
+ * Priorité : handleSubAgentCall > handleToolLogicCall.
+ *
+ * Utilisé dans Promise.all — ne traite PAS transferAgents (court-circuité en amont).
+ * context.discussionRootAgent est utilisé par handleSubAgentCall pour la clé de session.
+ */
+async function dispatchToolCall(stateGraph, currentAgentRef, agents, toolCall, context) {
+    const toolName = toolCall.function.name;
+    if (toolName.startsWith('subAgent')) {
+        return handleSubAgentCall(stateGraph, agents, toolCall, context);
+    }
+    return (0, utils_1.handleToolLogicCall)(currentAgentRef, agents, toolCall, context);
+}
 /**
  * OPTIM: Traite tous les tool calls en batch et retourne les résultats
  *
@@ -102,38 +298,48 @@ async function batchProcessToolCalls(toolCalls, agents, stateGraph, agentName, c
     // ✅ Préparer les tool_outputs pour submitToolOutputs
     const toolOutputs = [];
     //
-    // Traiter tous les tool calls
-    for (const toolCall of parsedCalls) {
-        const result = await (0, utils_1.handleTransferCall)(discussion, currentAgentRef, agents, toolCall, context);
+    // ✅ Court-circuit : transferAgents traité séquentiellement en priorité absolue.
+    // Un handoff modifie currentAgentRef (effet de bord mutable) — incompatible Promise.all.
+    const transferCall = parsedCalls.find(tc => tc.function.name === 'transferAgents');
+    if (transferCall) {
+        const result = await (0, utils_1.handleTransferCall)(discussion, currentAgentRef, agents, transferCall, context);
         results.push(result);
-        // ✅ Détecter les transfers
         if (result.did_transfer && result.destination_agent) {
             hasTransfer = true;
             transferAgentName = result.destination_agent;
         }
+        if (result.content || result.did_transfer || result.rawResult) {
+            needsFollowUp = true;
+            toolOutputs.push({
+                call_id: transferCall.id,
+                output: result.content || JSON.stringify(result.rawResult || result)
+            });
+        }
+        return { results, needsFollowUp, parsedCalls, transferAgentName, hasTransfer, toolOutputs };
+    }
+    //
+    // ✅ Tous les autres tool calls (subAgent*, toolLogic, thinking) : exécution parallèle.
+    // Indépendants entre eux, pas d'effet de bord sur currentAgentRef.
+    const parallelCalls = parsedCalls.map(toolCall => dispatchToolCall(stateGraph, currentAgentRef, agents, toolCall, context)
+        .then(result => ({ toolCall, result })));
+    const settled = await Promise.all(parallelCalls);
+    for (const { toolCall, result } of settled) {
+        results.push(result);
         //
-        // Accumuler les messages pour le follow-up
         // ✅ IMPORTANT: Toujours ajouter l'output même si content est undefined
         // Car un ToolContractOutput peut ne pas avoir de content mais avoir rawResult
-        if (result.content || result.did_transfer || result.rawResult) {
+        if (result.content || result.rawResult) {
             needsFollowUp = true;
-            // ✅ Préparer les outputs pour function_call_output
-            // Si content existe, l'utiliser (texte formaté)
-            // Sinon, sérialiser rawResult si présent (ToolContractOutput), sinon result complet
             toolOutputs.push({
                 call_id: toolCall.id,
-                // ⚠️ ATTENTION: rawResult contient le résultat brut du tool (ToolContractOutput)
+                // ⚠️ rawResult contient le résultat brut du tool (ToolContractOutput)
                 // Si content est undefined, on sérialise rawResult pour préserver la structure JSON complète
-                // Sinon, on utilise result complet comme fallback
                 output: result.content || JSON.stringify(result.rawResult || result)
             });
         }
-        //
-        // ✅ Les steps sont ajoutés APRÈS le follow-up dans readCompletionsStream
-        // pour éviter que le LLM pense que l'outil a déjà été exécuté
     }
+    //
     // ✅ NOTE: On ne gère PAS submitToolOutputs ici
     // C'est readCompletionsStream qui décide selon hasTransfer
-    // On retourne juste les données nécessaires
     return { results, needsFollowUp, parsedCalls, transferAgentName, hasTransfer, toolOutputs };
 }

package/dist/src/execute/responses.js

@@ -196,7 +196,7 @@ async function readCompletionsStream(params) {
             const transferredAgent = agents.find(a => a.name === transferAgentName) || agentConfig;
             const instructions = transferredAgent.instructions;
             const enrichedInstructions = (await params.enrichWithMemory?.("system", transferredAgent, context)) || '';
-            // ✅ Set préserve le trail existant via updateSystemMessage()
+            // ✅ Set préserve le trail existant via updateSystemContextTrail()
             stateGraph.set(discussionRootAgent, instructions + '\n' + enrichedInstructions);
         }
         //
@@ -221,9 +221,26 @@ async function readCompletionsStream(params) {
             const followUpAgent = agents.find(a => a.name === followUpAgentName) || currentAgent;
             const tools = followUpAgent.tools || [];
             //
-            // Responses API: utiliser input au lieu de messages
+            // Responses API — previous_response_id (intra-turn, follow-up après tool calls)
+            //
+            // Si final.id disponible ET pas de transfer : previous_response_id + uniquement les function_call_output.
+            // L'historique complet (system, user, assistant+tools) est encodé dans final.id.
+            //
+            // ⚠️ Transfer case : le system prompt a changé (nouvelles instructions de l'agent destination).
+            // previous_response_id cacherait l'ANCIEN system prompt (orientation) → agent destination
+            // ne recevrait pas ses propres instructions. On envoie l'historique complet.
             const followUpOptions = Object.assign({}, (0, modelconfig_1.modelConfig)(followUpAgent.model, {}, true)); // forResponses=true
-            followUpOptions.input = (0, shared_1.convertMessagesToResponsesInput)(discussion.messages);
+            if (final.id && !hasTransfer) {
+                followUpOptions.previous_response_id = final.id;
+                followUpOptions.input = toolOutputs.map(o => ({
+                    type: 'function_call_output',
+                    call_id: o.call_id,
+                    output: o.output
+                }));
+            }
+            else {
+                followUpOptions.input = (0, shared_1.convertMessagesToResponsesInput)(discussion.messages);
+            }
             if (tools.length > 0) {
                 followUpOptions.tools = tools;
                 followUpOptions.tool_choice = "auto";
@@ -236,12 +253,11 @@ async function readCompletionsStream(params) {
             for (let i = 0; i < results.length; i++) {
                 const result = results[i];
                 const toolCall = parsedCalls[i];
+                const reason = result.context ? `${result.context} (${toolCall.args.justification})` : toolCall.args.justification;
                 if (result.name) {
                     stateGraph.addStep(discussionRootAgent, {
                         tool: result.name,
-                        context: result.context || '',
-                        reason: toolCall.args.justification || '',
-                        id: result.id
+                        reason
                     });
                 }
             }
@@ -294,6 +310,12 @@ async function readCompletionsStream(params) {
             if (followUpContent) {
                 stateGraph.push(discussionRootAgent, { role: "assistant", content: followUpContent });
             }
+            //
+            // ✅ Base case intra-turn : mettre à jour lastResponseId pour le prochain tour.
+            if (followUpFinal.id) {
+                discussion.lastResponseId = followUpFinal.id;
+                discussion.lastResponseMsgCount = discussion.messages.length;
+            }
         }
     }
     else if (content) {
@@ -301,6 +323,12 @@ async function readCompletionsStream(params) {
         if (verbose)
             console.log("✅ Agent (Responses): save content without tool calls:", content?.length);
         stateGraph.push(discussionRootAgent, { role: "assistant", content });
+        //
+        // ✅ Base case direct : mettre à jour lastResponseId pour le prochain tour.
+        if (final.id) {
+            discussion.lastResponseId = final.id;
+            discussion.lastResponseMsgCount = discussion.messages.length;
+        }
     }
     //
     // ✅ OPTIM: Utiliser helper centralisé
@@ -315,7 +343,15 @@ async function readCompletionsStream(params) {
 async function executeAgentSet(agentSet, context, params) {
     const { query, verbose } = params;
     const openai = (0, llm_1.llmInstance)();
-    const agents = (0, utils_1.injectTransferTools)(agentSet);
+    //
+    // injectSubAgentTools retourne un tableau plat : copies des parents (tools injectés)
+    // + configs complètes des subAgents (instructions+tools+toolLogic pour handleSubAgentCall)
+    const agents = (0, utils_1.injectTransferTools)((0, utils_1.injectSubAgentTools)(agentSet));
+    //
+    // Propager stdout dans le contexte pour les tools (ex: Worker sendFeedback)
+    if (params.stdout) {
+        context.stdout = params.stdout;
+    }
     const discussionRootAgent = params.home || agents[0].name;
     const stateGraph = (0, stategraph_1.sessionStateGraphGet)(context);
     const discussion = stateGraph.createOrRestore(discussionRootAgent);
@@ -345,25 +381,22 @@ async function executeAgentSet(agentSet, context, params) {
     // - https://community.openai.com/t/appropriate-role-for-context-message-in-query-in-rag/867231
     //
     const enrichedInstructions = await params.enrichWithMemory?.("system", currentAgentConfig, context);
+    //
+    // ✅ Toujours rafraîchir le system prompt au début de chaque tour.
+    // - Nouvelle discussion : initialiser usage + injecter instructions
+    // - Discussion existante : réinitialiser les instructions de l'agent HOME
+    //
+    // ⚠️ Sans ce reset systématique, un transfer précédent peut avoir remplacé le system prompt
+    // de la discussion home avec les instructions de l'agent destination. Au tour suivant,
+    // l'agent home démarrerait avec le mauvais prompt (ex: "orientation" avec instructions "guess-word").
+    // stateGraph.set() préserve le context-trail existant (via updateSystemContextTrail).
+    const instructions = currentAgentConfig.instructions + '\n' + (enrichedInstructions || '');
     if (!discussion.messages.length) {
-        //
-        // New discussion: initialize usage and set system message
         discussion.usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
-        const instructions = currentAgentConfig.instructions + '\n' + (enrichedInstructions || '');
-        stateGraph.set(discussionRootAgent, instructions);
-    }
-    else if (enrichedInstructions) {
-        //
-        // Existing discussion: only update system message if enrichedInstructions exists
-        // stateGraph.set() preserves context-trail via updateSystemMessage()
-        const instructions = currentAgentConfig.instructions + '\n' + enrichedInstructions;
-        stateGraph.set(discussionRootAgent, instructions);
     }
+    stateGraph.set(discussionRootAgent, instructions);
     stateGraph.push(discussionRootAgent, { role: "user", content: enrichedQuery });
     const tools = currentAgentConfig.tools;
-    if (verbose) {
-        console.log('--- DBG current agent (Responses)', currentAgentConfig.name, `reasoning:${params.thinking}`, 'memory len:', discussion.messages.length);
-    }
     let result = (0, types_1.enrichExecutionResult)({
         runId: `${discussionRootAgent}-${Date.now()}`,
         startQuery: query,
@@ -383,18 +416,29 @@ async function executeAgentSet(agentSet, context, params) {
     //
     // Responses API: utiliser modelConfig avec forResponses=true pour reasoning: { effort }
     const model = (0, modelconfig_1.modelConfig)(currentAgentConfig.model, { thinking: params.thinking }, true);
-    const options = Object.assign({}, model);
+    const options = (0, shared_1.applyResponseTextFormat)(Object.assign({}, model), params);
     //
-    // TODO [Phase 3]: Ajouter support de previous_response_id dans executeAgentSet
-    // Actuellement uniquement implémenté dans executeAgent (ligne 456)
-    // Pour améliorer le contexte multi-tours, stocker response.id dans discussion/stateGraph
-    // et l'utiliser dans les appels suivants:
-    // if (discussion.lastResponseId) {
-    //   options.previous_response_id = discussion.lastResponseId;
-    // }
+    // Responses API — previous_response_id (inter-turn)
     //
-    // Responses API: utiliser input au lieu de messages
-    options.input = (0, shared_1.convertMessagesToResponsesInput)(discussion.messages);
+    // Si la discussion a un lastResponseId (fin d'un tour précédent), envoyer uniquement
+    // le delta de messages (system mis à jour + nouveau message user) plutôt que
+    // l'historique complet. Le contexte est récupéré côté OpenAI via previous_response_id.
+    //
+    // Messages[0] (system) est toujours inclus pour propager les instructions mises à jour
+    // (enrichedInstructions, context-trail). Les messages depuis lastResponseMsgCount sont
+    // les nouveaux messages du tour courant (typiquement : le message user).
+    if (discussion.lastResponseId && discussion.lastResponseMsgCount !== undefined) {
+        const deltaMessages = discussion.messages.slice(discussion.lastResponseMsgCount);
+        const systemMsg = discussion.messages[0]; // Toujours envoyer le system (instructions à jour)
+        const inputMessages = systemMsg?.role === 'system' ? [systemMsg, ...deltaMessages] : deltaMessages;
+        options.input = (0, shared_1.convertMessagesToResponsesInput)(inputMessages);
+        options.previous_response_id = discussion.lastResponseId;
+        if (verbose)
+            console.log(`🔁 previous_response_id (inter-turn): ${discussion.lastResponseId}, delta: ${deltaMessages.length} msgs`);
+    }
+    else {
+        options.input = (0, shared_1.convertMessagesToResponsesInput)(discussion.messages);
+    }
     if (tools.length > 0) {
         options.tools = tools;
         options.tool_choice = "auto";
@@ -438,8 +482,11 @@ async function executeAgentSet(agentSet, context, params) {
     result.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
     // 💾 Auto-save du StateGraph à la fin
     (0, stategraph_1.sessionStateGraphSet)(context, stateGraph);
-    // finalize result
-    result.lastMessage = discussion.messages?.[discussion.messages.length - 1]?.content || '';
+    // finalize result — ne pas écraser si une erreur a déjà été capturée (ex: quota, timeout)
+    const lastDiscussionMsg = discussion.messages?.[discussion.messages.length - 1]?.content || '';
+    if (!result.error || lastDiscussionMsg) {
+        result.lastMessage = lastDiscussionMsg || result.lastMessage;
+    }
     if (discussion?.usage) {
         result.usage = {
             prompt: discussion.usage.prompt || 0,
@@ -472,9 +519,6 @@ async function executeAgent(agentSet, params) {
     let state = '';
     let maxIterations = 10;
     let iterations = 0;
-    if (verbose) {
-        console.log('--- DBG executeAgent (Responses):', agent.name);
-    }
     if (debug) {
         console.log('--- DBG executeAgent-system (Responses):', agent.instructions);
         console.log('--- DBG executeAgent-user:', query);
@@ -555,24 +599,6 @@ async function executeQuery(params) {
     }
     const openai = (0, llm_1.llmInstance)();
     const model = (0, modelconfig_1.modelConfig)(modelName, {}, true); // forResponses=true
-    // Responses API: response_format → text.format
-    // Fusionner avec text.verbosity qui peut venir de modelConfig
-    if (params.json || params.schema) {
-        const format = {};
-        if (params.schema) {
-            // Structured Outputs: type "json_schema" avec schema et strict
-            format.type = "json_schema";
-            format.name = "response_schema";
-            format.schema = params.schema;
-            format.strict = true;
-        }
-        else if (params.json) {
-            // JSON mode simple
-            format.type = "json_object";
-        }
-        // Fusionner avec text existant (verbosity)
-        model.text = Object.assign({}, model.text || {}, { format });
-    }
     if (verbose) {
         console.log('--- DBG query (Responses):', modelName, `${query?.substring(0, 100)}...`);
     }
@@ -581,7 +607,7 @@ async function executeQuery(params) {
     let usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
     let state = '';
     try {
-        const options = Object.assign({}, model);
+        const options = (0, shared_1.applyResponseTextFormat)(Object.assign({}, model), params);
         options.input = messages;
         // Responses API: utiliser instructions au lieu de role: "system" si fourni
         if (instructions) {

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

@@ -29,6 +29,11 @@ export interface ExecuteAgentSetParams {
     schema?: any;
     debug?: boolean;
 }
+/**
+ * Applique le format de sortie Responses API (JSON mode ou JSON Schema strict)
+ * sans écraser d'autres options `text` déjà présentes (ex: verbosity).
+ */
+export declare function applyResponseTextFormat(options: Record<string, any>, params: Pick<ExecuteAgentSetParams, 'json' | 'schema'>): Record<string, any>;
 /**
  * Normalise les options pour l'API Responses
  *

package/dist/src/execute/shared.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DummyWritable = void 0;
 exports.sendFeedback = sendFeedback;
+exports.applyResponseTextFormat = applyResponseTextFormat;
 exports.normalizeOptionsForResponses = normalizeOptionsForResponses;
 exports.normalizedFunctionCallFromResponse = normalizedFunctionCallFromResponse;
 exports.normalizeOutputFromResponses = normalizeOutputFromResponses;
@@ -35,6 +36,32 @@ function sendFeedback(params) {
     // send agent state and description
     stdout.write(`\n<step>${JSON.stringify(feedback)}</step>\n`);
 }
+/**
+ * Applique le format de sortie Responses API (JSON mode ou JSON Schema strict)
+ * sans écraser d'autres options `text` déjà présentes (ex: verbosity).
+ */
+function applyResponseTextFormat(options, params) {
+    if (!params.json && !params.schema) {
+        return options;
+    }
+    const format = params.schema
+        ? {
+            type: 'json_schema',
+            name: 'response_schema',
+            schema: params.schema,
+            strict: true
+        }
+        : {
+            type: 'json_object'
+        };
+    return {
+        ...options,
+        text: {
+            ...(options.text || {}),
+            format
+        }
+    };
+}
 /**
  * Normalise les options pour l'API Responses
  *

package/dist/src/index.d.ts

@@ -14,9 +14,9 @@ export * from './scrapper';
 export * from './prompts';
 export * from './agents/reducer';
 export * from './agents/prompts';
-export * from './agents/semantic';
 export * from './agents/system';
 export * from './agents/job.runner';
+export * from './agents/subagent';
 export * from './rag';
 export * from './usecase';
 export * from './rules';
@@ -25,3 +25,4 @@ export * from './agents/simulator.types';
 export * from './agents/simulator.prompts';
 export * from './agents/simulator.utils';
 export * from './agents/simulator.dashboard';
+export * from './agents/worker.executor';

package/dist/src/index.js

@@ -52,9 +52,9 @@ __exportStar(require("./prompts"), exports);
 // Agents
 __exportStar(require("./agents/reducer"), exports);
 __exportStar(require("./agents/prompts"), exports);
-__exportStar(require("./agents/semantic"), exports);
 __exportStar(require("./agents/system"), exports);
 __exportStar(require("./agents/job.runner"), exports);
+__exportStar(require("./agents/subagent"), exports);
 // RAG Library
 __exportStar(require("./rag"), exports);
 // Usecase
@@ -67,3 +67,5 @@ __exportStar(require("./agents/simulator.types"), exports);
 __exportStar(require("./agents/simulator.prompts"), exports);
 __exportStar(require("./agents/simulator.utils"), exports);
 __exportStar(require("./agents/simulator.dashboard"), exports);
+// Worker executor
+__exportStar(require("./agents/worker.executor"), exports);

package/dist/src/llm/openai.js

@@ -103,8 +103,15 @@ exports.LLMopenai = {
         verbosity: "low",
         stream: true
     },
+    "HIGH-codex": {
+        model: "gpt-5.3-codex",
+        reasoning_effort: "low",
+        verbosity: "low",
+        temperature: 1,
+        stream: true
+    },
     "HIGH-fast": {
-        model: "gpt-5.2",
+        model: "gpt-5.4",
         reasoning_effort: "none",
         verbosity: "low",
         temperature: 1,

package/dist/src/llm/pricing.js

@@ -36,6 +36,8 @@ exports.modelPricing = {
     "gpt-5": { input: 0.00000125, output: 0.00001 },
     "gpt-5.1": { input: 0.00000125, output: 0.00001 },
     "gpt-5.2": { input: 0.00000175, cachedInput: 0.000000175, output: 0.000014 },
+    "gpt-5.3-codex": { input: 0.00000175, cachedInput: 0.000000175, output: 0.000014 },
+    "gpt-5.4": { input: 0.0000025, cachedInput: 0.00000025, output: 0.000015 },
     "gpt-5-mini": { input: 0.00000025, output: 0.000002 },
     "gpt-5-nano": { input: 0.00000005, output: 0.0000004 },
     // OpenAI o-series