agentic-api 1.0.6 → 2.0.31

package/dist/src/types.d.ts

@@ -47,69 +47,42 @@ export interface AgentModel {
 }
 export interface AgentConfig {
     name: string;
-    model?: AgentModel;
+    model: AgentModel;
     human?: boolean;
     publicDescription: string;
     instructions: string;
     maxSteps?: number;
     tools: Tool[];
-    toolLogic?: Record<string, (args: any, session?: AgenticContext) => Promise<any> | any>;
+    toolLogic?: Record<string, (args: any, session?: AgenticContext | any) => Promise<any> | any>;
     downstreamAgents?: AgentConfig[] | {
         name: string;
         publicDescription: string;
         human?: boolean;
     }[];
     ready?: boolean;
+    cancelMemory?: boolean;
 }
 export interface UserNano {
     id: string;
     isAnonymous?: boolean;
     role: string;
-}
-export declare abstract class AgenticMemory {
-    abstract get currentAgent(): AgentConfig;
-    abstract set currentAgent(agent: AgentConfig);
-    abstract agents: AgentConfig[];
-    abstract messages: any[];
-    abstract usage: Usage;
-    abstract state?: string;
-}
-export interface AgenticMemorySession {
-    state: string;
-    user: UserNano;
-    currentAgent: string;
-    messages: any[];
-    usage: Usage;
+    uid?: string;
 }
 export type AgenticCache = {
     get: <T>(key: string) => Promise<T | null>;
     set: <T>(key: string, value: T, ttl?: number) => Promise<T>;
 };
