decision-toolkit 0.3.1__tar.gz → 0.4.0__tar.gz

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/CHANGELOG.md

@@ -1,8 +1,25 @@
 # Changelog
 
-All notable changes to this project are documented here. Version `0.3.1` is
+All notable changes to this project are documented here. Version `0.4.0` is
 published on PyPI.
 
+## [0.4.0] — 2026-10-21
+
+REST variant-selection correction. Quantizations are selected through standard
+model aliases (`id@variant`), not a non-standard `variant` body field. The same
+REST process can load two variants of one base model in separate registry slots.
+
+### Fixed
+
+- Removed `variant` from System One and OpenAI request bodies; standard clients
+  now see only the public request fields.
+- Added `catalog-id@variant` model aliases to `/v1/models` and
+  `/v1/models/{id}`. The standard `model` field selects the alias.
+- Registry keys and slots are per alias, so `laya-multilingual@fp16` and
+  `laya-multilingual@fp32` load independently and concurrently.
+- Updated README, REST, variants, examples and CLI help so REST never shows a
+  variant field in a standard request body.
+
 ## [0.3.1] — 2026-10-21
 
 Catalog UX patch: `dtk models list` now prints one row per variant, with
@@ -192,6 +209,7 @@ README correction. No code or model behavior changed.
 - Typed `DecisionModel` API with lifecycle, batching, async, usage, warnings,
   normalized confidence, capabilities, structured events and atomic model store.
 
+[0.4.0]: https://pypi.org/project/decision-toolkit/0.4.0/
 [0.3.1]: https://pypi.org/project/decision-toolkit/0.3.1/
 [0.3.0]: https://pypi.org/project/decision-toolkit/0.3.0/
 [0.2.1]: https://pypi.org/project/decision-toolkit/0.2.1/

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: decision-toolkit
-Version: 0.3.1
+Version: 0.4.0
 Summary: Local-first toolkit for open-weights decision models: one ONNX engine, one adapter per model contract, typed choice/yes-no/score decisions with probabilities on CPU.
 Project-URL: Homepage, https://github.com/gia-uh/decision-toolkit
 Project-URL: Repository, https://github.com/gia-uh/decision-toolkit
@@ -59,7 +59,7 @@ and CLI. `dtk --help` and every subcommand help also include runnable examples.
 ## Installation
 
 ```bash
-uv pip install decision-toolkit              # library + CLI (0.3.1 on PyPI)
+uv pip install decision-toolkit              # library + CLI (0.4.0 on PyPI)
 uv pip install "decision-toolkit[onnx]"      # + onnxruntime, tokenizers (the model runtime)
 uv pip install "decision-toolkit[server]"    # + REST server (FastAPI)
 ```
