pi-ai-python 1.3.0__py3-none-any.whl

pi_ai/providers/openrouter.py

@@ -0,0 +1,145 @@
+"""OpenRouter provider."""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+import math
+import re
+from collections.abc import Sequence
+from typing import Any
+
+import httpx
+
+from ..abort import AbortSignal, abort_scope
+from ..api.registry import (
+    anthropic_messages_api,
+    openai_completions_api,
+    openrouter_images_api,
+    typesafe_system_one_api,
+)
+from ..auth.helpers import env_api_key_auth, lazy_oauth
+from ..auth.oauth.load import load_openrouter_oauth
+from ..auth.types import ProviderAuth
+from ..models import Provider, RefreshModelsContext, create_provider
+from ..types import AnyModel
+from ..utils.http import get_http_client
+from ..utils.model_operations import is_model_type
+from .catalog import catalog_models
+from .openrouter_api import openrouter_cost
+
+__all__ = ["OPENROUTER_BASE_URL", "openrouter_provider", "personalize_openrouter_catalog"]
+
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+OPENROUTER_USER_MODELS_TIMEOUT_MS = 15_000
+
+_TRAILING_SLASHES = re.compile(r"/+$")
+
+
+def _truthy(value: Any) -> bool:
+    """JavaScript truthiness (``{}`` and ``[]`` are truthy, ``NaN`` is not)."""
+    if isinstance(value, float) and math.isnan(value):
+        return False
+    if isinstance(value, (dict, list)):
+        return True
+    return bool(value)
+
+
+def _first_truthy(*values: Any) -> Any:
+    for value in values[:-1]:
+        if _truthy(value):
+            return value
+    return values[-1]
+
+
+async def personalize_openrouter_catalog(
+    catalog: Sequence[AnyModel],
+    context: RefreshModelsContext,
+    *,
+    http_client: httpx.AsyncClient | None = None,
+) -> Sequence[AnyModel]:
+    """Restrict an OpenRouter catalog to the chat models the key may use, with the key's limits and prices.
+
+    Uses ``GET /models/user``. Image and classifier models are returned unchanged and a
+    missing limit keeps the catalog value. The request goes to the provider's configured
+    base URL, so regional endpoints such as ``https://us.openrouter.ai/api/v1`` apply their
+    region's filtering. When the endpoint rejects the key (401/403) or does not exist (404),
+    for example with a proxy configured in models.json, ``catalog`` itself is returned.
+    """
+    credential = context.credential
+    if credential is not None and credential.get("type") == "oauth":
+        key = credential.get("access")
+    else:
+        key = credential.get("key") if credential is not None else None
+    if not key:
+        return catalog
+    base_url = context.base_url if context.base_url is not None else OPENROUTER_BASE_URL
+    url = f"{_TRAILING_SLASHES.sub('', base_url)}/models/user"
+    signal = AbortSignal.any([context.signal, AbortSignal.timeout(OPENROUTER_USER_MODELS_TIMEOUT_MS / 1000)])
+    client = http_client if http_client is not None else get_http_client(url)
+    async with abort_scope(signal):
+        response = await client.get(
+            url,
+            headers={"accept": "application/json", "authorization": f"Bearer {key}"},
+            timeout=OPENROUTER_USER_MODELS_TIMEOUT_MS / 1000,
+        )
+        raw = await response.aread()
+    if response.status_code in (401, 403, 404):
+        return catalog
+    if not response.is_success:
+        raise RuntimeError(f"OpenRouter model list request failed: {response.status_code}")
+    body: Any = json.loads(raw)
+    data = body.get("data") if isinstance(body, dict) else None
+    if not isinstance(data, list):
+        raise ValueError("Invalid OpenRouter model list response")
+    allowed: dict[str, dict[str, Any]] = {}
+    for entry in data:
+        if isinstance(entry, dict) and isinstance(entry.get("id"), str):
+            allowed[entry["id"]] = entry
+
+    personalized: list[AnyModel] = []
+    for model in catalog:
+        if not is_model_type(model, "chat"):
+            personalized.append(model)
+            continue
+        listed = allowed.get(model.id)
+        if listed is None:
+            continue
+        top_provider = listed.get("top_provider")
+        top_provider = top_provider if isinstance(top_provider, dict) else {}
+        pricing = listed.get("pricing")
+        personalized.append(
+            dataclasses.replace(
+                model,  # type: ignore[arg-type]
+                # `or`: OpenRouter reports a missing limit as absent, null or 0, like the generator's fallback.
+                context_window=_first_truthy(
+                    top_provider.get("context_length"),
+                    listed.get("context_length"),
+                    model.context_window,  # type: ignore[union-attr]
+                ),
+                max_tokens=_first_truthy(top_provider.get("max_completion_tokens"), model.max_tokens),  # type: ignore[union-attr]
+                cost=openrouter_cost(pricing) if _truthy(pricing) else model.cost,
+            )
+        )
+    return personalized
+
+
+def openrouter_provider() -> Provider:
+    """OpenRouter (chat, image and System One classifier models): ``OPENROUTER_API_KEY`` or OAuth."""
+    return create_provider(
+        id="openrouter",
+        name="OpenRouter",
+        base_url=OPENROUTER_BASE_URL,
+        auth=ProviderAuth(
+            api_key=env_api_key_auth("OpenRouter API key", ["OPENROUTER_API_KEY"]),
+            oauth=lazy_oauth("OpenRouter OAuth", load_openrouter_oauth, login_label="Sign in with OpenRouter"),
+        ),
+        models=lambda: catalog_models("openrouter"),
+        api={
+            "anthropic-messages": anthropic_messages_api(),
+            "openai-completions": openai_completions_api(),
+        },
+        images={"openrouter-images": openrouter_images_api()},
+        # OpenRouter serves TypeSafe's System One protocol at /api/v1/systemone.
+        classifiers={"typesafe-system-one": typesafe_system_one_api()},
+    )

