agentic-api 2.0.646 → 2.0.885

package/dist/src/execute/legacy.js

@@ -1,460 +0,0 @@
-"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.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");
-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).model;
-    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);
-    if (content) {
-        if (verbose)
-            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) {
-            (0, shared_1.sendFeedback)({
-                agent: agentConfig.name,
-                stdout,
-                description: args.justification,
-                usage: discussion.usage,
-                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, context);
-        if (functionCallResult.usage) {
-            stateGraph.updateTokens(discussionRootAgent, {
-                prompt: functionCallResult.usage.prompt || 0,
-                completion: functionCallResult.usage.completion || 0,
-                total: functionCallResult.usage.total || 0,
-                cost: functionCallResult.usage.cost || 0
-            });
-        }
-        if (functionCallResult.did_transfer) {
-            if (verbose)
-                console.log("✅ Agent transfer response:", functionCallResult.source_agent, '::to', functionCallResult.destination_agent, '::with', functionCallResult.content, ' transfer done ✅');
-            // 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, context)) || '';
-            // ✅ Set préserve le trail existant via updateSystemMessage()
-            stateGraph.set(discussionRootAgent, instructions + '\n' + enrichedInstructions);
-            stateGraph.push(discussionRootAgent, {
-                role: "assistant",
-                content: functionCallResult.content,
-                name: functionCallResult.name
-            });
-        }
-        else {
-            // other function call have a result
-            stateGraph.push(discussionRootAgent, {
-                role: "assistant",
-                content: functionCallResult.content,
-                name: functionCallResult.name
-            });
-        }
-        //
-        // send user feedback (if not already sent via addStep for transfer)
-        if (functionCallResult.feedback && !functionCallResult.did_transfer) {
-            (0, shared_1.sendFeedback)({
-                agent: agentConfig.name,
-                stdout,
-                description: functionCallResult.feedback,
-                usage: discussion.usage,
-                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({}, (0, modelconfig_1.modelConfig)(currentAgent.model));
-        followUpOptions.messages = discussion.messages;
-        if (tools.length > 0) {
-            followUpOptions.tools = tools;
-            followUpOptions.tool_choice = "auto";
-        }
-        //
-        // 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) {
-            const delta = chunk.choices[0]?.delta;
-            if (delta?.content) {
-                stdout.write(delta?.content);
-            }
-        }
-        const followUpFinal = await followUpStream.finalChatCompletion();
-        //
-        // ✅ addStep APRÈS la réponse de l'agent (pour avoir le trail complet au prochain tour)
-        if (functionCallResult.name) {
-            stateGraph.addStep(discussionRootAgent, {
-                tool: functionCallResult.name,
-                context: functionCallResult.context || '',
-                reason: args.justification || '',
-                id: functionCallResult.id
-            });
-        }
-        //
-        // when called a function, agent must continue the conversation
-        if (followUpFinal.choices[0]?.message.tool_calls) {
-            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);
-            // ✅ OPTIM: Utiliser helper centralisé
-            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 });
-        }
-    }
-    //
-    // ✅ OPTIM: Utiliser helper centralisé
-    localResult.actions = (0, helpers_1.stepsToActions)(stateGraph, discussionRootAgent);
-    return localResult;
-}
-/**
- * Executes a set of agents to process a user query
- *
- * 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
-    const discussionRootAgent = params.home || agents[0].name;
-    // 🎯 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);
-    // 🔄 Agent courant: peut différer de l'agent racine après des transferts
-    let currentAgent = (0, stategraph_1.getSpecializedAgent)(discussion) || discussionRootAgent;
-    // Trouver la config de l'agent courant
-    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`);
-    }
-    // 🔧 Setup system message si pas encore fait
-    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', currentAgentConfig.name, `deep-thinking:${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 },
-    });
-    //
-    // ✅ 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,
-        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
-    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;
-}
-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:', agent.name);
-        console.log('--- DBG query:', `${query?.substring(0, 100)}...`);
-    }
-    if (debug) {
-        console.log('--- DBG executeAgent-system:', agent.instructions);
-        console.log('--- DBG executeAgent-user:', query);
-    }
-    while (iterations < maxIterations) {
-        iterations++;
-        const options = Object.assign({}, (0, modelconfig_1.modelConfig)(agent.model));
-        options.messages = messages;
-        const tools = agent.tools || [];
-        if (tools.length > 0) {
-            options.tools = tools;
-            options.tool_choice = "auto";
-        }
-        if (verbose) {
-            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);
-        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 model = (0, modelconfig_1.modelConfig)(agent.model).model;
-        (0, pricing_llm_1.accumulateCost)(usage, model, final.usage);
-        state = final.id;
-        const content = final.choices[0]?.message.content;
-        if (content) {
-            messages.push({ role: "assistant", content });
-        }
-        const toolCalls = final.choices[0]?.message.tool_calls;
-        let hasToolCalls = false;
-        if (toolCalls && toolCalls.length > 0) {
-            hasToolCalls = true;
-            const lastAssistant = messages[messages.length - 1];
-            if (lastAssistant && lastAssistant.role === 'assistant') {
-                lastAssistant.tool_calls = toolCalls;
-            }
-            else {
-                messages.push({
-                    role: "assistant",
-                    content: content || null,
-                    tool_calls: toolCalls
-                });
-            }
-            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 });
-                        messages.push({
-                            role: "tool",
-                            tool_call_id: toolCall.id,
-                            content: typeof result === 'string' ? result : JSON.stringify(result)
-                        });
-                    }
-                    catch (error) {
-                        messages.push({
-                            role: "tool",
-                            tool_call_id: toolCall.id,
-                            content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
-                        });
-                    }
-                }
-            }
-        }
-        if (!hasToolCalls) {
-            break;
-        }
-    }
-    return {
-        usage,
-        content: messages[messages.length - 1]?.content || '',
-        messages,
-        state
-    };
-}
-/**
- * Executes a simple query without agent orchestration or tool handling
- */
-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);
-    const more = {};
-    if (params.json) {
-        more.response_format = { type: "json_object" };
-    }
-    if (params.schema) {
-        more.response_format = { type: "json_object", schema: params.schema };
-    }
-    if (verbose) {
-        console.log('--- DBG query:', modelName, `${query?.substring(0, 100)}...`);
-    }
-    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 {
-        const options = Object.assign({}, model, more);
-        options.messages = messages;
-        if (verbose) {
-            console.log('--- DBG executeQuery options:', JSON.stringify(options, null, 2));
-        }
-        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) {
-                params.stdout.write(delta?.content);
-            }
-        }
-        const final = await stream.finalChatCompletion();
-        (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, usage:', usage);
-        }
-        return {
-            usage,
-            content,
-            messages: [
-                ...messages,
-                { role: "assistant", content }
-            ],
-            state
-        };
-    }
-    catch (error) {
-        console.error('❌ executeQuery failed:', error);
-        throw error;
-    }
-}

