@runnerpro/backend 1.22.7 → 1.23.0

package/lib/cjs/chat/api/conversation.js

@@ -508,6 +508,11 @@ const sendFile = (req, res, { sendNotification, firebaseMessaging, isClient, buc
         files.push({ data: fileData, id: idFile });
     }
     res.send({ idFile, logrosDesbloqueados });
+    // Procesar el adjunto en background, sea del tipo que sea: transcripción, descripción, resumen
+    // o ficha del archivo. El router de mediaProcessing decide qué toca. Va ANTES de subir a Storage
+    // a propósito: si la subida falla, el mensaje se quedaría sin FILE TEXT de forma permanente y
+    // eso bloquea al entrenador, que no distingue "sin texto" de "aún sin procesar".
+    (0, mediaProcessing_1.processMediaFile)(idFile, fileData, req.file.mimetype, req.file.originalname);
     for (const file of files) {
         yield bucket.file(`Chat/${file.id}`).save(file.data);
     }
@@ -530,10 +535,6 @@ const sendFile = (req, res, { sendNotification, firebaseMessaging, isClient, buc
         });
         yield updateSenderView({ userid, idCliente, idMessage: idFile });
     }
-    // Procesar archivo multimedia en background (transcripción de audio / descripción de imagen)
-    if (req.file.mimetype.startsWith('audio/') || req.file.mimetype.startsWith('image/')) {
-        (0, mediaProcessing_1.processMediaFile)(idFile, fileData, req.file.mimetype);
-    }
 });
 const getThumbnailFromVideo = (videoPath, duration) => __awaiter(void 0, void 0, void 0, function* () {
     const targetWidth = 500;

package/lib/cjs/index.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.describeImage = exports.transcribeAudio = exports.updateSenderView = exports.saveResponseTime = exports.getZone = exports.saveDoneStructuraWorkout = exports.computeStreakStats = exports.getUnlockedAchievements = exports.evaluateAchievementsBounded = exports.evaluateAchievements = exports.saveWorkoutLaps = exports.saveWorkoutAplication = exports.getPlanificacionPrueba7dias = exports.sendWorkoutToWatch = exports.getDefaultWorkoutImage = exports.generateShareMap = exports.reduceSizeImage = exports.getLetter = exports.getNumberByLetter = exports.appendSheet = exports.writeSheet = exports.findCellByValue = exports.readSheet = exports.NOTION_DATABASES_ID = exports.notionEditPage = exports.notionAddPage = exports.notionGetDatabase = exports.notionGetUsers = exports.getCountNotificaciones = exports.chatExposed = exports.chatApi = exports.chat = exports.getExerciseTranslatedDescription = exports.useTranslation = exports.LANGUAGES = exports.translate = exports.CHANNEL_SLACK = exports.notifySlack = exports.fetchIA = exports.err = exports.sendMail = exports.pool = exports.toPgArray = exports.batchQuery = exports.longRunningQuery = exports.queryWithClient = exports.query = exports.sleep = exports.sendNotification = exports.achievementsCatalog = void 0;
-exports.calculateCost = exports.MODEL_PRICING = exports.AISTUDIO_PREFIX = exports.BEDROCK_CLAUDE_HAIKU = exports.BEDROCK_CLAUDE_SONNET_4 = exports.BEDROCK_CLAUDE_SONNET_4_5 = exports.BEDROCK_CLAUDE_OPUS_4_1 = exports.BEDROCK_CLAUDE_OPUS_4_5 = exports.BEDROCK_CLAUDE_SONNET = exports.BEDROCK_CLAUDE_OPUS = exports.FALLBACK_MODELS = exports.PRODUCTION_MODELS = exports.AZURE_PRIMARY_MODELS = exports.AZURE_GPT_5_4_NANO = exports.AZURE_GPT_5_4_MINI = exports.AZURE_GPT_5_5 = exports.AZURE_GPT_5_4_NANO_DEPLOYMENT = exports.AZURE_GPT_5_4_MINI_DEPLOYMENT = exports.AZURE_GPT_5_5_DEPLOYMENT = exports.AZURE_PREFIX = exports.GOOGLE_MODELS = exports.AI_MODELS = exports.MODEL_TIER = exports.runWithModels = exports.runWithCostTracking = exports.createModelFromString = exports.createAzureModelFromString = exports.createBedrockModelFromString = exports.createGoogleModelFromString = exports.createGoogleModel = exports.generateText = exports.generateObject = exports.reprocessRecentMedia = exports.processMediaFile = void 0;
+exports.calculateCost = exports.MODEL_PRICING = exports.AISTUDIO_PREFIX = exports.BEDROCK_CLAUDE_HAIKU = exports.BEDROCK_CLAUDE_SONNET_4 = exports.BEDROCK_CLAUDE_SONNET_4_5 = exports.BEDROCK_CLAUDE_OPUS_4_1 = exports.BEDROCK_CLAUDE_OPUS_4_5 = exports.BEDROCK_CLAUDE_SONNET = exports.BEDROCK_CLAUDE_OPUS = exports.FALLBACK_MODELS = exports.PRODUCTION_MODELS = exports.AZURE_PRIMARY_MODELS = exports.AZURE_GPT_5_4_NANO = exports.AZURE_GPT_5_4_MINI = exports.AZURE_GPT_5_5 = exports.AZURE_GPT_5_4_NANO_DEPLOYMENT = exports.AZURE_GPT_5_4_MINI_DEPLOYMENT = exports.AZURE_GPT_5_5_DEPLOYMENT = exports.AZURE_PREFIX = exports.GOOGLE_MODELS = exports.AI_MODELS = exports.MODEL_TIER = exports.runWithModels = exports.runWithCostTracking = exports.createModelFromString = exports.createAzureModelFromString = exports.createBedrockModelFromString = exports.createGoogleModelFromString = exports.createGoogleModel = exports.generateText = exports.generateObject = exports.reprocessRecentMedia = exports.processMediaFile = exports.analyzeFile = exports.describeTextFile = exports.describePdf = exports.describeVideo = void 0;
 const sendNotification_1 = require("./sendNotification");
 Object.defineProperty(exports, "sendNotification", { enumerable: true, get: function () { return sendNotification_1.sendNotification; } });
 const sleep_1 = require("./sleep");
@@ -102,6 +102,10 @@ Object.defineProperty(exports, "updateSenderView", { enumerable: true, get: func
 const mediaProcessing_1 = require("./mediaProcessing");
 Object.defineProperty(exports, "transcribeAudio", { enumerable: true, get: function () { return mediaProcessing_1.transcribeAudio; } });
 Object.defineProperty(exports, "describeImage", { enumerable: true, get: function () { return mediaProcessing_1.describeImage; } });
+Object.defineProperty(exports, "describeVideo", { enumerable: true, get: function () { return mediaProcessing_1.describeVideo; } });
+Object.defineProperty(exports, "describePdf", { enumerable: true, get: function () { return mediaProcessing_1.describePdf; } });
+Object.defineProperty(exports, "describeTextFile", { enumerable: true, get: function () { return mediaProcessing_1.describeTextFile; } });
+Object.defineProperty(exports, "analyzeFile", { enumerable: true, get: function () { return mediaProcessing_1.analyzeFile; } });
 Object.defineProperty(exports, "processMediaFile", { enumerable: true, get: function () { return mediaProcessing_1.processMediaFile; } });
 Object.defineProperty(exports, "reprocessRecentMedia", { enumerable: true, get: function () { return mediaProcessing_1.reprocessRecentMedia; } });
 const prompt_1 = require("./prompt");

package/lib/cjs/mediaProcessing/audio.js

@@ -0,0 +1,216 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNC_MAX_SECONDS = exports.AUDIO_ENCODING_MAP = exports.convertToWav16k = exports.transcribeWithModel = exports.transcribeWav16k = exports.transcribeAudio = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const speech_1 = require("@google-cloud/speech");
+const ffmpegUtils_1 = require("./ffmpegUtils");
+const index_1 = require("../prompt/index");
+const constants_1 = require("../prompt/constants");
+const index_2 = require("../err/index");
+// ✅ Mapeo de MIME types a encoding de Speech-to-Text. Solo se usa en el camino de emergencia,
+// cuando ffmpeg no ha podido convertir el archivo y hay que mandarlo tal cual.
+const AUDIO_ENCODING_MAP = {
+    'audio/mpeg': 'MP3',
+    'audio/mp3': 'MP3',
+    'audio/wav': 'LINEAR16',
+    'audio/wave': 'LINEAR16',
+    'audio/x-wav': 'LINEAR16',
+    'audio/ogg': 'OGG_OPUS',
+    'audio/webm': 'WEBM_OPUS',
+    'audio/flac': 'FLAC',
+    'audio/x-flac': 'FLAC',
+    'audio/mp4': 'MP3',
+    'audio/m4a': 'MP3',
+    'audio/aac': 'MP3',
+};
+exports.AUDIO_ENCODING_MAP = AUDIO_ENCODING_MAP;
+// ✅ `recognize` (síncrono) rechaza audio de más de 60s. Cuando se le declara LINEAR16 deduce la
+// duración exacta de los bytes y lo aplica a rajatabla, así que por encima de esto no se le manda.
+const SYNC_MAX_SECONDS = 55;
+exports.SYNC_MAX_SECONDS = SYNC_MAX_SECONDS;
+// ✅ Speech-to-Text admite 10 MB en línea; a 32 KB/s son ~290s. Gemini aguanta mucho más,
+// pero recortamos para acotar el coste y la latencia de una nota de voz.
+const TRANSCRIPTION_MAX_SECONDS = 600;
+const TRANSCRIPTION_PROMPT = `Transcribe literalmente lo que se dice en este audio. Es una nota de voz que un corredor manda a su entrenador.
+Devuelve SOLO la transcripción en su idioma original, sin comentarios, sin introducción y sin describir el audio.
+Si de verdad no se oye ninguna voz, responde exactamente: SIN_VOZ`;
+/**
+ * Llama a Speech-to-Text con un buffer y una configuración ya decididas
+ *
+ * @param content - Buffer del audio
+ * @param encoding - Encoding declarado (LINEAR16, MP3...)
+ * @returns Promise<string | null> - Transcripción, o null si no se reconoció nada
+ */
+const recognizeSpeech = (content, encoding) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const speechClient = new speech_1.SpeechClient();
+        // @ts-ignore - Tipos de Speech-to-Text son complejos
+        const [response] = yield speechClient.recognize({
+            audio: {
+                content: content.toString('base64'),
+            },
+            config: {
+                // @ts-ignore - El encoding se determina dinámicamente
+                encoding: encoding,
+                sampleRateHertz: ffmpegUtils_1.SPEECH_SAMPLE_RATE,
+                languageCode: 'es-ES', // Español de España
+                alternativeLanguageCodes: ['es-MX', 'es-AR', 'en-US'], // Alternativas: México, Argentina, Inglés
+                enableAutomaticPunctuation: true, // Puntuación automática
+                model: 'latest_long', // Modelo más reciente para audios largos
+                useEnhanced: true, // Modelo mejorado
+            },
+        });
+        const transcription = (_a = response.results) === null || _a === void 0 ? void 0 : _a.map((result) => { var _a, _b; return (_b = (_a = result.alternatives) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.transcript; }).filter(Boolean).join(' ').trim();
+        return transcription || null;
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('[transcribeAudio] Error Speech-to-Text:', (error === null || error === void 0 ? void 0 : error.message) || error);
+        return null;
+    }
+});
+/**
+ * Transcribe con un modelo multimodal de Google. Es la red que recoge lo que Speech-to-Text
+ * no reconoce y, sobre todo, los audios de más de 60s, que el modo síncrono no admite.
+ *
+ * @param wavBuffer - Buffer WAV mono 16 kHz
+ * @returns Promise<string | null> - Transcripción, o null si no hay voz
+ */
+const transcribeWithModel = (wavBuffer) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const model = (0, index_1.createGoogleModelFromString)(constants_1.GOOGLE_MODELS.FLASH);
+        // El primario es Vertex; si el proyecto no lo tiene disponible se pasa a AI Studio
+        model._fallbackModelNames = [`${constants_1.AISTUDIO_PREFIX}${constants_1.GOOGLE_MODELS.FLASH}`, 'gemini-2.5-flash', `${constants_1.AISTUDIO_PREFIX}gemini-2.5-flash`];
+        const { text } = yield (0, index_1.generateText)({
+            model,
+            // ⭐ Sin registro en LLM CACHE: el audio no aporta nada como clave y engorda la tabla
+            log: false,
+            messages: [
+                {
+                    role: 'user',
+                    content: [
+                        { type: 'file', data: wavBuffer, mediaType: 'audio/wav' },
+                        { type: 'text', text: TRANSCRIPTION_PROMPT },
+                    ],
+                },
+            ],
+        });
+        const transcription = (text || '').trim();
+        return !transcription || transcription === 'SIN_VOZ' ? null : transcription;
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('[transcribeAudio] Error transcribiendo con el modelo:', (error === null || error === void 0 ? void 0 : error.message) || error);
+        return null;
+    }
+});
+exports.transcribeWithModel = transcribeWithModel;
+/**
+ * Convierte cualquier audio al formato que espera Speech-to-Text (WAV PCM mono 16 kHz)
+ *
+ * @param fileBuffer - Buffer del audio original
+ * @param filename - Nombre original del archivo
+ * @returns WAV mono 16 kHz y la duración original en segundos
+ */
+const convertToWav16k = (fileBuffer, filename) => (0, ffmpegUtils_1.withTempDir)((dir) => __awaiter(void 0, void 0, void 0, function* () {
+    // ffmpeg detecta el formato por contenido, así que la extensión solo es cosmética
+    const extension = path_1.default.extname(filename || '') || '.m4a';
+    const inputPath = path_1.default.join(dir, `input${extension}`);
+    const outputPath = path_1.default.join(dir, 'audio.wav');
+    fs_1.default.writeFileSync(inputPath, fileBuffer);
+    const { duration } = yield (0, ffmpegUtils_1.probeMedia)(inputPath);
+    yield (0, ffmpegUtils_1.runFfmpeg)((0, ffmpegUtils_1.ffmpeg)(inputPath)
+        .noVideo()
+        .audioCodec('pcm_s16le')
+        .audioFrequency(ffmpegUtils_1.SPEECH_SAMPLE_RATE)
+        .audioChannels(1)
+        .duration(TRANSCRIPTION_MAX_SECONDS)
+        .format('wav')
+        .output(outputPath), 'conversión de audio');
+    return { wav: fs_1.default.readFileSync(outputPath), duration };
+}));
+exports.convertToWav16k = convertToWav16k;
+/**
+ * Transcribe una nota de voz.
+ *
+ * El audio se normaliza a WAV mono 16 kHz y luego se elige motor por duración:
+ *  - hasta 55s → Speech-to-Text, que es barato y preciso.
+ *  - más de 55s → modelo multimodal, porque `recognize` no admite audios más largos y
+ *    `longRunningRecognize` exige subir el archivo a GCS antes.
+ *  - si Speech-to-Text no reconoce nada, se reintenta con el modelo antes de darlo por perdido.
+ *
+ * ⚠️ El orden importa y no es intercambiable. Medido sobre notas de voz reales de producción
+ * que hoy acaban en '[Audio sin contenido reconocible]':
+ *  - mandar el AAC crudo declarando 'MP3' (lo que se hacía): 0 de 14 recuperadas.
+ *  - convertir a WAV y declarar LINEAR16: 13 de 14 (la que falla es de 81s).
+ *  - modelo multimodal: 14 de 14.
+ * Y a la inversa, convertir a WAV SIN respetar el límite de 55s rompe los audios largos que hoy
+ * sí funcionan (4 de 4 medidos): con LINEAR16 la API deduce la duración exacta y los rechaza,
+ * mientras que con un códec comprimido declarado se saltaba esa comprobación.
+ *
+ * @param fileBuffer - Buffer del archivo de audio
+ * @param mimetype - Tipo MIME del archivo (ej: 'audio/aac', 'audio/x-m4a')
+ * @param filename - Nombre original del archivo
+ * @returns Promise<string> - Transcripción del audio
+ *
+ * @example
+ * ```typescript
+ * const transcription = await transcribeAudio(audioBuffer, 'audio/aac', 'audio.aac');
+ * // Resultado: "Hola, quería comentarte que hoy me duele un poco la rodilla..."
+ * ```
+ */
+const transcribeAudio = (fileBuffer, mimetype, filename) => __awaiter(void 0, void 0, void 0, function* () {
+    let wav;
+    let duration;
+    try {
+        ({ wav, duration } = yield convertToWav16k(fileBuffer, filename));
+    }
+    catch (error) {
+        // ⭐ Sin ffmpeg no se puede elegir motor: se manda el original tal cual, como se hacía antes
+        // eslint-disable-next-line no-console
+        console.error('[transcribeAudio] No se pudo convertir el audio, se envía sin normalizar:', (error === null || error === void 0 ? void 0 : error.message) || error);
+        (0, index_2.err)(null, null, error, null);
+        const mime = (mimetype || '').toLowerCase().split(';')[0].trim();
+        return (yield recognizeSpeech(fileBuffer, AUDIO_ENCODING_MAP[mime] || 'MP3')) || '[Audio sin contenido reconocible]';
+    }
+    if (duration > 0 && duration <= SYNC_MAX_SECONDS) {
+        const transcription = yield recognizeSpeech(wav, 'LINEAR16');
+        if (transcription)
+            return transcription;
+    }
+    const fromModel = yield transcribeWithModel(wav);
+    if (fromModel) {
+        return duration > TRANSCRIPTION_MAX_SECONDS
+            ? `${fromModel} (Solo se transcribieron los primeros ${Math.round(TRANSCRIPTION_MAX_SECONDS / 60)} minutos.)`
+            : fromModel;
+    }
+    return '[Audio sin contenido reconocible]';
+});
+exports.transcribeAudio = transcribeAudio;
+/**
+ * Transcribe un WAV que ya viene en el formato que espera Speech-to-Text
+ * (PCM 16 bits, mono, 16 kHz) y dura menos de 55 segundos. Lo usa el análisis de vídeo,
+ * que extrae la pista así y ya la recorta.
+ *
+ * @param wavBuffer - Buffer WAV mono 16 kHz de menos de 55 segundos
+ * @returns Promise<string> - Transcripción del audio
+ */
+const transcribeWav16k = (wavBuffer) => __awaiter(void 0, void 0, void 0, function* () {
+    const transcription = (yield recognizeSpeech(wavBuffer, 'LINEAR16')) || (yield transcribeWithModel(wavBuffer));
+    return transcription || '[Audio sin contenido reconocible]';
+});
+exports.transcribeWav16k = transcribeWav16k;