pi_ai/providers/openrouter_api.py

@@ -0,0 +1,122 @@
+"""OpenRouter model-list shapes and price conversion."""
+
+from __future__ import annotations
+
+import math
+import re
+from typing import Any, TypedDict
+
+from ..types import ModelCost, ModelCostTier
+
+__all__ = [
+    "OpenRouterPricing",
+    "OpenRouterPricingOverride",
+    "OpenRouterTopProvider",
+    "OpenRouterModel",
+    "openrouter_cost",
+]
+
+
+class OpenRouterPricingOverride(TypedDict, total=False):
+    """A conditional price.
+
+    ``min_prompt_tokens`` selects prompt-length pricing; ``utc_*`` fields select
+    time-of-day or weekday pricing. Missing rates keep the base price.
+    """
+
+    min_prompt_tokens: int
+    utc_start: int
+    utc_end: int
+    utc_days: list[str]
+    prompt: str
+    completion: str
+    input_cache_read: str
+    input_cache_write: str
+
+
+class OpenRouterPricing(TypedDict, total=False):
+    """OpenRouter's per-token prices, as decimal strings."""
+
+    prompt: str
+    completion: str
+    input_cache_read: str
+    input_cache_write: str
+    overrides: list[OpenRouterPricingOverride]
+
+
+class OpenRouterTopProvider(TypedDict, total=False):
+    context_length: int | None
+    max_completion_tokens: int | None
+
+
+class OpenRouterModel(TypedDict, total=False):
+    """The fields pi reads from a model in OpenRouter's ``GET /models`` and ``GET /models/user``."""
+
+    id: str
+    context_length: int | None
+    top_provider: OpenRouterTopProvider
+    pricing: OpenRouterPricing
+
+
+_FLOAT_PREFIX = re.compile(r"\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?|[+-]?Infinity)")
+
+
+def _parse_float(value: Any) -> float:
+    """``Number.parseFloat``: the longest numeric prefix, ``nan`` when there is none."""
+    if isinstance(value, bool):
+        value = str(value).lower()
+    if isinstance(value, (int, float)):
+        return float(value)
+    match = _FLOAT_PREFIX.match(str(value) if value is not None else "")
+    if match is None:
+        return math.nan
+    return float(match.group(1).replace("Infinity", "inf"))
+
+
+def _per_million(value: Any, fallback: float) -> float:
+    """Convert one $/token price to $/1M tokens. 0 means free.
+
+    Missing, invalid and negative prices use the fallback: OpenRouter reports -1 for
+    router models such as ``openrouter/auto``, whose price depends on the model they pick.
+    """
+    per_token = _parse_float(value)
+    return round(per_token * 1_000_000, 6) if per_token >= 0 else fallback
+
+
+def openrouter_cost(pricing: OpenRouterPricing | None) -> ModelCost:
+    """Convert OpenRouter's $/token prices to pi's $/1M tokens.
+
+    Missing, invalid and negative base prices are 0. Prompt-length overrides become
+    request-wide tiers; a rate a tier does not list keeps the base price. Time-of-day
+    overrides are skipped because :class:`ModelCost` cannot express them.
+    """
+    pricing = pricing or {}
+    base_input = _per_million(pricing.get("prompt"), 0)
+    base_output = _per_million(pricing.get("completion"), 0)
+    base_cache_read = _per_million(pricing.get("input_cache_read"), 0)
+    base_cache_write = _per_million(pricing.get("input_cache_write"), 0)
+    tiers: list[ModelCostTier] = []
+    for override in pricing.get("overrides") or []:
+        if (
+            override.get("min_prompt_tokens") is None
+            or "utc_start" in override
+            or "utc_end" in override
+            or "utc_days" in override
+        ):
+            continue
+        tiers.append(
+            ModelCostTier(
+                input_tokens_above=override["min_prompt_tokens"],  # type: ignore[typeddict-item]
+                input=_per_million(override.get("prompt"), base_input),
+                output=_per_million(override.get("completion"), base_output),
+                cache_read=_per_million(override.get("input_cache_read"), base_cache_read),
+                cache_write=_per_million(override.get("input_cache_write"), base_cache_write),
+            )
+        )
+    return ModelCost(
+        input=base_input,
+        output=base_output,
+        cache_read=base_cache_read,
+        cache_write=base_cache_write,
+        tiers=tiers or None,
+    )

