soft_usite/pkg/models/umind_tool.go

package models

import (
	"encoding/json"
	"fmt"

	"github.com/sujit-baniya/fiber-boilerplate/app"
	"gorm.io/gorm"
)

// UmindHerramientaMax es el máximo de tools activas por tenant — acota el
// tamaño del prompt (cada tool declarada se manda entera al modelo en cada
// mensaje) y la superficie de webhooks que un tenant puede disparar.
const UmindHerramientaMax = 10

// UmindHerramientaParametro describe un parámetro que el modelo debe
// completar al invocar la tool. Es un JSON Schema simplificado (solo tipos
// primitivos) para que el staff lo pueda armar desde un formulario sin
// escribir JSON a mano.
type UmindHerramientaParametro struct {
	Nombre      string `json:"nombre"`
	Tipo        string `json:"tipo"` // string | number | boolean
	Descripcion string `json:"descripcion"`
	Requerido   bool   `json:"requerido"`
}

// UmindHerramienta es una tool custom de un tenant: cuando el agente decide
// usarla, se hace un POST a URL con los argumentos que decidió el modelo. El
// valor de AuthHeaderValorEnc viaja cifrado en reposo (ver
// pkg/services/umind_secrets.go) porque es un secreto de terceros que hay
// que poder recuperar tal cual para reenviarlo, a diferencia de una
// contraseña propia que solo necesitamos poder verificar.
type UmindHerramienta struct {
	gorm.Model
	TenantID           uint   `json:"tenant_id" gorm:"column:tenant_id;index;not null"`
	Nombre             string `json:"nombre" gorm:"column:nombre;size:64;not null"` // identificador de function-calling, ej: "consultar_stock"
	Descripcion        string `json:"descripcion" gorm:"column:descripcion;type:text;not null"`
	ParametrosJSON     string `json:"parametros_json" gorm:"column:parametros_json;type:text"` // []UmindHerramientaParametro
	URL                string `json:"url" gorm:"column:url;type:text;not null"`
	AuthHeaderNombre   string `json:"auth_header_nombre" gorm:"column:auth_header_nombre;size:100"` // ej: "Authorization", opcional
	AuthHeaderValorEnc string `json:"-" gorm:"column:auth_header_valor_enc;type:text"`
	Activa             bool   `json:"activa" gorm:"column:activa;default:true"`
}

func (UmindHerramienta) TableName() string { return "umind_herramientas" }

func ParametrosToJSON(p []UmindHerramientaParametro) (string, error) {
	b, err := json.Marshal(p)
	if err != nil {
		return "", err
	}
	return string(b), nil
}

func ParametrosFromJSON(s string) ([]UmindHerramientaParametro, error) {
	if s == "" {
		return nil, nil
	}
	var p []UmindHerramientaParametro
	if err := json.Unmarshal([]byte(s), &p); err != nil {
		return nil, err
	}
	return p, nil
}

func CreateUmindHerramienta(h *UmindHerramienta) error {
	var activas int64
	if err := app.Http.Database.DB.Model(&UmindHerramienta{}).
		Where("tenant_id = ? AND activa = ?", h.TenantID, true).Count(&activas).Error; err != nil {
		return err
	}
	if activas >= UmindHerramientaMax {
		return fmt.Errorf("este tenant ya tiene el máximo de %d tools activas", UmindHerramientaMax)
	}
	return app.Http.Database.DB.Create(h).Error
}

func GetUmindHerramientasByTenant(tenantID uint) ([]UmindHerramienta, error) {
	var items []UmindHerramienta
	err := app.Http.Database.DB.Where("tenant_id = ?", tenantID).Order("id DESC").Find(&items).Error
	return items, err
}

// GetUmindHerramientasActivas retorna las tools activas del tenant, para
// armar el toolset del agente en cada mensaje.
func GetUmindHerramientasActivas(tenantID uint) ([]UmindHerramienta, error) {
	var items []UmindHerramienta
	err := app.Http.Database.DB.Where("tenant_id = ? AND activa = ?", tenantID, true).Find(&items).Error
	return items, err
}

func GetUmindHerramientaByID(id uint) (*UmindHerramienta, error) {
	var h UmindHerramienta
	if err := app.Http.Database.DB.First(&h, id).Error; err != nil {
		return nil, err
	}
	return &h, nil
}

// GetUmindHerramientaByNombre resuelve una tool por nombre dentro del
// tenant — así arma la llamada real cuando el modelo pide ejecutar
// "consultar_stock", por ejemplo.
func GetUmindHerramientaByNombre(tenantID uint, nombre string) (*UmindHerramienta, error) {
	var h UmindHerramienta
	err := app.Http.Database.DB.Where("tenant_id = ? AND nombre = ? AND activa = ?", tenantID, nombre, true).First(&h).Error
	if err != nil {
		return nil, err
	}
	return &h, nil
}

func UpdateUmindHerramienta(id uint, updates map[string]interface{}) error {
	return app.Http.Database.DB.Model(&UmindHerramienta{}).Where("id = ?", id).Updates(updates).Error
}

func DeleteUmindHerramienta(id uint) error {
	return app.Http.Database.DB.Delete(&UmindHerramienta{}, id).Error
}