Stable Diffusion: LoRA selection + per-workflow model/lora memory - LoRA dropdown for ComfyUI (new %lora% workflow placeholder; backend /api/sd/comfy/loras endpoint lists LoraLoader options; RunPod proxy URLs list catalog entries of kind 'lora' instead). - RunPod catalog entries are typed (model|lora); the active selection pushed to the proxy is now the model+lora set, and the pod provisions the union of their files (homelab: proxy v4). - Per-workflow memory: model + lora are remembered per comfy workflow (stored in comfy_workflow_prefs, part of preset snapshots -> each chain provider keeps its own map); switching workflows auto-restores them.

83a5205f51492f7446527d4a1a90bfc4c633b515

permissionBRICK <40219477+permissionBRICK@users.noreply.github.com>

Parents: 012e9fea1bfc457230dd4650ba1a3a0aed0e8107

homelab/runpod-lazy-proxy.py+45 -29 Viewed

     return None
-def active_value():
+def active_values():
-    return load_catalog().get('active')
+    active = load_catalog().get('active')
+    if isinstance(active, str):
+        active = [active]
+    return [a for a in (active or []) if a]
+def values_key(values):
+    return '+'.join(sorted(values)) if values else ''
 def api(method, path, body=None):

     return None, None, None
-def create_pod(value):
+def create_pod(values):
+    files = []
+    for value in values or []:
         entry = catalog_entry(value)
