@imenam/unified-llm-client 1.2.0

package/dist/utils/audioUtils.js

@@ -0,0 +1,185 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUniqueAttachedFilename = generateUniqueAttachedFilename;
+exports.validateOutputPath = validateOutputPath;
+exports.saveAttachedFile = saveAttachedFile;
+exports.parseMimeType = parseMimeType;
+exports.createWavHeader = createWavHeader;
+exports.convertToWav = convertToWav;
+exports.cleanupTempFiles = cleanupTempFiles;
+exports.getAttachedFileExtension = getAttachedFileExtension;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+/**
+ * Génère un nom de fichier unique pour l'audio
+ */
+function generateUniqueAttachedFilename(prefix = 'audio', extension = 'wav') {
+    const timestamp = Date.now();
+    const randomHash = crypto.randomBytes(4).toString('hex');
+    return `${prefix}-${timestamp}-${randomHash}.${extension}`;
+}
+/**
+ * Valide et normalise un chemin de sortie
+ */
+function validateOutputPath(outputPath) {
+    const resolved = path.resolve(outputPath);
+    const directory = path.dirname(resolved);
+    // Créer le répertoire s'il n'existe pas
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory, { recursive: true });
+    }
+    return resolved;
+}
+/**
+ * Sauvegarde des données audio dans un fichier
+ */
+function saveAttachedFile(filePath, audioData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            fs.writeFile(filePath, audioData, (err) => {
+                if (err) {
+                    reject(new Error(`Erreur lors de l'écriture du fichier ${filePath}: ${err.message}`));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    });
+}
+/**
+ * Parse le type MIME pour extraire les options audio
+ * Basé sur l'exemple google-tts-example.js
+ */
+function parseMimeType(mimeType) {
+    const [fileType, ...params] = mimeType.split(';').map(s => s.trim());
+    const [_, format] = fileType.split('/');
+    const options = {
+        numChannels: 1,
+        sampleRate: 44100,
+        bitsPerSample: 16
+    };
+    if (format && format.startsWith('L')) {
+        const bits = parseInt(format.slice(1), 10);
+        if (!isNaN(bits)) {
+            options.bitsPerSample = bits;
+        }
+    }
+    for (const param of params) {
+        const [key, value] = param.split('=').map(s => s.trim());
+        if (key === 'rate') {
+            options.sampleRate = parseInt(value, 10);
+        }
+    }
+    return options;
+}
+/**
+ * Crée un header WAV pour les données audio
+ * Basé sur l'exemple google-tts-example.js
+ */
+function createWavHeader(dataLength, options) {
+    const { numChannels, sampleRate, bitsPerSample } = options;
+    const byteRate = sampleRate * numChannels * bitsPerSample / 8;
+    const blockAlign = numChannels * bitsPerSample / 8;
+    const buffer = Buffer.alloc(44);
+    buffer.write('RIFF', 0);
+    buffer.writeUInt32LE(36 + dataLength, 4);
+    buffer.write('WAVE', 8);
+    buffer.write('fmt ', 12);
+    buffer.writeUInt32LE(16, 16);
+    buffer.writeUInt16LE(1, 20);
+    buffer.writeUInt16LE(numChannels, 22);
+    buffer.writeUInt32LE(sampleRate, 24);
+    buffer.writeUInt32LE(byteRate, 28);
+    buffer.writeUInt16LE(blockAlign, 32);
+    buffer.writeUInt16LE(bitsPerSample, 34);
+    buffer.write('data', 36);
+    buffer.writeUInt32LE(dataLength, 40);
+    return buffer;
+}
+/**
+ * Convertit des données audio brutes au format WAV
+ * Basé sur l'exemple google-tts-example.js
+ */
+function convertToWav(rawData, mimeType) {
+    const options = parseMimeType(mimeType);
+    const buffer = Buffer.from(rawData, 'base64');
+    const wavHeader = createWavHeader(buffer.length, options);
+    return Buffer.concat([wavHeader, buffer]);
+}
+/**
+ * Nettoie les fichiers temporaires
+ */
+function cleanupTempFiles(filePaths) {
+    filePaths.forEach(filePath => {
+        try {
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+            }
+        }
+        catch (error) {
+            console.warn(`Avertissement: Impossible de supprimer le fichier temporaire ${filePath}: ${error}`);
+        }
+    });
+}
+/**
+ * Détecte l'extension de fichier appropriée basée sur le type MIME
+ */
+function getAttachedFileExtension(mimeType) {
+    const mimeToExt = {
+        'audio/wav': 'wav',
+        'audio/wave': 'wav',
+        'audio/x-wav': 'wav',
+        'audio/mpeg': 'mp3',
+        'audio/mp3': 'mp3',
+        'audio/ogg': 'ogg',
+        'audio/webm': 'webm',
+        'audio/aac': 'aac',
+        'audio/flac': 'flac'
+    };
+    const baseMimeType = mimeType.split(';')[0].trim().toLowerCase();
+    return mimeToExt[baseMimeType] || 'wav';
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@imenam/unified-llm-client",
+  "version": "1.2.0",
+  "description": "A unified interface for multiple LLM providers (OpenAI, Gemini, Anthropic, Qwen) with tool-calling, streaming, and audio support",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "prepublishOnly": "npm run build",
+    "release:patch": "npm version patch && npm publish",
+    "release:minor": "npm version minor && npm publish",
+    "release:major": "npm version major && npm publish",
+    "example": "node dist/examples/example.js",
+    "example:audio": "node dist/examples/audio-example.js",
+    "example:qwen": "node dist/examples/qwen-vl-example.js",
+    "example:anthropic": "node dist/examples/anthropic-example.js"
+  },
+  "keywords": [
+    "llm",
+    "openai",
+    "gemini",
+    "anthropic",
+    "qwen",
+    "ai",
+    "unified",
+    "tool-calling",
+    "streaming",
+    "chatgpt",
+    "gpt",
+    "claude",
+    "mistral"
+  ],
+  "author": "imenam",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/imenam/globalLLMInterface.git"
+  },
+  "devDependencies": {
+    "@types/mime-types": "^2.1.4",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0",
+    "@google/genai": "^1.46.0",
+    "@mistralai/mistralai": "^1.6.1",
+    "@types/node": "^22.15.24",
+    "@types/node-fetch": "^2.6.13",
+    "dotenv": "^16.5.0",
+    "mime-types": "^3.0.1",
+    "node-fetch": "^3.3.2",
+    "openai": "^4.103.0",
+    "sharp": "^0.34.4"
+  }
+}