pbesa 4.0.28__tar.gz → 4.0.29__tar.gz

{pbesa-4.0.28 → pbesa-4.0.29}/PKG-INFO

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

pbesa-4.0.29/pbesa/celulas/celula_conversador.py

@@ -0,0 +1,60 @@
+import logging
+
+SYSTEM_PROMPT = """
+[ROL Y OBJETIVO]
+Eres un asistente conversacional amigable y servicial llamado Justino especializado en las funciones jurisdiccionales de las entidades SIC, DIMAR, DNDA, SFC, SNS, ICA y Supersociedades. 
+
+Tu objetivo es analizar el historial de la conversación y las reglas para identificar qué información falta y luego formular una pregunta clara y natural al usuario.
+
+[DEFINICIONES DE REFERENCIA]
+%s
+
+[REGLAS]
+%s
+
+[HISTORIAL DE LA CONVERSACIÓN]
+%s
+
+[TAREA]
+Sigue un proceso de Chain of Thought para construir tu respuesta. Primero, razona sobre la información que tienes y la que te falta. Luego, escribe la pregunta final para el usuario.
+
+[FORMATO DE RESPUESTA]
+**Chain of Thought:**
+1. **Información disponible:** (Resume los datos que el usuario ya ha proporcionado).
+2. **Información requerida por las reglas:** (Enumera los datos que necesitas para validar todas las reglas).
+3. **Análisis de carencias:** (Compara la información disponible con la requerida para identificar exactamente qué falta).
+4. **Formulación de la pregunta:** (Diseña una pregunta amigable y precisa basada en el análisis de carencias).
+
+[RESTRICCIONES]
+- No debes proporcionar respuestas directas o afirmaciones, solo preguntas.
+- La pregunta debe ser clara y natural, evitando tecnicismos innecesarios.
+- No debes asumir información que no esté explícitamente en el historial de la conversación.
+- Si el usario responde con una pregunta o comentario que no es relevante, debes ignorarlo y centrarte en la información que falta.
+
+"""
+
+USER_PROMPT = """
+
+**Respuesta final para el usuario:**
+(Escribe aquí únicamente la pregunta que le harás al usuario).
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, definiciones, reglas, text, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT % (definiciones, reglas, text)
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:\nDefiniciones: {definiciones}\nReglas: {reglas}\nTexto: {text}")        
+        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.28 → pbesa-4.0.29}/pbesa/celulas/celula_datos_identificables.py

@@ -31,7 +31,7 @@ Responde únicamente con:
 """
 
 # Efectua la inferencia del modelo.
-def derive(service, text, max_tkns=4096) -> any:
+def derive(service, text, max_tkns=2000) -> any:
     try:
         tmp_work_memory = []
         user_prompt  = """

pbesa-4.0.29/pbesa/celulas/celula_evaluador.py

@@ -0,0 +1,59 @@
+import logging
+
+SYSTEM_PROMPT = """
+[TAREA]
+Eres un sistema de clasificación experto. Tu única tarea es evaluar la siguiente conversación contra las reglas proporcionadas y responder con una sola palabra que resuma el estado.
+
+[DEFINICIONES]
+%s
+
+[REGLAS]
+%s
+
+[INSTRUCCIONES DE RESPUESTA]
+Responde únicamente con una de estas tres opciones:
+- APLICA: Si la conversación contiene TODA la información necesaria para verificar las reglas, y AL MENOS UNA de las regla se cumple.
+- RECHAZO: Si la conversación contiene información que viola explícitamente a TODAS las reglas.
+- PREGUNTAR: Si en la conversación FALTA información esencial para poder verificar una o más reglas.
+
+[EJEMPLOS]
+Reglas: 
+- Ser mayor de 18
+- Vivir en México.
+
+Texto del usuario:
+- Texto: "Tengo 20 años y vivo en la Ciudad de México." -> APLICA
+- Texto: "Tengo 12 y vivo en Argentina." -> RECHAZO
+- Texto: "Soy de México." -> APLICA
+- Texto: "Soy hombre." -> PREGUNTAR
+
+"""
+
+USER_PROMPT = """
+
+[EVALUACIÓN ACTUAL]
+Conversación: 
+"%s"
+
+Respuesta:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, definiciones, reglas, text, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT % (definiciones, reglas)
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:\nDefiniciones: {definiciones}\nReglas: {reglas}\nTexto: {text}")        
+        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.29/pbesa/celulas/celula_extraccion.py