-    env = {'HF_TOKEN': HF_TOKEN, 'MODEL_KEY': value or ''}
+        if entry:
-    if entry and entry.get('files'):
+            files.extend(entry.get('files') or [])
-        env['MODEL_MANIFEST'] = json.dumps(entry['files'])
+    env = {'HF_TOKEN': HF_TOKEN, 'MODEL_KEY': values_key(values)}
+    if files:
+        env['MODEL_MANIFEST'] = json.dumps(files)
     else:
         env['MODELS'] = 'all'  # legacy fallback when no catalog is configured
     body = {

     if DATACENTERS:
         body['dataCenterIds'] = DATACENTERS
     pod = api('POST', '/pods', body)
-    log(f"pod created: {pod['id']} model={value or 'legacy-all'} {pod.get('machine', {}).get('gpuTypeId')} ${pod.get('costPerHr')}/hr")
+    log(f"pod created: {pod['id']} models={values_key(values) or 'legacy-all'} {pod.get('machine', {}).get('gpuTypeId')} ${pod.get('costPerHr')}/hr")
     return pod['id'], pod.get('machine', {}).get('gpuTypeId')

         log('terminate failed:', err)
-def ensure_pod(value=None, wait=True):
+def ensure_pod(values=None, wait=True):
-    """Ensures a pod provisioned for catalog entry `value` (None = active entry)."""
+    """Ensures a pod provisioned for catalog values (None = active selection)."""
-    value = value or active_value()
+    values = values or active_values()
+    key = values_key(values)
     with state['lock']:
         pod_id, have, gpu = (state['pod_id'], state['model'], state['gpu'])
         if not pod_id:
             pod_id, have, gpu = find_pod()
-        # Only recreate when the pod's model is KNOWN and different. An unknown
+        # Only recreate when the pod's model set is KNOWN and different. An
-        # model (e.g. env not reported yet) must not churn pods.
+        # unknown set (e.g. env not reported) must not churn pods.
-        if pod_id and value and have and have != value:
+        if pod_id and key and have and have != key:
-            log(f'pod has model={have}, need {value} - recreating')
+            log(f'pod has models={have}, need {key} - recreating')
             terminate(pod_id)
             pod_id, have, gpu = None, None, None
         if not pod_id:

             last_err = None
             for attempt in range(3):
                 try:
-                    pod_id, gpu = create_pod(value)
+                    pod_id, gpu = create_pod(values)
-                    have = value
+                    have = key
                     break
                 except urllib.error.HTTPError as err:
                     last_err = err.read().decode()[:200]

     raise RuntimeError('pod not ready within START_TIMEOUT')
-def match_workflow_model(workflow_bytes):
+def match_workflow_models(workflow_bytes):
-    """Returns the catalog value whose filename appears in the workflow, else None."""
+    """Returns all catalog values whose filenames appear in the workflow."""
     try:
         text = workflow_bytes.decode('utf-8', 'replace')
     except Exception:
-        return None
+        return []
+    found = []
     for entry in load_catalog().get('models', []):
         value = entry.get('value')
         if value and value in text:
-            return value
+            found.append(value)
-    return None
+    return found
 def idle_reaper():

         'state': state['phase'],
         'pod_id': state['pod_id'],
         'model': state['model'],
-        'active': active_value(),
+        'active': active_values(),
         'gpu': state['gpu'],
         'since': state['since'],
         'url': pod_url(state['pod_id']) if state['pod_id'] else None,

         if path == '/lazy/catalog':
             try:
                 payload = json.loads(body or b'{}')
-                catalog = {'models': payload.get('models', []), 'active': payload.get('active')}
+                active = payload.get('active')
+                if isinstance(active, str):
+                    active = [active]
+                catalog = {'models': payload.get('models', []), 'active': [a for a in (active or []) if a]}
                 save_catalog(catalog)
                 log(f"catalog updated: {len(catalog['models'])} models, active={catalog['active']}")
                 # Re-provision proactively when the active model changed under a live pod
                 # (known-model pods only - never churn a pod of unknown provenance).
-                if state['pod_id'] and catalog['active'] and state['model'] and state['model'] != catalog['active']:
+                if state['pod_id'] and catalog['active'] and state['model'] and state['model'] != values_key(catalog['active']):
-                    log('active model changed - re-provisioning pod')
+                    log('active model set changed - re-provisioning pod')
                     threading.Thread(target=self._safe_ensure, args=(catalog['active'],), daemon=True).start()
                 return self._reply(200, status_body())
             except Exception as err:

             except FileNotFoundError:
                 return self._reply(200, json.dumps({'system': {'comfyui_version': 'cold'}, 'devices': []}).encode())
         if not ready or (self.command == 'POST' and path == '/prompt'):
-            value = match_workflow_model(body) if (self.command == 'POST' and path == '/prompt' and body) else None
+            values = match_workflow_models(body) if (self.command == 'POST' and path == '/prompt' and body) else None
             try:
-                pod_id = ensure_pod(value)
+                pod_id = ensure_pod(values or None)
             except Exception as err:
                 log('ensure_pod failed:', err)
                 return self._reply(502, json.dumps({'error': str(err)}).encode())

         def _adopt():
             try:
-                ensure_pod(have)
+                ensure_pod(have.split('+') if have else None)
             except Exception as err:
                 log('adoption wait failed:', err)
         threading.Thread(target=_adopt, daemon=True).start()
     server = ThreadingHTTPServer(('0.0.0.0', LISTEN_PORT), Proxy)
-    log(f'runpod-lazy v3 (catalog) on :{LISTEN_PORT} (pod "{POD_NAME}", DCs {DATACENTERS or "any"}, idle {IDLE_SECONDS}s)')
+    log(f'runpod-lazy v4 (catalog+lora) on :{LISTEN_PORT} (pod "{POD_NAME}", DCs {DATACENTERS or "any"}, idle {IDLE_SECONDS}s)')
     server.serve_forever()

public/scripts/extensions/stable-diffusion/index.js+124 -12 Viewed

     // RunPod lazy-pod proxy base URL ('' = feature off)
     runpod_lazy_url: '',
-    // RunPod model catalog ({ name, value, downloads } entries)
+    // RunPod model catalog ({ name, value, kind: 'model'|'lora', downloads } entries)
     runpod_models: [],
+    // Selected LoRA for comfy workflows using the %lora% placeholder
+    lora: '',
+    // Per-workflow remembered selections ({ [workflow]: { model, lora } });
+    // part of preset snapshots, so each chain provider keeps its own map.
+    comfy_workflow_prefs: {},
     // Dedicated LLM connection profile for image-prompt generation ('' = use active model)
     prompt_generation_profile: '',

         extension_settings.sd.runpod_models = [];
+    }
+    if (extension_settings.sd.lora === undefined) {
+        extension_settings.sd.lora = '';
+    }
+    if (typeof extension_settings.sd.comfy_workflow_prefs !== 'object' || !extension_settings.sd.comfy_workflow_prefs) {
+        extension_settings.sd.comfy_workflow_prefs = {};
+    }
     if (!Array.isArray(extension_settings.sd.custom_entries)) {
         extension_settings.sd.custom_entries = [];
+    }

         loadModels(),
         loadSchedulers(),
         loadVaes(),
+        loadLoras(),
         loadComfyWorkflows(),
     ]);
