Update MEDEX_FINAL.py

MEDEX_FINAL.py

@@ -577,6 +577,168 @@ FORMATO ESTRICTO PARA CASOS CLÍNICOS:
             print(f"❌ {error_msg}")
             return error_msg
 
+    async def generate_response_stream(self, query: str):
+        """
+        Genera respuesta médica con streaming REAL para Streamlit.
+        Yielde los chunks progresivamente en lugar de retornar todo al final.
+        """
+
+        # Analizar query
+        user_type = self.detect_user_type(query)
+        is_emergency = self.detect_emergency(query)
+
+        # Actualizar estadísticas
+        self.session_stats["queries"] += 1
+        if is_emergency:
+            self.session_stats["emergencies"] += 1
+        if user_type == "Professional":
+            self.session_stats["professional_queries"] += 1
+        else:
+            self.session_stats["educational_queries"] += 1
+
+        # Crear system prompt
+        system_prompt = self.create_system_prompt(user_type, is_emergency)
+
+        # Configurar herramientas para búsqueda web si no es emergencia
+        tools = None
+        if not is_emergency:
+            tools = [{"type": "builtin_function", "function": {"name": "$web_search"}}]
+
+        # Preparar mensajes
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": query},
+        ]
+
+        # Agregar historial reciente si existe
+        if self.conversation_history:
+            for interaction in self.conversation_history[-3:]:
+                if "user_query" in interaction:
+                    messages.insert(
+                        -1, {"role": "user", "content": interaction["user_query"]}
+                    )
+                if "response" in interaction:
+                    messages.insert(
+                        -1,
+                        {"role": "assistant", "content": interaction["response"][:500]},
+                    )
+
+        print(
+            f"\n🩺 MedeX - Usuario: {user_type.upper()} | Emergencia: {'SÍ' if is_emergency else 'NO'}"
+        )
+
+        # Configurar max_tokens dinámico
+        if user_type == "Educational":
+            max_tokens = 5120
+        else:
+            max_tokens = 5120
+
+        try:
+            # Manejar tool calls si es necesario
+            finish_reason = None
+            full_response = ""
+
+            while finish_reason is None or finish_reason == "tool_calls":
+                stream = self.client.chat.completions.create(
+                    model="kimi-k2-0711-preview",
+                    messages=messages,
+                    temperature=0.6,
+                    max_tokens=max_tokens,
+                    stream=True,
+                    tools=tools,
+                )
+
+                tool_calls = []
+                current_message = {"role": "assistant", "content": ""}
+
+                for chunk in stream:
+                    if chunk.choices:
+                        choice = chunk.choices[0]
+                        finish_reason = choice.finish_reason
+
+                        if choice.delta:
+                            # Contenido normal - YIELD para streaming
+                            if choice.delta.content:
+                                content_chunk = choice.delta.content
+                                full_response += content_chunk
+                                current_message["content"] += content_chunk
+
+                                # YIELD el chunk para Streamlit
+                                yield content_chunk
+
+                            # Tool calls
+                            if choice.delta.tool_calls:
+                                for tool_call in choice.delta.tool_calls:
+                                    if len(tool_calls) <= tool_call.index:
+                                        tool_calls.extend(
+                                            [None]
+                                            * (tool_call.index + 1 - len(tool_calls))
+                                        )
+
+                                    if tool_calls[tool_call.index] is None:
+                                        tool_calls[tool_call.index] = {
+                                            "id": tool_call.id,
+                                            "type": tool_call.type,
+                                            "function": {
+                                                "name": tool_call.function.name,
+                                                "arguments": "",
+                                            },
+                                        }
+
+                                    if tool_call.function.arguments:
+                                        tool_calls[tool_call.index]["function"][
+                                            "arguments"
+                                        ] += tool_call.function.arguments
+
+                # Si hay tool calls, procesarlos
+                if finish_reason == "tool_calls" and tool_calls:
+                    current_message["tool_calls"] = [
+                        tc for tc in tool_calls if tc is not None
+                    ]
+                    messages.append(current_message)
+
+                    yield "\n\n🔍 _Buscando información médica actualizada..._\n\n"
+
+                    for tool_call in current_message["tool_calls"]:
+                        if tool_call["function"]["name"] == "$web_search":
+                            try:
+                                arguments = json.loads(
+                                    tool_call["function"]["arguments"]
+                                )
+                                messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tool_call["id"],
+                                        "name": "$web_search",
+                                        "content": json.dumps(arguments),
+                                    }
+                                )
+                            except:
+                                messages.append(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tool_call["id"],
+                                        "name": "$web_search",
+                                        "content": json.dumps({"query": query}),
+                                    }
+                                )
+
+            # Guardar en historial
+            self.conversation_history.append(
+                {
+                    "timestamp": datetime.now().isoformat(),
+                    "user_query": query,
+                    "response": full_response,
+                    "user_type": user_type,
+                    "is_emergency": is_emergency,
+                }
+            )
+
+        except Exception as e:
+            error_msg = f"❌ Error en streaming: {e}"
+            print(error_msg)
+            yield error_msg
+
     async def _generate_streaming(
         self,
         messages: List[Dict],