pbesa 4.0.7__tar.gz → 4.0.9__tar.gz

{pbesa-4.0.7 → pbesa-4.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pbesa
-Version: 4.0.7
+Version: 4.0.9
 License-File: LICENSE
 License-File: LICENSE.txt
 Requires-Dist: pymongo==4.6.3

{pbesa-4.0.7 → pbesa-4.0.9}/pbesa/__init__.py

@@ -2,4 +2,5 @@ from .kernel import *
 from .social import *
 from .remote import *
 from .cognitive import *
-from .models import *
+from .models import *
+from .celulas import *

pbesa-4.0.9/pbesa/celulas/__init__.py

@@ -0,0 +1,3 @@
+from .celula_casos import *
+from .celula_consultas import *
+from .celula_saludos import *

pbesa-4.0.9/pbesa/celulas/celula_casos.py

@@ -0,0 +1,60 @@
+import logging
+
+PROMPT = """
+Eres un clasificador que identifica si un texto corresponde a una queja o demanda que debe ser radicada ante un ente de control del Estado colombiano.
+
+Responde únicamente con:
+- QUEJA_DEMANDA
+- NO_QUEJA_DEMANDA
+
+**Definición de QUEJA_DEMANDA**: El texto describe hechos, situaciones o infracciones por parte de una empresa, entidad o persona que pueden requerir la intervención de entidades como:
+
+- Superintendencia de Sociedades  
+- Superintendencia de Industria y Comercio  
+- Supersalud  
+- Dirección General Marítima  
+- Superintendencia Financiera de Colombia  
+- Instituto Colombiano Agropecuario (ICA)  
+- Dirección Nacional de Derecho de Autor  
+- Autoridades de protección al consumidor  
+- Casos de competencia desleal o propiedad industrial
+
+**NO_QUEJA_DEMANDA**: El texto no describe una inconformidad, infracción ni intención de denuncia. Puede ser una pregunta, saludo, comentario o solicitud de orientación.
+
+---
+
+**Ejemplos:**
+
+1. "Quiero presentar una denuncia contra la empresa Colmédica por incumplimiento en la prestación de servicios de salud." → QUEJA_DEMANDA  
+2. "La empresa Navemar ha incurrido en prácticas marítimas irregulares y omisión de protocolos de seguridad." → QUEJA_DEMANDA  
+3. "Explícame cómo radicar una queja" → NO_QUEJA_DEMANDA  
+4. "Hola, buen día" → NO_QUEJA_DEMANDA  
+5. "Evacol S.A.S. está copiando diseños registrados de Crocs Inc. y aprovechando su reputación." → QUEJA_DEMANDA  
+6. "¿Dónde puedo radicar una demanda?" → NO_QUEJA_DEMANDA  
+7. "El supermercado está vendiendo productos vencidos que afectaron mi salud." → QUEJA_DEMANDA  
+8. "Necesito orientación sobre propiedad industrial" → NO_QUEJA_DEMANDA
+
+---
+
+Texto: "%s"
+
+Clasificación:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, text) -> any:
+    try:
+        logging.info(f"Procesando: {text}")
+        tmp_work_memory = []
+        prompt  = PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory)
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

pbesa-4.0.9/pbesa/celulas/celula_consultas.py

@@ -0,0 +1,45 @@
+import logging
+
+PROMPT = """
+Eres un clasificador de intenciones. Tu tarea es analizar el siguiente texto y determinar si representa una **pregunta** o **solicitud de información**.
+
+Responde solo con:
+- PREGUNTA_O_SOLICITUD
+- NO_PREGUNTA
+
+**Definiciones:**
+- **PREGUNTA_O_SOLICITUD**: El texto expresa claramente una intención de obtener información, ya sea mediante una pregunta directa ("¿Qué hora es?") o una solicitud indirecta ("Quisiera saber el estado del pedido").
+- **NO_PREGUNTA**: El texto no busca información. Puede ser un saludo, afirmación, comentario, instrucción, etc.
+
+**Ejemplos:**
+1. "¿Cuál es el horario de atención?" → PREGUNTA_O_SOLICITUD  
+2. "Necesito saber cómo ingresar al sistema" → PREGUNTA_O_SOLICITUD  
+3. "Hola, buen día" → NO_PREGUNTA  
+4. "Ya envié el informe" → NO_PREGUNTA  
+5. "¿Me puedes confirmar la dirección?" → PREGUNTA_O_SOLICITUD  
+6. "Saludos" → NO_PREGUNTA  
+7. "Explícame cómo hacerlo" → PREGUNTA_O_SOLICITUD  
+8. "No tengo acceso" → NO_PREGUNTA
+
+Texto: "%s"
+
+Clasificación:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, text) -> any:
+    try:
+        logging.info(f"Procesando: {text}")
+        tmp_work_memory = []
+        prompt  = PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory)
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

