agentic-api 2.0.314 → 2.0.491

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

@@ -0,0 +1,75 @@
+import { AgentStateGraph } from '../stategraph';
+import { AgentConfig, AgenticContext, ExecutionAction } from '../types';
+/**
+ * OPTIM: Accumule l'usage des tokens et met à jour stateGraph + discussion.usage
+ *
+ * Centralise la logique d'accumulation des tokens qui était dupliquée
+ * à plusieurs endroits dans le code original
+ *
+ * @param stateGraph - Instance du StateGraph
+ * @param discussion - Discussion courante
+ * @param agentName - Nom de l'agent (discussionRootAgent)
+ * @param model - Nom du modèle (pour calcul du coût)
+ * @param usage - Usage retourné par l'API (prompt_tokens, completion_tokens, total_tokens)
+ */
+export declare function accumulateUsageTokens(stateGraph: AgentStateGraph, discussion: any, agentName: string, model: string, usage: any): void;
+/**
+ * OPTIM: Convertit les steps du stateGraph en actions ExecutionResult
+ *
+ * Centralise la logique de conversion qui était dupliquée
+ * à plusieurs endroits dans le code original
+ *
+ * TODO/FIXME [Phase 3 - Normalisation]: Normaliser l'interface ExecutionAction
+ * Actuellement on fait un mapping manuel (tool→action, context→content, reason→feedback)
+ * À terme, utiliser directement le type StepTrail (tool, context, reason) partout
+ * au lieu d'ExecutionAction (action, content, feedback).
+ * Cela simplifiera le code et évitera les conversions répétées.
+ *
+ * @param stateGraph - Instance du StateGraph
+ * @param agentName - Nom de l'agent (discussionRootAgent)
+ * @returns Array d'actions pour ExecutionResult
+ */
+export declare function stepsToActions(stateGraph: AgentStateGraph, agentName: string): ExecutionAction[];
+/**
+ * OPTIM: Traite tous les tool calls en batch et retourne les résultats
+ *
+ * Exploite parallel_tool_calls pour optimiser les follow-ups :
+ * - Parse tous les arguments JSON une seule fois
+ * - Traite tous les tool calls
+ * - Accumule les messages pour un seul follow-up stream
+ *
+ * Au lieu de :
+ *   for (toolCall) {
+ *     handleTransferCall(toolCall)
+ *     followUpStream()  // ← Un stream par tool call (séquentiel)
+ *   }
+ *
+ * On fait :
+ *   batchProcessToolCalls(allToolCalls)
+ *   followUpStream()  // ← Un seul stream pour tous les résultats (batch)
+ *
+ * ✅ NEW: Support de submitToolOutputs (Responses API)
+ * Si responseId et openai sont fournis, utilise submitToolOutputs pour
+ * soumettre les résultats directement à l'API au lieu de les accumuler
+ * dans le stateGraph. Sinon, utilise l'approche classique (fallback).
+ *
+ * @param toolCalls - Array de tool calls retournés par l'API
+ * @param agents - Liste de tous les agents
+ * @param stateGraph - Instance du StateGraph
+ * @param agentName - Nom de l'agent (discussionRootAgent)
+ * @param context - Context (AgenticContext, doit contenir discussionRootAgent, currentAgent et stateGraph)
+ * @param responseId - (Optional) Response ID pour submitToolOutputs (Responses API)
+ * @param verbose - (Optional) Mode verbose pour logs
+ * @returns Résultats de tous les tool calls + flag needsFollowUp + parsedCalls (avec args parsés)
+ */
+export declare function batchProcessToolCalls(toolCalls: any[], agents: AgentConfig[], stateGraph: AgentStateGraph, agentName: string, context: AgenticContext, responseId?: string, verbose?: boolean): Promise<{
+    results: any[];
+    needsFollowUp: boolean;
+    parsedCalls: any[];
+    transferAgentName: string;
+    hasTransfer: boolean;
+    toolOutputs: Array<{
+        call_id: string;
+        output: string;
+    }>;
+}>;

