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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
"""Persisted preference for telling the model today's date."""
from __future__ import annotations
from datetime import date, datetime, timedelta, timezone
from functools import lru_cache
import json
import re
from typing import Any
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
CURRENT_DATE_PROMPT_SETTING_KEY = "include_current_date_in_prompt"
# Lets callers recognise a prompt that already states a date, whoever put it there.
CURRENT_DATE_PROMPT_PREFIX = "The current date is "
# Leads the turn: a trailing sentence made small models answer about the date instead (PR #12096).
CURRENT_DATE_UPDATE_PREFIX = "[Current date: "
CURRENT_DATE_UPDATE_NOTE_RE = re.compile(
rf"^\s*{re.escape(CURRENT_DATE_UPDATE_PREFIX)}[0-9]{{4}}-[0-9]{{2}}-[0-9]{{2}}\]\s*"
)
CURRENT_DATE_PROMPT_LINE_RE = re.compile(
rf"(?m)^{re.escape(CURRENT_DATE_PROMPT_PREFIX)}[0-9]{{4}}-[0-9]{{2}}-[0-9]{{2}}\.(?=\r?$)"
)
# default on: date-blind models answer from their training cutoff and search for stale material.
DEFAULT_CURRENT_DATE_PROMPT_ENABLED = True
CURRENT_DATE_TIMEZONE_HEADER = "x-unsloth-timezone"
CURRENT_DATE_TIMEZONE_OFFSET_HEADER = "x-unsloth-timezone-offset-minutes"
MAX_TIMEZONE_OFFSET_MINUTES = 14 * 60
def contains_current_date_prompt_line(text: str) -> bool:
return CURRENT_DATE_PROMPT_LINE_RE.search(text) is not None
def replace_current_date_prompt_lines(text: str, date_line: str) -> str:
return CURRENT_DATE_PROMPT_LINE_RE.sub(date_line, text)
def strip_current_date_prompt_lines(text: str) -> str:
if not contains_current_date_prompt_line(text):
return text
return "".join(
line
for line in text.splitlines(keepends = True)
if not CURRENT_DATE_PROMPT_LINE_RE.fullmatch(line.rstrip("\r\n"))
).strip()
def _coerce_bool(value: Any) -> bool | None:
if isinstance(value, bool):
return value
if isinstance(value, str):
normalized = value.strip().lower()
if normalized in {"1", "true", "yes", "on"}:
return True
if normalized in {"0", "false", "no", "off", ""}:
return False
return None
def get_current_date_prompt_enabled() -> bool:
"""Read the persisted preference, defaulting to enabled when it is missing or unreadable."""
try:
from storage.studio_db import get_app_setting
stored = get_app_setting(CURRENT_DATE_PROMPT_SETTING_KEY, None)
except Exception:
stored = None
parsed = _coerce_bool(stored)
return parsed if parsed is not None else DEFAULT_CURRENT_DATE_PROMPT_ENABLED
def set_current_date_prompt_enabled(value: Any) -> bool:
"""Persist whether prompts should state the current date."""
parsed = _coerce_bool(value)
if parsed is None:
raise ValueError("Include current date in prompt must be true or false.")
from storage.studio_db import upsert_app_settings
upsert_app_settings({CURRENT_DATE_PROMPT_SETTING_KEY: parsed})
return parsed
def _request_local_date(request: Any, now: datetime | None = None) -> date:
instant = now or datetime.now(timezone.utc)
try:
headers = request.headers
except Exception:
return instant.astimezone().date()
timezone_name = str(headers.get(CURRENT_DATE_TIMEZONE_HEADER) or "").strip()
if timezone_name and len(timezone_name) <= 64:
try:
return instant.astimezone(ZoneInfo(timezone_name)).date()
except (ValueError, ZoneInfoNotFoundError, OSError):
pass
try:
offset_minutes = int(headers.get(CURRENT_DATE_TIMEZONE_OFFSET_HEADER, ""))
except (TypeError, ValueError):
return instant.astimezone().date()
if abs(offset_minutes) > MAX_TIMEZONE_OFFSET_MINUTES:
return instant.astimezone().date()
browser_zone = timezone(timedelta(minutes = -offset_minutes))
return instant.astimezone(browser_zone).date()
def current_date_prompt_line(today: date | None = None, request: Any = None) -> str:
"""Return the shared date sentence, or an empty string when the preference is off."""
if not get_current_date_prompt_enabled():
return ""
resolved_date = today or _request_local_date(request)
return f"{CURRENT_DATE_PROMPT_PREFIX}{resolved_date.isoformat()}."
_PROBE_SYSTEM = "UNSLOTH_DATE_PROBE_SYSTEM"
_PROBE_USER = "UNSLOTH_DATE_PROBE_USER"
# stand-ins for the tokenizer's control tokens, so a default that carries one can be told apart.
_PROBE_SPECIAL_TOKENS = {
f"{name}_token": f"UNSLOTH_DATE_PROBE_{name.upper()}"
for name in ("bos", "eos", "pad", "unk", "sep", "cls", "mask")
}
# Names the probe passes itself; a caller's template kwarg of the same name would collide.
PROBE_RENDER_KEYS = frozenset(
{"messages", "tools", "documents", "add_generation_prompt", *_PROBE_SPECIAL_TOKENS}
)
# a catalog a tool request's branch can render, for probing the template it selects.
PROBE_TOOLS = [
{
"type": "function",
"function": {
"name": "probe",
"description": "Probe.",
"parameters": {"type": "object", "properties": {}},
},
}
]
def _render_probe(
chat_template: str,
messages: list[dict],
today: date,
tools: list | None = None,
controls: dict | None = None,
) -> str:
from jinja2.exceptions import TemplateError
from jinja2.ext import Extension
from jinja2.sandbox import ImmutableSandboxedEnvironment
def raise_exception(message):
raise TemplateError(message)
def tojson(
value,
ensure_ascii = False,
indent = None,
separators = None,
sort_keys = False,
):
# Transformers disables HTML escaping, so the probe must match the same bytes.
return json.dumps(
value,
ensure_ascii = ensure_ascii,
indent = indent,
separators = separators,
sort_keys = sort_keys,
)
class _GenerationTag(Extension):
tags = {"generation"}
def parse(self, parser):
next(parser.stream)
return parser.parse_statements(["name:endgeneration"], drop_needle = True)
# Match transformers' chat-template syntax; a generation block is transparent in this text-only probe.
env = ImmutableSandboxedEnvironment(
trim_blocks = True,
lstrip_blocks = True,
extensions = [_GenerationTag, "jinja2.ext.loopcontrols"],
)
env.filters["tojson"] = tojson
env.globals["raise_exception"] = raise_exception
# the user's day, so a default that dates itself (or works out yesterday) is dated for them.
env.globals["strftime_now"] = today.strftime
return env.from_string(chat_template).render(
messages = messages,
tools = tools,
documents = None,
add_generation_prompt = False,
**_PROBE_SPECIAL_TOKENS,
**(controls or {}),
)
def _is_whitespace_normalized_substring(value: str, container: str) -> bool:
"""Whether ``value`` remains intact after ignoring formatting whitespace."""
return " ".join(value.split()) in " ".join(container.split())
@lru_cache(maxsize = 16)
def template_system_turn(
chat_template: str | None,
today: date,
tools: bool = False,
controls: tuple = (),
) -> tuple[bool, str | None]:
"""Default is empty when the template has none or the probe cannot render; None when no system turn reproduces it."""
if not chat_template:
return True, ""
catalog = PROBE_TOOLS if tools else None
kwargs = dict(controls)
renders_chat = False
prefix = None
# some templates read message text only from content parts, as a vision processor sends it.
for content in (lambda text: text, lambda text: [{"type": "text", "text": text}]):
user = {"role": "user", "content": content(_PROBE_USER)}
def render(system: str | None) -> str:
turns = [{"role": "system", "content": content(system)}] if system is not None else []
return _render_probe(chat_template, [*turns, user], today, catalog, kwargs)
try:
bare = render(None)
except Exception:
continue
renders_chat = True
try:
with_system = render(_PROBE_SYSTEM)
except Exception:
continue
if with_system.count(_PROBE_SYSTEM) != 1:
continue
head, tail = with_system.split(_PROBE_SYSTEM)
without_system = head + tail
if _is_whitespace_normalized_substring(bare, without_system):
return True, ""
if prefix is None:
try:
prefix = _render_probe(chat_template, [], today, catalog, kwargs)
except Exception:
prefix = ""
# what the template writes before any message, like BOS or GLM's [gMASK]<sop>, is no turn.
fixed = len(prefix) if bare.startswith(prefix) and head.startswith(prefix) else 0
if fixed and _is_whitespace_normalized_substring(bare[fixed:], without_system[fixed:]):
return True, ""
if len(bare) <= len(without_system) or not bare.startswith(head) or not bare.endswith(tail):
# Replaying it would silently replace the native default with the date, so the branch is non-replayable.
return True, None
default = bare[len(head) : len(bare) - len(tail)]
try:
replayed = render(default)
except Exception:
replayed = None
# replayed as text, a control token in the default would no longer be one.
carries_token = any(token in default for token in _PROBE_SPECIAL_TOKENS.values())
return True, (default.strip() if replayed == bare and not carries_token else None)
return not renders_chat, ("" if not renders_chat else None)
def strip_current_date_update_note(text: str) -> str:
return CURRENT_DATE_UPDATE_NOTE_RE.sub("", text)