@imenam/unified-llm-client 1.2.0

package/dist/examples/qwen-vl-example.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qwenVLImageAnalysisExample = qwenVLImageAnalysisExample;
+exports.qwenVLBoundingBoxesExample = qwenVLBoundingBoxesExample;
+exports.qwenVLPdfAnalysisExample = qwenVLPdfAnalysisExample;
+exports.qwenVLStreamingExample = qwenVLStreamingExample;
+exports.runAllQwenVLExamples = runAllQwenVLExamples;
+exports.parseQwenJsonResponse = parseQwenJsonResponse;
+const UnifiedLLMClient_1 = require("../core/UnifiedLLMClient");
+const fs = __importStar(require("fs"));
+const sharp_1 = __importDefault(require("sharp"));
+const Models_1 = require("../core/Models");
+/**
+ * Redimensionne une image pour que le plus long côté fasse au maximum maxSize pixels
+ * @param imagePath Chemin vers l'image source
+ * @param maxSize Taille maximale du plus long côté (défaut: 1000)
+ * @returns Buffer de l'image redimensionnée
+ */
+function resizeImageForVision(imagePath_1) {
+    return __awaiter(this, arguments, void 0, function* (imagePath, maxSize = 1000) {
+        try {
+            // Obtenir les dimensions originales
+            const metadata = yield (0, sharp_1.default)(imagePath).metadata();
+            const { width = 0, height = 0 } = metadata;
+            console.log(`📏 Image originale: ${width}x${height}`);
+            // Calculer les nouvelles dimensions
+            let newWidth;
+            let newHeight;
+            if (width > height) {
+                // Image paysage
+                newWidth = maxSize;
+                newHeight = Math.round((height * maxSize) / width);
+            }
+            else {
+                // Image portrait ou carrée
+                newHeight = maxSize;
+                newWidth = Math.round((width * maxSize) / height);
+            }
+            console.log(`🔄 Redimensionnement vers: ${newWidth}x${newHeight}`);
+            // Redimensionner l'image
+            const resizedBuffer = yield (0, sharp_1.default)(imagePath)
+                .resize(newWidth, newHeight, {
+                fit: 'inside',
+                withoutEnlargement: true // Ne pas agrandir si l'image est plus petite
+            })
+                .jpeg({ quality: 90 }) // Convertir en JPEG avec bonne qualité
+                .toBuffer();
+            console.log(`✅ Image redimensionnée: ${resizedBuffer.length} bytes`);
+            return resizedBuffer;
+        }
+        catch (error) {
+            console.warn(`⚠️ Impossible de redimensionner ${imagePath}, utilisation de l'original:`, error);
+            // En cas d'erreur, retourner l'image originale
+            return fs.readFileSync(imagePath);
+        }
+    });
+}
+/**
+ * Exemple 1: Analyse d'une image simple avec Qwen VL
+ */
+function qwenVLImageAnalysisExample() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log("🔍 Exemple 1: Analyse d'une image avec Qwen VL...");
+            // Initialiser le client Qwen
+            const client = new UnifiedLLMClient_1.UnifiedLLMClient(Models_1.MODELS.QWEN_VL_3);
+            // Redimensionner l'image avant l'envoi
+            const resizedImageBuffer = yield resizeImageForVision("./media/image.png", 1000);
+            const base64Image = resizedImageBuffer.toString('base64');
+            const response = yield client.chat({
+                message: {
+                    role: "user",
+                    content: [
+                        { type: "text", text: "Décris cette image en détail. Qu'est-ce que tu vois ?" },
+                        {
+                            type: "image_url",
+                            image_url: {
+                                url: `data:image/jpeg;base64,${base64Image}`
+                            }
+                        }
+                    ]
+                }
+            });
+            console.log("📝 Réponse de Qwen VL:");
+            console.log(response.content);
+        }
+        catch (error) {
+            console.error("❌ Erreur lors de l'analyse d'image:", error);
+            console.log("\n🔧 Assurez-vous que ALIBABA_CLOUD_API_KEY est défini dans votre fichier .env");
+        }
+    });
+}
+/**
+ * Exemple 2: Extraction de texte structuré (bounding boxes) avec Qwen VL
+ */
+function qwenVLBoundingBoxesExample() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log("📦 Exemple 2: Extraction de bounding boxes...");
+            // Initialiser le client Qwen
+            const client = new UnifiedLLMClient_1.UnifiedLLMClient(Models_1.MODELS.QWEN_VL_3);
+            const expectedJsonFormat = `{
+      "data": [
+        {
+          "bbox_2d": [x1, y1, x2, y2],
+          "text_content": "contenu du texte"
+        }
+      ]
+    }`;
+            // Redimensionner l'image pour l'extraction de bounding boxes
+            const resizedImageBuffer = yield resizeImageForVision("./media/Gaspard_5_with_lines.png", 1000);
+            const base64Image = resizedImageBuffer.toString('base64');
+            const response = yield client.chat({
+                message: {
+                    role: "user",
+                    content: [
+                        { type: "text", text: `Identifie tous les éléments de texte sur cette image et retourne les coordonnées des bounding boxes au format JSON: ${expectedJsonFormat}. Inclus le texte contenu dans chaque boîte.` },
+                        {
+                            type: "image_url",
+                            image_url: {
+                                url: `data:image/jpeg;base64,${base64Image}`
+                            }
+                        }
+                    ]
+                }
+            });
+            console.log("📝 Données extraites:");
+            console.log(response.content);
+            // Sauvegarder la réponse
+            if (response.content) {
+                fs.writeFileSync("qwen_response.json", JSON.stringify({
+                    response: response.content,
+                    timestamp: new Date().toISOString()
+                }, null, 2));
+                console.log("✅ Réponse sauvegardée dans qwen_response.json");
+            }
+        }
+        catch (error) {
+            console.error("❌ Erreur lors de l'extraction de bounding boxes:", error);
+            console.log("\n🔧 Assurez-vous que ALIBABA_CLOUD_API_KEY est défini dans votre fichier .env");
+        }
+    });
+}
+/**
+ * Exemple 3: Analyse de document PDF avec Qwen VL
+ */
+function qwenVLPdfAnalysisExample() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log("📄 Exemple 3: Analyse d'un document PDF...");
+            // Initialiser le client Qwen
+            const client = new UnifiedLLMClient_1.UnifiedLLMClient(Models_1.MODELS.QWEN_VL_3);
+            const response = yield client.chat({
+                message: {
+                    role: "user",
+                    content: "Analyse ce document PDF. Quel est son contenu principal ? Y a-t-il des tableaux ou des graphiques ?",
+                    attachedFile: "./media/subject.pdf"
+                }
+            });
+            console.log("📝 Analyse du PDF:");
+            console.log(response.content);
+        }
+        catch (error) {
+            console.error("❌ Erreur lors de l'analyse du PDF:", error);
+            console.log("\n🔧 Assurez-vous que ALIBABA_CLOUD_API_KEY est défini dans votre fichier .env");
+        }
+    });
+}
+/**
+ * Exemple 4: Analyse d'image avec streaming pour voir la génération en temps réel
+ */
+function qwenVLStreamingExample() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            console.log("🌊 Exemple 4: Analyse d'image avec streaming...");
+            // Initialiser le client Qwen
+            const client = new UnifiedLLMClient_1.UnifiedLLMClient(Models_1.MODELS.QWEN_VL_3);
+            // Redimensionner l'image avant l'envoi
+            const resizedImageBuffer = yield resizeImageForVision("./media/image.png", 1000);
+            const base64Image = resizedImageBuffer.toString('base64');
+            // Logging des tailles d'image
+            const originalSizeBytes = resizedImageBuffer.length;
+            const base64SizeChars = base64Image.length;
+            const base64SizeBytes = Math.ceil(base64SizeChars * 6 / 8); // Conversion base64 vers bytes
+            console.log(`📏 Taille de l'image source: ${originalSizeBytes} bytes (${(originalSizeBytes / 1024).toFixed(2)} KB)`);
+            console.log(`📏 Taille après encodage base64: ${base64SizeChars} caractères (${(base64SizeBytes / 1024).toFixed(2)} KB)`);
+            console.log(`📏 Ratio d'encodage: ${(base64SizeBytes / originalSizeBytes).toFixed(2)}x`);
+            console.log("📡 Démarrage du streaming...");
+            let startTime = Date.now();
+            let firstChunkReceived = false;
+            const response = yield client.chat({
+                message: {
+                    role: "user",
+                    content: [
+                        { type: "text", text: "Donne moi le texte de la première ligne de la page." },
+                        {
+                            type: "image_url",
+                            image_url: {
+                                url: `data:image/jpeg;base64,${base64Image}`
+                            }
+                        }
+                    ]
+                },
+                stream: true,
+                onChunk: (chunk) => {
+                    if (!firstChunkReceived) {
+                        firstChunkReceived = true;
+                        let elapsedTime = Date.now() - startTime;
+                        console.log(`Temps écoulé pour recevoir le premier chunk: ${elapsedTime}ms`);
+                    }
+                    if (chunk.contentChunk) {
+                        process.stdout.write(chunk.contentChunk); // Écrire directement sur stdout pour voir le streaming en temps réel
+                    }
+                },
+                onFinalResponse: (finalResponse) => {
+                    console.log("\n\n✅ Streaming terminé!");
+                    console.log("📝 Réponse complète:");
+                    console.log(finalResponse.content);
+                }
+            });
+            console.log("\n📊 Statistiques du streaming:");
+            console.log(`Longueur totale de la réponse: ${((_a = response.content) === null || _a === void 0 ? void 0 : _a.length) || 0} caractères`);
+        }
+        catch (error) {
+            console.error("❌ Erreur lors du streaming:", error);
+            console.log("\n🔧 Assurez-vous que ALIBABA_CLOUD_API_KEY est défini dans votre fichier .env");
+        }
+    });
+}
+/**
+ * Exécute tous les exemples Qwen VL
+ */
+function runAllQwenVLExamples() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("🚀 Démarrage de tous les exemples Qwen VL...\n");
+        yield qwenVLImageAnalysisExample();
+        console.log("\n" + "=".repeat(50) + "\n");
+        yield qwenVLBoundingBoxesExample();
+        console.log("\n" + "=".repeat(50) + "\n");
+        yield qwenVLPdfAnalysisExample();
+        console.log("\n" + "=".repeat(50) + "\n");
+        yield qwenVLStreamingExample();
+        console.log("\n✅ Tous les exemples terminés!");
+    });
+}
+/**
+ * Fonction utilitaire pour parser les réponses JSON de Qwen
+ */
+function parseQwenJsonResponse(responseContent) {
+    if (!responseContent)
+        return null;
+    try {
+        // Nettoyer la réponse (enlever les balises markdown si présentes)
+        let cleanResponse = responseContent.replace(/```json\s*/g, '').replace(/```\s*$/g, '');
+        // Corriger les clés non-quoted si nécessaire
+        cleanResponse = cleanResponse.replace(/(\{|\,)\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\:/g, '$1"$2":');
+        return JSON.parse(cleanResponse);
+    }
+    catch (error) {
+        console.warn("⚠️ Impossible de parser la réponse JSON:", error);
+        return null;
+    }
+}
+// Exécuter tous les exemples si ce fichier est appelé directement
+if (require.main === module) {
+    // runAllQwenVLExamples().catch(console.error);
+    qwenVLStreamingExample().catch(console.error);
+}

package/dist/examples/test-multiturn-tools.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-multiturn-tools.d.ts.map

package/dist/examples/test-multiturn-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-multiturn-tools.d.ts","sourceRoot":"","sources":["../../src/examples/test-multiturn-tools.ts"],"names":[],"mappings":""}

package/dist/examples/test-multiturn-tools.js

@@ -0,0 +1,139 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
+// ─── Changer ici pour tester un autre provider ───────────────────────────────
+// const MODEL = MODELS.CLAUDE_SONNET_4_6;
+const MODEL = __1.MODELS.GEMINI_3_FLASH;
+// const MODEL = MODELS.GPT_4O_MINI;
+// ─────────────────────────────────────────────────────────────────────────────
+const tools = [
+    {
+        name: "get_weather",
+        description: "Retourne la météo actuelle pour une ville donnée.",
+        parameters: {
+            type: "object",
+            properties: {
+                city: { type: "string", description: "Nom de la ville" },
+            },
+            required: ["city"],
+        },
+        executor: (_a) => __awaiter(void 0, [_a], void 0, function* ({ city }) { return `Météo à ${city} : 22°C, ensoleillé.`; }),
+    },
+];
+function pass(label) { console.log(`  ✓ ${label}`); }
+function fail(label, detail) { console.error(`  ✗ ${label}`, detail !== null && detail !== void 0 ? detail : ""); }
+// ─── Test 1 : tool call simple ────────────────────────────────────────────────
+function testSingleTurnToolCall() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        console.log("\n[Test 1] Single-turn tool call");
+        const client = new __1.UnifiedLLMClient(MODEL);
+        const response = yield client.chat({
+            message: "Quel temps fait-il à Lyon ?",
+            tools,
+            toolChoice: "auto",
+        });
+        if (response.toolCalls && response.toolCalls.length > 0) {
+            pass("toolCalls présent dans la réponse");
+            const tc = response.toolCalls[0];
+            if (tc.name === "get_weather")
+                pass(`outil correct : ${tc.name}`);
+            else
+                fail("nom d'outil inattendu", tc.name);
+            if ((_a = tc.arguments) === null || _a === void 0 ? void 0 : _a.city)
+                pass(`argument city présent : ${tc.arguments.city}`);
+            else
+                fail("argument city manquant", tc.arguments);
+        }
+        else {
+            fail("aucun toolCall reçu — le modèle a répondu en texte", response.content);
+        }
+        return response;
+    });
+}
+// ─── Test 2 : conversation multi-tour avec injection de résultat ──────────────
+function testMultiTurnToolCall() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        console.log("\n[Test 2] Multi-turn tool call");
+        const client = new __1.UnifiedLLMClient(MODEL);
+        const history = [
+            { role: "user", content: "Quel temps fait-il à Bordeaux ?" },
+        ];
+        // Tour 1 — le modèle appelle l'outil
+        const r1 = yield client.chat({ message: history, tools, toolChoice: "auto" });
+        if (!r1.toolCalls || r1.toolCalls.length === 0) {
+            fail("Tour 1 : aucun toolCall reçu", r1.content);
+            return;
+        }
+        pass("Tour 1 : toolCall reçu");
+        const tc = r1.toolCalls[0];
+        // Injection du message assistant qui déclare le tool call
+        history.push({
+            role: "assistant",
+            content: r1.content,
+            tool_calls: r1.toolCalls,
+        });
+        // Exécution de l'outil
+        const toolResult = yield tools[0].executor(tc.arguments);
+        // Injection du résultat
+        // Note : pour Gemini, tool_call_id doit être le nom de la fonction (tc.name)
+        history.push({
+            role: "tool",
+            tool_call_id: (_a = tc.id) !== null && _a !== void 0 ? _a : tc.name,
+            content: toolResult,
+        });
+        pass(`Tour 1 : historique injecté (${history.length} messages)`);
+        // Tour 2 — le modèle formule sa réponse finale avec le résultat
+        const r2 = yield client.chat({ message: history, tools });
+        if (r2.content && r2.content.trim().length > 0) {
+            pass("Tour 2 : réponse finale reçue");
+            console.log(`  → "${r2.content.trim().slice(0, 120)}..."`);
+        }
+        else {
+            fail("Tour 2 : réponse vide ou absente", r2);
+        }
+    });
+}
+// ─── Test 3 : toolChoice forcé (structured output) ────────────────────────────
+function testForcedToolChoice() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("\n[Test 3] toolChoice forcé");
+        const client = new __1.UnifiedLLMClient(MODEL);
+        const response = yield client.chat({
+            message: "Donne-moi la météo de Nantes",
+            tools,
+            toolChoice: "get_weather",
+        });
+        if (response.toolCalls && response.toolCalls.length > 0) {
+            pass(`outil forcé appelé : ${response.toolCalls[0].name}`);
+            pass(`arguments : ${JSON.stringify(response.toolCalls[0].arguments)}`);
+        }
+        else {
+            fail("toolCall forcé non reçu", response.content);
+        }
+    });
+}
+// ─── Runner ───────────────────────────────────────────────────────────────────
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    console.log(`\n=== Tests multi-turn tool calls — provider : ${MODEL.provider} (${MODEL.modelName}) ===`);
+    try {
+        yield testSingleTurnToolCall();
+        yield testMultiTurnToolCall();
+        yield testForcedToolChoice();
+        console.log("\n✅ Tous les tests terminés.\n");
+    }
+    catch (err) {
+        console.error("\n❌ Erreur inattendue :", err);
+        process.exit(1);
+    }
+}))();

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { ChatMessage, ToolDefinition, ToolCall, ChatResponse, AudioGenerationOptions, AudioGenerationResponse, VoiceConfig, SpeakerConfig } from "./common/types";
+import { PromptAdapter, PromptAdapterOptions, OutputAdapter, AudioAdapter } from "./core/LLMAdapter";
+import { UnifiedLLMClient } from "./core/UnifiedLLMClient";
+import { MODELS } from "./core/Models";
+export { UnifiedLLMClient, MODELS };
+export type { ChatMessage, ToolDefinition, ToolCall, ChatResponse, PromptAdapter, PromptAdapterOptions, OutputAdapter, AudioAdapter, AudioGenerationOptions, AudioGenerationResponse, VoiceConfig, SpeakerConfig };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAE,YAAY,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAClK,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACrG,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,CAAC;AACpC,YAAY,EACV,WAAW,EACX,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,aAAa,EACb,YAAY,EACZ,sBAAsB,EACtB,uBAAuB,EACvB,WAAW,EACX,aAAa,EACd,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODELS = exports.UnifiedLLMClient = void 0;
+const UnifiedLLMClient_1 = require("./core/UnifiedLLMClient");
+Object.defineProperty(exports, "UnifiedLLMClient", { enumerable: true, get: function () { return UnifiedLLMClient_1.UnifiedLLMClient; } });
+const Models_1 = require("./core/Models");
+Object.defineProperty(exports, "MODELS", { enumerable: true, get: function () { return Models_1.MODELS; } });

