agentic-api 2.0.314 → 2.0.585

package/dist/src/stategraph/stategraph.js

@@ -41,6 +41,14 @@ class AgentStateGraph {
     }
     /**
      * Ajoute un message à la discussion d'un agent
+     * Gère tous types de messages : user, assistant, system, tool, function_call_output, etc.
+     *
+     * Utilisée par:
+     * - readCompletionsStream (responses.ts) : messages assistant avec tool_calls, content
+     * - batchProcessToolCalls (helpers.ts) : messages function_call_output
+     * - executeAgentSet (responses.ts) : messages user
+     * - stategraph.storage.ts : migration ancien format
+     *
      * @param agentName Nom de l'agent
      * @param message Message sans ID ni timestamp (auto-générés)
      */
@@ -83,8 +91,14 @@ class AgentStateGraph {
     }
     /**
      * Ajoute une étape au CONTEXT TRAIL et met à jour le message system
+     * Injecte automatiquement le trail dans le system message via updateSystemMessage()
+     *
+     * Utilisée par:
+     * - readCompletionsStream (responses.ts) : après chaque tool call exécuté
+     * - Tests d'intégration pour validation du context trail
+     *
      * @param agentName Nom de l'agent
-     * @param step Étape à ajouter au trail
+     * @param step Étape à ajouter au trail (tool, context, reason, id optionnel)
      */
     addStep(agentName, step) {
         const discussion = this.discussions.find(d => d.startAgent === agentName);
@@ -158,6 +172,17 @@ class AgentStateGraph {
     /**
      * Retourne une vue filtrée pour le client
      * Supprime les messages system et les métadonnées d'outils
+     *
+     * Filtre appliqué:
+     * - Exclut: system, tool, messages avec name (Chat Completions function results)
+     * - Exclut: function_call_output (Responses API)
+     * - Exclut: messages assistant avec tool_calls mais sans content
+     * - Nettoie: <memories> tags dans le content
+     *
+     * Utilisée par:
+     * - ctrl/agent.ts (agentic-server) : ctrlGetHistory, ctrlExecuteAgent
+     * - Tests d'intégration pour validation
+     *
      * @param agentName Nom de l'agent
      * @returns Discussion filtrée pour l'affichage client
      */
@@ -170,8 +195,23 @@ class AgentStateGraph {
             return content;
         };
         // Filtrer les messages pour le client - exclure system, tool et messages avec name
+        // ✅ Exclure aussi les messages Responses API (type: "function_call_output") et tool_calls sans content
         const clientMessages = discussion.messages
-            .filter(msg => msg.role !== 'system' && msg.role !== 'tool' && !msg.name)
+            .filter((msg) => {
+            // Exclure system et tool
+            if (msg.role === 'system' || msg.role === 'tool')
+                return false;
+            // Exclure messages avec name (Chat Completions function results)
+            if (msg.name)
+                return false;
+            // Exclure messages Responses API: function_call_output
+            if (msg.type === 'function_call_output')
+                return false;
+            // Exclure messages assistant avec tool_calls mais sans content (métadonnées de tools)
+            if (msg.tool_calls && msg.tool_calls.length > 0 && !msg.content)
+                return false;
+            return true;
+        })
             .map(msg => ({
             id: msg.id,
             role: msg.role,
@@ -184,6 +224,7 @@ class AgentStateGraph {
             description: discussion.description,
             agent: agentName,
             messages: clientMessages,
+            steps: [...discussion.trailSteps],
             usage: discussion.usage,
             createdAt: discussion.createdAt,
             updatedAt: discussion.updatedAt

package/dist/src/stategraph/stategraph.storage.js

@@ -22,6 +22,10 @@ const SESSION_STATEGRAPH_KEY = 'agentStateGraph';
  * @returns StateGraph existant ou nouveau
  */
 function sessionStateGraphGet(context) {
+    // ✅ Si un stateGraph est passé directement dans le contexte (mode sans session)
+    if (context.stateGraph && context.stateGraph instanceof stategraph_1.AgentStateGraph) {
+        return context.stateGraph;
+    }
     const session = context.session;
     if (!session) {
         // Pour les tests, retourner un nouveau StateGraph si pas de session

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

@@ -19,6 +19,9 @@ export interface AgentMessage {
     agent?: string;
     /** Timestamp de création */
     timestamp: Date;
+    type?: string;
+    tool_call_id?: string;
+    output?: string;
 }
 /**
  * Usage des tokens et coût
@@ -146,6 +149,8 @@ export interface ClientDiscussion {
         content: string;
         timestamp: Date;
     }>;
+    /** Context trail steps (actions effectuées) */
+    steps: StepTrail[];
     /** Usage des tokens */
     usage: TokenUsage;
     /** Dates */

package/dist/src/types.d.ts

@@ -9,12 +9,20 @@ export interface ToolParameterProperty {
     required?: string[];
     additionalProperties?: boolean;
     items?: ToolParameterProperty;
+    minLength?: number;
+    maxLength?: number;
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    default?: any;
+    [key: string]: any;
 }
 export interface ToolParameters {
     type: string;
     properties: Record<string, ToolParameterProperty>;
     required?: string[];
     additionalProperties?: boolean;
+    [key: string]: any;
 }
 export interface Tool {
     type: "function";
@@ -25,6 +33,17 @@ export interface Tool {
         strict: boolean;
     };
 }
+export type ToolContractOutput<T> = {
+    status: "ok" | "success" | "empty" | "error" | "transfer_required" | "multiple_results";
+    items?: T[];
+    meta?: Record<string, any>;
+    control?: {
+        next_hint?: string;
+        can_retry: boolean;
+        error_code?: string;
+        transfer_message?: string;
+    };
+};
 export interface AgentModelMapping {
     [key: string]: string;
 }
@@ -35,16 +54,30 @@ export interface AgentModel {
     topP?: number;
     stream?: boolean;
     parallel_tool_calls: boolean;
-    frequencyPenalty?: number;
-    presencePenalty?: number;
     stop?: string[] | string;
     tool_choice?: "auto" | "none" | "required";
     /**
      * Timeout in milliseconds for a query.
-     * If not specified, the default  (10 minutes).
+     * If not specified, the default (10 minutes).
      * https://platform.openai.com/docs/guides/flex-processing#api-request-timeouts
      */
     timeout?: number;
+    verbosity?: string;
+    reasoning_effort?: string;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    text?: {
+        verbosity?: string;
+        format?: {
+            type: string;
+            name?: string;
+            schema?: any;
+            strict?: boolean;
+        };
+    };
+    reasoning?: {
+        effort: string;
+    };
 }
 export interface AgentConfig {
     name: string;
@@ -85,6 +118,7 @@ export interface AgenticContext {
     session: any;
     [key: string]: any;
     currentAgent?: AgentConfig;
+    discussionRootAgent?: string;
 }
 export type AllAgentConfigsType = Record<string, AgentConfig[]>;
 export interface Usage {
@@ -130,7 +164,8 @@ export interface ExecutionAction {
  * - `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).
+ *
+ * NOTE: `moreThinkin` was removed (obsolete) - reasoning_effort in modelConfig handles this natively
  */
 export interface ExecutionResult {
     runId: string;
@@ -140,7 +175,6 @@ export interface ExecutionResult {
     lastMessage: string;
     usage: Usage;
     error?: string;
-    moreThinkin: boolean;
     /**
      * Human-readable summary formatter. Optional to preserve backward compatibility.
      */
@@ -152,10 +186,11 @@ export interface ExecutionResult {
  * 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.
+ * - `lastMessage`: prioritize more recent (b) over older (a).
  * - `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.
+ *
+ * NOTE: moreThinkin removed (obsolete) - always returns false
  */
 export declare function enrichExecutionResult(result: ExecutionResult): ExecutionResult;
 export declare function executionResultMerge(a: ExecutionResult, b: ExecutionResult): ExecutionResult;

package/dist/src/types.js

@@ -8,10 +8,11 @@ exports.executionResultMerge = executionResultMerge;
  * 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.
+ * - `lastMessage`: prioritize more recent (b) over older (a).
  * - `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.
+ *
+ * NOTE: moreThinkin removed (obsolete) - always returns false
  */
 function enrichExecutionResult(result) {
     const formatAction = (action, index) => {
@@ -29,7 +30,7 @@ function enrichExecutionResult(result) {
         if (result.error) {
             lines.push(`error: ${result.error}`);
         }
-        lines.push(`moreThinkin: ${Boolean(result.moreThinkin)}`);
+        // moreThinkin removed (obsolete) - reasoning_effort fait le job
         const actions = result.actions || [];
         lines.push(`actions (${actions.length}):`);
         actions.forEach((a, i) => lines.push(`  - ${formatAction(a, i)}`));
@@ -42,16 +43,16 @@ function executionResultMerge(a, b) {
     const merged = {
         runId: a.runId && a.runId.length > 0 ? a.runId : b.runId,
         startQuery: a.startQuery || b.startQuery || '',
-        actions: [],
-        lastMessage: a.lastMessage || '',
+        actions: [...(a.actions || []), ...(b.actions || [])], // ✅ BUG FIX: Fusionner les actions
+        lastMessage: b.lastMessage || a.lastMessage || '', // ✅ BUG FIX: Prioriser le plus récent (b)
         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),
+        error: b.error ?? a.error
+        // moreThinkin removed (obsolete) - reasoning_effort fait le job
     };
     return enrichExecutionResult(merged);
 }

package/dist/src/usecase.js

@@ -24,7 +24,7 @@ async function llmExtractUserQueries(inputsection, file, options = { model: "LOW
     // response_format: { type: "json_object" }
     const result = await (0, execute_1.executeQuery)({
         query,
-        home: options.model,
+        model: options.model,
         stdout: execute_1.DummyWritable,
         verbose: false,
         json: true

package/dist/src/utils.d.ts

@@ -1,13 +1,5 @@
 import { ParsedFunctionToolCall } from "openai/resources/beta/chat/completions";
 import { AgentConfig, AgenticContext } from "./types";
-import OpenAI from "openai";
-/**
- * global openai instance
- */
-declare global {
-    var _openaiInstance_: OpenAI | undefined;
-}
-export declare const openaiInstance: (envKey?: string, baseUrl?: string) => OpenAI;
 /**
  * Converts a string to a URL-friendly slug
  * @param text The text to convert to a slug

package/dist/src/utils.js

@@ -1,34 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toSlug = exports.openaiInstance = void 0;
+exports.toSlug = void 0;
 exports.injectTransferTools = injectTransferTools;
 exports.handleTransferCall = handleTransferCall;
 const prompts_1 = require("./prompts");
-const openai_1 = __importDefault(require("openai"));
-const openaiInstance = function (envKey, baseUrl) {
-    if (globalThis._openaiInstance_) {
-        return globalThis._openaiInstance_;
-    }
-    if (!envKey) {
-        throw new Error('AI API key is missing');
-    }
-    const options = {
-        apiKey: process.env[envKey],
-        timeout: 60000 * 15
-    };
-    if (baseUrl) {
-        options.baseURL = baseUrl;
-    }
-    globalThis._openaiInstance_ = new openai_1.default(options);
-    if (!globalThis._openaiInstance_) {
-        throw new Error('OpenAI instance has not been initialized');
-    }
-    return globalThis._openaiInstance_;
-};
-exports.openaiInstance = openaiInstance;
 /**
  * Converts a string to a URL-friendly slug
  * @param text The text to convert to a slug
@@ -152,6 +127,14 @@ ${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
+//
+// 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.
 async function handleTransferCall(discussion, currentAgentRef, agents, functionCallParams, context) {
     const currentAgentName = currentAgentRef.name;
     const args = JSON.parse(functionCallParams?.function?.arguments || '{}');
@@ -199,6 +182,7 @@ async function handleTransferCall(discussion, currentAgentRef, agents, functionC
             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
             };
@@ -219,11 +203,24 @@ async function handleTransferCall(discussion, currentAgentRef, agents, functionC
     // ⚠️ 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, context);
+        const rawResult = await agent.toolLogic[functionCallParams.function.name](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
+        const toolContext = rawResult.context || 'Null';
+        const toolId = rawResult.id || args.justification || JSON.stringify(args);
         return {
-            content,
+            content: rawResult.content, // ✅ Peut être undefined pour ToolContractOutput
             name: functionCallParams.function.name,
-            usage
+            context: toolContext,
+            id: toolId,
+            usage: rawResult.usage,
+            feedback: rawResult.feedback,
+            rawResult: rawResult // ✅ Préserver le résultat brut pour sérialisation
         };
     }
     else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-api",
-  "version": "2.0.314",
+  "version": "2.0.585",
   "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",
@@ -10,11 +10,13 @@
   "scripts": {
     "prebuild": "npm version patch --no-git-tag-version",
     "build": "tsc",
-    "test": "jest -- tests --testPathIgnorePatterns=agent* --silent --verbose=false",
-    "test:quiet": "jest --silent -- tests --testPathIgnorePatterns=agent*",
-    "test:verbose": "jest --verbose -- tests --testPathIgnorePatterns=agent*",
-    "test:simulator": "jest -- tests --testNamePattern=simulator.* --silent --verbose=false",
-    "test:simulator:quiet": "jest --silent -- tests --testNamePattern=simulator.*",
+    "test": "jest --silent",
+    "test:quiet": "jest --testPathIgnorePatterns=agent* --silent tests",
+    "test:verbose": "jest --testPathIgnorePatterns=agent* --verbose tests",
+    "test:simulator": "jest --testNamePattern=simulator.* --silent tests",
+    "test:simulator:quiet": "jest --testNamePattern=simulator.* --silent tests",
+    "test:merge-recovery": "jest --testPathPattern=merge-recovery --verbose",
+    "test:merge-recovery:single": "jest --testPathPattern=merge-recovery --testNamePattern=corrupted-index-from-previous-pr --verbose",
     "lint": "eslint 'src/**/*.ts'",
     "prepublishOnly": "npm run build",
     "extract:pdf": "texttopdf ",
@@ -31,7 +33,7 @@
     "jsdom": "^26.0.0",
     "minisearch": "^7.1.0",
     "natural": "^8.1.0",
-    "openai": "^4.102.0",
+    "openai": "^5.23.2",
     "simple-git": "^3.27.0",
     "stopwords-fr": "^0.3.0"
   },

package/dist/src/execute.d.ts

@@ -1,63 +0,0 @@
-import { AgentConfig, AgenticContext, AgentModel, ExecuteAgentResult, Feedback, ExecutionResult } from "./types";
-import { Writable } from "stream";
-import { AgentStateGraph } from "./stategraph";
-export declare const DummyWritable: any;
-export declare function modelConfig(model: string, custom?: any): AgentModel;
-export declare function sendFeedback(params: Feedback): void;
-export interface ReadCompletionsStreamOptions {
-    stateGraph: AgentStateGraph;
-    discussion: any;
-    agentConfig: AgentConfig;
-    agents: AgentConfig[];
-    discussionRootAgent: string;
-    stdout: Writable;
-    session: AgenticContext;
-    final: any;
-    verbose?: boolean;
-    enrichWithMemory?: (role: string, agent: AgentConfig, context: AgenticContext) => Promise<string>;
-}
-export declare function readCompletionsStream(params: ReadCompletionsStreamOptions): Promise<ExecutionResult>;
-/**
- * Parameters for executing an agent set
- * @interface ExecuteAgentSetParams
- * @property {string} query - User query to process
- * @property {string} home - Name of the agent to start with
- * @property {Writable} stdout - Stream to write output to
- * @property {any[]} [messages] - Messages to add to the conversation
- * @property {boolean} [verbose] - Whether to log verbose debug information
- */
-export interface ExecuteAgentSetParams {
-    enrichWithMemory?: (role: string, agent: AgentConfig, context: AgenticContext) => Promise<string>;
-    query: string;
-    home?: string;
-    model?: string;
-    stdout: Writable;
-    messages?: any[];
-    verbose?: boolean;
-    json?: boolean;
-    schema?: any;
-    debug?: boolean;
-}
-/**
- * Executes a set of agents to process a user query
- *
- * This function initializes the agent memory, processes the user query through the appropriate
- * agent, and handles any agent transfers or tool calls that occur during execution.
- *
- * @param {AgentConfig[]} agentSet - Array of agent configurations
- * @param {AgenticContext} session - {memory, user, ...}  - Session object to store/read conversation state
- * @param {ExecuteAgentSetParams} params - Execution parameters
- * @returns {Promise<void>}
- */
-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
- *
- * 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
- */
-export declare function executeQuery(params: ExecuteAgentSetParams): Promise<ExecuteAgentResult>;