@@ -0,0 +1,51 @@
+import logging
+
+SYSTEM_PROMPT = """
+Eres un extractor de datos estructurados.  
+Tu tarea es leer la **Descripción** (lo que se le pide al usuario) y la **Respuesta del usuario** y devolver **únicamente** un objeto JSON válido con las claves indicadas en la descripción y los valores dados por el usuario.
+
+Reglas:
+1. Usa exactamente el texto entre comillas o negritas de la descripción como nombre de la clave en el JSON.  
+   • Ej.: si la descripción contiene **"Tipo de solicitante"**, la clave debe ser `"Tipo de solicitante"`.
+2. El valor debe ser la respuesta del usuario:
+   • Elimina saltos de línea y espacios al principio/fin.  
+   • Respeta mayúsculas/minúsculas tal cual la escribió el usuario.  
+   • Si responde varias opciones separadas (por comas, saltos de línea, “y”, etc.), devuelve una lista de cadenas.
+3. Si falta información para alguna clave, pon el valor vacío: `""`.
+4. No añadas texto extra, explicaciones ni código. Devuelve **solo** el objeto JSON.
+
+Descripción:
+\"\"\"%s\"\"\"
+
+"""
+USER_PROMPT = """
+Respuesta del usuario:
+\"\"\"%s\"\"\"
+
+Salida JSON:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, query, max_tkns=2000) -> any:
+    try:
+        description = query.get("description", "")
+        text = query.get("text", "")
+        
+        tmp_work_memory = []
+        prompt = SYSTEM_PROMPT
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT % description
+        tmp_work_memory.append({"role": "user", "content": text})
+        
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+
+        logging.info(f"[Celula][Extrac][Procesando]: {text}")        
+        logging.info(f"[Celula][Extrac][Respuesta]: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"[Celula][Extrac]: No obtener una respuesta.")
+        return res.replace("*", "").strip()
+    except Exception as e:
+        logging.error(f"[Celula][Extrac]: Error al procesar: {text}")
+        logging.error(e)
+        return None

pbesa-4.0.29/pbesa/celulas/celula_parafraseo.py

@@ -0,0 +1,56 @@
+import logging
+
+SYSTEM_PROMPT = """
+Dado el siguiente 'Conocimiento' y la 'Consulta de usuario', tu tarea es responder de manera amable y en lenguaje natural.
+
+**Conocimiento:**
+%s
+
+**Consulta de usuario:**
+%s
+
+**Importante:**
+- Es fundamental que evites responder si la consulta del usuario no se relaciona 
+con temas jurídicos, con Justifacil y las funciones jurisdiccionales de las siguientes entidades 
+colombianas: SIC, DNDA, DIMAR, SNS, SFC, ICA y Supersociedades, bajo el marco 
+legal del Código General del Proceso (Ley 1564 de 2012). Recuerda que Justifacil es 
+un sistema de información que permite adelantar tramites de estas entidades, y como tal, tiene secciones de:
+glosario, preguntas frecuentes, observatorio de justicia, etc.
+- Siempre finaliza tu respuesta invitando al usuario a hacer más consultas.
+
+**Instrucciones:**
+- Evita tutear al usuario.
+- Si la consulta del usuario no se relaciona con temas jurídicos, con Justifacil y las funciones jurisdiccionales de las siguientes entidades, inicia la respuesta con "Lo lamento, ..."
+- Tu respuesta debe basarse únicamente en el 'Conocimiento' proporcionado.
+- Tu respuesta debe ser amable y el lenguaje natural.
+- Tu respuesta debe ser clara, concisa y relevante para la consulta del usuario.
+- Evita agregar información que no esté en el 'Conocimiento'.
+- Evita agregar explicaciones innecesarias o adicionales.
+- Solo limitate a responder la consulta parafraseando el 'Conocimiento' proporcionado.
+
+"""
+
+USER_PROMPT = """
+
+Respuesta:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, conocimiento, consulta, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT % (conocimiento, consulta)
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:\Conocimiento: {conocimiento}\nConsulta: {consulta}")        
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = consulta
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {consulta}")
+        logging.error(e)
+        return None