pi_ai/providers/qwen_token_plan.py

@@ -0,0 +1,23 @@
+"""Qwen Token Plan provider."""
+
+from __future__ import annotations
+
+from ..api.registry import openai_completions_api
+from ..auth.helpers import env_api_key_auth
+from ..auth.types import ProviderAuth
+from ..models import Provider, create_provider
+from .catalog import catalog_models
+
+__all__ = ["qwen_token_plan_provider"]
+
+
+def qwen_token_plan_provider() -> Provider:
+    """Qwen Token Plan (OpenAI-compatible Chat Completions), authenticated with ``QWEN_TOKEN_PLAN_API_KEY``."""
+    return create_provider(
+        id="qwen-token-plan",
+        name="Qwen Token Plan",
+        base_url="https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
+        auth=ProviderAuth(api_key=env_api_key_auth("Qwen Token Plan API key", ["QWEN_TOKEN_PLAN_API_KEY"])),
+        models=lambda: catalog_models("qwen-token-plan"),
+        api=openai_completions_api(),
+    )

pi_ai/providers/qwen_token_plan_cn.py

@@ -0,0 +1,23 @@
+"""Qwen Token Plan CN provider."""
+
+from __future__ import annotations
+
+from ..api.registry import openai_completions_api
+from ..auth.helpers import env_api_key_auth
+from ..auth.types import ProviderAuth
+from ..models import Provider, create_provider
+from .catalog import catalog_models
+
+__all__ = ["qwen_token_plan_cn_provider"]
+
+
+def qwen_token_plan_cn_provider() -> Provider:
+    """Qwen Token Plan CN (OpenAI-compatible Chat Completions), authenticated with ``QWEN_TOKEN_PLAN_CN_API_KEY``."""
+    return create_provider(
+        id="qwen-token-plan-cn",
+        name="Qwen Token Plan CN",
+        base_url="https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
+        auth=ProviderAuth(api_key=env_api_key_auth("Qwen Token Plan CN API key", ["QWEN_TOKEN_PLAN_CN_API_KEY"])),
+        models=lambda: catalog_models("qwen-token-plan-cn"),
+        api=openai_completions_api(),
+    )

pi_ai/providers/qwen_token_plan_individual.py