pbesa-4.0.9/pbesa/celulas/celula_saludos.py

@@ -0,0 +1,41 @@
+import logging
+
+PROMPT = """
+Eres un clasificador de saludos. Tu tarea es analizar el siguiente texto y determinar si es un saludo.
+
+Responde únicamente con una de estas opciones:
+- SALUDO
+- NO_SALUDO
+
+**Definición de saludo**: Un saludo es cualquier forma de cortesía o expresión inicial utilizada para iniciar una conversación. Esto incluye "Hola", "Buenos días", "Qué tal", "Ey", "Saludos", etc., incluso si van acompañados de una pregunta o comentario breve. No se consideran saludos las preguntas o afirmaciones que van directo al contenido sin intención de cortesía.
+
+Ejemplos:
+- "Hola, ¿cómo estás?" → SALUDO
+- "Buenos días, equipo" → SALUDO
+- "¿Cómo se hace este análisis?" → NO_SALUDO
+- "Ey, qué más" → SALUDO
+- "Necesito ayuda con el código" → NO_SALUDO
+- "Saludos" → SALUDO
+
+Texto: "%s"
+
+Clasificación:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, text) -> any:
+    try:
+        logging.info(f"Procesando: {text}")
+        tmp_work_memory = []
+        prompt  = PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory)
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

pbesa-4.0.9/pbesa/celulas/web.py

@@ -0,0 +1,49 @@
+import logging
+
+PROMPT = """
+Eres un clasificador de intenciones de texto. Debes analizar el texto proporcionado y clasificarlo en una de las siguientes categorías:
+
+1. SALUDO: El texto contiene un saludo inicial como "hola", "buen día", "buenas tardes", "qué tal", "saludos", etc.
+2. PREGUNTA_O_SOLICITUD: El texto busca obtener información, ya sea mediante una pregunta directa ("¿Qué hora es?") o una solicitud indirecta ("Necesito saber cómo ingresar").
+3. QUEJA_DEMANDA: El texto describe una inconformidad o denuncia que debe ser radicada ante un ente de control estatal, como la Superintendencia de Industria y Comercio, Supersalud, ICA, Dirección Nacional de Derecho de Autor, etc.
+4. NINGUNA: El texto no encaja en ninguna de las categorías anteriores.
+
+Responde solo con una de estas cuatro categorías, en mayúsculas.
+
+---
+
+**Ejemplos:**
+
+- "Hola, buen día" → SALUDO  
+- "¿Dónde puedo radicar una queja?" → PREGUNTA_O_SOLICITUD  
+- "Quiero demandar a una empresa que está usando mi marca registrada" → QUEJA_DEMANDA  
+- "Ya envié el documento que solicitaste" → NINGUNA  
+- "Explícame cómo hacerlo" → PREGUNTA_O_SOLICITUD  
+- "Evacol S.A.S. está copiando diseños de Crocs Inc. para confundir a los consumidores" → QUEJA_DEMANDA  
+- "Saludos cordiales" → SALUDO  
+- "Estoy confirmando la reunión de mañana" → NINGUNA
+
+---
+
+Texto: "%s"
+
+Clasificación:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, text) -> any:
+    try:
+        logging.info(f"Procesando: {text}")
+        tmp_work_memory = []
+        prompt  = PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory)
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

{pbesa-4.0.7 → pbesa-4.0.9}/pbesa/cognitive.py

@@ -17,14 +17,16 @@ import uuid
 import json
 import logging
 import traceback
+from .mas import Adm
 from pydantic import BaseModel
 from typing import List, Optional
 from abc import ABC, abstractmethod
+from .celulas import celula_casos, celula_consultas, celula_saludos
 from pbesa.models import AIFoundry, AzureInference, GPTService, ServiceProvider
 from pbesa.social.dialog import (
     DialogState, imprimir_grafo, recorrer_interacciones, extraer_diccionario_nodos, 
     ActionNode, DeclarativeNode, GotoNode) #, TerminalNode
