ssss

my_tools.py

@@ -47,70 +47,67 @@ ChatMessage.message = property(lambda self: self)
 
 # ---------- GEMINI LLM ----------
 class GeminiLLM(LLM):
-    model_name: str = Field(default="models/gemini-1.5-flash-latest")
-    temperature: float = Field(default=0.0)
+    ...
+    # ← aquí ya tienes __init__, metadata, chat, achat, complete, acomplete
+    # ⬇️  pega estos métodos faltantes ⬇️
+
+    def stream_complete(self, prompt: str, formatted: bool = False, **kwargs):
+        """Devuelve un generador incremental de CompletionResponse."""
+        stream = self._model.generate_content(str(prompt), stream=True)
+
+        def gen():
+            acc = ""
+            from llama_index.core.llms import CompletionResponse  # import local
+            for chunk in stream:
+                delta = getattr(chunk, "text", "") or (
+                    chunk.parts[0].text if getattr(chunk, "parts", None) else ""
+                )
+                if delta:
+                    acc += delta
+                    yield CompletionResponse(text=acc, delta=delta)
+
+        return gen()
+
+    async def astream_complete(self, prompt: str, formatted: bool = False, **kwargs):
+        # ejecuta la versión síncrona en un hilo
+        sync_gen = await asyncio.to_thread(self.stream_complete, prompt, formatted=formatted, **kwargs)
+
+        async def async_gen():
+            for item in sync_gen:
+                yield item
+
+        return async_gen()
+
+    def stream_chat(self, messages: list[ChatMessage], **kwargs):
+        hist = [
+            {"role": "user" if m.role == "user" else "model", "parts": [{"text": str(m.content)}]}
+            for m in messages[:-1]
+        ]
+        last = str(messages[-1].content)
+        session = self._model.start_chat(history=hist)
+        stream = session.send_message(last, stream=True)
 
-    _model = None
+        def gen():
+            acc = ""
+            for chunk in stream:
+                delta = getattr(chunk, "text", "") or (
+                    chunk.parts[0].text if getattr(chunk, "parts", None) else ""
+                )
+                if delta:
+                    acc += delta
+                    yield ChatMessage(role="assistant", content=acc, additional_kwargs={"delta": delta})
 
-    class Config:
-        extra = "allow"
+        return gen()
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        api_key = os.getenv("GEMINI_API_KEY")
-        if not api_key:
-            raise ValueError("GEMINI_API_KEY not set in environment")
-        genai.configure(api_key=api_key)
+    async def astream_chat(self, messages: list[ChatMessage], **kwargs):
+        sync_gen = await asyncio.to_thread(self.stream_chat, messages, **kwargs)
 
-        self._model = genai.GenerativeModel(
-            model_name=self.model_name, generation_config=genai.types.GenerationConfig(temperature=self.temperature)
-        )
-        if self.callback_manager is None:
-            from llama_index.core.callbacks.base import CallbackManager
-
-            self.callback_manager = CallbackManager([])
-        if not self.callback_manager.handlers:
-            self.callback_manager.add_handler(LlamaDebugHandler())
-
-    # ----- metadata -----
-    @property
-    def metadata(self):
-        return LLMMetadata(
-            context_window=1_048_576,
-            num_output=8192,
-            is_chat_model=True,
-            is_function_calling_model=True,
-            model_name=self.model_name,
-        )
+        async def async_gen():
+            for item in sync_gen:
+                yield item
+
+        return async_gen()
 
-    # ----- sync chat -----
-    def chat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:
-        history = [
-            {"role": ("user" if m.role == "user" else "model"), "parts": [{"text": str(m.content)}]}
-            for m in messages[:-1]
-        ]
-        last_user_msg = str(messages[-1].content)
-        session = self._model.start_chat(history=history)
-        try:
-            response = session.send_message(last_user_msg)
-            return ChatMessage(role="assistant", content=response.text)
-        except Exception as exc:
-            return ChatMessage(role="assistant", content=f"Error Gemini chat: {exc}")
-
-    # ----- async chat -----
-    async def achat(self, messages: list[ChatMessage], **kwargs):
-        return await asyncio.to_thread(self.chat, messages, **kwargs)
-
-    # ----- completion helpers (rarely used) -----
-    def complete(self, prompt: str, formatted: bool = False, **kwargs):
-        try:
-            resp = self._model.generate_content(str(prompt))
-            return CompletionResponse(text=resp.text)
-        except Exception as exc:
-            return CompletionResponse(text=f"Error Gemini complete: {exc}")
-
-    async def acomplete(self, prompt: str, formatted: bool = False, **kwargs):
-        return await asyncio.to_thread(self.complete, prompt, formatted=formatted, **kwargs)
 
 
 # ---------- TOOLING ----------