feat(links): support ModelScope and TensorArt as model sources

A model file could only ever be linked to huggingface.co: `set_hf_url`
validated the URL with a huggingface-only regex, the agent fetched the card
from a hardcoded HF URL, and the readme processor built every relative image
path off `https://huggingface.co/{repo}/resolve/main`. ModelScope publishes the
same model-card convention (README.md + YAML frontmatter, often carrying
`base_model:` and `trigger_words:`) behind a public, key-less API, so the
enrichment pipeline could already serve it - it was the plumbing that was
HF-shaped, not the idea.

Make the external source a first-class, provider-driven concept:

- New `py/services/model_sources/` registry. A `ModelSource` owns URL
  recognition (lenient for stored values, strict for user input), the
  canonical page URL, model-card fetching, the asset base URL and the
  capability flags. `HuggingFaceSource` is the previous logic relocated;
  `ModelScopeSource` reads `/models/{o}/{n}/resolve/{master|main}/README.md`
  and falls back to `/api/v1/models/{o}/{n}/repo`. `TensorArtSource` is
  link-only on purpose: tensor.art answers plain HTTP clients with a
  Cloudflare challenge and its internal API (ap-east-1.tensorart.cloud /
  cn.tensorart.net) rejects every /v1/model/* route with "invalid
  authorization header", so it declares supports_enrichment=False rather than
  failing silently later.
- Metadata gains `source_platform` + `source_url`; `hf_url` stays as a
  read/write alias, written only for Hugging Face, so existing sidecars,
  cached rows and third-party consumers keep working. Normalisation runs at
  the scanner, the persistent cache (both directions, plus two new columns
  behind an ALTER migration) and the linking handler - which is what stops a
  user who switches sources from leaving a stale `hf_url` on a ModelScope
  model.
- The agent pipeline keys off the provider instead of `hf_url`: the fast-fail
  gate now explains *why* a model is skipped (no source / unknown source /
  source without a reachable card), the prompt context exposes
  source_url/source_id/source_label/asset_base_url while still filling the
  legacy hf_url/repo aliases, and the four README image extractors take a
  base_url (defaulting to HF) so relative paths resolve against the right
  site. Version grouping generalises to hf: / ms: / ta: keys.
- `POST /api/lm/set-hf-url` keeps its path and its legacy payload keys but
  accepts `source_url`, validates against every provider and returns the
  platform. `GET /api/lm/model-sources` lets the UI render the supported-site
  list from the server.
- Frontend: a `modelSourceHelpers` mirror of the registry drives the link
  dialog, the card/modal globe (branded "View on ModelScope/TensorArt"), the
  version-group key and the enrichment gate; the versions tab no longer sends
  ms:/ta: keys to the CivitAI API.

TensorArt stays in the list because provenance is worth keeping even when the
card is unreadable - the dialog says so plainly ("Sites that don't expose one
(currently TensorArt) can only be linked") and the context menu disables
enrichment with a matching tooltip, instead of the user getting
"Unsupported URL".

Verified against the real ModelScope API: jj3550945163/Krea-2-LORA returns a
1882-byte card whose frontmatter carries base_model/tags/trigger_words, and
relative images resolve to .../resolve/master/....

Tests: backend 2815 passed; frontend 1130 JS + 91 Vue passed; pytest
tests/i18n and a Jinja compile pass over templates/. The nine locales carry
[TODO: Translate] for the new strings, completed in the next commit.

py/services/agent/agent_service.py

@@ -19,16 +19,18 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import os
 import re
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
-import aiohttp
-
-import os
-
 from ...config import config
 from ..llm_service import LLMService
+from ..model_sources import (
+    get_source,
+    resolve_source_ref,
+    source_label,
+)
 from ..websocket_manager import ws_manager
 from .post_processor import PostProcessor
 from .skill_registry import SkillRegistry
@@ -267,14 +269,17 @@ class AgentService:
                 from ...metadata_ops import read_metadata
                 metadata = await read_metadata(model_path)
 
-                # Fast-fail: enrich_hf_metadata requires hf_url to have HF README context
-                if skill_name == "enrich_hf_metadata" and not metadata.get("hf_url", ""):
-                    logger.info(
-                        "[%s] SKIP %s — no hf_url in metadata",
-                        skill_name, model_filename,
-                    )
-                    skipped_count += 1
-                    skip_model = True
+                # Fast-fail: enrich_hf_metadata needs an external model source
+                # that exposes an accessible model card.
+                if skill_name == "enrich_hf_metadata":
+                    skip_reason = self._enrichment_skip_reason(metadata)
+                    if skip_reason:
+                        logger.info(
+                            "[%s] SKIP %s — %s",
+                            skill_name, model_filename, skip_reason,
+                        )
+                        skipped_count += 1
+                        skip_model = True
 
                 if not skip_model:
                     prompt_vars: Dict[str, Any] = {"model_path": model_path}
@@ -358,6 +363,28 @@ class AgentService:
     # Base model grouping (keeps the prompt compact)
     # ------------------------------------------------------------------
 
+    @staticmethod
+    def _enrichment_skip_reason(metadata: Dict[str, Any]) -> str:
+        """Return why ``enrich_hf_metadata`` cannot run, or ``""`` if it can.
+
+        Distinguishes the three cases the user can act on: no source linked,
+        a source we don't know, and a known source whose model card is not
+        reachable from the backend (TensorArt).
+        """
+
+        ref = resolve_source_ref(metadata)
+        if ref is None:
+            return "no model source linked (source_url missing)"
+        source = get_source(ref.platform)
+        if source is None:
+            return f"unsupported model source platform '{ref.platform}'"
+        if not source.supports_enrichment:
+            return (
+                f"{source.label} does not expose a model card to the backend; "
+                "AI metadata enrichment is not available for this source"
+            )
+        return ""
+
     @staticmethod
     def _format_base_models(models: List[str]) -> str:
         """Format the base model list as a flat, one-per-line list.
@@ -388,6 +415,14 @@ class AgentService:
         context: Dict[str, Any] = {
             "model_path": model_path,
             "model_basename": "",
+            # Canonical external-source variables
+            "source_url": "",
+            "source_id": "",
+            "source_platform": "",
+            "source_label": "",
+            "asset_base_url": "",
+            # Legacy Hugging Face aliases (kept so older prompt templates and
+            # third-party skills keep rendering)
             "hf_url": "",
             "repo": "",
             "readme_content": "",
@@ -411,12 +446,20 @@ class AgentService:
             "size": metadata.get("size", 0),
         }
 
-        hf_url = metadata.get("hf_url", "")
-        context["hf_url"] = hf_url
-        repo = self._extract_repo_from_url(hf_url) if hf_url else ""
-        context["repo"] = repo or ""
-        if repo:
-            readme = await self._fetch_readme(repo)
+        ref = resolve_source_ref(metadata)
+        if ref is not None:
+            context["source_url"] = ref.url
+            context["source_id"] = ref.source_id
+            context["source_platform"] = ref.platform
+            context["source_label"] = source_label(ref.platform, ref.platform)
+            if ref.platform == "huggingface":
+                context["hf_url"] = ref.url
+            context["repo"] = ref.source_id
+
+        source = get_source(ref.platform) if ref is not None else None
+        if ref is not None and source is not None and source.supports_enrichment:
+            context["asset_base_url"] = source.asset_base_url(ref.source_id)
+            readme = await source.fetch_model_card(ref.source_id)
             # Trim README to the section relevant to this model file
             # (collection repos often have multiple models in one README).
             if readme and raw_basename:
@@ -458,20 +501,14 @@ class AgentService:
 
     @staticmethod
     async def _fetch_readme(repo: str) -> str:
-        """Fetch README.md from HuggingFace (tries ``main``, then ``master``)."""
-        async with aiohttp.ClientSession(
-            headers={"User-Agent": "ComfyUI-LoRA-Manager/1.0"},
-            timeout=aiohttp.ClientTimeout(total=30),
-        ) as session:
-            for branch in ("main", "master"):
-                url = f"https://huggingface.co/{repo}/raw/{branch}/README.md"
-                try:
-                    async with session.get(url) as resp:
-                        if resp.status == 200:
-                            return await resp.text()
-                except Exception as exc:
-                    logger.debug("Failed to fetch README from %s: %s", url, exc)
-        return ""
+        """Fetch a Hugging Face README (tries ``main``, then ``master``).
+
+        Kept for backward compatibility; new code should go through the
+        model-source registry so every supported site works.
+        """
+        from ..model_sources import HuggingFaceSource
+
+        return await HuggingFaceSource().fetch_model_card(repo)
 
     async def _emit_progress(
         self,