agentic-api 2.0.491 → 2.0.592

package/dist/src/rules/git/repo.js

@@ -59,6 +59,8 @@ const errors_1 = require("../errors");
 const path_1 = require("path");
 const fs = __importStar(require("fs/promises"));
 const repo_tools_1 = require("./repo.tools");
+const repo_pr_1 = require("./repo.pr");
+const utils_matter_1 = require("../utils.matter");
 /**
  * Service singleton pour gérer le registre d'IDs en mémoire
  */
@@ -561,7 +563,7 @@ function gitEnsureMatterID(matter, config, branch, file) {
             // (Si même fichier, registerExistingID ne lève pas d'erreur)
         }
     }
-    // Générer un nouvel ID
+    // Générer un nouvel ID (si aucun ID fourni ou ID invalide)
     matter.id = gitGenerateNextID(config);
     // FIXME: Double save ici - gitGenerateNextID() fait save() puis gitRegisterExistingID() fait save() aussi
     // Refactorisation future: Retirer save() de gitGenerateNextID() et le faire uniquement dans gitRegisterExistingID()
@@ -999,13 +1001,20 @@ async function gitCheckConfiguration(git) {
     return check;
 }
 /**
- * Crée un fichier dans la branche draft (opération bas niveau)
- * @param git Instance Git
+ * Crée ou modifie un fichier dans une branche Git et fait un commit automatique
+ *
+ * @param git Instance SimpleGit
  * @param filePath Chemin du fichier
  * @param PR Nom de la branche de Pull Request
  * @param content Contenu du fichier
- * @param user Utilisateur qui effectue l'opération
- * @param config Configuration Git (optionnel, utilise la config globale)
+ * @param user Utilisateur qui fait le commit
+ * @param config Configuration Git optionnelle
+ * @returns Historique du commit créé
+ *
+ * @fixme Ajouter un paramètre optionnel `commitMessage?: string` pour permettre de personnaliser
+ *        le message de commit au lieu d'utiliser toujours `commit: ${filePath}` par défaut.
+ *        Cela permettrait aux callers de spécifier des messages plus descriptifs.
+ *
  * @throws GitOperationError si la création échoue
  */
 async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
