feat: OCR y Whisper como herramientas opcionales por canal en uMind

Cada canal (Telegram/WhatsApp) de un agente ahora puede activar, de forma independiente, que los audios entrantes se transcriban con el Whisper ASR propio y que a las imágenes entrantes se les extraiga texto con el servicio OCR propio, antes de pasarle el mensaje al agente. Antes esos mensajes se ignoraban en silencio. - UmindCanal gana usar_whisper_audio/usar_ocr_imagenes (default off). - WhatsApp: se descarga el media vía Graph API (resolución de URL + fetch con el mismo access_token del canal) y se enruta a Whisper/OCR según type. - Telegram: se descarga el archivo vía getFile + CDN de archivos del bot, mismo enrutamiento para voice/audio/photo. - Panel: checkboxes en el alta de canal y toggles inline por canal ya creado, en la tab Canales del agente. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-13 10:35:48 -05:00
parent d493d6dee6
commit 84506a98e2
10 changed files with 332 additions and 47 deletions
@@ -28,6 +28,11 @@ type UmindCanal struct {
 	WebhookSecret   string `json:"webhook_secret" gorm:"column:webhook_secret;uniqueIndex;size:40;not null"`
 	CredencialesEnc string `json:"-" gorm:"column:credenciales_enc;type:text"`
 	UltimoError     string `json:"ultimo_error" gorm:"column:ultimo_error;type:text"`
+	// Si están activos, los mensajes de voz/audio e imágenes que llegan por
+	// este canal se transcriben (Whisper) o se les extrae el texto (OCR)
+	// antes de pasarlos al agente, en vez de ignorarse.
+	UsarWhisperAudio bool `json:"usar_whisper_audio" gorm:"column:usar_whisper_audio;default:false"`
+	UsarOcrImagenes  bool `json:"usar_ocr_imagenes" gorm:"column:usar_ocr_imagenes;default:false"`
 }

 func (UmindCanal) TableName() string { return "umind_canales" }
@@ -1,9 +1,12 @@
 package services

 import (
+	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"net/url"
+	"strings"

 	"github.com/sujit-baniya/fiber-boilerplate/pkg/models"
 )
@@ -37,6 +40,92 @@ func ProcesarMensajeTelegramUmind(canal *models.UmindCanal, chatID int64, texto
 	return (&TelegramService{}).SendMessageWithToken(chatID, respuesta, botToken)
 }