@@ -67,7 +67,7 @@ uv pip install "decision-toolkit[server]"    # + REST server (FastAPI)
 The project is managed with [uv](https://docs.astral.sh/uv/) and ships a committed `uv.lock`. Published
 wheels remain compatible with `pip` for environments that do not use uv.
 
-PyPI: <https://pypi.org/project/decision-toolkit/0.3.1/>. See
+PyPI: <https://pypi.org/project/decision-toolkit/0.4.0/>. See
 [docs/RELEASE.md](https://github.com/gia-uh/decision-toolkit/blob/main/docs/RELEASE.md)
 for the Trusted Publishing flow and clean-install checks.
 
@@ -248,11 +248,11 @@ dtk models current --json          # {"current": "...", "variant": "fp32"}
 dtk decide --model gliner2.5-multi --variant fp16 --state "..." --q 'cat=choice:a|b'
 ```
 
-From Python: `DecisionModel("gliner2.5-multi", variant="fp32")`. REST selects
-the same way with `"variant": "fp32"` in the request body and returns the choice
-under `x_decision_toolkit.variant`. The variant must already be downloaded. If a
-variant is omitted, the catalog default is used unless `dtk models use` selected
-another one.
+From Python: `DecisionModel("gliner2.5-multi", variant="fp32")`. In REST,
+quantizations are **model aliases**: use `"model": "gliner2.5-multi@fp32"` in the
+standard `model` field. The base id uses the server/persisted default. There is
+no `variant` field in the request body; `/v1/models` lists both the base model
+and every alias, and two aliases can be loaded concurrently.
 
 A variant becomes default only after passing the parity gate (top-1 ≥ 99%,
 mean |Δp| ≤ 0.02, accuracy delta ≤ 1 pp against the fp32 build on a fixed

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/README.md

@@ -21,7 +21,7 @@ and CLI. `dtk --help` and every subcommand help also include runnable examples.
 ## Installation
 
 ```bash
-uv pip install decision-toolkit              # library + CLI (0.3.1 on PyPI)
+uv pip install decision-toolkit              # library + CLI (0.4.0 on PyPI)
 uv pip install "decision-toolkit[onnx]"      # + onnxruntime, tokenizers (the model runtime)
 uv pip install "decision-toolkit[server]"    # + REST server (FastAPI)
 ```
@@ -29,7 +29,7 @@ uv pip install "decision-toolkit[server]"    # + REST server (FastAPI)
 The project is managed with [uv](https://docs.astral.sh/uv/) and ships a committed `uv.lock`. Published
 wheels remain compatible with `pip` for environments that do not use uv.
 
-PyPI: <https://pypi.org/project/decision-toolkit/0.3.1/>. See
+PyPI: <https://pypi.org/project/decision-toolkit/0.4.0/>. See
 [docs/RELEASE.md](https://github.com/gia-uh/decision-toolkit/blob/main/docs/RELEASE.md)
 for the Trusted Publishing flow and clean-install checks.
 
@@ -210,11 +210,11 @@ dtk models current --json          # {"current": "...", "variant": "fp32"}
 dtk decide --model gliner2.5-multi --variant fp16 --state "..." --q 'cat=choice:a|b'
 ```
 
-From Python: `DecisionModel("gliner2.5-multi", variant="fp32")`. REST selects
-the same way with `"variant": "fp32"` in the request body and returns the choice
-under `x_decision_toolkit.variant`. The variant must already be downloaded. If a
-variant is omitted, the catalog default is used unless `dtk models use` selected
-another one.
+From Python: `DecisionModel("gliner2.5-multi", variant="fp32")`. In REST,
+quantizations are **model aliases**: use `"model": "gliner2.5-multi@fp32"` in the
+standard `model` field. The base id uses the server/persisted default. There is
+no `variant` field in the request body; `/v1/models` lists both the base model
+and every alias, and two aliases can be loaded concurrently.
 
 A variant becomes default only after passing the parity gate (top-1 ≥ 99%,
 mean |Δp| ≤ 0.02, accuracy delta ≤ 1 pp against the fp32 build on a fixed

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/docs/EXAMPLES.md

@@ -165,7 +165,8 @@ curl -s http://127.0.0.1:8000/v1/decisions \
   }' | jq
 ```
 
-`variant` is a decision-toolkit extension; omit it for a standard client.
+Use the model alias `id@variant` for a specific quantization; the base id uses
+the server's default. There is no `variant` field in the request body.
 
 ### Model per request and auth
 
@@ -176,8 +177,7 @@ curl -s http://127.0.0.1:8000/v1/systemone \
   -H "Authorization: Bearer secret" \
   -H "Content-Type: application/json" \
   -d '{
-    "model": "gliner2.5-decide",
-    "variant": "q4f16",
+    "model": "gliner2.5-multi@fp32",
     "state": "I want my money back.",
     "questions": {
       "intent": {"type": "choice", "instructions": "What is the request?",

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/docs/RELEASE.md

@@ -10,7 +10,9 @@ and selection in the CLI and documentation; `0.1.7` aligned variant selection
 across the library, CLI and REST API; `0.2.0` corrected the REST conformance
 claims and wire shapes to the published TypeSafe and OpenAI schemas; `0.2.1`
 changed the public documentation URLs to this repository's Pages site; `0.3.0`
-added the Laya multilingual, Open-Jev DeBERTa v3 large and Strands Decider ONNX models; `0.3.1` made the catalog list one row per variant with exact commands.
+added the Laya multilingual, Open-Jev DeBERTa v3 large and Strands Decider ONNX models; `0.3.1` made the catalog list one row per variant with exact commands; `0.4.0`
+replaced the non-standard REST `variant` body field with standard model aliases
+(`id@variant`).
 
 ## Local build and verification
 
@@ -37,7 +39,7 @@ Clean install test (no `PYTHONPATH`):
 ```bash
 uv venv --python 3.12 /tmp/dtk-wheel
 uv pip install --python /tmp/dtk-wheel/bin/python \
-  dist/decision_toolkit-0.3.1-py3-none-any.whl
+  dist/decision_toolkit-0.4.0-py3-none-any.whl
 uv pip check --python /tmp/dtk-wheel/bin/python
 /tmp/dtk-wheel/bin/dtk --version
 /tmp/dtk-wheel/bin/dtk models list --json
@@ -48,7 +50,7 @@ With inference and server extras:
 
 ```bash
 uv pip install --python /tmp/dtk-wheel/bin/python \
-  "dist/decision_toolkit-0.3.1-py3-none-any.whl[onnx,server,tracing]"
+  "dist/decision_toolkit-0.4.0-py3-none-any.whl[onnx,server,tracing]"
 /tmp/dtk-wheel/bin/dtk decide --model gliner2.5-decide ...
 /tmp/dtk-wheel/bin/dtk serve --model gliner2.5-decide --warmup --port 8016
 curl -s http://127.0.0.1:8016/health
@@ -82,8 +84,8 @@ No long-lived PyPI token is needed; the workflow uses GitHub OIDC
 4. Create and push an annotated tag:
 
    ```bash
-   git tag -a v0.3.1 -m "decision-toolkit 0.3.1"
-   git push origin v0.3.1
+   git tag -a v0.4.0 -m "decision-toolkit 0.4.0"
+   git push origin v0.4.0
    ```
 
 5. `.github/workflows/release.yml` builds once, publishes to **TestPyPI**, then
@@ -132,9 +134,9 @@ to TestPyPI without publishing to PyPI or creating a GitHub release.
 
 ## Published release
 
-`0.3.1` is published through Trusted Publishing on 2026-10-21:
+`0.4.0` is published through Trusted Publishing on 2026-10-21:
 
-<https://pypi.org/project/decision-toolkit/0.3.1/>
+<https://pypi.org/project/decision-toolkit/0.4.0/>
 
 `0.1.0` was the first release; `0.1.1` refreshed the PyPI description; `0.1.2`
 validated the OIDC TestPyPI → PyPI flow; `0.1.3` added post-publish install
@@ -144,7 +146,8 @@ published to TestPyPI only; `0.1.5` fixed TestPyPI resolution; `0.1.6` added
 complete variant/quantization visibility and CLI selection; `0.1.7` aligned
 selection across library, CLI and REST; `0.2.0` corrected the REST conformance
 claims and wire shapes; `0.2.1` changed the public documentation URLs; `0.3.0`
-added the three new ONNX decision models; `0.3.1` made the catalog list one row per variant.
+added the three new ONNX decision models; `0.3.1` made the catalog list one row per variant; `0.4.0` moved REST variant
+selection to standard model aliases.
 
 The tag-triggered workflow remains the preferred path for future releases once
 the TestPyPI/PyPI trusted publishers and protected environments are configured.

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/docs/REST.md

@@ -49,25 +49,25 @@ limitations listed below.
 Toolkit-only metadata is under `x_decision_toolkit`, never mixed into standard
 fields. `/v1/decision-models` is the rich, non-standard catalog endpoint.
 
-## Variants (local extension)
-
-Neither TypeSafe nor OpenAI has a `variant` request field: the public APIs select
-a model by name. Quantization is a **decision-toolkit extension**:
-
-- Request `variant` wins when a local client sends it.
-- Otherwise, a server started with `dtk serve --variant` uses that default.
-- Otherwise, the variant selected with `dtk models use` is used when the server
-  is serving the current model.
-- Otherwise, the catalog default (the `*` variant in `dtk models list`) is used.
-
-Standard clients should omit `variant`; they work with the server default. A
-standard-only integration can run one server per variant, or use the server's
-`--variant` setting. The selected variant is exposed in the namespaced
-`x_decision_toolkit.variant` extension, never in a standard field.
-`/v1/models`, `/v1/models/{id}`, `/v1/decision-models`, `/v1/info` and `/ready`
-expose the configured catalog variants, the default, cached variants, and the
-current selection. See [Variants and quantization](VARIANTS.md) for the catalog
-and download/select commands.
+## Variants as model aliases
+
+Neither TypeSafe nor OpenAI has a `variant` request field. The toolkit therefore
+publishes each quantization as a **model alias**:
+
+```json
+{"model": "gliner2.5-multi@fp32", "state": "...", "questions": {...}}
+```
+
+The `model` field is the standard field. `gliner2.5-multi` uses the server's
+default (or the persisted `dtk models use` selection); `gliner2.5-multi@fp32`
+selects that exact variant. Both aliases are listed by `/v1/models`, and the
+registry loads them in separate slots, so two variants of one base model can be
+used by the same server process.
+
+`/v1/models/gliner2.5-multi@fp32`, `/v1/decision-models`, `/v1/info` and `/ready`
+expose the alias, variant, default, cached state and current selection. The
+response metadata under `x_decision_toolkit.variant` is an extension; the
+request body remains standard. See [Variants and quantization](VARIANTS.md).
 
 ## System One (TypeSafe API schema 0.2.0)
 

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/docs/VARIANTS.md

@@ -45,8 +45,8 @@ the parity, hash and license gates for this catalog.
 The same catalog variant is used by the library, CLI and REST API. Selection
 precedence is:
 
-1. an explicit per-call/per-request variant (`DecisionModel(..., variant=...)`,
-   `--variant`, or `"variant"` in a REST body);
+1. an explicit per-call variant in the library or CLI
+   (`DecisionModel(..., variant=...)`, `--variant`);
 2. the CLI/server configuration (`dtk models use`, or `dtk serve --variant`);
 3. the catalog default marked with `*`.
 
@@ -54,17 +54,18 @@ precedence is:
 | --- | --- | --- |
 | Library | `DecisionModel("gliner2.5-multi", variant="fp32")` | persisted variant for the current model, else catalog default |
 | CLI | `--variant fp32` | variant selected by `dtk models use`, else catalog default |
-| REST (local extension) | `"variant": "fp32"` in the request body | server `--variant`, else persisted variant for the current model, else catalog default |
+| REST | `"model": "gliner2.5-multi@fp32"` (model alias) | base model id; server `--variant`/persisted default |
 
 `DecisionModel.variant` and the CLI report the selected variant (`id@variant` in
 `dtk models current`). REST responses expose it under the namespaced
 `x_decision_toolkit.variant` extension; `/v1/decision-models` includes
 `current` and `current_variant`, plus all `variants` and `cached_variants`.
-`variant` is **not** part of TypeSafe or OpenAI; standard clients should omit it
-and rely on the server's `--variant`/persisted default. A server started with
+`variant` is **not** part of TypeSafe or OpenAI, and standard REST clients must
+not send it. They select only `model`; the local server chooses the quantization
+from `--variant` or the persisted default. A server started with
 `--model`/`--variant` reports that default in `/v1/info` and `/ready`.
 
-The variant must have been downloaded before a library call or REST request
+The variant must have been downloaded before a library call or REST alias
 loads it. An unknown variant returns a model-not-found error; a known but
 missing cache entry returns a model-not-downloaded error.
 
@@ -162,14 +163,18 @@ from decision_toolkit import DecisionModel
 model = DecisionModel("gliner2.5-multi", variant="fp32")
 ```
 
-From REST, send the variant in the request body:
+For REST, select a quantization through the standard `model` field using the
+alias `id@variant`:
 
 ```json
-{"model": "gliner2.5-multi", "variant": "fp32", "state": "...",
- "questions": {"cat": {"type": "choice", "instructions": "What kind?",
-                       "criteria": {"meeting": null, "other": null}}}}
+{"model": "gliner2.5-multi@fp32", "state": "...", "questions": {}}
 ```
 
+The base id (`gliner2.5-multi`) uses the server `--variant`/persisted default.
+`/v1/models` lists base models and every alias, and the registry can hold two
+aliases of the same base model in separate slots. Do not add a `variant` field
+to the request body.
+
 The variant must already be downloaded. If you name an unknown variant, the
 error lists the catalogued choices, for example:
 

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "decision-toolkit"
-version = "0.3.1"
+version = "0.4.0"
 description = "Local-first toolkit for open-weights decision models: one ONNX engine, one adapter per model contract, typed choice/yes-no/score decisions with probabilities on CPU."
 readme = "README.md"
 requires-python = ">=3.12"

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/src/decision_toolkit/__init__.py

@@ -7,7 +7,7 @@ questions with a calibrated probability for every option, on CPU.
 
 from __future__ import annotations
 
-__version__ = "0.3.1"
+__version__ = "0.4.0"
 
 from .adapters import register_adapter
 from .calibration import brier_score, expected_calibration_error, threshold_sweep

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/src/decision_toolkit/catalog.py

@@ -703,6 +703,23 @@ def get(model_id: str) -> CatalogModel | None:
     return CATALOG_BY_ID.get(model_id)
 
 
+def parse_alias(model_id: str) -> tuple[str, str | None]:
+    """Split a REST model alias ``catalog-id@variant``.
+
+    Plain ids and non-catalog paths are returned unchanged. This is the
+    standard-compatible way to select a quantization: the OpenAI/TypeSafe
+    ``model`` field remains a single string; no non-standard ``variant`` body
+    field is needed.
+    """
+    if "@" not in model_id:
+        return model_id, None
+    base, variant_name = model_id.rsplit("@", 1)
+    model = get(base)
+    if model is not None and any(variant.name == variant_name for variant in model.variants):
+        return base, variant_name
+    return model_id, None
+
+
 def select_variant(model: CatalogModel, name: str | None = None) -> Variant:
     """Choose a variant by name, or the model's default."""
     if name is None:
@@ -732,5 +749,6 @@ __all__ = [
     "ModelInfo",
     "Variant",
     "get",
+    "parse_alias",
     "select_variant",
 ]

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/src/decision_toolkit/contracts/openai_decisions_beta.py

@@ -72,7 +72,7 @@ class OpenAIDecisionsRequest(BaseModel):
         min_length=1, max_length=MAX_QUESTIONS
     )
     model: str | None = None
-    variant: str | None = None
+
     @model_validator(mode="after")
     def _validate_input(self) -> OpenAIDecisionsRequest:
         if self.input is None:

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/src/decision_toolkit/contracts/systemone_v1.py

@@ -117,7 +117,6 @@ class SystemOneRequest(BaseModel):
     files: list[str] | None = None
     images: list[str] | None = None
     model: str | None = None
-    variant: str | None = None
 
     @model_validator(mode="after")
     def _validate_state(self) -> SystemOneRequest:

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/src/decision_toolkit/registry.py

@@ -165,6 +165,14 @@ class ModelRegistry:
             raise ModelNotFoundError(
                 "no model configured; pass `model` or set one with `dtk models use`"
             )
+        base_identifier, alias_variant = catalog.parse_alias(identifier)
+        if alias_variant is not None:
+            identifier = base_identifier
+            if variant is not None and variant != alias_variant:
+                raise ModelNotFoundError(
+                    f"model alias selects variant {alias_variant!r}, not {variant!r}"
+                )
+            variant = alias_variant
         effective_variant = variant
         if effective_variant is None and identifier == self.default_identifier:
             effective_variant = self.default_variant

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/src/decision_toolkit/server.py

@@ -378,6 +378,7 @@ def _rich_model_payload(
     *,
     current: str | None,
     current_variant: str | None = None,
+    selected_variant: catalog.Variant | None = None,
 ) -> dict[str, Any]:
     payload = model.info.to_dict()
     payload["cached_variants"] = [
@@ -385,12 +386,38 @@ def _rich_model_payload(
     ]
     payload["current"] = model.id == current
     payload["current_variant"] = current_variant if model.id == current else None
+    payload["base_model"] = model.id
+    if selected_variant is not None:
+        payload["selected_variant"] = selected_variant.name
+        payload["selected_quant"] = selected_variant.quant
     payload["object"] = "model"
     payload["owned_by"] = "decision-toolkit"
     payload["created"] = 0
     return payload
 
 
+def _alias_payload(
+    model: catalog.CatalogModel,
+    variant: catalog.Variant,
+    cached: set[tuple[str, str]],
+    *,
+    current: str | None,
+    current_variant: str | None,
+) -> dict[str, Any]:
+    """OpenAI-shaped entry for the standard ``model`` alias ``id@variant``."""
+    payload = _rich_model_payload(
+        model,
+        cached,
+        current=current,
+        current_variant=current_variant,
+        selected_variant=variant,
+    )
+    payload["id"] = f"{model.id}@{variant.name}"
+    payload["name"] = f"{model.name} [{variant.name}]"
+    payload["alias"] = True
+    return payload
+
+
 def _cached_custom_payload(entry: Any) -> dict[str, Any]:
     return {
         "id": entry.identifier,
@@ -689,21 +716,35 @@ def create_app(
     @app.get("/v1/models", tags=["models"], dependencies=protected)
     def models() -> dict[str, Any]:
         _store, cached, current, current_variant = catalog_state()
-        data = [
-            {
-                "id": model.id,
+        data = []
+        for catalog_model in catalog.CATALOG:
+            data.append({
+                "id": catalog_model.id,
                 "object": "model",
                 "created": 0,
                 "owned_by": "decision-toolkit",
                 "x_decision_toolkit": _rich_model_payload(
-                    model,
+                    catalog_model,
                     cached,
                     current=current,
                     current_variant=current_variant,
                 ),
-            }
-            for model in catalog.CATALOG
-        ]
+            })
+            for catalog_variant in catalog_model.variants:
+                rich = _alias_payload(
+                    catalog_model,
+                    catalog_variant,
+                    cached,
+                    current=current,
+                    current_variant=current_variant,
+                )
+                data.append({
+                    "id": rich["id"],
+                    "object": "model",
+                    "created": 0,
+                    "owned_by": "decision-toolkit",
+                    "x_decision_toolkit": rich,
+                })
         known = {model.id for model in catalog.CATALOG}
         for entry in _store.entries():
             if entry.identifier not in known:
@@ -714,16 +755,28 @@ def create_app(
     @app.get("/v1/models/{model_name:path}", tags=["models"], dependencies=protected)
     def model_detail(model_name: str) -> dict[str, Any]:
         _store, cached, current, current_variant = catalog_state()
-        model = catalog.get(model_name)
+        base_name, alias_variant = catalog.parse_alias(model_name)
+        model = catalog.get(base_name)
         if model is not None:
-            rich = _rich_model_payload(
-                model,
-                cached,
-                current=current,
-                current_variant=current_variant,
+            selected = catalog.select_variant(model, alias_variant) if alias_variant else None
+            rich = (
+                _alias_payload(
+                    model,
+                    selected,
+                    cached,
+                    current=current,
+                    current_variant=current_variant,
+                )
+                if selected is not None
+                else _rich_model_payload(
+                    model,
+                    cached,
+                    current=current,
+                    current_variant=current_variant,
+                )
             )
             return {
-                "id": model.id,
+                "id": rich["id"],
                 "object": "model",
                 "created": 0,
                 "owned_by": "decision-toolkit",
@@ -782,7 +835,7 @@ def create_app(
                 "in this catalog"
             )
         questions = systemone_questions(payload.questions)
-        with registry.acquire(payload.model, payload.variant) as selected:
+        with registry.acquire(payload.model) as selected:
             decision = await run_decision(
                 selected,
                 payload.state,
@@ -826,7 +879,7 @@ def create_app(
         if len(set(names)) != len(names):
             raise InvalidRequestError("question names must be unique")
         state_text, core_questions, names = openai_to_systemone(payload.input, wire_questions)
-        with registry.acquire(payload.model, payload.variant) as selected:
+        with registry.acquire(payload.model) as selected:
             decision = await run_decision(
                 selected,
                 state_text,

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/tests/test_server.py

@@ -140,7 +140,7 @@ def test_rest_default_request_uses_persisted_variant(
     assert seen == [("gliner2.5-multi", "fp32")]
 
 
-def test_rest_explicit_variant_is_passed_to_the_model(monkeypatch, home):
+def test_rest_model_alias_selects_a_variant(monkeypatch, home):
     from decision_toolkit import registry as registry_module
 
     seen: list[tuple[str | None, str | None]] = []
@@ -152,7 +152,8 @@ def test_rest_explicit_variant_is_passed_to_the_model(monkeypatch, home):
     monkeypatch.setattr(registry_module, "DecisionModel", fake_model)
     app = create_app(model_id="gliner2.5-multi", home=str(home))
     response = TestClient(app).post(
-        "/v1/systemone", json=_systemone_body(variant="fp32")
+        "/v1/systemone",
+        json=_systemone_body(model="gliner2.5-multi@fp32"),
     )
     assert response.status_code == 200
     assert response.json()["x_decision_toolkit"]["variant"] == "fp32"
@@ -174,7 +175,7 @@ def test_rest_openai_request_passes_variant(monkeypatch, home):
         "/v1/decisions",
         json={
             "input": "Customer wants a refund.",
-            "variant": "fp32",
+            "model": "gliner2.5-multi@fp32",
             "questions": [
                 {
                     "type": "choice",
@@ -215,12 +216,42 @@ def test_rest_catalog_exposes_current_variant(home, fake_snapshot):
     assert ready.json()["variant"] == "fp32"
 
 
-def test_fixed_model_rejects_a_different_variant(client):
+def test_rest_loads_two_variants_of_one_model_in_separate_slots(
+    monkeypatch, home
+):
+    from decision_toolkit import registry as registry_module
+
+    seen: list[tuple[str | None, str | None]] = []
+
+    def fake_model(identifier=None, **kwargs):
+        seen.append((identifier, kwargs.get("variant")))
+        return _VariantModel(kwargs.get("variant") or "fp16")
+
+    monkeypatch.setattr(registry_module, "DecisionModel", fake_model)
+    app = create_app(model_id="gliner2.5-multi", home=str(home))
+    client = TestClient(app)
+    for alias in ("gliner2.5-multi@fp16", "gliner2.5-multi@fp32"):
+        response = client.post(
+            "/v1/systemone", json=_systemone_body(model=alias)
+        )
+        assert response.status_code == 200
+    assert seen == [
+        ("gliner2.5-multi", "fp16"),
+        ("gliner2.5-multi", "fp32"),
+    ]
+    loaded = app.state.registry.describe()["loaded"]
+    assert {item["key"] for item in loaded} == {
+        "gliner2.5-multi@fp16",
+        "gliner2.5-multi@fp32",
+    }
+
+
+def test_rest_rejects_the_nonstandard_variant_body_field(client):
     response = client.post(
         "/v1/systemone", json=_systemone_body(variant="fp16")
     )
-    assert response.status_code == 404
-    assert "bound" in response.json()["error"]["message"]
+    assert response.status_code == 422
+    assert response.json()["detail"]
 
 
 # ----------------------------------------------------------------- system one
@@ -655,6 +686,19 @@ def test_models_detail_and_rich_catalog(client):
     assert entry["capabilities"]["max_options"] == 255
 
 
+def test_models_endpoint_lists_variant_aliases(client):
+    payload = client.get("/v1/models").json()
+    by_id = {item["id"]: item for item in payload["data"]}
+    assert "gliner2.5-multi" in by_id
+    assert "gliner2.5-multi@fp16" in by_id
+    assert "gliner2.5-multi@fp32" in by_id
+    alias = by_id["gliner2.5-multi@fp32"]
+    assert alias["x_decision_toolkit"]["selected_variant"] == "fp32"
+    detail = client.get("/v1/models/gliner2.5-multi@fp32").json()
+    assert detail["id"] == "gliner2.5-multi@fp32"
+    assert detail["x_decision_toolkit"]["selected_variant"] == "fp32"
+
+
 def test_openai_sdk_can_list_models(client):
     openai = pytest.importorskip("openai")
 
@@ -723,9 +767,9 @@ def test_per_request_model_selection_uses_the_registry(monkeypatch, home):
         "/v1/systemone", json=_systemone_body(model="alpha")
     ).status_code == 200
     assert client.post(
-        "/v1/systemone", json=_systemone_body(model="beta", variant="q8")
+        "/v1/systemone", json=_systemone_body(model="gliner2.5-multi@fp32")
     ).status_code == 200
     loaded = app.state.registry.describe()["loaded"]
     keys = {item["key"] for item in loaded}
     assert "alpha@" in keys
-    assert "beta@q8" in keys
+    assert "gliner2.5-multi@fp32" in keys

{decision_toolkit-0.3.1 → decision_toolkit-0.4.0}/uv.lock

@@ -349,7 +349,7 @@ wheels = [
 
 [[package]]
 name = "decision-toolkit"
-version = "0.3.1"
+version = "0.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "huggingface-hub" },