pbesa 4.0.4__tar.gz → 4.0.6__tar.gz

{pbesa-4.0.4 → pbesa-4.0.6}/PKG-INFO

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

{pbesa-4.0.4 → pbesa-4.0.6}/pbesa/cognitive.py

@@ -21,7 +21,7 @@ from typing import List, Optional
 from abc import ABC, abstractmethod
 from pbesa.models import AIFoundry, AzureInference, GPTService, ServiceProvider
 from pbesa.social.dialog import DialogState, imprimir_grafo, recorrer_interacciones, extraer_diccionario_nodos, ActionNode, DeclarativeNode#, TerminalNode
-from pbesa.social.prompts import CLASSIFICATION_PROMPT, DERIVE_PROMPT
+from pbesa.social.prompts import CLASSIFICATION_PROMPT, DERIVE_PROMPT, RECOVERY_PROMPT
 # --------------------------------------------------------
 # Define DTOs
 # --------------------------------------------------------
@@ -468,6 +468,15 @@ class Dialog(ABC):
         self.__deep_limit = 3
         # Define knowledge
         self.knowledge = None
+        # Define point recovery
+        self.__recovery = {
+            "owner": "Web",
+            "team": "Web",
+            "performative": DialogState.START,
+            "counter": 0
+        }
+        # Define recovery message
+        self.RECOVERY_MSG = "Lo lamento, puedes darme más detalles o reformular"
 
     def setup_world(self):
         """ Set up model method """
@@ -518,29 +527,29 @@ class Dialog(ABC):
         self.setup_world()
         interations = agent_metadata.role.interactions
         grafo = recorrer_interacciones(interations)
-        logging.info("")
+        logging.debug("")
         # Si el grafo es una lista de nodos, lo imprimimos cada uno
         if isinstance(grafo, list):
             for nodo in grafo:
                 imprimir_grafo(nodo)
         else:
             imprimir_grafo(grafo)
-        logging.info("")
+        logging.debug("")
         # Ejemplo de uso:
         self.__dfa = extraer_diccionario_nodos(grafo)
         # Mostrar el diccionario
         for clave, valor in self.__dfa.items():
-            logging.info(f"{clave}: {valor.text}")
-        logging.info("")
+            logging.debug(f"{clave}: {valor.text}")
+        logging.debug("")
         iniciadores = []
         for item in interations:
             for clave, valor in self.__dfa.items():
                 if valor.text == item['texto']:
                     iniciadores.append(valor)
-        logging.info("Iniciadores:")
+        logging.debug("Iniciadores:")
         for iniciador in iniciadores:
-            logging.info(iniciador.text)
-        logging.info("")
+            logging.debug(iniciador.text)
+        logging.debug("")
         # Set dialog state
         self.__dfa['start'] = iniciadores
 
@@ -561,219 +570,306 @@ class Dialog(ABC):
         self.__work_memory = []
         # Set up model
         self.setup_world()
-
-    def team_inquiry(self, team, data, operation, session_flag) -> str:
-        canales = self.state['canales']
-        canal = canales.get(team)
-        dto = None
-        if operation:
+        # Reset dialog state
+        self.__recovery = {
+            "owner": "Web",
+            "team": "Web",
+            "performative": DialogState.START,
+            "counter": 0
+        }
+
+    def notify(self, text):
+        try:
+            canales = self.state['canales']
+            canal = canales.get("Webhook")
+            session_id = self.state['session_id']
             dto = {
-                "data": {
-                    'text': data,
-                    'operation': operation
-                },
+                "session_id": session_id,
+                "text": text[0:100]
             }
-        else:
-            if session_flag:
-                logging.info(f"Session flag: {session_flag}")
-                logging.info(f"------------RESET--------------- {data}")
-                self.reset()
-                return data
-                
+            response = canal.post("notify", dto)
+            if response['status']:
+                logging.info(f"Notificación enviada: {text}")
             else:
+                logging.warning(f"Notificación no enviada: {text}")
+        except Exception as e:
+            logging.error(f"Error al enviar notificación: {text}")
+            logging.erro(f"Error: {e}")
+
+    def team_inquiry(self, team, data, operation, session_flag) -> str:
+        try:
+            dto = None
+            canales = self.state['canales']
+            canal = canales.get(team)
+            if session_flag:
                 dto = {
                     "data": {
-                        'text': data
+                        'text': data,
+                        'session_id': self.state['session_id'],
                     },
                 }
