agentic-api 1.0.6 → 2.0.31

package/dist/src/stategraph/stategraph.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * @fileoverview Implémentation du système AgentStateGraph
+ * Classe principale pour gérer les discussions par agent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentStateGraph = void 0;
+const crypto_1 = require("crypto");
+const types_1 = require("./types");
+/**
+ * Implémentation du StateGraph pour la gestion des discussions par agent
+ * Remplace AgenticMemoryManager avec une architecture simplifiée
+ */
+class AgentStateGraph {
+    constructor() {
+        this.discussions = [];
+    }
+    /**
+     * Crée ou restaure une discussion pour un agent donné
+     * @param agentName Nom de l'agent
+     * @returns Discussion existante ou nouvelle discussion créée
+     */
+    createOrRestore(agentName, description) {
+        // Chercher une discussion existante pour cet agent
+        let discussion = this.discussions.find(d => d.startAgent === agentName);
+        if (!discussion) {
+            // Créer une nouvelle discussion
+            discussion = {
+                id: (0, crypto_1.randomUUID)(),
+                description: description,
+                messages: [],
+                usage: { prompt: 0, completion: 0, total: 0, cost: 0 },
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                startAgent: agentName
+            };
+            this.discussions.push(discussion);
+        }
+        return discussion;
+    }
+    /**
+     * Ajoute un message à la discussion d'un agent
+     * @param agentName Nom de l'agent
+     * @param message Message sans ID ni timestamp (auto-générés)
+     */
+    push(agentName, message) {
+        const discussion = this.createOrRestore(agentName);
+        const fullMessage = {
+            ...message,
+            id: (0, crypto_1.randomUUID)(),
+            timestamp: new Date()
+        };
+        discussion.messages.push(fullMessage);
+        discussion.updatedAt = new Date();
+    }
+    /**
+     * Écrase le message system de la discussion avec un nouvel agent
+     * Le message system est toujours messages[0] avec role: "system"
+     * @param agentName Nom de l'agent
+     * @param content Nouveau contenu du message system
+     */
+    set(agentName, content) {
+        const discussion = this.createOrRestore(agentName);
+        const systemMessage = {
+            id: (0, crypto_1.randomUUID)(),
+            role: 'system',
+            content,
+            agent: agentName,
+            timestamp: new Date()
+        };
+        // Écraser ou créer le message system (toujours en position 0)
+        if (discussion.messages.length === 0) {
+            discussion.messages.push(systemMessage);
+        }
+        else {
+            discussion.messages[0] = systemMessage;
+        }
+        discussion.updatedAt = new Date();
+    }
+    /**
+     * Additionne l'usage des tokens pour un agent
+     * @param agentName Nom de l'agent
+     * @param usage Ajout aux valeurs existantes (addition)
+     */
+    updateTokens(agentName, usage) {
+        const discussion = this.createOrRestore(agentName);
+        // Additionner les valeurs aux existantes
+        discussion.usage = {
+            prompt: discussion.usage.prompt + (usage.prompt ?? 0),
+            completion: discussion.usage.completion + (usage.completion ?? 0),
+            total: discussion.usage.total + (usage.total ?? 0),
+            cost: discussion.usage.cost ? discussion.usage.cost + (usage.cost ?? 0) : (usage.cost ?? 0)
+        };
+        discussion.updatedAt = new Date();
+    }
+    /**
+     * Retourne une vue filtrée pour le client
+     * Supprime les messages system et les métadonnées d'outils
+     * @param agentName Nom de l'agent
+     * @returns Discussion filtrée pour l'affichage client
+     */
+    toClientView(agentName) {
+        const discussion = this.createOrRestore(agentName);
+        const cleanContent = (content) => {
+            if (typeof content === 'string') {
+                return content.replace(/<memories[^>]+[\s\S]*?<\/memories>/g, '');
+            }
+            return content;
+        };
+        // Filtrer les messages pour le client - exclure system et tool
+        const clientMessages = discussion.messages
+            .filter(msg => msg.role !== 'system' && !msg.name)
+            .map(msg => ({
+            id: msg.id,
+            role: msg.role,
+            content: cleanContent(msg.content),
+            timestamp: msg.timestamp
+        }));
+        return {
+            id: discussion.id,
+            name: discussion.name,
+            description: discussion.description,
+            agent: agentName,
+            messages: clientMessages,
+            usage: discussion.usage,
+            createdAt: discussion.createdAt,
+            updatedAt: discussion.updatedAt
+        };
+    }
+    /**
+     * Trouve une discussion par son ID
+     * @param discussionId ID de la discussion
+     * @returns Discussion trouvée ou undefined
+     */
+    findDiscussionById(discussionId) {
+        return this.discussions.find(d => d.id === discussionId);
+    }
+    /**
+     * Supprime une discussion
+     * @param discussionId ID de la discussion à supprimer
+     * @returns true si supprimée, false si non trouvée
+     */
+    deleteDiscussion(discussionId) {
+        const index = this.discussions.findIndex(d => d.id === discussionId);
+        if (index >= 0) {
+            this.discussions.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Vide une discussion en gardant uniquement le message system
+     * @param agentName Nom de l'agent
+     */
+    clearDiscussion(agentName) {
+        const discussion = this.createOrRestore(agentName);
+        // 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]];
+        }
+        else {
+            discussion.messages = [];
+        }
+        // Réinitialiser l'usage
+        discussion.usage = { prompt: 0, completion: 0, total: 0, cost: 0 };
+        discussion.updatedAt = new Date();
+    }
+    /**
+     * Supprime un message spécifique d'une discussion
+     * @param agentName Nom de l'agent
+     * @param messageId ID du message à supprimer
+     * @returns true si le message a été supprimé, false s'il n'a pas été trouvé
+     */
+    deleteMessage(agentName, messageId) {
+        const discussion = this.createOrRestore(agentName);
+        // Trouver l'index du message à supprimer
+        const messageIndex = discussion.messages.findIndex(msg => msg.id === messageId);
+        if (messageIndex !== -1) {
+            // Supprimer le message
+            discussion.messages.splice(messageIndex, 1);
+            discussion.updatedAt = new Date();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Renomme une discussion
+     * @param discussionId ID de la discussion
+     * @param name Nouveau nom
+     * @param description Nouvelle description (optionnel)
+     */
+    renameDiscussion(discussionId, name, description) {
+        const discussion = this.findDiscussionById(discussionId);
+        if (discussion) {
+            discussion.name = name;
+            if (description !== undefined) {
+                discussion.description = description;
+            }
+            discussion.updatedAt = new Date();
+        }
+    }
+    /**
+     * Retourne l'agent spécialisé pour une discussion
+     * @param agentName Nom de l'agent
+     * @returns Nom de l'agent spécialisé
+     */
+    getSpecializedAgent(agentName) {
+        const discussion = this.discussions.find(d => d.startAgent === agentName);
+        if (discussion) {
+            return (0, types_1.getSpecializedAgent)(discussion);
+        }
+        return agentName;
+    }
+    /**
+     * Sérialise le StateGraph en JSON
+     * @returns Représentation JSON
+     */
+    toJSON() {
+        return {
+            discussions: this.discussions
+        };
+    }
+    /**
+     * Restaure le StateGraph depuis JSON
+     * @param data Données JSON
+     */
+    fromJSON(data) {
+        if (data.discussions && Array.isArray(data.discussions)) {
+            this.discussions = data.discussions.map((d) => ({
+                ...d,
+                createdAt: new Date(d.createdAt),
+                updatedAt: new Date(d.updatedAt),
+                messages: d.messages.map((m) => ({
+                    ...m,
+                    timestamp: new Date(m.timestamp)
+                }))
+            }));
+        }
+    }
+}
+exports.AgentStateGraph = AgentStateGraph;

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

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Gestion du stockage et de la persistance pour AgentStateGraph
+ * Intégration avec req.session avec compression gzip pour optimiser la taille
+ */
+import { AgentStateGraph } from './stategraph';
+import { AgenticContext } from '../types';
+/**
+ * Récupère le StateGraph depuis la session avec décompression
+ * @param context qui contient la session requête Express OU objet avec session pour les tests
+ * @returns StateGraph existant ou nouveau
+ */
+export declare function sessionStateGraphGet(context: AgenticContext): AgentStateGraph;
+/**
+ * Sauvegarde le StateGraph dans la session avec compression
+ * @param req Requête Express avec session OU objet avec session pour les tests
+ * @param stateGraph StateGraph à sauvegarder
+ */
+export declare function sessionStateGraphSet(context: AgenticContext, stateGraph: AgentStateGraph): void;
+/**
+ * Supprime le StateGraph de la session
+ * @param context AgenticContext qui contient la session
+ */
+export declare function sessionStateGraphClear(context: AgenticContext): void;
+/**
+ * Vérifie si un StateGraph existe dans la session
+ * @param context AgenticContext qui contient la session
+ * @returns true si un StateGraph existe
+ */
+export declare function sessionStateGraphExists(context: AgenticContext): boolean;
+/**
+ * Obtient la taille du StateGraph en session (en bytes)
+ * @param context AgenticContext qui contient la session
+ * @returns Taille en bytes ou 0 si pas de StateGraph
+ */
+export declare function sessionStateGraphSize(context: AgenticContext): number;
+/**
+ * Convertit req.session.memory vers AgentStateGraph
+ * @param context AgenticContext qui contient la session
+ * @returns true si migration effectuée
+ */
+export declare function migrateFromLegacySession(context: AgenticContext): boolean;

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

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * @fileoverview Gestion du stockage et de la persistance pour AgentStateGraph
+ * Intégration avec req.session avec compression gzip pour optimiser la taille
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionStateGraphGet = sessionStateGraphGet;
+exports.sessionStateGraphSet = sessionStateGraphSet;
+exports.sessionStateGraphClear = sessionStateGraphClear;
+exports.sessionStateGraphExists = sessionStateGraphExists;
+exports.sessionStateGraphSize = sessionStateGraphSize;
+exports.migrateFromLegacySession = migrateFromLegacySession;
+const zlib_1 = require("zlib");
+const stategraph_1 = require("./stategraph");
+/**
+ * Clé utilisée pour stocker le StateGraph dans req.session
+ */
+const SESSION_STATEGRAPH_KEY = 'agentStateGraph';
+/**
+ * Récupère le StateGraph depuis la session avec décompression
+ * @param context qui contient la session requête Express OU objet avec session pour les tests
+ * @returns StateGraph existant ou nouveau
+ */
+function sessionStateGraphGet(context) {
+    const session = context.session;
+    if (!session) {
+        // Pour les tests, retourner un nouveau StateGraph si pas de session
+        if (process.env.NODE_ENV === 'test') {
+            return new stategraph_1.AgentStateGraph();
+        }
+        throw new Error('Session middleware non configuré');
+    }
+    // Vérifier si un StateGraph existe dans la session
+    const compressedData = session[SESSION_STATEGRAPH_KEY];
+    if (compressedData) {
+        try {
+            // Décompresser et parser le JSON
+            const jsonData = (0, zlib_1.gunzipSync)(Buffer.from(compressedData, 'base64')).toString('utf8');
+            const data = JSON.parse(jsonData);
+            // Créer un nouveau StateGraph et le restaurer
+            const stateGraph = new stategraph_1.AgentStateGraph();
+            stateGraph.fromJSON(data);
+            return stateGraph;
+        }
+        catch (error) {
+            console.warn('Erreur lors de la restauration du StateGraph:', error);
+            // En cas d'erreur, retourner un nouveau StateGraph
+        }
+    }
+    // Retourner un nouveau StateGraph si rien en session
+    return new stategraph_1.AgentStateGraph();
+}
+/**
+ * Sauvegarde le StateGraph dans la session avec compression
+ * @param req Requête Express avec session OU objet avec session pour les tests
+ * @param stateGraph StateGraph à sauvegarder
+ */
+function sessionStateGraphSet(context, stateGraph) {
+    const session = context.session;
+    if (!session) {
+        // Pour les tests, ne rien faire si pas de session
+        if (process.env.NODE_ENV === 'test') {
+            return;
+        }
+        throw new Error('Session middleware non configuré');
+    }
+    try {
+        // Sérialiser en JSON
+        const jsonData = JSON.stringify(stateGraph.toJSON());
+        // Compresser avec gzip
+        const compressed = (0, zlib_1.gzipSync)(Buffer.from(jsonData, 'utf8'));
+        // Stocker en base64 dans la session
+        session[SESSION_STATEGRAPH_KEY] = compressed.toString('base64');
+        // Logging pour debug (taille avant/après compression)
+        if (process.env.NODE_ENV === 'development') {
+            const originalSize = Buffer.byteLength(jsonData, 'utf8');
+            const compressedSize = compressed.length;
+            const ratio = Math.round((1 - compressedSize / originalSize) * 100);
+            console.log(`🗜️ StateGraph sauvegardé: ${originalSize}B → ${compressedSize}B (${ratio}% compression)`);
+        }
+    }
+    catch (error) {
+        console.error('Erreur lors de la sauvegarde du StateGraph:', error);
+        throw error;
+    }
+}
+/**
+ * Supprime le StateGraph de la session
+ * @param context AgenticContext qui contient la session
+ */
+function sessionStateGraphClear(context) {
+    const session = context.session;
+    if (session && session[SESSION_STATEGRAPH_KEY]) {
+        delete session[SESSION_STATEGRAPH_KEY];
+    }
+}
+/**
+ * Vérifie si un StateGraph existe dans la session
+ * @param context AgenticContext qui contient la session
+ * @returns true si un StateGraph existe
+ */
+function sessionStateGraphExists(context) {
+    const session = context.session;
+    return session && !!session[SESSION_STATEGRAPH_KEY];
+}
+/**
+ * Obtient la taille du StateGraph en session (en bytes)
+ * @param context AgenticContext qui contient la session
+ * @returns Taille en bytes ou 0 si pas de StateGraph
+ */
+function sessionStateGraphSize(context) {
+    const session = context.session;
+    if (!session || !session[SESSION_STATEGRAPH_KEY]) {
+        return 0;
+    }
+    try {
+        const compressedData = session[SESSION_STATEGRAPH_KEY];
+        return Buffer.from(compressedData, 'base64').length;
+    }
+    catch (error) {
+        console.error('Erreur lors du calcul de la taille StateGraph:', error);
+        return 0;
+    }
+}
+/**
+ * Convertit req.session.memory vers AgentStateGraph
+ * @param context AgenticContext qui contient la session
+ * @returns true si migration effectuée
+ */
+function migrateFromLegacySession(context) {
+    const session = context.session;
+    if (!session || !session.memory || sessionStateGraphExists(context)) {
+        return false;
+    }
+    try {
+        const legacyMemory = session.memory;
+        const stateGraph = new stategraph_1.AgentStateGraph();
+        // Créer une discussion depuis l'ancienne mémoire
+        if (legacyMemory.messages && Array.isArray(legacyMemory.messages)) {
+            const agentName = legacyMemory.currentAgent || 'default';
+            const discussion = stateGraph.createOrRestore(agentName);
+            // Migrer les messages
+            legacyMemory.messages.forEach((msg, index) => {
+                stateGraph.push(agentName, {
+                    role: msg.role || 'user',
+                    content: msg.content || '',
+                    agent: msg.agent || agentName
+                });
+            });
+            // Migrer l'usage
+            if (legacyMemory.usage) {
+                stateGraph.updateTokens(agentName, legacyMemory.usage);
+            }
+        }
+        // Sauvegarder le nouveau format
+        sessionStateGraphSet(context, stateGraph);
+        // Supprimer l'ancienne mémoire
+        delete session.memory;
+        console.log('✅ Migration réussie de session.memory vers AgentStateGraph');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Erreur lors de la migration:', error);
+        return false;
+    }
+}

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

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview Types pour le système AgentStateGraph
+ * Remplace l'ancien système AgenticMemoryManager pour une gestion simplifiée des discussions par agent
+ */
+/**
+ * Message d'agent dans une discussion
+ * Compatible avec le format OpenAI Chat Completions
+ */
+export interface AgentMessage {
+    /** Identifiant unique du message */
+    id: string;
+    /** Rôle du message (system, user, assistant, tool) */
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    /** Contenu textuel du message */
+    content: string;
+    /** Nom de l'agent ou de l'outil (compatible OpenAI) */
+    name?: string;
+    /** Agent associé à ce message (optionnel) */
+    agent?: string;
+    /** Timestamp de création */
+    timestamp: Date;
+}
+/**
+ * Usage des tokens et coût
+ */
+export interface TokenUsage {
+    /** Tokens de prompt */
+    prompt: number;
+    /** Tokens de complétion */
+    completion: number;
+    /** Total des tokens */
+    total: number;
+    /** Coût estimé en USD (optionnel) */
+    cost?: number;
+}
+/**
+ * Discussion d'agent - thread de messages pour un agent spécifique
+ * Remplace l'ancienne AgenticMemorySession
+ */
+export interface AgentDiscussion {
+    /** Identifiant unique de la discussion */
+    id: string;
+    /** Nom descriptif (optionnel) */
+    name?: string;
+    /** Description de la discussion (optionnel) */
+    description?: string;
+    /** Messages de la discussion */
+    messages: AgentMessage[];
+    /** Usage des tokens pour cette discussion */
+    usage: TokenUsage;
+    /** Date de création */
+    createdAt: Date;
+    /** Date de dernière mise à jour */
+    updatedAt: Date;
+    /** Agent qui a initié cette discussion (requis) */
+    startAgent: string;
+}
+/**
+ * Interface principale du StateGraph pour gérer les discussions par agent
+ * Remplace AgenticMemoryManager avec une API simplifiée
+ */
+export interface AgentStateGraph {
+    /** Liste des discussions par agent */
+    discussions: AgentDiscussion[];
+    /**
+     * Crée ou restaure une discussion pour un agent
+     * @param agentName Nom de l'agent
+     * @returns Discussion existante ou nouvelle
+     */
+    createOrRestore(agentName: string): AgentDiscussion;
+    /**
+     * Ajoute un message à la discussion d'un agent
+     * @param agentName Nom de l'agent
+     * @param message Message sans ID ni timestamp (auto-générés)
+     */
+    push(agentName: string, message: Omit<AgentMessage, 'id' | 'timestamp'>): void;
+    /**
+     * Écrase le message system de la discussion avec un nouvel agent
+     * @param agentName Nom de l'agent
+     * @param content Nouveau contenu du message system
+     */
+    set(agentName: string, content: string): void;
+    /**
+     * Additionne l'usage des tokens pour un agent
+     * @param agentName Nom de l'agent
+     * @param usage Ajout aux valeurs existantes (addition)
+     */
+    updateTokens(agentName: string, usage: Partial<TokenUsage>): void;
+    /**
+     * Retourne une vue filtrée pour le client (sans system messages, sans metadata tools)
+     * @param agentName Nom de l'agent
+     * @returns Discussion filtrée pour l'affichage client
+     */
+    toClientView(agentName: string): ClientDiscussion;
+    /**
+     * Vide une discussion en gardant uniquement le message system
+     * @param agentName Nom de l'agent
+     */
+    clearDiscussion(agentName: string): void;
+    /**
+     * Supprime un message spécifique d'une discussion
+     * @param agentName Nom de l'agent
+     * @param messageId ID du message à supprimer
+     * @returns true si le message a été supprimé, false s'il n'a pas été trouvé
+     */
+    deleteMessage(agentName: string, messageId: string): boolean;
+}
+/**
+ * Vue client d'une discussion (filtrée)
+ */
+export interface ClientDiscussion {
+    /** Identifiant de la discussion */
+    id: string;
+    /** Nom de la discussion */
+    name?: string;
+    /** Description */
+    description?: string;
+    /** Agent associé à cette discussion */
+    agent?: string;
+    /** Messages filtrés (sans system, sans metadata) */
+    messages: Array<{
+        id: string;
+        role: 'user' | 'assistant';
+        content: string;
+        timestamp: Date;
+    }>;
+    /** Usage des tokens */
+    usage: TokenUsage;
+    /** Dates */
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Retourne l'agent spécialisé d'une discussion
+ * Récupère l'agent depuis messages[0].agent ou utilise startAgent comme fallback
+ * @param discussion Discussion à analyser
+ * @returns Nom de l'agent spécialisé
+ */
+export declare function getSpecializedAgent(discussion: AgentDiscussion): string;

package/dist/src/stategraph/types.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @fileoverview Types pour le système AgentStateGraph
+ * Remplace l'ancien système AgenticMemoryManager pour une gestion simplifiée des discussions par agent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpecializedAgent = getSpecializedAgent;
+/**
+ * Retourne l'agent spécialisé d'une discussion
+ * Récupère l'agent depuis messages[0].agent ou utilise startAgent comme fallback
+ * @param discussion Discussion à analyser
+ * @returns Nom de l'agent spécialisé
+ */
+function getSpecializedAgent(discussion) {
+    if (discussion && discussion.messages.length > 0 && discussion.messages[0].agent) {
+        return discussion.messages[0].agent;
+    }
+    return discussion.startAgent;
+}