Include auth context in vision cache key

Caching only by model_name makes is_vision_model return stale/incorrect results when auth differs between calls. A common path is an unauthenticated probe that falls back to False (for gated/private models), then a later authenticated call still returns that cached False without re-checking; this is now process-wide because /config calls is_vision_model(model_name) without passing hf_token (studio/backend/routes/models.py), while other flows call is_vision_model(..., hf_token=...) (for example ModelConfig.from_identifier). That can misclassify gated vision models and disable vision-specific behavior until restart.

Useful? React with 👍 / 👎.

The cache key should include the hf_token to correctly handle gated models. If a check is first performed without a token (or with an invalid one) and fails, caching the False result under just the model_name will prevent subsequent attempts with a valid token from succeeding. This pattern is already used in is_embedding_model (line 1165). Note that updating this will require corresponding changes in the test suite to use tuple keys.

Incorporate the hf_token into the cache key and normalize local paths to ensure cache consistency and correctness. This avoids the issue where a failed initial check (e.g., due to missing authentication) permanently caches a False result for a gated model, and ensures that equivalent local paths (e.g., with or without trailing slashes) hit the same cache entry.

    # Normalize local paths to ensure cache hits for equivalent paths
    normalized_name = normalize_path(model_name) if is_local_path(model_name) else model_name
    cache_key = (normalized_name, hf_token)

    if cache_key in _vision_detection_cache:
        return _vision_detection_cache[cache_key]

    result = _is_vision_model_uncached(normalized_name, hf_token)
    _vision_detection_cache[cache_key] = result
    return result

Avoid caching fallback False after detection errors

is_vision_model now caches every returned value, but _is_vision_model_uncached collapses transient failures (HF API errors, subprocess timeout, etc.) to False; this means one temporary outage permanently classifies that model as non-vision for the rest of the process and can disable vision training/inference paths until restart. This regression is introduced by caching the first result unconditionally, so failures should not be cached the same way as successful detections.

Useful? React with 👍 / 👎.

Key vision cache by effective auth context

is_vision_model caches by (model_name, hf_token) only, but _is_vision_model_uncached uses load_model_config(..., use_auth=True, token=hf_token), so hf_token=None still depends on mutable default auth (e.g., HF_TOKEN/cached login). In flows that first probe without auth and later set auth in-process, token-less call sites (e.g., trainer/model routes that call is_vision_model(model_name) without passing hf_token) will keep hitting the stale (model_name, None) entry and can keep gated vision models classified as non-vision until restart.

Useful? React with 👍 / 👎.

Include default auth state in vision cache key

cache_key = (normalized, hf_token) treats every token-less call as the same context, but _is_vision_model_uncached uses load_model_config(..., use_auth=True, token=None), which depends on mutable default HF auth (HF_TOKEN/cached login). If an unauthenticated token-less probe caches False, later token-less calls after auth is set will keep returning that stale value and can disable vision paths for gated models. Fresh evidence: trainer.py sets os.environ["HF_TOKEN"] before calling is_vision_model(model_name) without passing hf_token (pre_detect_and_load_tokenizer, lines 176-193).

Useful? React with 👍 / 👎.

The normalization logic for the cache key is missing the 'unsloth/' prefix addition for shorthand HuggingFace model identifiers (e.g., 'llama-3' vs 'unsloth/llama-3'). This can lead to duplicate cache entries and redundant detection calls for the same model. Additionally, the broad exception handler has been updated to include a logging statement to avoid silent failures, as per repository rules.

In '_is_vision_model_uncached', all exceptions return 'None'. While safe for transient errors, it prevents caching deterministic failures (e.g., 'Model not found'). This causes every subsequent call for an invalid model name to trigger a new, failing HuggingFace API call. To improve efficiency, consider returning 'False' for clearly deterministic errors, matching the intent of the subprocess path.

Include ambient HF auth state in vision cache key

The new cache key only uses (resolved_model_name, token_fingerprint(hf_token)), so all token-less calls share the same entry even though detection with hf_token=None still depends on mutable ambient auth (HF_TOKEN/cached login). That means an early unauthenticated token-less probe can cache False and later token-less probes after auth changes will keep returning the stale value until process restart. Fresh evidence: there are still token-less call paths (routes/models.py check_vision_model and core/export/export.py load_checkpoint), so this regression remains observable despite the new token plumbing in other routes.

Useful? React with 👍 / 👎.

The exception handling logic for transient errors is complex and repetitive. Consider defining a helper function or a set of exception types to simplify the logic and improve readability.