-        response = canal.post(team.lower(), dto)
-        if response['status']:
-            return response['message']['response']
-        
-        logging.info(f"------------RESET---------------")
-        self.reset()
-        return "Lo lamento, no puedo responder en este momento"
-    
+                # Evia mensaje a los agentes remotos
+                logging.info('>>>> Call remote agent: team.\n')
+                response = canal.post(team.lower(), dto)
+                if response and not response['status']:
+                    logging.error(f'No se pudo establecer la comunicación con el agente remoto')
+                    return None
+                logging.info(f'>>>> Response: {response}')
+                return response['message']['response']
+            else:
+                if operation:
+                    dto = {
+                        "data": {
+                            'text': data,
+                            'operation': operation
+                        },
+                    }
+                else:
+                    dto = {
+                        "data": {
+                            'text': data
+                        },
+                    }
+                response = canal.post(team.lower(), dto)
+                if response['status']:
+                    return response['message']['response']
+                else:
+                    return None
+            logging.info("END: team_inquiry")
+        except Exception as e:
+            logging.error(f"Error al consultar al equipo: {team}")
+            return None
+
     def get_text(self, mensaje) -> str:
-        mensaje_limpio = mensaje.replace("<|im_start|>user<|im_sep|>", "").replace("<|im_start|>system<|im_sep|>", "")
-        mensaje_limpio = mensaje_limpio.replace("<|im_start|>", "").replace("<|im_sep|>", "").replace("<|im_end|>", "")
-        mensaje_limpio = mensaje_limpio.replace("[Usuario]: ", "").replace("[Sistema]: ", "")
-        return mensaje_limpio.strip()
+        if mensaje:
+            mensaje_limpio = mensaje.replace("<|im_start|>user<|im_sep|>", "").replace("<|im_start|>system<|im_sep|>", "")
+            mensaje_limpio = mensaje_limpio.replace("<|im_start|>", "").replace("<|im_sep|>", "").replace("<|im_end|>", "")
+            mensaje_limpio = mensaje_limpio.replace("[Usuario]: ", "").replace("[Sistema]: ", "")
+            return mensaje_limpio.strip()
+        else:
+            return ""
+    
+    def recovery(self, query):
+        try:
+            prompt = RECOVERY_PROMPT % query
+            temp_work_memory = [{"role": "user", "content": prompt}]
+            res = self.__ai_service.generate(temp_work_memory)
+            res = self.get_text(res)
+            if res and not res == "":
+                return self.__recovery['owner'], self.__recovery['performative'], res, self.__recovery['team']
+            else:
+                logging.info(f"------------RESET---------------")
+                logging.info(f"Recovery from: {self.__recovery['performative']}")
+                self.reset()
+                self.notify("STOP") 
+                return "Web", DialogState.START, self.RECOVERY_MSG, "Web"
+        except Exception as e:
+            return self.RECOVERY_MSG
 
     def transition(self, owner, dialog_state, query, team_source=False) -> str:
