agentic-api 2.0.31 → 2.0.314

package/dist/src/execute.js

@@ -1,112 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyWritable = void 0;
 exports.modelConfig = modelConfig;
 exports.sendFeedback = sendFeedback;
 exports.readCompletionsStream = readCompletionsStream;
 exports.executeAgentSet = executeAgentSet;
 exports.executeAgent = executeAgent;
-const princing_openai_1 = require("./princing.openai");
+exports.executeQuery = executeQuery;
 const types_1 = require("./types");
 const utils_1 = require("./utils");
 const stategraph_1 = require("./stategraph");
+const pricing_llm_1 = require("./pricing.llm");
+exports.DummyWritable = {
+    write: () => { }
+};
 function modelConfig(model, custom) {
     const defaultOptions = Object.assign({
         stream_options: { "include_usage": true },
     }, custom || {});
-    const mapping = {
-        "LOW-fast": {
-            temperature: 1,
-            frequency_penalty: 0.0,
-            presence_penalty: 0.0,
-            model: "gpt-5-nano",
-            reasoning_effort: "minimal",
-            verbosity: "low",
-            stream: true
-        },
-        "LOW": {
-            temperature: 1,
-            frequency_penalty: 0.0,
-            presence_penalty: 0.0,
-            model: "gpt-5-nano",
-            reasoning_effort: "medium",
-            verbosity: "low",
-            stream: true
-        },
-        "MEDIUM-fast": {
-            temperature: 1,
-            frequency_penalty: 0.0,
-            presence_penalty: 0.0,
-            model: "gpt-5-mini",
-            reasoning_effort: "minimal",
-            verbosity: "low",
-            stream: true
-        },
-        "LOW-4.1": {
-            temperature: .2,
-            frequency_penalty: 0.0,
-            presence_penalty: 0.0,
-            model: "gpt-4.1-nano",
-            stream: true
-        },
-        "MEDIUM-4.1-mini": {
-            temperature: .2,
-            frequency_penalty: 0.0,
-            presence_penalty: 0.0,
-            model: "gpt-4.1-mini",
-            stream: true
-        },
-        "MEDIUM-4.1": {
-            temperature: .2,
-            frequency_penalty: 0.0,
-            presence_penalty: 0.0,
-            model: "gpt-4.1",
-            stream: true
-        },
-        "MEDIUM": {
-            temperature: 1,
-            frequency_penalty: 0.0,
-            presence_penalty: 0.0,
-            model: "gpt-5-mini",
-            reasoning_effort: "low",
-            verbosity: "low",
-            stream: true
-        },
-        "HIGH-fast": {
-            model: "gpt-5",
-            reasoning_effort: "minimal",
-            verbosity: "low",
-            temperature: 1,
-            stream: true
-        },
-        "HIGH-low": {
-            model: "gpt-5",
-            reasoning_effort: "low",
-            verbosity: "low",
-            stream: true
-        },
-        "HIGH-medium": {
-            model: "gpt-5",
-            reasoning_effort: "medium",
-            verbosity: "low",
-            stream: true
-        },
-        "SEARCH": {
-            temperature: 0.2,
-            frequency_penalty: 0.0,
-            presence_penalty: 0.0,
-            model: "gpt-4o-mini-search-preview",
-            web_search_options: {
-                user_location: {
-                    type: "approximate",
-                    approximate: {
-                        country: "CH",
-                        city: "Geneva",
-                        region: "Geneva",
-                    },
-                },
-            },
-        },
-    };
+    // Get mapping based on provider
+    const mapping = (0, pricing_llm_1.LLM)((0, utils_1.openaiInstance)());
     const options = Object.assign(mapping[model], defaultOptions);
     return options;
 }
