Create providers.py

genesis/providers.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import os
+import asyncio
+from typing import List, Tuple
+
+import httpx
+
+# Optional: Gemini and DeepSeek post-processors to polish final text ONLY.
+# They must never add wet-lab protocols or operational steps.
+
+
+async def gemini_postprocess(text: str, citations: List[dict]) -> str:
+    """
+    Polish for clarity/flow using Gemini (sync SDK wrapped in a thread).
+    Falls back to original text if not configured or on error.
+    """
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        return text
+
+    try:
+        import google.generativeai as genai
+
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel("gemini-1.5-flash")
+
+        prompt = (
+            "Polish the following high-level scientific synthesis for clarity and flow. "
+            "Do NOT add wet-lab procedures or any operational/step-by-step details. "
+            "Preserve factual claims and cautious tone.\n\n"
+            f"{text}"
+        )
+
+        def _call_sync() -> str:
+            resp = model.generate_content(prompt)
+            return getattr(resp, "text", None) or text
+
+        return await asyncio.to_thread(_call_sync)
+
+    except Exception:
+        return text
+
+
+async def deepseek_postprocess(text: str, citations: List[dict]) -> str:
+    """
+    Polish using a generic OpenAI-compatible DeepSeek endpoint.
+    Configure DEEPSEEK_BASE_URL and DEEPSEEK_API_KEY (and optionally DEEPSEEK_MODEL).
+    """
+    base = os.getenv("DEEPSEEK_BASE_URL")
+    key = os.getenv("DEEPSEEK_API_KEY")
+    if not base or not key:
+        return text
+
+    try:
+        async with httpx.AsyncClient(timeout=60.0) as http:
+            r = await http.post(
+                f"{base.rstrip('/')}/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {key}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": os.getenv("DEEPSEEK_MODEL", "deepseek-chat"),
+                    "messages": [
+                        {
+                            "role": "system",
+                            "content": (
+                                "You are a scientific editor. Improve structure and clarity only. "
+                                "Never add wet-lab protocols, experimental steps, or operational advice."
+                            ),
+                        },
+                        {
+                            "role": "user",
+                            "content": (
+                                "Polish the following high-level synthesis without adding operational details.\n\n"
+                                f"{text}"
+                            ),
+                        },
+                    ],
+                    "temperature": 0.3,
+                },
+            )
+            data = r.json()
+            return (
+                data.get("choices", [{}])[0]
+                .get("message", {})
+                .get("content", text)
+            )
+    except Exception:
+        return text
+
+
+async def postprocess_summary(base_text: str, citations: List[dict], engine: str = "none") -> str:
+    """
+    Dispatch to the chosen post-processor (none|gemini|deepseek).
+    Always returns safe, high-level text.
+    """
+    engine = (engine or "none").lower()
+    if engine == "gemini":
+        return await gemini_postprocess(base_text, citations)
+    if engine == "deepseek":
+        return await deepseek_postprocess(base_text, citations)
+    return base_text
+
+
+async def synthesize_tts(text: str) -> Tuple[bytes | None, str]:
+    """
+    ElevenLabs TTS → (audio_bytes, mime). Returns (None, "") if not configured.
+    Requires ELEVEN_LABS_API_KEY and optional ELEVEN_LABS_VOICE_ID.
+    """
+    key = os.getenv("ELEVEN_LABS_API_KEY")
+    voice_id = os.getenv("ELEVEN_LABS_VOICE_ID", "21m00Tcm4TlvDq8ikWAM")
+    if not key:
+        return None, ""
+
+    payload = {
+        "text": text[:6000],  # safety limit
+        "model_id": "eleven_multilingual_v2",
+        "voice_settings": {"stability": 0.5, "similarity_boost": 0.75},
+    }
+
+    url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+    async with httpx.AsyncClient(timeout=120.0) as http:
+        r = await http.post(
+            url,
+            headers={"xi-api-key": key, "Accept": "audio/mpeg"},
+            json=payload,
+        )
+        if r.status_code >= 400:
+            # Propagate a readable error to the UI layer
+            raise RuntimeError(f"TTS API error {r.status_code}: {r.text[:200]}")
+        return r.content, r.headers.get("content-type", "audio/mpeg")