Add Blaxel, SambaNova, Nebius, and Hugging Face LLM providers

agent/llm_client.py

@@ -1,6 +1,6 @@
 """
 LLM Client for Overgrowth Pipeline
-Supports multiple providers: OpenAI, Anthropic, OpenRouter
+Supports multiple providers: OpenAI, Anthropic, Blaxel, SambaNova, Nebius, Hugging Face
 """
 
 import os
@@ -42,6 +42,10 @@ class LLMClient:
         # Support both standard and MCP hackathon naming conventions
         self.openai_key = _get_env(["OPENAI_API_KEY", "OPENAI_MCP_1ST_BDAY"])
         self.anthropic_key = _get_env(["ANTHROPIC_API_KEY", "ANTHROPIC_MCP_1ST_BDAY"])
+        self.blaxel_key = _get_env(["BLAXEL_MCP_1ST_BDAY"])
+        self.sambanova_key = _get_env(["SAMBA_NOVA_MCP_1ST_BDAY"])
+        self.nebius_key = _get_env(["NEBIUS_MCP_1ST_BDAY"])
+        self.huggingface_key = _get_env(["HUGGING_FACE_MCP_1ST_BDAY"])
         
         # Determine which provider to use
         self.provider = self._detect_provider()
@@ -67,12 +71,24 @@ class LLMClient:
         status = {
             "openai_key": "present" if _present(["OPENAI_API_KEY", "OPENAI_MCP_1ST_BDAY"]) else "missing",
             "anthropic_key": "present" if _present(["ANTHROPIC_API_KEY", "ANTHROPIC_MCP_1ST_BDAY"]) else "missing",
+            "blaxel_key": "present" if _present(["BLAXEL_MCP_1ST_BDAY"]) else "missing",
+            "sambanova_key": "present" if _present(["SAMBA_NOVA_MCP_1ST_BDAY"]) else "missing",
+            "nebius_key": "present" if _present(["NEBIUS_MCP_1ST_BDAY"]) else "missing",
+            "huggingface_key": "present" if _present(["HUGGING_FACE_MCP_1ST_BDAY"]) else "missing",
             "provider": "unknown",
         }
         if status["anthropic_key"] == "present":
             status["provider"] = "anthropic"
         elif status["openai_key"] == "present":
             status["provider"] = "openai"
+        elif status["blaxel_key"] == "present":
+            status["provider"] = "blaxel"
+        elif status["sambanova_key"] == "present":
+            status["provider"] = "sambanova"
+        elif status["nebius_key"] == "present":
+            status["provider"] = "nebius"
+        elif status["huggingface_key"] == "present":
+            status["provider"] = "huggingface"
         return status
     
     def _detect_provider(self) -> Optional[str]:
@@ -81,6 +97,14 @@ class LLMClient:
             return "anthropic"
         elif self.openai_key:
             return "openai"
