pbesa 4.0.6__tar.gz → 4.0.8__tar.gz

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

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

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

@@ -13,20 +13,25 @@
 # Define resources
 # --------------------------------------------------------
 
+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 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, RECOVERY_PROMPT
+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, ADAPT_PROMPT
 # --------------------------------------------------------
 # Define DTOs
 # --------------------------------------------------------
 
 class InteraccionDTO(BaseModel):
+    id: str
     tipo: str
     texto: str
     actor: str
@@ -38,6 +43,7 @@ def interaccion_serializer(interaccion):
     if isinstance(interaccion, list):
         return [interaccion_serializer(i) for i in interaccion]
     return {
+        "id": interaccion["id"] if "id" in interaccion and interaccion["id"] else str(uuid.uuid4()),
         "tipo": interaccion["tipo"],
         "texto": interaccion["texto"],
         "actor": interaccion["actor"],
@@ -476,7 +482,11 @@ 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
+        self.__visited_nodes = 0
 
     def setup_world(self):
         """ Set up model method """
@@ -577,6 +587,9 @@ class Dialog(ABC):
             "performative": DialogState.START,
             "counter": 0
         }
+        # Reset visited nodes
+        self.__visited_nodes = 0
+        self.__vertices = []
 
     def notify(self, text):
         try:
@@ -602,6 +615,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,
@@ -642,9 +663,10 @@ class Dialog(ABC):
 
     def get_text(self, mensaje) -> str:
         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]: ", "")
+            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 ""
@@ -680,20 +702,25 @@ 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:
-                self.notify("identificando la performativa...")
+            if self.__recovery['counter'] <= 3 and self.__visited_nodes <= 3:
+                self.notify("identificando concepto...")
+                #--------------------------
                 # Verifica que exista la performativa
                 if not dialog_state in self.__dfa:
-                    self.notify("performativa no encontrada")
+                    self.notify("concepto no encontrado")
                     return self.recovery(query)
                 # Performativa encontrada
                 children = None
-                self.notify("performativa encontrada")
+                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...")
@@ -724,20 +751,70 @@ class Dialog(ABC):
                     logging.info(f"--> Una opción.")
                     select_node = children[0]
                 else:
-                    logging.info(f"???????????????????> text: {res} es terminal")    
-                # Nuevo nodo
+                    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
+                if select_node.performative in self.__vertices:
+                    logging.info(f"-> nodo ya recorrido: {select_node.text}")
+                    self.__visited_nodes += 1
+                else:
+                    logging.info(f"-> nodo no recorrido: {select_node.text}")
+                    self.__visited_nodes = 0
+                    # Maraca el nodo como visitado
+                    self.__vertices.append(select_node.performative)
+                #---------------------------
+                # Verifica si el nodo es un
+                # nodo de salto
+                if isinstance(select_node, GotoNode):
+                    logging.info(f"-> node de salto: {select_node.text}")
+                    performative = select_node.text.replace("Salta a:", "").strip()
+                    select_node = self.__dfa[performative]
+                    logging.info(f"-> Salto: {select_node.text}, performativa: {select_node.performative}")
+                #---------------------------
+                # Efectua transicion
                 if select_node:
                     res = select_node.text
-                    node = select_node.children[0]
-                # Nodo seleccionado
+                    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)
+                #---------------------------
+                # Verifica si el nuevo nodo 
+                # es un nodo de salto
+                if isinstance(node, GotoNode):
+                    logging.info(f"-> node de salto: {node.text}")
+                    performative = node.text.replace("Salta a:", "").strip()
+                    node = self.__dfa[performative]
+                    logging.info(f"-> Salto: {node.text}, performativa: {node.performative}")
+                #---------------------------
+                # Actualiza la memoria de 
+                # 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})
-                # Efectua inferencia  
+                    #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)
                 res = self.get_text(res)
                 return new_owner, new_dialog_state, res, team
@@ -792,16 +869,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)
@@ -813,11 +896,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}")
@@ -861,8 +960,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()
@@ -876,4 +977,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.6 → pbesa-4.0.8}/pbesa/social/dialog.py

@@ -37,7 +37,7 @@ class DialogState:
 class Node:
     def __init__(self, actor, performative, text=None, is_terminal=False):
         self.actor = actor
-        self.performative = performative  # Se asigna el ID del objeto (en str)
+        self.performative = performative
         self.text = text
         self.is_terminal = is_terminal
         self.children = []
@@ -57,6 +57,10 @@ class ResponseNode(Node):
     def __init__(self, actor, performative, text, is_terminal=False):
         super().__init__(actor, performative=performative, text=text, is_terminal=is_terminal)
 
+class GotoNode(Node):
+    def __init__(self, actor, performative, text, is_terminal=False):
+        super().__init__(actor, performative=performative, text=text, is_terminal=is_terminal)
+
 #------------------------------------------
 # Define functions
 #------------------------------------------
@@ -125,7 +129,7 @@ def recorrer_interacciones(obj):
             # Si tiene la clave "tipo", creamos un nodo (según su valor) y procesamos sus hijos
             if "tipo" in obj:
                 # Se usa el id del diccionario convertido a cadena para 'performative'
-                current_id = str(id(obj))
+                current_id = obj["id"] if "id" in obj else str(id(obj))
                 texto = obj.get("texto")
                 
                 # Procesamos los nodos hijos buscando en las claves "interacciones" y "Interacciones"
@@ -150,6 +154,8 @@ def recorrer_interacciones(obj):
                     nuevo_nodo = ActionNode(actor=obj["actor"], performative=current_id, text=texto, action=tipo, team=obj["equipo"], tool=obj["herramienta"], is_terminal=is_terminal)
                 elif tipo == "respuesta de equipo":
                     nuevo_nodo = ResponseNode(actor=obj["actor"], performative=current_id, text=texto, is_terminal=is_terminal)
+                elif tipo == "salta a":
+                    nuevo_nodo = GotoNode(actor=obj["actor"], performative=current_id, text=texto, is_terminal=is_terminal)
                 else:
                     nuevo_nodo = Node(actor=obj["actor"], performative=current_id, text=texto, is_terminal=is_terminal)
                 
@@ -168,8 +174,10 @@ def recorrer_interacciones(obj):
                                 nodos.extend(resultado)
                             else:
                                 nodos.append(resultado)
+                # Devolvemos la lista de nodos encontrados
                 return nodos if nodos else None
         else:
+            # Si no es ni lista ni diccionario, devolvemos None
             return None
     except Exception as e:
         print(f"Error al recorrer interacciones: {e}")

{pbesa-4.0.6 → pbesa-4.0.8}/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.6 → pbesa-4.0.8}/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.6 → pbesa-4.0.8}/pbesa.egg-info/PKG-INFO

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

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

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