hhhh

my_tools.py

@@ -27,21 +27,57 @@ class GeminiLLM(LLM):
     model_name: str = Field(default="models/gemini-1.5-flash-latest")
     temperature: float = Field(default=0.0)
 
+    # Atributos para el modelo y config de generación.
+    # Pydantic los ignorará si no son Fields y Config.extra = "allow" (lo cual tienes)
+    _model: object = None
+    _gen_cfg: object = None
+
     class Config:
         extra = "allow"
 
     def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+        super().__init__(**kwargs) # Pydantic procesa campos y kwargs
+
+        # --- INICIO DE LA CORRECCIÓN PARA FieldInfo ---
+        # Obtener el valor resuelto de model_name explícitamente
+        # Primero, intentar con el atributo de instancia (que Pydantic debería haber establecido)
+        actual_model_name = self.model_name 
+        
+        # Si sigue siendo un FieldInfo (o no es un string), obtener el valor default del campo
+        if not isinstance(actual_model_name, str):
+            # Acceder a la definición del campo de la clase para obtener su default
+            # self.__fields__ es un dict de los campos Pydantic de la clase
+            model_field_definition = self.__fields__.get("model_name")
+            if model_field_definition and hasattr(model_field_definition, 'default'):
+                actual_model_name = model_field_definition.default
+            
+            # Como última salvaguarda, si todo falla, usar un string literal (no ideal)
+            if not isinstance(actual_model_name, str):
+                # print("ADVERTENCIA: model_name no se pudo resolver a un string, usando valor literal.")
+                actual_model_name = "models/gemini-1.5-flash-latest" 
+        
+        # Lo mismo para temperature, aunque es menos probable que sea un FieldInfo aquí
+        actual_temperature = self.temperature
+        if not isinstance(actual_temperature, (float, int)):
+            temp_field_definition = self.__fields__.get("temperature")
+            if temp_field_definition and hasattr(temp_field_definition, 'default'):
+                actual_temperature = temp_field_definition.default
+            if not isinstance(actual_temperature, (float, int)):
+                # print("ADVERTENCIA: temperature no se pudo resolver a un float, usando 0.0.")
+                actual_temperature = 0.0
+        # --- FIN DE LA CORRECCIÓN PARA FieldInfo ---
+
         key = os.getenv("GEMINI_API_KEY")
         if not key:
             raise ValueError("GEMINI_API_KEY no configurada")
         genai.configure(api_key=key)
-        self._gen_cfg = genai.types.GenerationConfig(temperature=self.temperature)
+        
+        self._gen_cfg = genai.types.GenerationConfig(temperature=actual_temperature)
         self._model = genai.GenerativeModel(
-            model_name=self.model_name,
+            model_name=actual_model_name, # Usar el valor de string resuelto
             generation_config=self._gen_cfg
         )
-        # Inicializar callback_manager si no se pasa en kwargs
+        
         if self.callback_manager is None:
             from llama_index.core.callbacks.base import CallbackManager
             self.callback_manager = CallbackManager([])
@@ -51,15 +87,28 @@ class GeminiLLM(LLM):
 
     @property
     def metadata(self):
+        # También asegurar que model_name es un string aquí
+        actual_model_name_meta = self.model_name
+        if not isinstance(actual_model_name_meta, str):
+            model_field_def_meta = self.__fields__.get("model_name")
+            if model_field_def_meta and hasattr(model_field_def_meta, 'default'):
+                actual_model_name_meta = model_field_def_meta.default
+            if not isinstance(actual_model_name_meta, str):
+                 actual_model_name_meta = "models/gemini-1.5-flash-latest" # Fallback
+
         return LLMMetadata(
             context_window=1048576,
             num_output=8192,
             is_chat_model=True,
             is_function_calling_model=True,
-            model_name=self.model_name,
+            model_name=actual_model_name_meta, # Usar el valor de string resuelto
         )
 
