saia-python 0.9.0__tar.gz → 0.10.1__tar.gz

{saia_python-0.9.0/saia_python.egg-info → saia_python-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: saia-python
-Version: 0.9.0
+Version: 0.10.1
 Summary: Python wrapper for the GWDG SAIA platform REST API
 Author: Friedrich Schwarz
 License-Expression: AGPL-3.0-only
@@ -42,6 +42,7 @@ Requires-Dist: sentencepiece>=0.1.99; extra == "tokenizer"
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 Requires-Dist: pytest-cov>=4.0; extra == "test"
+Requires-Dist: pydantic>=2; extra == "test"
 Requires-Dist: saia-python[async,openai]; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx>=7.0; extra == "docs"
@@ -136,7 +137,7 @@ async def main():
     async with AsyncSAIAClient() as client:
         # Non-streaming RAG chat
         answer = await client.arcana.chat(
-            model="openai-gpt-oss-120b",
+            model="deepseek-v4-flash-0731",
             messages=[{"role": "user", "content": "Summarise the DLBCL first line."}],
             arcana_id="owner/kb",
         )
@@ -166,7 +167,7 @@ remain synchronous on `SAIAClient` — see
 
 | Service | Description | GWDG Docs |
 |---------|-------------|-----------|
-| **Chat AI** | Chat completions with streaming and tool calling | [Chat AI](https://docs.hpc.gwdg.de/services/ai-services/chat-ai/index.html) |
+| **Chat AI** | Chat completions with streaming, tool calling, and structured output (Pydantic) | [Chat AI](https://docs.hpc.gwdg.de/services/ai-services/chat-ai/index.html) |
 | **Voice AI** | Audio transcription and translation (Whisper) | [Voice AI](https://docs.hpc.gwdg.de/services/ai-services/voice-ai/index.html) |
 | **ARCANA** | RAG — knowledge base management and retrieval-augmented chat | [ARCANA](https://docs.hpc.gwdg.de/services/ai-services/arcana/index.html) |
 | **Documents** | PDF/document conversion via Docling | [SAIA API](https://docs.hpc.gwdg.de/services/ai-services/saia/index.html) |

{saia_python-0.9.0 → saia_python-0.10.1}/README.md

@@ -76,7 +76,7 @@ async def main():
     async with AsyncSAIAClient() as client:
         # Non-streaming RAG chat
         answer = await client.arcana.chat(
-            model="openai-gpt-oss-120b",
+            model="deepseek-v4-flash-0731",
             messages=[{"role": "user", "content": "Summarise the DLBCL first line."}],
             arcana_id="owner/kb",
         )
@@ -106,7 +106,7 @@ remain synchronous on `SAIAClient` — see
 
 | Service | Description | GWDG Docs |
 |---------|-------------|-----------|
-| **Chat AI** | Chat completions with streaming and tool calling | [Chat AI](https://docs.hpc.gwdg.de/services/ai-services/chat-ai/index.html) |
+| **Chat AI** | Chat completions with streaming, tool calling, and structured output (Pydantic) | [Chat AI](https://docs.hpc.gwdg.de/services/ai-services/chat-ai/index.html) |
 | **Voice AI** | Audio transcription and translation (Whisper) | [Voice AI](https://docs.hpc.gwdg.de/services/ai-services/voice-ai/index.html) |
 | **ARCANA** | RAG — knowledge base management and retrieval-augmented chat | [ARCANA](https://docs.hpc.gwdg.de/services/ai-services/arcana/index.html) |
 | **Documents** | PDF/document conversion via Docling | [SAIA API](https://docs.hpc.gwdg.de/services/ai-services/saia/index.html) |

{saia_python-0.9.0 → saia_python-0.10.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "saia-python"
-version = "0.9.0"
+version = "0.10.1"
 description = "Python wrapper for the GWDG SAIA platform REST API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -81,6 +81,8 @@ tokenizer = [
 test = [
     "pytest>=7.0",
     "pytest-cov>=4.0",
+    # the structured-output tests define Pydantic v2 models
+    "pydantic>=2",
     "saia-python[openai,async]",
 ]
 docs = [
@@ -132,3 +134,8 @@ disable_error_code = ["index", "operator", "union-attr", "call-arg"]
 # `builtins.list`).
 module = ["saia_python.models", "saia_python.arcana", "saia_python.aio"]
 disable_error_code = ["valid-type"]
+
+[dependency-groups]
+dev = [
+    "ipykernel>=7.3.0",
+]

{saia_python-0.9.0 → saia_python-0.10.1}/saia_python/__init__.py

@@ -44,10 +44,17 @@ from .auth import (
 )
 from .client import SAIAClient
 from .documents import ConversionImage, ConversionResult
-from .exceptions import APIError, AuthenticationError, RateLimitError, SAIAError
+from .exceptions import (
+    APIError,
+    AuthenticationError,
+    RateLimitError,
+    SAIAError,
+    StructuredOutputError,
+)
 from .openai_compat import create_openai_client
 from .rate_limits import RateLimitInfo, format_rate_limit_error, parse_rate_limits
 from .responses import text_of
+from .structured import parse_structured, response_format_for
 from .tokenizer import (
     DEFAULT_TOKENIZER_DIR,
     GWDG_MODEL_REPOS,
@@ -98,6 +105,7 @@ __all__ = [
     "AuthenticationError",
     "RateLimitError",
     "APIError",
+    "StructuredOutputError",
     # Rate limits
     "RateLimitInfo",
     "parse_rate_limits",
@@ -110,6 +118,9 @@ __all__ = [
     # Response helpers
     "text_of",
     "SSEStream",
+    # Structured output (Pydantic v2 models)
+    "response_format_for",
+    "parse_structured",
     # ARCANA reference parsing
     "ArcanaReference",
     "ParsedReferences",

{saia_python-0.9.0 → saia_python-0.10.1}/saia_python/aio.py

@@ -12,7 +12,7 @@ calls and ``async for`` over a stream::
     async with AsyncSAIAClient() as client:
         # non-streaming RAG chat
         answer = await client.arcana.chat(
-            model="openai-gpt-oss-120b",
+            model="deepseek-v4-flash-0731",
             messages=[{"role": "user", "content": "..."}],
             arcana_id="owner/kb",
         )
@@ -41,7 +41,7 @@ the two transports cannot drift.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from ._async_http import aexecute, apost_chat_completion
 from ._async_streaming import AsyncSSEStream
@@ -54,6 +54,7 @@ from ._payloads import (
 from .auth import resolve_credentials
 from .exceptions import raise_for_status
 from .rate_limits import RateLimitInfo, parse_rate_limits
+from .structured import ModelT, parse_structured, response_format_for
 
 if TYPE_CHECKING:
     import httpx
@@ -140,6 +141,38 @@ class AsyncChatService:
             policy=resolve_retry(self._retry, retry),
         )
 
+    async def completions_structured(
+        self,
+        model: str,
+        messages: list[dict],
+        response_model: type[ModelT],
+        *,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        max_tokens: int | None = None,
+        retry: RetryPolicy | bool | None = None,
+        **kwargs: Any,
+    ) -> ModelT:
+        """Return the answer as a validated ``response_model`` instance.
+
+        See :meth:`ChatService.completions_structured
+        <saia_python.chat.ChatService.completions_structured>`; raises
+        :class:`~saia_python.StructuredOutputError` when there is no answer
+        that validates.
+        """
+        response = await self.completions(
+            model,
+            messages,
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            stream=False,
+            retry=retry,
+            response_format=response_format_for(response_model),
+            **kwargs,
+        )
+        return parse_structured(cast(dict, response), response_model)
+
     def __repr__(self) -> str:
         return f"AsyncChatService(base_url={self._base_url!r})"
 

saia_python-0.10.1/saia_python/chat.py

@@ -0,0 +1,141 @@
+"""Chat service — completions and streaming."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from ._http import RetryPolicy, coerce_retry, post_chat_completion, resolve_retry
+from ._streaming import SSEStream
+from .structured import ModelT, parse_structured, response_format_for
+
+if TYPE_CHECKING:
+    import requests
+
+
+class ChatService:
+    """Access the ``/chat/completions`` endpoint.
+
+    Args:
+        session: A :class:`requests.Session` with auth headers configured.
+        base_url: The SAIA API base URL.
+    """
+
+    def __init__(
+        self,
+        session: requests.Session,
+        base_url: str,
+        *,
+        retry: RetryPolicy | bool | None = None,
+    ):
+        self._session = session
+        self._base_url = base_url
+        self._retry = coerce_retry(retry)
+
+    def completions(
+        self,
+        model: str,
+        messages: list[dict],
+        *,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        max_tokens: int | None = None,
+        stream: bool = False,
+        retry: RetryPolicy | bool | None = None,
+        **kwargs,
+    ) -> dict | SSEStream:
+        """Send a chat completion request.
+
+        Args:
+            model: Model identifier (e.g. ``"meta-llama-3.1-8b-instruct"``).
+            messages: List of message dicts with ``"role"`` and ``"content"`` keys.
+            temperature: Sampling temperature (0–2).
+            top_p: Nucleus sampling parameter (0–1).
+            max_tokens: Maximum tokens to generate.
+            stream: If ``True``, return a generator yielding chunks.
+            **kwargs: Additional parameters forwarded to the API.
+
+        Returns:
+            When ``stream=False``: the API response dict, with an extra
+            ``"_rate_limits"`` key — a JSON-serializable dict of the current
+            rate-limit headers (see :class:`~saia_python.RateLimitInfo`).
+            When ``stream=True``: an ``SSEStream`` — iterate it for the
+            response chunks; its ``rate_limits`` attribute exposes the same
+            dict (available immediately, from the response headers).
+        """
+        body = {"model": model, "messages": messages, **kwargs}
+        if temperature is not None:
+            body["temperature"] = temperature
+        if top_p is not None:
+            body["top_p"] = top_p
+        if max_tokens is not None:
+            body["max_tokens"] = max_tokens
+
+        return post_chat_completion(
+            self._session,
+            f"{self._base_url}/chat/completions",
+            body,
+            stream=stream,
+            policy=resolve_retry(self._retry, retry),
+        )
+
+    def completions_structured(
+        self,
+        model: str,
+        messages: list[dict],
+        response_model: type[ModelT],
+        *,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        max_tokens: int | None = None,
+        retry: RetryPolicy | bool | None = None,
+        **kwargs,
+    ) -> ModelT:
+        """Send a chat completion and return the answer as a validated model.
+
+        Sends ``response_model``'s JSON Schema as the ``response_format`` (see
+        :func:`~saia_python.response_format_for`), which SAIA enforces on the
+        server, then validates the answer into an instance (see
+        :func:`~saia_python.parse_structured`). Non-streaming only. To keep the
+        raw response too (``usage``, ``_rate_limits``), call those two helpers
+        around :meth:`completions` yourself.
+
+        Args:
+            model: Model identifier (e.g. ``"meta-llama-3.1-8b-instruct"``).
+            messages: List of message dicts with ``"role"`` and ``"content"`` keys.
+                SAIA uses the schema only to constrain the output and does not
+                add it to the prompt, so say what each field should hold.
+            response_model: The Pydantic v2 model class the answer must match.
+            temperature: Sampling temperature (0–2).
+            top_p: Nucleus sampling parameter (0–1).
+            max_tokens: Maximum tokens to generate. Reasoning models think
+                before they answer, so leave room, or turn thinking off where
+                the chat template allows it (e.g. Qwen:
+                ``chat_template_kwargs={"enable_thinking": False}``).
+            retry: Overrides the service's rate-limit retry policy for this
+                call, as in :meth:`completions`.
+            **kwargs: Additional parameters forwarded to the API.
+
+        Returns:
+            An instance of ``response_model``.
+
+        Raises:
+            StructuredOutputError: The response holds no answer that validates,
+                e.g. because the token budget ran out (``finish_reason`` is
+                ``"length"``). The error keeps the full response, ``usage``
+                included.
+        """
+        response = self.completions(
+            model,
+            messages,
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            stream=False,
+            retry=retry,
+            response_format=response_format_for(response_model),
+            **kwargs,
+        )
+        return parse_structured(cast(dict, response), response_model)
+
+    def __repr__(self):
+        return f"ChatService(base_url={self._base_url!r})"

{saia_python-0.9.0 → saia_python-0.10.1}/saia_python/client.py

@@ -154,7 +154,7 @@ class SAIAClient:
         Example::
 
             response = client.openai.chat.completions.create(
-                model="llama-3.3-70b-instruct",
+                model="deepseek-v4-flash-0731",
                 messages=[{"role": "user", "content": "Hello!"}],
             )
         """

{saia_python-0.9.0 → saia_python-0.10.1}/saia_python/exceptions.py

@@ -76,6 +76,32 @@ class APIError(SAIAError):
         super().__init__(message, status_code=status_code, response_body=response_body)
 
 
+class StructuredOutputError(SAIAError):
+    """Raised when a chat response holds no answer that validates against the
+    requested structured-output model.
+
+    The HTTP call itself succeeded, so ``status_code`` is ``None``; the message
+    says why the answer is unusable. The response stays attached, so a caller
+    can still read ``usage`` (the tokens were spent) or inspect the raw content.
+
+    Attributes:
+        response: The chat response dict the answer was read from.
+        finish_reason: The first choice's ``finish_reason`` — ``"length"`` means
+            the token budget ran out — or ``None`` when there was no choice.
+    """
+
+    def __init__(
+        self,
+        message: object,
+        *,
+        response: dict,
+        finish_reason: str | None = None,
+    ):
+        super().__init__(message)
+        self.response = response
+        self.finish_reason = finish_reason
+
+
 def _extract_detail(resp: Any) -> str:
     """Try to extract a human-readable message from a JSON error body.
 

{saia_python-0.9.0 → saia_python-0.10.1}/saia_python/openai_compat.py

@@ -43,7 +43,7 @@ def create_openai_client(
 
         client = create_openai_client()
         response = client.chat.completions.create(
-            model="llama-3.3-70b-instruct",
+            model="deepseek-v4-flash-0731",
             messages=[{"role": "user", "content": "Hello!"}],
         )
 

saia_python-0.10.1/saia_python/structured.py

@@ -0,0 +1,130 @@
+"""Structured output — a Pydantic model in, a validated instance out.
+
+SAIA enforces a ``json_schema`` ``response_format`` on the server: its inference
+backend (vLLM) compiles the schema into a grammar and blocks every token that
+would break it, so the answer matches the schema by construction and needs no
+validate-and-retry loop. This module covers the two client-side ends:
+
+- :func:`response_format_for` turns a Pydantic model into the
+  ``response_format`` request field.
+- :func:`parse_structured` validates a chat response back into the model, and
+  raises :class:`~saia_python.StructuredOutputError` with the reason when there
+  is nothing usable — most often a reasoning model that spent its
+  ``max_tokens`` thinking.
+
+:meth:`ChatService.completions_structured
+<saia_python.chat.ChatService.completions_structured>` does both in one call.
+Use the two helpers directly when you also need the raw response, e.g. its
+``usage``::
+
+    resp = client.chat.completions(
+        model, messages, response_format=response_format_for(Invoice)
+    )
+    invoice = parse_structured(resp, Invoice)
+    tokens = resp["usage"]["total_tokens"]
+
+Needs Pydantic v2, which you already have if you define a model; the package
+itself imports it only inside :func:`parse_structured`.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, TypeVar
+
+from .exceptions import StructuredOutputError
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+ModelT = TypeVar("ModelT", bound="BaseModel")
+
+_TOKEN_HINT = (
+    "Reasoning models spend tokens thinking before they answer: raise max_tokens, "
+    "or turn thinking off where the chat template allows it (e.g. Qwen: "
+    "chat_template_kwargs={'enable_thinking': False})."
+)
+
+
+def response_format_for(response_model: type[BaseModel]) -> dict:
+    """Build the ``response_format`` request field for a Pydantic model.
+
+    ``strict`` is left unset: SAIA's backends enforce the schema either way,
+    whereas OpenAI's strict mode would reject a plain Pydantic schema (it
+    requires ``additionalProperties: false`` on every object).
+
+    Args:
+        response_model: A Pydantic v2 model class.
+
+    Returns:
+        ``{"type": "json_schema", "json_schema": {"name": ..., "schema": ...}}``
+        with the model's JSON Schema, named after the class (characters outside
+        ``a-z A-Z 0-9 _ -``, such as a generic's brackets, become ``_``).
+    """
+    name = re.sub(r"[^a-zA-Z0-9_-]", "_", response_model.__name__)[:64]
+    return {
+        "type": "json_schema",
+        "json_schema": {"name": name, "schema": response_model.model_json_schema()},
+    }
+
+
+def parse_structured(response: dict, response_model: type[ModelT]) -> ModelT:
+    """Validate a chat response's answer into ``response_model``.
+
+    Reads the first choice's ``content`` — the JSON string the model wrote — and
+    validates it with ``response_model.model_validate_json``. Works on any
+    OpenAI-style ChatCompletion dict, such as the one
+    :meth:`~saia_python.chat.ChatService.completions` returns.
+
+    Args:
+        response: A chat completion response dict.
+        response_model: The Pydantic v2 model class to validate into.
+
+    Returns:
+        The validated ``response_model`` instance.
+
+    Raises:
+        StructuredOutputError: When there is no usable answer: no choices; no
+            content (a reasoning model that ran out of tokens while thinking
+            returns ``content: None`` with ``finish_reason: "length"``); an
+            answer cut off at ``max_tokens``; or one that fails validation, with
+            the :class:`pydantic.ValidationError` chained as the cause.
+    """
+    from pydantic import ValidationError
+
+    name = response_model.__name__
+    choices = response.get("choices") or []
+    if not choices:
+        raise StructuredOutputError(
+            f"{name}: the response has no choices", response=response
+        )
+    finish_reason = choices[0].get("finish_reason")
+    message = choices[0].get("message") or {}
+    content = message.get("content")
+    if not content:
+        if finish_reason == "length":
+            reason = f"the model ran out of tokens before answering. {_TOKEN_HINT}"
+        elif message.get("refusal"):
+            reason = f"the model refused: {message['refusal']}"
+        else:
+            reason = f"the response has no content (finish_reason={finish_reason!r})"
+        raise StructuredOutputError(
+            f"{name}: {reason}", response=response, finish_reason=finish_reason
+        )
+    try:
+        return response_model.model_validate_json(content)
+    except ValidationError as exc:
+        # Validate before blaming finish_reason: an answer can be complete even
+        # when generation hit the limit afterwards (e.g. trailing whitespace).
+        if finish_reason == "length":
+            reason = f"the answer was cut off at max_tokens. {_TOKEN_HINT}"
+        else:
+            error = exc.errors()[0]
+            where = ".".join(str(part) for part in error["loc"])
+            detail = f"{where}: {error['msg']}" if where else error["msg"]
+            if exc.error_count() > 1:
+                detail += f"; {exc.error_count() - 1} more"
+            reason = f"the answer failed validation ({detail})"
+        raise StructuredOutputError(
+            f"{name}: {reason}", response=response, finish_reason=finish_reason
+        ) from exc

{saia_python-0.9.0 → saia_python-0.10.1}/saia_python/tokenizer.py

@@ -50,16 +50,64 @@ if TYPE_CHECKING:  # pragma: no cover - typing only
 # ---------------------------------------------------------------------------
 
 # Single source of truth: ``(api_model_id, display_name, hf_repo)`` for every
-# open-weight model GWDG hosts. ``api_model_id`` is the string passed as
-# ``"model"`` to the API (and returned as ``id`` by ``GET /models``);
+# open-weight model GWDG hosts or has hosted. ``api_model_id`` is the string
+# passed as ``"model"`` to the API (and returned as ``id`` by ``GET /models``);
 # ``display_name`` is the catalogue's "Model" column (and the ``name`` field of
 # the ``/models`` payload); ``hf_repo`` is the ``org/name`` the catalogue links
 # to on https://huggingface.co . Sourced from the GWDG model catalogue and
-# cross-checked against the live ``/models`` listing on 2026-06-21. Only
-# open-weight models are listed — the externally hosted, proprietary models
-# (GPT-5.x, o3, Claude, ...) have no downloadable tokenizer; see
+# cross-checked against the live ``/models`` listing on 2026-06-21; the models
+# added on 2026-10-09 come from the catalogue page alone. Only open-weight
+# models are listed — the externally hosted, proprietary models (GPT-5.x, o3,
+# Claude, ...) have no downloadable tokenizer; see
 # :data:`OPENAI_TIKTOKEN_ENCODINGS` for their byte-pair encodings.
 _MODEL_TABLE: list[tuple[str, str, str]] = [
+    # Served by GWDG as of 2026-10-09.
+    # DeepSeek V4 ships no Jinja chat template (only a Python encoder), so
+    # chat_template_tokens falls back to a plain render with a warning for it.
+    (
+        "deepseek-v4-flash-0731",
+        "DeepSeek V4 Flash 0731",
+        "deepseek-ai/DeepSeek-V4-Flash-0731",
+    ),
+    ("gemma-4-31b-it", "Gemma 4 31B Instruct", "google/gemma-4-31B-it"),
+    # Its tokenizer_config names TokenizersBackend, a transformers 5 class.
+    ("glm-5.3-flash", "GLM 5.3 Flash", "zai-org/GLM-5.3-Flash"),
+    (
+        "meta-llama-3.1-8b-instruct",
+        "Llama 3.1 8B Instruct",
+        "nvidia/Llama-3.1-8B-Instruct-FP8",
+    ),
+    (
+        "qwen3-30b-a3b-instruct-2507",
+        "Qwen 3 30B A3B Instruct 2507",
+        "Qwen/Qwen3-30B-A3B-Instruct-2507-FP8",
+    ),
+    ("qwen3-coder-next", "Qwen 3 Coder Next", "Qwen/Qwen3-Coder-Next-FP8"),
+    (
+        "qwen3-omni-30b-a3b-instruct",
+        "Qwen 3 Omni 30B A3B Instruct",
+        "Qwen/Qwen3-Omni-30B-A3B-Instruct",
+    ),
+    ("qwen3.5-397b-a17b", "Qwen 3.5 397B A17B", "Qwen/Qwen3.5-397B-A17B-GPTQ-Int4"),
+    ("qwen3.6-35b-a3b", "Qwen 3.6 35B A3B", "Qwen/Qwen3.6-35B-A3B-FP8"),
+    ("qwen3.8-27b", "Qwen 3.8 27B", "Qwen/Qwen3.8-27B-FP8"),
+    # Embedding models — served via /embeddings rather than the chat /models
+    # listing, but their tokenizers are useful for sizing RAG chunks.
+    # ``qwen3-embedding-4b`` is the model ARCANA's RAG pipeline uses internally.
+    (
+        "qwen3-embedding-4b",
+        "Qwen3 Embedding 4B",
+        "Qwen/Qwen3-Embedding-4B",
+    ),
+    (
+        "e5-mistral-7b-instruct",
+        "E5 Mistral 7B Instruct",
+        "intfloat/e5-mistral-7b-instruct",
+    ),
+    # No longer served by GWDG (openai-gpt-oss-120b, devstral-2-123b-instruct-2512
+    # and apertus-70b-instruct-2509 were retired on 2026-10-08). Kept because
+    # their Hugging Face repos remain: the ids still resolve and the tokenizers
+    # still download.
     (
         "apertus-70b-instruct-2509",
         "Apertus 70B Instruct 2509",
@@ -75,57 +123,26 @@ _MODEL_TABLE: list[tuple[str, str, str]] = [
         "Devstral 2 123B Instruct 2512",
         "mistralai/Devstral-2-123B-Instruct-2512",
     ),
-    ("gemma-4-31b-it", "Gemma 4 31B Instruct", "google/gemma-4-31B-it"),
     ("glm-4.7", "GLM-4.7", "zai-org/GLM-4.7-FP8"),
     ("internvl3.5-30b-a3b", "InternVL 3.5 30B A3B", "OpenGVLab/InternVL3_5-30B-A3B-HF"),
     ("medgemma-27b-it", "MedGemma 27B Instruct", "google/medgemma-27b-it"),
-    (
-        "meta-llama-3.1-8b-instruct",
-        "Llama 3.1 8B Instruct",
-        "nvidia/Llama-3.1-8B-Instruct-FP8",
-    ),
     (
         "mistral-large-3-675b-instruct-2512",
         "Mistral Large 3 675B Instruct 2512",
         "mistralai/Mistral-Large-3-675B-Instruct-2512-NVFP4",
     ),
     ("openai-gpt-oss-120b", "GPT OSS 120B", "openai/gpt-oss-120b"),
-    (
-        "qwen3-30b-a3b-instruct-2507",
-        "Qwen 3 30B A3B Instruct 2507",
-        "Qwen/Qwen3-30B-A3B-Instruct-2507-FP8",
-    ),
     (
         "qwen3-coder-30b-a3b-instruct",
         "Qwen 3 Coder 30B A3B Instruct",
         "Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8",
     ),
-    (
-        "qwen3-omni-30b-a3b-instruct",
-        "Qwen 3 Omni 30B A3B Instruct",
-        "Qwen/Qwen3-Omni-30B-A3B-Instruct",
-    ),
     ("qwen3.5-122b-a10b", "Qwen 3.5 122B A10B", "Qwen/Qwen3.5-122B-A10B-GPTQ-Int4"),
-    ("qwen3.5-397b-a17b", "Qwen 3.5 397B A17B", "Qwen/Qwen3.5-397B-A17B-GPTQ-Int4"),
-    ("qwen3.6-35b-a3b", "Qwen 3.6 35B A3B", "Qwen/Qwen3.6-35B-A3B-FP8"),
     (
         "teuken-7b-instruct-research",
         "Teuken 7B Instruct Research",
         "openGPT-X/Teuken-7B-instruct-research-v0.4",
     ),
-    # Embedding models — served via /embeddings rather than the chat /models
-    # listing, but their tokenizers are useful for sizing RAG chunks.
-    # ``qwen3-embedding-4b`` is the model ARCANA's RAG pipeline uses internally.
-    (
-        "qwen3-embedding-4b",
-        "Qwen3 Embedding 4B",
-        "Qwen/Qwen3-Embedding-4B",
-    ),
-    (
-        "e5-mistral-7b-instruct",
-        "E5 Mistral 7B Instruct",
-        "intfloat/e5-mistral-7b-instruct",
-    ),
 ]
 
 #: Mapping of GWDG API model id → Hugging Face ``org/name`` repository.
@@ -279,7 +296,9 @@ def available_open_models() -> list[str]:
     """Return the GWDG open-weight model ids known to this module.
 
     These are the keys of :data:`GWDG_MODEL_REPOS` — the models for which a
-    tokenizer repository is published and can be downloaded.
+    tokenizer repository is published and can be downloaded, including the ones
+    GWDG no longer serves. For the models available right now, annotate the live
+    listing instead (:meth:`TokenizerService.available_repos`).
     """
     return list(GWDG_MODEL_REPOS)
 
@@ -289,12 +308,13 @@ def resolve_repo(model: str) -> str:
 
     Accepts, in order of preference:
 
-    1. A GWDG API model id (e.g. ``"openai-gpt-oss-120b"``) — exactly as
+    1. A GWDG API model id (e.g. ``"deepseek-v4-flash-0731"``) — exactly as
        returned by ``GET /models`` / passed as ``"model"`` in API calls.
     2. A full ``org/name`` Hugging Face repo (anything containing ``/``) — used
        verbatim, so callers can point at a model this module does not list yet.
-    3. A catalogue display name (e.g. ``"GPT OSS 120B"``) or a loose spelling of
-       an id — matched after normalisation (case / punctuation insensitive).
+    3. A catalogue display name (e.g. ``"DeepSeek V4 Flash 0731"``) or a loose
+       spelling of an id — matched after normalisation (case / punctuation
+       insensitive).
 
     Args:
         model: The model id, display name, or ``org/name`` repository.