pbesa-4.0.29/pbesa/celulas/celula_respuesta.py

@@ -0,0 +1,58 @@
+import logging
+
+SYSTEM_PROMPT = """
+[TAREA]
+Eres un sistema de clasificación experto. Tu única tarea es evaluar la siguiente conversación contra las reglas proporcionadas y responder con la justificación de RECHAZO.
+
+[DEFINICIONES]
+%s
+
+[REGLAS]
+%s
+
+[INSTRUCCIONES DE RESPUESTA]
+Responde únicamente bajo las siguientes condiciones:
+- Con la justificación de RECHAZO si la conversación no cumple con las reglas argumentando por qué no aplica.
+- Con la justificación de RECHAZO parafrasea el concepto de reglas por el de marco normativo.
+- Si la conversación cumple AL MENOS UNA de las reglas responde unicamente: SIN_COMENTARIOS.
+
+[EJEMPLOS]
+Reglas: 
+- Ser mayor de 18
+- Vivir en México.
+
+Texto del usuario:
+- Texto: "Tengo 20 años y vivo en la Ciudad de México." -> SIN_COMENTARIOS
+- Texto: "Tengo 12 y vivo en Argentina." -> RECHAZO: "No cumple con la regla de ser mayor de 18 y vivir en México."
+- Texto: "Soy de México." -> SIN_COMENTARIOS
+
+"""
+
+USER_PROMPT = """
+
+[EVALUACIÓN ACTUAL]
+Conversación: 
+"%s"
+
+Respuesta:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, definiciones, reglas, text, max_tkns=2000) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = SYSTEM_PROMPT % (definiciones, reglas)
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        prompt = USER_PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        logging.info(f"\n\n\nProcesando:\nDefiniciones: {definiciones}\nReglas: {reglas}\nTexto: {text}")        
+        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.28 → pbesa-4.0.29}/pbesa/celulas/celula_saludos.py

@@ -21,7 +21,7 @@ Ejemplos:
 """
 
 # Efectua la inferencia del modelo.
-def derive(service, text, max_tkns=4096) -> any:
+def derive(service, text, max_tkns=2000) -> any:
     try:
         logging.info(f"Procesando: {text}")
         tmp_work_memory = []

{pbesa-4.0.28 → pbesa-4.0.29}/pbesa/cognitive.py

@@ -27,7 +27,8 @@ from pbesa.social.dialog import (
     DialogState, imprimir_grafo, recorrer_interacciones, extraer_diccionario_nodos, 
     ActionNode, DeclarativeNode, GotoNode)
 from .celulas import (celula_casos, celula_consultas, celula_saludos, celula_datos_identificables,
-                      celula_generar_documento, celula_expertos, celula_pertinencia)
+                      celula_generar_documento, celula_expertos, celula_pertinencia, celula_extraccion,
+                      celula_evaluador, celula_respuesta, celula_conversador, celula_parafraseo)
 from pbesa.social.prompts import ANALIZER_PROMPT, CLASSIFICATION_PROMPT, DERIVE_PROMPT, RECOVERY_PROMPT, ADAPT_PROMPT, SINTETIZER_PROMPT
 
 # --------------------------------------------------------
@@ -544,6 +545,7 @@ class Dialog(ABC):
         self.__work_memory:list = []
         self.__meta_work_memory:list = []
         self.__system_work_memory:list = []
+        self.__evaluate_work_memory:list = []
         # Define role
         self.__agent_metadata = "Undefined"
         # Define role
@@ -563,6 +565,7 @@ class Dialog(ABC):
         self.__deep_limit = 9
         # Define knowledge
         self.knowledge = None
+        self.special_knowledge = None
         # Define point recovery
         self.__recovery = {
             "owner": "Web",
@@ -571,7 +574,7 @@ class Dialog(ABC):
             "counter": 0
         }
         # Define recovery message