+}
+async function loadLoras() {
+    $('#sd_lora').empty();
+    let loras = ['N/A'];
+    if (extension_settings.sd.source === sources.comfy && extension_settings.sd.comfy_type === comfyTypes.standard) {
+        loras = await loadComfyLoras();
+    }
+    for (const lora of loras) {
+        const option = document.createElement('option');
+        option.innerText = lora?.text ?? lora;
+        option.value = lora?.value ?? lora;
+        option.selected = option.value === extension_settings.sd.lora;
+        $('#sd_lora').append(option);
+    }
+}
+async function loadComfyLoras() {
+    if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
+        return getRunpodCatalog().filter(m => m.kind === 'lora').map(m => ({ value: m.value, text: m.name || m.value }));
+    }
+    if (!extension_settings.sd.comfy_url) {
+        return [];
+    }
+    try {
+        const result = await fetch('/api/sd/comfy/loras', {
+            method: 'POST',
+            headers: getRequestHeaders(),
+            body: JSON.stringify({ url: extension_settings.sd.comfy_url }),
+        });
+        if (!result.ok) {
+            throw new Error('ComfyUI returned an error.');
+        }
+        return await result.json();
+    } catch (error) {
+        return [];
+    }
+}
 function addPromptTemplates() {
     $('#sd_prompt_templates').empty();

     return models.filter(m => m && String(m.value ?? '').trim());
+}
+/** Catalog entries that go in the Model dropdown (kind !== 'lora'). */
+function getRunpodModelEntries() {
+    return getRunpodCatalog().filter(m => m.kind !== 'lora');
+}
 /**
  * Parses a catalog entry's download lines ("dest-subpath url" per line).
  * @param {string} text Multiline downloads definition.

+}
 /**
- * The model filename saved for whichever config uses the proxy: the live
+ * The model+lora filenames saved for whichever config uses the proxy: the live
  * settings if they point at it, else the chain entry that does.
- * @returns {string|null} Active catalog value.
+ * @returns {string[]} Active catalog values (model and/or lora).
  */
-function getRunpodActiveModel() {
+function getRunpodActiveModels() {
+    let config = null;
     if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
-        return extension_settings.sd.model || null;
+        config = extension_settings.sd;
-    }
+    } else {
         const chain = Array.isArray(extension_settings.sd.settings_preset_chain) ? extension_settings.sd.settings_preset_chain : [];
-    const entry = chain.find(e => isRunpodProxyUrl(e?.preset?.comfy_url));
+        config = chain.find(e => isRunpodProxyUrl(e?.preset?.comfy_url))?.preset ?? null;
-    return entry?.preset?.model ?? null;
+    }
+    if (!config) {
+        return [];
+    }
+    const known = new Set(getRunpodCatalog().map(m => m.value));
+    return [config.model, config.lora].filter(v => v && known.has(v));
+}
 /** Pushes the model catalog + active selection to the proxy (fire-and-forget). */

     const models = getRunpodCatalog().map(m => ({
         name: m.name || m.value,
         value: m.value,
+        kind: m.kind === 'lora' ? 'lora' : 'model',
         files: parseRunpodFiles(m.downloads),
     }));
     try {

             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             signal: AbortSignal.timeout(8000),
-            body: JSON.stringify({ models, active: getRunpodActiveModel() }),
+            body: JSON.stringify({ models, active: getRunpodActiveModels() }),
         });
     } catch (error) {
         console.warn('SD: runpod catalog push failed', error);

         const nameInput = $('<input>').addClass('text_pole flex1').attr({ type: 'text', placeholder: 'Display name' })
             .val(model.name || '')
             .on('change', function () { model.name = String($(this).val() ?? '').trim(); saveSettingsDebounced(); pushRunpodCatalog(); });
-        const valueInput = $('<input>').addClass('text_pole flex1').attr({ type: 'text', placeholder: 'Model filename (used by %model%)' })
+        const valueInput = $('<input>').addClass('text_pole flex1').attr({ type: 'text', placeholder: 'Filename (used by %model% / %lora%)' })
             .val(model.value || '')
             .on('change', function () { model.value = String($(this).val() ?? '').trim(); saveSettingsDebounced(); pushRunpodCatalog(); });
+        const kindSelect = $('<select></select>').addClass('text_pole')
+            .append($('<option></option>').val('model').text('model'))
+            .append($('<option></option>').val('lora').text('lora'))
+            .val(model.kind === 'lora' ? 'lora' : 'model')
+            .on('change', function () { model.kind = String($(this).val()); saveSettingsDebounced(); pushRunpodCatalog(); });
         const deleteButton = $('<div></div>').addClass('menu_button menu_button_icon fa-solid fa-trash-can')
             .attr('title', 'Remove model')
             .on('click', () => { models.splice(index, 1); saveSettingsDebounced(); renderRunpodModels(); pushRunpodCatalog(); });

             .on('change', function () { model.downloads = String($(this).val() ?? ''); saveSettingsDebounced(); pushRunpodCatalog(); });
         container.append(
             $('<div></div>').addClass('flexFlowColumn marginTopBot5')
-                .append($('<div></div>').addClass('flex-container alignItemsCenter').append(nameInput).append(valueInput).append(deleteButton))
+                .append($('<div></div>').addClass('flex-container alignItemsCenter').append(nameInput).append(valueInput).append(kindSelect).append(deleteButton))
                 .append(downloadsInput));
     });