-        logging.info(f"Transition: {owner} -> {dialog_state}, Team: {team_source}, Query: {query}")
-        text = ""
-
-        # Verifica que exista la performativa
-        if not dialog_state in self.__dfa:
-            logging.warning(f"------------Performativa no existe---------------")
-            self.reset()
-            return "Web", DialogState.START, "Lo lamento, no puedo responder en este momento", "Web"
-
-        node = self.__dfa[dialog_state]
-        if not isinstance(node, list):
-            node = node.children
-        
-        # Flujo de selección
-        if node and len(node)> 1:
-            logging.info(f"--> Más de una opción.")
-            options = ""
-            cont = 1
-            for item in node:
-                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})
-            text = self.__ai_service.generate(self.__meta_work_memory)
-            logging.info(f"Thought: {text}")
-            self.__meta_work_memory = []
-            text = self.get_text(text)
-            select_node = None
-            for option in range(1, cont):
-                if str(option) in text:
-                    select_node = node[option-1]
-                    logging.info(f"Select node: {select_node.text}")
-                    break
-            if not select_node:
-                logging.info("=> No se seleccionó ninguna opción")
-                logging.info(f"=> Node: {node}")
-                logging.info(f"=> len node: {len(node)}")
-                select_node = node[0]
-                logging.info(f"=> Selecciona el primer nodo: {select_node.text}")               
-        elif node and len(node) == 1:
-            logging.info(f"--> Una opción.")
-            select_node = node[0]
-        else:
+        try:
+            res = ""
+            logging.info(f"TOPTQ: {owner} - {dialog_state} - {team_source} - {query}")
+            # Punto de restauración
+            counter = (self.__recovery['counter'] + 1) if self.__recovery['performative'] == dialog_state else self.__recovery['counter']
+            self.__recovery = {
+                "owner": owner,
+                "team": owner,
+                "performative": dialog_state,
+                "counter": counter
+            }
+            logging.info(f"Recovery attemps: {self.__recovery["counter"]}")
+            # Verifica si se ha alcanzado el límite de recuperación
+            if self.__recovery['counter'] <= 3:
+                self.notify("identificando la performativa...")
+                # Verifica que exista la performativa
+                if not dialog_state in self.__dfa:
+                    self.notify("performativa no encontrada")
+                    return self.recovery(query)
+                # Performativa encontrada
+                children = None
+                self.notify("performativa encontrada")
+                node = self.__dfa[dialog_state]
+                if not isinstance(node, list):
+                    children = node.children
+                else:
+                    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]
+                else:
+                    logging.info(f"???????????????????> text: {res} es terminal")    
+                # Nuevo nodo
+                if select_node:
+                    res = select_node.text
+                    node = select_node.children[0]
+                # Nodo seleccionado
+                logging.info(f"Flujo normal: {res}")
+                self.notify(res)
+                if team_source:
+                    self.__work_memory.append({"role": "user", "content": res})
+                else:
+                    self.__work_memory.append({"role": "user", "content": query})
+                    self.__work_memory.append({"role": "user", "content": res})
+                # Efectua inferencia  
+                new_owner, new_dialog_state, res, team = self.do_transition(owner, node, query)
+                res = self.get_text(res)
+                return new_owner, new_dialog_state, res, team
+            else:
+                logging.info(f"------------RESET---------------")
+                self.notify("STOP")
+                self.reset()
+                return "Web", DialogState.START, self.RECOVERY_MSG, "Web"
+            logging.info("END: do_transition")
+        except Exception as e:
+            traceback.print_exc()
             logging.info(f"------------RESET---------------")
             self.reset()