-        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."
+        self.RECOVERY_MSG = "Puede darme más detalles o reformular. O si desea puede recibir asistencia humana vía correo electrónico al ministerio@minjsuticia.gov.co"
         # Define vertices list
         self.__vertices = []
         # Define visited nodes
@@ -580,6 +583,10 @@ class Dialog(ABC):
         self.__attemps = 1
         self.__analaizer_work_memory:list = []
         self.__sintetizer_work_memory:list = []
+        # Define production rules
+        self.definitions = None
+        self.rules = None
+        self.__q_attemps = 0
 
     def setup_world(self):
         """ Set up model method """
@@ -901,7 +908,7 @@ class Dialog(ABC):
         eva += 1 if es_consulta else 0
         eva += 1 if es_caso else 0
         
-        msg = "Lo lamento, no puedo ayudarle con su consulta. Dado que no está relacionada con los servicios que presta Justifacil."
+        msg = "No puedo ayudarle con su consulta. Dado que no está relacionada con los servicios que presta Justifacil."
 
         # Verifica los casos
         if eva > 0 and eva < 3:
@@ -943,7 +950,7 @@ class Dialog(ABC):
 
             # Casos ambiguos con consulta y caso
             elif es_consulta and es_caso and not es_saludo:
-                res = "Lo lamento, puede confirmar si ¿Desea que le ayude con una Consulta o una Demanda?"
+                res = "¿Desea que le ayude con una consulta o una demanda?"
             else:
                 ambiguedad = True
                 per_res = celula_pertinencia.derive(self.__ai_service, query, max_tkns=10)
@@ -1352,6 +1359,22 @@ class Dialog(ABC):
             else:
                 self.notify(session['session_id'], "efectuando inferencia...")
                 logging.info(f"[Inferencia]:[node]: {node.text}")
+
+                if "Evaluar: produccion-" in node.text:
+                    data = {"text": ""}
+                    for item in reversed(self.__work_memory):
+                        if item['role'] == 'user':
+                            data['text'] = item['content']
+                            break
+                    self.notify(session['session_id'], f"continuando díalogo paso a usuario")                    
+                    res = self.evaluate(session, data['text'])                    
+                    if 'Lo lamento' in res:
+                        logging.info(f"------------RESET---------------")
+                        self.reset()
+                        self.notify(session['session_id'], "STOP")
+                        return "Web", DialogState.START, res, "Web"                    
+                    return owner, node.performative, res, owner
+
                 self.__work_memory.append({"role": "system", "content": node.text})
                 logging.info(f"=> !!!!: {query}")
                 logging.info("-----")
@@ -1369,8 +1392,14 @@ class Dialog(ABC):
                     # Verifica recursion
                     if not self.chek_user_interaction(node.children):
                         if self.__visited_nodes > 3:
+                            self.__visited_nodes = 0
                             logging.info(f"[Inferencia]:[Recursion]: Deep limit")
-                            return self.recovery(session['session_id'], "Lo lamento, no puedo responder en este momento")
+                            #return self.recovery(session['session_id'], "Lo lamento, no puedo responder en este momento")
+                            logging.info(f"------------RESET---------------")
+                            self.reset()
+                            self.notify(session['session_id'], "STOP")
+                            res = "Lo lamento, no puedo responder en este momento. Intentelo más tarde desde el inicio."
+                            return "Web", DialogState.START, res, "Web"
                         logging.info(f"[Inferencia]:[Recursion]:[Performativa]: {node.performative}")
                         self.notify(session['session_id'], "efectuando inferencia en profundidad")
                         #return self.do_transition(session, owner, node, query)
@@ -1398,6 +1427,21 @@ class Dialog(ABC):
         :return: str
         """
         self.knowledge = knowledge
+    
+    def set_special_knowledge(self, knowledge) -> str:
+        """ Set knowledge method
+        :param query: query
+        :return: str
+        """
+        self.special_knowledge = knowledge
+
+    def set_production_knowledge(self, definitions, rules) -> str:
+        """ Set knowledge method
+        :param query: query
+        :return: str
+        """
+        self.definitions = definitions
+        self.rules = rules
 
     def adapt(self, data, profile) -> any:
         """ Adapt method