package/dist/src/pricing.llm.d.ts

@@ -1,5 +0,0 @@
-/**
- * @deprecated Ce fichier est conservé pour rétrocompatibilité.
- * Utiliser les imports depuis './llm/pricing' directement.
- */
-export { modelPricing, calculateCost, accumulateCost, LLM, LLMxai, LLMopenai, } from './llm/pricing';

package/dist/src/pricing.llm.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMopenai = exports.LLMxai = exports.LLM = exports.accumulateCost = exports.calculateCost = exports.modelPricing = void 0;
-/**
- * @deprecated Ce fichier est conservé pour rétrocompatibilité.
- * Utiliser les imports depuis './llm/pricing' directement.
- */
-var pricing_1 = require("./llm/pricing");
-Object.defineProperty(exports, "modelPricing", { enumerable: true, get: function () { return pricing_1.modelPricing; } });
-Object.defineProperty(exports, "calculateCost", { enumerable: true, get: function () { return pricing_1.calculateCost; } });
-Object.defineProperty(exports, "accumulateCost", { enumerable: true, get: function () { return pricing_1.accumulateCost; } });
-Object.defineProperty(exports, "LLM", { enumerable: true, get: function () { return pricing_1.LLM; } });
-Object.defineProperty(exports, "LLMxai", { enumerable: true, get: function () { return pricing_1.LLMxai; } });
-Object.defineProperty(exports, "LLMopenai", { enumerable: true, get: function () { return pricing_1.LLMopenai; } });