Self-hosted AI workspace.
Python
"""Reasoning effort for utility-role LLM calls.
One owner for the rule. Precedence for a utility call:
1. an explicit caller effort (never touched here);
2. the ``utility_reasoning_effort`` setting, sent only to routes on the
utility chain (the Utility endpoint/model plus its fallbacks, matched by
``(url, model)``);
3. the chat session's own effort (``thinking_mode == "effort:<level>"``), when
the call is made for a chat session and its route is that session's route.
Every level is validated against what the model advertises; a model without
evidence gets nothing. Calls with no session only ever use (2).
"""
from typing import Optional
def utility_routes(owner: Optional[str] = None) -> set:
"""The ``(url, model)`` routes that make up the utility chain."""
from src.endpoint_resolver import resolve_endpoint, resolve_utility_fallback_candidates
return {
(url, model)
for url, model, _headers in [
resolve_endpoint("utility", owner=owner),
*resolve_utility_fallback_candidates(owner=owner),
]
if url and model
}
def configured_effort(owner: Optional[str] = None) -> str:
"""The raw setting, lowercased; empty when unset (the default)."""
from src.settings import get_user_setting
return str(get_user_setting("utility_reasoning_effort", owner or "", "") or "").strip().lower()
def fallback_route_efforts(owner: Optional[str] = None) -> dict[tuple[str, str], str]:
"""Configured effort per fallback candidate in ``utility_model_fallbacks``."""
from src.endpoint_resolver import resolve_endpoint_by_id
from src.settings import get_user_setting, load_settings
try:
settings = load_settings()
chain = get_user_setting(
"utility_model_fallbacks",
owner or "",
settings.get("utility_model_fallbacks") or [],
) or []
except Exception:
return {}
res = {}
for entry in chain:
if not isinstance(entry, dict) or "reasoning_effort" not in entry:
continue
effort = str(entry.get("reasoning_effort") or "").strip().lower()
ep = resolve_endpoint_by_id(
entry.get("endpoint_id", ""),
entry.get("model", ""),
owner=owner,
)
if ep:
url, model, _ = ep
if url and model:
res[(url, model)] = effort
return res
def effort_for_route(url: str, model: str, owner: Optional[str] = None) -> Optional[str]:
"""Validated effort for ``(url, model)``, or None when it must not be sent."""
fb_efforts = fallback_route_efforts(owner)
if (url, model) in fb_efforts:
fb_effort = fb_efforts[(url, model)]
if not fb_effort or fb_effort in {"off", "none", "default"}:
return None
from src.chatgpt_subscription import validate_reasoning_effort
return validate_reasoning_effort(model, fb_effort)
effort = configured_effort(owner)
if not effort or (url, model) not in utility_routes(owner):
return None
from src.chatgpt_subscription import validate_reasoning_effort
return validate_reasoning_effort(model, effort)
def session_effort(session) -> Optional[str]:
"""The raw effort level the chat session is set to, or None."""
mode = str(getattr(session, "thinking_mode", "") or "")
if not mode.startswith("effort:"):
return None
return mode[len("effort:"):].strip().lower() or None
def _is_session_route(url: str, model: str, session) -> bool:
from src.endpoint_resolver import same_endpoint_base
return bool(
model
and model == getattr(session, "model", None)
and same_endpoint_base(url, getattr(session, "endpoint_url", None))
)
def effort_for_call(url: str, model: str, owner: Optional[str] = None, session=None) -> Optional[str]:
"""Effort an owner-aware utility call should send to ``(url, model)``.
``session`` is the chat session the call is made for, or None for
session-less work (scheduled tasks, pollers, auto-sort). Never raises:
a lookup failure means "send nothing".
"""
try:
raw = configured_effort(owner)
if raw in {"off", "none", "default"}:
return None
effort = effort_for_route(url, model, owner)
if effort or session is None:
return effort
level = session_effort(session)
if not level or not _is_session_route(url, model, session):
return None
from src.chatgpt_subscription import validate_reasoning_effort
return validate_reasoning_effort(model, level)
except Exception:
return None
def candidate_effort_factory(owner=None):
"""Per-candidate factory for `llm_call_async_with_fallback`.
Returns None when neither the setting nor any fallback effort is configured.
Otherwise a factory sending the effort only to utility-chain candidates
(owner-scoped) whose model advertises it.
"""
raw = configured_effort(owner)
has_primary = bool(raw and raw not in {"off", "none", "default"})
fb_efforts = fallback_route_efforts(owner)
has_fb = any(eff and eff not in {"off", "none", "default"} for eff in fb_efforts.values())
if not has_primary and not has_fb:
return None
def factory(_index, url, model, _headers):
effort = effort_for_route(url, model, owner)
return {"kwargs": {"reasoning_effort": effort}} if effort else {}
return factory