+        elif self.blaxel_key:
+            return "blaxel"
+        elif self.sambanova_key:
+            return "sambanova"
+        elif self.nebius_key:
+            return "nebius"
+        elif self.huggingface_key:
+            return "huggingface"
         return None
     
     def chat(
@@ -101,6 +125,14 @@ class LLMClient:
             return self._call_openai(messages, temperature, max_tokens, stream)
         elif self.provider == "anthropic":
             return self._call_anthropic(messages, temperature, max_tokens, stream)
+        elif self.provider == "blaxel":
+            return self._call_blaxel(messages, temperature, max_tokens)
+        elif self.provider == "sambanova":
+            return self._call_sambanova(messages, temperature, max_tokens)
+        elif self.provider == "nebius":
+            return self._call_nebius(messages, temperature, max_tokens)
+        elif self.provider == "huggingface":
+            return self._call_huggingface(messages, temperature, max_tokens)
     
     def chat_stream(
         self,
@@ -116,6 +148,9 @@ class LLMClient:
             yield from self._stream_openai(messages, temperature, max_tokens)
         elif self.provider == "anthropic":
             yield from self._stream_anthropic(messages, temperature, max_tokens)
+        else:
+            # Other providers: no streaming support; fall back to single response
+            yield self.chat(messages, temperature=temperature, max_tokens=max_tokens)
     
     def _call_openrouter(self, messages, temperature, max_tokens, stream):
         """Call OpenRouter API"""
@@ -308,6 +343,161 @@ class LLMClient:
                 yield from self._stream_openai(messages, temperature, max_tokens)
             else:
                 raise RuntimeError(f"Anthropic streaming failed: {err_msg}")
+
+    # ----- Additional Providers (non-streaming) -----
+    def _call_blaxel(self, messages, temperature, max_tokens):
+        """Call Blaxel sandbox API (OpenAI-style)."""
+        import requests
+        call_id = str(uuid.uuid4())
+        model = os.getenv("BLAXEL_MODEL", "blaxel/claude-3-haiku")
+        base_url = os.getenv("BLAXEL_BASE_URL", "https://api.blaxel.ai/v0")
+        endpoint = f\"{base_url.rstrip('/')}/chat/completions\"
+        if monitor:
+            monitor.start_call(call_id, \"llm\", \"blaxel\", model, temperature=temperature)
+        payload = {
+            \"model\": model,
+            \"messages\": [{\"role\": m.role, \"content\": m.content} for m in messages],
+            \"temperature\": temperature,
+            \"max_tokens\": max_tokens,
+        }
+        headers = {\"Authorization\": f\"Bearer {self.blaxel_key}\"}
+        try:
+            resp = requests.post(endpoint, json=payload, headers=headers, timeout=30)
+            resp.raise_for_status()
+            data = resp.json()
+            content = data.get(\"choices\", [{}])[0].get(\"message\", {}).get(\"content\", \"\")
+            usage = data.get(\"usage\", {})
+            if monitor:
+                monitor.complete_call(
+                    call_id,
+                    success=True,
+                    input_tokens=usage.get(\"prompt_tokens\"), 
+                    output_tokens=usage.get(\"completion_tokens\")
+                )
+            return content
+        except Exception as e:
+            if monitor:
+                monitor.complete_call(call_id, success=False, error_message=str(e))
+            raise
+
+    def _call_sambanova(self, messages, temperature, max_tokens):
+        """Call SambaNova API (OpenAI-compatible)."""
+        import requests
+        call_id = str(uuid.uuid4())
+        model = os.getenv("SAMBA_NOVA_MODEL", "Meta-Llama-3-8B-Instruct")
+        base_url = os.getenv("SAMBA_NOVA_BASE_URL", "https://api.sambanova.ai/v1")
+        endpoint = f\"{base_url.rstrip('/')}/chat/completions\"
+        if monitor:
+            monitor.start_call(call_id, \"llm\", \"sambanova\", model, temperature=temperature)
+        payload = {
+            \"model\": model,
+            \"messages\": [{\"role\": m.role, \"content\": m.content} for m in messages],
+            \"temperature\": temperature,
+            \"max_tokens\": max_tokens,
+        }
+        headers = {
+            \"Authorization\": f\"Bearer {self.sambanova_key}\",
+            \"Content-Type\": \"application/json\"
+        }
+        try:
+            resp = requests.post(endpoint, json=payload, headers=headers, timeout=30)
+            resp.raise_for_status()
+            data = resp.json()
+            content = data.get(\"choices\", [{}])[0].get(\"message\", {}).get(\"content\", \"\")
+            usage = data.get(\"usage\", {})
+            if monitor:
+                monitor.complete_call(
+                    call_id,
+                    success=True,
+                    input_tokens=usage.get(\"prompt_tokens\"),
+                    output_tokens=usage.get(\"completion_tokens\")
+                )
+            return content
+        except Exception as e:
+            if monitor:
+                monitor.complete_call(call_id, success=False, error_message=str(e))
+            raise
+
+    def _call_nebius(self, messages, temperature, max_tokens):
+        """Call Nebius Token Factory API (OpenAI-compatible)."""
+        import requests
+        call_id = str(uuid.uuid4())
+        model = os.getenv("NEBIUS_MODEL", "gpt-3.5-turbo")
+        base_url = os.getenv("NEBIUS_BASE_URL", "https://api.studio.nebius.ai/v1")
+        endpoint = f\"{base_url.rstrip('/')}/chat/completions\"
+        if monitor:
+            monitor.start_call(call_id, \"llm\", \"nebius\", model, temperature=temperature)
+        payload = {
+            \"model\": model,
+            \"messages\": [{\"role\": m.role, \"content\": m.content} for m in messages],
+            \"temperature\": temperature,
+            \"max_tokens\": max_tokens,
+        }
+        headers = {
+            \"Authorization\": f\"Bearer {self.nebius_key}\",
+            \"Content-Type\": \"application/json\"
+        }
+        try:
+            resp = requests.post(endpoint, json=payload, headers=headers, timeout=30)
+            resp.raise_for_status()
+            data = resp.json()
+            content = data.get(\"choices\", [{}])[0].get(\"message\", {}).get(\"content\", \"\")
+            usage = data.get(\"usage\", {})
+            if monitor:
+                monitor.complete_call(
+                    call_id,
+                    success=True,
+                    input_tokens=usage.get(\"prompt_tokens\"),
+                    output_tokens=usage.get(\"completion_tokens\")
+                )
+            return content
+        except Exception as e:
+            if monitor:
+                monitor.complete_call(call_id, success=False, error_message=str(e))
+            raise
+
+    def _call_huggingface(self, messages, temperature, max_tokens):
+        """Call Hugging Face Inference API (text generation)."""
+        import requests
+        call_id = str(uuid.uuid4())
+        model = os.getenv("HUGGINGFACE_MODEL", "tiiuae/falcon-7b-instruct")
+        endpoint = f\"https://api-inference.huggingface.co/models/{model}\"
+        if monitor:
+            monitor.start_call(call_id, \"llm\", \"huggingface\", model, temperature=temperature)
+        # Simple prompt concatenation
+        prompt = \"\\n\".join(f\"{m.role.upper()}: {m.content}\" for m in messages)
+        payload = {
+            \"inputs\": prompt,
+            \"parameters\": {
+                \"max_new_tokens\": max_tokens,
+                \"temperature\": temperature,
+                \"return_full_text\": False
+            }
+        }
+        headers = {
+            \"Authorization\": f\"Bearer {self.huggingface_key}\",
+            \"Content-Type\": \"application/json\"
+        }
+        try:
+            resp = requests.post(endpoint, json=payload, headers=headers, timeout=60)
+            resp.raise_for_status()
+            data = resp.json()
+            # Response can be list or dict
+            text = \"\"
+            if isinstance(data, list) and data:
+                if isinstance(data[0], dict):
+                    text = data[0].get(\"generated_text\", \"\") or data[0].get(\"generated_texts\", \"\")
+                else:
+                    text = str(data[0])
+            elif isinstance(data, dict):
+                text = data.get(\"generated_text\", \"\") or data.get(\"generated_texts\", \"\") or \"\"
+            if monitor:
+                monitor.complete_call(call_id, success=True)
+            return text
+        except Exception as e:
+            if monitor:
+                monitor.complete_call(call_id, success=False, error_message=str(e))
+            raise
     
     def _mock_response(self, messages: List[LLMMessage]) -> str:
         """Deprecated: mocks disabled to avoid hiding real failures."""