agentic-api 1.0.5 → 2.0.26

package/dist/src/execute.js

@@ -4,32 +4,92 @@ exports.modelConfig = modelConfig;
 exports.sendFeedback = sendFeedback;
 exports.readCompletionsStream = readCompletionsStream;
 exports.executeAgentSet = executeAgentSet;
+exports.executeAgent = executeAgent;
 const princing_openai_1 = require("./princing.openai");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
+const stategraph_1 = require("./stategraph");
 function modelConfig(model, custom) {
     const defaultOptions = Object.assign({
-        max_completion_tokens: 15192,
         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: 0.3,
+            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-4.1-nano"
+            model: "gpt-5-mini",
+            reasoning_effort: "minimal",
+            verbosity: "low",
+            stream: true
         },
-        "MEDIUM": {
-            temperature: 0.3,
+        "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
         },
-        "HIGH": {
-            temperature: 0.3,
+        "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,
@@ -51,14 +111,16 @@ function modelConfig(model, custom) {
     return options;
 }
 function sendFeedback(params) {
-    const { agent, stdout, description, usage, state } = params;
+    const { agent, stdout, description, usage, state, verbose } = params;
     const feedback = {
         agent,
         description,
         usage,
         state
     };
-    //console.log('--- DBG feedback --:',description);
+    // if(verbose) {
+    //   console.log('--- DBG sendFeedback:',agent, description || '--', state);
+    // }
     //
     // send agent state and description
     stdout.write(`\n<step>${JSON.stringify(feedback)}</step>\n`);
@@ -67,79 +129,124 @@ async function readCompletionsStream(params) {
     const openai = (0, utils_1.openaiInstance)();
     //
     // set default context here
-    const { memory, stdout, final, session } = params;
-    const model = memory.currentAgent.model.model;
+    const { stateGraph, discussion, agentConfig, agents, agentName, stdout, final, session, verbose } = params;
+    const model = agentConfig.model.model;
     const accumulatedFunctionCall = final.choices[0]?.message.tool_calls || [];
     const content = final.choices[0]?.message.content;
     let thinking = false;
-    (0, princing_openai_1.accumulateCost)(memory, model, final.usage);
-    memory.state = final.id;
-    //console.log("✅ DEBUG memory (IN messages):",memory.messages);
+    let localResult = (0, types_1.enrichExecutionResult)({
+        runId: `${agentName}-${Date.now()}`,
+        startQuery: '',
+        actions: [],
+        lastMessage: '',
+        usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
+        moreThinkin: false,
+    });
+    // Accumulate cost in the discussion usage
+    (0, princing_openai_1.accumulateCost)(discussion.usage, model, final.usage);
+    stateGraph.updateTokens(agentName, {
+        prompt: final.usage?.prompt_tokens || 0,
+        completion: final.usage?.completion_tokens || 0,
+        total: final.usage?.total_tokens || 0,
+        cost: 0 // Cost already accumulated directly in discussion.usage
+    });
+    // Store state (implementation can be added later if needed)
+    // discussion.state = final.id;
     if (content) {
-        console.log("✅ Agent (1): 🌶️🌶️🌶️ content:", content);
-        memory.messages.push({ role: "assistant", content });
+        if (verbose)
+            console.log("✅ Agent (1): 🌶️🌶️🌶️  save content:", content?.length);
+        stateGraph.push(agentName, { 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) {
             sendFeedback({
-                agent: memory.currentAgent.name,
+                agent: agentConfig.name,
                 stdout,
                 description: args.justification,
-                usage: memory.usage,
-                state: memory.state
+                usage: discussion.usage,
+                state: '', // State will be set later if needed,
+                verbose
             });
         }
-        const functionCallResult = await (0, utils_1.handleTransferCall)(memory, functionCall, session);
+        // 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, session);
         // result can be 
         // {content, usage}  {did_transfer}
         thinking = functionCallResult.thinking;
         if (functionCallResult.usage) {
-            (0, princing_openai_1.accumulateCost)(memory, model, functionCallResult.usage);
+            stateGraph.updateTokens(agentName, {
+                prompt: functionCallResult.usage.prompt || 0,
+                completion: functionCallResult.usage.completion || 0,
+                total: functionCallResult.usage.total || 0,
+                cost: functionCallResult.usage.cost || 0
+            });
         }
         if (functionCallResult.did_transfer) {
-            console.log("✅ Agent transfer response:", functionCallResult.source_agent, ' call function ', functionCall.function.name, '::to', functionCallResult.destination_agent, ' transfer done ✅');
+            // 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 ✅');
             // Mise à jour du message système avec les nouvelles instructions du nouvel agent courant
-            const instructions = memory.currentAgent.instructions;
-            const enrichedInstructions = (await params.enrichWithMemory?.("system")) || '';
-            memory.messages[0] = { role: "system", content: instructions + '\n' + enrichedInstructions };
+            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 "${memory.currentAgent?.name}" a été effectué, Tu dois répondre immédiatement à la question.`;
-            memory.messages.push({
+            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",
-                name: functionCallResult.name,
                 content: message,
+                name: functionCallResult.name
             });
+            // Immediately surface the tool confirmation to the user output
+            // feedback or message?
+            if (message) {
+                stdout.write(message + "\n");
+            }
         }
         //
         // other function call have a result
         else if (functionCallResult.content) {
-            // console.log("✅ Agent tool response:",memory.currentAgent?.name,'::',functionCall.function.name, ' with content',functionCallResult.content);
-            memory.messages.push({
+            // 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, {
                 role: "assistant",
-                name: functionCallResult.name,
                 content: functionCallResult.content,
+                name: functionCallResult.name
             });
         }
         //
         // send user feedback 
         if (functionCallResult.feedback) {
             sendFeedback({
-                agent: memory.currentAgent.name,
+                agent: agentConfig.name,
                 stdout,
                 description: functionCallResult.feedback,
-                usage: memory.usage,
-                state: memory.state
+                usage: discussion.usage,
+                state: '', // State tracking can be added later if needed
+                verbose
             });
         }
         // Réactualisation de la liste des outils pour le nouvel agent courant
-        const tools = memory.currentAgent?.tools || [];
-        const followUpOptions = Object.assign({}, memory.currentAgent?.model);
-        followUpOptions.messages = memory.messages;
+        const currentAgent = agents.find(a => a.name === currentAgentRef.name) || agentConfig;
+        const tools = currentAgent?.tools || [];
+        const followUpOptions = Object.assign({}, currentAgent?.model);
+        followUpOptions.messages = discussion.messages;
         //
         // always force HIGH model for follow up
-        followUpOptions.model = "gpt-4.1";
+        followUpOptions.model = currentAgent.model.model;
         if (tools.length > 0) {
             followUpOptions.tools = tools;
             followUpOptions.tool_choice = "auto";
@@ -161,28 +268,55 @@ async function readCompletionsStream(params) {
         // console.log("✅ DEBUG followUpOptions (OUT tool_calls):",final.choices[0]?.message.tool_calls);
         //
         // when called a function, agent must continue the conversation
+        // if(verbose) console.log("✅ Agent ( followUp - OUT):",currentAgent.name, 'with tool_calls ',!!(final.choices[0]?.message.tool_calls),' and content:' ,!!(final.choices[0]?.message.content));
         if (final.choices[0]?.message.tool_calls) {
-            // console.log("✅ Agent (OUT):",currentAgent?.name,'continue with new call => go to readCompletionsStream (2)');
-            return await readCompletionsStream({ memory, stdout, final, session });
+            const partial = await readCompletionsStream({
+                stateGraph,
+                discussion,
+                agentConfig: currentAgent,
+                agents,
+                agentName,
+                stdout,
+                final,
+                session,
+                verbose,
+                enrichWithMemory: params.enrichWithMemory
+            });
+            localResult = (0, types_1.executionResultMerge)(localResult, partial);
+            return localResult;
         }
-        (0, princing_openai_1.accumulateCost)(memory, followUpOptions.model, final.usage);
-        memory.state = final.id;
+        // Accumulate final cost
+        stateGraph.updateTokens(agentName, {
+            prompt: final.usage?.prompt_tokens || 0,
+            completion: final.usage?.completion_tokens || 0,
+            total: final.usage?.total_tokens || 0,
+            cost: 0 // Cost calculation handled internally
+        });
         //
         // send the cost
         sendFeedback({
-            agent: memory.currentAgent.name,
+            agent: currentAgent.name,
             stdout,
             description: '',
-            usage: memory.usage,
-            state: memory.state
+            usage: discussion.usage,
+            state: final.id || '',
+            verbose
         });
         const content = final.choices[0]?.message.content;
-        console.log("✅ Agent (OUT):", memory.currentAgent?.name, 'with content length', content?.length);
+        //
+        // capture new memory with the last message
+        await params.enrichWithMemory?.("assistant", currentAgent, session);
+        // if(verbose) console.log("✅ Agent (OUT):",currentAgent.name, 'with content length',!!content);
         if (content) {
-            memory.messages.push({ role: "assistant", content });
+            stateGraph.push(agentName, { role: "assistant", content });
+        }
+        if (content?.includes('<continue>')) {
+            localResult.moreThinkin = true;
+            return localResult;
         }
-        return false;
+        return localResult;
     }
+    return localResult;
 }
 /**
  * Executes a set of agents to process a user query
@@ -195,49 +329,64 @@ async function readCompletionsStream(params) {
  * @param {ExecuteAgentSetParams} params - Execution parameters
  * @returns {Promise<void>}
  */
-async function executeAgentSet(agentSet, session, params) {
-    const { query, home, verbose } = params;
+async function executeAgentSet(agentSet, context, params) {
+    const { query, verbose } = params;
     const openai = (0, utils_1.openaiInstance)();
     const agents = (0, utils_1.injectTransferTools)(agentSet);
-    const memory = types_1.AgenticMemoryManager.createOrLoad(session, agents, home);
-    //
-    // restore the current agent
-    const currentAgent = memory.currentAgent;
-    if (!currentAgent) {
-        throw new Error(`Agent ${home} not found`);
+    const home = 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 };
+    // 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 (!currentAgent.instructions) {
-        throw new Error(`Agent ${home} has no instructions`);
+    if (!currentAgentConfig.instructions) {
+        throw new Error(`Agent ${currentAgent} has no instructions`);
     }
-    //
-    // set the initial agent instructions and memory
-    if (!memory.messages.length) {
-        memory.usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
+    // 🔧 Setup system message si pas encore fait
+    let enrichedQuery = query;
+    if (!discussion.messages.length) {
+        discussion.usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
         //
-        // add the initial agent to his memory
+        // add the initial agent to his memory as System
         // Handle two-shot prompting: if instructions is an array, use the first part as a system message
-        const enrichedInstructions = (await params.enrichWithMemory?.("system")) || '';
-        const instructions = currentAgent.instructions + '\n' + enrichedInstructions;
-        memory.messages.push({ role: "system", content: instructions });
+        const enrichedInstructions = await params.enrichWithMemory?.("system", currentAgentConfig, context);
+        const instructions = currentAgentConfig.instructions + '\n' + enrichedInstructions;
+        stateGraph.set(specializedAgent, instructions);
+    }
+    else {
+        // enrich the user query with memory as User
+        enrichedQuery = (await params.enrichWithMemory?.("user", currentAgentConfig, context)) || query;
     }
     // Append the user's query to the session-specific messages
     // input: `${getMemoryString(relevantMemories)}\n${input}`,
-    memory.messages.push({ role: "user", content: query });
+    stateGraph.push(specializedAgent, { role: "user", content: enrichedQuery });
     // Les outils (définition des fonctions) disponibles par l'agent courant
-    const tools = currentAgent.tools;
-    // console.log('--- DBG toolLogic (1)',memory.currentAgent, memory.currentAgent?.toolLogic);
+    const tools = currentAgentConfig.tools;
+    // console.log('--- DBG toolLogic (1)',currentAgentConfig, currentAgentConfig?.toolLogic);
     if (verbose) {
-        console.log('--- DBG current agent', currentAgent.name);
-        console.log('--- DBG memory len:', memory.messages.length);
-        console.log('--- DBG query:', query);
+        console.log('--- DBG current agent', currentAgentConfig.name, 'memory len:', discussion.messages.length);
     }
     // let shots = 1;
-    let thinking = false;
-    let message;
+    let result = (0, types_1.enrichExecutionResult)({
+        runId: `${specializedAgent}-${Date.now()}`,
+        startQuery: query,
+        actions: [],
+        lastMessage: '',
+        usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
+        moreThinkin: false,
+    });
     do {
-        thinking = false;
-        const options = Object.assign({}, currentAgent?.model);
-        options.messages = memory.messages;
+        const options = Object.assign({}, currentAgentConfig?.model);
+        options.messages = discussion.messages;
         if (tools.length > 0) {
             options.tools = tools;
             options.tool_choice = "auto";
@@ -259,21 +408,25 @@ async function executeAgentSet(agentSet, session, params) {
         //   state:memory.state!
         // })    
         for await (const chunk of stream) {
-            if (verbose)
-                process.stdout.write(chunk.choices[0]?.delta?.content || "");
             const delta = chunk.choices[0]?.delta;
             if (delta?.content) {
                 params.stdout.write(delta?.content);
             }
         }
         const final = await stream.finalChatCompletion();
-        thinking = await readCompletionsStream({
-            memory,
+        const partial = await readCompletionsStream({
+            stateGraph,
+            discussion,
+            agentConfig: currentAgentConfig,
+            agents,
+            agentName: specializedAgent,
             stdout: params.stdout,
-            session,
+            session: context,
             final,
+            verbose,
             enrichWithMemory: params.enrichWithMemory,
         });
+        result = (0, types_1.executionResultMerge)(result, partial);
         // 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
@@ -283,7 +436,129 @@ async function executeAgentSet(agentSet, session, params) {
         //   thinking = true;
         //   shots++;
         // }
-        if (thinking)
+        if (result.moreThinkin)
             console.log("🌶️🌶️🌶️ restart thinking:");
-    } while (thinking);
+    } while (result.moreThinkin);
+    // 💾 Auto-save du StateGraph à la fin (context contient session, user, credential, etc.)
+    (0, stategraph_1.sessionStateGraphSet)(context, stateGraph);
+    // finalize result (usage accumulated via discussion.usage once here)
+    result.lastMessage = discussion.messages?.[discussion.messages.length - 1]?.content || '';
+    // Ensure usage reflects the aggregated discussion usage (prompt/completion/total)
+    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 } = 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`);
+    }
+    // Simple message array without memory manager - but preserve conversation
+    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; // Prevent infinite loops
+    let iterations = 0;
+    if (verbose) {
+        console.log('--- DBG executeAgent (simple):', agent.name);
+        console.log('--- DBG query:', `${query?.substring(0, 100)}...`);
+    }
+    // Execute the agent with tool call handling loop
+    while (iterations < maxIterations) {
+        iterations++;
+        const options = Object.assign({}, 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 (simple):', 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
+        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();
+        // Update usage and state
+        const model = agent.model?.model;
+        (0, princing_openai_1.accumulateCost)(usage, model, final.usage);
+        state = final.id;
+        // Add assistant response to messages
+        const content = final.choices[0]?.message.content;
+        if (content) {
+            messages.push({ role: "assistant", content });
+        }
+        // Handle tool calls if any
+        const toolCalls = final.choices[0]?.message.tool_calls;
+        let hasToolCalls = false;
+        if (toolCalls && toolCalls.length > 0) {
+            hasToolCalls = true;
+            // First, update the assistant message with tool_calls
+            const lastAssistant = messages[messages.length - 1];
+            if (lastAssistant && lastAssistant.role === 'assistant') {
+                lastAssistant.tool_calls = toolCalls;
+            }
+            else {
+                // If no assistant message, add one with tool calls
+                messages.push({
+                    role: "assistant",
+                    content: content || null,
+                    tool_calls: toolCalls
+                });
+            }
+            // Then execute tools and add tool responses
+            for (const toolCall of toolCalls) {
+                const args = JSON.parse(toolCall.function.arguments || '{}');
+                // Execute tool if it exists in agent's toolLogic
+                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 no tool calls, we're done
+        if (!hasToolCalls) {
+            break;
+        }
+    }
+    return {
+        usage,
+        content: messages[messages.length - 1]?.content || '',
+        messages,
+        state
+    };
 }

package/dist/src/index.d.ts

@@ -4,8 +4,17 @@
  */
 export * from './utils';
 export * from './types';
+export * from './stategraph';
 export * from './execute';
 export * from './princing.openai';
 export * from './scrapper';
+export * from './agents/reducer';
 export * from './agents/semantic';
 export * from './agents/system';
+export * from './rag';
+export * from './usecase';
+export * from './rules';
+export * from './agents/simulator';
+export * from './agents/simulator.types';
+export * from './agents/simulator.prompts';
+export * from './agents/simulator.utils';

package/dist/src/index.js

@@ -22,11 +22,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils"), exports);
 // Types
 __exportStar(require("./types"), exports);
+// StateGraph - nouvelle architecture de gestion des discussions
+__exportStar(require("./stategraph"), exports);
 // Execute
 __exportStar(require("./execute"), exports);
 __exportStar(require("./princing.openai"), exports);
 // Scrapper
 __exportStar(require("./scrapper"), exports);
 // Agents
+__exportStar(require("./agents/reducer"), exports);
 __exportStar(require("./agents/semantic"), exports);
 __exportStar(require("./agents/system"), exports);
+// RAG Library
+__exportStar(require("./rag"), exports);
+// Usecase
+__exportStar(require("./usecase"), exports);
+// Rules API (test export)
+__exportStar(require("./rules"), exports);
+// Simulator
+__exportStar(require("./agents/simulator"), exports);
+__exportStar(require("./agents/simulator.types"), exports);
+__exportStar(require("./agents/simulator.prompts"), exports);
+__exportStar(require("./agents/simulator.utils"), exports);

package/dist/src/princing.openai.d.ts

@@ -1,4 +1,11 @@
 import { CompletionUsage } from "openai/resources";
-import { AgenticMemory } from "./types";
+import { Usage } from "./types";
+type ModelPricing = {
+    input: number;
+    cachedInput?: number;
+    output: number;
+};
+export declare const modelPricing: Record<string, ModelPricing>;
 export declare function calculateCost(model: string, usage?: CompletionUsage): number;
-export declare function accumulateCost(memory: AgenticMemory, model: string, usage?: CompletionUsage): number;
+export declare function accumulateCost(currentUsage: Usage, model: string, usage?: CompletionUsage): number;
+export {};