-    def chat(self, messages: list[ChatMessage], **kwargs): # Añadido tipo para messages
+    # ... (todos los demás métodos: chat, achat, stream_complete, astream_complete, stream_chat, astream_chat, complete, acomplete)
+    # DEBEN ESTAR EXACTAMENTE COMO EN TU ÚLTIMA VERSIÓN FUNCIONAL DEL CÓDIGO QUE ME PEGASTE.
+    # Los copio de tu último fragmento para asegurar consistencia:
+
+    def chat(self, messages: list[ChatMessage], **kwargs):
         hist = []
         for m in messages[:-1]:
             role = "user" if m.role == "user" else "model"
@@ -72,10 +121,10 @@ class GeminiLLM(LLM):
         except Exception as e:
             return ChatMessage(role="assistant", content=f"Error Gemini chat: {e}")
 
-    async def achat(self, messages: list[ChatMessage], **kwargs): # Añadido tipo para messages
+    async def achat(self, messages: list[ChatMessage], **kwargs):
         return await asyncio.to_thread(self.chat, messages, **kwargs)
 
-    def stream_complete(self, prompt: str, formatted=False, **kwargs): # Añadido tipo para prompt
+    def stream_complete(self, prompt: str, formatted=False, **kwargs):
         stream = self._model.generate_content(str(prompt), stream=True)
         def gen():
             acc = ""
@@ -88,17 +137,14 @@ class GeminiLLM(LLM):
                     yield CompletionResponse(text=acc, delta=delta)
         return gen()
 
-    async def astream_complete(self, prompt: str, formatted=False, **kwargs): # Añadido tipo para prompt
-        # Correctamente, esto debería devolver un generador asíncrono.
-        # Envolver el generador síncrono es un workaround común.
+    async def astream_complete(self, prompt: str, formatted=False, **kwargs):
         sync_gen = await asyncio.to_thread(self.stream_complete, prompt, formatted=formatted, **kwargs)
         async def async_gen_wrapper():
             for item in sync_gen:
                 yield item
         return async_gen_wrapper()
 
-
-    def stream_chat(self, messages: list[ChatMessage], **kwargs): # Añadido tipo para messages
+    def stream_chat(self, messages: list[ChatMessage], **kwargs):
         hist = []
         for m in messages[:-1]:
             role = "user" if m.role == "user" else "model"
@@ -117,25 +163,24 @@ class GeminiLLM(LLM):
                     yield ChatMessage(role="assistant", content=acc, additional_kwargs={"delta": delta})
         return gen()
 
-    # --- MÉTODO FALTANTE AÑADIDO AQUÍ ---
-    async def astream_chat(self, messages: list[ChatMessage], **kwargs): # Añadido tipo para messages
-        # Similar a astream_complete, envolvemos el generador síncrono
+    async def astream_chat(self, messages: list[ChatMessage], **kwargs):
         sync_gen = await asyncio.to_thread(self.stream_chat, messages, **kwargs)
         async def async_gen_wrapper():
             for item in sync_gen:
                 yield item
         return async_gen_wrapper()
-    # --- FIN DEL MÉTODO AÑADIDO ---
 
-    def complete(self, prompt: str, formatted=False, **kwargs): # Añadido tipo para prompt
+    def complete(self, prompt: str, formatted=False, **kwargs):
         try:
             resp = self._model.generate_content(str(prompt))
             return CompletionResponse(text=resp.text)
         except Exception as e:
             return CompletionResponse(text=f"Error Gemini complete: {e}")
 
-    async def acomplete(self, prompt: str, formatted=False, **kwargs): # Añadido tipo para prompt
+    async def acomplete(self, prompt: str, formatted=False, **kwargs):
         return await asyncio.to_thread(self.complete, prompt, formatted=formatted, **kwargs)
+
+# --- Fin de la clase GeminiLLM ---
 # -------------------------------------------------------------------
 # 2) Herramientas
 # -------------------------------------------------------------------