@@ -0,0 +1,23 @@
+"""Qwen Token Plan Individual provider."""
+
+from __future__ import annotations
+
+from ..api.registry import openai_completions_api
+from ..auth.helpers import env_api_key_auth
+from ..auth.types import ProviderAuth
+from ..models import Provider, create_provider
+from .catalog import catalog_models
+
+__all__ = ["qwen_token_plan_individual_provider"]
+
+
+def qwen_token_plan_individual_provider() -> Provider:
+    """Qwen Token Plan Individual (OpenAI-compatible Chat Completions), authenticated with ``QWEN_TOKEN_PLAN_API_KEY``."""
+    return create_provider(
+        id="qwen-token-plan-individual",
+        name="Qwen Token Plan Individual",
+        base_url="https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
+        auth=ProviderAuth(api_key=env_api_key_auth("Qwen Token Plan Individual API key", ["QWEN_TOKEN_PLAN_API_KEY"])),
+        models=lambda: catalog_models("qwen-token-plan-individual"),
+        api=openai_completions_api(),
+    )

pi_ai/providers/radius.py

@@ -0,0 +1,146 @@
+"""Radius gateway provider with a persisted, dynamically refreshed catalog."""
+
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+import httpx
+
+from ..api.registry import pi_messages_api
+from ..auth.helpers import env_api_key_auth, lazy_oauth
+from ..auth.oauth.load import load_radius_oauth
+from ..auth.types import ProviderAuth
+from ..event_stream import AssistantMessageEventStream
+from ..models import ModelsPublication, Provider, RefreshModelsContext
+from ..models_store import ModelsStoreEntry
+from ..types import Model, TranscriptContext, now_ms
+from .catalog import get_builtin_models
+from .radius_config import (
+    DEFAULT_RADIUS_GATEWAY,
+    get_radius_models,
+    get_radius_models_from_config,
+    load_radius_gateway_config,
+    normalize_radius_gateway_url,
+)
+
+__all__ = ["RadiusProvider", "radius_provider"]
+
+
+class RadiusProvider(Provider):
+    """Radius gateway provider.
+
+    The gateway catalog for the account replaces the shipped baseline once known: Radius
+    organization owners can disable models, so disabled models must not reappear from the
+    baseline. The baseline (default gateway only) covers the time before any catalog exists.
+    """
+
+    def __init__(
+        self,
+        *,
+        id: str = "radius",
+        name: str = "Radius",
+        gateway: str = DEFAULT_RADIUS_GATEWAY,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        self.id = id
+        self.name = name
+        self.gateway = normalize_radius_gateway_url(gateway)
+        self._http_client = http_client
+        self._use_public_catalog = self.gateway == normalize_radius_gateway_url(DEFAULT_RADIUS_GATEWAY)
+        self._baseline: list[Model] | None = None
+        self._dynamic: list[Model] | None = None
+        self._streams = pi_messages_api()
+        gateway_url = self.gateway
+        self.auth = ProviderAuth(
+            api_key=env_api_key_auth("Radius API key", ["RADIUS_API_KEY"]),
+            oauth=lazy_oauth(name, lambda: load_radius_oauth(name=name, gateway=gateway_url)),
+        )
+        self.refresh_models = self._refresh_models
+
+    def _baseline_models(self) -> list[Model]:
+        baseline = self._baseline
+        if baseline is None:
+            baseline = (
+                [dataclasses.replace(model, provider=self.id) for model in get_builtin_models("radius")]
+                if self._use_public_catalog
+                else []
+            )
+            self._baseline = baseline
+        return baseline
+
+    def get_models(self) -> Sequence[Model]:
+        dynamic = self._dynamic
+        return list(dynamic if dynamic is not None else self._baseline_models())
+
+    def _set_dynamic(self, models: list[Model]) -> None:
+        self._dynamic = models
+
+    async def _refresh_models(self, context: RefreshModelsContext) -> None:
+        stored = context.stored
+        if stored is not None:
+            restored: list[Model] = [model for model in stored.models if model.provider == self.id]
+            if not await context.publish(ModelsPublication(update=lambda: self._set_dynamic(restored))):
+                return
+
+        credential = context.credential
+        is_oauth = credential is not None and credential.get("type") == "oauth"
+        # Import catalogs cached by the pre-ModelsStore Radius implementation.
+        if stored is None and is_oauth:
+            legacy = get_radius_models(self.id, credential)
+            if legacy:
+                if not await context.publish(
+                    ModelsPublication(
+                        persist=ModelsStoreEntry(models=list(legacy), checked_at=now_ms()),
+                        update=lambda: self._set_dynamic(legacy),
+                    )
+                ):
+                    return
+
+        if not context.allow_network or context.signal.aborted:
+            return
+        if is_oauth:
+            api_key = credential.get("access")  # type: ignore[union-attr]
+        else:
+            api_key = credential.get("key") if credential is not None else None
+        config = await load_radius_gateway_config(self.gateway, api_key, context.signal, http_client=self._http_client)
+        if context.signal.aborted:
+            return
+        refreshed = get_radius_models_from_config(self.id, config)
+        await context.publish(
+            ModelsPublication(
+                persist=ModelsStoreEntry(models=list(refreshed), checked_at=now_ms()),
+                update=lambda: self._set_dynamic(refreshed),
+            )
+        )
+
+    def stream(
+        self, model: Model, context: TranscriptContext, options: Mapping[str, Any] | None = None
+    ) -> AssistantMessageEventStream:
+        return self._streams.stream(model, context, options)
+
+    def stream_simple(
+        self, model: Model, context: TranscriptContext, options: Mapping[str, Any] | None = None
+    ) -> AssistantMessageEventStream:
+        return self._streams.stream_simple(model, context, options)
+
+
+def radius_provider(
+    *,
+    id: str | None = None,
+    name: str | None = None,
+    gateway: str | None = None,
+    http_client: httpx.AsyncClient | None = None,
+) -> Provider:
+    """Radius gateway provider (``RADIUS_API_KEY`` or Radius OAuth).
+
+    ``gateway`` defaults to ``https://radius.pi.dev``; only the default gateway ships a
+    static baseline catalog. ``http_client`` is used for ``/v1/config`` catalog requests.
+    """
+    return RadiusProvider(
+        id=id if id is not None else "radius",
+        name=name if name is not None else "Radius",
+        gateway=gateway if gateway is not None else DEFAULT_RADIUS_GATEWAY,
+        http_client=http_client,
+    )

pi_ai/providers/radius_config.py

@@ -0,0 +1,136 @@
+"""Radius gateway configuration (``GET /v1/config``) and its model list."""
+
+from __future__ import annotations
+
+import json
+import re
+import urllib.parse
+from typing import Any, TypedDict
+
+import httpx
+
+from ..abort import AbortSignal, abort_scope
+from ..auth.types import Credential
+from ..serialization import model_from_dict
+from ..types import Model
+from ..utils.http import get_http_client
+
+__all__ = [
+    "DEFAULT_RADIUS_GATEWAY",
+    "RadiusGatewayModel",
+    "RadiusGatewayConfig",
+    "normalize_radius_gateway_url",
+    "get_radius_credential_config",
+    "get_radius_models_from_config",
+    "get_radius_models",
+    "load_radius_gateway_config",
+]
+
+DEFAULT_RADIUS_GATEWAY = "https://radius.pi.dev"
+
+
+class RadiusGatewayModel(TypedDict, total=False):
+    """One gateway model in pi's JSON shape (camelCase keys)."""
+
+    id: str
+    name: str
+    reasoning: bool
+    thinkingLevelMap: dict[str, str | None]
+    input: list[str]
+    cost: dict[str, Any]
+    contextWindow: int
+    maxTokens: int
+
+
+class RadiusGatewayConfig(TypedDict):
+    baseUrl: str
+    models: list[RadiusGatewayModel]
+
+
+def _is_number(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _is_radius_gateway_model(value: Any) -> bool:
+    if not isinstance(value, dict):
+        return False
+    return (
+        isinstance(value.get("id"), str)
+        and isinstance(value.get("name"), str)
+        and isinstance(value.get("reasoning"), bool)
+        and isinstance(value.get("input"), list)
+        and isinstance(value.get("cost"), dict)
+        and _is_number(value.get("contextWindow"))
+        and _is_number(value.get("maxTokens"))
+    )
+
+
+def _sanitize_radius_gateway_config(config: Any) -> RadiusGatewayConfig | None:
+    if not isinstance(config, dict):
+        return None
+    base_url = config.get("baseUrl")
+    models = config.get("models")
+    if not isinstance(base_url, str) or not isinstance(models, list):
+        return None
+    return {"baseUrl": base_url, "models": [dict(model) for model in models if _is_radius_gateway_model(model)]}  # type: ignore[misc]
+
+
+_SCHEME = re.compile(r"^https?://", re.IGNORECASE)
+_TRAILING_SLASHES = re.compile(r"/+$")
+
+
+def normalize_radius_gateway_url(value: str) -> str:
+    """Add ``https://`` when no scheme is given and drop trailing slashes."""
+    with_scheme = value if _SCHEME.match(value) else f"https://{value}"
+    return _TRAILING_SLASHES.sub("", with_scheme)
+
+
+def get_radius_credential_config(credential: Credential | None) -> RadiusGatewayConfig | None:
+    """The gateway config cached in an OAuth credential by the pre-ModelsStore Radius implementation."""
+    return _sanitize_radius_gateway_config(credential.get("gatewayConfig") if credential else None)
+
+
+def get_radius_models_from_config(provider_id: str, config: RadiusGatewayConfig) -> list[Model]:
+    models: list[Model] = []
+    for entry in config["models"]:
+        data = {key: value for key, value in entry.items() if key != "type"}
+        data.update(api="pi-messages", provider=provider_id, baseUrl=config["baseUrl"])
+        models.append(model_from_dict(data))
+    return models
+
+
+def get_radius_models(provider_id: str, credential: Credential | None) -> list[Model]:
+    config = get_radius_credential_config(credential)
+    return get_radius_models_from_config(provider_id, config) if config is not None else []
+
+
+def _truncate_http_body(body: str) -> str:
+    trimmed = body.strip()
+    return f"{trimmed[:512]}…" if len(trimmed) > 512 else trimmed
+
+
+async def load_radius_gateway_config(
+    gateway: str,
+    api_key: str | None = None,
+    signal: AbortSignal | None = None,
+    *,
+    http_client: httpx.AsyncClient | None = None,
+) -> RadiusGatewayConfig:
+    """Fetch and validate ``<gateway>/v1/config``. Raises on HTTP errors and invalid configs."""
+    headers = {"accept": "application/json"}
+    if api_key:
+        headers["authorization"] = f"Bearer {api_key}"
+    url = urllib.parse.urljoin(gateway, "/v1/config")
+    client = http_client if http_client is not None else get_http_client(url)
+    async with abort_scope(signal):
+        response = await client.get(url, headers=headers)
+        raw = await response.aread()
+    if not response.is_success:
+        text = raw.decode("utf-8", "replace")
+        raise RuntimeError(
+            f"Could not load Radius config from {gateway}: {response.status_code}: {_truncate_http_body(text)}"
+        )
+    config = _sanitize_radius_gateway_config(json.loads(raw))
+    if config is None:
+        raise ValueError(f"Invalid Radius config from {gateway}")
+    return config

pi_ai/providers/together.py

@@ -0,0 +1,23 @@
+"""Together provider."""
+
+from __future__ import annotations
+
+from ..api.registry import openai_completions_api
+from ..auth.helpers import env_api_key_auth
+from ..auth.types import ProviderAuth
+from ..models import Provider, create_provider
+from .catalog import catalog_models
+
+__all__ = ["together_provider"]
+
+
+def together_provider() -> Provider:
+    """Together (OpenAI-compatible Chat Completions), authenticated with ``TOGETHER_API_KEY``."""
+    return create_provider(
+        id="together",
+        name="Together",
+        base_url="https://api.together.ai/v1",
+        auth=ProviderAuth(api_key=env_api_key_auth("Together API key", ["TOGETHER_API_KEY"])),
+        models=lambda: catalog_models("together"),
+        api=openai_completions_api(),
+    )

pi_ai/providers/typesafe.py

@@ -0,0 +1,22 @@
+"""TypeSafe provider (System One classifiers)."""
+
+from __future__ import annotations
+
+from ..api.registry import typesafe_system_one_api
+from ..auth.helpers import env_api_key_auth
+from ..auth.types import ProviderAuth
+from ..models import Provider, create_provider
+from .catalog import catalog_models
+
+__all__ = ["typesafe_provider"]
+
+
+def typesafe_provider() -> Provider:
+    """TypeSafe System One classifiers, authenticated with ``TYPESAFE_API_KEY``."""
+    return create_provider(
+        id="typesafe",
+        name="TypeSafe",
+        auth=ProviderAuth(api_key=env_api_key_auth("TypeSafe API key", ["TYPESAFE_API_KEY"])),
+        models=lambda: catalog_models("typesafe"),
+        classifiers={"typesafe-system-one": typesafe_system_one_api()},
+    )