@@ -1439,6 +1483,95 @@ class Dialog(ABC):
             logging.error(e)
             return None
 
+    def command_derive(self, command, query, max_tkns=2000) -> str | None:
+        # data_extraction_cel
+        if command == "IDENTIFICAR_VALORES":
+            return celula_datos_identificables.derive(self.__ai_service, query, max_tkns=max_tkns)
+        if command == "EXTRAER_DATOS":
+            return celula_extraccion.derive(self.__ai_service, query, max_tkns=max_tkns)
+        if command == "VERIFICAR_CONSULTA":
+            return celula_consultas.derive(self.__ai_service, query, max_tkns=10)
+        if command == "EVALUAR_CONSULTA":
+            return celula_parafraseo.derive(self.__ai_service, self.special_knowledge, query, max_tkns=max_tkns)
+        return None
+    
+    def parse_conversation(self) -> str:
+        res = ""
+        if self.__evaluate_work_memory and len(self.__evaluate_work_memory) > 0:
+            for item in self.__evaluate_work_memory:
+                if item['role'] == 'user':
+                    res += f"usuario:\n{item['content']}\n"
+                elif item['role'] == 'assistant':
+                    res += f"asistente:\n{item['content']}\n"
+        else:
+            logging.warning("No hay memoria de trabajo para parsear la conversación.")
+        return res.strip()
+
+    def evaluate(self, session, query) -> str:
+        try:
+            self.__evaluate_work_memory.append({"role": "user", "content": query})            
+            # Evalua la conversación
+            logging.info(f"Evaluando consulta: {query}")
+            self.notify(session, "evaluando consulta...")
+            for _ in range(3):
+                logging.info(f"Intento de evaluación: {_+1}")
+                conversacion = self.parse_conversation()
+                result = celula_evaluador.derive(self.__ai_service, self.definitions, self.rules, conversacion, max_tkns=10)
+                if result and not result == "":                           
+                    if "APLICA" in result:
+                        self.notify(session, "aplicando consulta...")
+                        self.__evaluate_work_memory = []
+                        return "Considero que el caso aplica. ¿Desea continuar con el trámite? Responda Sí o No."
+                    elif "RECHAZO" in result:
+                        self.notify(session, "rechazando consulta...")
+                        res_rechazo = celula_respuesta.derive(self.__ai_service, self.definitions, self.rules, conversacion, max_tkns=164)
+                        if res_rechazo and not res_rechazo == "":
+                            if "SIN_COMENTARIOS" in res_rechazo:
+                                continue
+                            self.__evaluate_work_memory = []
+                            return res_rechazo
+                        self.__evaluate_work_memory = []
+                        return "Considero que el caso no aplica. ¿Desea continuar con el trámite? Responda Sí o No."
+                    elif "PREGUNTAR" in result:
+                        self.__q_attemps += 1
+                        if self.__q_attemps > 3:
+                            logging.error("Se alcanzó el límite de intentos de pregunta.")
+                            self.__q_attemps = 0
+                            self.__evaluate_work_memory = []
+                            return "Considero que el caso no aplica. ¿Desea continuar con el trámite? Responda Sí o No."
+                        self.notify(session, "preguntando al usuario...")
+                        conversacion = self.parse_conversation()
+                        res = celula_conversador.derive(self.__ai_service, self.definitions, self.rules, conversacion, max_tkns=200)
+                        if not res and res == "":                            
+                            res = "Lo lamento, no puedo responder en este momento."
+                        res = res.replace("*", " ").strip()
+                        if 'Formulación de la pregunta' in res:
+                            res = res.split('Formulación de la pregunta: ')[1].strip()
+                        elif 'Chain of Thought' in res:
+                            self.__q_attemps = 0
+                            return "Considero que el caso no aplica. ¿Desea continuar con el trámite? Responda Sí o No."
+                        self.__evaluate_work_memory.append({"role": "assistant", "content": res})
+                        return res
+                    else:
+                        logging.warning(f"Resultado inesperado: {result}")
+                        self.__evaluate_work_memory = []
+                        return "Lo lamento, no puedo responder en este momento."
+                else:
+                    logging.warning(f"Resultado de evaluación vacío o nulo: {result}")
+                    if _ < 2:
+                        logging.info("Reintentando evaluación...")
+                        continue
+                    else:
+                        self.__evaluate_work_memory = []
+                        logging.error("No se pudo evaluar la consulta después de 3 intentos.")
+                        return "Lo lamento, no puedo responder en este momento."
+            self.__evaluate_work_memory = []
+            return "Lo lamento, no puedo responder en este momento."
+        except Exception as e:
+            logging.error(f"Error al evaluar la consulta: {query}")
+            logging.error(e)
+            return "Lo lamento, no puedo responder en este momento."
+        
 # --------------------------------------------------------
 # Define Special Dispatch
 # --------------------------------------------------------