-from pbesa.social.prompts import CLASSIFICATION_PROMPT, DERIVE_PROMPT, RECOVERY_PROMPT
+from pbesa.social.prompts import CLASSIFICATION_PROMPT, DERIVE_PROMPT, RECOVERY_PROMPT, ADAPT_PROMPT
 # --------------------------------------------------------
 # Define DTOs
 # --------------------------------------------------------
@@ -481,7 +483,7 @@ class Dialog(ABC):
             "counter": 0
         }
         # Define recovery message
-        self.RECOVERY_MSG = "Lo lamento, puedes darme más detalles o reformular"
+        self.RECOVERY_MSG = "Lo lamento, puedes darme más detalles o reformular. O puedes recibir asistencia humana vía correo electrónico al atencion@minjsuticia.com.co o al Whatsapp 321456987."
         # Define vertices list
         self.__vertices = []
         # Define visited nodes
@@ -586,6 +588,9 @@ class Dialog(ABC):
             "performative": DialogState.START,
             "counter": 0
         }
+        # Reset visited nodes
+        self.__visited_nodes = 0
+        self.__vertices = []
 
     def notify(self, text):
         try:
@@ -611,6 +616,14 @@ class Dialog(ABC):
             canales = self.state['canales']
             canal = canales.get(team)
             if session_flag:
