pbesa 4.0.7__tar.gz → 4.0.8__tar.gz

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

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

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

@@ -17,6 +17,7 @@ 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
@@ -24,7 +25,7 @@ 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 +482,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 +587,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 +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,
@@ -690,7 +702,7 @@ 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:
+            if self.__recovery['counter'] <= 3 and self.__visited_nodes <= 3:
                 self.notify("identificando concepto...")
                 #--------------------------
                 # Verifica que exista la performativa
@@ -740,6 +752,8 @@ class Dialog(ABC):
                     select_node = children[0]
                 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
@@ -764,7 +778,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 +807,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 +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)
@@ -860,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}")
@@ -908,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()
@@ -923,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.7 → 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.7 → 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.7 → pbesa-4.0.8}/pbesa.egg-info/PKG-INFO

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

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

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