-            logging.info(f"???> text: {text} es terminal")
-            text = self.get_text(text)
-            return owner, DialogState.START, text, owner
-
-        # Flujo normal
-        logging.info(f"Flujo normal: {select_node.text}")
-        if team_source:
-            self.__work_memory.append({"role": "user", "content": select_node.text})
-        else:
-            self.__work_memory.append({"role": "user", "content": query})
-            self.__work_memory.append({"role": "user", "content": select_node.text})  
-        new_owner, new_dialog_state, text, team = self.do_transition(owner, select_node.children[0], query)
-        text = self.get_text(text)
-        return new_owner, new_dialog_state, text, team
+            self.notify("STOP")
+            return owner, DialogState.START, "Lo lamento, no puedo responder en este momento", owner
 
     def do_transition(self, owner, node, query) -> str:
         """ Generate method
         :return: str
-        """          
-        if isinstance(node, DeclarativeNode):
-            logging.info(f"D -> node: {node.text}")
-            self.__work_memory.append({"role": "user", "content": node.text})
-        elif isinstance(node, ActionNode):
-
-            #------------------------------
-            # Accion
-            #------------------------------
-
-            logging.info(f"-> node action: {node.action}")
-            if node.tool and not node.tool == "Ninguno":
-                logging.info(f"-> node tool: {node.tool}")
-                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)
-                logging.info(f"-> node tool: {res}")
-                res = self.get_text(res)
-                # Check if res is empty
-                if not res or res == "":
-                    logging.info("1 -> res vacio")
-                    res = "Lo lamento, no puedo responder en este momento"
-
-                    logging.info(f"------------RESET---------------")
-                    self.reset()
-
-                    return owner, DialogState.START, res, owner
-                logging.info(f"-> node tool: envia -> {res}")
-                text = self.team_inquiry(node.team, res, node.tool, False)   
-            else:
+        """
+        try:
+            if isinstance(node, ActionNode):
+                self.notify("realizando acción...")
                 #------------------------------
-                # Lllamada
+                # Accion
                 #------------------------------
-                logging.info(f"-> node team: {node.team}")
-                # Verifica si el nodo es termianl ya que significa
-                # que el dialogo cambia de agente
-                if node.is_terminal:
-                    logging.info(f"-> node team -> es terminal -> {node.text}")
+                logging.info(f"-> node action: {node.action}")
+                if node.tool and not node.tool == "Ninguno":
+                    self.notify("aplicando herramienta...")
+                    logging.info(f"-> node tool: {node.tool}")
                     self.__work_memory.append({"role": "user", "content": node.text})
                     logging.info("-----")
                     logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
-                    logging.info("-----")
+                    logging.info("-----")         
                     res = self.__ai_service.generate(self.__work_memory)
+                    logging.info(f"-> node tool: {res}")
                     res = self.get_text(res)
-                    self.__work_memory.append({"role": "system", "content": res})
                     # Check if res is empty
                     if not res or res == "":
-                        logging.info("2 -> res vacio")
-                        res = "Lo lamento, no puedo responder en este momento"
-                        logging.info(f"------------RESET---------------")
-                        self.reset()
-                        return owner, DialogState.START, res, owner
-                    logging.info(f"-> node team -> envia: {res}")
-                    text = self.team_inquiry(node.team, res, None, True)
-                    return node.team, DialogState.START, res, node.team
+                        self.notify("no pude hacer uso de la herramienta")
+                        return self.recovery(query)
+                    logging.info(f"-> node tool: envia -> {res}")
+                    res = self.team_inquiry(node.team, res, node.tool, False)   
                 else:
-                    logging.info("-> node team -> continua")
-                    self.__work_memory.append({"role": "user", "content": node.text})
-                    logging.info(f"-> node team -> envia: {query}")
-                    text = self.team_inquiry(node.team, query, node.tool, False)
-                logging.info(f"-> node team -> text: {text}")
-                if text:
-                    logging.info(f"-> Adicion WM node team -> text: {text}")
-                    self.__work_memory.append({"role": "system", "content": text})
-            self.__deep_count += 1
-            if self.__deep_count < self.__deep_limit:
-                return self.transition(owner, node.performative, text, True)
+                    self.notify("realizando llamada...")
+                    #------------------------------
+                    # Lllamada
+                    #------------------------------
+                    logging.info(f"-> node team: {node.team}")
+                    # Verifica si el nodo es termianl ya que significa
+                    # que el dialogo cambia de agente
+                    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)                    
+                        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)
+                        if res and not res == "ERROR" and not res == "":
+                            logging.info(f"------------RESET---------------")
+                            self.reset()
+                            self.notify("STOP")
+                            return node.team, DialogState.START, res, node.team
+                        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.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}")
+                    self.__work_memory.append({"role": "system", "content": res})
+                else:
+                    return self.recovery(query)
+                logging.info("#########> Procesa respuesta del equipo en profundidad")
+                # Verifica si se alcanzó el límite de profundidad
+                self.__deep_count += 1
+                if self.__deep_count < self.__deep_limit:
+                    self.notify("efectuando inferencia en profundidad")
+                    return self.transition(owner, node.performative, res, True)
+                else:
+                    self.notify(f"se alcanzó el límite de profundidad: {self.__deep_count}")
+                    self.__deep_count = 0
+                    logging.info("-> node team -> deep limit")
+                    logging.info(f"------------RESET---------------")
+                    self.notify("STOP")
+                    self.reset()
+                    return "Web", DialogState.START, self.RECOVERY_MSG, "Web"
             else:
-                self.__deep_count = 0
-                logging.info("-> node team -> deep limit")
-
-                logging.info(f"------------RESET---------------")
-                self.reset()
-
-                return "Web", DialogState.START, "Lo lamento me he perdido, ¿podrías repetir la pregunta?"
-        else:
-            logging.info(f"!!!!!!!!!!!!!!!!!!!!!!!> Otro tipo de nodo: {node.text}")
-
-        logging.info(f"=> !!!!: {query}")
-        logging.info("-----")
-        logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
-        logging.info("-----")
-        res = self.__ai_service.generate(self.__work_memory)
-        logging.info(f"=> res: {res}")
-        res = self.get_text(res)
-        self.__work_memory.append({"role": "system", "content": res})
-        # Check if res is empty
-        if not res or res == "":
-            logging.info("3 -> res vacio")
-
+                self.notify("efectuando inferencia...")
+                logging.info(f"D -> node: {node.text}")
+                self.__work_memory.append({"role": "user", "content": node.text})
+                logging.info(f"=> !!!!: {query}")
+                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 == "":
+                    return self.recovery(query)
+                logging.info(f"=> Thought DEEP: {res}")
+                self.notify(f"Realizando inferencia: {res}")
+                new_dialog_state = node.performative
+                if not node.is_terminal:
+                    self.notify(f"continuando díalogo de inferencia")
+                    return owner, new_dialog_state, res, owner
+                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}")
+                self.notify("STOP")
+                return owner, new_dialog_state, res, owner
+            logging.info("END: do_transition")
+        except Exception as e:
+            traceback.print_exc()
             logging.info(f"------------RESET---------------")
             self.reset()
-
-            res = "Lo lamento, no puedo responder en este momento"
-            return owner, DialogState.START, res, owner
-
-        logging.info(f"=> Thought DEEP: {res}")
-
-        new_dialog_state = node.performative
-        if not node.is_terminal:
-            logging.info(f"=> new_owner: {owner} new_dialog_state: {new_dialog_state}")
-            return owner, new_dialog_state, res, owner
-        
-        logging.info(f"Tipe node: {type(node)}")
-
-        logging.info(f"$$$> new_owner: {owner} new_dialog_state: {new_dialog_state}")
-        return owner, new_dialog_state, res, owner
+            self.notify("STOP")
+            return owner, DialogState.START, "Lo lamento, no puedo responder en este momento", owner
 
     def set_knowledge(self, knowledge) -> str:
         """ Set knowledge method

