agentic-api 1.0.5 → 2.0.26

package/dist/src/rules/utils.matter.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matterParse = matterParse;
+exports.matterSerializeFromRule = matterSerializeFromRule;
+exports.matterSerialize = matterSerialize;
+exports.matterParse_OTHER = matterParse_OTHER;
+/**
+ * Parse le front-matter YAML et le contenu Markdown d'un document
+ *
+ * Cette fonction extrait et parse le front-matter YAML délimité par '---'
+ * au début d'un document Markdown. Elle gère automatiquement :
+ * - La conversion des types (nombres, booléens, chaînes)
+ * - Le parsing des arrays JSON dans le YAML
+ * - La normalisation des champs `slugs` et `tags` en arrays
+ * - La suppression des guillemets de délimitation
+ *
+ * @param markdown - Texte Markdown brut avec front-matter optionnel
+ * @returns Objet contenant le front-matter parsé et le contenu
+ *
+ * @example
+ * ```typescript
+ * const doc = `---
+ * title: Ma Procédure
+ * tags: ["urgent", "finance"]
+ * version: 1.2
+ * active: true
+ * ---
+ * # Contenu de la procédure
+ *
+ * Instructions détaillées...`;
+ *
+ * const { matter, content } = matterParse(doc);
+ * // matter: { title: 'Ma Procédure', tags: ['urgent', 'finance'], version: 1.2, active: true }
+ * // content: '# Contenu de la procédure\n\nInstructions détaillées...'
+ * ```
+ */
+function matterParse(markdown) {
+    // 1. Séparer les lignes
+    const lines = markdown.split(/\r?\n/);
+    if (lines[0].trim() !== '---') {
+        return { matter: {}, content: markdown }; // Pas de front-matter
+    }
+    // 2. Trouver la ligne de fermeture '---'
+    let end = 1;
+    while (end < lines.length && lines[end].trim() !== '---')
+        end++;
+    // 3. Parser le bloc front-matter
+    const matter = {};
+    for (let i = 1; i < end; i++) {
+        const line = lines[i];
+        if (!line.trim())
+            continue; // ignorer les lignes vides
+        const [rawKey, ...rawValue] = line.split(':');
+        const key = rawKey.trim();
+        const value = rawValue.join(':').trim();
+        // Détection et parsing des arrays YAML
+        if (value.startsWith('[') && value.endsWith(']')) {
+            try {
+                // Utiliser JSON.parse pour parser l'array
+                const parsed = JSON.parse(value);
+                // Vérifier que c'est bien un array
+                if (Array.isArray(parsed)) {
+                    matter[key] = parsed;
+                }
+                else {
+                    // Si ce n'est pas un array, traiter comme string
+                    matter[key] = value.replace(/^["']|["']$/g, '');
+                }
+            }
+            catch (e) {
+                // Si JSON.parse échoue, garder comme string
+                matter[key] = value.replace(/^["']|["']$/g, '');
+            }
+        }
+        // Tentative de typage léger : nombre, booléen, sinon chaîne
+        else if (/^(true|false)$/i.test(value)) {
+            matter[key] = value.toLowerCase() === 'true';
+        }
+        else if (!isNaN(Number(value)) && value !== '') {
+            matter[key] = Number(value);
+        }
+        else {
+            // Retirer les guillemets éventuels
+            matter[key] = value.replace(/^["']|["']$/g, '');
+        }
+    }
+    // 4. parse slugs and tags as arrays
+    // Ensure slugs is always an array
+    // TODO: this code is not clean enough
+    if (matter.slugs && typeof matter.slugs === 'string') {
+        matter.slugs = matter.slugs.split(',').map((s) => s.trim()).filter((s) => s.length);
+    }
+    // Ensure tags is always an array
+    if (matter.tags && typeof matter.tags === 'string') {
+        const tagsStr = matter.tags;
+        matter.tags = tagsStr.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+    }
+    if (Object.keys(matter).length) {
+    }
+    // 5. Restituer le contenu Markdown sans le front-matter
+    const content = lines.slice(end + 1).join('\n').trimStart();
+    const data = matter;
+    return { data, content, matter };
+}
+/**
+ * Sérialise une Rule en format Markdown avec front-matter
+ * ✅ NOUVELLE FONCTION pour reconstruire le contenu complet
+*/
+function matterSerializeFromRule(rule) {
+    // Créer un objet propre pour le front-matter (exclure oldfile)
+    const matter = { ...rule.matter };
+    delete matter.oldfile;
+    return matterSerialize(rule.content, matter);
+}
+function matterSerialize(content, matter) {
+    // Créer un objet propre pour le front-matter (exclure oldfile)
+    const cleanMatter = { ...matter };
+    //
+    // FIX: Convertir la Date en string pour éviter l'erreur YAML
+    cleanMatter.lastModified = (cleanMatter.lastModified instanceof Date) ? `${new Date().toISOString()}` : `${cleanMatter.lastModified}`;
+    const result = Object.keys(cleanMatter).reduce((acc, key) => {
+        const value = cleanMatter[key];
+        if (Array.isArray(value)) {
+            return acc + `${key}: '${value.join(',')}'\n`;
+        }
+        else {
+            return acc + `${key}: '${value}'\n`;
+        }
+    }, '');
+    return `---
+${result}
+---
+${content}`;
+}
+/**
+ * Extrait le front-matter (entre les deux premiers '---') et le contenu Markdown.
+ * Fonction 100% vanilla : aucun paquet externe requis.
+ * PROS:
+ * Code plus propre et maintenable
+ *  - Typage TypeScript strict
+ *  - Plus robuste (ignore lignes indentées)
+ *  - Séparation des responsabilités
+ *  - Meilleure architecture (parsing pur)
+ * CONS:
+ *  - Perte de fonctionnalité (slugs/tags)
+ *
+ * @param markdown Texte Markdown brut
+ * @returns Objet avec matter, content et data
+ */
+function matterParse_OTHER(markdown) {
+    // 1. Séparer les lignes
+    const lines = markdown.split(/\r?\n/);
+    if (lines[0].trim() !== '---') {
+        return { matter: {}, content: markdown, data: {} }; // Pas de front-matter
+    }
+    // 2. Trouver la ligne de fermeture '---'
+    let end = 1;
+    while (end < lines.length && lines[end].trim() !== '---')
+        end++;
+    // 3. Parser le bloc front-matter (simple clé-valeur)
+    const matter = {};
+    for (let i = 1; i < end; i++) {
+        const line = lines[i];
+        if (!line.trim())
+            continue; // ignorer les lignes vides
+        // Ignorer les lignes indentées (structures complexes non supportées)
+        if (line.startsWith(' ') || line.startsWith('\t')) {
+            continue;
+        }
+        const trimmedLine = line.trim();
+        if (trimmedLine.includes(':')) {
+            const [rawKey, ...rawValue] = trimmedLine.split(':');
+            const key = rawKey.trim();
+            const value = rawValue.join(':').trim();
+            if (value) {
+                // Détection et parsing des arrays YAML
+                if (value.startsWith('[') && value.endsWith(']')) {
+                    try {
+                        const parsed = JSON.parse(value);
+                        if (Array.isArray(parsed)) {
+                            matter[key] = parsed;
+                        }
+                        else {
+                            matter[key] = value.replace(/^["']|["']$/g, '');
+                        }
+                    }
+                    catch (e) {
+                        matter[key] = value.replace(/^["']|["']$/g, '');
+                    }
+                }
+                // Tentative de typage léger : nombre, booléen, sinon chaîne
+                else if (/^(true|false)$/i.test(value)) {
+                    matter[key] = value.toLowerCase() === 'true';
+                }
+                else if (!isNaN(Number(value)) && value !== '') {
+                    matter[key] = Number(value);
+                }
+                else {
+                    matter[key] = value.replace(/^["']|["']$/g, '');
+                }
+            }
+        }
+    }
+    // 4. Restituer le contenu Markdown sans le front-matter
+    const content = lines.slice(end + 1).join('\n').trimStart();
+    const data = matter;
+    return { data, content, matter };
+}

package/dist/src/rules/utils.slug.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Utility functions for handling slugs in the rules system
+ */
+/**
+ * Extracts a slug from a file path
+ * @param filePath The file path to extract the slug from
+ * @returns The slug extracted from the file path
+ */
+export declare const slugFromFile: (filePath: string, ext?: string) => string;
+/**
+ * Converts a slug back to a file path
+ * @param slug The slug to convert to a file path
+ * @param ext The file extension to append (default: '.md')
+ * @returns The file path created from the slug
+ */
+export declare const fileFromSlug: (slug: string, ext?: string) => string;
+/**
+ * Validates if a string is a valid slug
+ * @param slug The slug to validate
+ * @returns True if the slug is valid, false otherwise
+ */
+export declare const isValidSlug: (slug: string) => boolean;

package/dist/src/rules/utils.slug.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Utility functions for handling slugs in the rules system
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidSlug = exports.fileFromSlug = exports.slugFromFile = void 0;
+const utils_1 = require("../utils");
+/**
+ * Extracts a slug from a file path
+ * @param filePath The file path to extract the slug from
+ * @returns The slug extracted from the file path
+ */
+const slugFromFile = (filePath, ext = '.md') => {
+    return (0, utils_1.toSlug)(filePath.replace(ext, ''));
+};
+exports.slugFromFile = slugFromFile;
+/**
+ * Converts a slug back to a file path
+ * @param slug The slug to convert to a file path
+ * @param ext The file extension to append (default: '.md')
+ * @returns The file path created from the slug
+ */
+const fileFromSlug = (slug, ext = '.md') => {
+    return `${slug}${ext}`;
+};
+exports.fileFromSlug = fileFromSlug;
+/**
+ * Validates if a string is a valid slug
+ * @param slug The slug to validate
+ * @returns True if the slug is valid, false otherwise
+ */
+const isValidSlug = (slug) => {
+    return /^[a-z0-9-]+$/.test(slug);
+};
+exports.isValidSlug = isValidSlug;

package/dist/src/scrapper.d.ts

@@ -16,7 +16,7 @@ export declare function callGPTForParsingPDF(inputfile: string, pdfData: any, op
     cost: number;
 }>;
 /**
- * Convertit un document HTML en markdown en appelant le modèle GPT (ex: gpt-4o-mini)
+ * Convertit un document HTML en markdown en appelant le modèle GPT (ex: gpt-4.1)
  * pour analyser et reformater le document.
  *
  * @param {any} htmlData - Le document HTML à transformer en markdown.
@@ -48,7 +48,8 @@ export declare function html2markdown(output: string, file: string, service: str
  * @param {any} openai - L'instance configurée pour appeler l'API OpenAI.
  * @returns {Promise<any>} - Le markdown structuré (issue de GPT) ou tout autre traitement souhaité.
  */
-export declare function pdf2markdown(output: string, file: string, service: string, openai: any): Promise<{
+export declare function pdf2markdown(folder: string, file: string, service: string, openai: any): Promise<{
     markdown: any;
     cost: number;
+    outputPath: string;
 }>;

package/dist/src/scrapper.js

@@ -30,7 +30,7 @@ async function extractCaptcha(base64Image, openai) {
         { type: 'image_url', image_url: { url: `data:image/jpeg;base64,${base64Image}` } },
     ];
     // Cost per captcha $0.0000696
-    const model = "gpt-4o-mini";
+    const model = "gpt-4.1";
     const response = await openai.chat.completions.create({
         model,
         messages: [{ role: "user", content }],
@@ -55,45 +55,42 @@ async function callGPTForParsingPDF(inputfile, pdfData, openai, links = []) {
     const pdfDataAsString = JSON.stringify(pdfData, null, 2);
     // Format: YYYY-MM-DD
     const today = new Date().toISOString().substring(0, 10);
-    const linkLabel = ' une liste de liens que tu dois placer dans le document. Si le libellé d\'un lien correspond à un texte existant dans le document, intègre le lien directement dans le texte. Sinon, place ces liens sous forme de liste à puces dans une section annexe (# Références externes) à la fin du document.';
+    const linkLabel = 'Voici une liste de liens que tu dois intègrer directement dans le texte si, et seulement si, celui-ci correspond précisément à un texte existant dans le document.';
     const linkPrefix = linkLabel + links.reduce((acc, link) => {
         return acc + `- [${link.text}](${link.href})\n`;
     }, '');
     // Créer le prompt pour décrire la tâche au LLM
     const messages = [
         { role: "system",
-            content: prompts_1.textToMarkdownPrompt },
+            content: prompts_1.htmlToMarkdownPrompt },
         { role: "user",
-            content: `Nous sommes le ${today}, voici le nom du document "${inputfile}", et ${linkPrefix}` },
-        { role: "user",
-            content: `Voici le document, pour commencer, tu DOIS extrais uniquement la structure  (titres et sous-titres) selon les instructions et sans les contenus détaillés:\n\n${pdfDataAsString}` }
+            content: `Structure le contenu  exhaustif en Markdown sans rien inventer, et avec les liens intégrés correctement.\n Nous sommes le ${today}.\n${linkPrefix}\nLe contenu du document est:\n${pdfDataAsString}`
+        }
     ];
+    // console.log('🌶️ DEBUG: callGPTForParsingPDF -- SYSTEM:', messages[0].content);
+    // console.log('🌶️ DEBUG: callGPTForParsingPDF -- USER:', messages[1].content);
     // WARNING: o3-mini is buggy with "Marche à suivre nouveau bail.pdf"
-    const model = "o3-mini"; // "gpt-4o-mini";
+    const model = "gpt-4.1"; // "gpt-4.1";
     let response = await openai.chat.completions.create({
         model: model,
         messages,
-        max_completion_tokens: 15192,
-        reasoning_effort: "low",
-        stop: "|<|james|>|"
     });
     // response_format: { type: "json_object" }
     let cost = (0, princing_openai_1.calculateCost)(model, response.usage);
-    console.log(`Markdown 💰 cost: ${cost}`);
-    messages.push({
-        role: "user",
-        content: `Maintenant génère le contenu Markdown détaillé et exhaustif correspondant à chaque section avec les liens intégrés correctement.`
-    });
-    response = await openai.chat.completions.create({
-        model: model,
-        messages,
-        max_completion_tokens: 15192,
-        reasoning_effort: "low",
-        stop: "|<|james|>|"
-    });
+    // messages.push({
+    //     role: "user",
+    //     content: `Maintenant génère le contenu Markdown détaillé et exhaustif correspondant à chaque section avec les liens intégrés correctement.`
+    // });
+    // response = await openai.chat.completions.create({
+    //   model: model,
+    //   messages,
+    //   max_completion_tokens: 15192,
+    //   reasoning_effort:"low",
+    //   stop:"|<|james|>|"
+    // });
     // Récupérer la réponse markdown
     let markdown = response.choices[0].message.content;
-    cost += (0, princing_openai_1.calculateCost)(model, response.usage);
+    console.log(`Markdown 💰 cost: ${cost}`);
     //
     // add a regex to extract the markdown content between <thinking></thinking> tags
     let markdownWithoutThinking = markdown.replace(/<thinking>[\s\S]*?<\/thinking>/g, '');
@@ -160,7 +157,7 @@ async function extractLinksFromPDF(pdfPath, output) {
     }
 }
 /**
- * Convertit un document HTML en markdown en appelant le modèle GPT (ex: gpt-4o-mini)
+ * Convertit un document HTML en markdown en appelant le modèle GPT (ex: gpt-4.1)
  * pour analyser et reformater le document.
  *
  * @param {any} htmlData - Le document HTML à transformer en markdown.
@@ -183,15 +180,14 @@ async function callGPTForParsingHTML(html, openai) {
     ];
     // Appel à l'API ChatCompletion
     const response = await openai.chat.completions.create({
-        model: "gpt-4o-mini",
+        model: "gpt-4.1",
         messages,
         max_completion_tokens: 15192,
         temperature: 0,
         frequency_penalty: 0.0,
         presence_penalty: 0.0,
-        stop: "|<|james|>|"
     });
-    const cost = (0, princing_openai_1.calculateCost)("gpt-4o-mini", response.usage);
+    const cost = (0, princing_openai_1.calculateCost)("gpt-4.1", response.usage);
     console.log(`Markdown 💰 cost: ${cost}`);
     // Récupérer la réponse markdown
     const markdown = response.choices[0].message.content;
@@ -218,12 +214,12 @@ function cleanHTML(html) {
  * @returns {Promise<{markdown: string, cost: number}>} - The generated markdown content and the cost of the GPT API call.
  */
 async function html2markdown(output, file, service, openai) {
-    const filename = (0, utils_1.slug)(path_1.default.basename(file, path_1.default.extname(file)));
+    const filename = (0, utils_1.toSlug)(path_1.default.basename(file, path_1.default.extname(file)));
     const htmlraw = fs_1.default.readFileSync(file, "utf8");
     const html = cleanHTML(htmlraw);
     const outputfile = html.indexOf('Please sign in') > -1 ? 'unauthorized-' : (service.toLocaleLowerCase() + '-');
     const { markdown, cost } = await callGPTForParsingPDF(file, html, openai);
-    fs_1.default.writeFileSync(path_1.default.join(output, `${outputfile + filename}.md`), markdown);
+    fs_1.default.writeFileSync(path_1.default.join(output, `${outputfile + filename}.md`), markdown, { encoding: 'utf8', flag: 'w' });
     return { markdown, cost };
 }
 /**
@@ -236,14 +232,14 @@ async function html2markdown(output, file, service, openai) {
  * @param {any} openai - L'instance configurée pour appeler l'API OpenAI.
  * @returns {Promise<any>} - Le markdown structuré (issue de GPT) ou tout autre traitement souhaité.
  */
-async function pdf2markdown(output, file, service, openai) {
-    const filename = (0, utils_1.slug)(path_1.default.basename(file, path_1.default.extname(file)));
+async function pdf2markdown(folder, file, service, openai) {
+    const filename = (0, utils_1.toSlug)(path_1.default.basename(file, path_1.default.extname(file)));
     // Créez des noms de fichiers temporaires pour le PDF nettoyé et le XML généré.
-    const tempPdf = path_1.default.join(output, `cleaned-${randomFile()}.pdf`);
-    const tempOut = path_1.default.join(output, `${filename}.txt`);
+    const tempPdf = path_1.default.join(folder, `cleaned-${randomFile()}.pdf`);
+    const tempOut = path_1.default.join(folder, `${filename}.txt`);
     //
-    // generated output path
-    const outputPath = path_1.default.join(output, `${service.toLocaleLowerCase()}-${filename}.md`);
+    // generated folder path
+    const outputPath = path_1.default.join(folder, `${(0, utils_1.toSlug)(service.toLocaleLowerCase())}-${filename}.md`);
     try {
         //
         // replace pdftotext with python script PyMuPDF
@@ -251,11 +247,11 @@ async function pdf2markdown(output, file, service, openai) {
         // const { stdout } = await execFileAsync("python3", ["./bin/extract_text_with_links.py", file]);
         // const { text, links } = JSON.parse(stdout);
         await execAsync(`pdftotext -nodiag -nopgbrk "${file}" "${outputPath}"`);
-        const links = await extractLinksFromPDF(file, output);
+        const links = await extractLinksFromPDF(file, folder);
         const text = fs_1.default.readFileSync(outputPath, "utf8");
         const { markdown, cost } = await callGPTForParsingPDF(file, text, openai, links);
         fs_1.default.writeFileSync(outputPath, markdown);
-        return { markdown, cost };
+        return { markdown, cost, outputPath };
         /**
     
         // STEP 1: Clean the PDF using Ghostscript.

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

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Point d'entrée du module AgentStateGraph
+ * Exports principaux pour le système de gestion des discussions par agent
+ */
+export type { AgentMessage, TokenUsage, AgentDiscussion, AgentStateGraph as IAgentStateGraph, ClientDiscussion } from './types';
+export { getSpecializedAgent } from './types';
+export { AgentStateGraph } from './stategraph';
+export { sessionStateGraphGet, sessionStateGraphSet, sessionStateGraphClear, sessionStateGraphExists, sessionStateGraphSize, migrateFromLegacySession } from './stategraph.storage';

package/dist/src/stategraph/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @fileoverview Point d'entrée du module AgentStateGraph
+ * Exports principaux pour le système de gestion des discussions par agent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateFromLegacySession = exports.sessionStateGraphSize = exports.sessionStateGraphExists = exports.sessionStateGraphClear = exports.sessionStateGraphSet = exports.sessionStateGraphGet = exports.AgentStateGraph = exports.getSpecializedAgent = void 0;
+// Fonction utilitaire
+var types_1 = require("./types");
+Object.defineProperty(exports, "getSpecializedAgent", { enumerable: true, get: function () { return types_1.getSpecializedAgent; } });
+// Classe principale
+var stategraph_1 = require("./stategraph");
+Object.defineProperty(exports, "AgentStateGraph", { enumerable: true, get: function () { return stategraph_1.AgentStateGraph; } });
+// Fonctions de stockage
+var stategraph_storage_1 = require("./stategraph.storage");
+Object.defineProperty(exports, "sessionStateGraphGet", { enumerable: true, get: function () { return stategraph_storage_1.sessionStateGraphGet; } });
+Object.defineProperty(exports, "sessionStateGraphSet", { enumerable: true, get: function () { return stategraph_storage_1.sessionStateGraphSet; } });
+Object.defineProperty(exports, "sessionStateGraphClear", { enumerable: true, get: function () { return stategraph_storage_1.sessionStateGraphClear; } });
+Object.defineProperty(exports, "sessionStateGraphExists", { enumerable: true, get: function () { return stategraph_storage_1.sessionStateGraphExists; } });
+Object.defineProperty(exports, "sessionStateGraphSize", { enumerable: true, get: function () { return stategraph_storage_1.sessionStateGraphSize; } });
+Object.defineProperty(exports, "migrateFromLegacySession", { enumerable: true, get: function () { return stategraph_storage_1.migrateFromLegacySession; } });

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

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview Implémentation du système AgentStateGraph
+ * Classe principale pour gérer les discussions par agent
+ */
+import { AgentStateGraph as IAgentStateGraph, AgentDiscussion, AgentMessage, TokenUsage, ClientDiscussion } from './types';
+/**
+ * Implémentation du StateGraph pour la gestion des discussions par agent
+ * Remplace AgenticMemoryManager avec une architecture simplifiée
+ */
+export declare class AgentStateGraph implements IAgentStateGraph {
+    discussions: AgentDiscussion[];
+    /**
+     * 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: string, description?: 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
+     * 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: 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
+     * 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: string): ClientDiscussion;
+    /**
+     * Trouve une discussion par son ID
+     * @param discussionId ID de la discussion
+     * @returns Discussion trouvée ou undefined
+     */
+    findDiscussionById(discussionId: string): AgentDiscussion | undefined;
+    /**
+     * Supprime une discussion
+     * @param discussionId ID de la discussion à supprimer
+     * @returns true si supprimée, false si non trouvée
+     */
+    deleteDiscussion(discussionId: string): boolean;
+    /**
+     * 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;
+    /**
+     * Renomme une discussion
+     * @param discussionId ID de la discussion
+     * @param name Nouveau nom
+     * @param description Nouvelle description (optionnel)
+     */
+    renameDiscussion(discussionId: string, name: string, description?: string): void;
+    /**
+     * Retourne l'agent spécialisé pour une discussion
+     * @param agentName Nom de l'agent
+     * @returns Nom de l'agent spécialisé
+     */
+    getSpecializedAgent(agentName: string): string;
+    /**
+     * Sérialise le StateGraph en JSON
+     * @returns Représentation JSON
+     */
+    toJSON(): any;
+    /**
+     * Restaure le StateGraph depuis JSON
+     * @param data Données JSON
+     */
+    fromJSON(data: any): void;
+}