agentic-api 2.0.31 → 2.0.491

package/dist/src/execute/responses.js

@@ -0,0 +1,594 @@
+"use strict";
+/**
+ * Responses API Implementation
+ *
+ * Migration de Chat Completions vers Responses API pour:
+ * - Meilleur support des modèles reasoning (o-series, gpt-5)
+ * - Tool calls préservés pendant le raisonnement via reasoning: { effort }
+ * - Events SSE typés (response.output_text.delta, response.function_call.*)
+ * - Plus de boucle moreThinkin (obsolète) : reasoning géré nativement
+ *
+ * Différences clés vs legacy:
+ * - `input` remplace `messages` (même format array, juste renommage du paramètre)
+ * - `reasoning: { effort: 'low' | 'medium' | 'high' }` remplace `reasoning_effort`
+ * - Events SSE structurés vs delta progressifs
+ * - `response.usage` vs `final.usage`
+ * - Tools/function calling: format identique, `parallel_tool_calls` supporté
+ *
+ * Optimisations appliquées (vs code original):
+ * - OPTIM: Helpers centralisés (accumulateUsageTokens, stepsToActions)
+ * - BUG FIX: executionResultMerge fusionne actions correctement (corrigé dans types.ts)
+ * - BUG FIX: moreThinkin supprimé (obsolète)
+ * - BUG FIX: reasoning_effort géré par modelConfig uniquement
+ *
+ * TODO [Phase 2]: Migration vers openai-agents-js
+ * https://openai.github.io/openai-agents-js/
+ * - Remplacer handleTransferCall par handoff natif du SDK
+ * - Utiliser swarm.run() pour orchestration multi-agents
+ * - Mapper downstreamAgents vers router policies
+ * - Intégration optionnelle avec Vercel AI SDK (multi-providers)
+ * - stateGraph restera compatible (AgentMessage générique, agnostic de l'API)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+//
+// Import des utilitaires partagés et helpers optimisés
+const shared_1 = require("./shared");
+const modelconfig_1 = require("./modelconfig");
+const helpers_1 = require("./helpers");
+/**
+ * Helper pour créer un stream Responses API avec handlers
+ *
+ * Conforme à la documentation officielle: utilise .stream() avec .on() handlers
+ * et .finalResponse() pour obtenir le résultat final
+ *
+ * Gère les événements:
+ * - response.output_text.delta: texte en streaming
+ * - response.function_call.arguments.delta: arguments de function call en streaming
+ * - response.function_call.arguments.done: function call complète
+ * - response.error: erreurs
+ *
+ * @param openai - Instance OpenAI
+ * @param options - Options pour responses.stream()
+ * @param stdout - Optional writable stream pour affichage en temps réel
+ */
+async function createResponseStream(openai, options, stdout) {
+    // Normaliser les options pour l'API Responses (tools, etc.)
+    const normalizedOptions = (0, shared_1.normalizeOptionsForResponses)(options);
+    const stream = openai.responses.stream(normalizedOptions)
+        .on("response.output_text.delta", (event) => {
+        if (stdout && event.delta) {
+            stdout.write(event.delta);
+        }
+    })
+        .on("response.function_call.arguments.delta", (event) => {
+        // Function call arguments arrivent en streaming
+        // Peut être loggé pour debug si nécessaire
+        // console.log('Function call delta:', event);
+    })
+        .on("response.function_call.arguments.done", (event) => {
+        // Function call complète - déjà capturé dans finalResponse
+        // Peut être loggé pour debug si nécessaire
+        // console.log('Function call done:', event.call?.name);
+    })
+        .on("response.error", (event) => {
+        console.error('Response error:', event.error);
+    });
+    // Obtenir la réponse finale qui contient tous the function calls complétés
+    const result = await stream.finalResponse();
+    // Normaliser l'output vers un format compatible avec le code existant
+    return (0, shared_1.normalizeOutputFromResponses)(result);
+}
+/**
+ * RESPONSES API: Traite le stream de responses avec tool calls
+ *
+ * Utilise les events SSE typés de Responses API:
+ * - response.output_text.delta → texte
+ * - response.function_call.* → tool calls
+ * - response.completed → finalisation
+ */
+async function readCompletionsStream(params) {
+    const openai = (0, utils_1.openaiInstance)();
+    const { stateGraph, discussion, agentConfig, agents, discussionRootAgent, stdout, final, context, verbose } = params;
+    const model = (0, modelconfig_1.modelConfig)(agentConfig.model, {}, true).model; // forResponses=true
+    const accumulatedFunctionCall = final.choices[0]?.message.tool_calls || [];
+    const content = final.choices[0]?.message.content;
+    let localResult = (0, types_1.enrichExecutionResult)({
+        runId: `${discussionRootAgent}-${Date.now()}`,
+        startQuery: '',
+        actions: [],
+        lastMessage: '',
+        usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
+    });
+    //
+    // OPTIM: Utiliser helper centralisé pour l'accumulation
+    (0, helpers_1.accumulateUsageTokens)(stateGraph, discussion, discussionRootAgent, model, final.usage);
+    //
+    // ✅ Envoyer reasoning_text via sendFeedback si présent (modèles reasoning: o-series, gpt-5)
+    const reasoningText = final.choices[0]?.message.reasoning_text;
+    if (reasoningText) {
+        (0, shared_1.sendFeedback)({
+            agent: agentConfig.name,
+            stdout,
+            description: `💭 Raisonnement: ${reasoningText}`,
+            usage: discussion.usage,
+            state: '',
+            verbose
+        });
+    }
+    //
+    // ✅ OPTIM: Utiliser batchProcessToolCalls pour traiter les tool calls en batch
+    // Au lieu de boucler séquentiellement avec un followUp par call, on fait un seul followUp pour tous
+    if (accumulatedFunctionCall && accumulatedFunctionCall.length > 0) {
+        //
+        // Envoyer les justifications des tool calls
+        for (const functionCall of accumulatedFunctionCall) {
+            const args = JSON.parse(functionCall?.function?.arguments || '{}');
+            if (args.justification) {
+                (0, shared_1.sendFeedback)({
+                    agent: agentConfig.name,
+                    stdout,
+                    description: args.justification,
+                    usage: discussion.usage,
+                    state: '',
+                    verbose
+                });
+            }
+        }
+        //
+        // Normaliser tous les functionCalls vers le format Chat Completions
+        const normalizedFunctionCalls = accumulatedFunctionCall.map(shared_1.normalizedFunctionCallFromResponse);
+        //
+        // ✅ Ajouter le message assistant avec les tool_calls (response.output) AVANT les function_call_output
+        // Nécessaire pour que l'API Responses puisse associer les function_call_output aux tool_calls
+        // Documentation: "input_list += response.output"
+        stateGraph.push(discussionRootAgent, {
+            role: "assistant",
+            content: content || '',
+            tool_calls: normalizedFunctionCalls
+        });
+        //
+        // ✅ Enrichir le session avec discussionRootAgent et currentAgent pour les tools
+        const currentAgent = agents.find(a => a.name === agentConfig.name);
+        context.discussionRootAgent = discussionRootAgent;
+        context.currentAgent = currentAgent;
+        //
+        // ✅ Traiter tous les tool calls en batch
+        const { results, needsFollowUp, parsedCalls, transferAgentName, toolOutputs } = await (0, helpers_1.batchProcessToolCalls)(normalizedFunctionCalls, agents, stateGraph, discussionRootAgent, context);
+        //
+        // ✅ Ajouter les function_call_output au stateGraph pour le follow-up
+        // Les outputs peuvent être du texte (content) ou du JSON structuré (JSON.stringify)
+        for (const output of toolOutputs) {
+            stateGraph.push(discussionRootAgent, {
+                type: "function_call_output",
+                call_id: output.call_id,
+                output: output.output // ✅ Déjà formaté : content ou JSON.stringify(result.rawResult || result)
+            });
+        }
+        //
+        // Accumuler les usages de tous les tool calls
+        for (const result of results) {
+            if (result.usage) {
+                stateGraph.updateTokens(discussionRootAgent, {
+                    prompt: result.usage.prompt || 0,
+                    completion: result.usage.completion || 0,
+                    total: result.usage.total || 0,
+                    cost: result.usage.cost || 0
+                });
+            }
+        }
+        //
+        // Gérer les transfers d'agents si nécessaire
+        const hasTransfer = results.some(r => r.did_transfer);
+        if (hasTransfer) {
+            const transferResult = results.find(r => r.did_transfer);
+            if (verbose)
+                console.log("✅ Agent transfer (Responses):", transferResult?.source_agent, '→', transferResult?.destination_agent);
+            // Mise à jour du message système avec les nouvelles instructions du nouvel agent courant
+            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()
+            stateGraph.set(discussionRootAgent, instructions + '\n' + enrichedInstructions);
+        }
+        //
+        // Envoyer feedbacks pour les tool calls non-transfer
+        for (const result of results) {
+            if (result.feedback && !result.did_transfer) {
+                (0, shared_1.sendFeedback)({
+                    agent: agentConfig.name,
+                    stdout,
+                    description: result.feedback,
+                    usage: discussion.usage,
+                    state: '',
+                    verbose
+                });
+            }
+        }
+        //
+        // ✅ Un seul follow-up stream pour tous les tool calls (au lieu de N streams séquentiels)
+        if (needsFollowUp) {
+            // ✅ Utiliser l'agent transféré si transfer, sinon l'agent courant
+            const followUpAgentName = transferAgentName || currentAgent.name;
+            const followUpAgent = agents.find(a => a.name === followUpAgentName) || currentAgent;
+            const tools = followUpAgent.tools || [];
+            //
+            // Responses API: utiliser input au lieu de messages
+            const followUpOptions = Object.assign({}, (0, modelconfig_1.modelConfig)(followUpAgent.model, {}, true)); // forResponses=true
+            followUpOptions.input = (0, shared_1.convertMessagesToResponsesInput)(discussion.messages);
+            if (tools.length > 0) {
+                followUpOptions.tools = tools;
+                followUpOptions.tool_choice = "auto";
+            }
+            //
+            // Responses API: utiliser responses.stream() avec .on() handlers et .finalResponse()
+            const followUpFinal = await createResponseStream(openai, followUpOptions, stdout);
+            //
+            // ✅ Ajouter les steps au trail APRÈS le follow-up (trail visible aux prochaines itérations)
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                const toolCall = parsedCalls[i];
+                if (result.name) {
+                    stateGraph.addStep(discussionRootAgent, {
+                        tool: result.name,
+                        context: result.context || '',
+                        reason: toolCall.args.justification || '',
+                        id: result.id
+                    });
+                }
+            }
+            // Debug: Vérifier que le trail est bien dans le message system
+            // if(verbose) {
+            //   const systemMsg = discussion.messages.find((m: any) => m.role === 'system');
+            //   const hasTrail = systemMsg?.content.includes('<context-trail>');
+            //   const trailSteps = stateGraph.steps(discussionRootAgent);
+            //   console.log('--- DBG trail added:', hasTrail, 'steps count:', trailSteps.length);
+            //   if(hasTrail && trailSteps.length > 0) {
+            //     console.log('--- DBG trail content:', systemMsg.content.match(/<context-trail>[\s\S]*?<\/context-trail>/)?.[0]);
+            //   }
+            // }
+            //
+            // when called a function, agent must continue the conversation
+            if (followUpFinal.choices[0]?.message.tool_calls && followUpFinal.choices[0].message.tool_calls.length > 0) {
+                const partial = await readCompletionsStream({
+                    stateGraph,
+                    discussion,
+                    agentConfig: currentAgent,
+                    agents,
+                    discussionRootAgent,
+                    stdout,
+                    final: followUpFinal,
+                    context,
+                    verbose,
+                    enrichWithMemory: params.enrichWithMemory
+                });
+                localResult = (0, types_1.executionResultMerge)(localResult, partial);
+                localResult.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
+                return localResult;
+            }
+            //
+            // OPTIM: Utiliser helper centralisé pour l'accumulation
+            (0, helpers_1.accumulateUsageTokens)(stateGraph, discussion, discussionRootAgent, model, followUpFinal.usage);
+            //
+            // send the cost
+            (0, shared_1.sendFeedback)({
+                agent: currentAgent.name,
+                stdout,
+                description: '',
+                usage: discussion.usage,
+                state: followUpFinal.id || '',
+                verbose
+            });
+            const followUpContent = followUpFinal.choices[0]?.message.content || '';
+            //
+            // capture new memory with the last message
+            await params.enrichWithMemory?.("assistant", currentAgent, context);
+            if (followUpContent) {
+                stateGraph.push(discussionRootAgent, { role: "assistant", content: followUpContent });
+            }
+        }
+    }
+    else if (content) {
+        // ✅ Pas de tool calls, mais il y a du content → ajouter le message assistant
+        if (verbose)
+            console.log("✅ Agent (Responses): save content without tool calls:", content?.length);
+        stateGraph.push(discussionRootAgent, { role: "assistant", content });
+    }
+    //
+    // ✅ OPTIM: Utiliser helper centralisé
+    localResult.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
+    return localResult;
+}
+/**
+ * Executes a set of agents to process a user query
+ *
+ * RESPONSES API VERSION
+ */
+async function executeAgentSet(agentSet, context, params) {
+    const { query, verbose } = params;
+    const openai = (0, utils_1.openaiInstance)();
+    const agents = (0, utils_1.injectTransferTools)(agentSet);
+    const discussionRootAgent = params.home || agents[0].name;
+    const stateGraph = (0, stategraph_1.sessionStateGraphGet)(context);
+    const discussion = stateGraph.createOrRestore(discussionRootAgent);
+    let currentAgent = (0, stategraph_1.getSpecializedAgent)(discussion) || discussionRootAgent;
+    const currentAgentConfig = agents.find(a => a.name === currentAgent);
+    discussion.description = currentAgentConfig?.publicDescription;
+    if (!currentAgentConfig) {
+        throw new Error(`Agent ${currentAgent} not found`);
+    }
+    if (!currentAgentConfig.instructions) {
+        throw new Error(`Agent ${currentAgent} has no instructions`);
+    }
+    let enrichedQuery = query;
+    if (!discussion.messages.length) {
+        discussion.usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
+        const enrichedInstructions = await params.enrichWithMemory?.("system", currentAgentConfig, context);
+        const instructions = currentAgentConfig.instructions + '\n' + enrichedInstructions;
+        stateGraph.set(discussionRootAgent, instructions);
+    }
+    else {
+        enrichedQuery = (await params.enrichWithMemory?.("user", currentAgentConfig, context)) || query;
+    }
+    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,
+        actions: [],
+        lastMessage: '',
+        usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
+    });
+    const intialinfo = ["Analyse", "Analyse en cours…"];
+    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
+    });
+    //
+    // 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);
+    //
+    // 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: utiliser input au lieu de messages
+    options.input = (0, shared_1.convertMessagesToResponsesInput)(discussion.messages);
+    if (tools.length > 0) {
+        options.tools = tools;
+        options.tool_choice = "auto";
+        options.parallel_tool_calls = true;
+    }
+    if (params.debug) {
+        console.log('--- DBG executeAgentSet:', JSON.stringify(options.input, null, 2));
+    }
+    //
+    // Responses API: utiliser responses.stream() avec .on() handlers et .finalResponse()
+    // normalizeOutputFromResponses retourne directement le format Chat Completions
+    try {
+        const final = await createResponseStream(openai, options, params.stdout);
+        const partial = await readCompletionsStream({
+            stateGraph,
+            discussion,
+            agentConfig: currentAgentConfig,
+            agents,
+            discussionRootAgent,
+            stdout: params.stdout,
+            context: context,
+            final: final,
+            verbose,
+            enrichWithMemory: params.enrichWithMemory,
+        });
+        result = (0, types_1.executionResultMerge)(result, partial);
+    }
+    catch (error) {
+        // ✅ Gérer les erreurs OpenAI de manière gracieuse (timeout, premature close, etc.)
+        const errorMsg = `❌ Erreur technique: ${error.message || 'Problème de communication avec l\'IA'}. Veuillez réessayer.`;
+        console.error('Error during OpenAI stream (executeAgentSet):', error);
+        // Ajouter le message d'erreur à la discussion pour que l'utilisateur le voie
+        stateGraph.push(discussionRootAgent, {
+            role: "assistant",
+            content: errorMsg
+        });
+        result.lastMessage = errorMsg;
+    }
+    //
+    // ✅ 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
+    result.lastMessage = discussion.messages?.[discussion.messages.length - 1]?.content || '';
+    if (discussion?.usage) {
+        result.usage = {
+            prompt: discussion.usage.prompt || 0,
+            completion: discussion.usage.completion || 0,
+            total: discussion.usage.total || 0,
+            cost: discussion.usage.cost || 0,
+        };
+    }
+    result = (0, types_1.enrichExecutionResult)(result);
+    return result;
+}
+/**
+ * Execute agent - Responses API version
+ */
+async function executeAgent(agentSet, params) {
+    const { query, verbose, debug } = params;
+    const openai = (0, utils_1.openaiInstance)();
+    const agent = agentSet.find(a => a.name === params.home);
+    if (!agent) {
+        throw new Error(`Agent ${params.home} not found`);
+    }
+    if (!agent.instructions) {
+        throw new Error(`Agent ${agent.name} has no instructions`);
+    }
+    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;
+    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);
+    }
+    while (iterations < maxIterations) {
+        iterations++;
+        const options = Object.assign({}, (0, modelconfig_1.modelConfig)(agent.model, {}, true)); // forResponses=true
+        options.input = messages;
+        // Utiliser previous_response_id pour maintenir le contexte des function calls
+        if (state) {
+            options.previous_response_id = state;
+        }
+        const tools = agent.tools || [];
+        if (tools.length > 0) {
+            options.tools = tools;
+            options.tool_choice = "auto";
+        }
+        if (verbose) {
+            console.log('--- DBG executeAgent (Responses):', agent.name, 'iterations:', iterations);
+        }
+        // Responses API: utiliser responses.stream() avec .on() handlers et .finalResponse()
+        // normalizeOutputFromResponses retourne directement le format Chat Completions
+        const final = await createResponseStream(openai, options, params.stdout);
+        const model = (0, modelconfig_1.modelConfig)(agent.model, {}, true).model;
+        (0, pricing_llm_1.accumulateCost)(usage, model, final.usage);
+        state = final.id;
+        const content = final.choices[0]?.message.content || '';
+        const toolCalls = final.choices[0]?.message.tool_calls || [];
+        let hasToolCalls = false;
+        // L'API Responses a un format d'input différent de Chat Completions
+        // On ajoute le content de l'assistant si présent
+        if (content) {
+            messages.push({ role: "assistant", content });
+        }
+        // Traiter les tool calls si présents (format Chat Completions après normalisation)
+        if (toolCalls && toolCalls.length > 0) {
+            hasToolCalls = true;
+            for (const toolCall of toolCalls) {
+                const args = JSON.parse(toolCall.function.arguments || '{}');
+                if (agent.toolLogic && agent.toolLogic[toolCall.function.name]) {
+                    try {
+                        const result = await agent.toolLogic[toolCall.function.name](args, { state });
+                        // Responses API: utiliser function_call_output
+                        messages.push({
+                            type: "function_call_output",
+                            call_id: toolCall.id,
+                            output: typeof result === 'string' ? result : JSON.stringify(result)
+                        });
+                    }
+                    catch (error) {
+                        messages.push({
+                            type: "function_call_output",
+                            call_id: toolCall.id,
+                            output: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
+                        });
+                    }
+                }
+            }
+        }
+        if (!hasToolCalls) {
+            break;
+        }
+    }
+    return {
+        usage,
+        content: messages[messages.length - 1]?.content || '',
+        messages,
+        state
+    };
+}
+/**
+ * Execute query - Responses API version
+ */
+async function executeQuery(params) {
+    const { query, verbose, model: modelName, instructions } = params;
+    if (!modelName) {
+        throw new Error('executeQuery requires "model" parameter');
+    }
+    const openai = (0, utils_1.openaiInstance)();
+    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)}...`);
+    }
+    const messages = params.messages || [];
+    messages.push({ role: "user", content: query });
+    let usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
+    let state = '';
+    try {
+        const options = Object.assign({}, model);
+        options.input = messages;
+        // Responses API: utiliser instructions au lieu de role: "system" si fourni
+        if (instructions) {
+            options.instructions = instructions;
+        }
+        if (verbose) {
+            console.log('--- DBG executeQuery options (Responses):', JSON.stringify(options, null, 2));
+        }
+        // Responses API: utiliser responses.stream() avec .on() handlers et .finalResponse()
+        // normalizeOutputFromResponses retourne directement le format Chat Completions
+        const final = await createResponseStream(openai, options, params.stdout);
+        (0, pricing_llm_1.accumulateCost)(usage, model.model, final.usage);
+        state = final.id || '';
+        const content = final.choices[0]?.message.content || '';
+        if (verbose) {
+            console.log('--- DBG executeQuery completed (Responses), usage:', usage);
+        }
+        return {
+            usage,
+            content,
+            messages: [
+                ...messages,
+                { role: "assistant", content }
+            ],
+            state
+        };
+    }
+    catch (error) {
+        console.error('❌ executeQuery failed (Responses):', error);
+        throw error;
+    }
+}

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

@@ -0,0 +1,83 @@
+import { Writable } from "stream";
+import { Feedback } from "../types";
+export declare const DummyWritable: any;
+export declare function sendFeedback(params: Feedback): void;
+export interface ReadCompletionsStreamOptions {
+    stateGraph: any;
+    discussion: any;
+    agentConfig: any;
+    agents: any[];
+    discussionRootAgent: string;
+    stdout: Writable;
+    context: any;
+    final: any;
+    verbose?: boolean;
+    enrichWithMemory?: (role: string, agent: any, context: any) => Promise<string>;
+    responseId?: string;
+}
+export interface ExecuteAgentSetParams {
+    enrichWithMemory?: (role: string, agent: any, context: any) => Promise<string>;
+    query: string;
+    home?: string;
+    thinking?: boolean;
+    model?: string;
+    instructions?: string;
+    stdout: Writable;
+    messages?: any[];
+    verbose?: boolean;
+    json?: boolean;
+    schema?: any;
+    debug?: boolean;
+}
+/**
+ * Normalise les options pour l'API Responses
+ *
+ * Transforme les paramètres du format Chat Completions vers Responses API:
+ * - Tools: { type: "function", function: {...} } → { type: "function", name, description, parameters, strict }
+ * - Autres transformations futures si nécessaire
+ *
+ * @param options - Options à normaliser
+ * @returns Options normalisées pour Responses API
+ */
+export declare function normalizeOptionsForResponses(options: any): any;
+/**
+ * Normalise un function call du format Responses vers Chat Completions
+ *
+ * Responses API: { type: "function_call", name, arguments, call_id }
+ * Chat Completions: { id, type: "function", function: { name, arguments } }
+ *
+ * Si déjà au format Chat Completions (avec .function), retourne tel quel
+ *
+ * @param functionCall - Function call au format Responses ou Chat Completions
+ * @returns Function call au format Chat Completions
+ */
+export declare function normalizedFunctionCallFromResponse(functionCall: any): any;
+/**
+ * Normalise l'output de l'API Responses vers le format Chat Completions
+ *
+ * Transforme la structure Responses API vers le format attendu par le reste du code
+ *
+ * Format Responses API (result.output array):
+ * - { type: "reasoning", summary: [] }
+ * - { type: "message", content: [{ type: "output_text", text: "..." }] }
+ * - { type: "function_call", name, arguments, call_id }
+ *
+ * Format Chat Completions compatible:
+ * - { choices: [{ message: { content, tool_calls, reasoning_text } }], usage: {...}, id: "..." }
+ *
+ * @param result - Résultat de stream.finalResponse()
+ * @returns Résultat au format Chat Completions avec reasoning_text si présent
+ */
+export declare function normalizeOutputFromResponses(result: any): any;
+/**
+ * Convertit les messages du stateGraph vers le format Responses API input
+ * Gère les messages normaux, tool_calls (Chat Completions), et function_call_output (Responses)
+ *
+ * Utilisée par:
+ * - readCompletionsStream (responses.ts) pour le follow-up après tool calls
+ * - executeAgentSet (responses.ts) pour préparer l'input initial
+ *
+ * @param messages Messages du stateGraph
+ * @returns Array d'items au format Responses API input
+ */
+export declare function convertMessagesToResponsesInput(messages: any[]): any[];