{pbesa-4.0.4 → pbesa-4.0.6}/pbesa/social/dialog.py

@@ -13,6 +13,7 @@
 # Define resources
 # --------------------------------------------------------
 
+import logging
 import datetime
 import traceback
 from .templates import AFIRMATIVE_RESPONSE, GET_DATE
@@ -199,6 +200,6 @@ def imprimir_grafo(nodo, nivel=0):
     indent = "  " * nivel
     # Se muestra la clase del nodo y algunos atributos
     clase = nodo.__class__.__name__
-    print(f"{indent}{clase} (performative: {nodo.performative}, text/action: {nodo.text if hasattr(nodo, 'text') and nodo.text is not None else getattr(nodo, 'action', None)}, terminal: {nodo.is_terminal})")
+    logging.debug(f"{indent}{clase} (performative: {nodo.performative}, text/action: {nodo.text if hasattr(nodo, 'text') and nodo.text is not None else getattr(nodo, 'action', None)}, terminal: {nodo.is_terminal})")
     for child in nodo.children:
         imprimir_grafo(child, nivel + 1)

{pbesa-4.0.4 → pbesa-4.0.6}/pbesa/social/dispatcher_team.py

@@ -130,7 +130,7 @@ class ResponseAction(Action):
 class DispatcherController(Agent):
     """ Represents the agent that delegates the execution of actions to other agents """
     
-    def __init__(self, agent_id:str, buffer_size:int, pool_size:int) -> None:
+    def __init__(self, agent_id:str, buffer_size:int, pool_size:int, delegate=None) -> None:
         """ Constructor
         @param agent_id: Agent ID
         @param type: Pool type
@@ -139,15 +139,20 @@ class DispatcherController(Agent):
         """
         self.__buffer_size = buffer_size
         self.__request_dict = {}
+        self.__pool_size = pool_size
         self.__free_queue = Queue(pool_size)
         self.__agent_list = []
+        self.__delegate = delegate
         super().__init__(agent_id)
 
     def setup(self) -> None:
         """ Set up method """
         self._social = True
         self.add_behavior('Delegate')
