Actualizar orchestrator.py

orchestrator.py

@@ -1,89 +1,102 @@
-import time
+import logging
+from datetime import datetime
 from typing import List
-from models.openai_api import OpenAIClient
-from models.deepseek_api import DeepSeekClient
-from models.gemini_api import GeminiClient
+import os
+
+class TaskType:
+    CONVERSATION = "conversación"
+    CODE_GENERATION = "código"
+    CODE_EXPLANATION = "explicación_código"
+    CREATIVE_WRITING = "escritura_creativa"
+    TECHNICAL_EXPLANATION = "explicación_técnica"
+    TRANSLATION = "traducción"
+    SUMMARIZATION = "resumen"
+    MATH_REASONING = "razonamiento_matemático"
+    IMAGE_GENERATION = "generación_imagen"
+    RESEARCH = "investigación"
+    DEBUGGING = "depuración"
 
 class SuperConfig:
-    def __init__(self, openai_api_key="", deepseek_api_key="", gemini_api_key="", enable_local_models=False, debug_mode=False):
-        self.openai_api_key = openai_api_key
+    def __init__(self, deepseek_api_key="", openai_api_key="", hf_token="", enable_local_models=True, debug_mode=False, max_history=20):
         self.deepseek_api_key = deepseek_api_key
-        self.gemini_api_key = gemini_api_key
+        self.openai_api_key = openai_api_key
+        self.hf_token = hf_token
         self.enable_local_models = enable_local_models
         self.debug_mode = debug_mode
+        self.max_history = max_history
 
 class SuperResponse:
-    def __init__(self, content: str, task_type: str, source: str, confidence: float):
+    def __init__(self, content, task_type, source, confidence, processing_time):
         self.content = content
         self.task_type = task_type
         self.source = source
         self.confidence = confidence
+        self.processing_time = processing_time
+
+try:
+    from models.local_chat_model import ChatLocal
+    from models.local_code_model import CodeLocal
+    from models.local_image_model import ImageLocal
+except ImportError:
+    ChatLocal = None
+    CodeLocal = None
+    ImageLocal = None
 
 class SuperOrchestrator:
     def __init__(self, config: SuperConfig):
         self.config = config
-        self.usage_stats = {"openai": 0, "deepseek": 0, "gemini": 0}
-        self.load_times = {"openai": "0.3s", "deepseek": "0.4s", "gemini": "0.5s"}
-        self.conversation_context: List[str] = []
+        self.logger = logging.getLogger("super_chatbot")
+        self._setup_logger()
+        self.history: List[str] = []
+        self.local_chat = ChatLocal() if (ChatLocal and config.enable_local_models) else None
+        self.local_code = CodeLocal() if (CodeLocal and config.enable_local_models) else None
+        self.local_image = ImageLocal() if (ImageLocal and config.enable_local_models) else None
 
-        self.model_priority = {
-            "código": ["deepseek","openai","gemini"],
-            "depuración": ["deepseek","openai","gemini"],
-            "explicación_código": ["deepseek","openai","gemini"],
-            "razonamiento_matemático": ["openai","gemini","deepseek"],
-            "traducción": ["openai","gemini","deepseek"],
-            "resumen": ["openai","gemini","deepseek"],
-            "generación_imagen": ["gemini","openai","deepseek"],
-            "investigación": ["openai","gemini","deepseek"],
-            "escritura_creativa": ["gemini","openai","deepseek"],
-            "conversación": ["gemini","openai","deepseek"],
-        }
+    def _setup_logger(self):
+        if not self.logger.handlers:
+            self.logger.setLevel(logging.DEBUG if self.config.debug_mode else logging.INFO)
+            ch = logging.StreamHandler()
+            ch.setLevel(logging.DEBUG)
+            self.logger.addHandler(ch)
 
-        self.openai = OpenAIClient(config.openai_api_key) if config.openai_api_key else None
-        self.deepseek = DeepSeekClient(config.deepseek_api_key) if config.deepseek_api_key else None
-        self.gemini = GeminiClient(config.gemini_api_key) if config.gemini_api_key else None
+    def process(self, message: str, task_type: str = TaskType.CONVERSATION) -> SuperResponse:
+        start = datetime.now()
+        self.history.append(message)
+        if len(self.history) > self.config.max_history:
+            self.history = self.history[-self.config.max_history:]
 
-    def _build_context(self) -> List[str]:
-        return self.conversation_context[-10:]
+        content = None
+        source = "local"
 
-    def _call_model(self, model_name: str, message: str, task_type: str) -> str:
-        if model_name == "openai":
-            if not self.openai:
-                raise Exception("OpenAI API Key no configurada")
-            return self.openai.chat(message, self._build_context(), task_type)
-        elif model_name == "deepseek":
-            if not self.deepseek:
-                raise Exception("DeepSeek API Key no configurada")
-            return self.deepseek.chat(message, self._build_context(), task_type)
-        elif model_name == "gemini":
-            if not self.gemini:
-                raise Exception("Gemini API Key no configurada")
-            return self.gemini.chat(message, self._build_context(), task_type)
-        else:
-            raise Exception(f"Modelo desconocido: {model_name}")
+        if task_type in [TaskType.CONVERSATION, TaskType.CREATIVE_WRITING]:
+            if self.local_chat:
+                try:
+                    content = self.local_chat.generate(message, task_type)
+                    source = "local_chat"
+                except Exception as e:
+                    self.logger.error(f"Fallo local_chat: {str(e)}")
+                    content = None
 
-    def process(self, message: str, task_type: str) -> SuperResponse:
-        self.conversation_context.append(f"Usuario: {message}")
-        if len(self.conversation_context) > 20:
-            self.conversation_context = self.conversation_context[-20:]
-
-        candidates = self.model_priority.get(task_type, ["gemini","openai","deepseek"])
+        if not content and self.local_code:
+            try:
+                content = self.local_code.generate_code(message, task_type)
+                source = "local_code"
+            except Exception as e:
+                self.logger.error(f"Fallo local_code: {str(e)}")
+                content = None
 
-        for model_name in candidates:
+        if not content and self.local_image and task_type == TaskType.IMAGE_GENERATION:
             try:
-                start = time.time()
-                response_text = self._call_model(model_name, message, task_type)
-                elapsed = time.time() - start
-                self.usage_stats[model_name] += 1
-                if response_text and isinstance(response_text, str) and len(response_text) > 0:
-                    self.conversation_context.append(f"Asistente: {response_text}")
-                    return SuperResponse(response_text, task_type, model_name, 0.95)
+                content = self.local_image.generate(message)
+                source = "local_image"
             except Exception as e:
-                if self.config.debug_mode:
-                    print(f"Error llamando a {model_name}: {str(e)}")
-                continue
+                self.logger.error(f"Fallo local_image: {str(e)}")
+                content = None
+
+        if not content:
+            content = "Lo siento, no pude generar una respuesta con los modelos locales disponibles."
+            source = "fallback"
 
-        fallback = "Lo siento, no pude procesar tu solicitud con los modelos disponibles."
-        self.conversation_context.append(f"Asistente: {fallback}")
-        return SuperResponse(fallback, task_type, "ninguno", 0.0)
+        duration = (datetime.now() - start).total_seconds()
+        return SuperResponse(content, task_type, source, 0.85, duration)