package/lib/cjs/mediaProcessing/documents.js

@@ -0,0 +1,225 @@
+"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 });
+exports.MAX_MODEL_FILE_BYTES = exports.formatBytes = exports.looksLikeText = exports.decodeTextBuffer = exports.describeOpaqueFile = exports.describeTextFile = exports.describePdf = void 0;
+const index_1 = require("../prompt/index");
+const index_2 = require("../err/index");
+// ✅ Límite de tamaño para mandar un documento entero al modelo (por encima, solo ficha)
+const MAX_MODEL_FILE_BYTES = 15 * 1024 * 1024;
+exports.MAX_MODEL_FILE_BYTES = MAX_MODEL_FILE_BYTES;
+// ✅ Cuánto texto plano se le pasa al modelo (~10k tokens); el resto se recorta
+const MAX_TEXT_CHARS = 40000;
+// ✅ Por debajo de este tamaño, el texto se guarda tal cual en vez de resumirlo
+const VERBATIM_TEXT_CHARS = 2000;
+const PDF_DESCRIPTION_PROMPT = `Resume este documento en un solo párrafo continuo, sin introducciones ni listas.
+Si es contenido deportivo o de salud (informe médico, prueba de esfuerzo, analítica, plan de entrenamiento, inscripción a una carrera, factura de material, resultados, etc.), indica de qué tipo de documento se trata y extrae los datos concretos que importan para entender el estado o el entrenamiento del atleta: fechas, diagnósticos, valores medidos con sus unidades, distancias, tiempos, recomendaciones y restricciones.
+Si NO es deportivo, resume su contenido de forma general pero útil para entender el contexto de la conversación.
+Devuelve ÚNICAMENTE el resumen en español, sin comentarios adicionales. Máximo 400 palabras.`;
+const TEXT_SUMMARY_PROMPT = `Resume el contenido de este archivo en un solo párrafo continuo, sin introducciones ni listas.
+Indica de qué tipo de archivo se trata y extrae los datos concretos que importan para entender el estado o el entrenamiento del atleta: fechas, distancias, tiempos, ritmos, frecuencias cardíacas, desniveles, valores medidos con sus unidades.
+Si el archivo es una traza GPS o un registro de actividad, resume el recorrido y sus métricas agregadas en vez de enumerar puntos.
+Devuelve ÚNICAMENTE el resumen en español, sin comentarios adicionales. Máximo 300 palabras.`;
+// ✅ Nombres legibles para los tipos que no se pueden abrir, para que la ficha diga algo útil
+const MIME_LABELS = {
+    'application/zip': 'archivo comprimido ZIP',
+    'application/x-zip-compressed': 'archivo comprimido ZIP',
+    'application/x-rar-compressed': 'archivo comprimido RAR',
+    'application/x-7z-compressed': 'archivo comprimido 7z',
+    'application/gzip': 'archivo comprimido GZIP',
+    'application/msword': 'documento de Word (.doc)',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'documento de Word (.docx)',
+    'application/vnd.ms-excel': 'hoja de cálculo de Excel (.xls)',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'hoja de cálculo de Excel (.xlsx)',
+    'application/vnd.ms-powerpoint': 'presentación de PowerPoint (.ppt)',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'presentación de PowerPoint (.pptx)',
+    'application/vnd.oasis.opendocument.text': 'documento OpenDocument',
+    'application/vnd.ant.fit': 'archivo de actividad FIT del reloj',
+    'application/octet-stream': 'archivo binario',
+    'text/vcard': 'contacto (vCard)',
+    'text/x-vcard': 'contacto (vCard)',
+};
+/**
+ * Formatea un tamaño en bytes de forma legible en español (1024 → "1 KB")
+ *
+ * @param bytes - Tamaño en bytes
+ * @returns Tamaño legible con unidad
+ */
+const formatBytes = (bytes) => {
+    if (!bytes || bytes < 1024)
+        return `${bytes || 0} B`;
+    const units = ['KB', 'MB', 'GB'];
+    let value = bytes / 1024;
+    let unitIdx = 0;
+    while (value >= 1024 && unitIdx < units.length - 1) {
+        value /= 1024;
+        unitIdx++;
+    }
+    return `${value.toFixed(1).replace('.', ',').replace(',0', '')} ${units[unitIdx]}`;
+};
+exports.formatBytes = formatBytes;
+/**
+ * Heurística para saber si un buffer es texto plano legible.
+ * Útil cuando el cliente manda un .gpx o un .csv como 'application/octet-stream'.
+ *
+ * @param fileBuffer - Buffer del archivo
+ * @returns true si los primeros KB parecen texto UTF-8
+ */
+const looksLikeText = (fileBuffer) => {
+    const sample = fileBuffer.subarray(0, 4096);
+    if (!sample.length)
+        return false;
+    let printable = 0;
+    for (const byte of sample) {
+        if (byte === 0)
+            return false; // ⭐ un byte nulo descarta texto plano
+        // Imprimibles ASCII + tabulador/salto de línea/retorno, o cualquier byte alto (UTF-8 multibyte)
+        if (byte >= 32 || byte === 9 || byte === 10 || byte === 13)
+            printable++;
+    }
+    return printable / sample.length > 0.9;
+};
+exports.looksLikeText = looksLikeText;
+/**
+ * Decodifica un buffer de texto respetando su BOM.
+ *
+ * Importa porque los .txt y .csv guardados como "Unicode" desde el Bloc de notas o Excel vienen
+ * en UTF-16: leerlos como UTF-8 intercala bytes nulos, y Postgres rechaza el carácter nulo en una
+ * columna text, así que el UPDATE de FILE TEXT fallaría (en silencio, porque query() se traga el
+ * error) y el adjunto se quedaría sin texto para siempre.
+ *
+ * @param fileBuffer - Buffer del archivo
+ * @returns Contenido decodificado
+ */
+const decodeTextBuffer = (fileBuffer) => {
+    // UTF-16 LE
+    if (fileBuffer.length >= 2 && fileBuffer[0] === 0xff && fileBuffer[1] === 0xfe) {
+        return fileBuffer.subarray(2).toString('utf16le');
+    }
+    // UTF-16 BE: Node solo sabe leer LE, así que se le da la vuelta a cada par de bytes
+    if (fileBuffer.length >= 2 && fileBuffer[0] === 0xfe && fileBuffer[1] === 0xff) {
+        const body = Buffer.from(fileBuffer.subarray(2, fileBuffer.length - ((fileBuffer.length - 2) % 2)));
+        body.swap16();
+        return body.toString('utf16le');
+    }
+    // BOM UTF-8
+    if (fileBuffer.length >= 3 && fileBuffer[0] === 0xef && fileBuffer[1] === 0xbb && fileBuffer[2] === 0xbf) {
+        return fileBuffer.subarray(3).toString('utf8');
+    }
+    return fileBuffer.toString('utf8');
+};
+exports.decodeTextBuffer = decodeTextBuffer;
+/**
+ * Genera un resumen de un PDF mandándoselo entero al modelo, que lo lee de forma nativa
+ *
+ * @param fileBuffer - Buffer del PDF
+ * @param filename - Nombre original del archivo (ayuda al modelo a contextualizar)
+ * @returns Promise<string> - Resumen del documento
+ *
+ * @example
+ * ```typescript
+ * const summary = await describePdf(pdfBuffer, 'informe-traumatologo.pdf');
+ * // Resultado: "Informe de traumatología del 12/03 con diagnóstico de fascitis plantar..."
+ * ```
+ */
+const describePdf = (fileBuffer, filename) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { text } = yield (0, index_1.generateText)({
+            model: (0, index_1.createGoogleModel)('PRO'),
+            messages: [
+                {
+                    role: 'user',
+                    content: [
+                        { type: 'file', data: fileBuffer, mediaType: 'application/pdf', filename: filename || 'documento.pdf' },
+                        { type: 'text', text: PDF_DESCRIPTION_PROMPT },
+                    ],
+                },
+            ],
+        });
+        return text || '[Documento no analizable]';
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('[describePdf] Error:', (error === null || error === void 0 ? void 0 : error.message) || error);
+        (0, index_2.err)(null, null, error, null);
+        return '[Error al analizar documento]';
+    }
+});
+exports.describePdf = describePdf;
+/**
+ * Extrae el contenido de un archivo de texto (txt, csv, gpx, json, xml...).
+ * Los archivos cortos se guardan literales; los largos se resumen con el modelo.
+ *
+ * @param fileBuffer - Buffer del archivo
+ * @param filename - Nombre original del archivo
+ * @returns Promise<string> - Contenido literal o resumen
+ *
+ * @example
+ * ```typescript
+ * const content = await describeTextFile(gpxBuffer, 'ruta-domingo.gpx');
+ * // Resultado: "Traza GPS de una carrera de 12,4 km con 340 m de desnivel..."
+ * ```
+ */
+const describeTextFile = (fileBuffer, filename) => __awaiter(void 0, void 0, void 0, function* () {
+    const content = decodeTextBuffer(fileBuffer).trim();
+    if (!content)
+        return '[Archivo de texto vacío]';
+    // ⭐ Si cabe entero y es corto, no gastamos una llamada al modelo
+    if (content.length <= VERBATIM_TEXT_CHARS) {
+        return filename ? `Contenido de ${filename}: ${content}` : content;
+    }
+    const truncated = content.slice(0, MAX_TEXT_CHARS);
+    const wasTruncated = content.length > MAX_TEXT_CHARS;
+    try {
+        const { text } = yield (0, index_1.generateText)({
+            model: (0, index_1.createGoogleModel)('PRO'),
+            prompt: `${TEXT_SUMMARY_PROMPT}
+
+Nombre del archivo: ${filename || 'desconocido'}
+${wasTruncated ? `(Contenido recortado a los primeros ${MAX_TEXT_CHARS} caracteres de ${content.length}.)` : ''}
+
+--- CONTENIDO ---
+${truncated}`,
+        });
+        return text || '[Archivo de texto no analizable]';
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('[describeTextFile] Error:', (error === null || error === void 0 ? void 0 : error.message) || error);
+        (0, index_2.err)(null, null, error, null);
+        // ⭐ Si el modelo falla, al menos guardamos el principio del archivo
+        return `Contenido de ${filename || 'archivo de texto'} (recortado): ${content.slice(0, VERBATIM_TEXT_CHARS)}`;
+    }
+});
+exports.describeTextFile = describeTextFile;
+/**
+ * Ficha determinista para los archivos cuyo contenido no se puede extraer
+ * (comprimidos, binarios propietarios, ofimática antigua...).
+ *
+ * No llama a ningún modelo: su valor es que FILE TEXT nunca se quede a NULL, de forma
+ * que el entrenador sabe que hay un adjunto y de qué tipo, en vez de quedarse bloqueado.
+ *
+ * @param mimetype - Tipo MIME del archivo
+ * @param filename - Nombre original del archivo
+ * @param size - Tamaño en bytes
+ * @returns Ficha del archivo en español
+ *
+ * @example
+ * ```typescript
+ * describeOpaqueFile('application/zip', 'fotos.zip', 2515000);
+ * // "[Archivo adjunto: fotos.zip (archivo comprimido ZIP, 2,4 MB). No se puede leer su contenido automáticamente.]"
+ * ```
+ */
+const describeOpaqueFile = (mimetype, filename, size) => {
+    const label = MIME_LABELS[mimetype] || mimetype || 'tipo desconocido';
+    const name = filename || 'sin nombre';
+    return `[Archivo adjunto: ${name} (${label}, ${formatBytes(size || 0)}). No se puede leer su contenido automáticamente.]`;
+};
+exports.describeOpaqueFile = describeOpaqueFile;