package/dist/src/execute/helpers.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accumulateUsageTokens = accumulateUsageTokens;
+exports.stepsToActions = stepsToActions;
+exports.batchProcessToolCalls = batchProcessToolCalls;
+const pricing_llm_1 = require("../pricing.llm");
+const utils_1 = require("../utils");
+/**
+ * OPTIM: Accumule l'usage des tokens et met à jour stateGraph + discussion.usage
+ *
+ * Centralise la logique d'accumulation des tokens qui était dupliquée
+ * à plusieurs endroits dans le code original
+ *
+ * @param stateGraph - Instance du StateGraph
+ * @param discussion - Discussion courante
+ * @param agentName - Nom de l'agent (discussionRootAgent)
+ * @param model - Nom du modèle (pour calcul du coût)
+ * @param usage - Usage retourné par l'API (prompt_tokens, completion_tokens, total_tokens)
+ */
+function accumulateUsageTokens(stateGraph, discussion, agentName, model, usage) {
+    (0, pricing_llm_1.accumulateCost)(discussion.usage, model, usage);
+    stateGraph.updateTokens(agentName, {
+        prompt: usage?.prompt_tokens || 0,
+        completion: usage?.completion_tokens || 0,
+        total: usage?.total_tokens || 0,
+        cost: 0 // Already accumulated in discussion.usage
+    });
+}
+/**
+ * OPTIM: Convertit les steps du stateGraph en actions ExecutionResult
+ *
+ * Centralise la logique de conversion qui était dupliquée
+ * à plusieurs endroits dans le code original
+ *
+ * TODO/FIXME [Phase 3 - Normalisation]: Normaliser l'interface ExecutionAction
+ * Actuellement on fait un mapping manuel (tool→action, context→content, reason→feedback)
+ * À terme, utiliser directement le type StepTrail (tool, context, reason) partout
+ * au lieu d'ExecutionAction (action, content, feedback).
+ * Cela simplifiera le code et évitera les conversions répétées.
+ *
+ * @param stateGraph - Instance du StateGraph
+ * @param agentName - Nom de l'agent (discussionRootAgent)
+ * @returns Array d'actions pour ExecutionResult
+ */
+function stepsToActions(stateGraph, agentName) {
+    return stateGraph.steps(agentName).map(step => ({
+        action: step.tool,
+        content: step.context,
+        feedback: step.reason
+    }));
+}
+/**
+ * OPTIM: Traite tous les tool calls en batch et retourne les résultats
+ *
+ * Exploite parallel_tool_calls pour optimiser les follow-ups :
+ * - Parse tous les arguments JSON une seule fois
+ * - Traite tous les tool calls
+ * - Accumule les messages pour un seul follow-up stream
+ *
+ * Au lieu de :
+ *   for (toolCall) {
+ *     handleTransferCall(toolCall)
+ *     followUpStream()  // ← Un stream par tool call (séquentiel)
+ *   }
+ *
+ * On fait :
+ *   batchProcessToolCalls(allToolCalls)
+ *   followUpStream()  // ← Un seul stream pour tous les résultats (batch)
+ *
+ * ✅ NEW: Support de submitToolOutputs (Responses API)
+ * Si responseId et openai sont fournis, utilise submitToolOutputs pour
+ * soumettre les résultats directement à l'API au lieu de les accumuler
+ * dans le stateGraph. Sinon, utilise l'approche classique (fallback).
+ *
+ * @param toolCalls - Array de tool calls retournés par l'API
+ * @param agents - Liste de tous les agents
+ * @param stateGraph - Instance du StateGraph
+ * @param agentName - Nom de l'agent (discussionRootAgent)
+ * @param context - Context (AgenticContext, doit contenir discussionRootAgent, currentAgent et stateGraph)
+ * @param responseId - (Optional) Response ID pour submitToolOutputs (Responses API)
+ * @param verbose - (Optional) Mode verbose pour logs
+ * @returns Résultats de tous les tool calls + flag needsFollowUp + parsedCalls (avec args parsés)
+ */
+async function batchProcessToolCalls(toolCalls, agents, stateGraph, agentName, context, responseId, verbose) {
+    const results = [];
+    let needsFollowUp = false;
+    let transferAgentName = '';
+    let hasTransfer = false; // ✅ Flag pour détecter les transfers
+    //
+    // ✅ Récupérer discussion depuis stateGraph
+    const discussion = stateGraph.createOrRestore(agentName);
+    //
+    // ✅ Créer currentAgentRef depuis agentName (référence mutable pour handleTransferCall)
+    const currentAgentRef = { name: agentName };
+    //
+    // OPTIM: Parse tous les args une seule fois
+    const parsedCalls = toolCalls.map(tc => ({
+        ...tc,
+        args: JSON.parse(tc?.function?.arguments || '{}')
+    }));
+    //
+    // ✅ 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);
+        results.push(result);
+        // ✅ Détecter les transfers
+        if (result.did_transfer && result.destination_agent) {
+            hasTransfer = true;
+            transferAgentName = result.destination_agent;
+        }
+        //
+        // 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) {
+            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)
+                // 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/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Point d'entrée du module execute avec feature toggle
+ *
+ * Feature toggle : basculer entre Chat Completions (legacy) et Responses API
+ * Contrôlé par la variable d'environnement USE_RESPONSES_API
+ */
+export declare const USE_RESPONSES_API: boolean;
+export * from './shared';
+export * from './helpers';
+export * from './modelconfig';
+export * from './responses';