@@ -129,13 +42,13 @@ async function readCompletionsStream(params) {
     const openai = (0, utils_1.openaiInstance)();
     //
     // set default context here
-    const { stateGraph, discussion, agentConfig, agents, agentName, stdout, final, session, verbose } = params;
-    const model = agentConfig.model.model;
+    const { stateGraph, discussion, agentConfig, agents, discussionRootAgent, stdout, final, session, verbose } = params;
+    const model = modelConfig(agentConfig.model).model;
     const accumulatedFunctionCall = final.choices[0]?.message.tool_calls || [];
     const content = final.choices[0]?.message.content;
     let thinking = false;
     let localResult = (0, types_1.enrichExecutionResult)({
-        runId: `${agentName}-${Date.now()}`,
+        runId: `${discussionRootAgent}-${Date.now()}`,
         startQuery: '',
         actions: [],
         lastMessage: '',
@@ -143,8 +56,8 @@ async function readCompletionsStream(params) {
         moreThinkin: false,
     });
     // Accumulate cost in the discussion usage
-    (0, princing_openai_1.accumulateCost)(discussion.usage, model, final.usage);
-    stateGraph.updateTokens(agentName, {
+    (0, pricing_llm_1.accumulateCost)(discussion.usage, model, final.usage);
+    stateGraph.updateTokens(discussionRootAgent, {
         prompt: final.usage?.prompt_tokens || 0,
         completion: final.usage?.completion_tokens || 0,
         total: final.usage?.total_tokens || 0,
@@ -155,7 +68,7 @@ async function readCompletionsStream(params) {
     if (content) {
         if (verbose)
             console.log("✅ Agent (1): 🌶️🌶️🌶️  save content:", content?.length);
-        stateGraph.push(agentName, { role: "assistant", content });
+        stateGraph.push(discussionRootAgent, { role: "assistant", content });
     }
     // Si le modèle décide d'appeler une fonction (par exemple "transferAgents")
     for (const functionCall of accumulatedFunctionCall) {
@@ -177,7 +90,7 @@ async function readCompletionsStream(params) {
         // {content, usage}  {did_transfer}
         thinking = functionCallResult.thinking;
         if (functionCallResult.usage) {
-            stateGraph.updateTokens(agentName, {
+            stateGraph.updateTokens(discussionRootAgent, {
                 prompt: functionCallResult.usage.prompt || 0,
                 completion: functionCallResult.usage.completion || 0,
                 total: functionCallResult.usage.total || 0,
@@ -185,51 +98,33 @@ async function readCompletionsStream(params) {
             });
         }
         if (functionCallResult.did_transfer) {
-            // record transfer action
-            localResult.actions.push({
-                action: 'transfert',
-                content: functionCallResult.destination_agent || currentAgentRef.name,
-                feedback: functionCallResult.feedback,
-            });
             if (verbose)
-                console.log("✅ Agent transfer response:", functionCallResult.source_agent, ' call function ', functionCall.function.name, '::to', functionCallResult.destination_agent, ' transfer done ✅');
+                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, session);
-            stateGraph.set(agentName, instructions + '\n' + enrichedInstructions);
-            // Ajout de la réponse de l'appel de fonction dans le contexte conversationnel
-            const message = functionCallResult.content ?? `Le transfert vers l'agent "${transferredAgent.name}" a été effectué, Tu dois répondre immédiatement à la question.`;
-            stateGraph.push(agentName, {
-                role: "assistant",
-                content: message,
-                name: functionCallResult.name
-            });
-            // Immediately surface the tool confirmation to the user output
-            // feedback or message?
-            if (message) {
-                stdout.write(message + "\n");
+            const enrichedInstructions = (await params.enrichWithMemory?.("system", transferredAgent, session)) || '';
+            // ✅ Set préserve le trail existant via updateSystemMessage()
+            stateGraph.set(discussionRootAgent, instructions + '\n' + enrichedInstructions);
+            //
+            // Display only explicit content to stdout (usually empty for silent transfers)
+            if (functionCallResult.content) {
+                stdout.write(functionCallResult.content + "\n");
             }
         }
         //
         // other function call have a result
         else if (functionCallResult.content) {
-            // record tool action
-            localResult.actions.push({
-                action: functionCall?.function?.name,
-                content: functionCallResult.content || '',
-                feedback: functionCallResult.feedback,
-            });
             // console.log("✅ Agent tool response:",agentConfig.name,'::',functionCall.function.name, ' with content',functionCallResult.content);
-            stateGraph.push(agentName, {
+            stateGraph.push(discussionRootAgent, {
                 role: "assistant",
                 content: functionCallResult.content,
                 name: functionCallResult.name
             });
         }
         //
-        // send user feedback 
-        if (functionCallResult.feedback) {
+        // send user feedback (if not already sent via addStep for transfer)
+        if (functionCallResult.feedback && !functionCallResult.did_transfer) {
             sendFeedback({
                 agent: agentConfig.name,
                 stdout,
@@ -242,15 +137,15 @@ async function readCompletionsStream(params) {
         // 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({}, currentAgent?.model);
+        const followUpOptions = Object.assign({}, modelConfig(currentAgent.model));
         followUpOptions.messages = discussion.messages;
-        //
-        // always force HIGH model for follow up
-        followUpOptions.model = currentAgent.model.model;
         if (tools.length > 0) {
             followUpOptions.tools = tools;
             followUpOptions.tool_choice = "auto";
         }
+        // console.log("✅ DEBUG followUpOptions (tools):",currentAgentRef.name,'\n',JSON.stringify(followUpOptions,null,2));
+        // console.log("✅ DEBUG followUpOptions (tools):",currentAgentRef.name,tools.length, tools[0]?.function?.parameters?.properties?.destination_agent);
+        // console.log("✅ DEBUG followUpOptions (system):",discussion.messages[0]?.content);
         // if(!functionCallResult.did_transfer) {
         //   followUpOptions.tool_choice = "none";
         // }
@@ -264,6 +159,16 @@ async function readCompletionsStream(params) {
             }
         }
         const final = await followUpStream.finalChatCompletion();
+        //
+        // ✅ addStep APRÈS la réponse de l'agent (pour avoir le trail complet au prochain tour)
+        if (functionCallResult.feedback) {
+            stateGraph.addStep(discussionRootAgent, {
+                tool: functionCallResult.name,
+                context: functionCallResult.context || '',
+                reason: functionCallResult.feedback,
+                id: functionCallResult.id
+            });
+        }
         // console.log("✅ DEBUG followUpOptions (OUT content):",final.choices[0]?.message.content);
         // console.log("✅ DEBUG followUpOptions (OUT tool_calls):",final.choices[0]?.message.tool_calls);
         //
@@ -275,7 +180,7 @@ async function readCompletionsStream(params) {
                 discussion,
                 agentConfig: currentAgent,
                 agents,
-                agentName,
+                discussionRootAgent, // ✅ Renommé de agentName pour clarté
                 stdout,
                 final,
                 session,
@@ -283,10 +188,16 @@ async function readCompletionsStream(params) {
                 enrichWithMemory: params.enrichWithMemory
             });
             localResult = (0, types_1.executionResultMerge)(localResult, partial);
+            // ✅ Convertir steps en actions avant de retourner
+            localResult.actions = stateGraph.steps(discussionRootAgent).map(step => ({
+                action: step.tool,
+                content: step.context,
+                feedback: step.reason
+            }));
             return localResult;
         }
         // Accumulate final cost
-        stateGraph.updateTokens(agentName, {
+        stateGraph.updateTokens(discussionRootAgent, {
             prompt: final.usage?.prompt_tokens || 0,
             completion: final.usage?.completion_tokens || 0,
             total: final.usage?.total_tokens || 0,
@@ -308,14 +219,20 @@ async function readCompletionsStream(params) {
         await params.enrichWithMemory?.("assistant", currentAgent, session);
         // if(verbose) console.log("✅ Agent (OUT):",currentAgent.name, 'with content length',!!content);
         if (content) {
-            stateGraph.push(agentName, { role: "assistant", content });
+            stateGraph.push(discussionRootAgent, { role: "assistant", content });
         }
         if (content?.includes('<continue>')) {
             localResult.moreThinkin = true;
-            return localResult;
         }
-        return localResult;
     }
+    //
+    // ✅ Convertir steps en actions une seule fois avant de retourner
+    const allSteps = stateGraph.steps(discussionRootAgent);
+    localResult.actions = allSteps.map(step => ({
+        action: step.tool,
+        content: step.context,
+        feedback: step.reason
+    }));
     return localResult;
 }
 /**
@@ -333,15 +250,15 @@ async function executeAgentSet(agentSet, context, params) {
     const { query, verbose } = params;
     const openai = (0, utils_1.openaiInstance)();
     const agents = (0, utils_1.injectTransferTools)(agentSet);
-    const home = params.home || agents[0].name;
+    // 🔑 CLÉ DE DISCUSSION: Agent racine qui sert de point d'entrée
+    // Cette clé reste FIXE même après des transferts, permettant de garder l'historique unifié
+    const discussionRootAgent = params.home || agents[0].name;
     // 🎯 Récupération du StateGraph depuis le context (qui contient session, user, credential, etc.)
     const stateGraph = (0, stategraph_1.sessionStateGraphGet)(context);
-    // 📍 Agent spécialisé (persistant) vs Agent contextuel (temporaire)
-    const specializedAgent = home;
-    const discussion = stateGraph.createOrRestore(specializedAgent);
-    let currentAgent = (0, stategraph_1.getSpecializedAgent)(discussion) || specializedAgent;
-    // Référence mutable pour handleTransferCall
-    const currentAgentRef = { name: currentAgent };
+    // 📍 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;
@@ -360,7 +277,7 @@ async function executeAgentSet(agentSet, context, params) {
         // Handle two-shot prompting: if instructions is an array, use the first part as a system message
         const enrichedInstructions = await params.enrichWithMemory?.("system", currentAgentConfig, context);
         const instructions = currentAgentConfig.instructions + '\n' + enrichedInstructions;
-        stateGraph.set(specializedAgent, instructions);
+        stateGraph.set(discussionRootAgent, instructions);
     }
     else {
         // enrich the user query with memory as User
@@ -368,7 +285,7 @@ async function executeAgentSet(agentSet, context, params) {
     }
     // Append the user's query to the session-specific messages
     // input: `${getMemoryString(relevantMemories)}\n${input}`,
-    stateGraph.push(specializedAgent, { role: "user", content: enrichedQuery });
+    stateGraph.push(discussionRootAgent, { role: "user", content: enrichedQuery });
     // Les outils (définition des fonctions) disponibles par l'agent courant
     const tools = currentAgentConfig.tools;
     // console.log('--- DBG toolLogic (1)',currentAgentConfig, currentAgentConfig?.toolLogic);
@@ -377,7 +294,7 @@ async function executeAgentSet(agentSet, context, params) {
     }
     // let shots = 1;
     let result = (0, types_1.enrichExecutionResult)({
-        runId: `${specializedAgent}-${Date.now()}`,
+        runId: `${discussionRootAgent}-${Date.now()}`,
         startQuery: query,
         actions: [],
         lastMessage: '',
@@ -385,7 +302,8 @@ async function executeAgentSet(agentSet, context, params) {
         moreThinkin: false,
     });
     do {
-        const options = Object.assign({}, currentAgentConfig?.model);
+        const model = modelConfig(currentAgentConfig.model);
+        const options = Object.assign({}, model);
         options.messages = discussion.messages;
         if (tools.length > 0) {
             options.tools = tools;
@@ -419,7 +337,7 @@ async function executeAgentSet(agentSet, context, params) {
             discussion,
             agentConfig: currentAgentConfig,
             agents,
-            agentName: specializedAgent,
+            discussionRootAgent, // ✅ CLÉ de discussion
             stdout: params.stdout,
             session: context,
             final,
@@ -427,6 +345,11 @@ async function executeAgentSet(agentSet, context, params) {
             enrichWithMemory: params.enrichWithMemory,
         });
         result = (0, types_1.executionResultMerge)(result, partial);
+        result.actions = stateGraph.steps(discussionRootAgent).map(step => ({
+            action: step.tool,
+            content: step.context,
+            feedback: step.reason
+        }));
         // Handle two-shot prompting: if instructions is an array, send the second part as a user message
         // This allows for more complex agent behavior by providing additional context or instructions
         // after the initial response, similar to chain-of-thought prompting
@@ -456,7 +379,7 @@ async function executeAgentSet(agentSet, context, params) {
     return result;
 }
 async function executeAgent(agentSet, params) {
-    const { query, verbose } = params;
+    const { query, verbose, debug } = params;
     const openai = (0, utils_1.openaiInstance)();
     const agent = agentSet.find(a => a.name === params.home);
     if (!agent) {
@@ -475,13 +398,17 @@ async function executeAgent(agentSet, params) {
     let maxIterations = 10; // Prevent infinite loops
     let iterations = 0;
     if (verbose) {
-        console.log('--- DBG executeAgent (simple):', agent.name);
+        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);
+    }
     // Execute the agent with tool call handling loop
     while (iterations < maxIterations) {
         iterations++;
-        const options = Object.assign({}, agent.model);
+        const options = Object.assign({}, modelConfig(agent.model));
         options.messages = messages;
         const tools = agent.tools || [];
         if (tools.length > 0) {
@@ -489,7 +416,7 @@ async function executeAgent(agentSet, params) {
             options.tool_choice = "auto";
         }
         if (verbose) {
-            console.log('--- DBG executeAgent (simple):', agent.name, 'iterations:', iterations, '\n', messages.length, '\n---', messages[messages.length - 1]?.content);
+            console.log('--- DBG executeAgent:', agent.name, 'iterations:', iterations, '\n', messages.length, '\n---', messages[messages.length - 1]?.content);
         }
         const stream = await openai.beta.chat.completions.stream(options);
         // Stream the response
@@ -501,8 +428,8 @@ async function executeAgent(agentSet, params) {
         }
         const final = await stream.finalChatCompletion();
         // Update usage and state
-        const model = agent.model?.model;
-        (0, princing_openai_1.accumulateCost)(usage, model, final.usage);
+        const model = modelConfig(agent.model).model;
+        (0, pricing_llm_1.accumulateCost)(usage, model, final.usage);
         state = final.id;
         // Add assistant response to messages
         const content = final.choices[0]?.message.content;
@@ -562,3 +489,74 @@ async function executeAgent(agentSet, params) {
         state
     };
 }
+/**
+ * Executes a simple query without agent orchestration or tool handling
+ *
+ * This is the simplest level of execution - just sends a query to the LLM
+ * and returns the response. No tools, no agent transfers, no complex logic.
+ *
+ * @param params - Execution parameters including query and model config
+ * @returns Promise<ExecuteAgentResult> - Simple result with usage and content
+ */
+async function executeQuery(params) {
+    const { query, verbose } = params;
+    // Get OpenAI/Grok instance
+    const openai = (0, utils_1.openaiInstance)();
+    // Use default model configuration if no home agent specified
+    const modelName = params.model || params.home || "LOW-fast";
+    const model = modelConfig(modelName);
+    const 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)}...`);
+    }
+    // Simple message array - no system prompt, just the user query
+    const messages = params.messages || [];
+    messages.push({ role: "user", content: query });
+    let usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
+    let state = '';
+    try {
+        // Create completion options
+        const options = Object.assign({}, model, more);
+        options.messages = messages;
+        if (verbose) {
+            console.log('--- DBG executeQuery options:', JSON.stringify(options, null, 2));
+        }
+        // Execute the query
+        const stream = await openai.beta.chat.completions.stream(options);
+        // Stream the response
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (delta?.content && params.stdout) {
+                params.stdout.write(delta?.content);
+            }
+        }
+        const final = await stream.finalChatCompletion();
+        // Update usage and state
+        (0, pricing_llm_1.accumulateCost)(usage, model.model, final.usage);
+        state = final.id || '';
+        // Get the response content
+        const content = final.choices[0]?.message.content || '';
+        if (verbose) {
+            console.log('--- DBG executeQuery completed, usage:', usage);
+        }
+        return {
+            usage,
+            content,
+            messages: [
+                ...messages,
+                { role: "assistant", content }
+            ],
+            state
+        };
+    }
+    catch (error) {
+        console.error('❌ executeQuery failed:', error);
+        throw error;
+    }
+}

package/dist/src/index.d.ts

@@ -6,7 +6,7 @@ export * from './utils';
 export * from './types';
 export * from './stategraph';
 export * from './execute';
-export * from './princing.openai';
+export * from './pricing.llm';
 export * from './scrapper';
 export * from './agents/reducer';
 export * from './agents/semantic';

package/dist/src/index.js

@@ -26,7 +26,7 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./stategraph"), exports);
 // Execute
 __exportStar(require("./execute"), exports);
-__exportStar(require("./princing.openai"), exports);
+__exportStar(require("./pricing.llm"), exports);
 // Scrapper
 __exportStar(require("./scrapper"), exports);
 // Agents

package/dist/src/{princing.openai.d.ts → pricing.llm.d.ts}

@@ -8,4 +8,10 @@ type ModelPricing = {
 export declare const modelPricing: Record<string, ModelPricing>;
 export declare function calculateCost(model: string, usage?: CompletionUsage): number;
 export declare function accumulateCost(currentUsage: Usage, model: string, usage?: CompletionUsage): number;
+export declare function LLM(openai: any): any;
+export declare const LLMxai: any;
+/**
+ * Get model mapping for OpenAI
+ */
+export declare const LLMopenai: any;
 export {};