feat: add Requesty provider (#1145)

## Summary

Adds **Requesty** as a new named LLM provider, mirroring the existing
OpenRouter provider exactly. Requesty is an OpenAI-compatible LLM router
(base URL `https://router.requesty.ai/v1`) that uses the same
`provider/model` naming scheme as OpenRouter (e.g.
`openai/gpt-4o-mini`).

Because Requesty is OpenAI-compatible and behaves like OpenRouter
(including the same optional reasoning directive shape), the
implementation is a structural 1:1 mirror of
`src/any_llm/providers/openrouter/`, changing only the provider id,
class name, base URL, env var, and documentation URL.

## What changed

- **`src/any_llm/providers/requesty/`** (new package): `requesty.py`,
`__init__.py`, `utils.py` mirroring the OpenRouter provider.
  - `API_BASE = "https://router.requesty.ai/v1"`
- `ENV_API_KEY_NAME` = `REQUESTY_API_KEY`, `ENV_API_BASE_NAME =
"REQUESTY_API_BASE"`
  - `PROVIDER_NAME = "requesty"`, docs at `https://docs.requesty.ai`
- Subclasses `BaseOpenAIProvider`, same reasoning-directive handling and
`_convert_models_list` model-normalization as OpenRouter.
- **`src/any_llm/constants.py`**: added `REQUESTY = "requesty"` to the
`LLMProvider` enum.
- **`pyproject.toml`**: added the `requesty = []` optional-dependency
group and included `requesty` in the `all` extra (the OpenAI-compatible
base requires no extra SDK, same as OpenRouter).
- **`tests/unit/providers/test_requesty_provider.py`** (new): full
mirror of `test_openrouter_provider.py` (reasoning directive, streaming,
max_tokens remap, model-list normalization, round-trip serialization).

The factory (`AnyLLM._create_provider`) discovers providers dynamically
from the enum value, so no factory/mapping edit is needed; the enum +
matching package name + pyproject group is the full registration
surface, which the repo's exhaustiveness tests enforce.

## Note on the README

The README does not contain a committed supported-provider list/table
(the provider list is generated to GitBook via
`scripts/convert_to_gitbook.py` and published to `docs.mozilla.ai`, not
committed). The only OpenRouter mention in the README is the "Proxy Only
Solutions" comparison paragraph, where adding Requesty would be
inappropriate. Happy to add a docs/provider entry wherever the
maintainers prefer.

## Usage

```python
from any_llm import AnyLLM

provider = AnyLLM.create("requesty", api_key="<REQUESTY_API_KEY>")
completion = provider.completion(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}],
)
```

Set `REQUESTY_API_KEY` in your environment, or pass `api_key=` directly.

## Testing & linting

- `uv run pytest tests/unit/providers/test_requesty_provider.py
tests/unit/providers/test_openrouter_provider.py
tests/unit/test_provider.py
tests/unit/test_provider_pyproject_options.py -q` -> **127 passed, 9
skipped** (includes the enum/pyproject/load exhaustiveness tests that
load every provider).
- `ruff@0.15.12 check` and `ruff@0.15.12 format --check` (the pinned
pre-commit version) -> clean on the new files.
- `uv run mypy src/any_llm/providers/requesty/` (strict) -> `Success: no
issues found`.

## Disclosure

I work at Requesty. Happy to adjust scope/naming or close if out of
scope.


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Added support for the Requesty provider, including completion
streaming.
* Enabled reasoning support for Requesty-based completions, with correct
request shaping.

* **Tests**
* Added comprehensive unit tests for Requesty completion parameters,
reasoning injection, and model-list conversion.

* **Chores**
* Updated optional dependencies to include the Requesty provider extra
(as a newly available provider option).
<!-- end of auto-generated comment: release notes by coderabbit.ai -->


## PR Type

- 🆕 New Feature

## Relevant issues

N/A

## Checklist

- [x] I understand the code I am submitting.
- [x] I have added unit tests that prove my fix/feature works
- [x] I have run this code locally and verified it fixes the issue.
- [x] New and existing tests pass locally
- [x] Documentation was updated where necessary
- [x] I have read and followed the [contribution
guidelines](https://github.com/mozilla-ai/any-llm/blob/main/CONTRIBUTING.md)
- [x] **AI Usage:**
    - [x] AI was used for drafting/refactoring.

## AI Usage Information

- AI Model used: Claude Opus
- AI Developer Tool used: CLI agent
- Any other info you'd like to share: The provider is a structural 1:1
mirror of the existing OpenRouter provider; I reviewed every line, ran
the unit tests (new + openrouter) and the enum/pyproject exhaustiveness
tests locally, and confirmed ruff + mypy pass before submitting.

- [ ] I am an AI Agent filling out this form (check box if true)

Author: Thibaultjaigu

pyproject.toml

@@ -21,7 +21,7 @@ dependencies = [
 [project.optional-dependencies]
 
 all = [
-  "any-llm-sdk[mistral,anthropic,huggingface,gemini,vertexai,vertexaianthropic,cohere,cerebras,fireworks,groq,bedrock,azure,azureanthropic,azureopenai,watsonx,together,sambanova,ollama,moonshot,neosantara,nebius,xai,databricks,deepseek,inception,openai,otari,openrouter,portkey,qiniu,lmstudio,llama,voyage,perplexity,platform,llamafile,llamacpp,sagemaker,github,zai,minimax,mzai,vllm,dashscope,deepinfra]"
+  "any-llm-sdk[mistral,anthropic,huggingface,gemini,vertexai,vertexaianthropic,cohere,cerebras,fireworks,groq,bedrock,azure,azureanthropic,azureopenai,watsonx,together,sambanova,ollama,moonshot,neosantara,nebius,xai,databricks,deepseek,inception,openai,otari,openrouter,portkey,qiniu,requesty,lmstudio,llama,voyage,perplexity,platform,llamafile,llamacpp,sagemaker,github,zai,minimax,mzai,vllm,dashscope,deepinfra]"
 ]
 
 platform = [
@@ -128,6 +128,7 @@ openai = []
 openrouter = []
 portkey = []
 qiniu = []
+requesty = []
 sambanova = []
 minimax = []
 mzai = []

src/any_llm/constants.py

@@ -46,6 +46,7 @@ class LLMProvider(StrEnum):
     OPENROUTER = "openrouter"
     PORTKEY = "portkey"
     QINIU = "qiniu"
+    REQUESTY = "requesty"
     SAMBANOVA = "sambanova"
     SAGEMAKER = "sagemaker"
     TOGETHER = "together"

src/any_llm/providers/requesty/__init__.py

@@ -0,0 +1,3 @@
+from .requesty import RequestyProvider
+
+__all__ = ["RequestyProvider"]

src/any_llm/providers/requesty/requesty.py

@@ -0,0 +1,54 @@
+from collections.abc import Sequence
+from typing import Any
+
+from typing_extensions import override
+
+from any_llm.providers.openai.base import BaseOpenAIProvider
+from any_llm.providers.requesty.utils import _convert_models_list, build_reasoning_directive
+from any_llm.types.completion import CompletionParams
+from any_llm.types.model import Model
+
+
+class RequestyProvider(BaseOpenAIProvider):
+    API_BASE = "https://router.requesty.ai/v1"
+    ENV_API_KEY_NAME = "REQUESTY_API_KEY"
+    ENV_API_BASE_NAME = "REQUESTY_API_BASE"
+    PROVIDER_NAME = "requesty"
+    PROVIDER_DOCUMENTATION_URL = "https://docs.requesty.ai"
+
+    SUPPORTS_COMPLETION_STREAMING = True
+    SUPPORTS_COMPLETION = True
+    SUPPORTS_RESPONSES = False
+    SUPPORTS_COMPLETION_REASONING = True
+    SUPPORTS_EMBEDDING = True
+    # Requesty does not expose a moderation endpoint.
+    SUPPORTS_MODERATION = False
+
+    @staticmethod
+    @override
+    def _convert_list_models_response(response: Any) -> Sequence[Model]:
+        """Convert Requesty list models response to valid Model objects."""
+        return _convert_models_list(response)
+
+    @staticmethod
+    @override
+    def _convert_completion_params(params: CompletionParams, **kwargs: Any) -> dict[str, Any]:
+        """Convert CompletionParams to kwargs for Requesty API, including reasoning directive."""
+        # Extract ``reasoning`` before delegating so the base converter does not
+        # forward it as a top-level kwarg (unsupported by the OpenAI SDK's
+        # ``create()``). Requesty expects it nested under ``extra_body`` instead.
+        reasoning = kwargs.pop("reasoning", None)
+        converted_params = BaseOpenAIProvider._convert_completion_params(params, **kwargs)
+
+        reasoning_directive = build_reasoning_directive(
+            reasoning=reasoning,
+            reasoning_effort=params.reasoning_effort,
+        )
+
+        if reasoning_directive is not None:
+            converted_params.pop("reasoning_effort", None)
+            extra_body = converted_params.get("extra_body", {}).copy()
+            extra_body["reasoning"] = reasoning_directive
+            converted_params["extra_body"] = extra_body
+
+        return converted_params

src/any_llm/providers/requesty/utils.py

@@ -0,0 +1,90 @@
+"""Requesty Provider Utilities.
+
+Utilities for building Requesty-specific request parameters, with explicit
+opt-in handling for reasoning capabilities.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from any_llm.types.model import Model
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def build_reasoning_directive(
+    *,
+    reasoning: Any | None = None,
+    reasoning_effort: str | None = None,
+) -> dict[str, Any] | None:
+    """Build Requesty's reasoning directive from user parameters.
+
+    Args:
+        reasoning: Direct reasoning config (dict/object) for advanced control
+        reasoning_effort: Standard effort level ("low"/"medium"/"high")
+
+    Returns:
+        Dict for request body "reasoning" key, or None to omit
+    """
+    if reasoning is not None:
+        return _normalize_reasoning_obj(reasoning)
+
+    if reasoning_effort and reasoning_effort not in ("auto", "none"):
+        level = str(reasoning_effort).lower()
+        if level in {"low", "medium", "high"}:
+            return {"effort": level}
+
+    return None
+
+
+def _convert_models_list(response: Any) -> Sequence[Model]:
+    """Convert Requesty list models response to valid Model objects.
+
+    Requesty's ``/v1/models`` endpoint omits the ``object`` and
+    ``owned_by`` fields that the OpenAI ``Model`` schema requires. The OpenAI
+    SDK silently accepts those missing fields via ``model_construct()``, but the
+    resulting objects fail round-trip serialization. This function fills the
+    missing required fields while preserving any extra Requesty attributes
+    (e.g. ``name``, ``pricing``) that may already be present on the SDK objects.
+    """
+    raw_models = response.data if hasattr(response, "data") else response
+    result: list[Model] = []
+    for model in raw_models:
+        data: dict[str, Any] = model.model_dump() if hasattr(model, "model_dump") else dict(vars(model))
+        if data.get("object") is None:
+            data["object"] = "model"
+        if data.get("owned_by") is None:
+            data["owned_by"] = "requesty"
+        if data.get("created") is None:
+            data["created"] = 0
+        result.append(Model.model_validate(data))
+    return result
+
+
+def _normalize_reasoning_obj(obj: Any) -> dict[str, Any]:
+    """Normalize reasoning config to Requesty format."""
+
+    def _get(o: Any, k: str) -> Any:
+        return o.get(k) if isinstance(o, dict) else getattr(o, k, None)
+
+    out: dict[str, Any] = {}
+
+    effort = _get(obj, "effort")
+    if effort is not None:
+        out["effort"] = str(effort).lower()
+
+    max_tokens = _get(obj, "max_tokens")
+    if max_tokens is not None:
+        out["max_tokens"] = int(max_tokens)
+
+    exclude = _get(obj, "exclude")
+    if exclude is not None:
+        out["exclude"] = bool(exclude)
+
+    enabled = _get(obj, "enabled")
+    if enabled is not None:
+        out["enabled"] = bool(enabled)
+
+    return out