-        self.bind_action('Delegate', 'delegate', Delegate())
+        if self.__delegate:
+            self.bind_action('Delegate', 'delegate', self.__delegate())
+        else:
+            self.bind_action('Delegate', 'delegate', Delegate())
         self.add_behavior('Notify')
         self.bind_action('Notify', 'notify', NotifyFreeAction())
         self.add_behavior('Response')
@@ -161,6 +166,8 @@ class DispatcherController(Agent):
         self.__agent_list.append(agent.id)
         agent.set_controller(self.id)
         agent.set_controller_type('POOL')
+        if len(self.__agent_list) > self.__pool_size:
+            raise DispatcherException('[Warn, suscribeAgent]: The pool is full')
         self.__free_queue.put(agent.id)
         actions = agent.get_actions()
         for action in actions:
@@ -181,7 +188,7 @@ class DispatcherController(Agent):
         @param event: Event
         @param data: Data
         """
-        from pbesa.kernel.system.adm import Adm
+        from ..mas import Adm
         for agent_id in self.__agent_list:
             Adm().send_event(agent_id, event, data)
     
@@ -190,6 +197,12 @@ class DispatcherController(Agent):
         """ Builds the agent """
         pass
 
+    def get_agent_list(self) -> list:
+        """ Gets the agent list
+        @return: Agent list
+        """
+        return self.__agent_list
+
     def get_free_queue(self) -> Queue:
         """ Gets the free queue
         @return: Free queue

{pbesa-4.0.4 → pbesa-4.0.6}/pbesa/social/prompts.py

@@ -36,5 +36,29 @@ Ahora, evalúa el siguiente caso:
 
 Texto: "%s"
 
+Respuesta:
+"""
+
+RECOVERY_PROMPT = """
+Instrucciones:
+
+Eres un agente especializado en parafrasear. Tu tarea es analizar un texto principal y parafrasearlo generando opciones al usuario.
+
+Requisitos:
+
+- No incluyas explicaciones, razonamientos ni texto adicional.
+- Genera opciones en lenguaje natural sin involucrar números o listas.
+- Si no logras parafrasear el texto principal, responde solicitando más información.
+
+Ejemplo:
+
+Texto: "Hola mi caso esta relacionado con la Superfinanciera"
+
+Respuesta: Perdona, tu solicitud ¿Es sobre la Superintendencia Financiera de Colombia o sobre la Superintendencia de Sociedades?
+
+Ahora, evalúa el siguiente caso:
+
+Texto: "%s"
+
 Respuesta:
 """

{pbesa-4.0.4 → pbesa-4.0.6}/pbesa/social/selected_dispatcher_team.py

@@ -104,7 +104,7 @@ class DelegateAction(Action):
                         self.__rewier[ag] = 0
                         exit = True
                     else:
-                        logging.info('The agent is not available')
+                        logging.info('The agent is not operational')
                         self.adm.send_event(agent_obj.get_controller(), 'notify', ag)
                         if ag in self.__rewier:
                             self.__rewier[ag] = self.__rewier[ag] + 1

{pbesa-4.0.4 → pbesa-4.0.6}/pbesa/social/worker.py

@@ -57,18 +57,18 @@ class TimeoutAction(Action):
         """ Execute the action
         @param data: Event data
         """
-        logging.info(f"[TimeoutAction][{self.agent.id}]: Execute {data}")
+        logging.debug(f"[TimeoutAction][{self.agent.id}]: Execute {data}")
         if data['command'] == 'start':
             if not self.agent.is_timeout():
                 self.agent.set_timeout(True)
                 self.__timer = Timer(data['time'], self.handler)
                 self.__timer.start()
-                logging.info(f"[TimeoutAction][{self.agent.id}]: Timer started")
+                logging.debug(f"[TimeoutAction][{self.agent.id}]: Timer started")
         else:
             if self.__timer:
                 self.__timer.cancel()
                 self.__timer = None
-                logging.info(f"[TimeoutAction][{self.agent.id}]: Timer stopped")
+                logging.debug(f"[TimeoutAction][{self.agent.id}]: Timer stopped")
 
 # --------------------------------------------------------
 # Define Task Action

{pbesa-4.0.4 → pbesa-4.0.6}/pbesa.egg-info/PKG-INFO

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

{pbesa-4.0.4 → pbesa-4.0.6}/setup.py

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