@@ -1507,6 +1640,7 @@ class SpecialDispatch():
         Response.
         @param data Event data 
         """
+        response = None
         if data and not data['dto']['session']['team'] == "Funcionalidades":
             logging.info("Despachando por descripcion...")
             options = ""
@@ -1550,7 +1684,7 @@ class SpecialDispatch():
                     break
             if not select_agent:
                 logging.info("=> No se seleccionó ningun agente")
-            return select_agent
+            return select_agent, response
         else:
             logging.info("Despachando por descripcion...")
             options = ""
@@ -1654,4 +1788,4 @@ class SpecialDispatch():
 
             self.kusto_close()
             self.__meta_work_memory = []
-            return select_agent
+            return select_agent, response

{pbesa-4.0.28 → pbesa-4.0.29}/pbesa/social/dispatcher_team.py

@@ -543,6 +543,7 @@ class LLMDispatcherDelegate(Action):
         @param data Event data 
         """
         try:
+            response = None
             logging.info('Assign to agent...')
             session_id = data['dto']['session']['session_id'] if 'session' in data['dto'] else None
             agent_list = self.agent.get_agent_list()
@@ -580,7 +581,7 @@ class LLMDispatcherDelegate(Action):
                 select_agent = self.manual_selection(data['dto'])
                 # Check if agent was selected
                 if not select_agent:
-                    select_agent = self.agent.special_dispatch(data)
+                    select_agent, response = self.agent.special_dispatch(data)
                 # Check if agent was selected        
                 if select_agent:
                     logging.info(f'The agent {select_agent} will be assigned')
@@ -597,6 +598,8 @@ class LLMDispatcherDelegate(Action):
                                     'gateway': data['gateway'],
                                     'dtoList': []
                                 }
+                                if response:
+                                    data['dto']['rq_query'] = response
                                 self.adm.send_event(ag, 'task', data['dto'])
                                 self.__rewier[ag] = 0
                                 exit = True

{pbesa-4.0.28 → pbesa-4.0.29}/pbesa.egg-info/PKG-INFO

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

{pbesa-4.0.28 → pbesa-4.0.29}/pbesa.egg-info/SOURCES.txt

@@ -73,11 +73,16 @@ pbesa.egg-info/top_level.txt
 pbesa/celulas/__init__.py
 pbesa/celulas/celula_casos.py
 pbesa/celulas/celula_consultas.py
+pbesa/celulas/celula_conversador.py
 pbesa/celulas/celula_datos_identificables.py
+pbesa/celulas/celula_evaluador.py
 pbesa/celulas/celula_expertos.py
+pbesa/celulas/celula_extraccion.py
 pbesa/celulas/celula_generar_documento.py
+pbesa/celulas/celula_parafraseo.py
 pbesa/celulas/celula_pertinencia.py
 pbesa/celulas/celula_preguntas.py
+pbesa/celulas/celula_respuesta.py
 pbesa/celulas/celula_saludos.py
 pbesa/celulas/celula_simulador_ciudadano.py
 pbesa/celulas/data_extraction_cel.py

{pbesa-4.0.28 → pbesa-4.0.29}/setup.py

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