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.

static/js/components/ContextMenu/ModelContextMenuMixin.js

@@ -7,6 +7,8 @@ import { MODEL_CONFIG } from '../../api/apiConfig.js';
 import { translate } from '../../utils/i18nHelpers.js';
 import { getNsfwLevelSelector } from '../shared/NsfwLevelSelector.js';
 import { classifyModelRelinkUrl } from '../../utils/civitaiUtils.js';
+import { parseModelSourceUrl, getModelSourceInfo } from '../../utils/modelSourceHelpers.js';
+import { escapeHtml } from '../shared/utils.js';
 
 // Mixin with shared functionality for LoraContextMenu and CheckpointContextMenu
 export const ModelContextMenuMixin = {
@@ -211,7 +213,7 @@ export const ModelContextMenuMixin = {
         setTimeout(() => urlInput.focus(), 50);
     },
 
-    // HuggingFace linking methods
+    // External model source linking (Hugging Face / ModelScope / TensorArt)
     showLinkHfModal() {
         const filePath = this.currentCard.dataset.filepath;
         if (!filePath) return;
@@ -225,15 +227,23 @@ export const ModelContextMenuMixin = {
         }
 
         this._boundLinkHfHandler = async () => {
-            const hfUrl = urlInput.value.trim();
-            if (!hfUrl) {
-                errorDiv.textContent = 'Please enter a HuggingFace repository URL.';
+            const rawUrl = urlInput.value.trim();
+            if (!rawUrl) {
+                errorDiv.textContent = translate(
+                    'modals.linkModelSource.urlRequired',
+                    {},
+                    'Please enter a model page URL.'
+                );
                 return;
             }
 
-            const hfPattern = /^https?:\/\/huggingface\.co\/([^/]+\/[^/]+)\/?$/;
-            if (!hfPattern.test(hfUrl)) {
-                errorDiv.textContent = 'Invalid URL format. Expected: https://huggingface.co/user/repo';
+            const sourceInfo = parseModelSourceUrl(rawUrl);
+            if (!sourceInfo) {
+                errorDiv.textContent = translate(
+                    'modals.linkModelSource.invalidUrl',
+                    {},
+                    'Unsupported URL. Supported sites: Hugging Face, ModelScope, TensorArt.'
+                );
                 return;
             }
 
@@ -241,12 +251,14 @@ export const ModelContextMenuMixin = {
             modalManager.closeModal('linkHfModal');
 
             try {
-                state.loadingManager.showSimpleLoading('Linking to HuggingFace...');
+                state.loadingManager.showSimpleLoading(
+                    translate('modals.linkModelSource.linking', {}, 'Linking model source...')
+                );
 
                 const response = await fetch('/api/lm/set-hf-url', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ file_path: filePath, hf_url: hfUrl }),
+                    body: JSON.stringify({ file_path: filePath, source_url: sourceInfo.url }),
                 });
 
                 if (!response.ok) {
@@ -262,7 +274,7 @@ export const ModelContextMenuMixin = {
                     throw new Error(data.error || 'Failed to link model');
                 }
             } catch (error) {
-                console.error('Error linking model to HuggingFace:', error);
+                console.error('Error linking model source:', error);
                 showToast('toast.contextMenu.linkHfFailed', { message: error.message }, 'error');
             } finally {
                 state.loadingManager.hide();
@@ -276,18 +288,68 @@ export const ModelContextMenuMixin = {
 
         modalManager.showModal('linkHfModal');
 
+        this._renderSupportedSources();
+
         setTimeout(() => urlInput.focus(), 50);
     },
 
-    // HF metadata enrichment (AI agent) methods
+    /**
+     * Refresh the supported-site hints from the server so the dialog reflects
+     * whatever sources this backend build actually knows about. Falls back to
+     * the static markup in the template when the request fails.
+     */
+    async _renderSupportedSources() {
+        const container = document.getElementById('hfSupportedSources');
+        if (!container) return;
+
+        try {
+            const response = await fetch('/api/lm/model-sources');
+            if (!response.ok) return;
+            const sources = await response.json();
+            if (!Array.isArray(sources) || sources.length === 0) return;
+
+            const examples = sources
+                .map((source) => source?.example_url)
+                .filter((url) => typeof url === 'string' && url);
+            if (examples.length === 0) return;
+
+            container.innerHTML = examples
+                .map((url) => `<strong>${escapeHtml(url)}</strong>`)
+                .join('<br>');
+        } catch (error) {
+            console.debug('Failed to load supported model sources:', error);
+        }
+    },
+
+    // Model metadata enrichment (AI agent) methods
     updateEnrichMenuItem(card) {
         const enrichItem = this.menu?.querySelector('[data-action="enrich-hf-llm"]');
         if (!enrichItem) return;
-        const hasHfUrl = !!card.dataset.hf_url;
-        enrichItem.classList.toggle('disabled', !hasHfUrl);
-        enrichItem.title = hasHfUrl
-            ? ''
-            : 'Link this model to a HuggingFace repo first (Link Model → Link to HuggingFace)';
+
+        const model = {
+            source_url: card.dataset.source_url || '',
+            source_platform: card.dataset.source_platform || '',
+            hf_url: card.dataset.hf_url || '',
+        };
+        const sourceInfo = getModelSourceInfo(model);
+        const canEnrich = Boolean(sourceInfo && sourceInfo.supportsEnrichment);
+
+        enrichItem.classList.toggle('disabled', !canEnrich);
+        if (canEnrich) {
+            enrichItem.title = '';
+        } else if (!sourceInfo) {
+            enrichItem.title = translate(
+                'toast.contextMenu.enrichNeedsSource',
+                {},
+                'Link this model to a model source first (Link Model → Link to Model Source)'
+            );
+        } else {
+            enrichItem.title = translate(
+                'toast.contextMenu.enrichUnsupportedSource',
+                { source: sourceInfo.label },
+                `AI enrichment is not available for ${sourceInfo.label} models`
+            );
+        }
     },
 
     async enrichWithAgent(filePath) {

static/js/components/shared/ModelCard.js

@@ -1,4 +1,5 @@
 import { showToast, openCivitai, openHuggingFace, copyToClipboard, copyLoraSyntax, sendLoraToWorkflow, sendEmbeddingToWorkflow, openExampleImagesFolder, buildLoraSyntax, sendModelPathToWorkflow } from '../../utils/uiHelpers.js';
+import { getModelSourceInfo, getModelSourceGroupKey, getModelSourceViewTitle, openModelSource } from '../../utils/modelSourceHelpers.js';
 import { state, getCurrentPageState } from '../../state/index.js';
 import { showModelModal } from './ModelModal.js';
 import { hasCivitaiSource } from './utils.js';
@@ -65,12 +66,15 @@ function handleModelCardEvent_internal(event, modelType) {
     if (event.target.closest('.fa-globe')) {
         event.stopPropagation();
         // CivitAI wins when the model actually has CivitAI data; otherwise fall
-        // back to HuggingFace. Relying on `from_civitai` here made the two
-        // sources mutually exclusive whenever one of them was (re)linked (#1094).
+        // back to the linked external source. Relying on `from_civitai` here
+        // made the two sources mutually exclusive whenever one of them was
+        // (re)linked (#1094).
         if (card.dataset.has_civitai === 'true') {
             openCivitai(card.dataset.filepath);
-        } else if (card.dataset.hf_url) {
+        } else if (card.dataset.source_platform === 'huggingface' && card.dataset.hf_url) {
             openHuggingFace(card.dataset.hf_url);
+        } else if (card.dataset.source_url) {
+            openModelSource(card.dataset.source_url);
         }
         return true; // Stop propagation
     }
@@ -337,6 +341,8 @@ async function showModelModalFromCard(card, modelType) {
         modified: card.dataset.modified,
         file_size: parseInt(card.dataset.file_size || '0'),
         from_civitai: card.dataset.from_civitai === 'true',
+        source_platform: card.dataset.source_platform || '',
+        source_url: card.dataset.source_url || '',
         hf_url: card.dataset.hf_url || '',
         base_model: card.dataset.base_model,
         notes: card.dataset.notes || '',
@@ -428,6 +434,8 @@ function showExampleAccessModal(card, modelType) {
                 modified: card.dataset.modified,
                 file_size: card.dataset.file_size,
                 from_civitai: card.dataset.from_civitai === 'true',
+                source_platform: card.dataset.source_platform || '',
+                source_url: card.dataset.source_url || '',
                 hf_url: card.dataset.hf_url || '',
                 base_model: card.dataset.base_model,
                 notes: card.dataset.notes,
@@ -490,7 +498,11 @@ export function createModelCard(model, modelType) {
     card.dataset.base_model = model.base_model || 'Unknown';
     card.dataset.favorite = model.favorite ? 'true' : 'false';
     card.dataset.exclude = model.exclude ? 'true' : 'false';
-    card.dataset.hf_url = model.hf_url || '';
+    const modelSourceInfo = getModelSourceInfo(model);
+    card.dataset.source_url = modelSourceInfo?.url || '';
+    card.dataset.source_platform = modelSourceInfo?.platform || '';
+    // Legacy alias: only Hugging Face models expose `hf_url`.
+    card.dataset.hf_url = modelSourceInfo?.platform === 'huggingface' ? modelSourceInfo.url : '';
     const hasUpdateAvailable = Boolean(model.update_available);
     card.dataset.update_available = hasUpdateAvailable ? 'true' : 'false';
     card.dataset.skip_metadata_refresh = model.skip_metadata_refresh ? 'true' : 'false';
@@ -508,11 +520,12 @@ export function createModelCard(model, modelType) {
     const modelId = civitaiData?.modelId ?? civitaiData?.model_id;
     if (modelId !== undefined && modelId !== null && modelId !== '') {
         card.dataset.modelId = modelId;
-    } else if (model.hf_url) {
-        // For HF-only models, derive a group key from hf_url for version grouping
-        const match = model.hf_url.match(/https?:\/\/huggingface\.co\/([^/]+\/[^/]+)/);
-        if (match) {
-            card.dataset.modelId = 'hf:' + match[1];
+    } else {
+        // For externally-sourced models, derive a group key from the source
+        // URL for version grouping (hf:user/repo, ms:user/repo, ta:<id>).
+        const sourceGroupKey = getModelSourceGroupKey(model);
+        if (sourceGroupKey) {
+            card.dataset.modelId = sourceGroupKey;
         }
     }
 
@@ -610,10 +623,10 @@ export function createModelCard(model, modelType) {
     const hasCivitai = hasCivitaiSource(model.civitai);
     const globeTitle = hasCivitai ?
         translate('modelCard.actions.viewOnCivitai', {}, 'View on Civitai') :
-        model.hf_url ?
-            translate('modelCard.actions.viewOnHuggingFace', {}, 'View on Hugging Face') :
+        modelSourceInfo ?
+            getModelSourceViewTitle(modelSourceInfo) :
             translate('modelCard.actions.notAvailableFromCivitai', {}, 'Not available from Civitai');
-    const globeEnabled = hasCivitai || !!model.hf_url;
+    const globeEnabled = hasCivitai || !!modelSourceInfo;
     let sendTitle;
     let copyTitle;
     if (modelType === MODEL_TYPES.LORA) {

static/js/components/shared/ModelModal.js

@@ -1,4 +1,5 @@
 import { showToast, openCivitai, sendLoraToWorkflow, sendEmbeddingToWorkflow, sendModelPathToWorkflow, buildLoraSyntax, copyToClipboard } from '../../utils/uiHelpers.js';
+import { getModelSourceInfo, getModelSourceGroupKey, getModelSourceViewTitle, openModelSource } from '../../utils/modelSourceHelpers.js';
 import { modalManager } from '../../managers/ModalManager.js';
 import { MODEL_TYPES } from '../../api/apiConfig.js';
 import {
@@ -397,10 +398,13 @@ export async function showModelModal(model, modelType) {
 <div class="civitai-view" title="${translate('modals.model.actions.viewOnCivitai', {}, 'View on Civitai')}" data-action="view-civitai" data-filepath="${escapedFilePathAttr}">
     <i class="fas fa-globe"></i> ${translate('modals.model.actions.viewOnCivitaiText', {}, 'View on Civitai')}
 </div>`.trim() : '';
-    const escapedHfUrl = modelWithFullData.hf_url ? escapeAttribute(modelWithFullData.hf_url) : '';
-    const viewOnHuggingFaceAction = escapedHfUrl ? `
-<div class="civitai-view" title="${translate('modals.model.actions.viewOnHuggingFace', {}, 'View on Hugging Face')}" data-action="view-huggingface" data-hf-url="${escapedHfUrl}">
-    <i class="fas fa-globe"></i> ${translate('modals.model.actions.viewOnHuggingFaceText', {}, 'View on Hugging Face')}
+    const sourceInfo = getModelSourceInfo(modelWithFullData);
+    const escapedSourceUrl = sourceInfo?.url ? escapeAttribute(sourceInfo.url) : '';
+    const isHuggingFaceSource = sourceInfo?.platform === 'huggingface';
+    const sourceTitle = sourceInfo ? getModelSourceViewTitle(sourceInfo) : '';
+    const viewOnHuggingFaceAction = escapedSourceUrl ? `
+<div class="civitai-view" title="${escapeAttribute(sourceTitle)}" data-action="${isHuggingFaceSource ? 'view-huggingface' : 'view-model-source'}" ${isHuggingFaceSource ? 'data-hf-url' : 'data-source-url'}="${escapedSourceUrl}">
+    <i class="fas fa-globe"></i> ${escapeHtml(sourceTitle)}
 </div>`.trim() : '';
     const creatorInfoAction = modelWithFullData.civitai?.creator ? `
 <div class="creator-info" data-username="${modelWithFullData.civitai.creator.username}" data-action="view-creator" title="${translate('modals.model.actions.viewCreatorProfile', {}, 'View Creator Profile')}">
@@ -520,12 +524,12 @@ export async function showModelModal(model, modelType) {
     const loadingExamplesText = translate('modals.model.loading.examples', {}, 'Loading examples...');
 
     const loadingVersionsText = translate('modals.model.loading.versions', {}, 'Loading versions...');
-    // Use CivitAI modelId, or derive HF group key for HF-only models
+    // Use CivitAI modelId, or derive a source group key for externally-linked models
     let civitaiModelId = modelWithFullData.civitai?.modelId || '';
-    if (!civitaiModelId && modelWithFullData.hf_url) {
-        const match = modelWithFullData.hf_url.match(/https?:\/\/huggingface\.co\/([^/]+\/[^/]+)/);
-        if (match) {
-            civitaiModelId = 'hf:' + match[1];
+    if (!civitaiModelId) {
+        const sourceGroupKey = getModelSourceGroupKey(modelWithFullData);
+        if (sourceGroupKey) {
+            civitaiModelId = sourceGroupKey;
         }
     }
     const civitaiVersionId = modelWithFullData.civitai?.id || '';
@@ -939,6 +943,11 @@ function setupEventHandlers(filePath, modelType) {
                     window.open(target.dataset.hfUrl, '_blank', 'noopener,noreferrer');
                 }
                 break;
+            case 'view-model-source':
+                if (target.dataset.sourceUrl) {
+                    openModelSource(target.dataset.sourceUrl);
+                }
+                break;
             case 'view-creator':
                 const username = target.dataset.username;
                 if (username) {

static/js/components/shared/ModelVersionsTab.js

@@ -5,6 +5,7 @@ import { openCivitaiUrl, showToast } from '../../utils/uiHelpers.js';
 import { translate } from '../../utils/i18nHelpers.js';
 import { state } from '../../state/index.js';
 import { buildCivitaiModelUrl } from '../../utils/civitaiUtils.js';
+import { parseModelSourceGroupKey } from '../../utils/modelSourceHelpers.js';
 import { formatFileSize } from './utils.js';
 import { setSessionItem, removeSessionItem } from '../../utils/storageHelpers.js';
 
@@ -993,22 +994,23 @@ export function initVersionsTab({
             renderErrorState(container, translate('modals.model.versions.missingModelId', {}, 'This model is missing a Civitai model id.'));
             return;
         }
-        // HF group keys (e.g. "hf:user/repo") are not real CivitAI model IDs —
-        // skip the remote API call and show a helpful message instead.
-        const isHfGroupKey = typeof modelId === 'string' && modelId.startsWith('hf:');
-        if (isHfGroupKey) {
+        // External source group keys (e.g. "hf:user/repo", "ms:user/repo",
+        // "ta:8278...") are not real CivitAI model IDs — skip the remote API
+        // call and show a helpful message instead.
+        const sourceGroup = parseModelSourceGroupKey(modelId);
+        if (sourceGroup) {
             controller.isLoading = false;
             controller.hasLoaded = true;
             controller.record = null;
-            const hfMsg = translate(
-                'modals.model.versions.hfGroupInfo',
-                {},
-                'This is a HuggingFace model group. Open the library to see all versions in the grid.'
+            const sourceMsg = translate(
+                'modals.model.versions.sourceGroupInfo',
+                { source: sourceGroup.label },
+                `This is a ${sourceGroup.label} model group. Open the library to see all versions in the grid.`
             );
             container.innerHTML = `
                 <div class="versions-empty-state">
                     <i class="fas fa-info-circle"></i>
-                    <p>${escapeHtml(hfMsg)}</p>
+                    <p>${escapeHtml(sourceMsg)}</p>
                 </div>
             `;
             return;

static/js/utils/modelSourceHelpers.js

@@ -0,0 +1,173 @@
+/**
+ * External model source helpers (Hugging Face / ModelScope / TensorArt).
+ *
+ * Mirrors `py/services/model_sources/registry.py` so the frontend and the
+ * backend agree on URL recognition, version-group keys, and which sites
+ * support AI metadata enrichment.
+ *
+ * Models loaded from an older cache may only carry the legacy `hf_url`
+ * field; every helper here falls back to it, and to the legacy
+ * `hf:user/repo` group key shape.
+ */
+
+import { translate } from './i18nHelpers.js';
+
+export const MODEL_SOURCES = [
+  {
+    platform: 'huggingface',
+    label: 'Hugging Face',
+    groupPrefix: 'hf',
+    supportsEnrichment: true,
+    supportsDownload: true,
+    exampleUrl: 'https://huggingface.co/user/repo',
+    placeholder: 'https://huggingface.co/user/repo',
+    pattern: /^https?:\/\/(?:www\.)?huggingface\.co\/([^/?#\s]+\/[^/?#\s]+)/i,
+    canonical: (id) => `https://huggingface.co/${id}`,
+  },
+  {
+    platform: 'modelscope',
+    label: 'ModelScope',
+    groupPrefix: 'ms',
+    supportsEnrichment: true,
+    supportsDownload: false,
+    exampleUrl: 'https://modelscope.cn/models/user/repo',
+    placeholder: 'https://modelscope.cn/models/user/repo',
+    pattern: /^https?:\/\/(?:www\.)?modelscope\.(?:cn|com)\/models\/([^/?#\s]+\/[^/?#\s]+)/i,
+    canonical: (id) => `https://modelscope.cn/models/${id}`,
+  },
+  {
+    platform: 'tensorart',
+    label: 'TensorArt',
+    groupPrefix: 'ta',
+    supportsEnrichment: false,
+    supportsDownload: false,
+    exampleUrl: 'https://tensor.art/models/827823520299086029',
+    placeholder: 'https://tensor.art/models/827823520299086029',
+    pattern: /^https?:\/\/(?:www\.)?(?:tensor\.art|tusi\.cn)\/models\/(\d+)/i,
+    canonical: (id) => `https://tensor.art/models/${id}`,
+  },
+];
+
+/** Return the source descriptor for a platform id, or null. */
+export function getModelSource(platform) {
+  if (!platform || typeof platform !== 'string') return null;
+  const needle = platform.trim().toLowerCase();
+  return MODEL_SOURCES.find((source) => source.platform === needle) || null;
+}
+
+/**
+ * Parse any supported model URL.
+ * @returns {{platform: string, label: string, groupPrefix: string,
+ *   supportsEnrichment: boolean, supportsDownload: boolean,
+ *   sourceId: string, url: string}|null}
+ */
+export function parseModelSourceUrl(url) {
+  if (!url || typeof url !== 'string') return null;
+  const candidate = url.trim();
+  if (!candidate) return null;
+  for (const source of MODEL_SOURCES) {
+    const match = candidate.match(source.pattern);
+    if (match) {
+      return {
+        ...source,
+        sourceId: match[1],
+        url: source.canonical(match[1]),
+      };
+    }
+  }
+  return null;
+}
+
+/** Return the stored source URL of a model (new field, then legacy). */
+export function getModelSourceUrl(model) {
+  if (!model) return '';
+  const value = model.source_url || model.hf_url || '';
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+/** Return the stored source platform of a model. */
+export function getModelSourcePlatform(model) {
+  if (!model) return '';
+  const value = model.source_platform || '';
+  return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
+/**
+ * Resolve the full source descriptor for a model, tolerating models that
+ * predate the `source_*` fields.
+ */
+export function getModelSourceInfo(model) {
+  if (!model) return null;
+  const url = getModelSourceUrl(model);
+  const declared = getModelSource(getModelSourcePlatform(model));
+  const parsed = parseModelSourceUrl(url);
+
+  if (declared) {
+    return {
+      ...declared,
+      sourceId: parsed ? parsed.sourceId : '',
+      url: parsed ? parsed.url : url,
+    };
+  }
+  return parsed;
+}
+
+/**
+ * Version-group key for a model, matching the backend's `_extract_group_key`.
+ * Returns `''` when the model has no external source.
+ */
+export function getModelSourceGroupKey(model) {
+  const info = getModelSourceInfo(model);
+  if (!info || !info.sourceId) return '';
+  return `${info.groupPrefix}:${info.sourceId}`;
+}
+
+/** Whether AI metadata enrichment can run for this model's source. */
+export function canEnrichModelSource(model) {
+  const info = getModelSourceInfo(model);
+  return Boolean(info && info.supportsEnrichment);
+}
+
+/**
+ * Parse a version-group key such as `hf:user/repo`, `ms:user/repo`, or
+ * `ta:827823520299086029` back into its source descriptor.
+ *
+ * These keys are NOT CivitAI model ids, so callers must not send them to the
+ * CivitAI API.
+ *
+ * @returns {{platform: string, label: string, sourceId: string}|null}
+ */
+export function parseModelSourceGroupKey(groupKey) {
+  if (!groupKey || typeof groupKey !== 'string') return null;
+  const separator = groupKey.indexOf(':');
+  if (separator <= 0) return null;
+
+  const prefix = groupKey.slice(0, separator);
+  const source = MODEL_SOURCES.find((candidate) => candidate.groupPrefix === prefix);
+  if (!source) return null;
+
+  return {
+    platform: source.platform,
+    label: source.label,
+    sourceId: groupKey.slice(separator + 1),
+  };
+}
+
+/** Localised "View on X" title for the source globe icon. */
+export function getModelSourceViewTitle(info) {
+  if (!info) return '';
+  if (info.platform === 'huggingface') {
+    return translate('modelCard.actions.viewOnHuggingFace', {}, 'View on Hugging Face');
+  }
+  return translate(
+    'modelCard.actions.viewOnSource',
+    { source: info.label },
+    `View on ${info.label}`
+  );
+}
+
+/** Open a model page on its external site in a new tab. */
+export function openModelSource(url) {
+  if (!url) return;
+  window.open(url, '_blank', 'noopener,noreferrer');
+}