@builderbot/provider-evolution-api 1.2.7 → 1.2.8-alpha.1

package/dist/index.cjs

@@ -3,19 +3,69 @@
 var bot = require('@builderbot/bot');
 var require$$1 = require('util');
 var stream = require('stream');
-var require$$1$1 = require('path');
+var path$1 = require('path');
 var require$$3 = require('http');
 var require$$4 = require('https');
 var require$$0$1 = require('url');
-var require$$6 = require('fs');
+var fs$1 = require('fs');
 var crypto = require('crypto');
 var require$$4$1 = require('assert');
-var require$$1$2 = require('tty');
+var require$$1$1 = require('tty');
 var require$$0$2 = require('os');
 var zlib = require('zlib');
 var require$$0$3 = require('events');
+var promises = require('fs/promises');
+var node_crypto = require('node:crypto');
 var EventEmitter = require('node:events');
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var json = function (opts={}) {
+	const limit = opts.limit || 100 * 1024; // 100kb
+	const type = opts.type || 'application/json';
+
+	return function (req, res, next) {
+		if (req._body) return next();
+		req.body = req.body || {};
+
+		const head = req.headers;
+		const ctype = head['content-type'];
+		const clength = parseInt(head['content-length'], 10);
+
+		if (isNaN(clength) && head['transfer-encoding'] == null) return next(); // no body
+		if (ctype && !ctype.includes(type)) return next(); // not json
+		if (clength === 0) return next(); // is empty
+
+		let bits = [];
+		let length = 0;
+		req.on('data', x => {
+			length += Buffer.byteLength(x);
+			if (length <= limit) {
+				bits.push(x);
+			} else {
+				next({
+					code: 413,
+					details: 'Exceeded JSON limit'
+				});
+				req.destroy();
+			}
+		}).on('end', () => {
+			try {
+				req.body = JSON.parse(bits);
+				req._body = true;
+				next();
+			} catch (err) {
+				err.code = 422;
+				err.details = err.message;
+				err.message = 'Invalid JSON';
+				next(err);
+			}
+		}).on('error', next);
+	};
+};
+
 function bind$1(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
@@ -861,10 +911,6 @@ AxiosError$1.from = (error, code, config, request, response, customProps) => {
   return axiosError;
 };
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
 var Stream$2 = stream.Stream;
 var util$2 = require$$1;
 
@@ -11915,7 +11961,7 @@ var mimeDb = require$$0;
 	 */
 
 	var db = mimeDb;
-	var extname = require$$1$1.extname;
+	var extname = path$1.extname;
 
 	/**
 	 * Module variables.
@@ -13385,11 +13431,11 @@ var populate$1 = function(dst, src) {
 
 var CombinedStream = combined_stream;
 var util = require$$1;
-var path = require$$1$1;
-var http$1 = require$$3;
-var https$1 = require$$4;
+var path = path$1;
+var http$2 = require$$3;
+var https$2 = require$$4;
 var parseUrl$2 = require$$0$1.parse;
-var fs = require$$6;
+var fs = fs$1;
 var Stream = stream.Stream;
 var mime = mimeTypes;
 var asynckit = asynckit$1;
@@ -13836,9 +13882,9 @@ FormData$1.prototype.submit = function(params, cb) {
 
   // https if specified, fallback to http in any other case
   if (options.protocol == 'https:') {
-    request = https$1.request(options);
+    request = https$2.request(options);
   } else {
-    request = http$1.request(options);
+    request = http$2.request(options);
   }
 
   // get content length and fire away
@@ -14372,12 +14418,12 @@ const hasStandardBrowserWebWorkerEnv = (() => {
 const origin = hasBrowserEnv && window.location.href || 'http://localhost';
 
 var utils = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  hasBrowserEnv: hasBrowserEnv,
-  hasStandardBrowserEnv: hasStandardBrowserEnv,
-  hasStandardBrowserWebWorkerEnv: hasStandardBrowserWebWorkerEnv,
-  navigator: _navigator,
-  origin: origin
+	__proto__: null,
+	hasBrowserEnv: hasBrowserEnv,
+	hasStandardBrowserEnv: hasStandardBrowserEnv,
+	hasStandardBrowserWebWorkerEnv: hasStandardBrowserWebWorkerEnv,
+	navigator: _navigator,
+	origin: origin
 });
 
 var platform = {
@@ -16007,7 +16053,7 @@ function requireSupportsColor () {
 	if (hasRequiredSupportsColor) return supportsColor_1;
 	hasRequiredSupportsColor = 1;
 	const os = require$$0$2;
-	const tty = require$$1$2;
+	const tty = require$$1$1;
 	const hasFlag = requireHasFlag();
 
 	const {env} = process;
@@ -16153,7 +16199,7 @@ function requireNode () {
 	if (hasRequiredNode) return node.exports;
 	hasRequiredNode = 1;
 	(function (module, exports) {
-		const tty = require$$1$2;
+		const tty = require$$1$1;
 		const util = require$$1;
 
 		/**
@@ -16452,8 +16498,8 @@ var debug_1 = function () {
 
 var url = require$$0$1;
 var URL$1 = url.URL;
-var http = require$$3;
-var https = require$$4;
+var http$1 = require$$3;
+var https$1 = require$$4;
 var Writable = stream.Writable;
 var assert = require$$4$1;
 var debug = debug_1;
@@ -17134,7 +17180,7 @@ function isURL(value) {
 }
 
 // Exports
-followRedirects$1.exports = wrap({ http: http, https: https });
+followRedirects$1.exports = wrap({ http: http$1, https: https$1 });
 followRedirects$1.exports.wrap = wrap;
 
 var followRedirectsExports = followRedirects$1.exports;
@@ -19830,302 +19876,258 @@ var _events=_interopRequireDefault(require$$0$3);Object.defineProperty(exports,"
 var distExports = dist.exports;
 var Queue = /*@__PURE__*/getDefaultExportFromCjs(distExports);
 
-async function getMediaUrl(version, IdMedia, numberId, Token) {
-    try {
-        const response = await axios.get(`https://graph.facebook.com/${version}/${IdMedia}?phone_number_id=${numberId}`, {
-            headers: {
-                Authorization: `Bearer ${Token}`,
-            },
-            maxBodyLength: Infinity,
-        });
-        return response.data?.url;
-    }
-    catch (error) {
-        console.error(error.message);
-    }
-}
-
-const processIncomingMessage = async ({ messageId, messageTimestamp, pushName, message, to, jwtToken, version, numberId, fileData, }) => {
-    let responseObj;
-    switch (message.type) {
-        case 'text': {
-            responseObj = {
-                type: message.type,
-                from: message.from,
-                to,
-                body: message.text?.body,
-                name: pushName,
-                pushName,
-            };
-            break;
-        }
-        case 'interactive': {
-            responseObj = {
-                type: 'interactive',
-                from: message.from,
-                to,
-                body: message.interactive?.button_reply?.title ??
-                    message.interactive?.list_reply?.id ??
-                    message.interactive?.nfm_reply.response_json,
-                title_button_reply: message.interactive?.button_reply?.title,
-                title_list_reply: message.interactive?.list_reply?.title,
-                nfm_reply: message.interactive?.nfm_reply?.response_json
-                    ? JSON.parse(message.interactive?.nfm_reply?.response_json)
-                    : undefined,
-                pushName,
-                name: pushName,
-            };
-            break;
-        }
-        case 'button': {
-            responseObj = {
-                type: 'button',
-                from: message.from,
-                to,
-                body: message.button?.text,
-                payload: message.button?.payload,
-                title_button_reply: message.button?.payload,
-                pushName,
-                name: pushName,
-            };
-            break;
-        }
-        case 'image': {
-            const imageUrl = await getMediaUrl(version, message.image?.id, numberId, jwtToken);
-            responseObj = {
-                type: message.type,
-                from: message.from,
-                url: imageUrl,
-                fileData,
-                caption: message?.image?.caption,
-                to,
-                body: bot.utils.generateRefProvider('_event_media_'),
-                pushName,
-                name: pushName,
-            };
-            break;
-        }
-        case 'document': {
-            const documentUrl = await getMediaUrl(version, message.document?.id, numberId, jwtToken);
-            responseObj = {
-                type: message.type,
-                from: message.from,
-                url: documentUrl,
-                fileData,
-                to,
-                body: bot.utils.generateRefProvider('_event_document_'),
-                pushName,
-                name: pushName,
-            };
-            break;
-        }
-        case 'video': {
-            const videoUrl = await getMediaUrl(version, message.video?.id, numberId, jwtToken);
-            responseObj = {
-                type: message.type,
-                from: message.from,
-                url: videoUrl,
-                fileData,
-                caption: message?.video?.caption,
-                to,
-                body: bot.utils.generateRefProvider('_event_media_'),
-                pushName,
-                name: pushName,
-            };
-            break;
-        }
-        case 'location': {
-            responseObj = {
-                type: message.type,
-                from: message.from,
-                to,
-                latitude: message.location.latitude,
-                longitude: message.location.longitude,
-                body: bot.utils.generateRefProvider('_event_location_'),
-                pushName,
-                name: pushName,
-            };
-            break;
-        }
-        case 'audio': {
-            const audioUrl = await getMediaUrl(version, message.audio?.id, numberId, jwtToken);
-            responseObj = {
-                type: message.type,
-                from: message.from,
-                url: audioUrl,
-                fileData,
-                to,
-                body: bot.utils.generateRefProvider('_event_voice_note_'),
-                pushName,
-                name: pushName,
-            };
-            break;
-        }
-        case 'sticker': {
-            responseObj = {
-                type: message.type,
-                from: message.from,
-                to,
-                id: message.sticker.id,
-                body: bot.utils.generateRefProvider('_event_media_'),
-                pushName,
-                name: pushName,
-            };
-            break;
-        }
-        case 'contacts': {
-            responseObj = {
-                type: message.type,
-                from: message.from,
-                contacts: [
-                    {
-                        name: message.contacts[0].name,
-                        phones: message.contacts[0].phones,
-                    },
-                ],
-                to,
-                body: bot.utils.generateRefProvider('_event_contacts_'),
-                pushName,
-                name: pushName,
-            };
-            break;
+const { http, https } = followRedirects;
+/**
+ * Extraer el mimetype from buffer
+ * @param response - La respuesta HTTP
+ * @returns Un objeto con el tipo y la extensión del archivo
+ */
+const fileTypeFromFile = async (response) => {
+    const type = response.headers['content-type'] ?? '';
+    const ext = mime$1.extension(type);
+    return {
+        type,
+        ext,
+    };
+};
+/**
+ * Descargar archivo binario en tmp
+ * @param url - La URL del archivo a descargar
+ * @returns La ruta al archivo descargado
+ */
+const generalDownload = async (url, pathToSave, headers) => {
+    const checkIsLocal = fs$1.existsSync(url);
+    const handleDownload = () => {
+        try {
+            const checkProtocol = url.startsWith('http');
+            const handleHttp = checkProtocol ? https : http;
+            const fileName = path$1.basename(checkProtocol ? new URL(url).pathname : url);
+            const name = path$1.parse(fileName).name;
+            const fullPath = path$1.join(pathToSave ?? require$$0$2.tmpdir(), name);
+            const file = fs$1.createWriteStream(fullPath);
+            if (checkIsLocal) {
+                /**
+                 * From Local
+                 */
+                return new Promise((res) => {
+                    const response = {
+                        headers: {
+                            'content-type': mime$1.contentType(path$1.extname(url)) || '',
+                        },
+                    };
+                    res({ response, fullPath: url });
+                });
+            }
+            else {
+                /**
+                 * From URL
+                 */
+                return new Promise((res, rej) => {
+                    const options = {
+                        headers: headers ?? {},
+                    };
+                    handleHttp.get(url, options, function (response) {
+                        response.pipe(file);
+                        file.on('finish', async function () {
+                            file.close();
+                            res({ response, fullPath });
+                        });
+                        file.on('error', function () {
+                            file.close();
+                            rej(new Error('Error downloading file'));
+                        });
+                    });
+                });
+            }
         }
-        case 'order': {
-            responseObj = {
-                type: message.type,
-                from: message.from,
-                to,
-                order: {
-                    catalog_id: message.order.catalog_id,
-                    product_items: message.order.product_items,
-                },
-                body: bot.utils.generateRefProvider('_event_order_'),
-                pushName,
-                name: pushName,
-            };
-            break;
+        catch (err) {
+            console.error('Error downloading file', err);
+            return;
         }
-    }
-    return {
-        ...responseObj,
-        message_id: messageId,
-        timestamp: messageTimestamp,
     };
+    const handleFile = (pathInput, ext) => {
+        return new Promise((resolve, reject) => {
+            if (!ext) {
+                reject(new Error('No extension found for the file'));
+                return;
+            }
+            const fullPath = checkIsLocal ? `${pathInput}` : `${pathInput}.${ext}`;
+            fs$1.rename(pathInput, fullPath, (err) => {
+                if (err)
+                    reject(err);
+                resolve(fullPath);
+            });
+        });
+    };
+    const httpResponse = await handleDownload();
+    const { ext } = await fileTypeFromFile(httpResponse.response);
+    if (!ext)
+        throw new Error('Unable to determine file extension');
+    const getPath = await handleFile(httpResponse.fullPath, ext);
+    return getPath;
 };
 
 /**
- * Class representing MetaCoreVendor, a vendor class for meta core functionality.
+ * Genera un UUID único con un prefijo opcional.
+ * @param prefix - Prefijo opcional para el UUID.
+ * @returns Un identificador único (UUID v4).
+ */
+const generateRefProvider = (prefix) => {
+    const id = node_crypto.randomUUID();
+    return prefix ? `${prefix}_${id}` : id;
+};
+/**
+ * Elimina el dominio del JID de WhatsApp (e.g., "@s.whatsapp.net").
+ * @param jid - JID completo.
+ * @returns El número limpio.
+ */
+const cleanJid = (jid) => {
+    return jid?.split('@')[0] ?? '';
+};
+/**
+ * Class representing EvolutionCoreVendor, a vendor class for WhatsApp Business API integration.
+ * Handles webhook validation, message reception, and processing through Meta's Cloud API.
  * @extends EventEmitter
  */
 class EvolutionCoreVendor extends EventEmitter {
     /**
-     * Create a MetaCoreVendor.
-     * @param {Queue} _queue - The queue instance.
+     * Creates an instance of EvolutionCoreVendor.
+     * @param {Queue} _queue - The queue instance for managing message processing.
      */
     constructor(_queue) {
         super();
         /**
-         * Middleware function for indexing home.
+         * Middleware function for health check endpoint.
+         * Returns a simple response to verify the service is running.
          * @type {polka.Middleware}
          */
         this.indexHome = (_, res) => {
-            res.end('running ok');
-        };
-        /**
-         * Middleware function for verifying token.
-         * @type {polka.Middleware}
-         */
-        this.verifyToken = async (req, res) => {
-            const { query } = req;
-            const mode = query?.['hub.mode'];
-            const token = query?.['hub.verify_token'];
-            const challenge = query?.['hub.challenge'];
-            const globalVendorArgs = req['globalVendorArgs'] ?? null;
-            if (!mode || !token) {
-                res.statusCode = 403;
-                res.end('No token!');
-                return;
+            try {
+                res.end('ok');
             }
-            if (this.tokenIsValid(mode, token, globalVendorArgs?.verifyToken)) {
-                this.emit('ready');
-                res.statusCode = 200;
-                res.end(challenge);
-                return;
+            catch (error) {
+                console.error('Error in indexHome middleware:', error);
+                res.statusCode = 500;
+                res.end('Internal server error');
             }
-            res.statusCode = 403;
-            res.end('Invalid token!');
         };
         /**
-         * Middleware function for handling incoming messages.
+         * Middleware function for handling incoming webhook messages.
+         * Processes incoming messages from WhatsApp and adds them to the processing queue.
          * @type {polka.Middleware}
          */
         this.incomingMsg = async (req, res) => {
-            const globalVendorArgs = req['globalVendorArgs'] ?? null;
-            const body = req?.body;
-            const { jwtToken, numberId, version } = globalVendorArgs;
-            const someErrors = this.extractStatus(body);
-            const findError = someErrors.find((s) => s.status === 'failed');
-            if (findError) {
-                this.emit('notice', {
-                    title: '🔔  META ALERT  🔔',
-                    instructions: [findError.reason],
-                });
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                return res.end(JSON.stringify(someErrors));
-            }
-            const messages = body?.entry?.[0]?.changes?.[0]?.value?.messages;
-            const contacts = body?.entry?.[0]?.changes?.[0]?.value?.contacts;
-            const messageId = body?.entry?.[0]?.changes?.[0]?.value?.messages?.[0]?.id;
-            const messageTimestamp = body?.entry?.[0]?.changes?.[0]?.value?.messages?.[0]?.timestamp;
-            if (!messages?.length) {
-                res.statusCode = 200;
-                res.end('empty endpoint');
-                return;
-            }
             try {
-                await Promise.all(messages.map(async (message) => {
-                    let contact;
-                    if (Array.isArray(contacts))
-                        [contact] = contacts;
-                    const to = body.entry[0].changes[0].value?.metadata?.display_phone_number;
-                    const pushName = contact?.profile?.name ?? 'Unknown';
-                    const fileData = message?.audio ??
-                        message?.image ??
-                        message?.video ??
-                        message?.document ??
-                        message?.sticker ??
-                        null;
-                    const response = await processIncomingMessage({
-                        messageId,
-                        messageTimestamp,
-                        to,
-                        pushName,
-                        message,
-                        jwtToken,
-                        numberId,
-                        version,
-                        fileData,
-                    });
-                    if (response) {
-                        await this.queue.enqueue(() => this.processMessage(response));
-                    }
-                }));
+                const globalVendorArgs = req['globalVendorArgs'] ?? null;
+                if (!globalVendorArgs) {
+                    res.statusCode = 400;
+                    res.end('Missing vendor arguments');
+                    return;
+                }
+                console.log(' body', JSON.stringify(req.body, null, 2));
+                const { event, data } = req.body;
+                if (!req.body) {
+                    res.statusCode = 400;
+                    res.end('Invalid request body');
+                    return;
+                }
+                switch (event) {
+                    case 'messages.upsert':
+                        if (data.message) {
+                            const { message } = data;
+                            const from = cleanJid(data.key?.remoteJid);
+                            const name = data.pushName;
+                            let responseObj = null;
+                            if (message.documentMessage) {
+                                responseObj = {
+                                    type: data.messageType,
+                                    from,
+                                    mimetype: message.documentMessage.mimetype,
+                                    body: generateRefProvider('_event_document_'),
+                                    name,
+                                    caption: message.documentMessage.caption,
+                                    base64: message.base64,
+                                };
+                            }
+                            else if (message.videoMessage) {
+                                responseObj = {
+                                    type: data.messageType,
+                                    from,
+                                    mimetype: message.videoMessage.mimetype,
+                                    body: generateRefProvider('_event_media_'),
+                                    name,
+                                    caption: message.videoMessage.caption || '',
+                                    base64: message.base64,
+                                };
+                            }
+                            else if (message.imageMessage) {
+                                responseObj = {
+                                    type: data.messageType,
+                                    from,
+                                    mimetype: message.imageMessage.mimetype,
+                                    body: generateRefProvider('_event_media_'),
+                                    name,
+                                    caption: message.imageMessage.caption || '',
+                                    base64: message.base64,
+                                };
+                            }
+                            else if (message.audioMessage) {
+                                responseObj = {
+                                    type: data.messageType,
+                                    from,
+                                    mimetype: message.audioMessage.mimetype,
+                                    body: generateRefProvider('_event_voice_note_'),
+                                    name,
+                                    caption: message.audioMessage.caption || '',
+                                    base64: message.base64,
+                                };
+                            }
+                            else if (message.locationMessage || message.liveLocationMessage) {
+                                responseObj = {
+                                    type: data.messageType,
+                                    from,
+                                    latitude: message.locationMessage?.degreesLatitude ??
+                                        message.liveLocationMessage?.degreesLatitude,
+                                    longitude: message.locationMessage?.degreesLongitude ??
+                                        message.liveLocationMessage?.degreesLongitude,
+                                    body: generateRefProvider('_event_location_'),
+                                    name,
+                                };
+                            }
+                            else if (message.conversation) {
+                                responseObj = {
+                                    type: data.messageType,
+                                    from,
+                                    body: message.conversation,
+                                    name,
+                                };
+                            }
+                            if (responseObj) {
+                                const enrichedMessage = { ...data, ...responseObj };
+                                await this.queue.enqueue(() => this.processMessage(enrichedMessage));
+                            }
+                        }
+                }
                 res.statusCode = 200;
-                res.end('Messages enqueued');
+                res.end('Message processed successfully');
+                // Check for errors reported by Meta
             }
             catch (error) {
+                console.error('Error processing incoming message:', error);
                 this.emit('notice', {
-                    title: '🔔  META ALERT  🔔',
-                    instructions: [error.message || 'An error occurred while processing messages.'],
+                    title: '🔔  EVOLUTION API ALERT  🔔',
+                    instructions: [error.message || 'An error occurred while processing message.'],
                 });
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: error.message || 'An error occurred while processing messages.' }));
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    error: error.message || 'An error occurred while processing message.',
+                    stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
+                }));
             }
         };
         /**
-         * Process incoming message.
-         * @param {Message} message - The message object.
-         * @returns {Promise<void>} Promise that resolves when processing is complete.
+         * Procesa un mensaje entrante y lo emite al flujo del bot.
+         * @param message - Objeto de mensaje enriquecido.
          */
         this.processMessage = (message) => {
             return new Promise((resolve, reject) => {
@@ -20138,41 +20140,22 @@ class EvolutionCoreVendor extends EventEmitter {
                 }
             });
         };
+        if (!_queue) {
+            throw new Error('Queue instance is required');
+        }
         this.queue = _queue;
     }
-    /**
-     * Check if the token is valid.
-     * @param {string} mode - The mode parameter.
-     * @param {string} token - The token parameter.
-     * @param {string} originToken - The origin token parameter.
-     * @returns {boolean} Returns true if token is valid, false otherwise.
-     */
-    tokenIsValid(mode, token, originToken) {
-        return mode === 'subscribe' && originToken === token;
-    }
-    extractStatus(obj) {
-        const entry = obj.entry || [];
-        const statusArray = [];
-        entry.forEach((entryItem) => {
-            const changes = entryItem.changes || [];
-            changes.forEach((change) => {
-                const values = change.value || {};
-                const statuses = values.statuses || [];
-                statuses.forEach((status) => {
-                    const recipient_id = status.recipient_id || 'N/A';
-                    const errorDetails = status.errors?.[0]?.error_data?.details || 'Unknown';
-                    statusArray.push({
-                        status: status.status || 'Unknown',
-                        reason: `Number(${recipient_id}): ${errorDetails}`,
-                    });
-                });
-            });
-        });
-        return statusArray;
-    }
 }
 
+/**
+ * Evolution API Provider implementation
+ * Handles all communication with Evolution API for sending messages, media, etc.
+ */
 class EvolutionProvider extends bot.ProviderClass {
+    /**
+     * Creates an instance of Evolution Provider
+     * @param args Provider configuration
+     */
     constructor(args) {
         super();
         this.queue = new Queue();
@@ -20181,108 +20164,164 @@ class EvolutionProvider extends bot.ProviderClass {
             apiKey: '',
             baseURL: 'http://localhost:8080',
             instanceName: '',
+            port: 3000,
         };
-        this.busEvents = () => [
-            {
-                event: 'auth_failure',
-                func: (payload) => this.emit('auth_failure', payload),
-            },
-            {
-                event: 'notice',
-                func: ({ instructions, title }) => this.emit('notice', { instructions, title }),
-            },
-            {
-                event: 'ready',
-                func: () => this.emit('ready', true),
-            },
-            {
-                event: 'message',
-                func: (payload) => {
-                    this.emit('message', payload);
+        /**
+         * Punto de entrada para envío de archivos multimedia.
+         * Detecta el tipo de archivo y redirige a la función correspondiente.
+         *
+         * @param number Número de destino
+         * @param mediaUrl URL o path del archivo
+         * @param caption Texto opcional
+         */
+        this.sendMedia = async (number, mediaUrl, caption) => {
+            const fileDownloaded = await generalDownload(mediaUrl);
+            const mimeType = mime$1.lookup(fileDownloaded);
+            if (!mimeType)
+                throw new Error('No se pudo determinar el tipo MIME');
+            if (mimeType.includes('image')) {
+                return this.sendImage(number, fileDownloaded, caption || '');
+            }
+            if (mimeType.includes('video')) {
+                return this.sendVideo(number, fileDownloaded, caption || '');
+            }
+            if (mimeType.includes('audio')) {
+                return this.sendAudio(number, fileDownloaded);
+            }
+            return this.sendFile(number, fileDownloaded, caption || '');
+        };
+        /**
+         * Envía una imagen al número dado.
+         * @param number Número destino
+         * @param filePath Ruta local de la imagen
+         * @param caption Texto opcional
+         */
+        this.sendImage = async (number, filePath, caption) => {
+            const mediaBase64 = fs$1.readFileSync(filePath, { encoding: 'base64' });
+            const mimeType = mime$1.lookup(filePath);
+            const body = {
+                number,
+                media: mediaBase64,
+                mimetype: mimeType,
+                mediatype: 'image',
+                caption: caption || path$1.basename(filePath),
+                delay: 0,
+            };
+            return this.sendMessageEvoApi(body, '/message/sendMedia/');
+        };
+        /**
+         * Envía un video al número dado.
+         * @param number Número destino
+         * @param filePath Ruta local del video
+         * @param caption Texto opcional
+         */
+        this.sendVideo = async (number, filePath, caption) => {
+            const mediaBase64 = fs$1.readFileSync(filePath, { encoding: 'base64' });
+            const mimeType = mime$1.lookup(filePath);
+            const body = {
+                number,
+                media: mediaBase64,
+                mimetype: mimeType,
+                mediatype: 'video',
+                caption: caption || path$1.basename(filePath),
+                delay: 0,
+            };
+            return this.sendMessageEvoApi(body, '/message/sendMedia/');
+        };
+        /**
+         * Envía un archivo de audio en formato compatible (OPUS).
+         * @param number Número destino
+         * @param filePath Ruta local del archivo de audio
+         */
+        this.sendAudio = async (number, filePath) => {
+            const mediaBase64 = fs$1.readFileSync(filePath, { encoding: 'base64' });
+            const body = {
+                number,
+                media: mediaBase64,
+                mimetype: 'audio/ogg; codecs=opus',
+                mediatype: 'audio',
+                delay: 0,
+            };
+            return this.sendMessageEvoApi(body, '/message/sendMedia/');
+        };
+        /**
+         * Envía un documento genérico al número dado.
+         * @param number Número destino
+         * @param filePath Ruta local del archivo
+         * @param caption Texto opcional
+         */
+        this.sendFile = async (number, filePath, caption) => {
+            const mediaBase64 = fs$1.readFileSync(filePath, { encoding: 'base64' });
+            const mimeType = mime$1.lookup(filePath);
+            const fileName = path$1.basename(filePath);
+            const body = {
+                number,
+                media: mediaBase64,
+                mimetype: mimeType,
+                mediatype: 'document',
+                fileName,
+                caption: caption || path$1.basename(filePath),
+                delay: 0,
+            };
+            return this.sendMessageEvoApi(body, '/message/sendMedia/');
+        };
+        /**
+         * Envía un mensaje de texto plano.
+         * @param number Número destino
+         * @param message Contenido del mensaje
+         */
+        this.sendText = async (number, message) => {
+            const ruta = '/message/sendText/';
+            const body = {
+                number,
+                text: message,
+                delay: 0,
+            };
+            return this.sendMessageEvoApi(body, ruta);
+        };
+        /**
+         * Función general para hacer peticiones POST a la API externa.
+         * @param body Cuerpo de la petición
+         * @param ruta Ruta relativa del endpoint (optional)
+         */
+        this.sendMessageToApi = async (body, ruta = '/message/') => {
+            const { baseURL, instanceName, apiKey } = this.globalVendorArgs;
+            const response = await fetch(`${baseURL}${ruta}${instanceName}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    apikey: apiKey,
                 },
-            },
-        ];
-        // async sendLocation(to: string, lat: string, long: string): Promise<any> {
-        //     const { baseURL, instanceName, apiKey } = this.globalVendorArgs
-        //     try {
-        //         return await axios.post(
-        //             `${baseURL}/message/sendLocation/${instanceName}`,
-        //             {
-        //                 number: to,
-        //                 lat,
-        //                 long
-        //             },
-        //             {
-        //                 headers: {
-        //                     'apikey': apiKey
-        //                 }
-        //             }
-        //         )
-        //     } catch (error) {
-        //         console.error('Error sending location:', error)
-        //         throw error
-        //     }
-        // }
-        // async sendContact(to: string, contact: Contact): Promise<any> {
-        //     const { baseURL, instanceName, apiKey } = this.globalVendorArgs
-        //     try {
-        //         return await axios.post(
-        //             `${baseURL}/message/contact/${instanceName}`,
-        //             {
-        //                 number: to,
-        //                 contact
-        //             },
-        //             {
-        //                 headers: {
-        //                     'apikey': apiKey
-        //                 }
-        //             }
-        //         )
-        //     } catch (error) {
-        //         console.error('Error sending contact:', error)
-        //         throw error
-        //     }
-        // }
-        // async sendReaction(to: string, message: string): Promise<any> {
-        //     const { baseURL, instanceName, apiKey } = this.globalVendorArgs
-        //     try {
-        //         return await axios.post(
-        //             `${baseURL}/message/reaction/${instanceName}`,
-        //             {
-        //                 number: to,
-        //                 reaction: message
-        //             },
-        //             {
-        //                 headers: {
-        //                     'apikey': apiKey
-        //                 }
-        //             }
-        //         )
-        //     } catch (error) {
-        //         console.error('Error sending reaction:', error)
-        //         throw error
-        //     }
-        // }
-        // Métodos auxiliares requeridos por la interfaz
-        this.sendMessageMeta = (body) => {
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                throw new Error(`Error sending message: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return data;
+        };
+        /**
+         * Encola el envío de un mensaje para asegurar orden y evitar conflictos.
+         * @param body Cuerpo del mensaje
+         * @param ruta Ruta del endpoint
+         */
+        this.sendMessageEvoApi = (body, ruta) => {
             return new Promise((resolve) => this.queue.add(async () => {
-                const resp = await this.sendMessageToApi(body);
+                const resp = await this.sendMessageToApi(body, ruta);
                 resolve(resp);
             }));
         };
-        this.sendMessageToApi = async (body) => {
-            const { baseURL, instanceName, apiKey } = this.globalVendorArgs;
+        this.saveFile = async (ctx, options = {}) => {
             try {
-                const response = await axios.post(`${baseURL}/message/sendText/${instanceName}`, body, {
-                    headers: {
-                        apikey: apiKey,
-                    },
-                });
-                return response.data;
+                const buffer = ctx.base64;
+                const extension = mime$1.extension(ctx.mimetype);
+                const fileName = `file-${Date.now()}.${extension}`;
+                const pathFile = path$1.join(options?.path ?? require$$0$2.tmpdir(), fileName);
+                await promises.writeFile(pathFile, buffer);
+                return path$1.resolve(pathFile);
             }
             catch (error) {
-                console.error('Error sending message:', error);
-                throw error;
+                return Promise.reject(error);
             }
         };
         this.globalVendorArgs = { ...this.globalVendorArgs, ...args };
@@ -20292,215 +20331,106 @@ class EvolutionProvider extends bot.ProviderClass {
             start: true,
         });
     }
+    /**
+     * Initialize HTTP server middleware
+     */
     beforeHttpServerInit() {
         this.server = this.server
+            .use(json())
             .use((req, _, next) => {
             req['globalVendorArgs'] = this.globalVendorArgs;
             return next();
         })
-            .post('/', this.vendor.indexHome);
+            .post('/', this.vendor.indexHome)
+            .post('/webhook', this.vendor.incomingMsg);
     }
-    async initVendor() {
+    /**
+     * Initialize vendor core
+     */
+    initVendor() {
         const vendor = new EvolutionCoreVendor(this.queue);
         this.vendor = vendor;
         return Promise.resolve(this.vendor);
     }
-    async afterHttpServerInit() {
+    /**
+     * Build standard headers for API requests
+     * @param additionalHeaders Optional additional headers to include
+     * @returns Headers object with apiKey
+     */
+    builderHeader(additionalHeaders = {}) {
+        const { apiKey } = this.globalVendorArgs;
+        return {
+            apikey: apiKey,
+            ...additionalHeaders,
+        };
+    }
+    /**
+     * Verify connection with Evolution API after HTTP server initialization
+     */ async afterHttpServerInit() {
         try {
-            const { baseURL, instanceName, apiKey } = this.globalVendorArgs;
-            // Verificar conexión con Evolution API
+            const { baseURL, instanceName } = this.globalVendorArgs;
+            // Verify connection with Evolution API
             const response = await axios.get(`${baseURL}/instance/connectionState/${instanceName}`, {
-                headers: {
-                    apikey: apiKey,
-                },
+                headers: this.builderHeader(),
             });
-            if (response.data.state === 'open') {
+            const state = response.data.state ?? response.data.instance.state ?? 'close';
+            if (state === 'open') {
                 this.emit('ready');
             }
             else {
-                throw new Error('Instance not connected');
+                throw new Error(`Instance state: ${state}`);
             }
         }
         catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
             this.emit('notice', {
                 title: '🟠 ERROR AUTH 🟠',
                 instructions: [
                     'Error connecting to Evolution API, please check your credentials',
                     'Make sure your instance is connected',
+                    `Details: ${errorMessage}`,
                 ],
             });
         }
     }
-    async sendText(to, message) {
-        return this.sendMessage(to, message);
-    }
-    async sendMessage(to, message) {
-        try {
-            const { baseURL, instanceName, apiKey } = this.globalVendorArgs;
-            return await axios.post(`${baseURL}/message/sendText/${instanceName}`, {
-                number: to,
-                text: message,
-            }, {
-                headers: {
-                    apikey: apiKey,
-                },
-            });
-        }
-        catch (error) {
-            console.error('Error sending message:', error);
-            throw error;
-        }
-    }
-    async sendImage(to, mediaUrl, mediaName, caption) {
-        try {
-            const { baseURL, instanceName, apiKey } = this.globalVendorArgs;
-            return await axios.post(`${baseURL}/message/sendMedia/${instanceName}`, {
-                number: to,
-                mediaType: 'image',
-                mimeType: mime$1.lookup(mediaUrl) || 'image/png',
-                caption: caption,
-                media: mediaUrl,
-                fileName: mediaName || 'image.png',
-            }, {
-                headers: {
-                    apikey: apiKey,
-                },
-            });
-        }
-        catch (error) {
-            console.error('Error sending image:', error);
-            throw error;
-        }
-    }
-    async sendImageUrl(to, url, mediaName, caption) {
-        return this.sendImage(to, url, mediaName, caption);
-    }
-    async sendVideo(to, mediaUrl, mediaName, caption) {
-        try {
-            const { baseURL, instanceName, apiKey } = this.globalVendorArgs;
-            return await axios.post(`${baseURL}/message/video/${instanceName}`, {
-                number: to,
-                mediaType: 'video',
-                mimeType: 'video/mp4',
-                caption: caption,
-                media: mediaUrl,
-                fileName: mediaName || 'video.mp4',
-            }, {
-                headers: {
-                    apikey: apiKey,
-                },
-            });
-        }
-        catch (error) {
-            console.error('Error sending video:', error);
-            throw error;
-        }
-    }
-    async sendVideoUrl(to, url, mediaName, caption) {
-        return this.sendVideo(to, url, mediaName, caption);
-    }
-    async sendAudio(to, mediaUrl, mediaName, caption) {
-        try {
-            const { baseURL, instanceName, apiKey } = this.globalVendorArgs;
-            return await axios.post(`${baseURL}/message/audio/${instanceName}`, {
-                number: to,
-                mediaType: 'audio',
-                mimeType: 'audio/mp3',
-                caption: caption,
-                media: mediaUrl,
-                fileName: mediaName || 'audio.mp3',
-            }, {
-                headers: {
-                    apikey: apiKey,
-                },
-            });
-        }
-        catch (error) {
-            console.error('Error sending audio:', error);
-            throw error;
-        }
-    }
-    async sendAudioUrl(to, url, mediaName, caption) {
-        return this.sendAudio(to, url, mediaName, caption);
-    }
-    async sendMedia(to, file, type) {
-        const { baseURL, instanceName, apiKey } = this.globalVendorArgs;
-        try {
-            return await axios.post(`${baseURL}/message/${type}/${instanceName}`, {
-                number: to,
-                [type]: file,
-            }, {
-                headers: {
-                    apikey: apiKey,
-                },
-            });
-        }
-        catch (error) {
-            console.error(`Error sending ${type}:`, error);
-            throw error;
-        }
-    }
-    // async sendButtons(to: string, buttons: Button[] = [], text: string): Promise<any> {
-    //     try {
-    //         const { baseURL, instanceName, apiKey } = this.globalVendorArgs
-    //         return await axios.post(
-    //             `${baseURL}/message/buttons/${instanceName}`,
-    //             {
-    //                 number: to,
-    //                 buttons: buttons.map(btn => ({
-    //                     buttonText: btn.body,
-    //                     buttonId: btn.id
-    //                 })),
-    //                 text
-    //             },
-    //             {
-    //                 headers: {
-    //                     'apikey': apiKey
-    //                 }
-    //             }
-    //         )
-    //     } catch (error) {
-    //         console.error('Error sending buttons:', error)
-    //         throw error
-    //     }
-    // }
-    async sendList(to, list) {
-        try {
-            const { baseURL, instanceName, apiKey } = this.globalVendorArgs;
-            return await axios.post(`${baseURL}/message/list/${instanceName}`, {
-                number: to,
-                list,
-            }, {
-                headers: {
-                    apikey: apiKey,
+    /**
+     * Event bus configuration
+     */
+    busEvents() {
+        return [
+            {
+                event: 'auth_failure',
+                func: (payload) => this.emit('auth_failure', payload),
+            },
+            {
+                event: 'notice',
+                func: ({ instructions, title }) => this.emit('notice', { instructions, title }),
+            },
+            {
+                event: 'ready',
+                func: () => this.emit('ready', true),
+            },
+            {
+                event: 'message',
+                func: (payload) => {
+                    this.emit('message', payload);
                 },
-            });
-        }
-        catch (error) {
-            console.error('Error sending list:', error);
-            throw error;
-        }
-    }
-    async sendListComplete(to, list) {
-        return this.sendList(to, list);
+            },
+        ];
     }
-    async saveFile(ctx, options = {}) {
-        // try {
-        //     // Download the file from the URL
-        //     const buffer = await utils.downloadFile(ctx.url)
-        //     // Generate filename using timestamp and mime type from file data
-        //     const fileName = `file-${Date.now()}.${ctx.fileData?.mime_type?.split('/')[1] || 'tmp'}`
-        //     // Create full path by joining target directory with filename
-        //     const pathFile = join(options?.path ?? tmpdir(), fileName)
-        //     // Write buffer to file
-        //     await writeFile(pathFile, buffer)
-        //     // Return resolved absolute path
-        //     return resolve(pathFile)
-        // } catch (err) {
-        //     console.error(`[Error saving file]:`, err.message)
-        //     return 'ERROR'
-        // }
-        return '';
+    /**
+     * Enrutador general para envío de mensajes.
+     * Si incluye media, se envía como archivo. Si no, como texto plano.
+     *
+     * @param number Número destino
+     * @param message Mensaje de texto
+     * @param options Opciones adicionales (media, etc.)
+     */
+    async sendMessage(number, message, options) {
+        options = { ...options, ...options['options'] };
+        if (options.media)
+            return this.sendMedia(number, options.media, message);
+        return this.sendText(number, message);
     }
 }