pbesa 4.0.13__tar.gz → 4.0.14__tar.gz

{pbesa-4.0.13 → pbesa-4.0.14}/PKG-INFO

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

pbesa-4.0.14/pbesa/celulas/celula_preguntas.py

@@ -0,0 +1,41 @@
+import logging
+
+PROMPT = """
+Eres un clasificador de preguntas. Tu tarea es analizar el siguiente texto y determinar si contiene preguntas.
+
+Responde únicamente con una de estas opciones:
+- CONTIENE
+- NO_CONTIENE
+
+**Definición de pregunta**: Una pregunta es una expresión que busca obtener información o aclaración sobre un tema específico. Esto incluye preguntas directas, indirectas y retóricas. No se consideran preguntas las afirmaciones o comentarios que no buscan respuesta.
+
+Ejemplos:
+- "Hola, ¿cómo estás?" → CONTIENE
+- "Buenos días, equipo" → NO_CONTIENE
+- "¿Cómo se hace este análisis?" → CONTIENE
+- "Ey, qué más" → NO_CONTIENE
+- "Necesito ayuda con el código" → NO_CONTIENE
+- "Saludos" → NO_CONTIENE
+
+Texto: "%s"
+
+Clasificación:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, text, max_tkns=4096) -> any:
+    try:
+        logging.info(f"Procesando: {text}")
+        tmp_work_memory = []
+        prompt  = PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory, max_tokens=max_tkns)
+        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.13 → pbesa-4.0.14}/pbesa/cognitive.py

@@ -27,7 +27,7 @@ from pbesa.social.dialog import (
     ActionNode, DeclarativeNode, GotoNode)
 from .celulas import (celula_casos, celula_consultas, celula_saludos, celula_datos_identificables,
                       celula_generar_documento)
-from pbesa.social.prompts import CLASSIFICATION_PROMPT, DERIVE_PROMPT, RECOVERY_PROMPT, ADAPT_PROMPT
+from pbesa.social.prompts import ANALIZER_PROMPT, CLASSIFICATION_PROMPT, DERIVE_PROMPT, RECOVERY_PROMPT, ADAPT_PROMPT, SINTETIZER_PROMPT
 
 # --------------------------------------------------------
 # Define DTOs
@@ -556,6 +556,10 @@ class Dialog(ABC):
         self.__vertices = []
         # Define visited nodes
         self.__visited_nodes = 0
+        # Define alter work memory
+        self.__attemps = 1
+        self.__analazer_work_memory:list = []
+        self.__sintetizer_work_memory:list = []
 
     def setup_world(self):
         """ Set up model method """
@@ -660,11 +664,11 @@ class Dialog(ABC):
         self.__visited_nodes = 0
         self.__vertices = []
 
-    def notify(self, text):
+    def notify(self, session_id, text):
         try:
             canales = self.state['canales']
             canal = canales.get("Webhook")
-            session_id = self.state['session_id']
+            #session_id = self.state['session_id']
             dto = {
                 "session_id": session_id,
                 "text": text[0:100]
@@ -676,9 +680,9 @@ class Dialog(ABC):
                 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}")
+            logging.error(f"Error: {e}")
 
-    def team_inquiry(self, team, data, operation, session_flag) -> str:
+    def team_inquiry(self, session, team, data, operation, session_flag) -> str:
         try:
             dto = None
             canales = self.state['canales']
@@ -686,7 +690,7 @@ class Dialog(ABC):
             if session_flag:
                 # Actualiza la sesion
                 session_manager = self.state['session_manager']
-                session_manager.update_session(self.state['session_id'], {
+                session_manager.update_session(session['session_id'], {
                     'team': team,
                     'owner': team,
                     'performative': DialogState.START,
@@ -695,7 +699,7 @@ class Dialog(ABC):
                 dto = {
                     "data": {
                         'text': data,
-                        'session_id': self.state['session_id'],
+                        'session_id': session['session_id'],
                     },
                 }
                 # Evia mensaje a los agentes remotos
@@ -712,8 +716,8 @@ class Dialog(ABC):
                         "data": {
                             'text': data,
                             'operation': operation,
-                            'id_conversacion': self.state['id_conversacion'],
-                            'session_id': self.state['session_id'],
+                            'id_conversacion': session['id_conversacion'],
+                            'session_id': session['session_id'],
                         },
                     }
                 else:
@@ -742,7 +746,7 @@ class Dialog(ABC):
         else:
             return ""
     
-    def recovery(self, query):
+    def recovery(self, session_id, query):
         try:
             prompt = RECOVERY_PROMPT % query
             temp_work_memory = [{"role": "user", "content": prompt}]
@@ -754,12 +758,98 @@ class Dialog(ABC):
                 logging.info(f"------------RESET---------------")
                 logging.info(f"Recovery from: {self.__recovery['performative']}")
                 self.reset()
-                self.notify("STOP") 
+                self.notify(session_id, "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:
+        
+    def stage_one_classification(self, session_id, messages, attemps, query):
+        """ Stage one classification """
+        res = ""
+        #evaluating = True
+        dicriminador = None
+        logging.info(f"------------Flujo de excepcion---------------")
+        self.notify(session_id, "identificando intención...")        
+
+        logging.info(f"Intento: {attemps}") 
+        # Obtiene discriminadores
+        # Verifica si es un saludo
+        if attemps == 1:
+            saludo = celula_saludos.derive(self.__ai_service, query, max_tkns=10)   
+        else:
+            saludo = "NO_SALUDO"
+        # De la forma user, system y de messages 
+        # genera un texto discriminando los tipos de mensajes
+        history = ""
+        for message in messages:
+            if message['user']:
+                history += f"user: {message['text']}\n"
+            else:
+                history += f"system: {message['text']}\n"
+        # User
+        #history += f"user: {query}\n"
+
+        # Actyaliza la memoria de trabajo
+        prompt = ANALIZER_PROMPT % history
+        self.__analazer_work_memory:list = [{"role": "user", "content": prompt}]
+        if attemps > 1:
+            # Desde la seegunda iteeraccion de la
+            # conversacion, se utiliza el sintentizador
+            prompt = SINTETIZER_PROMPT % history
+            self.__sintetizer_work_memory:list = [{"role": "user", "content": prompt}]
+            logging.info("\n\n\n--------------SINTETIZER------------------")
+            logging.info("\n%s", json.dumps(self.__sintetizer_work_memory, indent=4))
+            logging.info("\n\n\n")
+            query = self.__ai_service.generate(self.__sintetizer_work_memory, max_tokens=10)
+            res = self.get_text(query)
+            query = res
+            logging.info(f"Thought: {query}")
+        # Verifica si es una consulta o un caso
+        caso = celula_casos.derive(self.__ai_service, query, max_tkns=10)
+        consulta = celula_consultas.derive(self.__ai_service, query, max_tkns=10)
+        # Verifica si es un saludo, consulta o caso
+        es_saludo = ("SALUDO" in saludo) and ("NO_PREGUNTA" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and not ("NO_SALUDO" in saludo)    
+        es_consulta = ("PREGUNTA_O_SOLICITUD" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and ("NO_SALUDO" in saludo) and not ("NO_PREGUNTA" in consulta)
+        es_caso = ("QUEJA_DEMANDA" in caso) and ("NO_PREGUNTA" in consulta) and ("NO_SALUDO" in saludo) and not ("NO_QUEJA_DEMANDA" in caso)
+        print("\n------------------- Clase --------------------------")
+        logging.info(f"==> Saludo: {saludo}, Consulta: {consulta}, Caso: {caso}")                    
+        logging.info(f"==> Es saludo: {es_saludo}, Es consulta: {es_consulta}, Es caso: {es_caso}")
+        print("\n-----------------------------------------------------")
+        # Verifica los casos
+        if es_saludo or es_consulta or es_caso:
+            logging.info("Respuesta Clara")
+            if es_saludo:
+                dicriminador = "saluda"
+            elif es_consulta:
+                dicriminador = "consulta"
+            else:
+                dicriminador = "caso"
+            #evaluating = False
+            self.notify(session_id, f"fase uno es {dicriminador}...")
+            res = query
+        else:
+            logging.info("Respuesta con ambiguedad")
+            self.notify(session_id, "identificando ambiguedad...")
+            self.__analazer_work_memory.append({"role": "user", "content": query})
+            logging.info("\n\n\n--------------ANALIZER------------------")
+            logging.info("\n%s", json.dumps(self.__analazer_work_memory, indent=4))
+            logging.info("------------------------------------------\n\n\n")
+            res = self.__ai_service.generate(self.__analazer_work_memory, max_tokens=10)
+            logging.info(f"Thought: {res}")
+            self.__analazer_work_memory.append({"role": "system", "content": query})                
+            self.__sintetizer_work_memory.append({"role": "system", "content": query})
+            #if caso == "QUEJA_DEMANDA":
+            #    dicriminador = "caso"
+            #elif consulta == "PREGUNTA_O_SOLICITUD":
+            #    dicriminador = "consulta"
+            #elif saludo == "SALUDO":
+            #    dicriminador = "saluda"
+        #logging.info(f"==> Discriminador: {dicriminador}")
+        #if dicriminador == "Ninguno":
+        #    dicriminador = "consulta"
+        return dicriminador, res
+
+    def transition(self, session, owner, dialog_state, query, team_source=False) -> str:
         try:
             res = ""
             logging.info(f"TOPTQ: {owner} - {dialog_state} - {team_source} - {query}")
@@ -780,44 +870,26 @@ class Dialog(ABC):
                 #------------------------------
                 if owner == "Web" and dialog_state == DialogState.START:
                     logging.info(f"TOPTQ: {owner} - {dialog_state} - {team_source} - {query}")
-                    logging.info(f"------------Flujo de excepcion---------------")
-                    self.notify("identificando intencion...")
-                    # Obtiene discriminadores
-                    caso = celula_casos.derive(self.__ai_service, query, max_tkns=10)
-                    consulta = celula_consultas.derive(self.__ai_service, query, max_tkns=10)
-                    saludo = celula_saludos.derive(self.__ai_service, query, max_tkns=10)
-                    # Verifica si es un saludo
-                    es_saludo = ("SALUDO" in saludo) and ("NO_PREGUNTA" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and not ("NO_SALUDO" in saludo)
-                    es_consulta = ("PREGUNTA_O_SOLICITUD" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and ("NO_SALUDO" in saludo) and not ("NO_PREGUNTA" in consulta)
-                    es_caso = ("QUEJA_DEMANDA" in caso) and ("NO_PREGUNTA" in consulta) and ("NO_SALUDO" in saludo) and not ("NO_QUEJA_DEMANDA" in caso)
-
-                    print("\n--- Clase ---")
-                    logging.info(f"==> Saludo: {saludo}, Consulta: {consulta}, Caso: {caso}")                    
-                    logging.info(f"==> Es saludo: {es_saludo}, Es consulta: {es_consulta}, Es caso: {es_caso}")
-                    # Verifica los casos
-                    dicriminador = "Ninguno"
-                    if es_saludo or es_consulta or es_caso:
-                        logging.info("Respuesta Clara")
-                        self.notify("discriminando...")
-                        if es_saludo:
-                            dicriminador = "saluda"
-                        elif es_consulta:
-                            dicriminador = "consulta"
-                        elif es_caso:
-                            dicriminador = "caso"
-                    else:
-                        logging.info("Respuesta con ambiguedad")
-                        self.notify("identificando ambiguedad...")
-                        if caso == "QUEJA_DEMANDA":
-                            dicriminador = "caso"
-                        elif consulta == "PREGUNTA_O_SOLICITUD":
-                            dicriminador = "consulta"
-                        elif saludo == "SALUDO":
-                            dicriminador = "saluda"
-                    logging.info(f"==> Discriminador: {dicriminador}")
-                    if dicriminador == "Ninguno":
-                        dicriminador = "consulta"
-                    print("---------------------\n")
+                    session_manager = self.state['session_manager']        
+                    conversation = session_manager.get_conversation(session['id_conversacion'])
+                    attemps = conversation.get('attemps', 1)            
+                    dicriminador, res = self.stage_one_classification(session['session_id'], conversation['messages'], attemps, query)
+                    conversation['attemps'] = attemps + 1
+                    session_manager.update_conversation(session['id_conversacion'], conversation)
+                    logging.info(f"Discriminador: {dicriminador}")
+                    # Limpia la memoria de trabajo
+                    # Para que el agente la utilice en
+                    # Otra conversacion
+                    self.__analazer_work_memory:list = []
+                    self.__sintetizer_work_memory:list = []
+                    if not dicriminador:
+                        # Una nueva iteración de analisis
+                        logging.info(f"------------RESET---------------")
+                        logging.info(f"Recovery from: {self.__recovery['performative']}")
+                        self.reset()
+                        self.notify(session['session_id'], "STOP") 
+                        return "Web", DialogState.START, res, "Web"
+                    query = res                
                     #--------------------------
                     # Obtiene los hijos del 
                     # nodo
@@ -830,7 +902,6 @@ class Dialog(ABC):
                         children = node
                     #--------------------------
                     # Flujo de selección                
-                    self.notify("flujo de seleccion...")
                     if children and len(children)> 1:
                         logging.info(f"--> Más de una opción.")
                         options = ""
@@ -838,22 +909,22 @@ class Dialog(ABC):
                         for item in children:
                             if dicriminador in item.text:
                                 select_node = item
-                                break    
+                                break
                 else:                    
                     #------------------------------
                     # Fulo normal
                     #------------------------------    
                     logging.info("Flujo normal")    
-                    self.notify("identificando concepto...")
+                    self.notify(session['session_id'], "identificando concepto...")
                     #----------------------
                     # Verifica que exista 
                     # la performativa
                     if not dialog_state in self.__dfa:
-                        self.notify("concepto no encontrado")
-                        return self.recovery(query)
+                        self.notify(session['session_id'], "concepto no encontrado")
+                        return self.recovery(session['session_id'], query)
                     # Performativa encontrada
                     children = None
-                    self.notify("concepto encontrado")
+                    self.notify(session['session_id'], "concepto encontrado")
                     #----------------------
                     # Obtiene los hijos del
                     #  nodo
@@ -866,7 +937,6 @@ class Dialog(ABC):
                     #----------------------
                     # 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 = ""
@@ -897,13 +967,13 @@ class Dialog(ABC):
                         logging.info("???> Es un nodo terminal o iniciador")
                         logging.warning(f"???> Es un nodo terminal o iniciador: {node}")
                         logging.warning(f"???> Es un nodo terminal o iniciador: {node}")
-                        return self.recovery(query)
+                        return self.recovery(session['session_id'], query)
                 
                 # Verifica si el nodo fue seleccionado
                 if not select_node:
                     logging.warning(f"???> No se seleccionó ningún nodo")
                     logging.info(f"------------RESET---------------")
-                    self.notify("STOP")
+                    self.notify(session['session_id'], "STOP")
                     self.reset()
                     return "Web", DialogState.START, self.RECOVERY_MSG, "Web"
 
@@ -943,9 +1013,8 @@ class Dialog(ABC):
                         node = node[0]
                     else:
                         logging.info(f"-> !!!!!!!!!!!!!! Concepto no encontrado ????????????????")
-                        return self.recovery(query)
+                        return self.recovery(session['session_id'], query)
                 logging.info(f"Flujo normal: {res}")
-                self.notify(res)
                 #---------------------------
                 # Verifica si el nuevo nodo 
                 # es un nodo de salto
@@ -967,13 +1036,13 @@ class Dialog(ABC):
                     #logging.info(f"-> Actualiza r-WM: {res}")
                 #---------------------------
                 # Efectua inferencia
-                new_owner, new_dialog_state, res, team = self.do_transition(owner, node, query)
+                new_owner, new_dialog_state, res, team = self.do_transition(session, owner, node, query)
                 if res and not res == "ERROR" and isinstance(res, str):
                     res = self.get_text(res)
                 return new_owner, new_dialog_state, res, team
             else:
                 logging.info(f"------------RESET---------------")
-                self.notify("STOP")
+                self.notify(session['session_id'], "STOP")
                 self.reset()
                 return "Web", DialogState.START, self.RECOVERY_MSG, "Web"
             logging.info("END: do_transition")
@@ -981,22 +1050,22 @@ class Dialog(ABC):
             traceback.print_exc()
             logging.info(f"------------RESET---------------")
             self.reset()
-            self.notify("STOP")
+            self.notify(session['session_id'], "STOP")
             return owner, DialogState.START, "Lo lamento, no puedo responder en este momento", owner
 
-    def do_transition(self, owner, node, query) -> str:
+    def do_transition(self, session, owner, node, query) -> str:
         """ Generate method
         :return: str
         """
         try:
             if isinstance(node, ActionNode):
-                self.notify("realizando acción...")
+                self.notify(session['session_id'], "realizando acción...")
                 #------------------------------
                 # Accion
                 #------------------------------
                 logging.info(f"-> node action: {node.action}")
                 if node.tool and not node.tool == "Ninguno":
-                    self.notify("aplicando herramienta...")
+                    self.notify(session['session_id'], "aplicando herramienta...")
                     logging.info(f"-> node tool: {node.tool}")
 
                     res = query
@@ -1012,18 +1081,18 @@ class Dialog(ABC):
                         res = self.get_text(res)
                     # Check if res is empty
                     if not res or res == "":
-                        self.notify("no pude hacer uso de la herramienta")
-                        return self.recovery(query)
+                        self.notify(session['session_id'], "no pude hacer uso de la herramienta")
+                        return self.recovery(session['session_id'], query)
                     logging.info(f"-> node tool: envia -> {res}")
-                    res = self.team_inquiry(node.team, res, node.tool, False)
+                    res = self.team_inquiry(session, node.team, res, node.tool, False)
 
                     if res and not res == "ERROR" and not isinstance(res, str):
                         logging.info(f"COMANDO -> node tool: recibe -> {res}")
                         self.reset()
-                        self.notify("STOP")
+                        self.notify(session['session_id'], "STOP")
                         return "Web", DialogState.START, res, "Web"
                 else:
-                    self.notify("realizando llamada...")
+                    self.notify(session['session_id'], "realizando llamada...")
                     #------------------------------
                     # Lllamada
                     #------------------------------
@@ -1046,18 +1115,16 @@ class Dialog(ABC):
                             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}")
+                                return self.recovery(session['session_id'], query)
                         logging.info(f"-> node team -> envia: {res}")
-                        res = self.team_inquiry(node.team, res, None, True)
+                        res = self.team_inquiry(session, node.team, res, None, True)
                         if res and not res == "ERROR" and not res == "":
                             logging.info(f"------------RESET---------------")
                             self.reset()
-                            self.notify("STOP")
+                            self.notify(session['session_id'], "STOP")
                             return node.team, DialogState.START, res, node.team
                         else:
-                            return self.recovery(query)
+                            return self.recovery(session['session_id'], query)
                     else:
 
                         logging.info("-> node team -> continua")
@@ -1074,34 +1141,31 @@ class Dialog(ABC):
                             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")
+                                return self.recovery(session['session_id'], query)                    
+                        res = self.team_inquiry(session, node.team, res, node.tool, False)
 
                 # 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)
+                    return self.recovery(session['session_id'], 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)
+                    self.notify(session['session_id'], "efectuando inferencia en profundidad")
+                    return self.transition(session, owner, node.performative, res, True)
                 else:
-                    self.notify(f"se alcanzó el límite de profundidad: {self.__deep_count}")
+                    self.notify(session['session_id'], 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.notify(session['session_id'], "STOP")
                     self.reset()
                     return "Web", DialogState.START, self.RECOVERY_MSG, "Web"
             else:
-                self.notify("efectuando inferencia...")
+                self.notify(session['session_id'], "efectuando inferencia...")
                 logging.info(f"D -> node: {node.text}")
                 self.__work_memory.append({"role": "user", "content": node.text})
                 logging.info(f"=> !!!!: {query}")
@@ -1113,26 +1177,25 @@ class Dialog(ABC):
                 self.__work_memory.append({"role": "system", "content": res})
                 # Check if res is empty
                 if not res or res == "":
-                    return self.recovery(query)
+                    return self.recovery(session['session_id'], 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")
+                    self.notify(session['session_id'], f"continuando díalogo de inferencia")
                     return owner, new_dialog_state, res, owner
-                self.notify(f"finalizando díalogo de inferencia")
+                self.notify(session['session_id'], 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")
+                self.notify(session['session_id'], "STOP")
                 return "Web", DialogState.START, res, "Web"
             logging.info("END: do_transition")
         except Exception as e:
             traceback.print_exc()
             logging.info(f"------------RESET---------------")
             self.reset()
-            self.notify("STOP")
+            self.notify(session['session_id'], "STOP")
             return owner, DialogState.START, "Lo lamento, no puedo responder en este momento", owner
 
     def set_knowledge(self, knowledge) -> str:

{pbesa-4.0.13 → pbesa-4.0.14}/pbesa/models.py

@@ -13,6 +13,8 @@
 # Define resources
 # --------------------------------------------------------
 
+import json
+import logging
 import traceback
 from openai import AzureOpenAI
 from abc import ABC, abstractmethod
@@ -20,7 +22,7 @@ from azure.ai.projects import AIProjectClient
 from azure.identity import DefaultAzureCredential
 from azure.ai.inference import ChatCompletionsClient
 from azure.core.credentials import AzureKeyCredential
-
+from azure.core.exceptions import HttpResponseError
 import time
 from openai import AzureOpenAI, RateLimitError, APIStatusError
 from tenacity import (
@@ -135,13 +137,46 @@ class AzureInference(AIService):
             credential=AzureKeyCredential(config['AZURE_INFERENCE_SDK_KEY'])
         )
 
-    def generate(self, work_memory) -> str:
-        response = self.model.complete(
-            messages= work_memory,
-            model =self.model_conf['DEPLOYMENT_NAME'],
-            max_tokens=self.model_conf['MAX_TOKENS']
-        )
-        return response.choices[0].message.content
+    def generate(self, work_memory, max_tokens=2000, temperature=0, top_p=0.9) -> str:
+        try:
+            response = self.model.complete(
+                messages= work_memory,
+                model =self.model_conf['DEPLOYMENT_NAME'],
+                max_tokens=self.model_conf['MAX_TOKENS']
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            # Maneja otros errores
+            trace_err = traceback.format_exc()
+            err = str(e) + " - " + trace_err
+            print(f"Error en la respuesta de Azure: {err}")
+            if self.model_conf['SUBSTITUDE_DEPLOYMENT_NAME'] == "Llama-3.3-70B-Instruct":
+                print("\n\n\n")
+                print("----------------------------------------")
+                print("Entra a jugar el sustituto")
+                try:
+                    logging.info("\n\n\n.............................................")
+                    logging.info("\n%s", json.dumps(work_memory, indent=4))
+                    logging.info("........................................\n\n\n")
+
+                    response = self.model.complete(
+                        messages= work_memory,
+                        model =self.model_conf['SUBSTITUDE_DEPLOYMENT_NAME'],
+                        max_tokens=self.model_conf['MAX_TOKENS']
+                    )
+                    print("----------------------------------------")
+                    print("\n\n\n")
+                    
+                    return response.choices[0].message.content
+                except Exception as e2:
+                    trace_err2 = traceback.format_exc()
+                    err2 = str(e2) + " - " + trace_err2
+                    print(f"Error en la respuesta de Azure: {err2}")
+                    print("----------------------------------------")
+                    print("\n\n\n")
+                    
+                    raise e2
+                    
 
 # Función auxiliar para determinar la espera basada en el error
 def wait_strategy_for_rate_limit(retry_state):

{pbesa-4.0.13 → pbesa-4.0.14}/pbesa/social/dispatcher_team.py

@@ -253,7 +253,9 @@ class Delegate(Action):
             'gateway': data['gateway'],
             'dtoList': []
         }
+        logging.info(f"[Delegate][{self.agent.id}]: Assign to agent {ag}")
         self.adm.send_event(ag, 'task', data['dto'])
+        logging.info(f"[Delegate][{self.agent.id}]: Agent {ag} assigned")
         if 'timeout' in self.agent.state:
             self.active_timeout(ag, self.agent.state['timeout'])
         else:
@@ -293,7 +295,8 @@ class ResponseAction(Action):
         """ Execute
         @param data: Data
         """
-        logging.info(f"[ResponseAction][{self.agent.id}]: Response: {data}")
+        #@TODO: Check if the data is valid
+        #logging.info(f"[ResponseAction][{self.agent.id}]: Obtiene respuesta")
         if data['source'] in self.agent.get_request_dict():
             request = self.agent.get_request_dict()[data['source']]