Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Studio: model aliases for the OpenAI-compatible API (#13361)

Daniel Hanfa8b6eb92240
diff --git a/studio/backend/main.py b/studio/backend/main.py
index c18aea8f70c..efadc8e4d75 100644
--- a/studio/backend/main.py
+++ b/studio/backend/main.py
@@ -1699,6 +1699,11 @@ class MaxBodyMiddleware:
await self.app(scope, replay_receive, send)
+# Added before MaxBodyMiddleware so it runs inside it: the body it reads is already capped.
+from utils.model_aliases import ModelAliasMiddleware # noqa: E402
+
+app.add_middleware(ModelAliasMiddleware)
+
app.add_middleware(
MaxBodyMiddleware,
max_bytes_getter = default_request_body_limit_bytes,
diff --git a/studio/backend/routes/inference.py b/studio/backend/routes/inference.py
index 2af2bfddec6..35fbb0c6f64 100644
--- a/studio/backend/routes/inference.py
+++ b/studio/backend/routes/inference.py
@@ -37044,6 +37044,19 @@ async def loaded_inference_models(current_subject: str = Depends(get_current_sub
return {"object": "list", "data": [{**entry, "loaded": True} for entry in models]}
+async def _openai_catalog_with_aliases(quant_pins: bool = False) -> list[dict]:
+ from utils.model_aliases import alias_model_objects
+
+ if quant_pins:
+ objects = await _openai_catalog_objects(quant_pins = True)
+ else:
+ objects = await _openai_catalog_objects()
+ aliases = await asyncio.to_thread(alias_model_objects, objects, _pinned_quant_row)
+ # The rewrite gives an alias precedence, so a same-named model row would never be served.
+ shadowed = {row["id"].lower() for row in aliases}
+ return [o for o in objects if str(o.get("id", "")).lower() not in shadowed] + aliases
+
+
# Some OpenAI-compatible clients (notably DEVONthink) probe ``/v1/models/``
# literally and do not follow FastAPI's automatic slash redirect. Register the
# slash form directly so model discovery reaches authentication and returns the
@@ -37063,10 +37076,10 @@ async def openai_list_models(
"""
wanted = {m.strip() for m in (output_modalities or "").split(",")}
if not wanted & {"all", "decisions"}:
- return {"object": "list", "data": await _openai_catalog_objects(quant_pins = True)}
+ return {"object": "list", "data": await _openai_catalog_with_aliases(quant_pins = True)}
from routes.systemone import decision_model_objects
- data = [] if wanted == {"decisions"} else await _openai_catalog_objects(quant_pins = True)
+ data = [] if wanted == {"decisions"} else await _openai_catalog_with_aliases(quant_pins = True)
data += await asyncio.to_thread(decision_model_objects)
return {"object": "list", "data": data}
@@ -37107,6 +37120,11 @@ def _pinned_quant_object(model_id: str, objects: list[dict]) -> Optional[dict]:
return _quant_pin_object(listed, variant, _resident_gguf_quants)
+def _pinned_quant_row(model_id: str, objects: list[dict]) -> Optional[dict]:
+ pinned = _pinned_quant_object(model_id, objects)
+ return None if pinned is None else _with_openai_residency(pinned)
+
+
def _quant_pin_object(listed: dict, variant: str, resident_quants) -> dict:
"""*listed* pinned to its on-disk *variant*: the loaded row when that quant is resident."""
pinned_id = f"{listed['id']}:{variant}"
@@ -37140,13 +37158,17 @@ async def openai_retrieve_model(model_id: str, current_subject: str = Depends(ge
# the full catalog -- which may hit the filesystem -- for unloaded ids. Match
# case-insensitively, like the catalog loop below and the resolver's index.
# Off-loop like the catalog helper, and for the same sync resolver-index work.
+ from utils.model_aliases import resolve_model_alias
+
_loaded = await asyncio.to_thread(_openai_model_objects)
- for entry in _loaded:
+ # An alias wins over a same-named loaded model, as the request rewrite does.
+ aliased = await asyncio.to_thread(resolve_model_alias, model_id)
+ for entry in [] if aliased else _loaded:
eid = entry["id"]
if isinstance(eid, str) and eid.lower() == model_id.lower():
return _with_openai_residency({**entry, "loaded": True})
- objects = await _openai_catalog_objects()
+ objects = await _openai_catalog_with_aliases()
for model in objects:
# Case-insensitive to match the resolver, which lowercases its index.
mid = model.get("id")
diff --git a/studio/backend/routes/settings.py b/studio/backend/routes/settings.py
index 7775238ff45..2069743aafc 100644
--- a/studio/backend/routes/settings.py
+++ b/studio/backend/routes/settings.py
@@ -2377,6 +2377,54 @@ def update_openai_auto_switch(
)
+class ModelAliasEntry(BaseModel):
+ name: str
+ model: str
+
+
+class ModelAliasesPayload(BaseModel):
+ aliases: list[ModelAliasEntry] = Field(default_factory = list)
+
+
+class ModelAliasesResponse(BaseModel):
+ aliases: list[ModelAliasEntry]
+
+
+@_owner_settings_router.get("/model-aliases", response_model = ModelAliasesResponse)
+def get_model_aliases_setting(
+ current_subject: str = Depends(get_current_subject),
+) -> ModelAliasesResponse:
+ from utils.model_aliases import get_model_aliases
+ return ModelAliasesResponse(aliases = get_model_aliases())
+
+
+@_owner_settings_router.put("/model-aliases", response_model = ModelAliasesResponse)
+async def update_model_aliases_setting(
+ payload: ModelAliasesPayload, current_subject: str = Depends(get_current_subject)
+) -> ModelAliasesResponse:
+ from core.systemone import catalog as decision_catalog
+ from routes.inference import _openai_catalog_objects
+ from utils.model_aliases import set_model_aliases
+
+ # Decision ids (clef, laya-multilingual) are reserved even while that API is off.
+ objects = await _openai_catalog_objects()
+ model_ids = [o["id"] for o in objects if isinstance(o.get("id"), str)]
+ model_ids += list(decision_catalog.CHECKPOINTS)
+ try:
+ aliases = await asyncio.to_thread(
+ set_model_aliases, [entry.model_dump() for entry in payload.aliases], model_ids
+ )
+ except ValueError as exc:
+ raise log_and_http_error(
+ exc,
+ 400,
+ safe_curated_detail(exc, fallback = "Invalid model alias."),
+ event = "settings.update_model_aliases_failed",
+ log = logger,
+ ) from exc
+ return ModelAliasesResponse(aliases = aliases)
+
+
@_account_settings_router.get(
"/openai-auto-switch/overrides", response_model = ModelOverridesResponse
)
diff --git a/studio/backend/tests/test_model_aliases.py b/studio/backend/tests/test_model_aliases.py
new file mode 100644
index 00000000000..59ba95d5905
--- /dev/null
+++ b/studio/backend/tests/test_model_aliases.py
@@ -0,0 +1,364 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Owner-defined model aliases (#11649): validation, the /v1 body rewrite, and /v1/models rows."""
+
+import asyncio
+import json
+
+import pytest
+
+import utils.model_aliases as aliases_mod
+from utils.model_aliases import (
+ ModelAliasMiddleware,
+ alias_model_objects,
+ normalize_model_aliases,
+ set_model_aliases,
+)
+
+
+def store(monkeypatch):
+ import storage.studio_db as db
+ import utils.openai_auto_switch_settings as settings
+
+ data: dict = {}
+ monkeypatch.setattr(db, "upsert_app_settings", lambda mapping: data.update(mapping))
+ monkeypatch.setattr(settings, "_cached_setting", lambda k, d = None: data.get(k, d))
+ return data
+
+
+def test_normalize_accepts_valid_and_strips():
+ assert normalize_model_aliases(
+ [{"name": " fast-chat ", "model": " unsloth/Qwen3-4B-GGUF:Q4_K_M "}]
+ ) == [{"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF:Q4_K_M"}]
+ assert normalize_model_aliases(None) == []
+
+
+ "entries",
+ [
+ [{"name": "org/model", "model": "x"}],
+ [{"name": "chat:Q4", "model": "x"}],
+ [{"name": "", "model": "x"}],
+ [{"name": "Default", "model": "x"}],
+ [{"name": "chat", "model": ""}],
+ [{"name": "chat", "model": "a"}, {"name": "CHAT", "model": "b"}],
+ [{"name": "a", "model": "b"}, {"name": "b", "model": "c"}],
+ ],
+)
+def test_normalize_rejects_bad_entries(entries):
+ with pytest.raises(ValueError):
+ normalize_model_aliases(entries)
+
+
+def test_set_is_idempotent_and_a_bad_stored_row_disables_aliases(store):
+ entries = [{"name": "code", "model": "unsloth/Qwen3-Coder-GGUF"}]
+ assert set_model_aliases(entries) == set_model_aliases(entries) == entries
+ assert aliases_mod.resolve_model_alias("CODE") == "unsloth/Qwen3-Coder-GGUF"
+ store[aliases_mod.MODEL_ALIASES_SETTING_KEY] = [{"name": "bad/name", "model": "x"}]
+ assert aliases_mod.get_model_aliases() == []
+
+
+def _run_middleware(
+ body: bytes,
+ headers = None,
+ path = "/v1/chat/completions",
+ method = "POST",
+):
+ seen = {}
+
+ async def app(scope, receive, send):
+ message = await receive()
+ seen["body"] = message["body"]
+ seen["headers"] = dict(scope["headers"])
+
+ sent = [{"type": "http.request", "body": body, "more_body": False}]
+
+ async def receive():
+ return sent.pop(0)
+
+ scope = {
+ "type": "http",
+ "method": method,
+ "path": path,
+ "headers": headers
+ if headers is not None
+ else [(b"content-type", b"application/json"), (b"content-length", b"%d" % len(body))],
+ }
+ asyncio.run(ModelAliasMiddleware(app)(scope, receive, None))
+ return seen
+
+
+def test_middleware_rewrites_alias_and_content_length(store):
+ set_model_aliases([{"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF:Q4_K_M"}])
+ body = json.dumps({"model": "Fast-Chat", "messages": [{"role": "user", "content": "hé"}]})
+ seen = _run_middleware(body.encode())
+ payload = json.loads(seen["body"])
+ assert payload["model"] == "unsloth/Qwen3-4B-GGUF:Q4_K_M"
+ assert payload["messages"][0]["content"] == "hé"
+ assert seen["headers"][b"content-length"] == str(len(seen["body"])).encode()
+
+
+ "body, kwargs",
+ [
+ (b'{"model": "unsloth/Qwen3-4B-GGUF", "messages": []}', {}),
+ (b'{"model": "fast-chat"}', {"path": "/api/settings/x"}),
+ (b'{"model": "fast-chat"}', {"path": "/v1/systemone"}),
+ (b'{"model": "fast-chat"}', {"path": "/api/inference/audio/stt/load"}),
+ (b'{"model": "fast-chat"}', {"path": "/v1/modelsx/chat/completions"}),
+ (b'{"model": "fast-chat"}', {"method": "PUT"}),
+ (b"not json", {}),
+ (b'["model"]', {}),
+ (b'{"model": "fast-chat"}', {"headers": [(b"content-type", b"multipart/form-data")]}),
+ (b'{"model": "fast-chat"}', {"headers": [(b"content-type", b"audio/wav")]}),
+ (b'{"model": "fast-chat"}', {"headers": [(b"content-type", b"application/octet-stream")]}),
+ (b'{"model": "fast-chat"}', {"headers": []}),
+ (
+ b'{"model": "fast-chat"}',
+ {"path": "/v1/audio/inputs/"},
+ ),
+ ],
+)
+def test_middleware_leaves_other_requests_byte_identical(store, body, kwargs):
+ set_model_aliases([{"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF"}])
+ assert _run_middleware(body, **kwargs)["body"] == body
+
+
+def test_middleware_is_passthrough_without_aliases(store):
+ body = b'{"model": "fast-chat"}'
+ assert _run_middleware(body)["body"] == body
+
+
+def test_alias_rows_follow_the_visible_catalog(store):
+ set_model_aliases(
+ [
+ {"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF:Q4_K_M"},
+ {"name": "hidden", "model": "someone/not-on-disk"},
+ {"name": "local-model", "model": "unsloth/Qwen3-4B-GGUF"},
+ {"name": "dictate", "model": "unsloth/whisper-tiny"},
+ {"name": "clip", "model": "Wan-AI/Wan2.2-TI2V-5B"},
+ ]
+ )
+ catalog = [
+ {
+ "id": "unsloth/Qwen3-4B-GGUF",
+ "object": "model",
+ "loaded": True,
+ "quant": "Q8_0",
+ "display_name": "Qwen3 4B",
+ },
+ {"id": "local-model", "object": "model", "loaded": False},
+ {"id": "unsloth/whisper-tiny", "object": "model", "task": "automatic-speech-recognition"},
+ {"id": "Wan-AI/Wan2.2-TI2V-5B", "object": "model", "task": "text-to-video"},
+ ]
+
+ def pinned(target, objects):
+ # Stand-in for routes.inference._pinned_quant_object: only Q4_K_M is on disk.
+ if target.lower().endswith(":q4_k_m"):
+ return {**objects[0], "id": target, "quant": "Q4_K_M", "loaded": False}
+ return None
+
+ local = {
+ "id": "local-model",
+ "object": "model",
+ "loaded": True,
+ "alias_for": "unsloth/Qwen3-4B-GGUF",
+ }
+ # An alias the rewrite applies is listed even over a same-named model row.
+ assert alias_model_objects(catalog) == [local]
+ rows = alias_model_objects(catalog, pinned)
+ assert rows == [
+ {
+ "id": "fast-chat",
+ "object": "model",
+ "loaded": False,
+ "alias_for": "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ },
+ local,
+ ]
+ set_model_aliases([{"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF:Q8_0"}])
+ assert alias_model_objects(catalog, pinned) == []
+
+
+def test_catalog_listing_drops_the_model_row_an_alias_shadows(store, monkeypatch):
+ import routes.inference as inference
+
+ async def catalog(quant_pins = False):
+ return [
+ {"id": "unsloth/Qwen3-4B-GGUF", "object": "model", "loaded": False},
+ {"id": "local-model", "object": "model", "loaded": False},
+ ]
+
+ monkeypatch.setattr(inference, "_openai_catalog_objects", catalog)
+ set_model_aliases([{"name": "local-model", "model": "unsloth/Qwen3-4B-GGUF"}])
+ listed = asyncio.run(inference._openai_catalog_with_aliases())
+ assert [(m["id"], m.get("alias_for")) for m in listed] == [
+ ("unsloth/Qwen3-4B-GGUF", None),
+ ("local-model", "unsloth/Qwen3-4B-GGUF"),
+ ]
+
+
+def test_set_rejects_an_alias_that_reuses_a_real_model_id(store):
+ with pytest.raises(ValueError, match = "already the name of a model"):
+ set_model_aliases([{"name": "My-Model", "model": "unsloth/Qwen3-4B-GGUF"}], ["my-model"])
+ assert store == {}
+
+
+def test_pydantic_route_sees_the_target_behind_the_body_cap(store):
+ from fastapi import FastAPI
+ from fastapi.testclient import TestClient
+ from pydantic import BaseModel
+
+ import main
+
+ class Body(BaseModel):
+ model: str = "default"
+ temperature: float = 1.0
+
+ app = FastAPI()
+
+ @app.post("/v1/chat/completions")
+ def echo(body: Body):
+ return body.model_dump()
+
+ app.add_middleware(ModelAliasMiddleware)
+ app.add_middleware(
+ main.MaxBodyMiddleware, max_bytes_getter = lambda: 64, protected_prefixes = ("/v1",)
+ )
+ set_model_aliases([{"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF"}])
+ client = TestClient(app)
+ ok = client.post("/v1/chat/completions", json = {"model": "fast-chat", "temperature": 0.2})
+ assert ok.json() == {"model": "unsloth/Qwen3-4B-GGUF", "temperature": 0.2}
+ # The cap still runs first: an oversized aliased body is refused, never buffered here.
+ assert (
+ client.post("/v1/chat/completions", json = {"model": "fast-chat", "x": "y" * 100}).status_code
+ == 413
+ )
+
+
+def test_main_app_registers_the_alias_middleware_inside_the_body_cap():
+ import main
+ classes = [m.cls for m in main.app.user_middleware]
+ assert classes.index(main.MaxBodyMiddleware) < classes.index(ModelAliasMiddleware)
+
+
+def test_retrieve_prefers_an_alias_over_a_same_named_loaded_model(store, monkeypatch):
+ import routes.inference as inference
+
+ loaded = [{"id": "local-model", "object": "model"}]
+
+ async def catalog(quant_pins = False):
+ return [{"id": "unsloth/Qwen3-4B-GGUF", "object": "model", "loaded": False}, *loaded]
+
+ monkeypatch.setattr(inference, "_openai_model_objects", lambda: loaded)
+ monkeypatch.setattr(inference, "_openai_catalog_objects", catalog)
+ set_model_aliases([{"name": "local-model", "model": "unsloth/Qwen3-4B-GGUF"}])
+ got = asyncio.run(inference.openai_retrieve_model("local-model", current_subject = "owner"))
+ assert got["alias_for"] == "unsloth/Qwen3-4B-GGUF"
+
+
+def test_list_keeps_quant_pin_rows_next_to_aliases(store, monkeypatch):
+ import routes.inference as inference
+
+ async def catalog(quant_pins = False):
+ rows = [{"id": "unsloth/Qwen3-4B-GGUF", "object": "model", "loaded": False}]
+ if quant_pins:
+ rows.append({"id": "unsloth/Qwen3-4B-GGUF:Q4_K_M", "object": "model", "loaded": False})
+ return rows
+
+ monkeypatch.setattr(inference, "_openai_catalog_objects", catalog)
+ set_model_aliases([{"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF:Q4_K_M"}])
+ listed = asyncio.run(inference.openai_list_models(current_subject = "owner"))["data"]
+ assert [(m["id"], m.get("alias_for")) for m in listed] == [
+ ("unsloth/Qwen3-4B-GGUF", None),
+ ("unsloth/Qwen3-4B-GGUF:Q4_K_M", None),
+ ("fast-chat", "unsloth/Qwen3-4B-GGUF:Q4_K_M"),
+ ]
+
+
+def test_keepwarm_sees_the_markers_a_route_sets_on_an_aliased_request(store):
+ from core.inference import llama_keepwarm
+ from core.inference.llama_keepwarm import LlamaKeepWarmMiddleware, note_admitted_inference
+
+ # Relative to the process-wide counter: tests sharing an xdist worker can leave it raised.
+ baseline = llama_keepwarm.other_admitted_inference_count()
+
+ async def route(scope, receive, send):
+ await receive()
+ note_admitted_inference(scope)
+ assert llama_keepwarm.other_admitted_inference_count() == baseline + 1
+ await send({"type": "http.response.start", "status": 200, "headers": []})
+ await send({"type": "http.response.body", "body": b"{}", "more_body": False})
+
+ async def send(message):
+ pass
+
+ body = b'{"model": "fast-chat", "messages": []}'
+ sent = [{"type": "http.request", "body": body, "more_body": False}]
+
+ async def receive():
+ return sent.pop(0)
+
+ scope = {
+ "type": "http",
+ "method": "POST",
+ "path": "/v1/chat/completions",
+ "headers": [(b"content-type", b"application/json"), (b"content-length", b"%d" % len(body))],
+ }
+ set_model_aliases([{"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF"}])
+ asyncio.run(LlamaKeepWarmMiddleware(ModelAliasMiddleware(route))(scope, receive, send))
+ assert llama_keepwarm.other_admitted_inference_count() == baseline
+
+
+def test_retrieve_alias_to_an_unloaded_pin_reports_status(store, monkeypatch):
+ import core.inference.local_model_resolver as resolver
+ import routes.inference as inference
+
+ async def catalog(quant_pins = False):
+ return [
+ {
+ "id": "unsloth/Qwen3-4B-GGUF",
+ "object": "model",
+ "loaded": False,
+ "status": {"value": "unloaded"},
+ }
+ ]
+
+ monkeypatch.setattr(inference, "_openai_model_objects", lambda: [])
+ monkeypatch.setattr(inference, "_openai_catalog_objects", catalog)
+ monkeypatch.setattr(resolver, "local_gguf_pinned_variant", lambda model_id, **_: "Q4_K_M")
+ set_model_aliases([{"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF:Q4_K_M"}])
+ got = asyncio.run(inference.openai_retrieve_model("fast-chat", current_subject = "owner"))
+ assert got["alias_for"] == "unsloth/Qwen3-4B-GGUF:Q4_K_M"
+ assert got["status"] == {"value": "unloaded"}
+
+
+ "path",
+ ["/v1/chat/completions/", "/api/inference/chat/completions", "/v1/messages", "/v1/responses"],
+)
+def test_middleware_rewrites_on_every_chat_route(store, path):
+ set_model_aliases([{"name": "fast-chat", "model": "unsloth/Qwen3-4B-GGUF"}])
+ seen = _run_middleware(b'{"model": "fast-chat"}', path = path)
+ assert json.loads(seen["body"])["model"] == "unsloth/Qwen3-4B-GGUF"
+
+
+def test_saving_refuses_a_decision_model_id(store, monkeypatch):
+ from fastapi import HTTPException
+
+ import routes.inference as inference
+ import routes.settings as settings_routes
+
+ async def catalog():
+ return [{"id": "unsloth/Qwen3-4B-GGUF", "object": "model"}]
+
+ # With the Decision API off nothing lists clef, and it must still be refused.
+ monkeypatch.setattr(inference, "_openai_catalog_objects", catalog)
+ payload = settings_routes.ModelAliasesPayload(
+ aliases = [{"name": "clef", "model": "unsloth/Qwen3-4B-GGUF"}]
+ )
+ with pytest.raises(HTTPException) as err:
+ asyncio.run(settings_routes.update_model_aliases_setting(payload, current_subject = "owner"))
+ assert err.value.status_code == 400
diff --git a/studio/backend/utils/model_aliases.py b/studio/backend/utils/model_aliases.py
new file mode 100644
index 00000000000..c57dd2562dd
--- /dev/null
+++ b/studio/backend/utils/model_aliases.py
@@ -0,0 +1,226 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+"""Owner-defined, install-wide model aliases (``fast-chat`` -> a real model id) for API clients.
+
+Resolved once at the ASGI edge, so access checks, auto-switch and the resolver all see the real
+id: an alias never grants what its target would not. Names exclude ``/`` and ``:`` so they can
+never shadow a repo id or a ``model:quant`` pin."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Callable, Iterable, Optional
+
+MODEL_ALIASES_SETTING_KEY = "openai_api_model_aliases"
+MAX_MODEL_ALIASES = 100
+MAX_ALIAS_TARGET_LENGTH = 512
+_ALIAS_NAME_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$")
+_ALIAS_PATH_PREFIXES = ("/v1", "/api/inference")
+# Chat-model routes only: media, lifecycle and Decision API routes use their own model ids
+# (an STT "small" selector, "clef"), which an alias must never rewrite.
+_ALIAS_ROUTES = frozenset(
+ (
+ "/chat/completions",
+ "/chat/count_tokens",
+ "/completions",
+ "/embeddings",
+ "/messages",
+ "/messages/count_tokens",
+ "/responses",
+ )
+)
+_MODEL_VALUE_RE = re.compile(rb'"model"\s*:\s*"([^"\\]*)"')
+
+
+def normalize_model_aliases(raw: Any) -> list[dict[str, str]]:
+ """Validated ``[{"name", "model"}]``; raises ValueError naming the first bad entry."""
+ if raw is None:
+ return []
+ if not isinstance(raw, list):
+ raise ValueError("Model aliases must be a list.")
+ if len(raw) > MAX_MODEL_ALIASES:
+ raise ValueError(f"At most {MAX_MODEL_ALIASES} model aliases are allowed.")
+ aliases: list[dict[str, str]] = []
+ seen: set[str] = set()
+ for entry in raw:
+ if not isinstance(entry, dict):
+ raise ValueError("Each model alias needs a name and a model.")
+ name = str(entry.get("name") or "").strip()
+ model = str(entry.get("model") or "").strip()
+ if name.lower() == "default":
+ # Clients and the Decision API send "default" for "whatever is loaded".
+ raise ValueError("'default' is reserved and cannot be an alias name.")
+ if not _ALIAS_NAME_RE.match(name):
+ raise ValueError(
+ f"Alias name '{name}' must be 1 to 64 letters, digits, '.', '_' or '-' "
+ "and start with a letter or digit."
+ )
+ if not model or len(model) > MAX_ALIAS_TARGET_LENGTH:
+ raise ValueError(f"Alias '{name}' needs a model to point at.")
+ if name.lower() in seen:
+ raise ValueError(f"Alias '{name}' is defined twice.")
+ seen.add(name.lower())
+ aliases.append({"name": name, "model": model})
+ # One hop only: a target naming another alias would be served as a literal model id.
+ for alias in aliases:
+ if alias["model"].lower() in seen:
+ raise ValueError(f"Alias '{alias['name']}' cannot point at another alias.")
+ return aliases
+
+
+_normalized: tuple[Any, list[dict[str, str]]] = (None, [])
+
+
+def get_model_aliases() -> list[dict[str, str]]:
+ global _normalized
+ from utils.openai_auto_switch_settings import _cached_setting
+
+ raw = _cached_setting(MODEL_ALIASES_SETTING_KEY, None)
+ # The settings cache hands back the same object until it refreshes: validate once per object.
+ if raw is not _normalized[0]:
+ try:
+ aliases = normalize_model_aliases(raw)
+ except ValueError:
+ # A row the current rules reject (hand-edited db) disables aliases instead of 500ing /v1.
+ aliases = []
+ _normalized = (raw, aliases)
+ return _normalized[1]
+
+
+def set_model_aliases(raw: Any, model_ids: Iterable[str] = ()) -> list[dict[str, str]]:
+ """Replace the whole alias list; the same input always stores the same value. ``model_ids``
+ are real ids an alias may not reuse: the rewrite would silently serve other weights."""
+ from storage.studio_db import upsert_app_settings
+ from utils.openai_auto_switch_settings import _invalidate
+
+ aliases = normalize_model_aliases(raw)
+ taken = {model_id.lower() for model_id in model_ids}
+ for alias in aliases:
+ if alias["name"].lower() in taken:
+ raise ValueError(f"'{alias['name']}' is already the name of a model on this server.")
+ upsert_app_settings({MODEL_ALIASES_SETTING_KEY: aliases})
+ _invalidate(MODEL_ALIASES_SETTING_KEY)
+ return aliases
+
+
+def model_alias_map() -> dict[str, str]:
+ """Lowercased alias name -> target model id."""
+ return {alias["name"].lower(): alias["model"] for alias in get_model_aliases()}
+
+
+def resolve_model_alias(name: Any) -> Optional[str]:
+ if not isinstance(name, str) or not name:
+ return None
+ return model_alias_map().get(name.strip().lower())
+
+
+def alias_model_objects(
+ objects: list[dict], pinned_object: Optional[Callable[[str, list[dict]], Optional[dict]]] = None
+) -> list[dict]:
+ """``/v1/models`` rows for aliases whose target is in ``objects``, the caller's visible
+ catalog, so the listing never advertises a name that would 404. An alias the rewrite would
+ apply shadows a same-named model row (dropped by the caller). ``pinned_object`` resolves a
+ ``model:quant`` target the way ``GET /v1/models/{id}`` does (the quant must be on disk)."""
+ aliases = get_model_aliases()
+ if not aliases:
+ return []
+ by_id = {o["id"].lower(): o for o in objects if isinstance(o.get("id"), str)}
+ rows = []
+ for alias in aliases:
+ target = alias["model"]
+ listed = by_id.get(target.lower())
+ if listed is None and ":" in target and pinned_object is not None:
+ listed = pinned_object(target, objects)
+ # Chat models only: media routes take ``model`` in multipart or upload bodies the rewrite skips.
+ if listed is None or listed.get("task", "text-generation") != "text-generation":
+ continue
+ # The alias already names its quant; a listed one would invite an unresolvable "alias:Q4".
+ row = {k: v for k, v in listed.items() if k not in ("display_name", "quant")}
+ row.update(id = alias["name"], alias_for = target)
+ rows.append(row)
+ return rows
+
+
+def _rewrite_alias_body(body: bytes, aliases: dict[str, str]) -> Optional[bytes]:
+ """The body with an aliased top-level ``model`` replaced by its target, or None if unchanged."""
+ # Cheap scan first so a large (image, audio) body is only parsed when it names an alias.
+ if not any(
+ value.decode("utf-8", "ignore").strip().lower() in aliases
+ for value in _MODEL_VALUE_RE.findall(body)
+ ):
+ return None
+ try:
+ payload = json.loads(body)
+ except (ValueError, UnicodeDecodeError):
+ return None
+ if not isinstance(payload, dict):
+ return None
+ model = payload.get("model")
+ if not isinstance(model, str):
+ return None
+ target = aliases.get(model.strip().lower())
+ if target is None:
+ return None
+ payload["model"] = target
+ return json.dumps(payload, ensure_ascii = False).encode("utf-8")
+
+
+class ModelAliasMiddleware:
+ """Swap an aliased ``model`` for its target before any route runs. Never reads the body when
+ no alias is configured; registered inside MaxBodyMiddleware, so what it buffers is capped."""
+
+ def __init__(self, app):
+ self.app = app
+
+ async def __call__(self, scope, receive, send):
+ if scope["type"] != "http" or scope.get("method", "").upper() != "POST":
+ await self.app(scope, receive, send)
+ return
+ path = scope.get("path", "")
+ root_path = scope.get("root_path") or ""
+ if root_path and path.startswith(root_path):
+ path = path[len(root_path) :] or "/"
+ prefix = next((p for p in _ALIAS_PATH_PREFIXES if path.startswith(p)), "")
+ content_type = dict(scope.get("headers", [])).get(b"content-type", b"").lower()
+ # JSON only: raw and multipart uploads stream past the body cap and must never be held.
+ if (
+ not prefix
+ or path[len(prefix) :].rstrip("/") not in _ALIAS_ROUTES
+ or b"json" not in content_type
+ ):
+ await self.app(scope, receive, send)
+ return
+ aliases = model_alias_map()
+ if not aliases:
+ await self.app(scope, receive, send)
+ return
+
+ chunks: list[bytes] = []
+ while True:
+ message = await receive()
+ if message.get("type") != "http.request":
+ return
+ chunks.append(message.get("body", b"") or b"")
+ if not message.get("more_body", False):
+ break
+ body = b"".join(chunks)
+ rewritten = _rewrite_alias_body(body, aliases)
+ if rewritten is not None:
+ body = rewritten
+ headers = [(k, v) for k, v in scope.get("headers", []) if k != b"content-length"]
+ headers.append((b"content-length", str(len(body)).encode("ascii")))
+ # In place: outer middlewares (keep-warm) read markers the route sets on this same dict.
+ scope["headers"] = headers
+
+ replayed = False
+
+ async def replay_receive():
+ nonlocal replayed
+ if not replayed:
+ replayed = True
+ return {"type": "http.request", "body": body, "more_body": False}
+ return await receive()
+
+ await self.app(scope, replay_receive, send)
diff --git a/studio/frontend/src/features/settings/api/model-aliases.ts b/studio/frontend/src/features/settings/api/model-aliases.ts
new file mode 100644
index 00000000000..03f6e216484
--- /dev/null
+++ b/studio/frontend/src/features/settings/api/model-aliases.ts
@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import { authFetch } from "@/features/auth";
+import { readFastApiError } from "@/lib/format-fastapi-error";
+
+export type ModelAlias = { name: string; model: string };
+
+function parseAliases(body: unknown): ModelAlias[] {
+ const aliases = (body as { aliases?: unknown } | null)?.aliases;
+ if (!Array.isArray(aliases)) {
+ return [];
+ }
+ return aliases.flatMap((entry) =>
+ typeof entry?.name === "string" && typeof entry?.model === "string"
+ ? [{ name: entry.name, model: entry.model }]
+ : [],
+ );
+}
+
+export async function loadModelAliases(): Promise<ModelAlias[]> {
+ const res = await authFetch("/api/settings/model-aliases");
+ if (!res.ok) {
+ throw new Error(
+ await readFastApiError(res, "Failed to load model aliases"),
+ );
+ }
+ return parseAliases(await res.json());
+}
+
+/** Replaces the whole list; the server answers with what it stored. */
+export async function saveModelAliases(
+ aliases: ModelAlias[],
+): Promise<ModelAlias[]> {
+ const res = await authFetch("/api/settings/model-aliases", {
+ method: "PUT",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ aliases }),
+ });
+ if (!res.ok) {
+ throw new Error(
+ await readFastApiError(res, "Failed to save model aliases"),
+ );
+ }
+ return parseAliases(await res.json());
+}
diff --git a/studio/frontend/src/features/settings/components/model-aliases-section.tsx b/studio/frontend/src/features/settings/components/model-aliases-section.tsx
new file mode 100644
index 00000000000..b0e894f3d93
--- /dev/null
+++ b/studio/frontend/src/features/settings/components/model-aliases-section.tsx
@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { useT } from "@/i18n";
+import { Add01Icon, Delete02Icon } from "@hugeicons/core-free-icons";
+import { HugeiconsIcon } from "@hugeicons/react";
+import { useEffect, useId, useState } from "react";
+import {
+ type ModelAlias,
+ loadModelAliases,
+ saveModelAliases,
+} from "../api/model-aliases";
+import { listOpenAIModels } from "../api/openai-models";
+import { SettingsSection } from "./settings-section";
+
+function sameAliases(a: ModelAlias[], b: ModelAlias[]): boolean {
+ return (
+ a.length === b.length &&
+ a.every(
+ (alias, i) => alias.name === b[i].name && alias.model === b[i].model,
+ )
+ );
+}
+
+export function ModelAliasesSection() {
+ const t = useT();
+ const listId = useId();
+ const [saved, setSaved] = useState<ModelAlias[] | null>(null);
+ const [draft, setDraft] = useState<ModelAlias[]>([]);
+ const [modelIds, setModelIds] = useState<string[]>([]);
+ const [error, setError] = useState<string | null>(null);
+ const [isSaving, setIsSaving] = useState(false);
+
+ useEffect(() => {
+ let cancelled = false;
+ void loadModelAliases()
+ .then((loaded) => {
+ if (cancelled) {
+ return;
+ }
+ setSaved(loaded);
+ setDraft(loaded);
+ })
+ .catch((loadError) => {
+ if (cancelled) {
+ return;
+ }
+ setError(
+ loadError instanceof Error
+ ? loadError.message
+ : t("settings.general.modelAliases.loadError"),
+ );
+ });
+ // Suggestions only: a failed listing leaves the model field free text.
+ void listOpenAIModels()
+ .then((models) => {
+ if (!cancelled) {
+ setModelIds(models.map((m) => m.id));
+ }
+ })
+ .catch(() => {});
+ return () => {
+ cancelled = true;
+ };
+ }, [t]);
+
+ const aliasNames = new Set(draft.map((a) => a.name.trim().toLowerCase()));
+ const suggestions = modelIds.filter(
+ (id) => !aliasNames.has(id.toLowerCase()),
+ );
+ const dirty = saved !== null && !sameAliases(saved, draft);
+
+ const update = (index: number, patch: Partial<ModelAlias>) => {
+ setDraft((rows) =>
+ rows.map((row, i) => (i === index ? { ...row, ...patch } : row)),
+ );
+ };
+
+ const handleSave = async () => {
+ setIsSaving(true);
+ setError(null);
+ try {
+ const stored = await saveModelAliases(
+ draft.filter((row) => row.name.trim() || row.model.trim()),
+ );
+ setSaved(stored);
+ setDraft(stored);
+ } catch (saveError) {
+ setError(
+ saveError instanceof Error
+ ? saveError.message
+ : t("settings.general.modelAliases.saveError"),
+ );
+ } finally {
+ setIsSaving(false);
+ }
+ };
+
+ return (
+ <SettingsSection
+ title={t("settings.general.modelAliases.sectionTitle")}
+ description={t("settings.general.modelAliases.description")}
+ >
+ <datalist id={listId}>
+ {suggestions.map((id) => (
+ <option key={id} value={id} />
+ ))}
+ </datalist>
+ <div className="flex flex-col gap-2 py-3">
+ {draft.map((row, index) => (
+ // biome-ignore lint/suspicious/noArrayIndexKey: rows have no id until saved
+ <div key={index} className="flex items-center gap-2">
+ <Input
+ value={row.name}
+ placeholder={t("settings.general.modelAliases.namePlaceholder")}
+ aria-label={t("settings.general.modelAliases.nameAriaLabel")}
+ disabled={saved === null || isSaving}
+ onChange={(event) => update(index, { name: event.target.value })}
+ className="h-8 w-40"
+ />
+ <Input
+ value={row.model}
+ list={listId}
+ placeholder={t("settings.general.modelAliases.modelPlaceholder")}
+ aria-label={t("settings.general.modelAliases.modelAriaLabel")}
+ disabled={saved === null || isSaving}
+ onChange={(event) => update(index, { model: event.target.value })}
+ className="h-8 min-w-0 flex-1"
+ />
+ <Button
+ variant="ghost"
+ size="sm"
+ aria-label={t("settings.general.modelAliases.removeAriaLabel")}
+ disabled={saved === null || isSaving}
+ onClick={() =>
+ setDraft((rows) => rows.filter((_, i) => i !== index))
+ }
+ >
+ <HugeiconsIcon icon={Delete02Icon} className="size-3.5" />
+ </Button>
+ </div>
+ ))}
+ <div className="flex items-center justify-between gap-2">
+ <Button
+ variant="outline"
+ size="sm"
+ disabled={saved === null || isSaving}
+ onClick={() =>
+ setDraft((rows) => [...rows, { name: "", model: "" }])
+ }
+ >
+ <HugeiconsIcon icon={Add01Icon} className="mr-1.5 size-3.5" />
+ {t("settings.general.modelAliases.add")}
+ </Button>
+ <Button
+ variant="outline"
+ size="sm"
+ disabled={!dirty || isSaving}
+ onClick={() => void handleSave()}
+ >
+ {isSaving ? t("common.saving") : t("common.save")}
+ </Button>
+ </div>
+ {error ? (
+ <span className="text-xs text-destructive">{error}</span>
+ ) : null}
+ </div>
+ </SettingsSection>
+ );
+}
diff --git a/studio/frontend/src/features/settings/tabs/api-keys-tab.tsx b/studio/frontend/src/features/settings/tabs/api-keys-tab.tsx
index 0f0a1fcd3e8..566e5ce77c3 100644
--- a/studio/frontend/src/features/settings/tabs/api-keys-tab.tsx
+++ b/studio/frontend/src/features/settings/tabs/api-keys-tab.tsx
@@ -27,6 +27,7 @@ import { KeyRevealCard } from "../components/key-reveal-card";
import { KeylessApiAccessSection } from "../components/keyless-api-access-section";
import { LanAccessSection } from "../components/lan-access-section";
import { McpAccessSection } from "../components/mcp-access-section";
+import { ModelAliasesSection } from "../components/model-aliases-section";
import { ModelAutoSwitchSection } from "../components/model-auto-switch-section";
import { MonitorLink } from "../components/monitor-link";
import { RemoteAccessSection } from "../components/remote-access-section";
@@ -201,6 +202,8 @@ export function ApiKeysTab() {
<LanAccessSection />
<ModelAutoSwitchSection />
+
+ <ModelAliasesSection />
</>
) : null}
diff --git a/studio/frontend/src/i18n/locales/ar.ts b/studio/frontend/src/i18n/locales/ar.ts
index 6d1188597b3..8312391b8c9 100644
--- a/studio/frontend/src/i18n/locales/ar.ts
+++ b/studio/frontend/src/i18n/locales/ar.ts
@@ -1734,6 +1734,19 @@ export const ar = {
apiOnlyDescription:
"يُبقي التفريغ التلقائي عند الخمول النموذج الذي حمّلته من Unsloth في الذاكرة، ولا يفرّغ سوى النماذج التي حمّلها طلب عبر واجهة API.",
},
+ modelAliases: {
+ sectionTitle: "أسماء النماذج المستعارة (OpenAI API)",
+ description:
+ "أسماء ثابتة لعملاء الواجهة البرمجية مثل fast-chat أو code. يُخدَم الطلب الذي يذكر اسمًا مستعارًا بالنموذج الذي يشير إليه، فتستمر التطبيقات المتصلة في العمل عند تبديل النماذج. فعّل تبديل النموذج حسب الطلب ليتمكن الاسم المستعار من تحميل نموذجه.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "الاسم المستعار",
+ modelAriaLabel: "النموذج الذي يشير إليه الاسم المستعار",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "إزالة الاسم المستعار",
+ add: "إضافة اسم مستعار",
+ loadError: "تعذر تحميل أسماء النماذج المستعارة.",
+ saveError: "تعذر حفظ أسماء النماذج المستعارة.",
+ },
previewSharing: {
sectionTitle: "مشاركة المعاينة",
enableLabel: "روابط المعاينة العامة",
diff --git a/studio/frontend/src/i18n/locales/de.ts b/studio/frontend/src/i18n/locales/de.ts
index 7e4fe99abee..f7030d34d85 100644
--- a/studio/frontend/src/i18n/locales/de.ts
+++ b/studio/frontend/src/i18n/locales/de.ts
@@ -1751,6 +1751,19 @@ export const de = {
apiOnlyDescription:
"Das automatische Entladen bei Inaktivität lässt ein von dir in Unsloth geladenes Modell im Speicher und gibt nur solche frei, die eine API-Anfrage geladen hat.",
},
+ modelAliases: {
+ sectionTitle: "Modell-Aliase (OpenAI API)",
+ description:
+ "Feste Namen für API-Clients, etwa fast-chat oder code. Eine Anfrage mit einem Alias wird vom Modell bedient, auf das er zeigt, sodass verbundene Apps beim Modellwechsel weiter funktionieren. Aktiviere Modell je Anfrage wechseln, damit ein Alias sein Modell laden kann.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "Alias-Name",
+ modelAriaLabel: "Modell, auf das der Alias zeigt",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "Alias entfernen",
+ add: "Alias hinzufügen",
+ loadError: "Modell-Aliase konnten nicht geladen werden.",
+ saveError: "Modell-Aliase konnten nicht gespeichert werden.",
+ },
previewSharing: {
sectionTitle: "Vorschau-Freigabe",
enableLabel: "Öffentliche Vorschaulinks",
diff --git a/studio/frontend/src/i18n/locales/en.ts b/studio/frontend/src/i18n/locales/en.ts
index 60a36e1ccdb..3cf7dba1f0e 100644
--- a/studio/frontend/src/i18n/locales/en.ts
+++ b/studio/frontend/src/i18n/locales/en.ts
@@ -1785,6 +1785,19 @@ export const en = {
apiOnlyDescription:
"Idle unload leaves a model you loaded from Unsloth in memory, and frees only the ones an API request loaded.",
},
+ modelAliases: {
+ sectionTitle: "Model aliases (OpenAI API)",
+ description:
+ "Stable names for API clients, such as fast-chat or code. A request naming an alias is served by the model it points to, so connected apps keep working when you swap models. Turn on Switch model by request so an alias can load its model.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "Alias name",
+ modelAriaLabel: "Model the alias points to",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "Remove alias",
+ add: "Add alias",
+ loadError: "Failed to load model aliases.",
+ saveError: "Failed to save model aliases.",
+ },
previewSharing: {
sectionTitle: "Preview sharing",
enableLabel: "Public preview links",
diff --git a/studio/frontend/src/i18n/locales/es.ts b/studio/frontend/src/i18n/locales/es.ts
index be3fc9cb0ae..f5cf1a8ca44 100644
--- a/studio/frontend/src/i18n/locales/es.ts
+++ b/studio/frontend/src/i18n/locales/es.ts
@@ -1747,6 +1747,19 @@ export const es = {
apiOnlyDescription:
"La liberación por inactividad mantiene en memoria el modelo que cargaste desde Unsloth y solo libera los que cargó una solicitud a la API.",
},
+ modelAliases: {
+ sectionTitle: "Alias de modelos (OpenAI API)",
+ description:
+ "Nombres estables para clientes de la API, como fast-chat o code. Una solicitud que nombra un alias la atiende el modelo al que apunta, así las apps conectadas siguen funcionando cuando cambias de modelo. Activa Cambiar de modelo según la solicitud para que un alias pueda cargar el modelo al que apunta.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "Nombre del alias",
+ modelAriaLabel: "Modelo al que apunta el alias",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "Quitar alias",
+ add: "Añadir alias",
+ loadError: "No se pudieron cargar los alias de modelos.",
+ saveError: "No se pudieron guardar los alias de modelos.",
+ },
previewSharing: {
sectionTitle: "Compartir vista previa",
enableLabel: "Enlaces públicos de vista previa",
diff --git a/studio/frontend/src/i18n/locales/fr.ts b/studio/frontend/src/i18n/locales/fr.ts
index 07ea036a856..b5fc6e6740b 100644
--- a/studio/frontend/src/i18n/locales/fr.ts
+++ b/studio/frontend/src/i18n/locales/fr.ts
@@ -1750,6 +1750,19 @@ export const fr = {
apiOnlyDescription:
"Le déchargement en cas d'inactivité laisse en mémoire un modèle que vous avez chargé depuis Unsloth et ne libère que ceux chargés par une requête API.",
},
+ modelAliases: {
+ sectionTitle: "Alias de modèles (OpenAI API)",
+ description:
+ "Des noms stables pour les clients de l’API, comme fast-chat ou code. Une requête qui nomme un alias est servie par le modèle vers lequel il pointe, donc les apps connectées continuent de fonctionner quand vous changez de modèle. Activez Changer de modèle par requête pour qu’un alias puisse charger son modèle.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "Nom de l’alias",
+ modelAriaLabel: "Modèle vers lequel pointe l’alias",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "Supprimer l’alias",
+ add: "Ajouter un alias",
+ loadError: "Impossible de charger les alias de modèles.",
+ saveError: "Impossible d’enregistrer les alias de modèles.",
+ },
previewSharing: {
sectionTitle: "Partage de l'aperçu",
enableLabel: "Liens d'aperçu publics",
diff --git a/studio/frontend/src/i18n/locales/he.ts b/studio/frontend/src/i18n/locales/he.ts
index 500cf4353c8..bc04d40be61 100644
--- a/studio/frontend/src/i18n/locales/he.ts
+++ b/studio/frontend/src/i18n/locales/he.ts
@@ -1828,6 +1828,19 @@ export const he = {
apiOnlyDescription:
"פריקה בחוסר פעילות תשאיר מודל שטענת מ-Unsloth בזיכרון, ותשחרר רק מודלים שנטענו בעקבות בקשת API.",
},
+ modelAliases: {
+ sectionTitle: "כינויים למודלים (OpenAI API)",
+ description:
+ "שמות קבועים ללקוחות API, כמו fast-chat או code. בקשה שמציינת כינוי מוגשת על ידי המודל שאליו הוא מצביע, כך שאפליקציות מחוברות ממשיכות לעבוד כשמחליפים מודל. הפעילו את החלף מודל לפי בקשה כדי שכינוי יוכל לטעון את המודל שלו.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "שם הכינוי",
+ modelAriaLabel: "המודל שאליו הכינוי מצביע",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "הסרת כינוי",
+ add: "הוספת כינוי",
+ loadError: "טעינת הכינויים למודלים נכשלה.",
+ saveError: "שמירת הכינויים למודלים נכשלה.",
+ },
previewSharing: {
sectionTitle: "שיתוף תצוגה מקדימה",
enableLabel: "קישורי תצוגה מקדימה ציבוריים",
diff --git a/studio/frontend/src/i18n/locales/hi.ts b/studio/frontend/src/i18n/locales/hi.ts
index 9ec854f0897..0e4b1a8bdfb 100644
--- a/studio/frontend/src/i18n/locales/hi.ts
+++ b/studio/frontend/src/i18n/locales/hi.ts
@@ -1738,6 +1738,19 @@ export const hi = {
apiOnlyDescription:
"निष्क्रियता पर अनलोड करते समय Unsloth से आपके द्वारा लोड किया गया मॉडल मेमोरी में बना रहता है, और केवल वही मॉडल हटाए जाते हैं जिन्हें किसी API अनुरोध ने लोड किया था।",
},
+ modelAliases: {
+ sectionTitle: "मॉडल उपनाम (OpenAI API)",
+ description:
+ "API क्लाइंट के लिए स्थिर नाम, जैसे fast-chat या code. किसी उपनाम वाले अनुरोध को वही मॉडल जवाब देता है जिसकी ओर वह इशारा करता है, इसलिए मॉडल बदलने पर भी जुड़े ऐप चलते रहते हैं. उपनाम अपना मॉडल लोड कर सके, इसके लिए अनुरोध के अनुसार मॉडल बदलें चालू करें.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "उपनाम का नाम",
+ modelAriaLabel: "वह मॉडल जिसकी ओर उपनाम इशारा करता है",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "उपनाम हटाएं",
+ add: "उपनाम जोड़ें",
+ loadError: "मॉडल उपनाम लोड नहीं हो सके.",
+ saveError: "मॉडल उपनाम सहेजे नहीं जा सके.",
+ },
previewSharing: {
sectionTitle: "पूर्वावलोकन साझाकरण",
enableLabel: "सार्वजनिक पूर्वावलोकन लिंक",
diff --git a/studio/frontend/src/i18n/locales/it.ts b/studio/frontend/src/i18n/locales/it.ts
index bbfb27990fc..e5db6ec894e 100644
--- a/studio/frontend/src/i18n/locales/it.ts
+++ b/studio/frontend/src/i18n/locales/it.ts
@@ -1656,6 +1656,19 @@ export const it = {
apiOnlyDescription:
"Lo scaricamento per inattività lascia in memoria un modello caricato da te in Unsloth e libera solo quelli caricati da una richiesta API.",
},
+ modelAliases: {
+ sectionTitle: "Alias dei modelli (OpenAI API)",
+ description:
+ "Nomi stabili per i client API, come fast-chat o code. Una richiesta che nomina un alias viene servita dal modello a cui punta, così le app collegate continuano a funzionare quando cambi modello. Attiva Cambia modello in base alla richiesta perché un alias possa caricare il modello a cui punta.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "Nome dell'alias",
+ modelAriaLabel: "Modello a cui punta l'alias",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "Rimuovi alias",
+ add: "Aggiungi alias",
+ loadError: "Impossibile caricare gli alias dei modelli.",
+ saveError: "Impossibile salvare gli alias dei modelli.",
+ },
previewSharing: {
sectionTitle: "Condivisione delle anteprime",
enableLabel: "Link di anteprima pubblici",
diff --git a/studio/frontend/src/i18n/locales/ja.ts b/studio/frontend/src/i18n/locales/ja.ts
index 35a3f122aa2..2a356dc051c 100644
--- a/studio/frontend/src/i18n/locales/ja.ts
+++ b/studio/frontend/src/i18n/locales/ja.ts
@@ -1726,6 +1726,19 @@ export const ja = {
apiOnlyDescription:
"アイドル時の自動アンロードでは、Unsloth から自分で読み込んだモデルはメモリに残し、API リクエストが読み込んだモデルだけを解放します。",
},
+ modelAliases: {
+ sectionTitle: "モデルエイリアス (OpenAI API)",
+ description:
+ "fast-chat や code のような、API クライアント向けの固定名です。エイリアスを指定したリクエストは、そのエイリアスが指すモデルで処理されるため、モデルを入れ替えても接続中のアプリはそのまま動きます。エイリアスがモデルを読み込めるよう、リクエストごとにモデルを切り替えをオンにしてください。",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "エイリアス名",
+ modelAriaLabel: "エイリアスが指すモデル",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "エイリアスを削除",
+ add: "エイリアスを追加",
+ loadError: "モデルエイリアスを読み込めませんでした。",
+ saveError: "モデルエイリアスを保存できませんでした。",
+ },
previewSharing: {
sectionTitle: "プレビュー共有",
enableLabel: "公開プレビューリンク",
diff --git a/studio/frontend/src/i18n/locales/ko.ts b/studio/frontend/src/i18n/locales/ko.ts
index 9216de09e23..0c107c6b205 100644
--- a/studio/frontend/src/i18n/locales/ko.ts
+++ b/studio/frontend/src/i18n/locales/ko.ts
@@ -1731,6 +1731,19 @@ export const ko = {
apiOnlyDescription:
"유휴 해제 시 Unsloth에서 직접 불러온 모델은 메모리에 남기고, API 요청이 불러온 모델만 해제합니다.",
},
+ modelAliases: {
+ sectionTitle: "모델 별칭 (OpenAI API)",
+ description:
+ "fast-chat이나 code처럼 API 클라이언트용 고정 이름입니다. 별칭을 지정한 요청은 그 별칭이 가리키는 모델이 처리하므로, 모델을 바꿔도 연결된 앱이 계속 동작합니다. 별칭이 모델을 불러올 수 있도록 요청에 따라 모델 전환을 켜세요.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "별칭 이름",
+ modelAriaLabel: "별칭이 가리키는 모델",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "별칭 삭제",
+ add: "별칭 추가",
+ loadError: "모델 별칭을 불러오지 못했습니다.",
+ saveError: "모델 별칭을 저장하지 못했습니다.",
+ },
previewSharing: {
sectionTitle: "미리보기 공유",
enableLabel: "공개 미리보기 링크",
diff --git a/studio/frontend/src/i18n/locales/pt-br.ts b/studio/frontend/src/i18n/locales/pt-br.ts
index 7a03948df22..6a127e59aff 100644
--- a/studio/frontend/src/i18n/locales/pt-br.ts
+++ b/studio/frontend/src/i18n/locales/pt-br.ts
@@ -1740,6 +1740,19 @@ export const ptBR = {
apiOnlyDescription:
"O descarregamento por inatividade mantém na memória o modelo que você carregou pelo Unsloth e libera apenas os que uma requisição da API carregou.",
},
+ modelAliases: {
+ sectionTitle: "Aliases de modelos (OpenAI API)",
+ description:
+ "Nomes fixos para clientes da API, como fast-chat ou code. Uma solicitação que cita um alias é atendida pelo modelo para o qual ele aponta, então os apps conectados continuam funcionando quando você troca de modelo. Ative Trocar de modelo por requisição para que um alias possa carregar o modelo para o qual aponta.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "Nome do alias",
+ modelAriaLabel: "Modelo para o qual o alias aponta",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "Remover alias",
+ add: "Adicionar alias",
+ loadError: "Não foi possível carregar os aliases de modelos.",
+ saveError: "Não foi possível salvar os aliases de modelos.",
+ },
previewSharing: {
sectionTitle: "Compartilhamento de pré-visualização",
enableLabel: "Links públicos de pré-visualização",
diff --git a/studio/frontend/src/i18n/locales/ru.ts b/studio/frontend/src/i18n/locales/ru.ts
index 615a05b6d8a..56a4bd04ac7 100644
--- a/studio/frontend/src/i18n/locales/ru.ts
+++ b/studio/frontend/src/i18n/locales/ru.ts
@@ -1737,6 +1737,19 @@ export const ru = {
apiOnlyDescription:
"Автовыгрузка при простое оставляет в памяти модель, которую вы загрузили в Unsloth, и освобождает только те, что загрузил запрос через API.",
},
+ modelAliases: {
+ sectionTitle: "Псевдонимы моделей (OpenAI API)",
+ description:
+ "Постоянные имена для клиентов API, например fast-chat или code. Запрос с псевдонимом обслуживает модель, на которую он указывает, поэтому подключенные приложения продолжают работать при смене модели. Включите Переключать модель по запросу, чтобы псевдоним мог загрузить свою модель.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "Имя псевдонима",
+ modelAriaLabel: "Модель, на которую указывает псевдоним",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "Удалить псевдоним",
+ add: "Добавить псевдоним",
+ loadError: "Не удалось загрузить псевдонимы моделей.",
+ saveError: "Не удалось сохранить псевдонимы моделей.",
+ },
previewSharing: {
sectionTitle: "Публикация предпросмотра",
enableLabel: "Публичные ссылки предпросмотра",
diff --git a/studio/frontend/src/i18n/locales/sv.ts b/studio/frontend/src/i18n/locales/sv.ts
index 436b3a3e37d..676e90315f6 100644
--- a/studio/frontend/src/i18n/locales/sv.ts
+++ b/studio/frontend/src/i18n/locales/sv.ts
@@ -1888,6 +1888,19 @@ export const sv = {
apiOnlyDescription:
"Avlastning efter inaktivitet lämnar en modell som du läst in från Unsloth i minnet och frigör endast de som lästs in av en API-begäran.",
},
+ modelAliases: {
+ sectionTitle: "Modellalias (OpenAI API)",
+ description:
+ "Fasta namn för API-klienter, till exempel fast-chat eller code. En begäran som anger ett alias besvaras av modellen det pekar på, så anslutna appar fortsätter fungera när du byter modell. Slå på Byt modell enligt begäran så att ett alias kan läsa in sin modell.",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "Aliasnamn",
+ modelAriaLabel: "Modell som aliaset pekar på",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "Ta bort alias",
+ add: "Lägg till alias",
+ loadError: "Det gick inte att läsa in modellalias.",
+ saveError: "Det gick inte att spara modellalias.",
+ },
previewSharing: {
sectionTitle: "Delning av förhandsvisning",
enableLabel: "Offentliga förhandsvisningslänkar",
diff --git a/studio/frontend/src/i18n/locales/zh-CN.ts b/studio/frontend/src/i18n/locales/zh-CN.ts
index 0848aec769a..d8fafac444d 100644
--- a/studio/frontend/src/i18n/locales/zh-CN.ts
+++ b/studio/frontend/src/i18n/locales/zh-CN.ts
@@ -1714,6 +1714,19 @@ export const zhCN = {
apiOnlyDescription:
"空闲卸载会将你在 Unsloth 中加载的模型保留在内存中,只释放由 API 请求加载的模型。",
},
+ modelAliases: {
+ sectionTitle: "模型别名 (OpenAI API)",
+ description:
+ "为 API 客户端提供固定名称,例如 fast-chat 或 code。指定别名的请求由该别名指向的模型处理,因此更换模型后已连接的应用仍可正常使用。请开启按请求切换模型,以便别名可以加载其模型。",
+ namePlaceholder: "fast-chat",
+ nameAriaLabel: "别名名称",
+ modelAriaLabel: "别名指向的模型",
+ modelPlaceholder: "unsloth/Qwen3-4B-GGUF:Q4_K_M",
+ removeAriaLabel: "删除别名",
+ add: "添加别名",
+ loadError: "无法加载模型别名。",
+ saveError: "无法保存模型别名。",
+ },
previewSharing: {
sectionTitle: "预览分享",
enableLabel: "公开预览链接",