+                # Actualiza la sesion
+                session_manager = self.state['session_manager']
+                session_manager.update_session(self.state['session_id'], {
+                    'team': team,
+                    'owner': team,
+                    'performative': DialogState.START,
+                })
+                # Construye el mensaje
                 dto = {
                     "data": {
                         'text': data,
@@ -690,57 +703,122 @@ class Dialog(ABC):
             }
             logging.info(f"Recovery attemps: {self.__recovery["counter"]}")
             # Verifica si se ha alcanzado el límite de recuperación
-            if self.__recovery['counter'] <= 3 and self.__visited_nodes < 5:
-                self.notify("identificando concepto...")
-                #--------------------------
-                # Verifica que exista la performativa
-                if not dialog_state in self.__dfa:
-                    self.notify("concepto no encontrado")
-                    return self.recovery(query)
-                # Performativa encontrada
-                children = None
-                self.notify("concepto encontrado")
-                #--------------------------
-                # Obtiene los hijos del nodo
-                node = self.__dfa[dialog_state]
-                if not isinstance(node, list):
-                    children = node.children
-                else:
-                    # Es una lista de nodos
-                    children = node
-                #--------------------------
-                # Flujo de selección
+            if self.__recovery['counter'] <= 3 and self.__visited_nodes <= 3:                    
                 select_node = None
-                self.notify("flujo de seleccion...")
-                if children and len(children)> 1:
-                    logging.info(f"--> Más de una opción.")
-                    options = ""
-                    cont = 1
-                    for item in children:
-                        options += f"{cont}) {item.text}\n"
-                        cont += 1
-                    prompt = CLASSIFICATION_PROMPT % (query, options)
-                    logging.info(f"Query: {query},\n Options:\n{options}")
-                    self.__meta_work_memory.append({"role": "user", "content": prompt})
-                    res = self.__ai_service.generate(self.__meta_work_memory)
-                    logging.info(f"Thought: {res}")
-                    self.__meta_work_memory = []
-                    res = self.get_text(res)
-                    for option in range(1, cont):
-                        if str(option) in res:
-                            select_node = children[option-1]
-                            logging.info(f"Select node: {select_node.text}")
-                            break
-                    if not select_node:
-                        logging.info("=> No se seleccionó ninguna opción")
+                #------------------------------
+                # Flujode de excepcion
+                #------------------------------
+                if owner == "Web" and dialog_state == DialogState.START:
+                    logging.info(f"TOPTQ: {owner} - {dialog_state} - {team_source} - {query}")
+                    logging.info(f"------------Flujo de excepcion---------------")
+                    self.notify("identificando intencion...")
+                    # Obtiene discriminadores
+                    caso = celula_casos.derive(self.__ai_service, query)
+                    consulta = celula_consultas.derive(self.__ai_service, query)
+                    saludo = celula_saludos.derive(self.__ai_service, query)
+                    # Verifica si es un saludo
+                    es_saludo = saludo == "SALUDO" and consulta == "NO_PREGUNTA" and caso == "NO_QUEJA_DEMANDA"
+                    es_consulta = consulta == "PREGUNTA_O_SOLICITUD" and caso == "NO_QUEJA_DEMANDA" and saludo == "NO_SALUDO"
+                    es_caso = caso == "QUEJA_DEMANDA" and consulta == "NO_PREGUNTA" and saludo == "NO_SALUDO"
+                    # Verifica los casos
+                    dicriminador = "Ninguno"
+                    if es_saludo or es_consulta or es_caso:
+                        logging.info("Sin ambiguedad")
+                        self.notify("discriminando...")
+                        if es_saludo:
+                            dicriminador = "saluda"
+                        elif es_consulta:
+                            dicriminador = "consulta"
+                        elif es_caso:
+                            dicriminador = "caso"
+                    else:
+                        logging.info("Hay ambiguedad")
+                        self.notify("identificando ambiguedad...")
+                        if saludo == "SALUDO":
+                            dicriminador = "saluda"
+                        else:
+                            dicriminador = "consulta"
+                    #--------------------------
+                    # Obtiene los hijos del 
+                    # nodo
+                    children = None
+                    node = self.__dfa[dialog_state]
+                    if not isinstance(node, list):
+                        children = node.children
+                    else:
+                        # Es una lista de nodos
+                        children = node
+                    #--------------------------
+                    # Flujo de selección                
+                    self.notify("flujo de seleccion...")
+                    if children and len(children)> 1:
+                        logging.info(f"--> Más de una opción.")
+                        options = ""
+                        cont = 1
+                        for item in children:
+                            if dicriminador in item.text:
+                                select_node = item
+                                break    
+                else:                    
+                    #------------------------------
+                    # Fulo normal
+                    #------------------------------    
+                    logging.info("Flujo normal")    
+                    self.notify("identificando concepto...")
+                    #----------------------
+                    # Verifica que exista 
+                    # la performativa
+                    if not dialog_state in self.__dfa:
+                        self.notify("concepto no encontrado")
+                        return self.recovery(query)
+                    # Performativa encontrada
+                    children = None
+                    self.notify("concepto encontrado")
+                    #----------------------
+                    # Obtiene los hijos del
+                    #  nodo
+                    node = self.__dfa[dialog_state]
+                    if not isinstance(node, list):
+                        children = node.children
+                    else:
+                        # Es una lista de nodos
+                        children = node
+                    #----------------------
+                    # Flujo de selección
+                    select_node = None
+                    self.notify("flujo de seleccion...")
+                    if children and len(children)> 1:
+                        logging.info(f"--> Más de una opción.")
+                        options = ""
+                        cont = 1
+                        for item in children:
+                            options += f"{cont}) {item.text}\n"
+                            cont += 1
+                        prompt = CLASSIFICATION_PROMPT % (query, options)
+                        logging.info(f"Query: {query},\n Options:\n{options}")
+                        self.__meta_work_memory.append({"role": "user", "content": prompt})
+                        res = self.__ai_service.generate(self.__meta_work_memory)
+                        logging.info(f"Thought: {res}")
+                        self.__meta_work_memory = []
+                        res = self.get_text(res)
+                        for option in range(1, cont):
+                            if str(option) in res:
+                                select_node = children[option-1]
+                                logging.info(f"Select node: {select_node.text}")
+                                break
+                        if not select_node:
+                            logging.info("=> No se seleccionó ninguna opción")
+                            select_node = children[0]
+                            logging.info(f"=> Selecciona el primer nodo: {select_node.text}")               
+                    elif children and len(children) == 1:
+                        logging.info(f"--> Una opción.")
                         select_node = children[0]
-                        logging.info(f"=> Selecciona el primer nodo: {select_node.text}")               
-                elif children and len(children) == 1:
-                    logging.info(f"--> Una opción.")
-                    select_node = children[0]
-                else:
-                    logging.info("???> Es un nodo terminal o iniciador")
-                    return self.recovery(query)
+                    else:
+                        logging.info("???> Es un nodo terminal o iniciador")
+                        logging.warning(f"???> Es un nodo terminal o iniciador: {node.text}")
+                        logging.warning(f"???> Es un nodo terminal o iniciador: {node.performative}")
+                        return self.recovery(query)
+
                 #--------------------------
                 # Verifica si es un nodo
                 # que ya fue recorrido
@@ -764,7 +842,20 @@ class Dialog(ABC):
                 # Efectua transicion
                 if select_node:
                     res = select_node.text
-                    node = select_node.children[0]
+                    if select_node.children and len(select_node.children) > 0:
+                        res = select_node.children[0].text
+                        node = select_node.children[0]
+                    else:
+                        logging.info(f"-> El nodo de transición es terminal: {select_node.text}")
+                        res = select_node.text
+                        node = select_node
+                else:
+                    logging.info(f"-> !!!!!!!!!!!!!! Concepto no encontrado !!!!!!!!!!!!!!")
+                    if isinstance(node, list) and len(node) > 0:
+                        node = node[0]
+                    else:
+                        logging.info(f"-> !!!!!!!!!!!!!! Concepto no encontrado ????????????????")
+                        return self.recovery(query)
                 logging.info(f"Flujo normal: {res}")
                 self.notify(res)
                 #---------------------------
@@ -780,9 +871,12 @@ class Dialog(ABC):
                 # trabajo
                 if team_source:
                     self.__work_memory.append({"role": "user", "content": res})
+                    logging.info(f"-> Actualiza WM: {res}")
                 else:
                     self.__work_memory.append({"role": "user", "content": query})
-                    self.__work_memory.append({"role": "user", "content": res})
+                    #self.__work_memory.append({"role": "user", "content": res})
+                    logging.info(f"-> Actualiza q-WM: {query}")
+                    #logging.info(f"-> Actualiza r-WM: {res}")
                 #---------------------------
                 # Efectua inferencia
                 new_owner, new_dialog_state, res, team = self.do_transition(owner, node, query)
@@ -839,16 +933,22 @@ class Dialog(ABC):
                     if node.is_terminal:
                         logging.info(f"-> node team -> es terminal -> {node.text}")
                         self.__work_memory.append({"role": "user", "content": node.text})
-                        logging.info("-----")
-                        logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
-                        logging.info("-----")
-                        res = self.__ai_service.generate(self.__work_memory)
-                        res = self.get_text(res)
-                        self.__work_memory.append({"role": "system", "content": res})
-                        # Check if res is empty
-                        if not res or res == "":
-                            self.notify(f"no pude contactar al agente: {node.team}")
-                            return self.recovery(query)                    
+                        
+                        res = query
+                        if "consulta" in node.text.lower():
+                            logging.info(f"-> node team -> consulta: {query}")
+                        else:
+                            logging.info("-----")
+                            logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
+                            logging.info("-----")
+                            res = self.__ai_service.generate(self.__work_memory)
+                            res = self.get_text(res)
+                            self.__work_memory.append({"role": "system", "content": res})
+                            # Check if res is empty
+                            if not res or res == "":
+                                self.notify(f"no pude contactar al agente: {node.team}")
+                                return self.recovery(query)
+                                
                         self.notify(f"le envio al agente {node.team}: {res}")
                         logging.info(f"-> node team -> envia: {res}")
                         res = self.team_inquiry(node.team, res, None, True)
@@ -860,11 +960,27 @@ class Dialog(ABC):
                         else:
                             return self.recovery(query)
                     else:
+
                         logging.info("-> node team -> continua")
-                        self.__work_memory.append({"role": "user", "content": node.text})
-                        logging.info(f"-> node team -> envia: {query}")
-                        res = self.team_inquiry(node.team, query, node.tool, False)
+                        self.__work_memory.append({"role": "user", "content": node.text})   
+                        res = query
+                        if "consulta" in node.text.lower():
+                            logging.info(f"-> node team -> consulta: {query}")
+                        else:
+                            logging.info(f"-> node team -> sentencia: {node.text}")
+                            logging.info("-----")
+                            logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
+                            logging.info("-----")
+                            res = self.get_text(res)
+                            self.__work_memory.append({"role": "system", "content": res})
+                            # Check if res is empty
+                            if not res or res == "":
+                                self.notify(f"no pude contactar al agente: {node.team}")
+                                return self.recovery(query)                    
+                        self.notify(f"le envio al agente {node.team}: {res}")
+                        res = self.team_inquiry(node.team, res, node.tool, False)
                         self.notify(f"continuando con díalogo")
+
                 # Adiciona el texto al work memory
                 if res and not res == "ERROR" and not res == "":
                     logging.info(f"-> Adicion WM node team -> text: {res}")
@@ -908,8 +1024,10 @@ class Dialog(ABC):
                 self.notify(f"finalizando díalogo de inferencia")
                 logging.info(f"Tipe node: {type(node)}")
                 logging.info(f"$$$> new_owner: {owner} new_dialog_state: {new_dialog_state}")
+                #logging.info(f"------------RESET---------------")
+                #self.reset()      
                 self.notify("STOP")
-                return owner, new_dialog_state, res, owner
+                return "Web", DialogState.START, res, "Web"
             logging.info("END: do_transition")
         except Exception as e:
             traceback.print_exc()
@@ -923,4 +1041,112 @@ class Dialog(ABC):
         :param query: query
         :return: str
         """
-        self.knowledge = knowledge
+        self.knowledge = knowledge
+
+    def adapt(self, data, profile) -> any:
+        """ Adapt method
+        :param data: data
+        :return: str
+        """
+        try:
+            logging.info(f"Adaptando respuesta: {data}")
+            # Get text
+            text = ""
+            if isinstance(data, str):
+                text = data
+            elif isinstance(data, dict):
+                text = data['dto']['text'] if data and 'dto' in data and data['dto']['text'] is not None else ''
+            else:
+                raise ValueError("Respuesta mal formada")
+            # Adapt the data
+            tmp_work_memory = []
+            prompt  = ADAPT_PROMPT % (text, profile)
+            tmp_work_memory.append({"role": "user", "content": prompt})
+            res = self.__ai_service.generate(tmp_work_memory)
+            res = self.get_text(res)
+            logging.info(f"Respuesta adaptada: {res}")
+            if not res or res == "":
+                res = text
+                logging.warning(f"No se pudo adaptar la respuesta.")
+            return res
+        except Exception as e:
+            logging.error(f"Error al adaptar el dato: {data}")
+            logging.error(e)
+            return None
+
+# --------------------------------------------------------
+# Define Special Dispatch
+# --------------------------------------------------------
+
+class SpecialDispatch():
+    """ Special dispatch """
+
+    def __init__(self) -> None:
+        """ Constructor method """
+        self.model:any = None
+        self.model_conf:dict = None
+        self.__meta_work_memory:list = []
+        # Define AI service
+        self.__ai_service = None
+        self.knowledge = None
+        # Define options dictionary
+        self.__options_dict = {}
+        # Reference of ADM
+        self.adm = Adm()
+
+    def load_model(self, provider, config, ai_service=None) -> None:
+        self.__service_provider, service = define_service_provider(provider, ai_service)
+        service.setup(config)
+        self.__ai_service = service
+        # Setup options dictionary
+        agent_list = self.get_agent_list()
+        # Get the agent asocciated with the data.
+        for agent_id in agent_list:
+            agent = self.adm.get_agent(agent_id)
+            # Check if the agent is instance of Dialog
+            if isinstance(agent, Dialog):
+                # Get the role
+                role = agent.get_role()
+                self.__options_dict[agent_id] = role.description
+    
+    def get_text(self, mensaje) -> str:
+        if mensaje:
+            mensaje_limpio = mensaje.replace("<|im_start|>user<|im_sep|>", "").replace("<|im_start|>system<|im_sep|>", "") \
+                .replace("<|im_start|>", "").replace("<|im_sep|>", "").replace("<|im_end|>", "") \
+                .replace("[Usuario]: ", "").replace("[Sistema]: ", "") \
+                .replace("<|user|>", "").replace("<|system|>", "")
+            return mensaje_limpio.strip()
+        else:
+            return ""
+
+    def special_dispatch(self, data: any) -> None:
+        """ 
+        Response.
+        @param data Event data 
+        """
+        logging.info("Despachando por descripcion...")
+        options = ""
+        cont = 1
+        agent_options = {}
+        for agent, item in self.__options_dict.items():
+            agent_options[cont] = agent
+            options += f"{cont}) {item}\n"
+            cont += 1
+        query = data['dto']['text'] if data and 'dto' in data and data['dto']['text'] is not None else ''
+        prompt = CLASSIFICATION_PROMPT % (query, options)
+        logging.info(f"Query: {query},\n Options:\n{options}")
+        self.__meta_work_memory.append({"role": "user", "content": prompt})
+        res = self.__ai_service.generate(self.__meta_work_memory)
+        logging.info(f"Thought: {res}")
+        self.__meta_work_memory = []
+        res = self.get_text(res)
+        select_agent = None
+        for option in range(1, cont+1):
+            if str(option) in res:
+                select_agent = agent_options[option]
+                logging.info(f"Descripcion del agente seleccionado: {select_agent}")
+                break
+        if not select_agent:
+            logging.info("=> No se seleccionó ningun agente")
+        return select_agent
+ 

{pbesa-4.0.7 → pbesa-4.0.9}/pbesa/social/dispatcher_team.py

@@ -113,15 +113,21 @@ class ResponseAction(Action):
         """ Execute
         @param data: Data
         """
-        request = self.agent.get_request_dict()[data['source']]
-        if 'timeout' in data:
-            logging.info(f"[ResponseAction][{self.agent.id}]: Timeout ******************")
-            request['gateway'].put("TIMEOUT")
+        logging.info(f"[ResponseAction][{self.agent.id}]: Response: {data}")
+        if data['source'] in self.agent.get_request_dict():
+            request = self.agent.get_request_dict()[data['source']]
+        
+            if 'timeout' in data:
+                logging.info(f"[ResponseAction][{self.agent.id}]: Timeout ******************")
+                request['gateway'].put("TIMEOUT")
+            else:
+                request['dtoList'].append(data['result'])
+                if len(request['dtoList']) >= self.agent.get_buffer_size():
+                    self.send_response(request)
+                    self.adm.send_event(data['source'], 'timeout', {'command': 'stop'})
         else:
-            request['dtoList'].append(data['result'])
-            if len(request['dtoList']) >= self.agent.get_buffer_size():
-                self.send_response(request)
-                self.adm.send_event(data['source'], 'timeout', {'command': 'stop'})
+            logging.warning(f"[ResponseAction][{self.agent.id}]: Warning ******************")
+            logging.warning(f"[ResponseAction][{self.agent.id}]: {data}")
 
 # --------------------------------------------------------
 # Define component

{pbesa-4.0.7 → pbesa-4.0.9}/pbesa/social/prompts.py

@@ -60,5 +60,31 @@ Ahora, evalúa el siguiente caso:
 
 Texto: "%s"
 
+Respuesta:
+"""
+
+ADAPT_PROMPT = """
+Instrucciones:
+
+Eres un un asistente experto en comunicación. Recibirás un texto original y un perfil de adaptación. Tu tarea es reescribir el texto para que se alinee completamente con el estilo, tono y objetivo comunicativo del perfil.
+
+Requisitos:
+
+- No incluyas explicaciones, razonamientos ni texto adicional.
+
+Ejemplo:
+
+Texto: "Para solicitar el certificado, debe ingresar al sitio web, crear una cuenta, llenar el formulario y esperar el correo de confirmación."
+
+Perfil de adaptación: "Usaurio Autonomo - Proporcionar respuestas directas y concisas para realizar trámites rápidamente."
+
+Respuesta: Ingrese al sitio, cree su cuenta, complete el formulario y revise su correo.
+
+Ahora, evalúa el siguiente caso:
+
+Texto: "%s"
+
+Perfil de adaptación: "%s"
+
 Respuesta:
 """

{pbesa-4.0.7 → pbesa-4.0.9}/pbesa.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pbesa
-Version: 4.0.7
+Version: 4.0.9
 License-File: LICENSE
 License-File: LICENSE.txt
 Requires-Dist: pymongo==4.6.3

{pbesa-4.0.7 → pbesa-4.0.9}/pbesa.egg-info/SOURCES.txt

@@ -70,6 +70,11 @@ pbesa.egg-info/SOURCES.txt
 pbesa.egg-info/dependency_links.txt
 pbesa.egg-info/requires.txt
 pbesa.egg-info/top_level.txt
+pbesa/celulas/__init__.py
+pbesa/celulas/celula_casos.py
+pbesa/celulas/celula_consultas.py
+pbesa/celulas/celula_saludos.py
+pbesa/celulas/web.py
 pbesa/kernel/__init__.py
 pbesa/kernel/adapter.py
 pbesa/kernel/agent.py

{pbesa-4.0.7 → pbesa-4.0.9}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='pbesa',
-    version='4.0.7',
+    version='4.0.9',
     packages=find_packages(),
     install_requires=[
         'pymongo==4.6.3',