+// ProcesarMediaTelegramUmind atiende notas de voz/audio y fotos entrantes:
+// si el canal tiene la conversión habilitada, descarga el archivo vía
+// getFile, lo pasa por Whisper/OCR y responde igual que un mensaje de texto.
+// Si no está habilitada, se ignora en silencio.
+func ProcesarMediaTelegramUmind(canal *models.UmindCanal, chatID int64, fileID, tipo string) error {
+	agente, err := models.GetUmindAgenteByID(canal.AgenteID)
+	if err != nil || !agente.Activo {
+		return fmt.Errorf("agente no encontrado o inactivo: %w", err)
+	}
+	credenciales, err := DescifrarCredencialesCanal(canal.CredencialesEnc)
+	if err != nil {
+		return fmt.Errorf("credenciales del canal corruptas: %w", err)
+	}
+	botToken := credenciales["bot_token"]
+	if botToken == "" {
+		return fmt.Errorf("el canal no tiene bot_token configurado")
+	}
+
+	var texto string
+	switch tipo {
+	case "audio":
+		if !canal.UsarWhisperAudio {
+			return nil
+		}
+		data, err := descargarArchivoTelegram(botToken, fileID)
+		if err != nil {
+			return fmt.Errorf("no se pudo descargar el audio de Telegram: %w", err)
+		}
+		texto, err = TranscribirAudioSelfHosted(data, "audio.ogg")
+		if err != nil {
+			return err
+		}
+	case "image":
+		if !canal.UsarOcrImagenes {
+			return nil
+		}
+		data, err := descargarArchivoTelegram(botToken, fileID)
+		if err != nil {
+			return fmt.Errorf("no se pudo descargar la imagen de Telegram: %w", err)
+		}
+		texto, err = ExtraerTextoOCR(data, "image/jpeg")
+		if err != nil {
+			return err
+		}
+	default:
+		return nil
+	}
+	if strings.TrimSpace(texto) == "" {
+		return fmt.Errorf("no se pudo extraer texto del %s recibido", tipo)
+	}
+
+	sessionID := fmt.Sprintf("tg:%d", chatID)
+	respuesta, err := ProcessWidgetMessage(agente, sessionID, texto)
+	if err != nil {
+		return fmt.Errorf("error del agente: %w", err)
+	}
+	return (&TelegramService{}).SendMessageWithToken(chatID, respuesta, botToken)
+}
+
+// descargarArchivoTelegram resuelve el file_path de un file_id (getFile) y
+// descarga el archivo desde el CDN de archivos de Telegram.
+func descargarArchivoTelegram(botToken, fileID string) ([]byte, error) {
+	getFileURL := fmt.Sprintf("https://api.telegram.org/bot%s/getFile?file_id=%s", botToken, url.QueryEscape(fileID))
+	resp, err := telegramHTTPClient.Get(getFileURL)
+	if err != nil {
+		return nil, fmt.Errorf("no se pudo consultar getFile: %w", err)
+	}
+	defer resp.Body.Close()
+	var out struct {
+		Result struct {
+			FilePath string `json:"file_path"`
+		} `json:"result"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil || out.Result.FilePath == "" {
+		return nil, fmt.Errorf("respuesta inesperada de getFile")
+	}
+
+	fileURL := fmt.Sprintf("https://api.telegram.org/file/bot%s/%s", botToken, out.Result.FilePath)
+	resp2, err := telegramHTTPClient.Get(fileURL)
+	if err != nil {
+		return nil, fmt.Errorf("no se pudo descargar el archivo: %w", err)
+	}
+	defer resp2.Body.Close()
+	return io.ReadAll(io.LimitReader(resp2.Body, 20*1024*1024))
+}
+
 // RegistrarWebhookTelegram le dice a Telegram a qué URL mandar los updates
 // del bot — se llama una vez al crear el canal (o al reconfigurar el token).
 func RegistrarWebhookTelegram(botToken, webhookURL string) error {
@@ -7,6 +7,7 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"strings"
 	"time"
@@ -44,11 +45,67 @@ func ProcesarMensajeWhatsAppUmind(canal *models.UmindCanal, from, texto string)
 	if err != nil || !agente.Activo {
 		return fmt.Errorf("agente no encontrado o inactivo: %w", err)
 	}
-
 	credenciales, err := DescifrarCredencialesCanal(canal.CredencialesEnc)
 	if err != nil {
 		return fmt.Errorf("credenciales del canal corruptas: %w", err)
 	}
+	return responderWhatsApp(agente, credenciales, from, texto)
+}
+
+// ProcesarMediaWhatsAppUmind atiende audios/imágenes entrantes: si el canal
+// tiene la conversión habilitada, descarga el archivo desde la Graph API,
+// lo pasa por Whisper/OCR y sigue el mismo camino que un mensaje de texto.
+// Si la conversión no está habilitada para ese tipo, se ignora en silencio
+// (mismo comportamiento de antes de que existiera esta función).
+func ProcesarMediaWhatsAppUmind(canal *models.UmindCanal, from, mediaID, tipo string) error {
+	agente, err := models.GetUmindAgenteByID(canal.AgenteID)
+	if err != nil || !agente.Activo {
+		return fmt.Errorf("agente no encontrado o inactivo: %w", err)
+	}
+	credenciales, err := DescifrarCredencialesCanal(canal.CredencialesEnc)
+	if err != nil {
+		return fmt.Errorf("credenciales del canal corruptas: %w", err)
+	}
+
+	var texto string
+	switch tipo {
+	case "audio":
+		if !canal.UsarWhisperAudio {
+			return nil
+		}
+		data, _, err := descargarMediaWhatsApp(credenciales["access_token"], mediaID)
+		if err != nil {
+			return fmt.Errorf("no se pudo descargar el audio de WhatsApp: %w", err)
+		}
+		texto, err = TranscribirAudioSelfHosted(data, "audio.ogg")
+		if err != nil {
+			return err
+		}
+	case "image":
+		if !canal.UsarOcrImagenes {
+			return nil
+		}
+		data, mimeType, err := descargarMediaWhatsApp(credenciales["access_token"], mediaID)
+		if err != nil {
+			return fmt.Errorf("no se pudo descargar la imagen de WhatsApp: %w", err)
+		}
+		if mimeType == "" {
+			mimeType = "image/jpeg"
+		}
+		texto, err = ExtraerTextoOCR(data, mimeType)
+		if err != nil {
+			return err
+		}
+	default:
+		return nil
+	}
+	if strings.TrimSpace(texto) == "" {
+		return fmt.Errorf("no se pudo extraer texto del %s recibido", tipo)
+	}
+	return responderWhatsApp(agente, credenciales, from, texto)
+}
+
+func responderWhatsApp(agente *models.UmindAgente, credenciales map[string]string, from, texto string) error {
 	phoneNumberID := credenciales["phone_number_id"]
 	accessToken := credenciales["access_token"]
 	if phoneNumberID == "" || accessToken == "" {
@@ -64,6 +121,49 @@ func ProcesarMensajeWhatsAppUmind(canal *models.UmindCanal, from, texto string)
 	return enviarMensajeWhatsApp(phoneNumberID, accessToken, from, respuesta)
 }

+// descargarMediaWhatsApp resuelve la URL temporal de un media_id (paso 1) y
+// descarga el archivo (paso 2) — la Graph API de WhatsApp requiere ambos, y
+// las dos llamadas necesitan el mismo Bearer token del canal.
+func descargarMediaWhatsApp(accessToken, mediaID string) ([]byte, string, error) {
+	if accessToken == "" || mediaID == "" {
+		return nil, "", fmt.Errorf("access_token/media_id vacíos")
+	}
+	metaURL := fmt.Sprintf("https://graph.facebook.com/%s/%s", whatsappGraphAPIVersion, mediaID)
+	req, err := http.NewRequest(http.MethodGet, metaURL, nil)
+	if err != nil {
+		return nil, "", err
+	}
+	req.Header.Set("Authorization", "Bearer "+accessToken)
+	resp, err := umindWhatsappHTTPClient.Do(req)
+	if err != nil {
+		return nil, "", fmt.Errorf("no se pudo consultar el media en WhatsApp: %w", err)
+	}
+	defer resp.Body.Close()
+	var meta struct {
+		URL      string `json:"url"`
+		MimeType string `json:"mime_type"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&meta); err != nil || meta.URL == "" {
+		return nil, "", fmt.Errorf("respuesta inesperada al consultar el media de WhatsApp")
+	}
+
+	req2, err := http.NewRequest(http.MethodGet, meta.URL, nil)
+	if err != nil {
+		return nil, "", err
+	}
+	req2.Header.Set("Authorization", "Bearer "+accessToken)
+	resp2, err := umindWhatsappHTTPClient.Do(req2)
+	if err != nil {
+		return nil, "", fmt.Errorf("no se pudo descargar el archivo de WhatsApp: %w", err)
+	}
+	defer resp2.Body.Close()
+	data, err := io.ReadAll(io.LimitReader(resp2.Body, 20*1024*1024))
+	if err != nil {
+		return nil, "", err
+	}
+	return data, meta.MimeType, nil
+}
+
 func enviarMensajeWhatsApp(phoneNumberID, accessToken, to, texto string) error {
 	payload := map[string]interface{}{
 		"messaging_product": "whatsapp",