package/lib/cjs/mediaProcessing/ffmpegUtils.js

@@ -0,0 +1,107 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPEECH_SAMPLE_RATE = exports.FFMPEG_TIMEOUT_MS = exports.withTempDir = exports.probeMedia = exports.runFfmpeg = exports.ffmpeg = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+exports.ffmpeg = fluent_ffmpeg_1.default;
+const ffmpeg_static_1 = __importDefault(require("ffmpeg-static"));
+const ffprobe_static_1 = __importDefault(require("ffprobe-static"));
+fluent_ffmpeg_1.default.setFfmpegPath(ffmpeg_static_1.default);
+fluent_ffmpeg_1.default.setFfprobePath(ffprobe_static_1.default.path);
+// ✅ Techo por si ffmpeg se cuelga: sin él la promesa nunca se resuelve, el finally no llega
+// a borrar el temporal (que en Cloud Run vive en RAM) y el adjunto se queda sin FILE TEXT
+const FFMPEG_TIMEOUT_MS = 120000;
+exports.FFMPEG_TIMEOUT_MS = FFMPEG_TIMEOUT_MS;
+// ✅ Formato que espera Speech-to-Text: WAV PCM 16 bits, mono, 16 kHz
+const SPEECH_SAMPLE_RATE = 16000;
+exports.SPEECH_SAMPLE_RATE = SPEECH_SAMPLE_RATE;
+/**
+ * Ejecuta un comando de ffmpeg como promesa, matándolo si se pasa del tiempo máximo
+ *
+ * @param command - Comando de fluent-ffmpeg ya configurado
+ * @param label - Etiqueta para el mensaje de error
+ */
+const runFfmpeg = (command, label) => new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (fn) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        fn();
+    };
+    const timer = setTimeout(() => {
+        finish(() => {
+            try {
+                command.kill('SIGKILL');
+            }
+            catch (_a) {
+                // el proceso ya no está; da igual
+            }
+            reject(new Error(`${label}: ffmpeg superó ${FFMPEG_TIMEOUT_MS / 1000}s`));
+        });
+    }, FFMPEG_TIMEOUT_MS);
+    command.on('end', () => finish(resolve)).on('error', (error) => finish(() => reject(error))).run();
+});
+exports.runFfmpeg = runFfmpeg;
+/**
+ * Lee duración y pistas disponibles de un archivo multimedia con ffprobe
+ *
+ * @param inputPath - Ruta del archivo en disco
+ * @returns Duración en segundos y si tiene pista de vídeo y de audio
+ */
+const probeMedia = (inputPath) => new Promise((resolve, reject) => {
+    // ⭐ Si ffprobe no contesta, la promesa debe rechazar igualmente para que el finally
+    // llegue a borrar el temporal
+    const timer = setTimeout(() => reject(new Error(`ffprobe superó ${FFMPEG_TIMEOUT_MS / 1000}s`)), FFMPEG_TIMEOUT_MS);
+    fluent_ffmpeg_1.default.ffprobe(inputPath, (error, data) => {
+        var _a;
+        clearTimeout(timer);
+        if (error)
+            return reject(error);
+        const streams = (data === null || data === void 0 ? void 0 : data.streams) || [];
+        resolve({
+            duration: Number((_a = data === null || data === void 0 ? void 0 : data.format) === null || _a === void 0 ? void 0 : _a.duration) || 0,
+            hasAudio: streams.some((stream) => stream.codec_type === 'audio'),
+            hasVideo: streams.some((stream) => stream.codec_type === 'video'),
+        });
+    });
+});
+exports.probeMedia = probeMedia;
+/**
+ * Crea un directorio temporal, ejecuta el trabajo y lo borra pase lo que pase.
+ * En Cloud Run el temporal vive en RAM, así que dejarlo sin borrar cuesta memoria.
+ *
+ * @param work - Función que recibe la ruta del directorio temporal
+ * @returns Lo que devuelva `work`
+ */
+// eslint-disable-next-line no-unused-vars -- el nombre del parámetro es obligatorio en un tipo función
+const withTempDir = (work) => __awaiter(void 0, void 0, void 0, function* () {
+    const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'rp-media-'));
+    try {
+        return yield work(dir);
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        }
+        catch (_a) {
+            // El temporal se queda; no merece romper el procesado
+        }
+    }
+});
+exports.withTempDir = withTempDir;