+export interface ExecuteAgentResult {
+    usage: Usage;
+    content: string;
+    messages: any[];
+    state: string;
+}
 export interface AgenticContext {
-    memory?: AgenticMemorySession;
     user: UserNano;
+    session: any;
     [key: string]: any;
-}
-export declare class AgenticMemoryManager extends AgenticMemory {
-    #private;
-    constructor(session: {
-        memory?: AgenticMemorySession;
-        user?: UserNano;
-    }, initialAgent: string, agents: AgentConfig[]);
-    static createOrLoad(session: {
-        memory?: AgenticMemorySession;
-        user: UserNano;
-    }, agents: any[], initialAgent: string): AgenticMemoryManager;
-    get session(): AgenticMemorySession;
-    get agents(): AgentConfig[];
-    get state(): string;
-    set state(state: string);
-    get currentAgent(): AgentConfig;
-    set currentAgent(agent: AgentConfig);
-    get usage(): Usage;
-    get messages(): any[];
-    set messages(messages: any[]);
-    set usage(usage: Usage);
+    currentAgent?: AgentConfig;
 }
 export type AllAgentConfigsType = Record<string, AgentConfig[]>;
 export interface Usage {
@@ -124,6 +97,7 @@ export interface Feedback {
     description?: string;
     usage: Usage;
     state: string;
+    verbose?: boolean;
 }
 export interface TranscriptItem {
     id: string;
@@ -134,3 +108,52 @@ export interface TranscriptItem {
     timestamp: string;
     status: "IN_PROGRESS" | "DONE";
 }
+/**
+ * Represents a single action taken during an agent execution.
+ *
+ * - For a transfer action, use `action: 'transfert'` and set `content` to the destination agent name.
+ * - For a tool call, use `action: <function name>` and set `content` to the tool output (stringified if needed).
+ * - `feedback` can include justification, notes, or any short status associated with the action.
+ */
+export interface ExecutionAction {
+    action: string;
+    content: string;
+    feedback?: string;
+}
+/**
+ * Aggregated result of an agent set execution.
+ *
+ * - `runId`: Correlation identifier for the execution run.
+ * - `actions`: Ordered list of actions (tools/transfers) performed.
+ * - `lastMessage`: The final assistant message content after execution.
+ * - `usage`: Token usage/cost snapshot for the whole execution.
+ * - `error`: Optional error message if something went wrong (non-fatal).
+ * - `moreThinkin`: When true, caller should continue the execution loop (retro-compat flag).
+ */
+export interface ExecutionResult {
+    runId: string;
+    /** Initial user query used to start the execution */
+    startQuery: string;
+    actions: ExecutionAction[];
+    lastMessage: string;
+    usage: Usage;
+    error?: string;
+    moreThinkin: boolean;
+    /**
+     * Human-readable summary formatter. Optional to preserve backward compatibility.
+     */
+    toString?: () => string;
+}
+/**
+ * Merge two partial execution results into a single result.
+ *
+ * Merge strategy:
+ * - `runId`: preserved from the primary accumulator `a`.
+ * - `actions`: appended in order (a.actions then b.actions).
+ * - `lastMessage`: preserved from `a` unless set elsewhere later in the workflow.
+ * - `usage`: summed field-by-field to accumulate totals across steps.
+ * - `error`: keep the latest non-undefined error (prefer `b`).
+ * - `moreThinkin`: true if either `a` or `b` requests continued thinking.
+ */
+export declare function enrichExecutionResult(result: ExecutionResult): ExecutionResult;
+export declare function executionResultMerge(a: ExecutionResult, b: ExecutionResult): ExecutionResult;

package/dist/src/types.js

@@ -1,93 +1,57 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _AgenticMemoryManager_memory, _AgenticMemoryManager_initialAgent, _AgenticMemoryManager_agents;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgenticMemoryManager = exports.AgenticMemory = void 0;
-class AgenticMemory {
-}
-exports.AgenticMemory = AgenticMemory;
-class AgenticMemoryManager extends AgenticMemory {
-    constructor(session, initialAgent, agents) {
-        super();
-        _AgenticMemoryManager_memory.set(this, void 0);
-        _AgenticMemoryManager_initialAgent.set(this, void 0);
-        _AgenticMemoryManager_agents.set(this, void 0);
-        __classPrivateFieldSet(this, _AgenticMemoryManager_initialAgent, initialAgent, "f");
-        __classPrivateFieldSet(this, _AgenticMemoryManager_agents, agents, "f");
-        //
-        // create sessionmemory if not exists
-        if (!session.memory) {
-            if (!session.user || !session.user.id) {
-                throw new Error('User ID is required');
-            }
-            session.memory = __classPrivateFieldSet(this, _AgenticMemoryManager_memory, {
-                state: '',
-                user: session.user,
-                messages: [],
-                currentAgent: initialAgent,
-                usage: { prompt: 0, completion: 0, total: 0, cost: 0 }
-            }, "f");
+exports.enrichExecutionResult = enrichExecutionResult;
+exports.executionResultMerge = executionResultMerge;
+/**
+ * Merge two partial execution results into a single result.
+ *
+ * Merge strategy:
+ * - `runId`: preserved from the primary accumulator `a`.
+ * - `actions`: appended in order (a.actions then b.actions).
+ * - `lastMessage`: preserved from `a` unless set elsewhere later in the workflow.
+ * - `usage`: summed field-by-field to accumulate totals across steps.
+ * - `error`: keep the latest non-undefined error (prefer `b`).
+ * - `moreThinkin`: true if either `a` or `b` requests continued thinking.
+ */
+function enrichExecutionResult(result) {
+    const formatAction = (action, index) => {
+        const content = (action.content ?? '').toString();
+        const trimmed = content.length > 160 ? content.slice(0, 160) + '…' : content;
+        const feedback = action.feedback ? ` | feedback: ${action.feedback}` : '';
+        return `${index + 1}. ${action.action}: ${trimmed}${feedback}`;
+    };
+    result.toString = () => {
+        const lines = [];
+        lines.push(`runId: ${result.runId}`);
+        lines.push(`startQuery: ${result.startQuery?.slice(0, 200)}`);
+        lines.push(`lastMessage: ${result.lastMessage?.slice(0, 200)}`);
+        lines.push(`usage: prompt=${result.usage?.prompt || 0}, completion=${result.usage?.completion || 0}, total=${result.usage?.total || 0}, cost=${result.usage?.cost || 0}`);
+        if (result.error) {
+            lines.push(`error: ${result.error}`);
         }
-        __classPrivateFieldSet(this, _AgenticMemoryManager_memory, session.memory, "f");
-        // this.#memory.state = session.memory.state,
-        // this.#memory.messages = session.memory.messages,
-        // this.#memory.currentAgent = session.memory.currentAgent,  
-        // this.#memory.usage = session.memory.usage    
-    }
-    //
-    // control and bind agent memory for one session
-    static createOrLoad(session, agents, initialAgent) {
-        return new AgenticMemoryManager(session, initialAgent, agents);
-    }
-    //
-    // get serializable session memory
-    get session() {
-        return {
-            state: __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").state,
-            user: __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").user,
-            messages: __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").messages,
-            currentAgent: __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").currentAgent,
-            usage: __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").usage,
-        };
-    }
-    get agents() {
-        return __classPrivateFieldGet(this, _AgenticMemoryManager_agents, "f");
-    }
-    get state() {
-        return __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").state;
-    }
-    set state(state) {
-        __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").state = state;
-    }
-    get currentAgent() {
-        const name = __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").currentAgent || __classPrivateFieldGet(this, _AgenticMemoryManager_initialAgent, "f");
-        return __classPrivateFieldGet(this, _AgenticMemoryManager_agents, "f").find((a) => a.name == name);
-    }
-    set currentAgent(agent) {
-        __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").currentAgent = agent.name;
-    }
-    get usage() {
-        return __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").usage;
-    }
-    get messages() {
-        return __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").messages;
-    }
-    set messages(messages) {
-        __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").messages = messages;
-    }
-    set usage(usage) {
-        __classPrivateFieldGet(this, _AgenticMemoryManager_memory, "f").usage = usage;
-    }
+        lines.push(`moreThinkin: ${Boolean(result.moreThinkin)}`);
+        const actions = result.actions || [];
+        lines.push(`actions (${actions.length}):`);
+        actions.forEach((a, i) => lines.push(`  - ${formatAction(a, i)}`));
+        return lines.join('\n');
+    };
+    return result;
+}
+function executionResultMerge(a, b) {
+    // Prefer b.runId if a.runId is empty (initial placeholder result)
+    const merged = {
+        runId: a.runId && a.runId.length > 0 ? a.runId : b.runId,
+        startQuery: a.startQuery || b.startQuery || '',
+        actions: [...(a.actions || []), ...(b.actions || [])],
+        lastMessage: a.lastMessage || '',
+        usage: {
+            prompt: (a.usage?.prompt || 0) + (b.usage?.prompt || 0),
+            completion: (a.usage?.completion || 0) + (b.usage?.completion || 0),
+            total: (a.usage?.total || 0) + (b.usage?.total || 0),
+            cost: (a.usage?.cost || 0) + (b.usage?.cost || 0),
+        },
+        error: b.error ?? a.error,
+        moreThinkin: Boolean(a.moreThinkin || b.moreThinkin),
+    };
+    return enrichExecutionResult(merged);
 }
-exports.AgenticMemoryManager = AgenticMemoryManager;
-_AgenticMemoryManager_memory = new WeakMap(), _AgenticMemoryManager_initialAgent = new WeakMap(), _AgenticMemoryManager_agents = new WeakMap();

package/dist/src/usecase.d.ts

@@ -0,0 +1,4 @@
+export declare function callGPTToExtractUserQueries(inputsection: string, file: string): Promise<{
+    json: any;
+    cost: number;
+}>;

package/dist/src/usecase.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callGPTToExtractUserQueries = callGPTToExtractUserQueries;
+const princing_openai_1 = require("./princing.openai");
+const prompts_1 = require("./prompts");
+const utils_1 = require("./utils");
+async function callGPTToExtractUserQueries(inputsection, file) {
+    const openai = (0, utils_1.openaiInstance)();
+    // Format: YYYY-MM-DD
+    const today = new Date().toISOString().substring(0, 10);
+    // Créer le prompt pour décrire la tâche au LLM
+    const messages = [
+        {
+            role: "system",
+            content: (0, prompts_1.usecaseExtractionPrompt)(file)
+        },
+        {
+            role: "user",
+            content: `Nous sommes le ${today}.\nVoici le document à analyser :\n${inputsection}`
+        }
+    ];
+    // WARNING: o3-mini is buggy with "Marche à suivre nouveau bail.pdf"
+    //const model = "o3-mini";// "gpt-4o-mini";
+    const model = "gpt-5-mini";
+    const response = await openai.chat.completions.create({
+        model: model,
+        reasoning_effort: "low",
+        verbosity: "low",
+        messages,
+        //reasoning_effort:"low",
+        response_format: { type: "json_object" }
+    });
+    // response_format: { type: "json_object" }
+    const cost = (0, princing_openai_1.calculateCost)(model, response.usage);
+    // Récupérer la réponse markdown
+    const json = response.choices[0].message.content;
+    console.log(`Markdown 💰 cost: ${cost}`);
+    //
+    // add a regex to extract the markdown content between <thinking></thinking> tags
+    // const thinking = markdown.match(/<thinking>[\s\S]*?<\/thinking>/)?.[0];
+    // const markdownWithoutThinking = markdown.replace(/<thinking>[\s\S]*?<\/thinking>/g, '');
+    // return markdownWithoutThinking;
+    return { json, cost };
+}

package/dist/src/utils.d.ts

@@ -1,13 +1,20 @@
 import { ParsedFunctionToolCall } from "openai/resources/beta/chat/completions";
-import { AgentConfig, AgenticContext, AgenticMemory } from "./types";
-import OpenAI from "openai";
-export declare const openaiInstance: (openai?: OpenAI) => any;
-export declare const slug: (text: string) => string;
+import { AgentConfig, AgenticContext } from "./types";
+export declare const openaiInstance: (openai?: any) => any;
+/**
+ * Converts a string to a URL-friendly slug
+ * @param text The text to convert to a slug
+ * @param whitespace The character to use for whitespace replacement (default: '-')
+ * @returns A URL-friendly slug
+ */
+export declare const toSlug: (text: string, whitespace?: string) => string;
 /**
  * This defines and adds "transferAgents" tool dynamically based on the specified downstreamAgents on each agent.
  */
 export declare function injectTransferTools(agentDefs: AgentConfig[]): AgentConfig[];
-export declare function handleTransferCall(memory: AgenticMemory, functionCallParams: ParsedFunctionToolCall, session: AgenticContext): Promise<any>;
+export declare function handleTransferCall(discussion: any, currentAgentRef: {
+    name: string;
+}, agents: AgentConfig[], functionCallParams: ParsedFunctionToolCall, context: AgenticContext): Promise<any>;
 /**
  * Calls the system review agent to analyze a prompt
  *

package/dist/src/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.slug = exports.openaiInstance = void 0;
+exports.toSlug = exports.openaiInstance = void 0;
 exports.injectTransferTools = injectTransferTools;
 exports.handleTransferCall = handleTransferCall;
 exports.callForSystemReview = callForSystemReview;
@@ -18,10 +18,28 @@ const openaiInstance = function (openai) {
     return _openaiInstance;
 };
 exports.openaiInstance = openaiInstance;
-const slug = (text) => {
-    return text.toLowerCase().replace(/ /g, '-').replace(/[^a-z0-9àâçéèêëîïôûù-]+/g, '').replace(/-{2,}/g, '-');
+/**
+ * Converts a string to a URL-friendly slug
+ * @param text The text to convert to a slug
+ * @param whitespace The character to use for whitespace replacement (default: '-')
+ * @returns A URL-friendly slug
+ */
+const toSlug = (text, whitespace = '-') => {
+    // Trim and lowercase
+    let str = text.trim().toLowerCase();
+    // Remove accents and special characters
+    const from = "àáäâèéëêìíïîòóöôùúüûñç·/_,:;";
+    const to = "aaaaeeeeiiiioooouuuunc------";
+    for (let i = 0, l = from.length; i < l; i++) {
+        str = str.replace(new RegExp(from.charAt(i), 'g'), to.charAt(i));
+    }
+    return str
+        .replace(/[^a-z0-9 -]/g, '') // Remove invalid chars
+        .replace(/\s+/g, whitespace) // Collapse whitespace and replace by whitespace char
+        .replace(/-+/g, whitespace === '-' ? '-' : whitespace) // Collapse dashes, but respect whitespace char
+        .replace(new RegExp(`^\\${whitespace}+|\\${whitespace}+$`, 'g'), ''); // Trim whitespace char (escape for regex)
 };
-exports.slug = slug;
+exports.toSlug = toSlug;
 /**
  * This defines and adds "transferAgents" tool dynamically based on the specified downstreamAgents on each agent.
  */
@@ -148,9 +166,8 @@ ${availableAgentsList}
 //
 // Fonction pour gérer un appel de fonction retourné par OpenAI
 // le contexte est un objet qui contient des informations supplémentaires de session
-async function handleTransferCall(memory, functionCallParams, session) {
-    const { agents } = memory;
-    const currentAgentName = memory.currentAgent?.name;
+async function handleTransferCall(discussion, currentAgentRef, agents, functionCallParams, context) {
+    const currentAgentName = currentAgentRef.name;
     const args = JSON.parse(functionCallParams?.function?.arguments || '{}');
     // console.log("↩️ Appel de fonction à gérer :",currentAgent?.name,'->', functionCallParams.function.name,'::',args);
     if (functionCallParams.function.name === "transferAgents") {
@@ -167,7 +184,7 @@ async function handleTransferCall(memory, functionCallParams, session) {
         // For debug, we don't want to transfer to the same agent
         if (currentAgentName === destinationAgentName) {
             console.log("❌ Le transfert sur moi-même n'est pas nécessaire", destinationAgentName, args);
-            memory.messages.slice(1).forEach(m => {
+            discussion.messages.slice(1).forEach((m) => {
                 process.stdout.write(`--    DBG      ---> 🤖 ${m.role}: ${m.content}\n`);
             });
         }
@@ -176,7 +193,7 @@ async function handleTransferCall(memory, functionCallParams, session) {
         const destinationAgent = agents.find((agent) => agent.name === destinationAgentName);
         if (destinationAgent) {
             //console.log(`🤖 Agent "${destinationAgent.name}" en préparation`);
-            memory.currentAgent = destinationAgent;
+            currentAgentRef.name = destinationAgent.name;
             return {
                 feedback: args.rationale_for_transfer,
                 destination_agent: destinationAgentName,
@@ -196,7 +213,7 @@ async function handleTransferCall(memory, functionCallParams, session) {
     }
     if (functionCallParams.function.name === "thinking") {
         const { justification, thought, step } = args;
-        console.log('🤖', memory.currentAgent?.name, '->', functionCallParams.function.name, '::', thought, '(step', step, ')');
+        console.log('🤖', currentAgentRef.name, '->', functionCallParams.function.name, '::', thought, '(step', step, ')');
         return {
             feedback: justification,
             content: `Pour l'étape ${step}, j'ai pensé à "${thought}"`,
@@ -206,10 +223,10 @@ async function handleTransferCall(memory, functionCallParams, session) {
     }
     //
     // looking on agents tool logic
-    const agent = memory.currentAgent;
+    // ⚠️ ALWAYS inject context in tool logic, ALWAYS!
+    const agent = agents.find(a => a.name === currentAgentRef.name);
     if (agent?.toolLogic && agent.toolLogic[functionCallParams.function.name]) {
-        const { content, usage } = await agent.toolLogic[functionCallParams.function.name](args, session);
-        console.log('🤖', agent.name, '->', functionCallParams.function.name, '::usage', usage);
+        const { content, usage } = await agent.toolLogic[functionCallParams.function.name](args, context);
         return {
             content,
             name: functionCallParams.function.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-api",
-  "version": "1.0.6",
+  "version": "2.0.31",
   "description": "API pour l'orchestration d'agents intelligents avec séquences et escalades automatiques",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -8,11 +8,13 @@
     "dist/src"
   ],
   "scripts": {
+    "prebuild": "npm version patch --no-git-tag-version",
     "build": "tsc",
     "test": "jest",
     "lint": "eslint 'src/**/*.ts'",
     "prepublishOnly": "npm run build",
-    "extract:pdf": "texttopdf "
+    "extract:pdf": "texttopdf ",
+    "deploy": "npm run prebuild && npm run build"
   },
   "optionalDependencies": {
     "python3": ">=3.5"
@@ -22,7 +24,11 @@
     "dotenv": "^16.4.7",
     "hnswlib-node": "^3.0.0",
     "jsdom": "^26.0.0",
-    "openai": "^4.102.0"
+    "minisearch": "^7.1.0",
+    "natural": "^8.1.0",
+    "openai": "^4.102.0",
+    "simple-git": "^3.27.0",
+    "stopwords-fr": "^0.3.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",