feat: add Requesty LLM provider

Add RequestyLLM mirroring the existing OpenRouterLLM, using Requesty's
OpenAI-compatible router endpoint (https://router.requesty.ai/v1).

- New semantic_router/llms/requesty.py with RequestyLLM
- Export RequestyLLM from semantic_router.llms
- Unit tests in tests/unit/llms/test_llm_requesty.py

Author: Thibaultjaigu

semantic_router/llms/__init__.py

@@ -4,13 +4,15 @@
 from semantic_router.llms.mistral import MistralAILLM
 from semantic_router.llms.openai import OpenAILLM
 from semantic_router.llms.openrouter import OpenRouterLLM
+from semantic_router.llms.requesty import RequestyLLM
 from semantic_router.llms.zure import AzureOpenAILLM
 
 __all__ = [
     "BaseLLM",
     "OpenAILLM",
     "LlamaCppLLM",
     "OpenRouterLLM",
+    "RequestyLLM",
     "CohereLLM",
     "AzureOpenAILLM",
     "MistralAILLM",

semantic_router/llms/requesty.py

@@ -0,0 +1,81 @@
+import os
+from typing import List, Optional
+
+import openai
+from pydantic import PrivateAttr
+
+from semantic_router.llms import BaseLLM
+from semantic_router.schema import Message
+from semantic_router.utils.logger import logger
+
+
+class RequestyLLM(BaseLLM):
+    """LLM for Requesty. Requires a Requesty API key, see here for more information
+    https://docs.requesty.ai/quickstart"""
+
+    _client: Optional[openai.OpenAI] = PrivateAttr(default=None)
+    _base_url: str = PrivateAttr(default="https://router.requesty.ai/v1")
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        requesty_api_key: Optional[str] = None,
+        base_url: str = "https://router.requesty.ai/v1",
+        temperature: float = 0.01,
+        max_tokens: int = 200,
+    ):
+        """Initialize the RequestyLLM.
+
+        :param name: The name of the Requesty model to use.
+        :type name: Optional[str]
+        :param requesty_api_key: The Requesty API key.
+        :type requesty_api_key: Optional[str]
+        :param base_url: The base URL for the Requesty API.
+        :type base_url: str
+        :param temperature: The temperature of the LLM.
+        :type temperature: float
+        :param max_tokens: The maximum number of tokens to generate.
+        :type max_tokens: int
+        """
+        if name is None:
+            name = os.getenv("REQUESTY_CHAT_MODEL_NAME", "openai/gpt-4o-mini")
+        super().__init__(name=name)
+        self._base_url = base_url
+        api_key = requesty_api_key or os.getenv("REQUESTY_API_KEY")
+        if api_key is None:
+            raise ValueError("Requesty API key cannot be 'None'.")
+        try:
+            self._client = openai.OpenAI(api_key=api_key, base_url=self._base_url)
+        except Exception as e:
+            raise ValueError(
+                f"Requesty API client failed to initialize. Error: {e}"
+            ) from e
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+
+    def __call__(self, messages: List[Message]) -> str:
+        """Call the RequestyLLM.
+
+        :param messages: The messages to pass to the RequestyLLM.
+        :type messages: List[Message]
+        :return: The response from the RequestyLLM.
+        :rtype: str
+        """
+        if self._client is None:
+            raise ValueError("Requesty client is not initialized.")
+        try:
+            completion = self._client.chat.completions.create(
+                model=self.name,
+                messages=[m.to_openai() for m in messages],
+                temperature=self.temperature,
+                max_tokens=self.max_tokens,
+            )
+
+            output = completion.choices[0].message.content
+
+            if not output:
+                raise Exception("No output generated")
+            return output
+        except Exception as e:
+            logger.error(f"LLM error: {e}")
+            raise Exception(f"LLM error: {e}") from e

tests/unit/llms/test_llm_requesty.py

@@ -0,0 +1,60 @@
+import pytest
+
+from semantic_router.llms import RequestyLLM
+from semantic_router.schema import Message
+
+
+@pytest.fixture
+def requesty_llm(mocker):
+    mocker.patch("openai.Client")
+    return RequestyLLM(requesty_api_key="test_api_key")
+
+
+class TestRequestyLLM:
+    def test_requesty_llm_init_with_api_key(self, requesty_llm):
+        assert requesty_llm._client is not None, "Client should be initialized"
+        assert (
+            requesty_llm.name == "openai/gpt-4o-mini"
+        ), "Default name not set correctly"
+
+    def test_requesty_llm_init_success(self, mocker):
+        mocker.patch("os.getenv", return_value="fake-api-key")
+        llm = RequestyLLM()
+        assert llm._client is not None
+
+    def test_requesty_llm_init_without_api_key(self, mocker):
+        mocker.patch("os.getenv", return_value=None)
+        with pytest.raises(ValueError) as _:
+            RequestyLLM()
+
+    def test_requesty_llm_call_uninitialized_client(self, requesty_llm):
+        # Set the client to None to simulate an uninitialized client
+        requesty_llm._client = None
+        with pytest.raises(ValueError) as e:
+            llm_input = [Message(role="user", content="test")]
+            requesty_llm(llm_input)
+        assert "Requesty client is not initialized." in str(e.value)
+
+    def test_requesty_llm_init_exception(self, mocker):
+        mocker.patch("os.getenv", return_value="fake-api-key")
+        mocker.patch("openai.OpenAI", side_effect=Exception("Initialization error"))
+        with pytest.raises(ValueError) as e:
+            RequestyLLM()
+        assert (
+            "Requesty API client failed to initialize. Error: Initialization error"
+            in str(e.value)
+        )
+
+    def test_requesty_llm_call_success(self, requesty_llm, mocker):
+        mock_completion = mocker.MagicMock()
+        mock_completion.choices[0].message.content = "test"
+
+        mocker.patch("os.getenv", return_value="fake-api-key")
+        mocker.patch.object(
+            requesty_llm._client.chat.completions,
+            "create",
+            return_value=mock_completion,
+        )
+        llm_input = [Message(role="user", content="test")]
+        output = requesty_llm(llm_input)
+        assert output == "test"