package/lib/cjs/mediaProcessing/image.js

@@ -0,0 +1,59 @@
+"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 });
+exports.IMAGE_DESCRIPTION_PROMPT = exports.describeImage = void 0;
+const index_1 = require("../prompt/index");
+const index_2 = require("../err/index");
+// ✅ PROMPT PARA DESCRIPCIÓN DE IMÁGENES
+const IMAGE_DESCRIPTION_PROMPT = `Describe esta imagen de forma directa y completa en un solo párrafo continuo, sin introducciones ni listas.
+Si la imagen es de contenido deportivo (captura de Garmin/Strava/reloj deportivo, foto de lesión/dolor, gráfica de entrenamiento, selfie deportivo, foto de equipamiento, datos de entrenamiento, etc.), incluye el tipo de imagen, los datos relevantes si es una captura (ritmo, distancia, frecuencia cardíaca, zonas, etc.), y cualquier contexto útil para entender el estado del atleta o su entrenamiento.
+Si la imagen NO es deportiva, describe su contenido de forma general pero útil para entender el contexto de la conversación.
+Devuelve ÚNICAMENTE la descripción en español, sin comentarios adicionales ni formato de lista. Máximo 300 palabras.`;
+exports.IMAGE_DESCRIPTION_PROMPT = IMAGE_DESCRIPTION_PROMPT;
+/**
+ * Genera una descripción de una imagen usando el modelo de visión (Vercel AI SDK)
+ * Contextualizada para una aplicación de fitness/entrenamiento
+ *
+ * @param fileBuffer - Buffer del archivo de imagen
+ * @param mimetype - Tipo MIME del archivo (ej: 'image/jpeg', 'image/png')
+ * @param promptOverride - Prompt alternativo (ej: para fotogramas extraídos de un vídeo)
+ * @returns Promise<string> - Descripción de la imagen
+ *
+ * @example
+ * ```typescript
+ * const description = await describeImage(imageBuffer, 'image/jpeg');
+ * // Resultado: "Captura de Garmin Connect mostrando un entrenamiento de 10km..."
+ * ```
+ */
+const describeImage = (fileBuffer, mimetype, promptOverride) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { text } = yield (0, index_1.generateText)({
+            model: (0, index_1.createGoogleModel)('PRO'),
+            messages: [
+                {
+                    role: 'user',
+                    content: [
+                        { type: 'file', data: fileBuffer, mediaType: mimetype },
+                        { type: 'text', text: promptOverride || IMAGE_DESCRIPTION_PROMPT },
+                    ],
+                },
+            ],
+        });
+        return text || '[Imagen no analizable]';
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('[describeImage] Error:', (error === null || error === void 0 ? void 0 : error.message) || error);
+        (0, index_2.err)(null, null, error, null);
+        return '[Error al describir imagen]';
+    }
+});
+exports.describeImage = describeImage;