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+46 -30 Viewed

     return None
 def active_valueactive_values():
     returnactive = 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(valuevalues):
     entryfiles = catalog_entry(value)[]
 -    env = {'HF_TOKEN': HF_TOKEN, 'MODEL_KEY': value or ''}
 +    for value in values or []:
 -    if entry and entry.get('files'):
 +        entry = catalog_entry(value)
 -        env['MODEL_MANIFEST'] = json.dumps(entry['files'])
 +        if entry:
 +            files.extend(entry.get('files') or [])
 +    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']} modelmodels={valuevalues_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(valuevalues=None, wait=True):
     """Ensures a pod provisioned for catalog entry `value`values (None = active entryselection)."""
     valuevalues = valuevalues or active_valueactive_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 set is KNOWN and different. An unknown
         # modelunknown set (e.g. env not reported yet) must not churn pods.
         if pod_id and valuekey and have and have != valuekey:
             log(f'pod has modelmodels={have}, need {valuekey} - 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(valuevalues)
                     have = valuekey
                     break
                 except urllib.error.HTTPError as err:
                     last_err = err.read().decode()[:200]

     raise RuntimeError('pod not ready within START_TIMEOUT')
 def match_workflow_modelmatch_workflow_models(workflow_bytes):
     """Returns theall catalog valuevalues whose filenamefilenames appearsappear in the workflow, else None."""
     try:
         text = workflow_bytes.decode('utf-8', 'replace')
     except Exception:
         return None[]
 +    found = []
     for entry in load_catalog().get('models', []):
         value = entry.get('value')
         if value and value in text:
 -            return value
 +            found.append(value)
     return Nonefound
 def idle_reaper():

         'state': state['phase'],
         'pod_id': state['pod_id'],
         'model': state['model'],
         'active': active_valueactive_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'] != values_key(catalog['active']):
                     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'):
             valuevalues = match_workflow_modelmatch_workflow_models(body) if (self.command == 'POST' and path == '/prompt' and body) else None
             try:
                 pod_id = ensure_pod(valuevalues 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 v3v4 (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, 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+lora filenamefilenames 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 valuevalues (model and/or lora).
  */
 function getRunpodActiveModelgetRunpodActiveModels() {
 +    let config = null;
     if (isRunpodProxyUrl(extension_settings.sd.comfy_url)) {
         returnconfig = extension_settings.sd.model || null;
 +    } else {
 +        const chain = Array.isArray(extension_settings.sd.settings_preset_chain) ? extension_settings.sd.settings_preset_chain : [];
 +        config = chain.find(e => isRunpodProxyUrl(e?.preset?.comfy_url))?.preset ?? null;
+    }
 -    const chain = Array.isArray(extension_settings.sd.settings_preset_chain) ? extension_settings.sd.settings_preset_chain : [];
 +    if (!config) {
 -    const entry = chain.find(e => isRunpodProxyUrl(e?.preset?.comfy_url));
 +        return [];
 -    return entry?.preset?.model ?? null;
 +    }
 +    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: getRunpodActiveModelgetRunpodActiveModels() }),
         });
     } 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 filenameFilename (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(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 getRunpodCataloggetRunpodModelEntries().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);