@@ -1019,8 +1028,7 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
         if (gitConf.withID) {
             try {
                 // Import dynamique pour éviter les dépendances circulaires
-                const { matterParse, matterSerialize } = await Promise.resolve().then(() => __importStar(require('../utils.matter')));
-                const parsed = matterParse(content);
+                const parsed = (0, utils_matter_1.matterParse)(content);
                 if (gitConf.strictID) {
                     // Mode strict : valider que l'ID existe et est correct
                     validateMatter(parsed.matter);
@@ -1040,7 +1048,7 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
                         // Seulement si l'ID est manquant ou invalide
                         parsed.matter = gitEnsureMatterID(parsed.matter, gitConf, PR, filePath);
                         // Re-sérialiser avec l'ID mis à jour
-                        content = matterSerialize(parsed.content, parsed.matter);
+                        content = (0, utils_matter_1.matterSerialize)(parsed.content, parsed.matter);
                     }
                     else {
                         // ✅ L'ID existe déjà : gitRegisterExistingID() appelle maintenant setMatterCache() automatiquement
@@ -1052,7 +1060,7 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
                             if (error.code === 'id_already_used') {
                                 // En mode non-strict, générer un nouvel ID si doublon détecté
                                 parsed.matter = gitEnsureMatterID(parsed.matter, gitConf, PR, filePath);
-                                content = matterSerialize(parsed.content, parsed.matter);
+                                content = (0, utils_matter_1.matterSerialize)(parsed.content, parsed.matter);
                                 // ✅ Ne pas propager l'erreur, continuer avec le nouvel ID généré
                             }
                             else {
@@ -1089,13 +1097,15 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
         //
         // without note the branche is not a valid PR branch
         const oldNote = await (0, repo_tools_1.gitReadNote)(git, PR, gitConf.gitNotes.namespace, 10);
+        if (oldNote && gitConf.verbose) {
+            console.debug('[gitCreateOrEditFile] metadata.files before update:', oldNote.files);
+        }
         const commit = await _writeFileAndCommit(git, filePath, content, user, gitConf, `commit: ${filePath}`);
         // ✅ Mettre à jour le cache du matter après sauvegarde
         // NOTE: Le cache est TOUJOURS mis à jour, indépendamment de withID
         // C'est une opération de cache, pas une validation
         try {
-            const { matterParse } = await Promise.resolve().then(() => __importStar(require('../utils.matter')));
-            const parsed = matterParse(content);
+            const parsed = (0, utils_matter_1.matterParse)(content);
             idRegistryService.init(gitConf.repoPath);
             idRegistryService.setMatterCache(PR, filePath, {
                 id: parsed.matter.id,
@@ -1124,11 +1134,15 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
         }
         // Determine the current head after the commit attempt.
         const newHead = (await git.revparse(['HEAD'])).trim();
-        const newFiles = await (0, repo_tools_1.gitGetDiffFiles)(git, PR, oldNote.mergeBase);
+        let newFiles = await (0, repo_tools_1.gitGetDiffFiles)(git, PR, oldNote.mergeBase);
+        newFiles = await sanitizePRFiles(git, newFiles, PR);
         const updatedNote = {
             ...oldNote,
             files: newFiles,
         };
+        if (gitConf.verbose) {
+            console.debug('[gitCreateOrEditFile] metadata.files after update:', updatedNote.files);
+        }
         // Write the note to the current HEAD of the PR branch.
         // If no commit was made, this overwrites the note on oldHead.
         // If a new commit was made, this writes the note on newHead.
@@ -1331,12 +1345,24 @@ async function gitRenameFile(git, oldFileName, newFileName, branch, user, config
         //
         //FIXME: add a check about the branch (file can be NEW and on branch)
         const fullOldPath = (0, path_1.join)(gitConf.uploadPath, oldFileName);
+        let result;
         if ((0, fs_1.existsSync)(fullOldPath)) {
-            return await gitRenameFile_fs(git, oldFileName, newFileName, branch, user, config);
+            result = await gitRenameFile_fs(git, oldFileName, newFileName, branch, user, config);
         }
         else {
-            return await gitRenameFile_git(git, oldFileName, newFileName, branch, user, config);
+            result = await gitRenameFile_git(git, oldFileName, newFileName, branch, user, config);
+            if (branch !== 'NEW' && branch.startsWith(gitConf.validationPrefix)) {
+                try {
+                    await (0, repo_pr_1.gitPRReplaceFile)(git, branch, { remove: oldFileName, add: newFileName }, gitConf);
+                }
+                catch (metadataError) {
+                    if (gitConf.verbose) {
+                        console.warn('⚠️ Failed to update PR metadata after rename:', metadataError);
+                    }
+                }
+            }
         }
+        return result;
     }
     catch (error) {
         // Pour les vraies branches Git, ne pas faire de fallback filesystem
@@ -1663,9 +1689,7 @@ function createUnhealthyStatus(branch, exists, accessible, clean, mergeInProgres
  * Vérifie si un merge est en cours en regardant les fichiers Git
  */
 async function checkMergeInProgress(repoPath) {
-    const { existsSync } = await Promise.resolve().then(() => __importStar(require('fs')));
-    const { join } = await Promise.resolve().then(() => __importStar(require('path')));
-    const gitDir = join(repoPath, '.git');
+    const gitDir = (0, path_1.join)(repoPath, '.git');
     const mergeFiles = [
         'MERGE_HEAD',
         'MERGE_MODE',
@@ -1673,5 +1697,27 @@ async function checkMergeInProgress(repoPath) {
         'CHERRY_PICK_HEAD',
         'REVERT_HEAD'
     ];
-    return mergeFiles.some(file => existsSync(join(gitDir, file)));
+    return mergeFiles.some(file => (0, fs_1.existsSync)((0, path_1.join)(gitDir, file)));
+}
+async function sanitizePRFiles(git, files, branch) {
+    if (!files || files.length === 0) {
+        return [];
+    }
+    const checks = await Promise.all(files.map(async (file) => ({
+        file,
+        exists: await (0, repo_tools_1.gitFileExistsInBranch)(git, file, branch)
+    })));
+    const sanitized = [];
+    const seen = new Set();
+    for (const { file, exists } of checks) {
+        if (!exists) {
+            continue;
+        }
+        if (seen.has(file)) {
+            continue;
+        }
+        seen.add(file);
+        sanitized.push(file);
+    }
+    return sanitized;
 }

package/dist/src/rules/git/repo.pr.d.ts

@@ -79,6 +79,14 @@ export declare function gitGetAllPR(git: SimpleGit, options?: {
  */
 export declare function gitGetClosedPRs(git: SimpleGit, gitConfig: RulesGitConfig): Promise<PRInfo[]>;
 export declare function gitLoadPR(git: SimpleGit, branch: string): Promise<PRInfo>;
+/**
+ * Remplace explicitement un nom de fichier dans les métadonnées d'une PR.
+ * Utilisé pour refléter immédiatement les renames sans dépendre de git diff.
+ */
+export declare function gitPRReplaceFile(git: SimpleGit, branch: string, options?: {
+    remove?: string;
+    add?: string;
+}, config?: RulesGitConfig): Promise<void>;
 export declare function gitPRUpdateComments(git: SimpleGit, branch: string, details: RulePullRequestDetails, config?: RulesGitConfig): Promise<PRInfo>;
 /**
  * DEPRECATED: use gitClosePRRobust instead

package/dist/src/rules/git/repo.pr.js

@@ -40,6 +40,7 @@ exports.gitGetPRMetadata = gitGetPRMetadata;
 exports.gitGetAllPR = gitGetAllPR;
 exports.gitGetClosedPRs = gitGetClosedPRs;
 exports.gitLoadPR = gitLoadPR;
+exports.gitPRReplaceFile = gitPRReplaceFile;
 exports.gitPRUpdateComments = gitPRUpdateComments;
 exports.gitClosePR = gitClosePR;
 exports.gitClosePRRobust = gitClosePRRobust;
@@ -321,7 +322,7 @@ async function gitLoadPR(git, branch) {
         if (!metadata) {
             throw new errors_1.GitOperationError(`PR not found for branch ${branch}`, 'pr_load', { branch });
         }
-        const files = await (0, repo_tools_1.gitGetDiffFiles)(git, branch, metadata?.mergeBase, '.md');
+        const files = metadata.files || (await (0, repo_tools_1.gitGetDiffFiles)(git, branch, metadata?.mergeBase, '.md'));
         // Récupérer les infos du dernier commit de la branche
         const log = await git.log({ from: branch, to: branch, maxCount: 1 });
         const lastCommit = log.latest;
@@ -341,6 +342,49 @@ async function gitLoadPR(git, branch) {
         throw new errors_1.GitOperationError(`Failed to retrieve PR: ${error}`, 'pr_load');
     }
 }
+/**
+ * Remplace explicitement un nom de fichier dans les métadonnées d'une PR.
+ * Utilisé pour refléter immédiatement les renames sans dépendre de git diff.
+ */
+async function gitPRReplaceFile(git, branch, options = {}, config) {
+    const { remove, add } = options;
+    if (!remove && !add) {
+        return;
+    }
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    const metadata = await gitGetPRMetadata(git, branch, config);
+    if (!metadata) {
+        return;
+    }
+    const currentFiles = Array.isArray(metadata.files) ? metadata.files : [];
+    const seen = new Set();
+    const nextFiles = [];
+    for (const file of currentFiles) {
+        if (!file) {
+            continue;
+        }
+        if (remove && file === remove) {
+            continue;
+        }
+        if (seen.has(file)) {
+            continue;
+        }
+        seen.add(file);
+        nextFiles.push(file);
+    }
+    if (add && !seen.has(add)) {
+        nextFiles.push(add);
+        seen.add(add);
+    }
+    const changed = currentFiles.length !== nextFiles.length ||
+        currentFiles.some((file, idx) => file !== nextFiles[idx]);
+    if (!changed) {
+        return;
+    }
+    metadata.files = nextFiles;
+    const headCommitHash = (await git.revparse([branch])).trim();
+    await (0, repo_tools_1.gitWriteNote)(git, headCommitHash, metadata, gitConf.gitNotes.namespace);
+}
 async function gitPRUpdateComments(git, branch, details, config) {
     const gitConf = (0, repo_tools_1.gitLoad)(config);
     const metadata = await gitGetPRMetadata(git, branch, config);

package/dist/src/rules/git/repo.tools.d.ts

@@ -56,7 +56,11 @@ export declare function gitReadFileOutsideRepo(git: SimpleGit, filePath: string)
     content: string;
     date: Date;
 }>;
-export declare function gitGetFileHistory(git: SimpleGit, filename: string, hash?: string): Promise<GitCommitHistory[]>;
+export declare function gitGetFileHistory(git: SimpleGit, filename: string, options?: {
+    hash?: string;
+    branch?: string;
+    maxCommits?: number;
+}): Promise<GitCommitHistory[]>;
 /**
  * Récupère le dernier commit d'une branche (opération bas niveau atomique)
  * @param git Instance SimpleGit

package/dist/src/rules/git/repo.tools.js

@@ -338,10 +338,23 @@ async function gitReadFileOutsideRepo(git, filePath) {
         throw error;
     }
 }
-async function gitGetFileHistory(git, filename, hash) {
+async function gitGetFileHistory(git, filename, options) {
+    // - Normalisation des paramètres pour compatibilité
     try {
-        const log = await git.log({ file: filename });
-        const all = log.all.map(commit => ({
+        // - Utiliser git.log() pour obtenir l'historique des commits
+        // - git.log() retourne déjà les commits du plus récent au plus ancien (ordre standard Git)
+        const branch = options?.branch || 'HEAD';
+        const logArgs = [];
+        if (branch !== 'HEAD') {
+            logArgs.push(branch);
+        }
+        logArgs.push('--', filename);
+        const log = await git.log(logArgs);
+        if (log.all.length === 0) {
+            return [];
+        }
+        // - Construire l'historique (déjà dans l'ordre du plus récent au plus ancien)
+        let all = log.all.map(commit => ({
             hash: commit.hash,
             date: new Date(commit.date),
             message: commit.message,
@@ -350,10 +363,44 @@ async function gitGetFileHistory(git, filename, hash) {
                 email: commit.author_email
             }
         }));
-        // Si un hash est fourni, retourner le contenu du fichier à ce hash
-        if (hash) {
-            const fileContent = await gitGetFileContent(git, filename, hash);
-            const index = all.findIndex(commit => commit.hash === hash);
+        // - Si un hash est fourni, s'assurer qu'il est inclus avant l'échantillonnage
+        let requestedHashIndex = -1;
+        if (options?.hash) {
+            requestedHashIndex = all.findIndex(commit => commit.hash === options.hash);
+        }
+        // - Limitation du nombre de commits avec échantillonnage uniforme
+        // - Garantit que le premier (plus récent) et dernier (plus ancien) commit sont inclus
+        // - Si un hash spécifique est demandé, il est aussi garanti d'être inclus
+        if (options?.maxCommits && all.length > options.maxCommits) {
+            const step = Math.ceil((all.length - 2) / (options.maxCommits - 2)) || 1;
+            const sampled = [all[0]]; // Premier commit (plus récent)
+            const includedIndices = new Set([0]); // Track des indices déjà inclus
+            // - Si un hash spécifique est demandé et n'est pas le premier, l'ajouter
+            if (requestedHashIndex > 0 && requestedHashIndex < all.length - 1) {
+                sampled.push(all[requestedHashIndex]);
+                includedIndices.add(requestedHashIndex);
+            }
+            // - Échantillonnage des commits intermédiaires
+            for (let i = 1; i < all.length - 1; i += step) {
+                if (!includedIndices.has(i)) {
+                    sampled.push(all[i]);
+                    includedIndices.add(i);
+                }
+                if (sampled.length >= options.maxCommits - 1)
+                    break;
+            }
+            // - Dernier commit (plus ancien) si on a encore de la place
+            if (sampled.length < options.maxCommits && all.length > 1 && !includedIndices.has(all.length - 1)) {
+                sampled.push(all[all.length - 1]);
+            }
+            // - Trier par date décroissante pour maintenir l'ordre (plus récent en premier)
+            sampled.sort((a, b) => b.date.getTime() - a.date.getTime());
+            all = sampled;
+        }
+        // - Si un hash est fourni, retourner le contenu du fichier à ce hash
+        if (options?.hash) {
+            const fileContent = await gitGetFileContent(git, filename, options.hash);
+            const index = all.findIndex(commit => commit.hash === options.hash);
             if (index !== -1 && fileContent) {
                 all[index] = fileContent;
             }

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

@@ -334,6 +334,20 @@ export interface GitCommitHistory {
     /** Branche où s'est produit ce commit (optionnel) */
     branch?: string;
 }
+/**
+ * Structure simplifiée d'un commit pour la prévisualisation
+ *
+ * Utilisée dans loadPreview() pour retourner uniquement les informations essentielles
+ * sans le contenu complet du commit.
+ */
+export interface CommitPreview {
+    /** Hash unique du commit */
+    hash: string;
+    /** Date et heure du commit */
+    date: Date;
+    /** Nom de l'auteur du commit */
+    author: string;
+}
 /**
  * Résumé d'un fichier Git avec son commit associé
  *

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

@@ -40,23 +40,3 @@ export declare function matterParse(markdown: string): {
 */
 export declare function matterSerializeFromRule(rule: Rule): string;
 export declare function matterSerialize(content: string, matter: FrontMatter | any): string;
-/**
- * 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
- */
-export declare function matterParse_OTHER(markdown: string): {
-    matter: Record<string, any>;
-    content: string;
-    data: Record<string, any>;
-};

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

@@ -3,7 +3,6 @@ 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
  *
@@ -152,85 +151,54 @@ function matterSerialize(content, matter) {
             return acc + `${key}: '${value.toISOString()}'\n`;
         }
         else {
-            // Pour les strings, mettre des guillemets
-            return acc + `${key}: '${value}'\n`;
+            const formatted = formatYAMLString(value.toString());
+            return acc + `${key}: ${formatted}\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
+function formatYAMLString(value) {
+    const shouldQuote = needsQuotes(value);
+    if (!shouldQuote) {
+        return value;
     }
-    // 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, '');
-                }
-            }
-        }
+    if (process.env.DEBUG_YAML === '1') {
+        console.warn('[matterSerialize] quoting value:', value);
     }
-    // 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 };
+    const escaped = value.replace(/'/g, "''");
+    return `'${escaped}'`;
+}
+function needsQuotes(value) {
+    if (value.length === 0) {
+        return true;
+    }
+    const firstChar = value[0];
+    const lastChar = value[value.length - 1];
+    if (firstChar === ' ' || lastChar === ' ') {
+        return true;
+    }
+    if (/[:#{}\[\],&*?]/.test(value)) {
+        return true;
+    }
+    if (/^-/.test(value)) {
+        return true;
+    }
+    if (/^\d/.test(value)) {
+        return true;
+    }
+    if (value.includes('\n')) {
+        return true;
+    }
+    if (value.includes('- ')) {
+        return true;
+    }
+    if (value.includes('"')) {
+        return true;
+    }
+    if (value.includes("'")) {
+        return true;
+    }
+    return false;
 }

package/dist/src/scrapper.js

@@ -13,7 +13,7 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const jsdom_1 = require("jsdom");
 const readability_1 = require("@mozilla/readability");
-const pricing_llm_1 = require("./pricing.llm");
+const pricing_1 = require("./llm/pricing");
 const prompts_1 = require("./prompts");
 const utils_1 = require("./utils");
 const execute_1 = require("./execute");
@@ -37,7 +37,7 @@ async function extractCaptcha(base64Image, openai) {
         messages: [{ role: "user", content }],
         max_completion_tokens: 50,
     });
-    const cost = (0, pricing_llm_1.calculateCost)(model, response.usage);
+    const cost = (0, pricing_1.calculateCost)(model, response.usage);
     // Récupérer la réponse markdown
     const number = response.choices[0].message.content;
     return { number, cost };

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,36 +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');
-    }
-    // 
-    // use multiple fallback if envKey is not set
-    const options = {
-        apiKey: process.env[envKey] || envKey || process.env.API_LLM_KEY || process.env.OPENAI_API_KEY,
-        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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-api",
-  "version": "2.0.491",
+  "version": "2.0.592",
   "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",