agentic-api 2.0.646 → 2.0.885

package/dist/src/stategraph/stategraph.d.ts

@@ -38,7 +38,7 @@ export declare class AgentStateGraph implements IAgentStateGraph {
     set(agentName: string, content: string): void;
     /**
      * Ajoute une étape au CONTEXT TRAIL et met à jour le message system
-     * Injecte automatiquement le trail dans le system message via updateSystemMessage()
+     * Injecte automatiquement le trail dans le system message via updateSystemContextTrail()
      *
      * Utilisée par:
      * - readCompletionsStream (responses.ts) : après chaque tool call exécuté
@@ -64,7 +64,7 @@ export declare class AgentStateGraph implements IAgentStateGraph {
      * Met à jour le message system avec le nouveau trail via regexp
      * @param agentName Nom de l'agent
      */
-    private updateSystemMessage;
+    private updateSystemContextTrail;
     /**
      * Additionne l'usage des tokens pour un agent
      * @param agentName Nom de l'agent
@@ -95,6 +95,10 @@ export declare class AgentStateGraph implements IAgentStateGraph {
      * @returns Discussion trouvée ou undefined
      */
     findDiscussionById(discussionId: string): AgentDiscussion | undefined;
+    /**
+     * Supprime les sessions enfants sub-agent dont l'id commence par `{parentId}_subAgent`
+     */
+    private deleteChildSubAgentDiscussions;
     /**
      * Supprime une discussion
      * @param discussionId ID de la discussion à supprimer

package/dist/src/stategraph/stategraph.js

@@ -86,12 +86,12 @@ class AgentStateGraph {
             discussion.messages[0].agent = systemMessage.agent;
             discussion.messages[0].timestamp = new Date();
         }
-        this.updateSystemMessage(discussion);
+        this.updateSystemContextTrail(discussion);
         discussion.updatedAt = new Date();
     }
     /**
      * Ajoute une étape au CONTEXT TRAIL et met à jour le message system
-     * Injecte automatiquement le trail dans le system message via updateSystemMessage()
+     * Injecte automatiquement le trail dans le system message via updateSystemContextTrail()
      *
      * Utilisée par:
      * - readCompletionsStream (responses.ts) : après chaque tool call exécuté
@@ -105,7 +105,7 @@ class AgentStateGraph {
         if (!discussion)
             return;
         discussion.trailSteps.push(step);
-        this.updateSystemMessage(discussion);
+        this.updateSystemContextTrail(discussion);
     }
     /**
      * Retourne tous les steps du CONTEXT TRAIL pour une discussion
@@ -127,15 +127,14 @@ class AgentStateGraph {
             return '(No actions yet)';
         }
         return discussion.trailSteps.map(s => {
-            const idPart = s.id ? ` [id: ${s.id}]` : '';
-            return `- ${s.tool}: ${s.context} "${s.reason}"${idPart}`;
+            return `- ${s.tool}: ${s.reason}`;
         }).join('\n');
     }
     /**
      * Met à jour le message system avec le nouveau trail via regexp
      * @param agentName Nom de l'agent
      */
-    updateSystemMessage(discussion) {
+    updateSystemContextTrail(discussion) {
         const systemMessage = discussion.messages.find((m) => m.role === 'system');
         if (!systemMessage)
             return;
@@ -238,12 +237,27 @@ class AgentStateGraph {
     findDiscussionById(discussionId) {
         return this.discussions.find(d => d.id === discussionId);
     }
+    /**
+     * Supprime les sessions enfants sub-agent dont l'id commence par `{parentId}_subAgent`
+     */
+    deleteChildSubAgentDiscussions(parentId) {
+        if (!parentId)
+            return;
+        const prefix = `${parentId}_subAgent`;
+        const children = this.discussions.filter(d => d.id.startsWith(prefix));
+        for (const child of children) {
+            this.deleteDiscussion(child.id);
+        }
+    }
     /**
      * Supprime une discussion
      * @param discussionId ID de la discussion à supprimer
      * @returns true si supprimée, false si non trouvée
      */
     deleteDiscussion(discussionId) {
+        if (!discussionId)
+            return false;
+        this.deleteChildSubAgentDiscussions(discussionId);
         const index = this.discussions.findIndex(d => d.id === discussionId);
         if (index >= 0) {
             this.discussions.splice(index, 1);
@@ -257,6 +271,7 @@ class AgentStateGraph {
      */
     clearDiscussion(agentName) {
         const discussion = this.createOrRestore(agentName);
+        this.deleteChildSubAgentDiscussions(discussion.id);
         // Garder uniquement le premier message s'il est de type system
         if (discussion.messages.length > 0 && discussion.messages[0].role === 'system') {
             discussion.messages = [discussion.messages[0]];

package/dist/src/stategraph/types.d.ts

@@ -41,14 +41,10 @@ export interface TokenUsage {
  * Utilisé pour maintenir une mémoire de travail des actions effectuées par les outils
  */
 export interface StepTrail {
-    /** Nom de l'outil (ex: "transferAgents", "database") */
+    /** Nom de l'outil (ex: "resolveLocataire", "lookupKnowledge") */
     tool: string;
-    /** Contexte de l'action (ex: "orientation → guess-word") */
-    context: string;
-    /** Justification/raison de l'action */
+    /** Raison de l'appel (context du résultat ou justification de l'appel) */
     reason: string;
-    /** ID optionnel pour détection de boucles */
-    id?: string;
 }
 /**
  * Discussion d'agent - thread de messages pour un agent spécifique
@@ -73,6 +69,18 @@ export interface AgentDiscussion {
     updatedAt: Date;
     /** Agent qui a initié cette discussion (requis) */
     startAgent: string;
+    /**
+     * Responses API: ID de la dernière réponse complète du tour précédent.
+     * Permet d'utiliser previous_response_id pour éviter de re-envoyer l'historique complet.
+     * Mis à jour à la FIN de chaque tour (readCompletionsStream, base cases uniquement).
+     */
+    lastResponseId?: string;
+    /**
+     * Nombre de messages dans discussion.messages à la fin du tour précédent.
+     * Permet de calculer le delta : messages.slice(lastResponseMsgCount) = nouveaux messages.
+     * Mis à jour en même temps que lastResponseId.
+     */
+    lastResponseMsgCount?: number;
 }
 /**
  * Interface principale du StateGraph pour gérer les discussions par agent

package/dist/src/types.d.ts

@@ -42,8 +42,25 @@ export type ToolContractOutput<T> = {
         can_retry: boolean;
         error_code?: string;
         transfer_message?: string;
+        pipeline?: string[];
+        query_id?: string;
     };
 };
+export interface SubAgentResult {
+    /** Dernier message produit par le sub-agent (réponse finale) */
+    message: string;
+    /** Nom original du sub-agent appelé (ex: "PR-knowledge") */
+    agentName: string;
+    /** Clé de session scoped utilisée ({parentId}_{toolName}) */
+    sessionKey: string;
+    /** Usage tokens consommés par le sub-agent */
+    usage: {
+        prompt: number;
+        completion: number;
+        total: number;
+        cost: number;
+    };
+}
 export interface AgentModelMapping {
     [key: string]: string;
 }
@@ -94,6 +111,11 @@ export interface AgentConfig {
         publicDescription: string;
         human?: boolean;
     }[];
+    subAgents?: AgentConfig[] | {
+        name: string;
+        publicDescription: string;
+    }[];
+    outputSchema?: any;
     ready?: boolean;
     cancelMemory?: boolean;
 }

package/dist/src/utils.d.ts

@@ -7,6 +7,12 @@ import { AgentConfig, AgenticContext } from "./types";
  * @returns A URL-friendly slug
  */
 export declare const toSlug: (text: string, whitespace?: string) => string;
+import { subAgentInjectTools, subAgentExtractCapabilities, subAgentComposeMission } from './agents/subagent';
+/** @deprecated Use subAgentInjectTools from 'agents/subagent' */
+export declare const injectSubAgentTools: typeof subAgentInjectTools;
+/** @deprecated Use subAgentExtractCapabilities from 'agents/subagent' */
+export declare const extractAgentCapabilities: typeof subAgentExtractCapabilities;
+export { subAgentComposeMission };
 /**
  * Contrat standard JSON pour le transfert (handoff) entre agents.
  *
@@ -35,6 +41,24 @@ export declare const toSlug: (text: string, whitespace?: string) => string;
  * https://github.com/openai/openai-realtime-agents/blob/without-agents-sdk/src/app/agentConfigs/utils.ts
  */
 export declare function injectTransferTools(agentDefs: AgentConfig[]): AgentConfig[];
+/**
+ * Gère le transfert d'un agent vers un autre (handoff).
+ * Responsabilité unique : `transferAgents` uniquement.
+ *
+ * TODO [Phase 2 - openai-agents-js]:
+ * Sera remplacé par le handoff natif openai-agents-js.
+ * Les concepts downstreamAgents/confidence seront mappés vers swarm.run / handoff strategies.
+ * @deprecated
+ */
 export declare function handleTransferCall(discussion: any, currentAgentRef: {
     name: string;
 }, agents: AgentConfig[], functionCallParams: ParsedFunctionToolCall, context: AgenticContext): Promise<any>;
+/**
+ * Gère les tool calls métier (toolLogic) et le thinking interne.
+ * Extrait de handleTransferCall — responsabilité : tout sauf transferAgents et subAgent*.
+ *
+ * ⚠️ ALWAYS inject context in tool logic, ALWAYS!
+ */
+export declare function handleToolLogicCall(currentAgentRef: {
+    name: string;
+}, agents: AgentConfig[], functionCallParams: ParsedFunctionToolCall, context: AgenticContext): Promise<any>;

package/dist/src/utils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toSlug = void 0;
+exports.subAgentComposeMission = exports.extractAgentCapabilities = exports.injectSubAgentTools = exports.toSlug = void 0;
 exports.injectTransferTools = injectTransferTools;
 exports.handleTransferCall = handleTransferCall;
+exports.handleToolLogicCall = handleToolLogicCall;
 const prompts_1 = require("./prompts");
 /**
  * Converts a string to a URL-friendly slug
@@ -26,6 +27,16 @@ const toSlug = (text, whitespace = '-') => {
         .replace(new RegExp(`^\\${whitespace}+|\\${whitespace}+$`, 'g'), ''); // Trim whitespace char (escape for regex)
 };
 exports.toSlug = toSlug;
+// ============================================================================
+// SubAgent functions — re-exported from agents/subagent.ts
+// Aliases preserve backward compatibility with existing imports.
+// ============================================================================
+const subagent_1 = require("./agents/subagent");
+Object.defineProperty(exports, "subAgentComposeMission", { enumerable: true, get: function () { return subagent_1.subAgentComposeMission; } });
+/** @deprecated Use subAgentInjectTools from 'agents/subagent' */
+exports.injectSubAgentTools = subagent_1.subAgentInjectTools;
+/** @deprecated Use subAgentExtractCapabilities from 'agents/subagent' */
+exports.extractAgentCapabilities = subagent_1.subAgentExtractCapabilities;
 /**
  * Contrat standard JSON pour le transfert (handoff) entre agents.
  *
@@ -124,113 +135,100 @@ ${availableAgentsList}
     });
     return agentDefs;
 }
-//
-// Fonction pour gérer un appel de fonction retourné par OpenAI
-// le contexte est un objet qui contient des informations supplémentaires de session
-//
-// TODO [Phase 2 - openai-agents-js]: 
-// Cette logique de handleTransferCall sera remplacée par le handoff natif
-// de openai-agents-js (https://openai.github.io/openai-agents-js/)
-// qui gère les transferts via policies et router intégrés.
-// Les concepts de downstreamAgents et confidence seront mappés 
-// vers les primitives de l'Agent SDK (swarm.run, handoff strategies).
-// Le stateGraph restera compatible car il utilise AgentMessage générique.
+/**
+ * Gère le transfert d'un agent vers un autre (handoff).
+ * Responsabilité unique : `transferAgents` uniquement.
+ *
+ * TODO [Phase 2 - openai-agents-js]:
+ * Sera remplacé par le handoff natif openai-agents-js.
+ * Les concepts downstreamAgents/confidence seront mappés vers swarm.run / handoff strategies.
+ * @deprecated
+ */
 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") {
-        if (args.confidence < 0.7) {
-            return {
-                content: "Le transfert n'est pas nécessaire, tu DOIS répondre directement",
-                feedback: args.rationale_for_transfer,
-                did_transfer: false,
-                name: functionCallParams.function.name
-            };
-        }
-        const destinationAgentName = args.destination_agent;
-        console.log(`🤖 Transfert de l'agent "${currentAgentName}" vers "${destinationAgentName}" (${args?.confidence})`, '::', args?.rationale_for_transfer);
-        // 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);
-            discussion.messages.slice(1).forEach((m) => {
-                process.stdout.write(`--    DBG      ---> 🤖 ${m.role}: ${m.content}\n`);
-            });
-        }
-        //
-        // agent transfer to the destination agent
-        const destinationAgent = agents.find((agent) => agent.name === destinationAgentName);
-        if (destinationAgent) {
-            //console.log(`🤖 Agent "${destinationAgent.name}" en préparation`);
-            currentAgentRef.name = destinationAgent.name;
-            //
-            // Generate ID for CONTEXT TRAIL (loop detection)
-            const transferId = (0, exports.toSlug)(args.rationale_for_transfer);
-            return {
-                name: functionCallParams.function.name, // ← tool pour addStep
-                feedback: args.rationale_for_transfer, // ← reason pour addStep
-                context: `${currentAgentName} → ${destinationAgentName}`, // ← context pour addStep
-                id: transferId, // ← ID optionnel pour addStep
-                destination_agent: destinationAgentName,
-                source_agent: currentAgentName,
-                content: '', // ✅ Transfert silencieux
-                did_transfer: true
-            };
-        }
-        else {
-            console.log(`❌L'agent destination "${destinationAgentName}" n'a pas été trouvé.`);
-            return {
-                feedback: `❌ L'agent destination "${destinationAgentName}" n'a pas été trouvé.`,
-                content: `❌L'agent destination "${destinationAgentName}" n'a pas été trouvé.`,
-                context: `❌L'agent destination "${destinationAgentName}" n'a pas été trouvé.`,
-                did_transfer: false,
-                name: functionCallParams.function.name
-            };
-        }
+    if (args.confidence < 0.7) {
+        return {
+            content: "Le transfert n'est pas nécessaire, tu DOIS répondre directement",
+            feedback: args.rationale_for_transfer,
+            did_transfer: false,
+            name: functionCallParams.function.name
+        };
+    }
+    const destinationAgentName = args.destination_agent;
+    console.log(`🤖 Transfert de l'agent "${currentAgentName}" vers "${destinationAgentName}" (${args?.confidence})`, '::', args?.rationale_for_transfer);
+    if (currentAgentName === destinationAgentName) {
+        console.log("❌ Le transfert sur moi-même n'est pas nécessaire", destinationAgentName, args);
+        discussion.messages.slice(1).forEach((m) => {
+            process.stdout.write(`--    DBG      ---> 🤖 ${m.role}: ${m.content}\n`);
+        });
     }
-    if (functionCallParams.function.name === "thinking") {
+    const destinationAgent = agents.find(a => a.name === destinationAgentName);
+    if (destinationAgent) {
+        currentAgentRef.name = destinationAgent.name;
+        const transferId = (0, exports.toSlug)(args.rationale_for_transfer);
+        return {
+            name: functionCallParams.function.name,
+            feedback: args.rationale_for_transfer,
+            context: `${currentAgentName} → ${destinationAgentName}`,
+            id: transferId,
+            destination_agent: destinationAgentName,
+            source_agent: currentAgentName,
+            content: '',
+            did_transfer: true
+        };
+    }
+    console.log(`❌ L'agent destination "${destinationAgentName}" n'a pas été trouvé.`);
+    return {
+        feedback: `❌ L'agent destination "${destinationAgentName}" n'a pas été trouvé.`,
+        content: `❌ L'agent destination "${destinationAgentName}" n'a pas été trouvé.`,
+        context: `❌ L'agent destination "${destinationAgentName}" n'a pas été trouvé.`,
+        did_transfer: false,
+        name: functionCallParams.function.name
+    };
+}
+/**
+ * Gère les tool calls métier (toolLogic) et le thinking interne.
+ * Extrait de handleTransferCall — responsabilité : tout sauf transferAgents et subAgent*.
+ *
+ * ⚠️ ALWAYS inject context in tool logic, ALWAYS!
+ */
+async function handleToolLogicCall(currentAgentRef, agents, functionCallParams, context) {
+    const args = JSON.parse(functionCallParams?.function?.arguments || '{}');
+    const toolName = functionCallParams.function.name;
+    if (toolName === 'thinking') {
         const { justification, thought, step } = args;
-        console.log('🤖', currentAgentRef.name, '->', functionCallParams.function.name, '::', thought, '(step', step, ')');
+        console.log('🤖', currentAgentRef.name, '->', toolName, '::', thought, '(step', step, ')');
         return {
             feedback: justification,
             content: `Pour l'étape ${step}, j'ai pensé à "${thought}"`,
-            name: functionCallParams.function.name,
+            name: toolName,
             usage: 0
         };
     }
-    //
-    // looking on agents tool logic
-    // ⚠️ 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 rawResult = await agent.toolLogic[functionCallParams.function.name](args, context);
+    if (agent?.toolLogic && agent.toolLogic[toolName]) {
+        const rawResult = await agent.toolLogic[toolName](args, context);
         //
         // ✅ Le tool peut retourner { content, context, id, usage? } OU ToolContractOutput
-        // - Si content existe → utiliser le texte formaté
-        // - Sinon → préserver rawResult pour sérialisation (ToolContractOutput)
         // - context: identifiant sémantique unique pour le trail (ex: "intention_123", "daily-events")
-        // - id: slug unique pour détection de boucles (généralement dérivé du context)
-        // Si le tool ne fournit pas context/id, on utilise le nom du tool comme fallback
+        // - id: slug unique pour détection de boucles
         const toolContext = rawResult.context || 'Null';
         const toolId = rawResult.id || args.justification || JSON.stringify(args);
         return {
-            content: rawResult.content, // ✅ Peut être undefined pour ToolContractOutput
-            name: functionCallParams.function.name,
+            content: rawResult.content,
+            name: toolName,
             context: toolContext,
             id: toolId,
             usage: rawResult.usage,
             feedback: rawResult.feedback,
-            rawResult: rawResult // ✅ Préserver le résultat brut pour sérialisation
-        };
-    }
-    else {
-        // whit thinking, we hask the agent to restart the conversation 
-        // console.log('🤖',agent.name,'->',agent.tools[0]);
-        console.log("❌ Cette fonction n'existe pas !", agent.name, functionCallParams.function.name);
-        return {
-            feedback: `Humm, cette fonction "${functionCallParams.function.name}" n'existe pas!`,
-            name: functionCallParams.function.name,
-            content: `Cette fonction "${functionCallParams.function.name}" n'existe pas, tu ne dois plus l'appeler et TU DOIS répondre à la question.`
+            rawResult: rawResult
         };
     }
+    console.log("❌ Cette fonction n'existe pas !", agent?.name, toolName);
+    return {
+        feedback: `Humm, cette fonction "${toolName}" n'existe pas!`,
+        name: toolName,
+        content: `Cette fonction "${toolName}" n'existe pas, tu ne dois plus l'appeler et TU DOIS répondre à la question.`
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-api",
-  "version": "2.0.646",
+  "version": "2.0.885",
   "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",
@@ -9,7 +9,7 @@
   ],
   "scripts": {
     "prebuild": "npm version patch --no-git-tag-version",
-    "build": "tsc",
+    "build": "tsc && cp mupdf-extract.mjs dist/",
     "test": "jest --silent",
     "test:quiet": "jest --testPathIgnorePatterns=agent* --silent tests",
     "test:verbose": "jest --testPathIgnorePatterns=agent* --verbose tests",
@@ -32,6 +32,7 @@
     "hnswlib-node": "^3.0.0",
     "jsdom": "^26.0.0",
     "minisearch": "^7.1.0",
+    "mupdf": "^1.27.0",
     "natural": "^8.1.0",
     "openai": "^5.23.2",
     "simple-git": "^3.27.0",

package/dist/src/agents/semantic.d.ts

@@ -1,4 +0,0 @@
-import { AgentConfig } from "../types";
-export declare const semantic: AgentConfig;
-declare const agents: AgentConfig[];
-export default agents;

package/dist/src/agents/semantic.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.semantic = void 0;
-const utils_1 = require("../utils");
-const prompts_1 = require("./prompts");
-exports.semantic = {
-    name: "semantic",
-    model: "LOW",
-    publicDescription: "Agent spécialisé dans l’extraction sémantique structurée",
-    instructions: prompts_1.semanticPrompt,
-    tools: [],
-    downstreamAgents: []
-};
-//instructions: [semanticPrompt, semanticStructurePrompt],
-//
-// go back to semantic once the task is done
-// add the transfer tool to point to downstreamAgents
-const agents = (0, utils_1.injectTransferTools)([exports.semantic]);
-exports.default = agents;

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

@@ -1,46 +0,0 @@
-/**
- * Legacy Implementation - Chat Completions API (beta.chat.completions)
- *
- * ⚠️ Cette implémentation utilise openai.beta.chat.completions.stream (ancienne API)
- * Pour les nouveaux projets, Responses API (responses.ts) est recommandée.
- *
- * Code optimisé depuis execute.ts original avec les améliorations suivantes:
- * - OPTIM: Helpers centralisés (accumulateUsageTokens, stepsToActions)
- * - BUG FIX: executionResultMerge fusionne actions correctement (corrigé dans types.ts)
- * - BUG FIX: moreThinkin supprimé (obsolète, reasoning_effort fait le job)
- * - BUG FIX: Suppression de la boucle do...while(moreThinkin)
- * - BUG FIX: Suppression de la ligne reasoning_effort dupliquée (ligne 425 originale)
- *
- * TODO [Optimisation future]: Remplacer la boucle for séquentielle par batchProcessToolCalls
- * pour exploiter pleinement parallel_tool_calls et réduire la latence
- */
-import { AgentConfig, AgenticContext, ExecuteAgentResult, ExecutionResult } from "../types";
-import { ReadCompletionsStreamOptions, ExecuteAgentSetParams } from "./shared";
-export declare function readCompletionsStream(params: ReadCompletionsStreamOptions): Promise<ExecutionResult>;
-/**
- * Parameters for executing an agent set
- */
-export interface ExecuteAgentSetParamsLegacy {
-    enrichWithMemory?: (role: string, agent: AgentConfig, context: AgenticContext) => Promise<string>;
-    query: string;
-    home?: string;
-    thinking?: boolean;
-    model?: string;
-    stdout: any;
-    messages?: any[];
-    verbose?: boolean;
-    json?: boolean;
-    schema?: any;
-    debug?: boolean;
-}
-/**
- * Executes a set of agents to process a user query
- *
- * OPTIMIZED: Sans boucle do...while(moreThinkin), reasoning_effort fait le job
- */
-export declare function executeAgentSet(agentSet: AgentConfig[], context: AgenticContext, params: ExecuteAgentSetParams): Promise<ExecutionResult>;
-export declare function executeAgent(agentSet: AgentConfig[], params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;
-/**
- * Executes a simple query without agent orchestration or tool handling
- */
-export declare function executeQuery(params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;