package/dist/src/execute/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * @fileoverview Point d'entrée du module execute avec feature toggle
+ *
+ * Feature toggle : basculer entre Chat Completions (legacy) et Responses API
+ * Contrôlé par la variable d'environnement USE_RESPONSES_API
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USE_RESPONSES_API = void 0;
+//
+// Feature toggle: basculer entre legacy et responses
+// Par défaut : Responses API (meilleur support reasoning models)
+// Pour revenir à legacy : USE_RESPONSES_API=false
+exports.USE_RESPONSES_API = process.env.USE_RESPONSES_API !== 'false';
+//
+// Exports des utilitaires partagés
+__exportStar(require("./shared"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./modelconfig"), exports);
+//
+// Exports conditionnels selon le feature flag
+// Par défaut : responses.ts (Responses API)
+// Si USE_RESPONSES_API=false → legacy.ts (Chat Completions)
+// const implementation = USE_RESPONSES_API 
+//   ? require('./responses')
+//   : require('./legacy');
+__exportStar(require("./responses"), exports);
+// export const executeQuery = implementation.executeQuery;
+// export const executeAgent = implementation.executeAgent;
+// export const executeAgentSet = implementation.executeAgentSet;

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

@@ -0,0 +1,46 @@
+/**
+ * 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
+ */
+import { AgentConfig, AgenticContext, ExecuteAgentResult, ExecutionResult } from "../types";
+import { ReadCompletionsStreamOptions, ExecuteAgentSetParams } from "./shared";
+export declare function readCompletionsStream(params: ReadCompletionsStreamOptions): Promise<ExecutionResult>;
+/**
+ * Parameters for executing an agent set
+ */
+export interface ExecuteAgentSetParamsLegacy {
+    enrichWithMemory?: (role: string, agent: AgentConfig, context: AgenticContext) => Promise<string>;
+    query: string;
+    home?: string;
+    thinking?: boolean;
+    model?: string;
+    stdout: any;
+    messages?: any[];
+    verbose?: boolean;
+    json?: boolean;
+    schema?: any;
+    debug?: boolean;
+}
+/**
+ * Executes a set of agents to process a user query
+ *
+ * OPTIMIZED: Sans boucle do...while(moreThinkin), reasoning_effort fait le job
+ */
+export declare function executeAgentSet(agentSet: AgentConfig[], context: AgenticContext, params: ExecuteAgentSetParams): Promise<ExecutionResult>;
+export declare function executeAgent(agentSet: AgentConfig[], params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;
+/**
+ * Executes a simple query without agent orchestration or tool handling
+ */
+export declare function executeQuery(params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;