package/dist/utils/audioUtils.d.ts

@@ -0,0 +1,41 @@
+export interface AudioParseOptions {
+    numChannels: number;
+    sampleRate: number;
+    bitsPerSample: number;
+}
+/**
+ * Génère un nom de fichier unique pour l'audio
+ */
+export declare function generateUniqueAttachedFilename(prefix?: string, extension?: string): string;
+/**
+ * Valide et normalise un chemin de sortie
+ */
+export declare function validateOutputPath(outputPath: string): string;
+/**
+ * Sauvegarde des données audio dans un fichier
+ */
+export declare function saveAttachedFile(filePath: string, audioData: Buffer): Promise<void>;
+/**
+ * Parse le type MIME pour extraire les options audio
+ * Basé sur l'exemple google-tts-example.js
+ */
+export declare function parseMimeType(mimeType: string): AudioParseOptions;
+/**
+ * Crée un header WAV pour les données audio
+ * Basé sur l'exemple google-tts-example.js
+ */
+export declare function createWavHeader(dataLength: number, options: AudioParseOptions): Buffer;
+/**
+ * Convertit des données audio brutes au format WAV
+ * Basé sur l'exemple google-tts-example.js
+ */
+export declare function convertToWav(rawData: string, mimeType: string): Buffer;
+/**
+ * Nettoie les fichiers temporaires
+ */
+export declare function cleanupTempFiles(filePaths: string[]): void;
+/**
+ * Détecte l'extension de fichier appropriée basée sur le type MIME
+ */
+export declare function getAttachedFileExtension(mimeType: string): string;
+//# sourceMappingURL=audioUtils.d.ts.map

package/dist/utils/audioUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audioUtils.d.ts","sourceRoot":"","sources":["../../src/utils/audioUtils.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,GAAE,MAAgB,EAAE,SAAS,GAAE,MAAc,GAAG,MAAM,CAI1G;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAU7D;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUzF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAyBjE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAqBtF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKtE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAU1D;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAejE"}