+}

     saveSettingsDebounced();
+}
+/**
+ * Stores the current model/lora choice for the active comfy workflow, so
+ * switching back to this workflow restores it (per provider via presets).
+ * @param {'model'|'lora'} key Which selection to remember.
+ * @param {string} value Selected value.
+ */
+function rememberWorkflowPref(key, value) {
+    if (extension_settings.sd.source !== sources.comfy || !extension_settings.sd.comfy_workflow) {
+        return;
+    }
+    const prefs = extension_settings.sd.comfy_workflow_prefs;
+    prefs[extension_settings.sd.comfy_workflow] = { ...(prefs[extension_settings.sd.comfy_workflow] ?? {}), [key]: value };
+}
+async function onLoraChange() {
+    extension_settings.sd.lora = $('#sd_lora').find(':selected').val();
+    rememberWorkflowPref('lora', extension_settings.sd.lora);
+    saveSettingsDebounced();
+    if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
+        pushRunpodCatalog();
+    }
+}
 function onComfyWorkflowChange() {
     extension_settings.sd.comfy_workflow = $('#sd_comfy_workflow').find(':selected').val();
+    // Restore the model/lora remembered for this workflow (auto-configuration
+    // when switching between e.g. the flux and qwen workflow families).
+    const pref = extension_settings.sd.comfy_workflow_prefs?.[extension_settings.sd.comfy_workflow];
+    if (pref) {
+        if (pref.model) {
+            extension_settings.sd.model = pref.model;
+            $('#sd_model').val(pref.model);
+        }
+        if (pref.lora !== undefined) {
+            extension_settings.sd.lora = pref.lora;
+            $('#sd_lora').val(pref.lora);
+        }
+        if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
+            pushRunpodCatalog();
+        }
+    }
     saveSettingsDebounced();
+}

 async function onModelChange() {
     const selectedModel = $('#sd_model').find(':selected');
     extension_settings.sd.model = selectedModel.val();
+    rememberWorkflowPref('model', extension_settings.sd.model);
     saveSettingsDebounced();
     // Selecting a catalog model while pointed at the RunPod proxy kicks off the

     if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
         // The RunPod pod downloads models on demand: list the configured catalog
         // instead of asking the (possibly cold) backend what it has on disk.
-        return getRunpodCatalog().map(m => ({ value: m.value, text: m.name || m.value }));
+        return getRunpodModelEntries().map(m => ({ value: m.value, text: m.name || m.value }));
+    }
     if (extension_settings.sd.comfy_type === comfyTypes.runpod_serverless) {
         $('#sd_runpod_key').toggleClass('success', !!secret_state[SECRET_KEYS.COMFY_RUNPOD]);

     const placeholders = [
         'model',
         'vae',
+        'lora',
         'sampler',
         'scheduler',
         'steps',

     $('#sd_scale').on('input', onScaleInput);
     $('#sd_steps').on('input', onStepsInput);
     $('#sd_model').on('change', onModelChange);
+    $('#sd_lora').on('change', onLoraChange);
     $('#sd_vae').on('change', onVaeChange);
     $('#sd_sampler').on('change', onSamplerChange);
     $('#sd_resolution').on('change', onResolutionChange);

public/scripts/extensions/stable-diffusion/settings.html+5 -0 Viewed

                     <label for="sd_vae">VAE</label>
                     <select id="sd_vae" class="text_pole"></select>
                 </div>
+                <div class="flex1" data-sd-source="comfy">
+                    <label for="sd_lora" data-i18n="LoRA">LoRA</label>
+                    <select id="sd_lora" class="text_pole"></select>
+                </div>
             </div>
             <div class="flex-container">

src/endpoints/stable-diffusion.js+19 -0 Viewed

+    }
 });
+comfy.post('/loras', async (request, response) => {
+    try {
+        const url = new URL(urlJoin(request.body.url, '/object_info'));
+        const result = await fetch(url);
+        if (!result.ok) {
+            throw new Error('ComfyUI returned an error.');
+        }
+        /** @type {any} */
+        const data = await result.json();
+        const loras = data.LoraLoader?.input?.required?.lora_name?.[0] ?? [];
+        return response.send(loras);
+    } catch (error) {
+        console.error(error);
+        return response.sendStatus(500);
+    }
+});
 comfy.post('/workflows', async (request, response) => {
     try {
         const data = getComfyWorkflows(request.user.directories);